stmr_msp.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 "http_interface.h"
#include "glue_memory.h"
#include "glue_queue.h"

#include "mh5base.h"
#include "mh5profile.h"
#include "mh5streamer.h"
#include "stmr_msp.h"
#include "stmr_util.h"
#include "stmr_common.h"

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

#define MAX_MEASURE_SIZE (0x7fffffff)



#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)


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

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

   /* Download ID */
   U32BIT downloadId;

   /* Request ID */
   U32BIT requestId;

   /* HTTP handle */
   HttpRequest_t handle;

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

   /* Measurement */
   U32BIT startTime;
   U32BIT finishTime;
   U64BIT receivedBytes;
   U64BIT maxReceivedBytes;

   /* Next request */
   struct sMeasureRequest *next;
} MeasureRequest;

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

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

static MeasureRequest* FindRequestById(U32BIT requestId);
static BOOLEAN HeaderCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response);
static BOOLEAN ContentCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response);
static BOOLEAN HandleMeasureData(MeasureRequest *request, U32BIT bytes);
static BOOLEAN HandleMeasureEnd(MeasureRequest *request,
   HttpResponse_t *response);

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

static MeasureRequest *measureRequestList = NULL;


U32BIT MHEG5CreateMeasureRequest(U32BIT requestId, char *url, S32BIT maxBytes)
{
   char rangeBuffer[MHEG5_MAX_RANGE_BUFFER];
   MeasureRequest *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->handle = NULL;
      request->code = 0;
      request->status = HTTP_STATUS_OTHER_ERROR;

      request->startTime = 0;
      request->finishTime = 0;

      request->next = measureRequestList;
      measureRequestList = request;

      strcpy(rangeBuffer, "0-");
      if (maxBytes > 0)
      {
         sprintf(&rangeBuffer[2], "%d", (int)maxBytes);
      }
      else
      {
         maxBytes = 0x7fffffff;
      }

      ULL_Set32(request->receivedBytes, 0);
      ULL_Set32(request->maxReceivedBytes, maxBytes);

      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 MHEG5StartMeasureRequest(U32BIT downloadId)
{
   MeasureRequest *request;

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

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

S32BIT MHEG5GetMeasureResponseCode(U32BIT downloadId)
{
   MeasureRequest *request;
   S32BIT code = 0;

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

      code = request->code;
   }

   return code;
}

S32BIT MHEG5GetMeasureStatus(U32BIT downloadId)
{
   MeasureRequest *request;
   S32BIT status = HTTP_STATUS_OTHER_ERROR;

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

      status = request->status;
   }

   return status;
}

U8BIT* MHEG5GetMeasureRedirect(U32BIT downloadId)
{
   MeasureRequest *request;
   U8BIT *redirectUrl = NULL;

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

      redirectUrl = httpGetRequestRedirect(request->handle);
   }

   return redirectUrl;
}

void MHEG5ProcessMeasureRequest(U32BIT downloadId)
{
   U64BIT numerator;
   MeasureRequest *request;
   U32BIT timeDiff, speed;

   request = FindRequestById(downloadId);
   if (request != NULL)
   {
      /* Report speed in terms of bytes / second */
      if (ULL_IsValid(request->receivedBytes))
      {
         timeDiff = request->finishTime - request->startTime;
         if (timeDiff == 0)
         {
            /* Avoid the division by zero */
            speed = -1;
         }
         else
         {
            /* speed = receivedBytes * 1000 / timeDiff */
            numerator = request->receivedBytes;
            ULL_Mul32(numerator, 1000);
            ULL_Div32(numerator, timeDiff);
            speed = ULL_Get32(numerator);
         }
      }
      else
      {
         speed = -1;
      }

      MHEG5StreamerNotifyStreamingPerformance(request->requestId, speed);
   }
}

void MHEG5StopMeasureRequest(U32BIT downloadId)
{
   MeasureRequest *request;

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

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

void MHEG5DestroyMeasureRequest(U32BIT downloadId)
{
   MeasureRequest **pRequest, *request;

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

         assert(request->handle != NULL);
         httpDestroyRequest(request->handle);
         request->handle = NULL;

         *pRequest = request->next;
         MHEG5freeMem(request);

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

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


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

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

   return request;
}

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

   VERIFY_MAGIC(request);

   if (response->data_len <= 2)
   {
      /* End of headers */
      request->code = response->code;
   }

   return TRUE;
}

static BOOLEAN ContentCallback(void *userdata, U32BIT downloadId,
   HttpResponse_t *response)
{
   MeasureRequest *request = userdata;
   BOOLEAN more = TRUE;

   VERIFY_MAGIC(request);

   if (response->status == HTTP_STATUS_WAIT)
   {
      more = HandleMeasureData(request, response->data_len);
   }
   else
   {
      more = HandleMeasureEnd(request, response);
   }

   return more;
}

static BOOLEAN HandleMeasureData(MeasureRequest *request, U32BIT bytes)
{
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;
   BOOLEAN more = TRUE;

   if (request->code == 200 || request->code == 206)
   {
      /* Update bytes received */
      ULL_Add32(request->receivedBytes, bytes);

      if (ULL_Compare(request->receivedBytes,
             request->maxReceivedBytes) >= 0)
      {
         /* Update finish time */
         request->finishTime = STB_OSGetClockMilliseconds();
         more = FALSE;
      }
   }

   if (!more)
   {
      /* Update status */
      request->status = HTTP_STATUS_OK;

      /* HandleMeasureEnd will not be called, as more=FALSE. So the
       * event must be sent here.
       */
      event.proc_msg_func = (F_MSG_PROCESS)MHEG5StreamerHandle;
      event.data_type = DT_VALUE;
      event.data.streamer.requestId = request->downloadId;
      event.data.streamer.eventType = MHEG5_STREAMER_EVENT_MSP_DOWNLOAD_DONE;

      cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
      if (cqu_err != MHERR_OK)
      {
         DBG(("HandleMeasureData: Cannot send MHEG5_STREAMER_EVENT_MSP_DOWNLOAD_DONE event\n"));
      }
   }

   return more;
}

static BOOLEAN HandleMeasureEnd(MeasureRequest *request,
   HttpResponse_t *response)
{
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;

   /* Perform the following only if the request hasn't finished yet */
   if (request->finishTime == 0)
   {
      /* Update status */
      request->status = response->status;

      /* Update finish time */
      request->finishTime = STB_OSGetClockMilliseconds();

      event.proc_msg_func = (F_MSG_PROCESS)MHEG5StreamerHandle;
      event.data_type = DT_VALUE;
      event.data.streamer.requestId = request->downloadId;
      event.data.streamer.eventType = MHEG5_STREAMER_EVENT_MSP_DOWNLOAD_DONE;

      cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
      if (cqu_err != MHERR_OK)
      {
         DBG(("HandleMeasureEnd: Cannot send MHEG5_STREAMER_EVENT_MSP_DOWNLOAD_DONE event %d\n", cqu_err));
      }
   }
   return TRUE;
}