stmr_dl.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2010 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include <assert.h>
#include <string.h>

#include "stb_os.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "glue_queue.h"

#include "http_interface.h"
#include "stmr_dl.h"
#include "stmr_common.h"
#include "http_header.h"
#include "stmr_header.h"
#include "stmr_queue.h"
#include "mh5streamer.h"


/*---constant definitions for this file--------------------------------------*/

#ifdef ICS_THROTTLE
#define THROTTLE_BYTES (3 * 1024 * 1024 - 262144)
#endif

#define INVALID_TIMESTAMP 0xffffffff
#define SYNC_BYTE 0x47
#define SYNC_COUNT_ACCEPT        20
#define SYNC_BUFFER_SIZE         (STMR_TS_PACKET_SIZE * SYNC_COUNT_ACCEPT)
#define SYNC_COUNT_MIN_ACCEPT    (SYNC_COUNT_ACCEPT / 2)

#define USE_MAGIC

#ifdef USE_MAGIC
#define GOOD_MAGIC 0xdeadbeef
#define BAD_MAGIC 0xfefefefe
#define SET_MAGIC(r) do { r->magic = GOOD_MAGIC; } while (0)
#define VERIFY_MAGIC(r) assert(r->magic == GOOD_MAGIC)
#define CLEAR_MAGIC(r) do { r->magic = BAD_MAGIC; } while (0)
#else
#define SET_MAGIC(r)
#define VERIFY_MAGIC(r)
#define CLEAR_MAGIC(r)
#endif

#define DBG(x)
#define PDBG(x) TRACE(TICS, x)


/*---local typedef structs for this file-------------------------------------*/

enum SyncState
{
   SYNC_ACCUM,
   SYNC_FOUND,
   SYNC_FAILED
};

enum PsiState
{
   PSI_STATE_PAT,
   PSI_STATE_PMT,
   PSI_STATE_PCR
};

typedef struct sPsiInfo
{
   enum PsiState state;
   U8BIT section[STMR_MAX_PSI_SECTION];
   U16BIT offset;
   U16BIT pmt_pid;
   U16BIT pcr_pid;
   U32BIT prevTimestamp;
   U32BIT firstTimestamp;
   U32BIT lastTimestamp;
   U64BIT firstPosition;
   U64BIT lastPosition;
} PsiInfo;

typedef struct sDownloadRequest
{
   /* Magic */
   U32BIT magic;

   /* Download ID */
   U32BIT downloadId;

   /* Request ID */
   U32BIT requestId;

   /* HTTP or HTTPS */
   BOOLEAN https;

   /* HTTP handle */
   HttpRequest_t handle;

   /* Response code and status */
   S32BIT code;
   E_HttpStatus status;

   /* Request information */
   U64BIT rangeFrom;
   U64BIT rangeTo;

   /* Last request */
   BOOLEAN lastRequest;

   /* Download */
   U64BIT contentLength;
   U64BIT bytesReceived;
   U64BIT bytesExpected;

   BOOLEAN processing;
   BOOLEAN stopped;

   MHEG5String keyLocation;
   S_ICSKeys keys;

   enum SyncState syncState;
   U8BIT syncBuffer[SYNC_BUFFER_SIZE];
   U16BIT syncBufferPos;

   U32BIT bytesPerSecond;
   BOOLEAN knownBitrate;
   U32BIT timestamp;

    #ifdef ICS_THROTTLE
   BOOLEAN throttled;
   U64BIT throttledBytes;
   U32BIT targetBitrate;
    #endif

   /* Partial data to allow buffering of complete packets */
   U8BIT partialData[STMR_TS_PACKET_SIZE];
   U16BIT partialDataLength;

   /* PSI information */
   PsiInfo psiInfo;

   /* Next request */
   struct sDownloadRequest *next;
} DownloadRequest;

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/

static DownloadRequest* FindRequestById(U32BIT downloadId);
static BOOLEAN HeaderCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response);
static void HandleHeaderData(DownloadRequest *request, U8BIT *data,
   U32BIT len);
static BOOLEAN ContentCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response);
static BOOLEAN HandleStreamData(DownloadRequest *request, U8BIT *data,
   U32BIT len);
static BOOLEAN HandleData(DownloadRequest *request, U8BIT *data, U32BIT len);
static BOOLEAN StoreItem(DownloadRequest *request, U8BIT *data, U32BIT len,
   MHEG5QueueItem **pItem);
#ifdef ICS_THROTTLE
static void CheckThrottling(DownloadRequest *request);
#endif
static BOOLEAN ProcessItem(MHEG5QueueItem *item, PsiInfo *psiInfo);
static BOOLEAN ProcessPacket(U8BIT *packet, PsiInfo *psiInfo,
   U32BIT *timestamp);
static BOOLEAN BuildSection(U8BIT *packet, U8BIT *section, U16BIT *offset);
static void HandlePatSection(PsiInfo *psiInfo);
static void HandlePmtSection(PsiInfo *psiInfo);
static BOOLEAN HandlePcrPacket(U8BIT *packet, U32BIT *timestamp);
static void NotifyHeadersDone(U32BIT downloadId,S32BIT code);
static void NotifyDownloadComplete(U32BIT downloadId,E_HttpStatus status,S32BIT code);
static BOOLEAN IsValidSection(U8BIT *section);
static BOOLEAN IsPositionPartial(DownloadRequest *request);

/*---local (static) variable declarations for this file----------------------*/

static DownloadRequest *downloadRequestList = NULL;


U32BIT MHEG5CreateDownloadRequest(U32BIT requestId, char *url,
   U64BIT rangeFrom, U64BIT rangeTo,
   BOOLEAN lastRequest)
{
   char rangeBuffer[MHEG5_MAX_RANGE_BUFFER];
   DownloadRequest *request;
   U32BIT downloadId;

   downloadId = 0;
   request = MHEG5getMem(sizeof *request);
   if (request != NULL)
   {
      SET_MAGIC(request);

      /* Download ID is a unique ID */
      request->downloadId = MHEG5GetUniqueId();

      request->requestId = requestId;

      request->https = FALSE;
      if (memcmp(url, "https://", 8) == 0)
      {
         request->https = TRUE;
      }

      request->rangeFrom = rangeFrom;
      request->rangeTo = rangeTo;
      request->lastRequest = lastRequest;

      request->handle = NULL;
      request->code = 0;
      request->status = HTTP_STATUS_OTHER_ERROR;

      ULL_SetInvalid(request->contentLength);
      ULL_Set32(request->bytesReceived, 0);
      ULL_SetInvalid(request->bytesExpected);

      request->processing = FALSE;
      request->stopped = FALSE;

      request->keyLocation.len = 0;
      request->keyLocation.data = NULL;
      request->keys.num_pids = 0;
      request->keys.pid_info = 0;

      request->syncState = SYNC_ACCUM;
      request->syncBufferPos = 0;

      request->bytesPerSecond = 0;
      request->knownBitrate = FALSE;
      request->timestamp = 0;
        #ifdef ICS_THROTTLE
      request->throttled = FALSE;
      request->targetBitrate = 0;
      ULL_Set32(request->throttledBytes, 0);
        #endif

      request->partialDataLength = 0;

      request->psiInfo.state = PSI_STATE_PAT;
      request->psiInfo.offset = 0;
      request->psiInfo.pmt_pid = 0xffff;
      request->psiInfo.pcr_pid = 0xffff;
      request->psiInfo.firstTimestamp = INVALID_TIMESTAMP;
      ULL_SetInvalid(request->psiInfo.firstPosition);
      request->psiInfo.prevTimestamp = INVALID_TIMESTAMP;
      request->psiInfo.lastTimestamp = INVALID_TIMESTAMP;
      ULL_SetInvalid(request->psiInfo.lastPosition);

      request->next = downloadRequestList;
      downloadRequestList = request;

      ULL_Itoa(rangeFrom, rangeBuffer);
      strcat(rangeBuffer, "-");
      if (ULL_IsValid(rangeTo))
      {
         ULL_Itoa(rangeTo, &rangeBuffer[strlen(rangeBuffer)]);
      }

      request->handle = httpCreateStreamRequest((U8BIT *)url,
            (U8BIT *)rangeBuffer,
            HeaderCallback,
            ContentCallback,
            request->downloadId,
            request);
      if (request->handle != NULL)
      {
         downloadId = request->downloadId;
      }
      else
      {
         /* Failed to create an HTTP request */
         MHEG5freeMem(request);
         request = NULL;
      }
   }

   return downloadId;
}

void MHEG5StartDownloadRequest(U32BIT downloadId)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      assert(request->handle != NULL);
      httpStartRequest(request->handle);
   }
}

U8BIT* MHEG5GetDownloadRedirect(U32BIT downloadId)
{
   DownloadRequest *request;
   U8BIT *redirectUrl = NULL;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      PDBG(("id=%d",downloadId));
      redirectUrl = httpGetRequestRedirect(request->handle);
   }
   return redirectUrl;
}

BOOLEAN MHEG5DownloadPositionPartial(U32BIT downloadId,U64BIT *position)
{
   DownloadRequest *request;
   BOOLEAN result;
   request = FindRequestById(downloadId);
   if (request == NULL)
   {
      result = FALSE;
   }
   else
   {
      result = IsPositionPartial(request);
   }
   if (result)
   {
      *position = request->rangeFrom;
      ULL_Add(*position,request->bytesReceived);
   }
   else
   {
      ULL_Set32((*position),0);
   }
   return result;
}

U64BIT MHEG5GetDownloadContentLength(U32BIT downloadId, U64BIT contentLength)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      contentLength = request->contentLength;
   }
   return contentLength;
}

void MHEG5CopyDownloadBitrate(U32BIT downloadId, U32BIT *bytesPerSecond)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      if (request->bytesPerSecond > 0)
      {
         *bytesPerSecond = request->bytesPerSecond;
      }
   }
}

void MHEG5CopyDownloadStreamKeyInfo(U32BIT downloadId,
   S_ICSKeys *keys,
   MHEG5String *keyLocation)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      if ((request->keys.num_pids > 0) || (request->keyLocation.len > 0))
      {
         if (keys->num_pids > 0)
         {
            /* Clear caller's keys */
            MHEG5freeMem(keys->pid_info);
            keys->num_pids = 0;
            keys->pid_info = NULL;
         }

         if (keyLocation->len > 0)
         {
            /* Clear caller's key location */
            MHEG5stringDestruct(keyLocation);
         }

         if (request->keys.num_pids > 0)
         {
            /* Pass keys ownership */
            *keys = request->keys;

            /* Clear requests's keys */
            request->keys.num_pids = 0;
            request->keys.pid_info = NULL;
         }

         if (request->keyLocation.len > 0)
         {
            /* Pass key location ownership */
            *keyLocation = request->keyLocation;

            /* Clear requests's key location */
            request->keyLocation.len = 0;
            request->keyLocation.data = NULL;
         }
      }
   }
}

BOOLEAN MHEG5GetDownloadPmt(U32BIT downloadId, U8BIT *pmt)
{
   DownloadRequest *request;
   BOOLEAN found = FALSE;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      if (request->psiInfo.state == PSI_STATE_PCR)
      {
         /* PMT was extracted */
         memcpy(pmt, request->psiInfo.section, STMR_MAX_PSI_SECTION);
         found = TRUE;
      }
   }

   return found;
}

void MHEG5ResumeDownload(void)
{
   DownloadRequest *request;

   request = downloadRequestList;
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      if (!request->processing)
      {
         DBG(("Download: Resuming connection"));
         httpResumeRequest(request->handle);
      }
   }
}

void MHEG5ClearDownloadThrottling(void)
{
   DownloadRequest *request;

   request = downloadRequestList;
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      DBG(("Download: Clearing throttling"));
      request->timestamp = 0;

        #ifdef ICS_THROTTLE
      request->throttled = FALSE;
      request->targetBitrate = 0;
      ULL_Set32(request->throttledBytes, 0);
        #endif

      request->psiInfo.firstTimestamp = INVALID_TIMESTAMP;
      ULL_SetInvalid(request->psiInfo.firstPosition);
      request->psiInfo.lastTimestamp = INVALID_TIMESTAMP;
      ULL_SetInvalid(request->psiInfo.lastPosition);

      if (!request->processing)
      {
         httpResumeRequest(request->handle);
      }
   }
}

void MHEG5StopDownloadRequest(U32BIT downloadId)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      if (request->handle != NULL)
      {
         httpStopRequest(request->handle);
      }
   }
}

void MHEG5StopDownloadRequestAsync(U32BIT downloadId)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      request->stopped = TRUE;
   }
}

void MHEG5DestroyDownloadRequest(U32BIT downloadId)
{
   DownloadRequest **pRequest, *request;

   pRequest = &downloadRequestList;
   while (*pRequest != NULL)
   {
      request = *pRequest;
      if (request->downloadId == downloadId)
      {
         VERIFY_MAGIC(request);

         *pRequest = request->next;

         if (request->handle != NULL)
         {
            httpDestroyRequest(request->handle);
         }
         if (request->keys.num_pids > 0)
         {
            MHEG5freeMem(request->keys.pid_info);
         }
         MHEG5stringDestruct(&request->keyLocation);

         MHEG5freeMem(request);

         break;
      }
      else
      {
         pRequest = &request->next;
      }
   }
}

void MHEG5ClearDownloadRequest(U32BIT downloadId)
{
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);

      if (request->handle != NULL)
      {
         httpStopRequest(request->handle);
         httpDestroyRequest(request->handle);
         request->handle = NULL;
      }
      if (request->keys.num_pids > 0)
      {
         MHEG5freeMem(request->keys.pid_info);
         request->keys.num_pids = 0;
         request->keys.pid_info = 0;
      }
      MHEG5stringDestruct(&request->keyLocation);
   }
}

void MHEG5RenewDownloadRequest(U32BIT downloadId, char *url)
{
   char rangeBuffer[MHEG5_MAX_RANGE_BUFFER];
   DownloadRequest *request;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      VERIFY_MAGIC(request);
      assert(request->handle == NULL);
      assert(request->status == HTTP_STATUS_PARTIAL);

      request->processing = FALSE;
      request->partialDataLength = 0;

      ULL_Add(request->rangeFrom, request->bytesReceived);
      ULL_Set32(request->bytesReceived, 0);

      ULL_SetInvalid(request->contentLength);
      ULL_SetInvalid(request->bytesExpected);

      ULL_Itoa(request->rangeFrom, rangeBuffer);
      strcat(rangeBuffer, "-");
      if (ULL_IsValid(request->rangeTo))
      {
         ULL_Itoa(request->rangeTo, &rangeBuffer[strlen(rangeBuffer)]);
      }
      request->handle = httpCreateStreamRequest((U8BIT *)url, (U8BIT *)rangeBuffer,
            HeaderCallback, ContentCallback, downloadId, request);
   }
}

/*******************
 * LOCAL FUNCTION   *
 ********************/


static DownloadRequest* FindRequestById(U32BIT downloadId)
{
   DownloadRequest *request;

   request = downloadRequestList;
   while (request != NULL && request->downloadId != downloadId)
   {
      request = request->next;
   }

   return request;
}

static BOOLEAN HeaderCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response)
{
   DownloadRequest *request = userdata;

   VERIFY_MAGIC(request);

   if (response->data_len <= 2)
   {
      /* Store response code */
      request->code = response->code;

      /* Send notification to main task */
      DBG(("Calling NotifyHeadersDone"));
      NotifyHeadersDone(downloadId,response->code);
   }
   else
   {
      HandleHeaderData(request, response->data, response->data_len);
   }

   return TRUE;
}

static void HandleHeaderData(DownloadRequest *request, U8BIT *data,
   U32BIT len)
{
   E_HTTP_FIELD field;
   U64BIT contentLength;

   /* Parse field for its name, and beginning of field data */
   data = httpHdrParseFieldName(data, len, &field);
   switch (field)
   {
      case HTTP_FIELD_CONTENT_LENGTH:
         contentLength = httpHdrParseContentLength(data, len);
         if (ULL_IsValid(contentLength) &&
             !ULL_IsValid(request->contentLength))
         {
            request->contentLength = contentLength;
            request->bytesExpected = contentLength;
            PDBG(("expected=%s",ULL_ToString(contentLength)));
            PDBG(("rangeFrom=%s",ULL_ToString(request->rangeFrom)));
            ULL_Add(request->contentLength, request->rangeFrom);
            PDBG(("total contentLength=%s",ULL_ToString(request->contentLength)));
         }
         break;
      case HTTP_FIELD_CONTENT_RANGE:
         contentLength = httpHdrParseContentRange(data, len);
         if (ULL_IsValid(contentLength) && ULL_Compare(contentLength,request->rangeFrom) > 0)
         {
            request->contentLength = contentLength;
            request->bytesExpected = contentLength;
            PDBG(("expected=%s",ULL_ToString(contentLength)));
            PDBG(("rangeFrom=%s",ULL_ToString(request->rangeFrom)));
            ULL_Sub(request->bytesExpected, request->rangeFrom);
            PDBG(("expected=%s",ULL_ToString(request->bytesExpected)));
         }
         break;
      case HTTP_FIELD_X_KEYS:
         if (request->keys.num_pids > 0)
         {
            MHEG5freeMem(request->keys.pid_info);
            request->keys.pid_info = NULL;
            request->keys.num_pids = 0;
         }
         MHEG5ParseXKeys(data, len, &request->keys);
         break;
      case HTTP_FIELD_X_KEY_LOCATION:
         MHEG5stringDestruct(&request->keyLocation);
         MHEG5ParseXKeyLocation(data, len, &request->keyLocation);
         break;
      case HTTP_FIELD_X_BYTES_PER_SECOND:
         MHEG5ParseXBytesPerSecond(data, len, &request->bytesPerSecond,
         &request->knownBitrate);
         break;
      default:
      case HTTP_FIELD_UNKNOWN:
         break;
   }
}

static BOOLEAN ContentCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response)
{
   DownloadRequest *request = userdata;
   BOOLEAN handled;

   VERIFY_MAGIC(request);
   assert(request->downloadId == downloadId);


   if (response->status == HTTP_STATUS_WAIT)
   {
      if (request->code == 200 || request->code == 206)
      {
         if (!request->https)
         {
            handled = HandleStreamData(request, response->data,
                  response->data_len);
            if (handled && request->stopped)
            {
               PDBG(("Pause, id=%d request has stopped",downloadId));
               request->status = HTTP_STATUS_OK;
               NotifyDownloadComplete(downloadId,HTTP_STATUS_OK,request->code);
               handled = FALSE;
            }
         }
         else
         {
            /* The test suite doesn't like streaming from HTTPS, so
             * we report this as an error.
             */
            request->code = 0;
            request->status = HTTP_STATUS_OTHER_ERROR;
            NotifyDownloadComplete(downloadId,HTTP_STATUS_OTHER_ERROR,0);
            handled = TRUE;
         }
      }
      else
      {
         /* Just ignore the data */
         handled = TRUE;
      }
   }
   else
   {
      PDBG(("response->status = %s",
             response->status == HTTP_STATUS_OK ? "HTTP_STATUS_OK" :
             response->status == HTTP_STATUS_PARTIAL ? "HTTP_STATUS_PARTIAL" :
             response->status == HTTP_STATUS_SSL_ERROR ? "HTTP_STATUS_SSL_ERROR" :
             response->status == HTTP_STATUS_NETWORK_ERROR ? "HTTP_STATUS_NETWORK_ERROR" :
             response->status == HTTP_STATUS_TIMEOUT ? "HTTP_STATUS_TIMEOUT" :
             response->status == HTTP_STATUS_OTHER_ERROR ? "HTTP_STATUS_OTHER_ERROR" :
             "UNKNOWN"));
      PDBG(("Download: request %d: finished, code=%ld len=%ld", downloadId,response->code,response->data_len));
      if (response->code == 206 &&
         (response->status == HTTP_STATUS_OK || response->status == HTTP_STATUS_TIMEOUT) &&
         IsPositionPartial(request) )
      {
         response->status = HTTP_STATUS_PARTIAL;
      }
      request->status = response->status;
      NotifyDownloadComplete(downloadId,response->status,response->code);
      handled = TRUE;
   }
   return handled;
}

static BOOLEAN HandleStreamData(DownloadRequest *request, U8BIT *data,
   U32BIT len)
{
   BOOLEAN handled = FALSE;
#ifdef ICS_THROTTLE
   U32BIT current;
   U64BIT bytes;
   U32BIT bitrate;
   BOOLEAN queueData = TRUE;

   if (request->throttled)
   {
      queueData = FALSE;

      /* Check if data can be handled */
      current = STB_OSGetClockMilliseconds();
      if (current > request->timestamp)
      {
         bytes = request->throttledBytes;
         ULL_Sub32(bytes, THROTTLE_BYTES);
         ULL_Add32(bytes, len);
         /* Over-estimate by 5% */
         ULL_Mul32(bytes, 1050);
         ULL_Div32(bytes, (current - request->timestamp));
         bitrate = ULL_Get32(bytes);

         /*
            DBG_PRINTF("%d bytes d/l, ts = %d, ct = %d\n",
                ULL_Get32(request->throttledBytes) + len,
                request->timestamp, current);
          */

         if (bitrate <= request->targetBitrate)
         {
            /*DBG_PRINTF("Data allowed\n");*/
            /*DBG_PRINTF("%d bytes d/l, ts = %d, ct = %d\n",
                   ULL_Get32(bytes),
                   request->timestamp, current);*/
            queueData = TRUE;
         }
      }
   }

   if (queueData)
   {
      /* Cannot handle the data - pause the connection */
      DBG(("Download: Pausing connection"));
      assert(!handled);
   }
   else
#endif  /* ICS_THROTTLE */
   {
      handled = HandleData(request, data, len);
      if (handled)
      {
      #ifdef ICS_THROTTLE
         ULL_Add32(request->throttledBytes, len);
       #endif
      }
      else
      {
         /* Cannot handle the data - pause the connection */
         DBG(("Download: Pausing connection"));
      }
   }
   request->processing = handled;
   return handled;
}

static BOOLEAN FindSyncOffset( U8BIT *syncBuffer, U16BIT *pOffset )
{
   U16BIT offset, i, count, maxCount, bestOffset;
   bestOffset = 0;
   maxCount = 0;
   for (offset = 0; offset != STMR_TS_PACKET_SIZE; offset++)
   {
      count = 0;
      for (i = offset; i != (SYNC_BUFFER_SIZE + offset); i += STMR_TS_PACKET_SIZE)
      {
         count += (syncBuffer[i] == SYNC_BYTE);
      }

      if (count == SYNC_COUNT_ACCEPT)
      {
         /* Accept immediately */
         break;
      }

      if (count > maxCount)
      {
         maxCount = count;
         bestOffset = offset;
      }
   }

   if (maxCount >= SYNC_COUNT_MIN_ACCEPT)
   {
      DBG(("[sync] Found possible offset %d with count %d\n",
           bestOffset, maxCount));
      offset = bestOffset;
   }
   if (offset == STMR_TS_PACKET_SIZE)
   {
      /* Tried every offset but couldn't find enough sync_bytes,
       * so the sync process has failed
       */
      DBG(("[sync] Could not find sync offset"));
      #if 0
      {
         int i;
         for (i = 0; i < SYNC_BUFFER_SIZE; i++)
         {
            DBG_PRINTF("%02x ", syncBuffer[i]);
            if (i % 16 == 15)
            {
               DBG_PRINTF("\n");
            }
         }
      }
      #endif
      return FALSE;
   }
   DBG(("[sync] Found offset %d", offset));
   *pOffset = offset;
   return TRUE;
}

static BOOLEAN HandleData( DownloadRequest *request, U8BIT *data, U32BIT len )
{
   U16BIT offset, origOffset;
   BOOLEAN success;
   MHEG5QueueItem *item;

   success = TRUE;

   switch (request->syncState)
   {
      case SYNC_ACCUM:
         origOffset = request->syncBufferPos;

         /* Accumulate data until there is enough for the sync process */
         DBG(("[sync] request->syncState == SYNC_ACCUM"));
         assert( origOffset < SYNC_BUFFER_SIZE );
         offset = SYNC_BUFFER_SIZE - origOffset;
         if (offset > len)
         {
            offset = (U16BIT)len;
         }
         memcpy(request->syncBuffer + origOffset, data, offset);

         DBG(("[sync] Updated request->syncBufferPos from %d to %d",
              request->syncBufferPos, request->syncBufferPos + offset));
         request->syncBufferPos += offset;

         if (request->syncBufferPos != SYNC_BUFFER_SIZE)
         {
            // continue accumulating
            break;
         }

         /* Perform sync process */
         DBG(("[sync] request->SyncState == SYNC_ACCUM and enough data"));
         if (!FindSyncOffset( request->syncBuffer, &offset ))
         {
            request->syncState = SYNC_FAILED;
            success = FALSE;
            break;
         }
         request->syncState = SYNC_FOUND;
         if (offset != 0)
         {
            // dropping 'offset' bytes - sync byte not at beginning of buffer
            DBG(("[sync] offset = %d", offset));
            // still register that these bytes have been received,
            // even though they are being ignored
            ULL_Add32(request->bytesReceived, offset);
         }
         if (offset == origOffset)
         {
            // nothing to drop, and nothing accumulated before this packet
         }
         else if (offset > origOffset)
         {
            // sync bye not at beginning of packet
            len -= offset - origOffset;
            data += offset - origOffset;
         }
         else //if ( offset < origOffset )
         {
            // Add data from sync buffer
            if (!StoreItem(request, request->syncBuffer + offset, origOffset - offset, &item))
            {
               success = FALSE;
               break;
            }
            if (item != NULL)
            {
               (void)ProcessItem(item, &request->psiInfo);
               MHEG5QueueInsertItem(item);
            }
         }
      // fallthrough

      case SYNC_FOUND:
         if (!StoreItem(request, data, len, &item))
         {
            success = FALSE;
            break;
         }
         if (item != NULL)
         {
            if (!ProcessItem(item, &request->psiInfo))
            {
               request->syncState = SYNC_ACCUM;
               origOffset = request->partialDataLength;
               request->syncBufferPos = origOffset;
               if (origOffset != 0)
               {
                  memcpy(request->syncBuffer, request->partialData, origOffset);
                  request->partialDataLength = 0;
               }
            }
            MHEG5QueueInsertItem(item);
         }
         break;

      default:
      case SYNC_FAILED:
      PDBG(("syncState=%d",request->syncState));
         success = FALSE;
         break;
   }
   return success;
}

static BOOLEAN StoreItem(DownloadRequest *request, U8BIT *data, U32BIT len,
   MHEG5QueueItem **pItem)
{
   U32BIT totalLen, storeLen, partialLen, remainingLen;
   MHEG5QueueItem *item;
   BOOLEAN success;

   *pItem = NULL;

   totalLen = len + request->partialDataLength;
   storeLen = totalLen - totalLen % STMR_TS_PACKET_SIZE;
   if (storeLen >= STMR_TS_PACKET_SIZE)
   {
      partialLen = storeLen - request->partialDataLength;

      /* partialDataLength bytes from the request and partialLen bytes
       * from the new data are stored in the queue (if possible). This
       * leaves us with (len - partialLen) bytes to store in
       * the request's partialData buffer.
       */
      item = MHEG5QueueAllocItem(request->requestId, storeLen);
      if (item == NULL)
      {
         DBG(("FAIL Q alloc for %d",storeLen));
         success = FALSE;
      }
      else
      {
         /* Copy partial data (if any) into item */
         if (request->partialDataLength > 0)
         {
            memcpy(item->data, request->partialData,
               request->partialDataLength);
            item->len += request->partialDataLength;
         }

         /* Copy new data into item */
         memcpy(item->data + item->len, data, partialLen);
         item->len += partialLen;

         /* Copy remaining data into the request for next time */
         remainingLen = len - partialLen;
         if (remainingLen > 0)
         {
            assert(remainingLen < STMR_TS_PACKET_SIZE);
            memcpy(request->partialData, data + partialLen,
               remainingLen);
         }
         request->partialDataLength = (U16BIT)remainingLen;

         PDBG(("Download: Inserting item(%d, %u + %u + %u)",
              request->downloadId, ULL_Get32(request->rangeFrom),
              ULL_Get32(request->bytesReceived),storeLen));

         item->position = request->bytesReceived;
         item->base = request->rangeFrom;
         item->downloadId = request->downloadId;
         item->timestamp = 0;

         ULL_Add32(request->bytesReceived, storeLen);
         if ((request->lastRequest) &&
             (ULL_IsEqual(request->bytesReceived,
                 request->bytesExpected)))
         {
            PDBG(("expected=%s",ULL_ToString(request->bytesExpected)));
            item->last = TRUE;
         }
         else
         {
            item->last = FALSE;
         }

      #ifdef ICS_THROTTLE
         if (!request->throttled)
         {
            CheckThrottling(request);
         }
      #endif

         *pItem = item;

         success = TRUE;
      }
   }
   else
   {
      /* Not enough data to store in the buffer */
      memcpy(request->partialData + request->partialDataLength,
         data, len);
      request->partialDataLength += (U16BIT)len;

      success = TRUE;
   }

   return success;
}

#ifdef ICS_THROTTLE

static void CheckThrottling(DownloadRequest *request)
{
   U64BIT bitrate;

   if (!request->throttled)
   {
      if (ULL_Get32(request->throttledBytes) >= THROTTLE_BYTES &&
          request->psiInfo.firstTimestamp != request->psiInfo.lastTimestamp)
      {
         request->throttled = TRUE;

         bitrate = request->psiInfo.lastPosition;
         ULL_Sub(bitrate, request->psiInfo.firstPosition);
         ULL_Mul32(bitrate, 1200);
         ULL_Div32(bitrate, request->psiInfo.lastTimestamp - request->psiInfo.firstTimestamp);
         request->targetBitrate = ULL_Get32(bitrate);
         request->timestamp = STB_OSGetClockMilliseconds();
         /*ULL_Set32(request->throttledBytes, 0);*/
      }
   }
}

#endif  /* ICS_THROTTLE */


static BOOLEAN ProcessItem(MHEG5QueueItem *item, PsiInfo *psiInfo)
{
   U32BIT remaining = item->len;
   U8BIT *packet = item->data;
   U32BIT timestamp;
   BOOLEAN ok;

   ok = TRUE;
   assert((remaining % STMR_TS_PACKET_SIZE) == 0);
   while (remaining != 0)
   {
      if (packet[0] != SYNC_BYTE)
      {
         PDBG(("Need to find sync byte again"))
         ok = FALSE;
         break;
      }
      if (ProcessPacket(packet, psiInfo, &timestamp))
      {
         DBG(("item=%p position=%s timestamp=%lu remaining=%d",item,ULL_ToString(item->position),timestamp,remaining));
         if (psiInfo->firstTimestamp == INVALID_TIMESTAMP)
         {
            psiInfo->firstTimestamp = timestamp;
            psiInfo->firstPosition = item->position;
            ULL_Add32(psiInfo->firstPosition, item->len);
         }

         psiInfo->lastTimestamp = timestamp;
         psiInfo->lastPosition = item->position;

         assert(item->timestamp == 0);
         if (item->timestamp == 0)
         {
            item->timestamp = timestamp;

            /* Timestamp is only updated when state=PSI_STATE_PCR, so
             * there's no need to stay in this loop.
             */
            break;
         }
      }
      packet += STMR_TS_PACKET_SIZE;
      remaining -= STMR_TS_PACKET_SIZE;
   }
   if (psiInfo->state == PSI_STATE_PCR && ok)
   {
      U16BIT pid;
      remaining = item->len;
      remaining -= remaining % STMR_TS_PACKET_SIZE;
      packet = item->data + remaining;
      if (item->timestamp == 0)
      {
         DBG(("item=%p position=%s timestamp=%lu remaining=%d",item,ULL_ToString(item->position),psiInfo->prevTimestamp,remaining));
         item->timestamp = psiInfo->prevTimestamp;
      }
      while (remaining != 0)
      {
         packet -= STMR_TS_PACKET_SIZE;
         remaining -= STMR_TS_PACKET_SIZE;
         pid = (packet[1] << 8 | packet[2]) & 0x1fff;
         if (pid == psiInfo->pcr_pid &&
            HandlePcrPacket(packet,&timestamp))
         {
            DBG(("item=%p position=%s timestamp=%lu remaining=%d",item,ULL_ToString(item->position),timestamp,remaining));
            psiInfo->prevTimestamp = timestamp;
            break;
         }
      }
   }
   return ok;
}

static BOOLEAN ProcessPacket(U8BIT *packet, PsiInfo *psiInfo,
   U32BIT *timestamp)
{
   int pid;
   BOOLEAN built;
   BOOLEAN found;

   found = FALSE;

   pid = (packet[1] << 8 | packet[2]) & 0x1fff;

   switch (psiInfo->state)
   {
      case PSI_STATE_PAT:
         if (pid == 0x0000)
         {
            built = BuildSection(packet, psiInfo->section, &psiInfo->offset);
            if (built)
            {
               if (psiInfo->section[0] == 0x00)
               {
                  HandlePatSection(psiInfo);
               }
               psiInfo->offset = 0;
            }
         }
         break;
      case PSI_STATE_PMT:
         if (pid == psiInfo->pmt_pid)
         {
            built = BuildSection(packet, psiInfo->section, &psiInfo->offset);
            if (built)
            {
               if (psiInfo->section[0] == 0x02)
               {
                  HandlePmtSection(psiInfo);
               }
               psiInfo->offset = 0;
            }
         }
         break;
      case PSI_STATE_PCR:
         if (pid == psiInfo->pcr_pid)
         {
            found = HandlePcrPacket(packet, timestamp);
         }
         break;
   }

   return found;
}

static BOOLEAN BuildSection(U8BIT *packet, U8BIT *section, U16BIT *offset)
{
   U32BIT payload_start_indicator;
   U32BIT adaptation_field_control;
   U32BIT pointer;
   U8BIT *payload;
   U16BIT payload_length;
   BOOLEAN complete;

   complete = FALSE;

   payload_start_indicator = (packet[1] >> 6) & 0x1;
   adaptation_field_control = (packet[3] >> 4) & 0x3;
   if (adaptation_field_control >= 2)
   {
      payload = packet + 5 + packet[4];
      payload_length = 188 - 5 - packet[4];
   }
   else
   {
      payload = packet + 4;
      payload_length = 188 - 4;
   }

   if (payload_start_indicator)
   {
      pointer = payload[0];
      if (payload_length > 0)
      {
         memcpy(section, payload + 1 + pointer, payload_length - 1);
         *offset = payload_length - 1;
      }
      else
      {
         *offset = 0;
      }
   }
   else if (*offset > 0)
   {
      if (payload_length > 0)
      {
         if (*offset + payload_length <= STMR_MAX_PSI_SECTION)
         {
            memcpy(section + *offset, payload, payload_length);
            *offset += payload_length;
         }
         else
         {
            /* Section too long */
            *offset = 0;
         }
      }
   }

   if (*offset > 2)
   {
      U16BIT section_length;

      section_length = (section[1] << 8 | section[2]) & 0xfff;
      if (*offset >= section_length + 3)
      {
         complete = IsValidSection(section);
         if (!complete)
         {
            /* Invalid data, start again */
            *offset = 0;
         }
      }
   }

   return complete;
}

static void HandlePatSection(PsiInfo *psiInfo)
{
   U8BIT *section = psiInfo->section;
   U16BIT section_length;
   U16BIT offset;
   U16BIT program_number;
   U16BIT pmt_pid;

   section_length = (section[1] << 8 | section[2]) & 0xfff;
   offset = 8;
   while (offset + 4 < section_length + 3)
   {
      program_number = section[offset] << 8 | section[offset + 1];
      pmt_pid = (section[offset + 2] << 8 | section[offset + 3]) & 0x1fff;
      if (program_number != 0x0000)
      {
         PDBG(("program_number = %d, program_map_PID = %d",
               program_number, pmt_pid));
         psiInfo->pmt_pid = pmt_pid;
         psiInfo->state = PSI_STATE_PMT;
         break;
      }

      offset += 4;
   }
}

static void HandlePmtSection(PsiInfo *psiInfo)
{
   U8BIT *section = psiInfo->section;

   /* PCR PID */
   psiInfo->pcr_pid = (section[8] << 8 | section[9]) & 0x1fff;
   PDBG(("PCR PID = %d", psiInfo->pcr_pid));

   psiInfo->state = PSI_STATE_PCR;
}

static BOOLEAN HandlePcrPacket(U8BIT *packet, U32BIT *timestamp)
{
   S32BIT adaptation_field_control;
   S32BIT adaptation_field_length;
   S32BIT PCR_flag;

   U32BIT pcr_base_x;
   U32BIT pcr_base_y;

   BOOLEAN found;

   found = FALSE;
   *timestamp = 0;

   adaptation_field_control = (packet[3] >> 4) & 0x3;
   if (adaptation_field_control >= 2)
   {
      adaptation_field_length = packet[4];
      if (adaptation_field_length > 0)
      {
         PCR_flag = (packet[5] >> 4) & 0x1;
         if (PCR_flag)
         {
            /*
             * PCR = (packet[6] << 25 | packet[7] << 17 | packet[8] << 9 |
             *        packet[9] << 1  | packet[10] >> 7)
             *
             * But we cannot store 33 bit values. So we divide it into
             * two parts:
             */
            pcr_base_x = (packet[6] << 24 |
                          packet[7] << 16 |
                          packet[8] << 8 |
                          packet[9]);
            pcr_base_y = packet[10] >> 7;

            /* PCR = (pcr_base_x << 1) | pcr_base_y
             *
             * To convert PCR to milliseconds, we have to divide it by
             * 90:
             *
             * (2x + y) / 90 = x/45 + y/90 = (x - x%45 + x%45)/45 + y/90
             *               = (x - x%45)/45 + (2 * x%45 + y)/90
             *               = x / 45 + (2 * (x % 45) + y) / 90
             */

            *timestamp = (pcr_base_x / 45 +
                          (2 * (pcr_base_x % 45) + pcr_base_y) / 90);
            found = TRUE;
         }
      }
   }

   return found;
}

static void NotifyHeadersDone(U32BIT downloadId,S32BIT code)
{
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;

   event.proc_msg_func = (F_MSG_PROCESS)MHEG5StreamerHandle;
   event.data_type = DT_VALUE;
   event.data.streamer.requestId = downloadId;
    event.data.streamer.code = code;
   event.data.streamer.eventType = MHEG5_STREAMER_EVENT_HTTP_HEADERS_DONE;

   cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
   if (cqu_err != MHERR_OK)
   {
      PDBG(("NotifyHeaders: Cannot generate event %d", cqu_err));
   }
}

static void NotifyDownloadComplete(U32BIT downloadId,E_HttpStatus status,S32BIT code)
{
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;

   event.proc_msg_func = (F_MSG_PROCESS)MHEG5StreamerHandle;
   event.data_type = DT_VALUE;
   event.data.streamer.requestId = downloadId;
    event.data.streamer.status    = status;
    event.data.streamer.code      = code;
   event.data.streamer.eventType = MHEG5_STREAMER_EVENT_HTTP_DOWNLOAD_DONE;

   cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
   if (cqu_err != MHERR_OK)
   {
      PDBG(("Download: Cannot send MHEG5_STREAMER_EVENT_HTTP_DOWNLOAD_DONE %d", cqu_err));
   }
}

static U32BIT crc_table[] = {
   0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
   0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
   0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
   0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
   0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
   0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
   0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
   0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
   0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
   0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
   0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
   0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
   0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
   0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
   0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
   0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
   0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
   0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
   0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
   0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
   0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
   0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
   0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
   0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
   0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
   0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
   0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
   0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
   0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
   0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
   0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
   0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
   0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
   0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
   0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
   0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
   0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
   0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
   0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
   0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
   0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
   0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
   0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};


static BOOLEAN IsValidSection(U8BIT *section)
{
   U16BIT section_length;
   U32BIT idx;
   U32BIT crc_accum;
   U8BIT *limit;
   BOOLEAN valid = FALSE;

   section_length = (section[1] << 8 | section[2]) & 0xfff;

   crc_accum = 0xffffffffL;
   limit = section + section_length + 3;
   while (section < limit)
   {
      idx = ((crc_accum >> 24) ^ (*section++)) & 0xff;
      crc_accum = ((crc_accum << 8) ^ crc_table[idx]) & 0xffffffffL;
   }

   if (crc_accum == 0x00000000)
   {
      valid = TRUE;
   }

   return valid;
}

static BOOLEAN IsPositionPartial(DownloadRequest *request)
{
   U64BIT left;
   BOOLEAN result = FALSE;
   VERIFY_MAGIC(request);
   left = request->bytesExpected;
   PDBG(("expected=%s received=%s",ULL_ToString(left),ULL_ToString(request->bytesReceived)));
   if (ULL_IsValid(left) && ULL_Compare(left,request->bytesReceived) > 0)
   {
      ULL_Sub(left,request->bytesReceived);
      if (ULL_Get32(left) > 262144)
      {
         PDBG(("******** PARTIAL DOWNLOAD **** id=%d, left=%s",request->downloadId,ULL_ToString(left)));
         result = TRUE;
      }
   }
   return result;
}