mh5support.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 <string.h>
#include "mh5support.h"
#include "mh5debug.h"
#include "mh5memory.h"
#include "mh5profile.h"
#include "mheg5_control.h"
#include "mg_fontapi.h"
#include "mg_osd.h"

#include "mheg5_version.h"
#include "build.h"

/*---constant definitions for this file--------------------------------------*/
#define FUNC_TYPE_NONE     0
#define FUNC_TYPE_ONEINT   1
#define FUNC_TYPE_TWOINT   2
#define FUNC_TYPE_THRINT   3
#define FUNC_TYPE_STRING   5
#define FUNC_TYPE_ERROR    0xff

#define OPEN_BRACKET       '('
#define CLOSE_BRACKET      ')'

#define ENGINE_STRING_TOTAL  4

#define MAX_USER_AGENT     255

#define FREESAT_MAX_FILE_LEN (256 * 1024)
#define UK_MAX_FILE_LEN       1024
#define AU_MAX_FILE_LEN       (64 * 1024)
#define SA_MAX_FILE_LEN       (512 * 1024)

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

typedef enum
{
#ifdef INCLUDE_CI_PLUS
   PRF_NDX_CIPLUS,
#endif
   PRF_NDX_UK,
   PRF_NDX_NZ,
   PRF_NDX_AU,
   PRF_NDX_HK,
#ifdef INCLUDE_SA_PROFILE
   PRF_NDX_SA,
#endif
#ifdef INCLUDE_FREESAT
   PRF_NDX_FS,
#endif
   PRF_TOTAL
} E_PRFS;

enum
{
   MANF_STRING,
   ENG_STRING,
   DSM_STRING,
   REV_STRING
};

typedef struct s_EngineSupportTable
{
   const char *short_name;
   const char *long_name;
   MHEG5Bool (*function)(void *);
   U32BIT func_type;
} S_EngineSupportTable;

typedef struct
{
   U32BIT c_len;
   const char *c_data;
   BOOLEAN whoami;
   E_COUNTRY_PROFILE type;
} S_PROFILE_STRING;

typedef enum
{
   MHEG5_SCALE_CAPS_QUARTER,
   MHEG5_SCALE_CAPS_STANDARD,
   MHEG5_SCALE_CAPS_DOUBLE,
   MHEG5_SCALE_CAPS_HDGRAPHICS,
   MHEG5_SCALE_CAPS_HDVIDEO,
   MHEG5_SCALE_CAPS_HDGRAPHICS_AND_HDVIDEO
} E_ScalingCapabilities;


static MHEG5Bool UniversalEngineProfile(void *str);
static MHEG5Bool HDExtension(void *p_val);
static MHEG5Bool PVRFunction(void *p_val);
static MHEG5Bool ICProfile(void *p_val);
static MHEG5Bool IPStreamingProfile(void *p_val);
static MHEG5Bool NonLinearPlaybackKeys(void *v);
static MHEG5Bool DownloadableFont(void *p_val);
static MHEG5Bool VideoScaling(void *p_val);
static MHEG5Bool BitmapScaling(void *p_val);
static MHEG5Bool BitmapFormat(void *p_val);
static MHEG5Bool VideoDecodeOffset(void *p_val);
static MHEG5Bool BitmapDecodeOffset(void *p_val);
static MHEG5Bool SceneCoordinateSystem(void *p_val);
static MHEG5Bool SceneAspectRatio(void *p_val);
static MHEG5Bool SubtitlesAndGraphics(void *v);
static MHEG5Bool MultipleVideoStreams(void *p_val);
static MHEG5Bool MultipleAudioStreams(void *p_val);
#ifdef INCLUDE_DEBUG_PACKAGE
static MHEG5Bool DebugPackageSupport(void *p_val);
#endif  /* INCLUDE_DEBUG_PACKAGE */
#ifdef INCLUDE_CONNECTED_TV
static MHEG5Bool ConnectedTVExtension(void* p_val);
static MHEG5Bool ApplicationLaunchExtension(void* p_val);
#endif  /* INCLUDE_CONNECTED_TV */

static void AddProfileStringLen(S_PROFILE_STRING *profile_string,
   MHEG5Int *length);
static void AppendProfileString(S_PROFILE_STRING *profile_string,
   MHEG5Byte **pString);

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

static const S_EngineSupportTable support_table[] = {
   { "UEP", "UniversalEngineProfile", UniversalEngineProfile, FUNC_TYPE_STRING },
   { "HDE", "HDExtension", HDExtension, FUNC_TYPE_ONEINT },
   { "HDG", "HDGraphics", HDExtension, FUNC_TYPE_ONEINT },
   { "PVR", "PVR", PVRFunction, FUNC_TYPE_ONEINT },
   { "ICP", "ICProfile", ICProfile, FUNC_TYPE_ONEINT },
   { "IPS", "IPStreamingProfile", IPStreamingProfile, FUNC_TYPE_ONEINT },
   { "NLK", "NonLinearPlaybackKeys", NonLinearPlaybackKeys, FUNC_TYPE_NONE   },
   { "DLF", "DownloadableFont", DownloadableFont, FUNC_TYPE_ONEINT },
   { "VSc", "VideoScaling", VideoScaling, FUNC_TYPE_THRINT },
   { "BSc", "BitmapScaling", BitmapScaling, FUNC_TYPE_THRINT },
   { "BFo", "BitmapFormat", BitmapFormat, FUNC_TYPE_ONEINT },
   { "VDO", "VideoDecodeOffset", VideoDecodeOffset, FUNC_TYPE_TWOINT },
   { "BDO", "BitmapDecodeOffset", BitmapDecodeOffset, FUNC_TYPE_TWOINT },
   { "SCS", "SceneCoordinateSystem", SceneCoordinateSystem, FUNC_TYPE_TWOINT },
   { "SAR", "SceneAspectRatio", SceneAspectRatio, FUNC_TYPE_TWOINT },
   { "SAG", "SubtitlesAndGraphics", SubtitlesAndGraphics, FUNC_TYPE_NONE   },
   { "Clo", "Cloning", NULL, FUNC_TYPE_NONE   },
   { "ASt", "ApplicationStacking", NULL, FUNC_TYPE_NONE   },
   { "OvV", "OverlappingVisibles", NULL, FUNC_TYPE_NONE   },
   { "MVS", "MultipleVideoStreams", MultipleVideoStreams, FUNC_TYPE_ONEINT },
   { "MAS", "MultipleAudioStreams", MultipleAudioStreams, FUNC_TYPE_ONEINT },
#ifdef INCLUDE_DEBUG_PACKAGE
   { "DPS", "DebugPackageSupport", DebugPackageSupport, FUNC_TYPE_NONE   },
#endif
#ifdef INCLUDE_CONNECTED_TV
   { "CTV", "ConnectedTVExtension",    ConnectedTVExtension,   FUNC_TYPE_ONEINT },
   { "ApE", "ApplicationLaunchExtension", ApplicationLaunchExtension, FUNC_TYPE_STRING },
#endif  /* INCLUDE_CONNECTED_TV */
   { NULL, NULL, NULL, FUNC_TYPE_ERROR }    /* End of list */
};

/* The 'WhoAmI' strings for MHEG engine and DSM-CC */
static char mheg5EngineString[10] = "MHGDTV000";
static char dsmccEngineString[10] = "DSMDTV000";
static char manufacturerString[10] = "123456789";
/* The extra string (revision for internal testing) to add to 'WhoAmI' */
static const char *buildRevisionString = BUILD_REVISION;

static S_PROFILE_STRING engine_strings[] = {
   { 9, manufacturerString, TRUE, 0 },
   { 9, mheg5EngineString, TRUE, 0 },
   { 9, dsmccEngineString, TRUE, 0 },
   { 0, NULL, TRUE, 0 }
};

/* Holds the capabilities of the receiver, in terms of different supported
 * scaling values and off-screen display. */
static E_MHEG5_CAPABILITES receiver_caps = VC_DEFAULT;

static S_PROFILE_STRING profile_strings[PRF_TOTAL] = {
#ifdef INCLUDE_CI_PLUS
   {  9, "CIPLUS001", TRUE, 0 },
#endif
   {  4, "1285", FALSE, CPROFILE_UK },                       /* UK v1.06 */
   { 15, "INT002001000000", TRUE, CPROFILE_NZ },             /* New Zealand v1.03 */
   { 15, "INTAUS001000000", TRUE, CPROFILE_AU },             /* Australia   1.0.0 */
   { 15, "INT003001000000", TRUE, CPROFILE_HK },             /* Hong Kong   1.0.0 */
#ifdef INCLUDE_SA_PROFILE
   { 14, "INTZA001000000", TRUE, CPROFILE_SA },              /* South Africa 2.1 */
#endif
#ifdef INCLUDE_FREESAT
   {  4, "1285", FALSE, CPROFILE_FREESAT }                   /* Freesat */
#endif
};

static E_ProfileId current_profile; // = PROFILE_BROADCAST;
static E_MHEG_PROFILE mheg_profile;
static MHEG5Int max_storage_file_len = UK_MAX_FILE_LEN;
static char user_agent[MAX_USER_AGENT];

/***********************
 * FUNCTION DEFINITIONS *
 ************************/

const char* MHEG5VersionString(void)
{
   return MHEG5_VER_STRING;
}

const char* MHEG5RevisionString(void)
{
   return BUILD_REVISION;
}

E_MhegErr MH5_SupportInitialise( S_MhegConfig *pConfig )
{
   E_MhegErr result = MHERR_OK;

   U16BIT ndx;
   U8BIT *pchr;
   pchr = pConfig->manufacturerString;
   if (pchr == NULL || *pchr == 0)
   {
      result = MHERR_BAD_PARAMETER;
   }
   else
   {
      for (ndx = 0; ndx != 10; ndx++)
      {
         if (pchr[ndx] == 0)
         {
            engine_strings[0].c_len = ndx;
            break;
         }
         manufacturerString[ndx] = pchr[ndx];
      }
      for (; ndx != 10; ndx++)
      {
         manufacturerString[ndx] = 0;
      }
      receiver_caps = pConfig->capabilities;
   }

#ifndef INCLUDE_MHEG_PVR
   if (receiver_caps & VC_SUPPORT_MHEG_PVR)
   {
      DPL1(("ERROR: PVR Extension not supported\n"));
      result = MHERR_UNSUPPORTED_EXTENSION;
   }
#endif
#ifndef INCLUDE_PVR_AU
   if (receiver_caps & VC_SUPPORT_MHEG_AU_PVR)
   {
      DPL1(("ERROR: PVR for Australia not supported\n"));
      result = MHERR_UNSUPPORTED_EXTENSION;
   }
#endif

   mheg_profile = pConfig->countryProfile;
#ifndef INCLUDE_NZ_PROFILE
   if (mheg_profile & CPROFILE_NZ)
   {
      DPL1(("ERROR: New Zealand profile not supported\n"));
      mheg_profile &= ~CPROFILE_NZ;
      if (pConfig->countryProfile != CPROFILE_ALL)
      {
         result = MHERR_UNSUPPORTED_PROFILE;
      }
   }
#endif
#ifndef INCLUDE_AU_PROFILE
   if (mheg_profile & CPROFILE_AU)
   {
      DPL1(("ERROR: Australia profile not supported\n"));
      mheg_profile &= ~CPROFILE_AU;
      if (pConfig->countryProfile != CPROFILE_ALL)
      {
         result = MHERR_UNSUPPORTED_PROFILE;
      }
   }
#endif
#ifndef INCLUDE_SA_PROFILE
   if (mheg_profile & CPROFILE_SA)
   {
      DPL1(("ERROR: South Africa profile not supported\n"));
      mheg_profile &= ~CPROFILE_SA;
      if (pConfig->countryProfile != CPROFILE_ALL)
      {
         result = MHERR_UNSUPPORTED_PROFILE;
      }
   }
#endif

#ifdef INCLUDE_DSM_FG
   if (mheg_profile & CPROFILE_SA)
   {
      if (pConfig->nvmSize < SA_NVM_MINIMUM_SIZE)
      {
         DPL1((" MHEG5 SA profile nvmSize  0x%x >= 0x%x ?\n", pConfig->nvmSize, SA_NVM_MINIMUM_SIZE));
         result = MHERR_BAD_NVM_SIZE;
      }
   }
   else if (mheg_profile & CPROFILE_AU)
   {
      if (pConfig->nvmSize < AU_NVM_MINIMUM_SIZE)
      {
         DPL1((" MHEG5 AU profile nvmSize  0x%x >= 0x%x ?\n", pConfig->nvmSize, AU_NVM_MINIMUM_SIZE));
         result = MHERR_BAD_NVM_SIZE;
      }
   }
#endif
   if (mheg_profile & CPROFILE_AU)
   {
      max_storage_file_len = AU_MAX_FILE_LEN;
   }
#ifdef INCLUDE_FREESAT
   if (mheg_profile & CPROFILE_FREESAT)
   {
      max_storage_file_len = FREESAT_MAX_FILE_LEN;
   }
#endif
   if (mheg_profile & CPROFILE_SA)
   {
      max_storage_file_len = SA_MAX_FILE_LEN;
   }

#ifndef INCLUDE_FREESAT
   if (mheg_profile & CPROFILE_FREESAT)
   {
      DPL1(("ERROR: Freesat profile not supported\n"));
      result = MHERR_UNSUPPORTED_PROFILE;
   }
#else
   /* Freesat is sensitive to specific WhoAmI */
   engine_strings[REV_STRING].whoami = FALSE;
#endif

#if (MHEG5_VER_MAJOR < 10)
   mheg5EngineString[6] = '0' + MHEG5_VER_MAJOR;
#else
   mheg5EngineString[6] = 'a' + MHEG5_VER_MAJOR - 0xa;
#endif
#if (MHEG5_VER_MINOR < 10)
   mheg5EngineString[7] = '0' + MHEG5_VER_MINOR;
#else
   mheg5EngineString[7] = 'a' + MHEG5_VER_MINOR - 0xa;
#endif
#if (MHEG5_VER_PATCH < 10)
   mheg5EngineString[8] = '0' + MHEG5_VER_PATCH;
#else
   mheg5EngineString[8] = 'a' + MHEG5_VER_PATCH - 0xa;
#endif

#ifndef CI_PLUS_ONLY

#if (DSMCC_VER_MAJOR < 10)
   dsmccEngineString[6] = '0' + DSMCC_VER_MAJOR;
#else
   dsmccEngineString[6] = 'a' + DSMCC_VER_MAJOR - 0xa;
#endif
#if (DSMCC_VER_MINOR < 10)
   dsmccEngineString[7] = '0' + DSMCC_VER_MINOR;
#else
   dsmccEngineString[7] = 'a' + DSMCC_VER_MINOR - 0xa;
#endif
#if (DSMCC_VER_PATCH < 10)
   dsmccEngineString[8] = '0' + DSMCC_VER_PATCH;
#else
   dsmccEngineString[8] = 'a' + DSMCC_VER_PATCH - 0xa;
#endif

#endif /*CI_PLUS_ONLY*/

   /* find length of revision string */
   engine_strings[REV_STRING].c_data = buildRevisionString;
   engine_strings[REV_STRING].c_len = strlen(buildRevisionString);

   return result;
}

U8BIT* MH5_GetManufacturerString(void)
{
   return (U8BIT *)manufacturerString;
}

U8BIT* MH5_GetEngineVersionString(void)
{
   return (U8BIT *)mheg5EngineString;
}

MHEG5Bool MH5_SupportInteractionChannel(void)
{
   if (receiver_caps & VC_SUPPORT_MHEG_INTERACTION_CHANNEL)
   {
      return MHEG5TRUE;
   }
   return MHEG5FALSE;
}

MHEG5Bool MH5_SupportICStreaming(void)
{
   if (receiver_caps & (VC_SUPPORT_MHEG_IC_STREAMING | VC_SUPPORT_MHEG_IC_STREAMING_HD))
   {
      return MHEG5TRUE;
   }
   return MHEG5FALSE;
}

MHEG5Bool MH5_SupportMhegProfile( E_MHEG_PROFILE profile )
{
   if (current_profile == PROFILE_BROADCAST &&
       (mheg_profile & profile))
   {
      return MHEG5TRUE;
   }
   return MHEG5FALSE;
}

MHEG5Bool MH5_SupportHDGraphics(void)
{
   return (MG_IsHdSupported()) ? MHEG5TRUE : MHEG5FALSE;
}

MHEG5Bool MH5_SupportHDVideo(void)
{
   return (!(receiver_caps & VC_HD_VIDEO_NOT_SUPPORTED)) ? MHEG5TRUE : MHEG5FALSE;
}

MHEG5Bool MH5_SupportNativeApplication(void)
{
#ifdef INCLUDE_NATIVE_APP
   if (receiver_caps & VC_SUPPORT_MHEG_NATIVE_APP)
   {
      return MHEG5TRUE;
   }
#endif
   return MHEG5FALSE;
}

MHEG5Bool MH5_SupportPVRExtension(void)
{
#ifdef INCLUDE_MHEG_PVR
   if (receiver_caps & VC_SUPPORT_MHEG_PVR)
   {
      return MHEG5TRUE;
   }
#endif
   return MHEG5FALSE;
}

MHEG5Bool MH5_SupportServiceInfoExtension(void)
{
#ifdef INCLUDE_SI_EXTENSION
   return MHEG5TRUE;
#else
   return MHEG5FALSE;
#endif
}

void MH5_SetCurrentProfile( E_ProfileId profile )
{
   current_profile = profile;
   if (profile == PROFILE_BROADCAST)
   {
   #ifdef INCLUDE_DLF
      MG_SetMaxFonts( 5 );
   #else
      MG_SetMaxFonts( 1 );
   #endif
   }
   else
   {
      /*CI Plus*/
      MG_SetMaxFonts( 2 );
   }
}

E_ProfileId MH5_GetCurrentProfile( void )
{
   return current_profile;
}

MHEG5Bool MH5_SupportFontClass( void )
{
#ifdef INCLUDE_DLF
   return MHEG5TRUE;
#else
   return MHEG5FALSE;
#endif
}

MHEG5Int MH5_MaxStorageFileLength( void )
{
   return max_storage_file_len;
}

MHEG5Bool MH5_GetEngineSupport( MHEG5String feature )
{
   const S_EngineSupportTable *table_item = support_table;
   MHEG5Bool answer;
   unsigned int values[3] = { 0, 0, 0 };
   unsigned int *p_value;
   int flen, ftype;

   assert( feature.len > 2 );
   assert( feature.data != NULL );

   if (feature.data[3] == OPEN_BRACKET || feature.len == 3)
   {
      flen = 3;
      while (table_item->short_name != NULL)
      {
         if (strncmp(table_item->short_name, (char *)feature.data, 3) == 0)
         {
            /* recognised short feature string */
            break;
         }
         table_item++;
      }
   }
   else
   {
      flen = 0;
      while (flen != feature.len &&
             feature.data[flen] != '\0' &&
             feature.data[flen] != OPEN_BRACKET)
         flen++;

      while (table_item->long_name != NULL)
      {
         if (strncmp(table_item->long_name, (char *)feature.data, flen) == 0)
         {
            /* recognised long feature string */
            break;
         }
         table_item++;
      }
   }
   switch (table_item->func_type)
   {
      case FUNC_TYPE_ERROR:
         answer = MHEG5FALSE;
         break;

      case FUNC_TYPE_NONE:
         if (table_item->function != NULL)
            answer = table_item->function( &feature );
         else
            answer = MHEG5TRUE;
         break;

      case FUNC_TYPE_STRING:
         if (feature.data[flen] != OPEN_BRACKET ||
             feature.data[feature.len - 1] != CLOSE_BRACKET)
         {
            answer = MHEG5FALSE;
         }
         else
         {
            assert( table_item->function != NULL );
            feature.data += flen + 1;
            feature.len -= flen + 2;
            answer = table_item->function( &feature );
         }
         break;

      default:
         feature.len--;
         ftype = table_item->func_type;
         assert( ftype >= FUNC_TYPE_ONEINT && ftype <= FUNC_TYPE_THRINT );
         if (feature.data[flen] != OPEN_BRACKET ||
             feature.data[feature.len] != CLOSE_BRACKET ||
             feature.len < flen + (ftype << 1))
         {
            answer = MHEG5FALSE;
         }
         else
         {
            assert( table_item->function != NULL );
            p_value = values;
            flen++; /*skip past open bracket*/
            while (flen != feature.len)
            {
               if (feature.data[flen] >= '0' && feature.data[flen] <= '9')
               {
                  *p_value = ((*p_value) * 10) + (feature.data[flen] - '0');
               }
               else if (feature.data[flen] == ',')
               {
                  ftype--;
                  if (ftype == 0)
                     break;             /*error*/
                  p_value++;
               }
               else
               {
                  break;
               }
               flen++;
            }
            if (flen != feature.len || ftype != 1)
            {
               /* had wrong number of params */
               answer = MHEG5FALSE;
            }
            else
            {
               assert( table_item->function != NULL );
               answer = table_item->function( values );
            }
         }
         break;
   }
   return answer;
}

MHEG5String MH5_WhoAmI(void)
{
   MHEG5String whoAmI;
   MHEG5Byte *pstr;
   unsigned int i;
   size_t engine_strings_total;
   size_t profile_strings_total;
   #ifdef INCLUDE_CI_PLUS
   MHEG5Boolean added[sizeof(profile_strings) / sizeof(*profile_strings)];
   #endif

   engine_strings_total = sizeof(engine_strings) / sizeof(*engine_strings);
   profile_strings_total = sizeof(profile_strings) / sizeof(*profile_strings);

   whoAmI.len = 0;
   for (i = 0; i < engine_strings_total; i++)
   {
      AddProfileStringLen(&engine_strings[i], &whoAmI.len);
   }

   /* Profile strings */
   for (i = 0; i != profile_strings_total; i++)
   {
      if (profile_strings[i].type & mheg_profile)
      {
         AddProfileStringLen(&profile_strings[i], &whoAmI.len);
         #ifdef INCLUDE_CI_PLUS
         added[i] = MHEG5TRUE;
         #endif
      }
      #ifdef INCLUDE_CI_PLUS
      else
      {
         added[i] = MHEG5FALSE;
      }
      #endif
   }

   #ifdef INCLUDE_CI_PLUS
   /* CI+ profile is added if the engine supports it */
   if (!added[PRF_NDX_CIPLUS])
   {
      AddProfileStringLen(&profile_strings[PRF_NDX_CIPLUS], &whoAmI.len);
   }
   #endif

   whoAmI.data = STR_DataAlloc( whoAmI.len );
   if (whoAmI.data != NULL)
   {
      pstr = whoAmI.data;
      for (i = 0; i < engine_strings_total; i++)
      {
         AppendProfileString(&engine_strings[i], &pstr);
      }

      for (i = 0; i != profile_strings_total; i++)
      {
         if (profile_strings[i].type & mheg_profile)
         {
            AppendProfileString(&profile_strings[i], &pstr);
         }
      }

      #ifdef INCLUDE_CI_PLUS
      if (!added[PRF_NDX_CIPLUS])
      {
         AppendProfileString(&profile_strings[PRF_NDX_CIPLUS], &pstr);
      }
      #endif

      --pstr;
      *pstr = '\0';
   }
   return whoAmI;
}

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



static MHEG5Bool UniversalEngineProfile(void *p_str)
{
   MHEG5String *pFeature = (MHEG5String *)p_str;
   MHEG5Bool answer = MHEG5FALSE;
   int i;

   if (pFeature->len == 1 && *pFeature->data == '2')
   {
      answer = MHEG5TRUE;
   }
   else
   {
      for (i = 0; i != ENGINE_STRING_TOTAL; i++)
      {
         if (engine_strings[i].c_len == pFeature->len &&
             memcmp(engine_strings[i].c_data, pFeature->data, pFeature->len) == 0)
         {
            answer = MHEG5TRUE;
            break;
         }
      }
      if (i == ENGINE_STRING_TOTAL)
      {
      #ifdef INCLUDE_CI_PLUS
         if (profile_strings[PRF_NDX_CIPLUS].c_len == pFeature->len &&
             memcmp(profile_strings[PRF_NDX_CIPLUS].c_data, pFeature->data, pFeature->len) == 0)
         {
            answer = MHEG5TRUE;
         }
         else
      #endif
         {
            /* always respond with TRUE for UK string */
            if (profile_strings[PRF_NDX_UK].c_len == pFeature->len &&
                memcmp(profile_strings[PRF_NDX_UK].c_data, pFeature->data, pFeature->len) == 0)
            {
               answer = MHEG5TRUE;
            }
            else
            {
               for (i = PRF_NDX_UK+1; i != PRF_TOTAL; i++)
               {
                  if ((profile_strings[i].type & mheg_profile) &&
                      profile_strings[i].c_len == pFeature->len &&
                      memcmp(profile_strings[i].c_data, pFeature->data, pFeature->len) == 0)
                  {
                     answer = MHEG5TRUE;
                     break;
                  }
               }
            }
         }
      }
   }
   return answer;
}

static MHEG5Bool HDExtension(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;

   switch (*((unsigned int *)p_val))
   {
      case 1:
         if (MG_IsHdSupported())
         {
            capable = MHEG5TRUE;
         }
         break;

      case 0:
         if (!(receiver_caps & VC_HD_VIDEO_NOT_SUPPORTED))
         {
            capable = MHEG5TRUE;
         }
      default:;
   }

   return capable;
}

static MHEG5Bool PVRFunction(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;

   switch (*((unsigned int *)p_val))
   {
      case 1:
      #ifdef INCLUDE_PVR_AU
         if (receiver_caps & VC_SUPPORT_MHEG_AU_PVR)
         {
            capable = MHEG5TRUE;
         }
      #endif /*INCLUDE_PVR_AU*/
         break;

      case 0:
      #ifdef INCLUDE_MHEG_PVR
         if (receiver_caps & VC_SUPPORT_MHEG_PVR)
         {
            capable = MHEG5TRUE;
         }
      #endif /*INCLUDE_MHEG_PVR*/
      default:;
   }
   return capable;
}

static MHEG5Bool ICProfile(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;

#ifdef INCLUDE_IC
   switch (*((unsigned int *)p_val))
   {
      case 1:
      case 2:
      case 3:
      case 4:
#ifdef INCLUDE_ICS
         if ((receiver_caps & VC_SUPPORT_MHEG_IC_STREAMING) &&
             (!MH5_SupportMhegProfile(CPROFILE_FREESAT)))
         {
            capable = MHEG5TRUE;
         }
#endif  /* INCLUDE_ICS */
         break;
      case 5:
#ifdef INCLUDE_ICS
         if ((receiver_caps & VC_SUPPORT_MHEG_IC_STREAMING_HD) &&
             (!MH5_SupportMhegProfile(CPROFILE_FREESAT)))
         {
            capable = MHEG5TRUE;
         }
#endif  /* INCLUDE_ICS */
         break;

      case 0:
         if (receiver_caps & VC_SUPPORT_MHEG_INTERACTION_CHANNEL)
         {
            capable = MHEG5TRUE;
         }
         break;

      default:;
   }
#endif /*INCLUDE_IC*/

   return capable;
}

static MHEG5Bool IPStreamingProfile(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;

   switch (*((unsigned int *)p_val))
   {
      case 1:
#if defined(INCLUDE_IC) && defined(INCLUDE_ICS) && defined(INCLUDE_FREESAT)
         if (receiver_caps & VC_SUPPORT_MHEG_IC_STREAMING)
         {
            capable = MHEG5TRUE;
         }
#endif /* IC, ICS and FREESAT */
         break;
      default:;
   }

   return capable;
}

static MHEG5Bool NonLinearPlaybackKeys(void *v)
{
   MHEG5Bool capable = MHEG5FALSE;

#ifdef INCLUDE_ICS
   if ((receiver_caps & VC_SUPPORT_MHEG_IC_STREAMING) &&
       (receiver_caps & VC_SUPPORT_NON_LINEAR_PLAYBACK_KEYS))
   {
      capable = MHEG5TRUE;
   }
#endif /*INCLUDE_ICS*/

   return capable;
}

static MHEG5Bool DownloadableFont(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;

#ifdef INCLUDE_DLF
   if (*((unsigned int *)p_val) == 10)
   {
      return MHEG5TRUE;
   }
#endif

   return capable;
}

static MHEG5Bool CommonScaling(unsigned int *p_uint)
{
   unsigned int scaleX, scaleY;
   MHEG5Bool capable = MHEG5TRUE;
   E_ScalingCapabilities scaling = MHEG5_SCALE_CAPS_QUARTER;
   scaleX = *p_uint;
   p_uint++;
   scaleY = *p_uint;
   switch (scaleX)
   {
      case 360:
         switch (scaleY)
         {
            case 288:
               /* MHEG5_SCALE_CAPS_QUARTER */
               break;
            case 576:
               scaling = MHEG5_SCALE_CAPS_STANDARD;
               break;
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
#ifdef INCLUDE_FREESAT
      case 480:
         switch (scaleY)
         {
            case 288:
               /* MHEG5_SCALE_CAPS_QUARTER */
               break;
            case 576:
               scaling = MHEG5_SCALE_CAPS_STANDARD;
               break;
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
#endif
      case 540:
         switch (scaleY)
         {
            case 288:
            case 576:
               scaling = MHEG5_SCALE_CAPS_STANDARD;
               break;
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
#ifdef INCLUDE_FREESAT
      case 640:
         switch (scaleY)
         {
            case 288:
            case 576:
               scaling = MHEG5_SCALE_CAPS_STANDARD;
               break;
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
#endif
      case 720:
         switch (scaleY)
         {
            case 288:
               scaling = MHEG5_SCALE_CAPS_STANDARD;
               break;
            case 576:
               /* MHEG5_SCALE_CAPS_QUARTER */
               break;
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
      case 960:
         switch (scaleY)
         {
            case 288:
            case 576:
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
      case 1080:
      case 1440:
         switch (scaleY)
         {
            case 288:
            case 576:
            case 1152:
               scaling = MHEG5_SCALE_CAPS_DOUBLE;
               break;
            default:
               capable = MHEG5FALSE;
         }
         break;
      default:
         capable = MHEG5FALSE;
   }

   if (capable == MHEG5TRUE)
   {
      if ((receiver_caps & VC_ONLY_SD_QUARTER_SCALING) &&
          (scaling != MHEG5_SCALE_CAPS_QUARTER))
      {
         capable = MHEG5FALSE;
      }
      else if ((receiver_caps & VC_ONLY_SD_STANDARD_SCALING) &&
               (scaling != MHEG5_SCALE_CAPS_QUARTER) &&
               (scaling != MHEG5_SCALE_CAPS_STANDARD))
      {
         capable = MHEG5FALSE;
      }
   }
   return capable;
}

static MHEG5Bool VideoScaling(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;
   unsigned int *p_uint = (unsigned int *)p_val;

   switch (*p_uint)
   {
      #ifdef INCLUDE_ICS
      case CHOOK_STREAM_IC:
      #endif
      case CHOOK_STREAM_NORMAL:
         p_uint++;
         capable = CommonScaling( p_uint );

      default:;
   }
   return capable;
}

static MHEG5Bool BitmapScaling(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;
   unsigned int *p_uint = (unsigned int *)p_val;

   switch (*p_uint)
   {
      case CHOOK_BITMAP_H264_IFRAME:
      case CHOOK_BITMAP_NORMAL_IFRAME:
         p_uint++;
         capable = CommonScaling( p_uint );

      default:;
   }
   return capable;
}

static MHEG5Bool BitmapFormat(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;

   switch (*((unsigned int *)p_val))
   {
      case CHOOK_BITMAP_NORMAL_IFRAME:
         capable = MHEG5TRUE;
         break;

      case CHOOK_BITMAP_PNG:
         capable = MHEG5TRUE;
         break;

      case CHOOK_BITMAP_JPG:
         capable = MHEG5TRUE;
         break;

      case CHOOK_BITMAP_H264_IFRAME:
         if (!(receiver_caps & VC_HD_VIDEO_NOT_SUPPORTED))
         {
            capable = MHEG5TRUE;
         }
         break;
      #ifdef INCLUDE_FREESAT
      case CHOOK_BITMAP_IMAGE_PLANE_IFRAME:
         if (MH5_SupportMhegProfile(CPROFILE_FREESAT))
         {
            capable = MHEG5TRUE;
         }
      #endif
      default:;
   }
   return capable;
}

static MHEG5Bool VideoDecodeOffset(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;
   unsigned int *p_uint = (unsigned int *)p_val;

   switch (*p_uint)
   {
      #ifdef INCLUDE_ICS
      case CHOOK_STREAM_IC:
      #endif
      case CHOOK_STREAM_NORMAL:
         p_uint++;
         if (*p_uint == 0 ||
             (*p_uint == 1 && !(receiver_caps & VC_NO_VIDEO_OFF_SCREEN)))
         {
            capable = MHEG5TRUE;
         }

      default:;
   }
   return capable;
}

static MHEG5Bool BitmapDecodeOffset(void *p_val)
{
   MHEG5Bool capable = MHEG5FALSE;
   unsigned int *p_uint = (unsigned int *)p_val;

   switch (*p_uint)
   {
      #ifdef INCLUDE_FREESAT
      case CHOOK_BITMAP_IMAGE_PLANE_IFRAME:
         if (!MH5_SupportMhegProfile(CPROFILE_FREESAT))
            break;
      #endif

      case CHOOK_BITMAP_H264_IFRAME:
      case CHOOK_BITMAP_NORMAL_IFRAME:
         p_uint++;
         if (*p_uint == 0 ||
             (*p_uint == 1 && !(receiver_caps & VC_NO_BITMAP_OFF_SCREEN)))
         {
            capable = MHEG5TRUE;
         }

      default:;
   }
   return capable;
}

static MHEG5Bool SceneCoordinateSystem(void *p_val)
{
   unsigned int *p_uint = (unsigned int *)p_val;
   MHEG5Bool capable = MHEG5FALSE;
   if (*p_uint == 720)
   {
      p_uint++;
      if (*p_uint == 576)
      {
         capable = MHEG5TRUE;
      }
   }
   return capable;
}

static MHEG5Bool SceneAspectRatio(void *p_val)
{
   unsigned int *p_uint = (unsigned int *)p_val;
   MHEG5Bool capable = MHEG5FALSE;
   switch (*p_uint)
   {
      case 4:
         p_uint++;
         if (*p_uint == 3)
         {
            capable = MHEG5TRUE;
         }
         break;

      case 16:
         p_uint++;
         if (*p_uint == 9)
         {
            capable = MHEG5TRUE;
         }
         break;

      default:;
   }
   return capable;
}

static MHEG5Bool SubtitlesAndGraphics(void *v)
{
   /* Set to TRUE if the receiver can present DVB subtitles and non-MPEG
    * MHEG5 Visibles simultaneously, without restriction (see [1] 6.5.1.1)  */
   if (receiver_caps & VC_SUBTITLES_NOT_SIMULTANEOUS)
   {
      return MHEG5FALSE;
   }
   return MHEG5TRUE;
}

static MHEG5Bool MultipleVideoStreams(void *p_val)
{
   if (*((unsigned int *)p_val) <= 1)
   {
      return MHEG5TRUE;
   }
   return MHEG5FALSE;
}

static MHEG5Bool MultipleAudioStreams(void *p_val)
{
   if (*((unsigned int *)p_val) <= 1)
   {
      return MHEG5TRUE;
   }
   return MHEG5FALSE;
}

#ifdef INCLUDE_DEBUG_PACKAGE

static MHEG5Bool DebugPackageSupport(void *p_val)
{
   return MHEG5TRUE;
}

#endif  /* INCLUDE_DEBUG_PACKAGE */

#ifdef INCLUDE_CONNECTED_TV
/*******************************************************************************
*@begin
* NAME: ConnectedTVExtension
*       Determines whether the system supports CTV. This support string
*       is defined in D-Book 7 part B section B4.3.1.1.
*
* Returns : True if the system supports it, else False.
*
* Parameter     Flow    Description
* ------------------------------------------------------------------------------
* p_val         IN      Pointer to value: 0
*
* Additional information:
*
*@end
*******************************************************************************/
static MHEG5Bool ConnectedTVExtension(void* p_val)
{
   if( *((unsigned int*)p_val) == 0)
   {
      if (receiver_caps & VC_SUPPORT_OIPF_BROWSER_PROFILE)
      {
         return MHEG5TRUE;
      }
   }
   return MHEG5FALSE;
}

/*******************************************************************************
*@begin
* NAME: ApplicationLaunchExtension
*       Determines whether the system supports CTV. This support string
*       is defined in D-Book 7 part B section B4.3.1.1.
*
* Returns : True if the system supports it, else False.
*
* Parameter     Flow    Description
* ------------------------------------------------------------------------------
* p_val         IN      Pointer to string value
*
* Additional information:
*
*@end
*******************************************************************************/
static MHEG5Bool ApplicationLaunchExtension(void* p_str)
{
   MHEG5String *pFeature = (MHEG5String *)p_str;
   MHEG5Bool answer;
   U8BIT buffer[128];
   BOOLEAN supported;

   if (pFeature->len == 1 && *pFeature->data == '0')
   {
      /* Shall return "true" for N=0 if the receiver supports
       * ApplicationLaunchExtension.
       */
      answer = MHEG5TRUE;
   }

   else if (pFeature->len == 2 && memcmp(pFeature->data, "-1", 2) == 0)
   {
      /* Shall return “true” for N=-1 if the receiver supports
       * ApplicationLaunch () from ApplicationLaunchExtension.
       */
      answer = MHEG5TRUE;
   }
   else
   {
      /* Check if the receiver supports launching applications whose
       * MIME type=N.
       */
      memcpy(buffer, pFeature->data, pFeature->len);
      buffer[pFeature->len] = 0;
      DVB_MhegGetMimeTypeSupport(buffer, &supported);
      if (supported)
      {
         answer = MHEG5TRUE;
      }
   }
   return answer;
}
#endif  /* INCLUDE_CONNECTED_TV */



static void AddProfileStringLen(S_PROFILE_STRING *profile_string,
   MHEG5Int *length)
{
   if (profile_string->c_len > 0 && profile_string->whoami)
   {
      if (*length > 0)
      {
         /* Space */
         (*length)++;
      }

      *length += profile_string->c_len;
   }
}

static void AppendProfileString(S_PROFILE_STRING *profile_string,
   MHEG5Byte **pString)
{
   if (profile_string->c_len > 0 && profile_string->whoami)
   {
      memcpy(*pString, profile_string->c_data, profile_string->c_len);
      (*pString) += profile_string->c_len;
      *(*pString) = ' ';
      (*pString)++;
   }
}

U8BIT* MH5_GetUserAgent(void)
{
   static char *uk_mheg = "UK-MHEG/1285";
   static BOOLEAN first = TRUE;
   U8BIT *manufacturer;
   U8BIT *mheg5_engine;
   int offset;

   if (first)
   {
      strcpy(user_agent, uk_mheg);
      offset = strlen(uk_mheg);

      user_agent[offset] = ' ';
      ++offset;

      manufacturer = MH5_GetManufacturerString();
      memcpy(user_agent + offset, manufacturer, 6);
      offset += 6;
      user_agent[offset] = '/';
      offset += 1;
      memcpy(user_agent + offset, manufacturer + 6, 3);
      offset += 3;

      user_agent[offset] = ' ';
      ++offset;

      mheg5_engine = MH5_GetEngineVersionString();
      memcpy(user_agent + offset, mheg5_engine, 6);
      offset += 6;
      user_agent[offset] = '/';
      offset += 1;
      memcpy(user_agent + offset, mheg5_engine + 6, 3);
      offset += 3;

      user_agent[offset] = '\0';
   }

   return (U8BIT *)user_agent;
}