mh5prgs.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * 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 <stdlib.h>             /* for RANDOM function      */
#include "mh5prgs.h"
#include "mh5object.h"          /* for actions              */
#include "mh5variable.h"        /* for actions              */
#include "mh5date.h"            /* for Davic-Date functions */
#include "mh5memory.h"          /* for CastToObjectRef      */
#include "mh5display.h"         /* for VideoToGraphics      */
#include "mh5fileorm.h"
#include "mh5group.h"
#include "mh5debug.h"
#include "mh5misc.h"
#include "mh5final.h"
#include "mh5queue.h"
#include "mh5profile.h"
#include "mh5support.h"
#include "mh5keypress.h"
#include "mh5control.h"
#include "dvb_audio.h"
#include "dvb_video.h"
#include "mg_video.h"
#include "dvb_misc.h"

#if defined(INCLUDE_MHEG_PVR) || defined(INCLUDE_PVR_AU)
#include "dvb_pvr.h"
#include "mh5parse.h"
#endif

#ifdef INCLUDE_SA_PROFILE
#include "dvb_native.h"
#endif

#ifdef INCLUDE_IC
#include "mh5hfs.h"
#include "mh5parse.h"
#include "mh5cookies.h"
#ifdef INCLUDE_ICS
#include "mh5streamer.h"
#endif
#endif

#ifndef _WIN32_WCE
#include <string.h>
#else
#include "mh5base.h"
#endif

#ifdef INCLUDE_SI_EXTENSION
#include "dvb_service.h"
#endif

#ifdef INCLUDE_TPS
#include "mh5tps.h"
#endif

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


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

typedef struct ResidentProgramTableEntry_struct
{
   const char *name;
   MHEG5ErrorCode (*startFunction)(MHEG5Program *);
   void (*stopFunction)(MHEG5Program *);
} ResidentProgramTableEntry_t;

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

#if defined(INCLUDE_MHEG_PVR) || defined(INCLUDE_PVR_AU)
static MHEG5Program *pvr_program = NULL;
#endif
#if defined(INCLUDE_IC) && defined(INCLUDE_ICS)
static MHEG5Program *guidance_program = NULL;
#endif
#if defined(INCLUDE_CONNECTED_TV)
static MHEG5Program *application_launch_program = NULL;
#endif
/*---local function definitions----------------------------------------------*/

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


/*
     Program Implementations
 */


/*
 *   3.10.2 Date and Time functions
 *
 *   3.10.2.1 DAVIC Day, Date & Time functions
 *
 *   Some of these functions return textual information. In all cases this shall
 *   use the UTF-8 representation of character codes selected from the character
 *   repertoire in Table 5-18, "Set of characters supported by the engine," on
 *   page 5-23.
 */

static MHEG5ErrorCode MHEG5prgGetCurrentDate(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *dateVar, *timeVar;
   S32BIT day = 0, time = 0;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &dateVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &timeVar);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!dateVar) || (dateVar->clazz != MHEG5INTEGERVARIABLE) ||
       (!timeVar) || (timeVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5getDate((S32BIT *)&day, (S32BIT *)&time);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) dateVar)->value = day;
   ((MHEG5IntegerVariable *) timeVar)->value = time;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "GetCurrentDate( %ld, %ld )", day, time);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgFormatDate(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *osVar;
   MHEG5Int day, time;
   MHEG5String format;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &format, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &day);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &time);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &osVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!osVar) || (osVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) osVar)->value);
   ((MHEG5OctetStringVariable *) osVar)->value =
      MHEG5formatDate(format, day, time);
  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "FormatDate( ");
      MHEG5stringTrace( format, buff, 0, 120 );
      DBG_PRINTF("%s, %ld, %ld, ", buff, day, time);
      buff[0] = 0;
      MHEG5stringTrace(((MHEG5OctetStringVariable *) osVar)->value, buff, 0, 120 );
      DBG_PRINTF("%s)", buff);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetDayOfWeek(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intVar;
   MHEG5Int day = 0;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &day);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &intVar);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intVar) || (intVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) intVar)->value = MHEG5getDayOfWeek(day);

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "GetDayOfWeek( %ld, %ld )", day, ((MHEG5IntegerVariable *) intVar)->value);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

/* 3.10.3 Random Number function */

static MHEG5ErrorCode MHEG5prgRandom(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *rndVar;
   MHEG5Int intVal = 0;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &intVal);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &rndVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!rndVar) || (rndVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   /* Check the value of intVar passed in. */
   if (intVal < 1)
   {
      /* Behaviour for this condition is not specified. Force program to
       * always return 1.
       */
      intVal = 1;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) rndVar)->value = MHEG5random() / (0xffffffff / intVal);
   ((MHEG5IntegerVariable *) rndVar)->value++;

   if (((MHEG5IntegerVariable *) rndVar)->value < 1)
   {
      ((MHEG5IntegerVariable *) rndVar)->value = 1;
   }
   if (((MHEG5IntegerVariable *) rndVar)->value > intVal)
   {
      ((MHEG5IntegerVariable *) rndVar)->value = intVal;
   }

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "Random( %ld, %ld )", intVal, ((MHEG5IntegerVariable *) rndVar)->value);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

/* 3.10.4 Type Conversion Functions */

static MHEG5ErrorCode MHEG5prgCastToContentRef(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *osVar = 0;
   MHEG5String s1;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &s1, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &osVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!osVar) || (osVar->clazz != MHEG5CONTENTREFVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }
   TRACE(TEVNTS, (" s=%.*s", (int)s1.len, s1.data))
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   MHEG5stringDestruct(&((MHEG5ContentVariable *) osVar)->contentData);
   ((MHEG5ContentVariable *) osVar)->contentData = MHEG5stringCopy(s1);
  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "CastToContentRef( ");
      MHEG5stringTrace( s1, buff, 0, 120 );
      DBG_PRINTF("%s )", buff);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

/* mh5variable.h is included at the top of this file and yet the ST compiler still does not
 * know about the function MHEG5objRefValueDestruct unless its definition is placed here
 * ??? - beats me!
 */
extern void MHEG5objRefValueDestruct(MHEG5ObjectRefVariable *objRef);

static MHEG5ErrorCode MHEG5prgCastToObjectRef(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *obVar = 0;
   MHEG5String s1;
   MHEG5Int id;
   MHEG5Bool result = MHEG5TRUE;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString(nextParam, &s1, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveGenericInteger(nextParam, &id);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &obVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!obVar) || (obVar->clazz != MHEG5OBJECTREFVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5objRefStoreString((MHEG5ObjectRefVariable *)obVar, s1, id );

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "CastToObjectRef( ");
      MHEG5stringTrace( s1, buff, 0, 120 );
      DBG_PRINTF("%s, %ld ) result=%s", buff, id, result ? "true" : "false");
   }
  #endif
   ((MHEG5BooleanVariable *) callVar)->value = result;

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgCastToStringInt(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *objIdVar = 0, *oStrVar = 0;
   MH5GroupRef gref;
   MHEG5String sout;
   MHEG5Int id;
   MHEG5Bool result = MHEG5TRUE;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericORefProper(nextParam, &gref, &id);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &oStrVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &objIdVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!oStrVar) || (oStrVar->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!objIdVar) || (objIdVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   TRACE(TEVNTS, (" id=%ld gref.len=%d", id, (int)gref.len))

   if (gref.len == 0)
   {
      if (gref.ptr.group != NULL)
      {
         /* by definition, this group must exist */
         sout.len = gref.ptr.group->groupName.len;
         sout.data = STR_DataAlloc( sout.len );
         memcpy( sout.data, gref.ptr.group->groupName.data, sout.len + 1 );
      }
      else
      {
         /* Null string for the name, so cannot exist */
         sout.len = 0;
         sout.data = 0;
      }
   }
   else
   {
      sout.len = gref.len;
      sout.data = STR_DataAlloc( sout.len );
      memcpy( sout.data, gref.ptr.name, gref.len + 1 );
   }

   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) oStrVar)->value);
   ((MHEG5OctetStringVariable *) oStrVar)->value = sout;
   ((MHEG5IntegerVariable *) objIdVar)->value = id;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "CastToStringInt( ");
      MHEG5stringTrace( sout, buff, 0, 120 );
      DBG_PRINTF("%s, %ld ) result=%s", buff, id, result ? "true" : "false");
   }
  #endif
   ((MHEG5BooleanVariable *) callVar)->value = result;

   return MHEG5ERR_NOERROR;
}

/*
 *  3.10.5 UK String manipulation functions
 *
 *  These resident programs are for the manipulation of OctetStrings, and octet
 *  values in the range 0x00...0xFF are valid and particular values have no
 *  special meaning. In particular the value zero does not indicate a string
 *  termination. The functions are similar to those defined by DAVIC [51] but
 *  with more exact definitions and consideration of the UK string formats. In
 *  summary the issues addressed are:
 *
 *      * Treatment of mark-up codes & multi-byte UTF-8 characters within
 *        strings. Neither is given special treatment. I.e. they are just
 *        considered as octets within the string. The "octetLengthSearch" bytes
 *        per character switch is not required.
 *
 *      * Alignment to MHEG-5 corrigenda. I.e. "Output parameters and
 *        Input/Output Parameters shall be encoded as follows: The
 *        IndirectReference option in GenericBoolean, GenericInteger,
 *        GenericOctetString, GenericObjectReference, and GenericContentReference
 *        respectively shall be encoded."
 *
 *  Range of string index values
 *
 *      The first octet of any string has is referenced by an index of 1.
 *
 *      For the input indices beginExtract, endExtract and startIndex the
 *      following bounds checking shall be observed:
 *
 *          * If the index is < 1 it shall be treated as 1.
 *
 *          * If the index is > greater than the string length then it shall be
 *          treated as string length.
 *
 */

static MHEG5ErrorCode MHEG5prgGetStringLength(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intVar;
   MHEG5String osVal;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &osVal, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &intVar);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intVar) || (intVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) intVar)->value = osVal.len;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "GetStringLength( ");
      MHEG5stringTrace( osVal, buff, 0, 120 );
      DBG_PRINTF("%s, %ld )", buff, osVal.len);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetSubString(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *osVar = 0;
   MHEG5String input;
   MHEG5Int begin = 0, end = 0;
   MHEG5String sout = {0, 0};
   MHEG5Bool invalidString;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString(nextParam, &input, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveGenericInteger(nextParam, &begin);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericInteger(nextParam, &end);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &osVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!osVar) || (osVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "GetSubString( ");
      MHEG5stringTrace( input, buff, 0, 120 );
      DBG_PRINTF("%s, %ld, %ld, ", buff, begin, end);
   }
  #endif

   if (input.len > 0)
   {
      begin = (begin > input.len) ? input.len : begin;
      begin = (begin < 1) ? 1 : begin;
      end = (end > input.len) ? input.len : end;
      end = (end < 1) ? 1 : end;

      if (begin <= end)
      {
         begin--;
         sout.data = STR_DataAlloc( end - begin );
         if (sout.data)
         {
            while (begin != end)
            {
               sout.data[sout.len] = input.data[begin];
               sout.len++;
               begin++;
            }
         }
      }
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) osVar)->value);
   ((MHEG5OctetStringVariable *) osVar)->value = sout;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      buff[0] = 0;
      MHEG5stringTrace( sout, buff, 0, 120 );
      DBG_PRINTF("%s )", buff);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgSearchSubString(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intVar = 0;
   MHEG5String string, searchString;
   MHEG5Int start = 0, i = 0, rc = -1, j = 0;
   MHEG5Bool invalidString;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString(nextParam, &string, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveGenericInteger(nextParam, &start);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString(nextParam, &searchString, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5resolveORef(nextParam, &intVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intVar) || (intVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   start = (start > string.len) ? string.len : start;
   start = (start < 1) ? 1 : start;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "SearchSubString( ");
      MHEG5stringTrace( string, buff, 0, 120 );
      DBG_PRINTF("%s, %ld, ", buff, start);
      MHEG5stringTrace( searchString, buff, 0, 120 );
      DBG_PRINTF(buff);
   }
  #endif

   if (searchString.len == 0)
   {
      if (string.len == 0)
      {
         /* Both searchString and string are empty. This is a special case, which
          * returns -1, to avoid returning an index out of the string.
          */
         rc = -1;
      }
      else
      {
         /* String to search for is empty. Always match an empty string, so
          * return the start position.
          */
         rc = start;
      }
   }
   else
   {
      i = (start - 1);
      while (i < string.len)
      {
         if (string.data[i] == searchString.data[j])
         {
            i++;
            if (j == 0)
            {
               rc = i;
            }
            j++;
            if (j >= searchString.len)
            {
               break;
            }
         }
         else
         {
            i = i - j + 1;
            j = 0;
         }
      }
      if (j < searchString.len)
      {
         /* Didn't match the string */
         rc = -1;
      }
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) intVar)->value = rc;
  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(", %ld )", rc);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgSearchAndExtractSubString(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intVar = 0, *osVar = 0;
   MHEG5String string, searchString;
   MHEG5String sout = {0, 0};
   MHEG5Int start = 0, i = 0, rc = -1, j = 0;
   MHEG5Bool invalidString;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString(nextParam, &string, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveGenericInteger(nextParam, &start);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString( nextParam, &searchString, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveORef(nextParam, &osVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &intVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intVar) || (intVar->clazz != MHEG5INTEGERVARIABLE) ||
       (!osVar) || (osVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   start = (start > string.len) ? string.len : start;
   start = (start < 1) ? 1 : start;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "SearchAndExtractSubString( ");
      MHEG5stringTrace( string, buff, start - 1, 60 );
      DBG_PRINTF(buff);
      DBG_PRINTF(", %ld, ", start);
      buff[0] = 0;
      MHEG5stringTrace( searchString, buff, 0, 120 );
      DBG_PRINTF(buff);
      DBG_PRINTF(" l=%ld", searchString.len);
   }
  #endif

   if (searchString.len == 0)
   {
      if (string.len == 0)
      {
         /* Both searchString and string are empty. This is a special case, which
          * returns -1, to avoid returning an index out of the string.
          */
         rc = -1;
      }
      else
      {
         /* String to search for is empty. Always match an empty string, so
          * return the start position.
          */
         rc = start;
      }
   }
   else
   {
      i = (start - 1);
      while (i < string.len)
      {
         if (string.data[i] == searchString.data[j])
         {
            i++;
            if (j == 0)
            {
               rc = i;
            }
            j++;
            if (j >= searchString.len)
            {
               /* String found */
               break;
            }
         }
         else
         {
            i = i - j + 1;
            j = 0;
            rc = -1;
         }
      }

      if (j < searchString.len)
      {
         /* Didn't match the string */
         rc = -1;
      }
   }

   if (rc == start)
   {
      /* No string to copy */
      rc += searchString.len;
   }
   else if (rc > start)
   {
      /* Copy string from startIndex to stringPosition */
      sout.data = STR_DataAlloc( rc - start );
      if (sout.data)
      {
         i = (start - 1);
         while (i < (rc - 1))
         {
            sout.data[sout.len] = string.data[i++];
            sout.len++;
         }
      }
      rc += searchString.len;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) intVar)->value = rc;
   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) osVar)->value);
   ((MHEG5OctetStringVariable *) osVar)->value = sout;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, ", ");
      MHEG5stringTrace( sout, buff, 0, 120 );
      DBG_PRINTF("%s, %ld )", buff, rc);
   }
  #endif
   return MHEG5ERR_NOERROR;
}

/* 3.10.6 Service Selection
 *
 * The text here is based on DAVIC 14B94R10 [52].
 */

static MHEG5ErrorCode MHEG5prgSI_GetServiceIndex(MHEG5Program *program)
{
   /*
       Can not emulate this one
    */
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intVar = 0;
   MHEG5String s1;
   MHEG5Int rc = -1;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, &s1, &invalidString);

   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5resolveORef(nextParam, &intVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intVar) || (intVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   /* check whether DVB URL is available in current stream: */
   rc = MHEG5GetServiceIndex(&s1);

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) intVar)->value = rc;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "SI_GetServiceIndex( ");
      MHEG5stringTrace( s1, buff, 0, 120 );
      DBG_PRINTF("%s, %ld )", buff, rc);
   }
  #endif

   return MHEG5ERR_NOERROR;
}

#ifndef CI_PLUS_ONLY

static MHEG5ErrorCode MHEG5prgSI_TuneIndex(MHEG5Program *program)
{
   /*
       Can not emulate this one
    */
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;

   assert(program);
   nextParam = MHEG5resolveORef( program->parameter, &callVar );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(nextParam, &serviceIndex);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5TuneIndex(serviceIndex);

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SI_TuneIndex( %ld )", serviceIndex);
   }
  #endif

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgSI_TuneIndexInfo(MHEG5Program *program)
{
   /*
       Can not emulate this one
    */
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int tuneInfo;

   assert(program);
   nextParam = MHEG5resolveORef( program->parameter, &callVar );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(nextParam, &tuneInfo);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5TuneIndexInfo(tuneInfo);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SI_TuneIndexInfo( %ld )", tuneInfo);
   }
  #endif

   return MHEG5ERR_NOERROR;
}

#endif /* CI_PLUS_ONLY*/

static MHEG5ErrorCode MHEG5prgSI_GetBasicSI(MHEG5Program *program)
{
   /*
       Can not emulate this one
    */
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *networkID = 0;
   MHEG5Root *origNetworkID = 0;
   MHEG5Root *transportStreamID = 0;
   MHEG5Root *serviceID = 0;
   MHEG5Int serviceIndex;
   MHEG5Int networkIDVal;
   MHEG5Int origNetworkIDVal;
   MHEG5Int transportStreamIDVal;
   MHEG5Int serviceIDVal;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &networkID);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &origNetworkID);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &transportStreamID);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &serviceID);

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!networkID) || (networkID->clazz != MHEG5INTEGERVARIABLE)) ||
       ((!origNetworkID) || (origNetworkID->clazz != MHEG5INTEGERVARIABLE)) ||
       ((!transportStreamID) || (transportStreamID->clazz != MHEG5INTEGERVARIABLE)) ||
       ((!serviceID) || (serviceID->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   /* check whether DVB URL is available in current stream: */
   MHEG5GetBasicSI(serviceIndex, &networkIDVal, &origNetworkIDVal,
      &transportStreamIDVal, &serviceIDVal);
   ((MHEG5IntegerVariable *) networkID)->value = networkIDVal;
   ((MHEG5IntegerVariable *) origNetworkID)->value = origNetworkIDVal;
   ((MHEG5IntegerVariable *) transportStreamID)->value = transportStreamIDVal;
   ((MHEG5IntegerVariable *) serviceID)->value = serviceIDVal;
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SI_GetBasicSI( %ld, %ld, %ld, %ld, %ld )",
         serviceIndex, networkIDVal, origNetworkIDVal, transportStreamIDVal, serviceIDVal );
   }
  #endif

   return MHEG5ERR_NOERROR;
}

static void ProgramCompleted( MHEG5Program *program )
{
   /* Disable the call to stop function since program has finished executing */
   program->stopFunc = NULL;

   if (program->forked)
   {
      if (!program->ingredient.root.runningStatus)
      {
         /* A forked program has finished before the activation action
          * completed. By clearing forkSucceededValue we indicate that
          * the program has finished. This will be detected after the
          * activation completes and the deactivation and AsyncStopped
          * event will occur then.
          */
         program->forkSucceededValue = NULL;
      }
      else
      {
         /* Perform the final steps of the Fork action when the execution of
          * a program finishes:
          *
          *  3. Apply the Deactivation behaviour.
          *  4. Generate an AsynchStopped event.
          */
         MHEG5ingredientDeactivate(&program->ingredient);
         MHEG5sendEvent((MHEG5Root *)program, MHEG5ASYNCHSTOPPED, 0);
      }
   }
   else
   {
      TRACE(TFILE, (""))
      /* For called programs, re-enable engine event processing */
      MHEG5enableEventProcessing(MHEG5TRUE);
   }
}

/*
 *   3.10.7 Checking References
 *
 *   This set of resident programs can be used by applications to determine if
 *   objects are available before embarking on a course of action that requires
 *   the objects. The tests serve two functions, first they confirm that the
 *   "file" implied by the reference is available in the file system, secondly
 *   the test confirms that, where practical, the file has been brought into the
 *   receiver’s memory. For the purposes of these Resident Programs the minimum
 *   condition under which a "file" may be considered as available is when the
 *   IOR of the corresponding File object has been extracted from the relevant
 *   parent Directory (or ServiceGateway) object. Further specification work will
 *   be required to enable application authors to predict the size of objects
 *   that can reliably be brought into memory by these functions. An authoring
 *   example is provided under 9.11 on page 9-10 which illustrates the expected
 *   use of these resident programs.
 */

static void clearOrmHandle(MHEG5Program *program)
{
   if (program->ingredient.ormHandle != NULL)
   {
      MHEG5FileOrmClear( program->ingredient.ormHandle );
      program->ingredient.ormHandle = NULL;
   }
}

static void checkRefGood( void *userData, S_CONTENT *content )
{
   MHEG5Program *program = (MHEG5Program *)userData;

   *((MHEG5Bool *)(program->resultValue)) = MHEG5TRUE;
   *(program->forkSucceededValue) = MHEG5TRUE;

   #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(", exists)");
   }
   #endif

   ProgramCompleted( program );
}

static void checkRefFail( void *userData )
{
   MHEG5Program *program = (MHEG5Program *)userData;

   *((MHEG5Bool *)(program->resultValue)) = MHEG5FALSE;
   *(program->forkSucceededValue) = MHEG5TRUE;

   #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(", not avl)");
   }
   #endif

   ProgramCompleted( program );
}

static MHEG5ErrorCode MHEG5prgCheckContentRef(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *rcVar1 = 0, *rcVar2 = 0;
   MHEG5String cref_data;
   MHEG5Bool cref_referenced = MHEG5FALSE;
   MHEG5Bool valid = MHEG5FALSE;
   MHEG5BooleanVariable *rc1;
   MHEG5ContentVariable *rc2;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericCRef(nextParam, &cref_data, &cref_referenced, &valid);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &rcVar1);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &rcVar2);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!rcVar1) || (rcVar1->clazz != MHEG5BOOLEANVARIABLE) ||
       (!rcVar2) || (rcVar2->clazz != MHEG5CONTENTREFVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   rc1 = (MHEG5BooleanVariable *) rcVar1;
   rc2 = (MHEG5ContentVariable *) rcVar2;

   if (rc2->contentData.data != cref_data.data)
   {
      MHEG5stringDestruct(&rc2->contentData);
      rc2->contentData = MHEG5stringCopy(cref_data);
   }
   rc1->value = MHEG5FALSE;

   /* Set the forkSuceeded to default to FALSE */
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;

   program->resultValue = &rc1->value;
   program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

   /* For a called program disable event processing until the program ends */
   if (!program->forked)
   {
      TRACE(TFILE, (""))
      MHEG5enableEventProcessing(MHEG5FALSE);
   }

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "CheckContentRef( ");
      MHEG5stringTrace( cref_data, buff, 0, 120 );
      DBG_PRINTF("%s, ", buff);
   }
  #endif

   if (!cref_referenced)
   {
      checkRefFail( program );
   }
   else
   {
      program->ingredient.ormHandle =
         MHEG5FileOrmGet( cref_data, FRP_EXISTS | FRP_CACHE_DEFAULT,
            program, checkRefGood, checkRefFail );
   }
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgCheckGroupIDRef(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *rcVar1 = 0, *rcVar2 = 0;
   MHEG5BooleanVariable *rc1;
   MHEG5ObjectRefVariable *out;
   MH5GroupRef gref;
   MHEG5Int id;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericORefProper(nextParam, &gref, &id);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &rcVar1);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &rcVar2);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!rcVar1) || (rcVar1->clazz != MHEG5BOOLEANVARIABLE) ||
       (!rcVar2) || (rcVar2->clazz != MHEG5OBJECTREFVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   rc1 = (MHEG5BooleanVariable *) rcVar1;
   out = (MHEG5ObjectRefVariable *) rcVar2;

   MHEG5objRefStoreValue( out, gref, id );
   if (gref.len == 0)
   {
      if (gref.ptr.group != NULL)
      {
         /* by definition, this group must exist */
         rc1->value = MHEG5TRUE;
      }
      else
      {
         /* Null string for the name, so cannot exist */
         rc1->value = MHEG5FALSE;
      }
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   }
   else if (out->valueGrp.data == NULL)
   {
      rc1->value = MHEG5FALSE;
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   }
   else
   {
      rc1->value = MHEG5FALSE;

      /* Set the forkSuceeded to default to FALSE */
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;

      program->resultValue = &rc1->value;
      program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

      /* For a called program disable event processing until the program ends */
      if (!program->forked)
      {
         TRACE(TFILE, (""))
         MHEG5enableEventProcessing(MHEG5FALSE);
      }

     #ifdef TRACING
      if (mheg_trace_debug & (TACTIONS | TEVNTS))
      {
         char buff[256];
         strcpy(buff, T_NL "CheckGroupIDRef( ");
         MHEG5stringTrace( out->valueGrp, buff, 0, 120 );
         DBG_PRINTF("%s,%ld ", buff, id);
      }
     #endif

      program->ingredient.ormHandle =
         MHEG5FileOrmGet( out->valueGrp, FRP_EXISTS | FRP_CACHE_DEFAULT,
            program, checkRefGood, checkRefFail );
   }
   return MHEG5ERR_NOERROR;
}

#ifndef CI_PLUS_ONLY

static MHEG5ErrorCode MHEG5prgGetBootInfo(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *bootInfo = 0, *infoResult = 0;
   MHEG5Bool infoResultVal;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &infoResult);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &bootInfo);

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!infoResult) || (infoResult->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!bootInfo) || (bootInfo->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) bootInfo)->value);
   ((MHEG5OctetStringVariable *) bootInfo)->value = MHEG5GetBootInfo(&infoResultVal);
   ((MHEG5BooleanVariable *) infoResult)->value = infoResultVal;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "GetBootInfo( ");
      MHEG5stringTrace(((MHEG5OctetStringVariable *) bootInfo)->value, buff, 0, 120 );
      DBG_PRINTF("%s, %s )", infoResultVal ? "true" : "false", buff);
   }
  #endif

   return MHEG5ERR_NOERROR;
}

#endif  /* !CI_PLUS_ONLY */

/* 3.10.8 Presentation information */

#ifndef CI_PLUS_ONLY

static MHEG5ErrorCode MHEG5prgVideoToGraphics(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *graphicsX = 0, *graphicsY = 0;
   MHEG5Int videoXVal, videoYVal, graphicsYVal, graphicsXVal;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &videoXVal);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &videoYVal);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &graphicsX);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &graphicsY);

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!graphicsX) || (graphicsX->clazz != MHEG5INTEGERVARIABLE)) ||
       ((!graphicsY) || (graphicsY->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MG_DisplayVideoToGraphics(videoXVal, videoYVal, &graphicsXVal, &graphicsYVal);

   ((MHEG5IntegerVariable *) graphicsX)->value = graphicsXVal;
   ((MHEG5IntegerVariable *) graphicsY)->value = graphicsYVal;
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "VideoToGraphics( %ld, %ld, %ld, %ld )",
         videoXVal, videoYVal, graphicsYVal, graphicsXVal );
   }
  #endif

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgSetWidescreenAlignment(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int modeVal;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5resolveGenericInteger( nextParam, &modeVal);

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   if (modeVal == 1)
   {
      /* centre cutout */
      DVB_MhegSetVideoAlignment(ASPECT_MODE_4_3);
   }
   else if (modeVal == 2)
   {
      /* letter box */
      DVB_MhegSetVideoAlignment(ASPECT_MODE_16_9);
   }
#ifdef INCLUDE_FREESAT
   else if (modeVal == 0)
   {
      DVB_MhegSetVideoAlignment(ASPECT_MODE_AUTO);
   }
#endif

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SetWidescreenAlignment( %ld )", modeVal );
   }
  #endif

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgSetSubtitleMode(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Bool onVal = 0;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericBoolean(nextParam, &onVal);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   MG_SetSubtitleMode(onVal);

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SetSubtitleMode( %ld )", onVal );
   }
  #endif

   return MHEG5ERR_NOERROR;
}

#endif /* CI_PLUS_ONLY*/

#ifdef INCLUDE_NATIVE_APP

static MHEG5ErrorCode MHEG5prgSetBroadcasterInterruptions(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Bool enable = 0;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericBoolean(nextParam, &enable);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   MHEG5PromotionalLinkControl(enable ? TRUE : FALSE);

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SetBroadcasterInterruptions( %ld )", enable );
   }
  #endif

   return MHEG5ERR_NOERROR;
}

#endif /*INCLUDE_NATIVE_APP*/

static MHEG5ErrorCode MHEG5prgGetDisplayAspectRatio(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *aspectRatioVal = 0;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &aspectRatioVal);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!aspectRatioVal) || (aspectRatioVal->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) aspectRatioVal)->value = MHEG5GetDisplayAspectRatio();

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "GetDisplayAspectRatio( %ld )", ((MHEG5IntegerVariable *) aspectRatioVal)->value );
   }
  #endif

   return MHEG5ERR_NOERROR;
}

/* 3.10.9 Conditional Access */

#ifdef COMMON_INTERFACE

static void ciSendMessageCallback(void *userData, MHEG5String output, MHEG5Bool success)
{
   MHEG5Program *program;

   /* Cast userData to an (MHEG5Program *) */
   program = (MHEG5Program *)userData;

   /* Check whether message was sent successfully */
   if (success)
   {
      *((MHEG5String *)(program->resultValue)) = MHEG5stringCopy(output);
      *(program->forkSucceededValue) = MHEG5TRUE;
   }
   else
   {
      /* An error condition ocurred - forkSucceeded defaults to FALSE, so do
       * nothing here.
       */
   }
   ProgramCompleted( program );
}

#endif /*COMMON_INTERFACE*/

static MHEG5ErrorCode MHEG5prgCI_SendMessage(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *osVar = 0;
   MHEG5String input;
   MHEG5OctetStringVariable *output;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, &input, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5resolveORef(nextParam, &osVar);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!osVar) || (osVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }
   output = (MHEG5OctetStringVariable *) osVar;
   MHEG5stringDestruct(&output->value);

   /* Set the forkSuceeded to default to FALSE */
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;

   program->resultValue = &output->value;
   program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

   /* For a called program disable event processing until the program ends */
   if (!program->forked)
   {
      TRACE(TFILE, (""))
      MHEG5enableEventProcessing(MHEG5FALSE);
   }

   /* Cannot stop CI_SendMessage */
   assert( program->ingredient.ormHandle == NULL );

#ifdef COMMON_INTERFACE
   if (MHEG5FileOrmSendCiMessage(input, ciSendMessageCallback, program) == MHEG5FALSE)
#endif
   {
      /* If no DVB CI Application MMI session exists then the resident
       * program shall have no effect.
       */
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
      if (!program->forked)
      {
         TRACE(TFILE, (""))
         MHEG5enableEventProcessing(MHEG5TRUE);
      }
   }

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "CI_SendMessage( ");
      MHEG5stringTrace( input, buff, 0, 120 );
      strcat(buff, ", n/a )");
      DBG_PRINTF(buff);
   }
  #endif

   return MHEG5ERR_NOERROR;
}

/* 3.10.10 Developer Utilities */
static MHEG5ErrorCode MHEG5prgWhoAmI(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *identVar = 0;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &identVar);

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!identVar) || (identVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) identVar)->value);
   ((MHEG5OctetStringVariable *) identVar)->value = MH5_WhoAmI();
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

  #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      strcpy(buff, T_NL "WhoAmI( ");
      MHEG5stringTrace(((MHEG5OctetStringVariable *) identVar)->value, buff, 0, 120 );
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
  #endif

   return MHEG5ERR_NOERROR;
}

#ifdef INCLUDE_DEBUG_PACKAGE

static MHEG5ErrorCode MHEG5prgDebug(MHEG5Program *program)
{
   MHEG5GList *prevParam, *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Generic g;
   U8BIT *buffer = 0;
   MHEG5Int allocated = 0, used = 0;
   MHEG5Bool success;

   assert(program);

   prevParam = MHEG5resolveORef(program->parameter, &callVar);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   buffer = NULL;

   while (prevParam)
   {
      nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
      success = MHEG5parseEncodeQPrintable(&buffer, &used, &allocated, &g);
      if (!success)
      {
         break;
      }

      prevParam = nextParam;
   }

   if (buffer != NULL)
   {
      DVB_MhegOutputDebugString(buffer);
      MHEG5freeMem(buffer);
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   return MHEG5ERR_NOERROR;
}

#endif  /* INCLUDE_DEBUG_PACKAGE */


#if defined(INCLUDE_MHEG_PVR) || defined(INCLUDE_PVR_AU)

void MHEG5NotifyBookingResult(E_MhegErr result)
{
   if (pvr_program == NULL)
   {
      TRACE(TERROR, ("No Program"))
   }
   else
   {
      switch (result)
      {
         case MHERR_ALTERNATIVE_FOUND:
            *((MHEG5Int *)(pvr_program->resultValue)) = 1;
            *(pvr_program->forkSucceededValue) = MHEG5TRUE;
            break;

         case MHERR_OK:
            *((MHEG5Int *)(pvr_program->resultValue)) = 0;
            *(pvr_program->forkSucceededValue) = MHEG5TRUE;
            break;

         case MHERR_CONFLICT:
            *((MHEG5Int *)(pvr_program->resultValue)) = -1;
            *(pvr_program->forkSucceededValue) = MHEG5TRUE;
            break;

         case MHERR_REQUEST_IGNORED:
            *((MHEG5Int *)(pvr_program->resultValue)) = -4;
            *(pvr_program->forkSucceededValue) = MHEG5TRUE;
            break;

         default:
            TRACE(TERROR, ("Invalid result %d", result))
      }

      ProgramCompleted( pvr_program );

      pvr_program = NULL;
   }
}

#endif /*defined(INCLUDE_MHEG_PVR) || defined(INCLUDE_PVR_AU)*/

#ifdef INCLUDE_MHEG_PVR

static MHEG5ErrorCode MHEG5prgPVR_MakeBooking(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intgVar = 0;
   S_STRING crid;
   S_CRID_DETAILS crid_details;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, (MHEG5String *)&crid, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, (MHEG5Int *)&crid_details.type);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (crid_details.type != 0x31 && crid_details.type != 0x32)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam,
         (MHEG5String *)&crid_details.title, &invalidString );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam,
         (MHEG5String *)&crid_details.description, &invalidString );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &intgVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intgVar) || (intgVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   TRACE(TEVNTS, ("%s", crid.zptr))

      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;


   switch (DVB_MhegPvrMakeBooking( crid, &crid_details ))
   {
      case MHERR_ALTERNATIVE_FOUND: ((MHEG5IntegerVariable *) intgVar)->value = 1; break;
      case MHERR_OK:                ((MHEG5IntegerVariable *) intgVar)->value = 0; break;
      case MHERR_CONFLICT:          ((MHEG5IntegerVariable *) intgVar)->value = -1; break;
      case MHERR_OBJECT_NOT_FOUND:  ((MHEG5IntegerVariable *) intgVar)->value = -2; break;
      case MHERR_REQUEST_IGNORED:   ((MHEG5IntegerVariable *) intgVar)->value = -3; break;
      default:
      case MHERR_OTHER:             ((MHEG5IntegerVariable *) intgVar)->value = -5; break;

      case MHERR_RESULT_PENDING:
      {
         pvr_program = program;
         if (program->forked)
         {
            /* Set the forkSuceeded default to FALSE */
            ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;
         }
         else
         {
            /* For a called program disable event processing until the program ends */
            TRACE(TFILE, (""))
            MHEG5enableEventProcessing(MHEG5FALSE);
         }
         program->resultValue = &((MHEG5IntegerVariable *) intgVar)->value;
         program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;
      }
   }
   return MHERR_OK;
}

static MHEG5ErrorCode MHEG5prgPVR_CancelBooking(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intgVar = 0;
   //MHEG5String crid;
   S_STRING crid;
   MHEG5Int crid_type;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef( program->parameter, &callVar );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam,
         (MHEG5String *)&crid, &invalidString );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &crid_type );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (crid_type != 0x31 && crid_type != 0x32)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &intgVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intgVar) || (intgVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   TRACE(TEVNTS, ("%s", crid.zptr))

      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   switch (DVB_MhegPvrCancelBooking( crid, (U16BIT)crid_type ))
   {
      case MHERR_OK:               ((MHEG5IntegerVariable *) intgVar)->value = 0; break;
      case MHERR_CONFLICT:         ((MHEG5IntegerVariable *) intgVar)->value = -1; break;
      case MHERR_OBJECT_NOT_FOUND: ((MHEG5IntegerVariable *) intgVar)->value = -2; break;
      default:
      case MHERR_REQUEST_IGNORED:  ((MHEG5IntegerVariable *) intgVar)->value = -3; break;
   }
   return MHERR_OK;
}

static MHEG5ErrorCode MHEG5prgPVR_ListBookings(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *ostrVar = 0;
   S_CRID_REC *crid_list;
   U16BIT number, ndx;
   MHEG5String out_str;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &ostrVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!ostrVar) || (ostrVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) ostrVar)->value);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   crid_list = DVB_MhegPvrListBookings( &number );
   out_str.len = 0;
   if (crid_list != NULL)
   {
      for (ndx = 0; ndx != number; ndx++)
      {
         out_str.len += crid_list[ndx].crid.zlen + 4; /* 4 for: ' '+('49'||'50')+(' '||'\0') */
      }
      out_str.data = STR_DataAlloc( out_str.len );
      if (out_str.data != NULL)
      {
         MHEG5Byte *pData = out_str.data;
         for (ndx = 0; ndx != number; ndx++)
         {
            memcpy( pData, crid_list[ndx].crid.zptr, crid_list[ndx].crid.zlen );
            pData += crid_list[ndx].crid.zlen;
            if (crid_list[ndx].type == 49)
            {
               memcpy( pData, " 49 ", 4 );
            }
            else
            {
               memcpy( pData, " 50 ", 4 );
            }
            pData += 4;
         }
         pData--;
         *pData = 0;
      }
      DVB_MhegPvrReleaseList(crid_list);
   }
   else
   {
      out_str.data = NULL;
   }
   ((MHEG5OctetStringVariable *) ostrVar)->value = out_str;

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[512];
      strcpy(buff, T_NL "WhoAmI( ");
      MHEG5stringTrace(((MHEG5OctetStringVariable *) ostrVar)->value, buff, 0, 120 );
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif
   return MHERR_OK;
}

#endif /*INCLUDE_MHEG_PVR*/

#ifdef INCLUDE_PVR_AU

static MHEG5ErrorCode MHEG5prgPVR_MakeBooking2(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intgVar = 0;
   S_STRING crid;
   MHEG5String bookingDetails;
   S_CRID_DETAILS crid_details;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, (MHEG5String *)&crid, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, &bookingDetails, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &intgVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intgVar) || (intgVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   TRACE(TEVNTS, ("%s", crid.zptr))

   if (!MHEG5parseDecodeBookings( bookingDetails, &crid_details ))
   {
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;
   }
   else
   {
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

      switch (DVB_MhegPvrMakeBooking( crid, &crid_details ))
      {
         case MHERR_OK:                ((MHEG5IntegerVariable *) intgVar)->value = 0; break;
         case MHERR_CONFLICT:          ((MHEG5IntegerVariable *) intgVar)->value = -1; break;
         case MHERR_REQUEST_IGNORED:   ((MHEG5IntegerVariable *) intgVar)->value = -4; break;
         default:
         case MHERR_OTHER:             ((MHEG5IntegerVariable *) intgVar)->value = -5; break;
         case MHEG5_INSUFFICIENT_SPACE:((MHEG5IntegerVariable *) intgVar)->value = -6; break;
         case MHERR_OVERBOOKED:        ((MHEG5IntegerVariable *) intgVar)->value = -7; break;
         case MHEG5_RESULT_PENDING:
         {
            pvr_program = program;
            if (program->forked)
            {
               /* Set the forkSuceeded default to FALSE */
               ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;
            }
            else
            {
               /* For a called program disable event processing until the program ends */
               TRACE(TFILE, (""))
               MHEG5enableEventProcessing(MHEG5FALSE);
            }
            program->resultValue = &((MHEG5IntegerVariable *) intgVar)->value;
            program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;
         }
      }
      MHEG5freeDecodeBookings( &crid_details );
   }
   return MHERR_OK;
}

static MHEG5ErrorCode MHEG5prgPVR_CancelBooking2(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *intgVar = 0;
   //MHEG5String crid;
   S_STRING crid;
   MHEG5Int crid_type;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef( program->parameter, &callVar );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam,
         (MHEG5String *)&crid, &invalidString );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &crid_type );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (crid_type != 0x31 && crid_type != 0x32)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &intgVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!intgVar) || (intgVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   TRACE(TEVNTS, ("%s", crid.zptr))

      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   switch (DVB_MhegPvrCancelBooking( crid, (S32BIT)crid_type ))
   {
      case MHERR_OK:               ((MHEG5IntegerVariable *) intgVar)->value = 0; break;
      case MHERR_OBJECT_NOT_FOUND: ((MHEG5IntegerVariable *) intgVar)->value = -2; break;
      default:
      case MHERR_OTHER:            ((MHEG5IntegerVariable *) intgVar)->value = -4; break;
   }
   return MHERR_OK;
}

static MHEG5ErrorCode MHEG5prgPVR_ListBookings2(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *ostrVar = 0;
   S_CRID_REC *crid_list;
   U16BIT number, ndx;
   MHEG5String out_str;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &ostrVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!ostrVar) || (ostrVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) ostrVar)->value);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   crid_list = DVB_MhegPvrListBookings( &number );
   out_str.len = 0;
   if (crid_list != NULL)
   {
      for (ndx = 0; ndx != number; ndx++)
      {
         out_str.len += crid_list[ndx].crid.zlen + 4; /* 4 for: ' '+('49'||'50')+(' '||'\0') */
      }
      out_str.data = STR_DataAlloc( out_str.len );
      if (out_str.data != NULL)
      {
         MHEG5Byte *pData = out_str.data;
         for (ndx = 0; ndx != number; ndx++)
         {
            memcpy( pData, crid_list[ndx].crid.zptr, crid_list[ndx].crid.zlen );
            pData += crid_list[ndx].crid.zlen;
            *pData = ' ';
            pData++;
         }
         pData--;
         *pData = 0;
      }
      DVB_MhegPvrReleaseList(crid_list);
   }
   else
   {
      out_str.data = NULL;
   }
   ((MHEG5OctetStringVariable *) ostrVar)->value = out_str;

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[512];
      strcpy(buff, T_NL "PVR_ListBooking2( ");
      MHEG5stringTrace(((MHEG5OctetStringVariable *) ostrVar)->value, buff, 0, 120 );
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif
   return MHERR_OK;
}

static MHEG5ErrorCode MHEG5prgPVR_GetDetails2(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *ostrVar = 0;
   S_STRING crid;
   S_CRID_DETAILS *pDetails;
   MHEG5String out_str;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam,
         (MHEG5String *)&crid, &invalidString );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &ostrVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!ostrVar) || (ostrVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) ostrVar)->value);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   pDetails = DVB_MhegPvrGetDetails( crid );
   out_str.len = 0;
   out_str.data = NULL;
   if (pDetails != NULL)
   {
      if (pDetails->bookings != NULL)
      {
         MHEG5parseEncodeBooking( pDetails, out_str );
      }
      DVB_MhegPvrReleaseDetails( pDetails );
   }
   ((MHEG5OctetStringVariable *) ostrVar)->value = out_str;

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[512];
      strcpy(buff, T_NL "PVR_GetDetails2( ");
      MHEG5stringTrace(((MHEG5OctetStringVariable *) ostrVar)->value, buff, 0, 120 );
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif
   return MHERR_OK;
}

#endif /*INCLUDE_PVR_AU*/


#ifdef INCLUDE_CI_PLUS
/* 12.3.6.1 in CI+ Specification */
static MHEG5ErrorCode MHEG5prgRequestMPEGDecoder(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *resultVar = 0;
   MHEG5Bool request;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericBoolean(nextParam, &request);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(nextParam, &resultVar);

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) resultVar)->value = MHEG5RequestMPEGDecoder(request);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   return MHEG5ERR_NOERROR;
}

/* 12.8.1.2 in CI+ Specification */
static MHEG5ErrorCode MHEG5prgSuppressMHEGGraphics(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Bool request;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericBoolean(nextParam, &request);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5SuppressMHEGGraphics(request);
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   return MHEG5ERR_NOERROR;
}

#endif  /* INCLUDE_CI_PLUS */

static MHEG5ErrorCode MHEG5prgTestInputMask(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *boolVar;
   MHEG5String maskVar;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &maskVar, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5resolveORef(nextParam, &boolVar);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!boolVar) || (boolVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5BooleanVariable *) boolVar)->value = MHEG5IsInputMaskSupported(maskVar);
   return MHEG5ERR_NOERROR;
}

#ifdef INCLUDE_IC

static MHEG5ErrorCode MHEG5prgSetHybridFileSystem(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5String pathName;
   MHEG5String mappingList;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, &pathName, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, &mappingList, &invalidString);
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   if (nextParam)
   {
      /* Should only be 2 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

 #ifdef TRACING
   if ((mheg_trace_debug & (TACTIONS | TEVNTS)) && !(mheg_trace_debug & TFILE))
   {
      char buff[512];
      strcpy(buff, T_NL "SetHybridFileSystem( ");
      MHEG5stringTrace(pathName, buff, 0, 120);
      strcat(buff, ", ");
      MHEG5stringTrace(mappingList, buff, 0, 230);
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif

   MHEG5SetHybridFileSystem(&pathName, &mappingList);

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetICStatus(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *icStatusVar = 0;
   MHEG5Int icStatus;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &icStatusVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!icStatusVar) || (icStatusVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5getICStatus( &icStatus );
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   ((MHEG5IntegerVariable *) icStatusVar)->value = icStatus;

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgSetCookie(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Bool invalidString;

   MHEG5Int expiryDate;
   MHEG5String value;
   MHEG5Bool secure;
   MHEG5String identity;

   MHEG5cookie_t cookie_data;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString( nextParam, &identity, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveGenericInteger( nextParam, &expiryDate );
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericOctetString( nextParam, &value, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5resolveGenericBoolean( nextParam, &secure );

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   cookie_data.value = value;
   cookie_data.secure = secure;
   cookie_data.expires = expiryDate;
   cookie_data.identity = identity;

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5CookieAdd(&cookie_data);

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetCookie(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *found = 0, *expiryDate = 0,
   *value = 0, *secure = 0;
   MHEG5String identity;
   MHEG5Bool invalidString;

   MHEG5cookie_t cookie_data;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString( nextParam, &identity, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveORef( nextParam, &found);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef( nextParam, &expiryDate);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef( nextParam, &value);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef( nextParam, &secure);


   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!found) || (found->clazz != MHEG5BOOLEANVARIABLE) ||
       (!expiryDate) || (expiryDate->clazz != MHEG5INTEGERVARIABLE) ||
       (!value) || (value->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   cookie_data.identity = identity;
   if (MHEG5CookieRetrieve(&cookie_data) == MHEG5TRUE)
   {
      ((MHEG5BooleanVariable *) found)->value = MHEG5TRUE;

      MHEG5stringDestruct(&((MHEG5OctetStringVariable *) value)->value);
      ((MHEG5OctetStringVariable *) value)->value = MHEG5stringCopy(cookie_data.value);

      ((MHEG5BooleanVariable *) secure)->value = cookie_data.secure;
      ((MHEG5IntegerVariable *) expiryDate)->value = cookie_data.expires;
   }
   else
   {
      ((MHEG5BooleanVariable *) found)->value = MHEG5FALSE;
   }
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   return MHEG5ERR_NOERROR;
}

#endif  /* INCLUDE_IC */


#ifdef INCLUDE_IC

static void returnDataCallback(void *userData, MHEG5String data, MHEG5Int code)
{
   MHEG5Program *program;

   /* Cast userData to an (MHEG5Program *) */
   program = (MHEG5Program *)userData;

   *((MHEG5Int *)(program->resultCode)) = code;
   *((MHEG5String *)(program->resultValue)) = MHEG5stringCopy(data);
   *(program->forkSucceededValue) = MHEG5TRUE;

   ProgramCompleted( program );
}

static MHEG5ErrorCode MHEG5prgReturnData(MHEG5Program *program)
{
   MHEG5GList *nextParam, *prevParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *codeVar = 0;
   MHEG5Root *dataVar = 0;
   MHEG5IntegerVariable *rc1;
   MHEG5OctetStringVariable *rc2;
   MHEG5String url;
   MHEG5String data;
   MHEG5Bool invalidString;
   MHEG5String name;
   MHEG5Generic g;
   U8BIT *buffer = 0;
   MHEG5Int allocated = 0, used = 0;
   MHEG5Bool success;

   assert(program);

   /* callVar */
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   /* URL */
   nextParam = MHEG5resolveGenericOctetString( nextParam, &url, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   buffer = NULL;

   /* Next parameter can be either GenericOctetString (name) or
    * GenericInteger pointing at IntegerVariable (responseCode)
    */
   prevParam = nextParam;
   nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
   while (nextParam && g.type == MHEG5OCTETSTRING)
   {
      name = g.value.s;

      /* Next parameter can be many things. */
      prevParam = nextParam;
      nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
      success = MHEG5parseEncodeField(&buffer, &used, &allocated, &name, &g);
      if (!success)
      {
         nextParam = NULL;
         break;
      }

      /* Next parameter can be either GenericOctetString (name) or
       * GenericInteger pointing at IntegerVariable (responseCode)
       */
      prevParam = nextParam;
      nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
   }

   if (!nextParam)
   {
      MHEG5freeMem(buffer);
      return MHEG5ERR_WRONGPARAM;
   }

   /* resolve responseCode */
   nextParam = MHEG5resolveORef(prevParam, &codeVar);
   if (!nextParam)
   {
      MHEG5freeMem(buffer);
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if ((!codeVar) || (codeVar->clazz != MHEG5INTEGERVARIABLE))
   {
      MHEG5freeMem(buffer);
      return MHEG5ERR_WRONGPARAM;
   }
   rc1 = (MHEG5IntegerVariable *)codeVar;

   /* Resolve responseData */
   prevParam = nextParam;
   nextParam = MHEG5resolveORef(prevParam, &dataVar);
   if (nextParam)
   {
      MHEG5freeMem(buffer);
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if ((!dataVar) || (dataVar->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      MHEG5freeMem(buffer);
      return MHEG5ERR_WRONGPARAM;
   }
   rc2 = (MHEG5OctetStringVariable *)dataVar;

    /* Make sure any currently stored string in rc2 is destroyed */
    MHEG5stringDestruct(&rc2->value);

   /* Set the forkSuceeded to default to FALSE */
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;

   program->resultCode = &rc1->value;
   program->resultValue = &rc2->value;
   program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

   /* For a called program disable event processing until the program ends */
   if (!program->forked)
   {
      MHEG5enableEventProcessing(MHEG5FALSE);
   }

   data.len = used;
   data.data = buffer;
   MHEG5FileOrmReturnData(url, data, returnDataCallback, program);
   MHEG5freeMem(buffer);

   return MHEG5ERR_NOERROR;
}

#ifdef INCLUDE_ICS

static void stopMeasurement(MHEG5Program *program)
{
   MHEG5StreamerAbortMeasurement(program);
}

void MHEG5notifyStreamPerformanceMeasurement(MHEG5Root *root, MHEG5Int speed)
{
   MHEG5Program *program;

   assert(root->clazz == MHEG5RESIDENTPROGRAM);

   program = (MHEG5Program *)root;

   /* Store speed */
   *((MHEG5Int *)(program->resultValue)) = speed;

   /* Call/Fork succeeded */
   *(program->forkSucceededValue) = MHEG5TRUE;

   ProgramCompleted( program );
}

static MHEG5ErrorCode MHEG5prgMeasureStreamPerformance(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *rcVar;
   MHEG5String url;
   MHEG5Int maxBytes;
   MHEG5IntegerVariable *speedVar;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &url, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &maxBytes);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &rcVar);
   if (nextParam)
   {
      /* Should only be 3 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!rcVar) || (rcVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   /* Set speed to "unkown" */
   speedVar = (MHEG5IntegerVariable *)rcVar;
   speedVar->value = -1;

   /* Set the forkSuceeded to default to FALSE */
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;

   program->resultValue = &speedVar->value;
   program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

   /* Set the function used to abort the performance measurement */
   program->stopFunc = stopMeasurement;

   /* For a called program disable event processing until the program ends */
   if (!program->forked)
   {
      MHEG5enableEventProcessing(MHEG5FALSE);
   }

   MHEG5StreamerMeasurePerformance(&url, maxBytes, program);

   return MHEG5ERR_NOERROR;
}

void MHEG5notifyGuidanceResponse(MHEG5Bool result)
{
   MHEG5Program *program = guidance_program;

   if (program != NULL)
   {
      TPRINT((TACTIONS | TEVNTS), (T_NL "PIN result %d",result))

      /* Store result */
      *((MHEG5Bool *)(program->resultValue)) = result;

      /* Call/Fork succeeded */
      *(program->forkSucceededValue) = MHEG5TRUE;

      ProgramCompleted( program );

      guidance_program = NULL;
   }
}

static void stopPrompt(MHEG5Program *program)
{
   if (guidance_program != NULL)
   {
      (void)MHEG5promptForGuidance(NULL, MHEG5FALSE);
      guidance_program = NULL;
   }
}

static MHEG5ErrorCode MHEG5prgPromptForGuidance(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5String restriction;
   MHEG5Root *resultVar;
   MHEG5Bool invalidString;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &restriction, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (nextParam)
   {
      /* Should only be 2 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   if (!MHEG5IsPinRequired())
   {
      TPRINT((TACTIONS | TEVNTS), (T_NL "PIN not required"))
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
      ((MHEG5BooleanVariable *)resultVar)->value = MHEG5TRUE;
   }
   else
   {
      /* Set the forkSuceeded to default to FALSE */
      ((MHEG5BooleanVariable *) callVar)->value = MHEG5FALSE;

      program->resultValue = &(((MHEG5BooleanVariable *)resultVar)->value);
      program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

      /* Set the function used to abort the performance measurement */
      program->stopFunc = stopPrompt;

      /* For a called program disable event processing until the program ends */
      if (!program->forked)
      {
         MHEG5enableEventProcessing(MHEG5FALSE);
      }

      guidance_program = program;

      TPRINT((TACTIONS | TEVNTS), (T_NL "requesting PIN"))
      if (!MHEG5promptForGuidance( &restriction, TRUE ))
      {
         ProgramCompleted( program );

         guidance_program = NULL;
      }
   }
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetAudioDescPref(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *viewerPref;
   BOOLEAN audioDescPref;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &viewerPref);
   if (nextParam)
   {
      /* Should only be one parameter */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!viewerPref) || (viewerPref->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   audioDescPref = DVB_MhegAudioDescriptionPref();
   if (audioDescPref)
   {
      ((MHEG5BooleanVariable *) viewerPref)->value = MHEG5TRUE;
   }
   else
   {
      ((MHEG5BooleanVariable *) viewerPref)->value = MHEG5FALSE;
   }
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetSubtitlePref(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *viewerPref;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &viewerPref);
   if (nextParam)
   {
      /* Should only be one parameter */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!viewerPref) || (viewerPref->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   if (DVB_MhegGetSubtitlePref())
   {
      ((MHEG5BooleanVariable *) viewerPref)->value = MHEG5TRUE;
   }
   else
   {
      ((MHEG5BooleanVariable *) viewerPref)->value = MHEG5FALSE;
   }
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   return MHEG5ERR_NOERROR;
}


#ifdef INCLUDE_IPLAYER

static MHEG5ErrorCode MHEG5prgGetPINSupport(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *supportVar = 0;
   MHEG5Int support;
   MHEG5Bool success;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &supportVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!supportVar) || (supportVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   success = MHEG5GetPINSupport(&support);

   ((MHEG5BooleanVariable *) callVar)->value = success;
   ((MHEG5IntegerVariable *) supportVar)->value = support;

   return MHEG5ERR_NOERROR;
}

#endif  /* INCLUDE_IPLAYER */
#ifdef INCLUDE_FREESAT

static MHEG5ErrorCode MHEG5prgGetPINRequirement(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *statusVar = 0;
   MHEG5Int status;
   MHEG5Bool success;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &statusVar);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!statusVar) || (statusVar->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   success = MHEG5GetPINRequirement(&status);

   ((MHEG5BooleanVariable *) callVar)->value = success;
   ((MHEG5IntegerVariable *) statusVar)->value = status;

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgValidatePIN(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5String pin;
   MHEG5Root *statusVar;
   MHEG5Bool invalidString;
   MHEG5Int status;
   MHEG5Bool success;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &pin, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveORef(nextParam, &statusVar);
   if (nextParam)
   {
      /* Should only be 2 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!statusVar) || (statusVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   success = MHEG5ValidatePIN(&pin, &status);

   ((MHEG5BooleanVariable *) callVar)->value = success;
   ((MHEG5IntegerVariable *) statusVar)->value = status;

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgComputePrivateSignature(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5String data;
   MHEG5Root *resultVar;
   MHEG5Bool invalidString;
   MHEG5String result;
   MHEG5Bool success;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &data, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }

   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (nextParam)
   {
      /* Should only be 2 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   success = MHEG5ComputePrivateSignature(&data, &result);

   ((MHEG5BooleanVariable *) callVar)->value = success;
   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) resultVar)->value);
   ((MHEG5OctetStringVariable *) resultVar)->value = result;

   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode MHEG5prgGetFSIServiceReference(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0, *fsi = 0, *fsiString = 0;
   MHEG5Int seviceIndex = 0, outputInt;
   MHEG5String outputString = {0, 0};
   MHEG5Bool rc;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericInteger(nextParam, &seviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &fsi);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &fsiString);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!fsi) || (fsi->clazz != MHEG5INTEGERVARIABLE) ||
       (!fsiString) || (fsiString->clazz != MHEG5OCTETSTRINGVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   rc = MHEG5GetFSIServiceReference(seviceIndex, &outputInt, &outputString);

   ((MHEG5BooleanVariable *) callVar)->value = rc;
   ((MHEG5IntegerVariable *) fsi)->value = outputInt;
    MHEG5stringDestruct(&((MHEG5OctetStringVariable *) fsiString)->value);
   ((MHEG5OctetStringVariable *) fsiString)->value = outputString;

   return MHEG5ERR_NOERROR;
}

#endif /* INCLUDE_FREESAT */

#endif /* INCLUDE_ICS */

#endif /* INCLUDE_IC */


#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgLNG_GetPreferredLangs(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *audioVar;
   MHEG5Root *subsVar;
   MHEG5String *audioStr;
   MHEG5String *subsStr;
   MHEG5String buffer;
   U32BIT lang;
   U8BIT lstr[4] = {0,0,0,0};

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &audioVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &subsVar);
   if (nextParam)
   {
      /* Should only be 3 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!audioVar) || (audioVar->clazz != MHEG5OCTETSTRINGVARIABLE)) ||
       ((!subsVar) || (subsVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   audioStr = &((MHEG5OctetStringVariable *)audioVar)->value;
   subsStr = &((MHEG5OctetStringVariable *)subsVar)->value;

   buffer.data = lstr;
   buffer.len = 3;
   if (!DVB_MhegPrefAudioLangs(&lang,1))
   {
      lang = UND_LANGUAGE_CODE;
   }
   lstr[0] = (U8BIT)(lang >> 16);
   lstr[1] = (lang >> 8) & 0xFF;
   lstr[2] = lang & 0xFF;
   MHEG5stringDestruct(audioStr);
   *audioStr = MHEG5stringCopy(buffer);

   if (!DVB_MhegPrefSubtitleLangs(&lang,1))
   {
      lang = UND_LANGUAGE_CODE;
   }
   lstr[0] = (U8BIT)(lang >> 16);
   lstr[1] = (lang >> 8) & 0xFF;
   lstr[2] = lang & 0xFF;
   MHEG5stringDestruct(subsStr);
   *subsStr = MHEG5stringCopy(buffer);

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[512];
      strcpy(buff, T_NL "GetPreferredLangs( ");
      MHEG5stringTrace(*audioStr, buff, 0, 120);
      strcat(buff, ", ");
      MHEG5stringTrace(*subsStr, buff, 0, 230);
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgLNG_GetAudioLangs(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventIndex;
   MHEG5Root *langsVar;
   MHEG5String *langsStr;
   MHEG5String buffer;
   U8BIT langs[256];
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &langsVar);
   if (nextParam)
   {
      /* Should only be 4 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!langsVar) || (langsVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   langsStr = &((MHEG5OctetStringVariable *)langsVar)->value;
   memset(langs, 0x0, sizeof(langs));

   err = DVB_MhegGetAudioLangs((S32BIT)serviceIndex, (S32BIT)eventIndex, langs);
   if (err == MHERR_OK)
   {
      MHEG5stringDestruct(langsStr);
      buffer.data = langs;
      buffer.len = strlen((char *)langs);
      *langsStr = MHEG5stringCopy(buffer);
   }

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      DBG_PRINTF(T_NL "LNG_GetADLangs( %ld, %ld, ", serviceIndex, eventIndex );
      *buff = 0;
      MHEG5stringTrace(*langsStr, buff, 0, 230);
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgLNG_GetSubtitleLangs(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventIndex;
   MHEG5Root *langsVar;
   MHEG5String *langsStr;
   MHEG5String buffer;
   U8BIT langs[256];
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &langsVar);
   if (nextParam)
   {
      /* Should only be 4 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!langsVar) || (langsVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   langsStr = &((MHEG5OctetStringVariable *)langsVar)->value;
   memset(langs, 0x0, sizeof(langs));

   err = DVB_MhegGetSubtitleLangs((S32BIT)serviceIndex, (S32BIT)eventIndex,
         langs);
   if (err == MHERR_OK)
   {
      MHEG5stringDestruct(langsStr);
      buffer.data = langs;
      buffer.len = strlen((char *)langs);
      *langsStr = MHEG5stringCopy(buffer);
   }

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      DBG_PRINTF(T_NL "LNG_GetAudioLangs( %ld, %ld, ", serviceIndex, eventIndex );
      *buff = 0;
      MHEG5stringTrace(*langsStr, buff, 0, 230);
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgLNG_GetADLangs(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventIndex;
   MHEG5Root *langsVar;
   MHEG5String *langsStr;
   MHEG5String buffer;
   U8BIT langs[256];
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &langsVar);
   if (nextParam)
   {
      /* Should only be 4 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!langsVar) || (langsVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   langsStr = &((MHEG5OctetStringVariable *)langsVar)->value;
   memset(langs, 0x0, sizeof(langs));

   err = DVB_MhegGetADLangs((S32BIT)serviceIndex, (S32BIT)eventIndex, langs);
   if (err == MHERR_OK)
   {
      MHEG5stringDestruct(langsStr);
      buffer.data = langs;
      buffer.len = strlen((char *)langs);
      *langsStr = MHEG5stringCopy(buffer);
   }

 #ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[256];
      DBG_PRINTF(T_NL "LNG_GetSubtitleLangs( %ld, %ld, ", serviceIndex, eventIndex );
      *buff = 0;
      MHEG5stringTrace(*langsStr, buff, 0, 230);
      strcat(buff, " )");
      DBG_PRINTF(buff);
   }
 #endif

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgREM_SetNativeReminder(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventId;
   MHEG5Root *resultVar;
   BOOLEAN result;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventId);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (nextParam)
   {
      /* Should only be 4 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegSetNativeReminder(serviceIndex, eventId, &result);
   if (err == MHERR_OK)
   {
      if (result)
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;
      }
      else
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
      }
   }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgREM_GetNativeReminder(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventId;
   MHEG5Root *setVar;
   BOOLEAN set;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventId);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &setVar);
   if (nextParam)
   {
      /* Should only be 4 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!setVar) || (setVar->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetNativeReminder(serviceIndex, eventId, &set);
   if (err == MHERR_OK)
   {
      if (set)
      {
         ((MHEG5BooleanVariable *) setVar)->value = MHEG5TRUE;
      }
      else
      {
         ((MHEG5BooleanVariable *) setVar)->value = MHEG5FALSE;
      }
   }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgREM_CancelNativeReminder(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventId;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventId);
   if (nextParam)
   {
      /* Should only be 3 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   DVB_MhegCancelNativeReminder(serviceIndex, eventId);

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSA_GetHostSetting(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5String key;
   MHEG5Root *valueVar;
   MHEG5String *strVal;
   MHEG5Int *intVal;
   MHEG5Bool invalidString;
   S32BIT ivalue;
   U8BIT svalue[4] = { 0, 0, 0, 0 };
   MHEG5String buffer;
   E_MhegErr err;

   static char bannerTransparency[] = "BannerTransparency";
   static char bannerTimeout[] = "BannerTimeout";
   static char osdLanguage[] = "OSDLanguage";
   static char serviceMode[] = "ServiceMode";

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &key,
         &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveORef(nextParam, &valueVar);
   if (nextParam)
   {
      /* Should only be 3 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       (!valueVar))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   if (strcmp((char *)key.data, bannerTransparency) == 0)
   {
      if (valueVar->clazz != MHEG5INTEGERVARIABLE)
      {
         return MHEG5ERR_WRONGPARAM;
      }
      intVal = &((MHEG5IntegerVariable *)valueVar)->value;
      err = DVB_MhegGetBannerTransparency(&ivalue);
      if (err == MHERR_OK)
      {
         *intVal = ivalue;
      }
   }
   else if (strcmp((char *)key.data, bannerTimeout) == 0)
   {
      if (valueVar->clazz != MHEG5INTEGERVARIABLE)
      {
         return MHEG5ERR_WRONGPARAM;
      }
      intVal = &((MHEG5IntegerVariable *)valueVar)->value;
      err = DVB_MhegGetBannerTimeout(&ivalue);
      if (err == MHERR_OK)
      {
         *intVal = ivalue;
      }
   }
   else if (strcmp((char *)key.data, osdLanguage) == 0)
   {
      if (valueVar->clazz != MHEG5OCTETSTRINGVARIABLE)
      {
         return MHEG5ERR_WRONGPARAM;
      }
      strVal = &((MHEG5OctetStringVariable *)valueVar)->value;
      err = DVB_MhegGetOSDLanguage(svalue);
      if (err == MHERR_OK)
      {
         MHEG5stringDestruct(strVal);
         buffer.data = svalue;
         buffer.len = 3;
         *strVal = MHEG5stringCopy(buffer);
      }
   }
    else if (strcmp((char*)key.data, serviceMode) == 0)
    {
        if (valueVar->clazz != MHEG5INTEGERVARIABLE)
        {
            return MHEG5ERR_WRONGPARAM;
        }
        intVal = &((MHEG5IntegerVariable *)valueVar)->value;
        switch (DVB_MhegGetServiceMode())
        {
           default:
           case SRV_TYP_TV_DATA: *intVal = 0; break;
           case SRV_TYP_RADIO:   *intVal = 1; break;
           case SRV_TYP_ALL:     *intVal = 3; break;
        }
    }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */



#ifdef INCLUDE_SI_EXTENSION

static MHEG5Bool GetServiceInfo( MHEG5Int serviceIndex,
   MHEG5String *serviceProvider,
   MHEG5String *serviceName,
   MHEG5Int *serviceType )
{
   S_ServiceDetails ServiceInfo;
   MHEG5String buffer;
   MHEG5Bool returnCode = MHEG5FALSE;

   MHEG5stringDestruct(serviceName);
   MHEG5stringDestruct(serviceProvider);
   if (DVB_MhegGetServiceDetails((S32BIT)serviceIndex, &ServiceInfo) == MHERR_OK)
   {
      returnCode = MHEG5TRUE;
      if (ServiceInfo.serviceName.zptr != NULL &&
          ServiceInfo.serviceName.zlen != 0)
      {
         buffer.data = ServiceInfo.serviceName.zptr;
         buffer.len = ServiceInfo.serviceName.zlen;

         *serviceName = MHEG5stringCopy(buffer);
      }
      if (ServiceInfo.serviceProvider.zptr != NULL &&
          ServiceInfo.serviceProvider.zlen != 0)
      {
         buffer.data = ServiceInfo.serviceProvider.zptr;
         buffer.len = ServiceInfo.serviceProvider.zlen;

         *serviceProvider = MHEG5stringCopy(buffer);
      }
      *serviceType = ServiceInfo.serviceType;

    #ifdef TRACING
      if (mheg_trace_debug & (TACTIONS | TEVNTS))
      {
         char buff[124];
         DBG_PRINTF(T_NL "SI_GetServiceInfo( %ld ", serviceIndex );
         *buff = 0;
         MHEG5stringTrace( *serviceName, buff, 0, 120 );
         strcat(buff, " ");
         MHEG5stringTrace( *serviceProvider, buff, 0, 100 );
         DBG_PRINTF(buff);
         DBG_PRINTF(" %ld )", ServiceInfo.serviceType );
      }
    #endif

      DVB_MhegReleaseServiceDetails( &ServiceInfo );
   }
   else
   {
      TRACE(TERROR, (" serviceIndex=%d", serviceIndex))
   }
   return returnCode;
}

static MHEG5ErrorCode MHEG5prgSI_GetServiceInfo(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Root *serviceName;
   MHEG5Root *serviceProvider;
   MHEG5Root *serviceType;

   MHEG5Bool success;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &serviceName);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &serviceProvider);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &serviceType);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!serviceProvider) || (serviceProvider->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!serviceName) || (serviceName->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!serviceType) || (serviceType->clazz != MHEG5INTEGERVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   success = GetServiceInfo( serviceIndex,
         &((MHEG5OctetStringVariable *)serviceProvider)->value,
         &((MHEG5OctetStringVariable *)serviceName)->value,
         &((MHEG5IntegerVariable *)serviceType)->value );

   ((MHEG5BooleanVariable *) callVar)->value = success;

   return MHEG5ERR_NOERROR;
}

static void GetEventInfo(S_EventDetails *eventDetails,
   MHEG5String *eventName,
   MHEG5String *shortDescription,
   MHEG5Int *parentalRating,
   MHEG5Int *startDate,
   MHEG5Int *startTime,
   MHEG5Int *duration,
   MHEG5String *category,
   MHEG5Bool *freeNotCA )
{
   MHEG5String buffer;
   U32BIT time;
   int i;

   MHEG5stringDestruct(eventName);
   MHEG5stringDestruct(shortDescription);
   MHEG5stringDestruct(category);

   if (eventDetails->eventName.zlen > 0 &&
       eventDetails->eventName.zptr != NULL)
   {
      buffer.data = eventDetails->eventName.zptr;
      buffer.len = eventDetails->eventName.zlen;

      *eventName = MHEG5stringCopy(buffer);
   }

   if (eventDetails->shortDescription.zlen > 0 &&
       eventDetails->shortDescription.zptr != NULL)
   {
      buffer.data = eventDetails->shortDescription.zptr;
      buffer.len = eventDetails->shortDescription.zlen;

      MHEG5stringDestruct(shortDescription);
      *shortDescription = MHEG5stringCopy(buffer);
   }
   if (eventDetails->category.zlen > 0 &&
       eventDetails->category.zptr != NULL)
   {
      buffer.len = eventDetails->category.zlen * 2;
      buffer.data = STR_DataAlloc( buffer.len );
      *category = buffer;
      for (i = 0; i != buffer.len; i += 2)
      {
         buffer.data[i] = ((eventDetails->category.zptr[i >> 1] >> 4) & 0xf) + 'A';
         buffer.data[i + 1] = (eventDetails->category.zptr[i >> 1] & 0xf) + 'a';
      }
   }

   *parentalRating = eventDetails->parentalRating;
   *startDate = eventDetails->startDate;

   time = eventDetails->startTime.hours;
   time *= 60;
   time += eventDetails->startTime.minutes;
   time *= 60;
   time += eventDetails->startTime.seconds;

   *startTime = time;

   time = eventDetails->duration.hours;
   time *= 60;
   time += eventDetails->duration.minutes;
   time *= 60;
   time += eventDetails->duration.seconds;

   *duration = time;

   if (eventDetails->freeNotCA == TRUE)
   {
      *freeNotCA = MHEG5TRUE;
   }
   else
   {
      *freeNotCA = MHEG5FALSE;
   }

#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      char buff[240];
      strcpy(buff, " ");
      MHEG5stringTrace( *eventName, buff, 0, 120 );
      MHEG5stringTrace( *shortDescription, buff, 0, 230 );
      strcat(buff, " ");
      DBG_PRINTF(buff);
      DBG_PRINTF(" %d %d", eventDetails->parentalRating, eventDetails->startDate );
      DBG_PRINTF(" %02d:%02d:%02d", eventDetails->startTime.hours,
         eventDetails->startTime.minutes, eventDetails->startTime.seconds );
      DBG_PRINTF(" %02d:%02d:%02d", eventDetails->startTime.hours,
         eventDetails->duration.minutes, eventDetails->duration.seconds );

      DBG_PRINTF(" %s %s )", category->data, *freeNotCA ? "TRUE" : "FALSE" );
   }
#endif
}

static MHEG5ErrorCode MHEG5prgSI_GetEventInfo(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;

   MHEG5Int serviceIndex;
   MHEG5Int porf;
   MHEG5Root *eventName;
   MHEG5Root *shortDescription;
   MHEG5Root *parentalRating;
   MHEG5Root *startDate;
   MHEG5Root *startTime;
   MHEG5Root *duration;
   MHEG5Root *category;
   MHEG5Root *freeNotCA;

   S_EventDetails eventDetails;
   E_MhegErr err;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger( nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveGenericInteger( nextParam, &porf);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &eventName);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &shortDescription);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &parentalRating);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &startDate);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &startTime);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &duration);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   nextParam = MHEG5resolveORef(nextParam, &category);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(nextParam, &freeNotCA);

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!eventName) || (eventName->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!shortDescription) || (shortDescription->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!parentalRating) || (parentalRating->clazz != MHEG5INTEGERVARIABLE) ||
       (!startDate) || (startDate->clazz != MHEG5INTEGERVARIABLE) ||
       (!startTime) || (startTime->clazz != MHEG5INTEGERVARIABLE) ||
       (!duration) || (duration->clazz != MHEG5INTEGERVARIABLE) ||
       (!category) || (category->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!freeNotCA) || (freeNotCA->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetEventDetails((S32BIT)serviceIndex, porf ? TRUE : FALSE, &eventDetails);
   if (err == MHERR_OK)
   {
   #ifdef TRACING
      if (mheg_trace_debug & (TACTIONS | TEVNTS))
      {
         DBG_PRINTF(T_NL "SI_GetEventInfo(");
      }
   #endif
      GetEventInfo(&eventDetails,
         &((MHEG5OctetStringVariable *)eventName)->value,
         &((MHEG5OctetStringVariable *)shortDescription)->value,
         &((MHEG5IntegerVariable *)parentalRating)->value,
         &((MHEG5IntegerVariable *)startDate)->value,
         &((MHEG5IntegerVariable *)startTime)->value,
         &((MHEG5IntegerVariable *)duration)->value,
         &((MHEG5OctetStringVariable *)category)->value,
         &((MHEG5BooleanVariable *)freeNotCA)->value);
      DVB_MhegReleaseEventDetails(&eventDetails);
   }

   return MHEG5ERR_NOERROR;
}

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_GetNumberOfServices(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *numberVar = 0;
   S32BIT number;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &numberVar);
   if (nextParam)
   {
      /* Should only be 2 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!numberVar) || (numberVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetNumberOfServices(&number);
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) numberVar)->value = (MHEG5Int)number;
   }

#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SEI_GetNumberOfServices( %d )", number);
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_NextServiceIndex(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *serviceIndexVar = 0;
   S32BIT serviceIndex;
#ifdef TRACING
   S32BIT oldIndex;
#endif
   MHEG5Int updown;
   E_ServiceType servType;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &serviceIndexVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &updown);
   if (nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   /* use 'serviceIndex' to retreive servType parameter */
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (nextParam)
   {
      /* should be four params */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!serviceIndexVar) || (serviceIndexVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }
   /* Set servType from 'serviceIndex' */
   switch (serviceIndex)
   {
     default:
     case 0: servType = SRV_TYP_ALL; break;
     case 1: servType = SRV_TYP_TV_DATA; break;
     case 2: servType = SRV_TYP_RADIO; break;
   }
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   serviceIndex = (S32BIT)(((MHEG5IntegerVariable *) serviceIndexVar)->value);

#ifdef TRACING
   oldIndex = serviceIndex;
#endif
   if (updown == 1)
   {
      err = DVB_MhegNextServiceIndex(&serviceIndex,servType);
   }
   else
   {
      err = DVB_MhegPrevServiceIndex(&serviceIndex,servType);
   }
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) serviceIndexVar)->value = (MHEG5Int)serviceIndex;
   }
#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SEI_NextServiceIndex( updown=%d, %d -> %d )", updown, oldIndex, serviceIndex);
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_GetServiceRunningStatus(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *statusVar = 0;
   MHEG5Int serviceIndex;
   U8BIT runningStatus;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &statusVar);
   if (nextParam)
   {
      /* Should only be 3 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!statusVar) || (statusVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetServiceRunningStatus((S32BIT)serviceIndex, &runningStatus);
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) statusVar)->value = (MHEG5Int)runningStatus;
   }

#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SEI_GetServiceRunningStatus( %d )", runningStatus);
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_GetChannelNumber(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *numVar = 0;
   MHEG5Int serviceIndex;
   S32BIT channelNum;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &numVar);
   if (nextParam)
   {
      /* Should only be 3 parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!numVar) || (numVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetChannelNumber((S32BIT)serviceIndex, &channelNum);
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) numVar)->value = (MHEG5Int)channelNum;
   }
#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SEI_GetChannelNumber( -> %d )", channelNum);
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgPFEI_GetEventId(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *resultVar = 0;
   MHEG5Root *eventIdVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int porf;
   S32BIT eventId;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &porf);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &eventIdVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!eventIdVar) || (eventIdVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetEventId((S32BIT)serviceIndex, (porf) ? TRUE : FALSE, &eventId);
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) eventIdVar)->value = (MHEG5Int)eventId;
      ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;
   }
   else
   {
      ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
   }
#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "PFEI_GetEventId( %d, %d, -> 0x%x )", serviceIndex, porf, eventId);
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_SetEventIterator(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *eventIdVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int startDate;
   MHEG5Int startTime;
   S32BIT eventId;
   E_MhegErr err;

   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &startDate);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &startTime);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &eventIdVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!eventIdVar) || (eventIdVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegSetEventIterator((S32BIT)serviceIndex, (S32BIT)startDate,
         (S32BIT)startTime, &eventId);
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) eventIdVar)->value = (MHEG5Int)eventId;
   }
#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SEI_SetEventIterator( %d, %d, %02d:%02d:%02d, -> 0x%x )",
         serviceIndex, startDate, startTime / 3600, (startTime / 60) % 60, startTime % 60, eventId );
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_IncrementEventIterator(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Root *eventIdVar = 0;
   E_MhegErr err;
   S32BIT eventId;
#ifdef TRACING
   S32BIT oldId;
#endif
   assert(program);
   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &eventIdVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!eventIdVar) || (eventIdVar->clazz != MHEG5INTEGERVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   eventId = (S32BIT)((MHEG5IntegerVariable *) eventIdVar)->value;
#ifdef TRACING
   oldId = eventId;
#endif
   err = DVB_MhegIncrementEventIterator(&eventId);
   if (err == MHERR_OK)
   {
      ((MHEG5IntegerVariable *) eventIdVar)->value = eventId;
   }
#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TEVNTS))
   {
      DBG_PRINTF(T_NL "SEI_IncrementEventIterator( 0x%x -> 0x%x )", oldId, eventId);
   }
#endif
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_GetScheduledEventInfo(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;

   MHEG5Int serviceIndex;
   MHEG5Int eventId;
   MHEG5Root *resultVar;
   MHEG5Root *eventName;
   MHEG5Root *shortDescription;
   MHEG5Root *parentalRating;
   MHEG5Root *startDate;
   MHEG5Root *startTime;
   MHEG5Root *duration;
   MHEG5Root *category;
   MHEG5Root *freeNotCA;

   BOOLEAN result;
   S_EventDetails eventDetails;
   E_MhegErr err;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventId);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &eventName);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &shortDescription);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &parentalRating);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &startDate);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &startTime);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &duration);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &category);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &freeNotCA);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!eventName) || (eventName->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!shortDescription) || (shortDescription->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!parentalRating) || (parentalRating->clazz != MHEG5INTEGERVARIABLE) ||
       (!startDate) || (startDate->clazz != MHEG5INTEGERVARIABLE) ||
       (!startTime) || (startTime->clazz != MHEG5INTEGERVARIABLE) ||
       (!duration) || (duration->clazz != MHEG5INTEGERVARIABLE) ||
       (!category) || (category->clazz != MHEG5OCTETSTRINGVARIABLE) ||
       (!freeNotCA) || (freeNotCA->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = DVB_MhegGetScheduledEventDetails((S32BIT)serviceIndex, (S32BIT)eventId,
         &result, &eventDetails);
   if (err == MHERR_OK)
   {
   #ifdef TRACING
      if (mheg_trace_debug & (TACTIONS | TEVNTS))
      {
         DBG_PRINTF(T_NL "SEI_GetScheduledEventInfo( %d, 0x%x, ->%d ", serviceIndex, eventId, result);
      }
   #endif
      if (result)
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;

         GetEventInfo(&eventDetails,
            &((MHEG5OctetStringVariable *)eventName)->value,
            &((MHEG5OctetStringVariable *)shortDescription)->value,
            &((MHEG5IntegerVariable *)parentalRating)->value,
            &((MHEG5IntegerVariable *)startDate)->value,
            &((MHEG5IntegerVariable *)startTime)->value,
            &((MHEG5IntegerVariable *)duration)->value,
            &((MHEG5OctetStringVariable *)category)->value,
            &((MHEG5BooleanVariable *)freeNotCA)->value);
         DVB_MhegReleaseEventDetails(&eventDetails);
      }
      else
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
      #ifdef TRACING
         if (mheg_trace_debug & (TACTIONS | TEVNTS))
         {
            DBG_PRINTF(")");
         }
      #endif
      }
   }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_GetComponentInfo(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventId;
   MHEG5Root *resultVar;
   MHEG5String keyStr;
   MHEG5Root *valueVar;
   MHEG5Bool invalidString;
   BOOLEAN result;
   BOOLEAN value;
   E_MhegErr err;

   static char subtitles[] = "Subtitles";
   static char audioDesc[] = "AudioDesc";
   static char altLang[] = "AltLang";
   static char dolby[] = "Dolby";
   static char hd[] = "HD";

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventId);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &keyStr, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveORef(nextParam, &valueVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!valueVar) || (valueVar->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = MHERR_OTHER;

   if ((keyStr.len != 0) && (keyStr.data != NULL))
   {
      if (strcmp((char *)keyStr.data, subtitles) == 0)
      {
         err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, (S32BIT)eventId,
               &result, MHEG5_COMPONENT_SUBTITLES,
               &value);
      }
      else if (strcmp((char *)keyStr.data, audioDesc) == 0)
      {
         err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, (S32BIT)eventId,
               &result, MHEG5_COMPONENT_AUDIO_DESC,
               &value);
      }
      else if (strcmp((char *)keyStr.data, altLang) == 0)
      {
         err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, (S32BIT)eventId,
               &result, MHEG5_COMPONENT_ALT_LANG,
               &value);
      }
      else if (strcmp((char *)keyStr.data, dolby) == 0)
      {
         err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, (S32BIT)eventId,
               &result, MHEG5_COMPONENT_DOLBY,
               &value);
      }
      else if (strcmp((char *)keyStr.data, hd) == 0)
      {
         err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, (S32BIT)eventId,
               &result, MHEG5_COMPONENT_HD,
               &value);
      }

      if (result)
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;

         if (err == MHERR_OK)
         {
            if (value)
            {
               ((MHEG5BooleanVariable *) valueVar)->value = MHEG5TRUE;
            }
            else
            {
               ((MHEG5BooleanVariable *) valueVar)->value = MHEG5FALSE;
            }
         }
         else
         {
            ((MHEG5BooleanVariable *) valueVar)->value = MHEG5FALSE;
         }
      }
      else
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
      }
   }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgPFEI_GetComponentInfo(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int porf;
   S32BIT eventId;
   MHEG5Root *resultVar;
   MHEG5String keyStr;
   MHEG5Root *valueVar;
   MHEG5Bool invalidString;
   BOOLEAN result;
   BOOLEAN value;
   E_MhegErr err;

   static char subtitles[] = "Subtitles";
   static char audioDesc[] = "AudioDesc";
   static char altLang[] = "AltLang";
   static char dolby[] = "Dolby";
   static char hd[] = "HD";

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &porf);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericOctetString(nextParam, &keyStr, &invalidString);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   nextParam = MHEG5resolveORef(nextParam, &valueVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!valueVar) || (valueVar->clazz != MHEG5BOOLEANVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   err = MHERR_OTHER;

   if ((keyStr.len != 0) && (keyStr.data != NULL))
   {
      err = DVB_MhegGetEventId((S32BIT)serviceIndex, (porf) ? TRUE : FALSE, &eventId);

      if (err == MHERR_OK)
      {
         if (strcmp((char *)keyStr.data, subtitles) == 0)
         {
            err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, eventId,
                  &result, MHEG5_COMPONENT_SUBTITLES,
                  &value);
         }
         else if (strcmp((char *)keyStr.data, audioDesc) == 0)
         {
            err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, eventId,
                  &result, MHEG5_COMPONENT_AUDIO_DESC,
                  &value);
         }
         else if (strcmp((char *)keyStr.data, altLang) == 0)
         {
            err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, eventId,
                  &result, MHEG5_COMPONENT_ALT_LANG,
                  &value);
         }
         else if (strcmp((char *)keyStr.data, dolby) == 0)
         {
            err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, eventId,
                  &result, MHEG5_COMPONENT_DOLBY,
                  &value);
         }
         else if (strcmp((char *)keyStr.data, hd) == 0)
         {
            err = DVB_MhegGetComponentInfo((S32BIT)serviceIndex, eventId,
                  &result, MHEG5_COMPONENT_HD,
                  &value);
         }

         if (result)
         {
            ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;

            if (err == MHERR_OK)
            {
               if (value)
               {
                  ((MHEG5BooleanVariable *) valueVar)->value = MHEG5TRUE;
               }
               else
               {
                  ((MHEG5BooleanVariable *) valueVar)->value = MHEG5FALSE;
               }
            }
            else
            {
               ((MHEG5BooleanVariable *) valueVar)->value = MHEG5FALSE;
            }
         }
         else
         {
            ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
         }
      }
      else
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
      }
   }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgSEI_GetComponentData(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int eventId;
   MHEG5Root *resultVar;
   MHEG5Root *strContVar;
   MHEG5Root *contTypeVar;
   MHEG5Root *langVar;
   MHEG5String *strContStr;
   MHEG5String *contTypeStr;
   MHEG5String *langStr;
   MHEG5String buffer;
   BOOLEAN result;
   U8BIT strCont[256];
   U8BIT contType[256];
   U8BIT lang[256];
   E_MhegErr err;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &eventId);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &strContVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &contTypeVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &langVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!strContVar) || (strContVar->clazz != MHEG5OCTETSTRINGVARIABLE)) ||
       ((!contTypeVar) || (contTypeVar->clazz != MHEG5OCTETSTRINGVARIABLE)) ||
       ((!langVar) || (langVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   strContStr = &((MHEG5OctetStringVariable *)strContVar)->value;
   contTypeStr = &((MHEG5OctetStringVariable *)contTypeVar)->value;
   langStr = &((MHEG5OctetStringVariable *)langVar)->value;

   err = DVB_MhegGetComponentData((S32BIT)serviceIndex, (S32BIT)eventId,
         &result, strCont, contType, lang);
   if (err == MHERR_OK && result)
   {
      ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;

      MHEG5stringDestruct(strContStr);
      MHEG5stringDestruct(contTypeStr);
      MHEG5stringDestruct(langStr);

      buffer.len = strlen((char *)strCont);
      buffer.data = strCont;
      *strContStr = MHEG5stringCopy(buffer);

      buffer.len = strlen((char *)contType);
      buffer.data = contType;
      *contTypeStr = MHEG5stringCopy(buffer);

      buffer.len = strlen((char *)lang);
      buffer.data = lang;
      *langStr = MHEG5stringCopy(buffer);
   }
   else
   {
      ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
   }

   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#ifdef INCLUDE_SA_PROFILE

static MHEG5ErrorCode MHEG5prgPFEI_GetComponentData(MHEG5Program *program)
{
   MHEG5GList *nextParam;
   MHEG5Root *callVar = 0;
   MHEG5Int serviceIndex;
   MHEG5Int porf;
   S32BIT eventId;
   MHEG5Root *resultVar;
   MHEG5Root *strContVar;
   MHEG5Root *contTypeVar;
   MHEG5Root *langVar;
   MHEG5String *strContStr;
   MHEG5String *contTypeStr;
   MHEG5String *langStr;
   MHEG5String buffer;
   BOOLEAN result;
   U8BIT strCont[256];
   U8BIT contType[256];
   U8BIT lang[256];
   E_MhegErr err;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &serviceIndex);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveGenericInteger(nextParam, &porf);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &resultVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &strContVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &contTypeVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   nextParam = MHEG5resolveORef(nextParam, &langVar);
   if (nextParam)
   {
      /* Too many parameters */
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!resultVar) || (resultVar->clazz != MHEG5BOOLEANVARIABLE)) ||
       ((!strContVar) || (strContVar->clazz != MHEG5OCTETSTRINGVARIABLE)) ||
       ((!contTypeVar) || (contTypeVar->clazz != MHEG5OCTETSTRINGVARIABLE)) ||
       ((!langVar) || (langVar->clazz != MHEG5OCTETSTRINGVARIABLE)))
   {
      return MHEG5ERR_WRONGPARAM;
   }

   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

   strContStr = &((MHEG5OctetStringVariable *)strContVar)->value;
   contTypeStr = &((MHEG5OctetStringVariable *)contTypeVar)->value;
   langStr = &((MHEG5OctetStringVariable *)langVar)->value;

   err = DVB_MhegGetEventId((S32BIT)serviceIndex, (porf) ? TRUE : FALSE, &eventId);
   if (err == MHERR_OK)
   {
      err = DVB_MhegGetComponentData((S32BIT)serviceIndex, eventId,
            &result, strCont, contType, lang);
      if (err == MHERR_OK && result)
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5TRUE;

         MHEG5stringDestruct(strContStr);
         MHEG5stringDestruct(contTypeStr);
         MHEG5stringDestruct(langStr);

         buffer.len = strlen((char *)strCont);
         buffer.data = strCont;
         *strContStr = MHEG5stringCopy(buffer);

         buffer.len = strlen((char *)contType);
         buffer.data = contType;
         *contTypeStr = MHEG5stringCopy(buffer);

         buffer.len = strlen((char *)lang);
         buffer.data = lang;
         *langStr = MHEG5stringCopy(buffer);
      }
      else
      {
         ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
      }
   }
   else
   {
      ((MHEG5BooleanVariable *) resultVar)->value = MHEG5FALSE;
   }
   return MHEG5ERR_NOERROR;
}

#endif  /* defined(INCLUDE_SA_PROFILE) */

#endif  /* INCLUDE_SI_EXTENSION */

#ifdef INCLUDE_TPS

static MHEG5ErrorCode MHEG5prgPersistentStorageInfo(MHEG5Program *program)
{
   MHEG5Root *callVar = 0;
   MHEG5GList *nextParam;
   MHEG5Root *enabled;

   assert(program);

   nextParam = MHEG5resolveORef(program->parameter, &callVar);
   if (!nextParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef( nextParam, &enabled);
   if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
       (!enabled) || (enabled->clazz != MHEG5BOOLEANVARIABLE))
   {
      return MHEG5ERR_WRONGPARAM;
   }
   ((MHEG5BooleanVariable *) enabled)->value = MHEG5GetTpsStatus();
   ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;
   return MHEG5ERR_NOERROR;
}

#endif

#ifdef INCLUDE_CONNECTED_TV
/*******************************************************************************
*@begin
* NAME: MHEG5notifyApplicationLaunchStatus
*       Pass a response from the external application to the ApplicationLaunch
*       resident program.
*
* Returns : void
*
* Parameter     Flow    Description
* ------------------------------------------------------------------------------
* success       IN      Indicates whether the application was launched
*
* Externals     Flow    Usage
* ------------------------------------------------------------------------------
*
* Additional information:
*
* This function is invoked as part of the Deactivate action on a resident program.
*
*@end
*******************************************************************************/
void MHEG5notifyApplicationLaunchStatus(MHEG5Bool success)
{
    MHEG5Program *program = application_launch_program;
    if (program != NULL)
    {
        /* Store result */
        *((MHEG5Bool *)(program->resultValue)) = success;

        /* Call/Fork succeeded */
        *(program->forkSucceededValue) = MHEG5TRUE;

        ProgramCompleted( program );

        application_launch_program = NULL;
    }
}


/*******************************************************************************
*@begin
* NAME: MHEG5prgApplicationLaunch
*       Implementation of the ApplicationLaunch (ApL) resident program
*
* Returns : MHEG5ErrorCode - see mh5base.h
*
* Parameter     Flow    Description
* ------------------------------------------------------------------------------
* program       IN/OUT  Program object that is running
*
* Externals     Flow    Usage
* ------------------------------------------------------------------------------
*
* Additional information:
*
*   B.4.3.1.2.1 GetLaunchArguments
*
*   Synopsis: Hands control of execution to another application of an
*             arbitrary type.
*
*   Arguments: ApL (location, [name, value]..., success)
*
*   Causes a new application to be started with the specified
*   arguments. The application to run is specified by the location
*   parameter.
*
*   The Application launched using this resident program is classified
*   as broadcast-related, as described in B.4.2.1.7 Relation of
*   Applications to Broadcast.
*
*   A side-effect of the resident program may be that the MHEG engine
*   is stopped (killing the application). In all cases the state of
*   the True Persistent Storage shall not be affected.
*
*   Flow    Type                    Name        Comment
*
*   input   GenericOctetString      location    Location of the application to
*                                               run
*   input   GenericOctetString      name        List of name/value pairs to be
*   input   GenericBoolean or       value       passed to the application
*           GenericInteger or
*           GenericOctetString
*   output  GenericBoolean [1]      success     True if the application started
*                                               successfully, false otherwise.
*
*   [1] (Shall provide an IndirectReference to a BooleanVariable)
*
*@end
*******************************************************************************/
static MHEG5ErrorCode MHEG5prgApplicationLaunch(MHEG5Program *program)
{
    MHEG5GList *secondParam = 0, *thirdParam = 0, *prevParam, *nextParam = 0;
    MHEG5Root *callVar = 0;
    MHEG5Root *successVar = 0;
    MHEG5BooleanVariable *rc;
    MHEG5String location;
    MHEG5String data;
    MHEG5Bool invalidString;
    MHEG5String name;
    MHEG5Generic g;
    U8BIT *buffer = 0;
    MHEG5Int allocated = 0, used = 0;
    MHEG5Bool success;

    assert(program);

    /* callVar */
    secondParam = MHEG5resolveORef(program->parameter, &callVar);
    if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) {
        return MHEG5ERR_WRONGPARAM;
    }
    if (!secondParam) {
        return MHEG5ERR_WRONGNUMBEROFPARAMS;
    }

    /* Location */
    thirdParam = MHEG5resolveGenericOctetString(secondParam, &location,
                                                &invalidString);
    if (!thirdParam) {
        return MHEG5ERR_WRONGNUMBEROFPARAMS;
    }
    if (invalidString) {
        /* Parameter was not an octet string */
        return MHEG5ERR_WRONGPARAM;
    }

    buffer = NULL;

    /* Next parameter can be either GenericOctetString (name) or
     * GenericBoolean pointing at BooleanVariable (success)
     */
    prevParam = thirdParam;
    nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
    while (nextParam && g.type == MHEG5OCTETSTRING)
    {
        name = g.value.s;

        /* Next parameter can be many things. */
        prevParam = nextParam;
        nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
        success = MHEG5parseEncodeField(&buffer, &used, &allocated, &name, &g);
        if (!success)
        {
            nextParam = NULL;
            break;
        }

        /* Next parameter can be either GenericOctetString (name) or
         * GenericBoolean pointing at BooleanVariable (success)
         */
        prevParam = nextParam;
        nextParam = MHEG5resolveGenericGeneric(prevParam, &g);
    }

    /* resolve success */
    nextParam = MHEG5resolveORef(prevParam, &successVar);
    if (nextParam != NULL) {
        MHEG5freeMem(buffer);
        return MHEG5ERR_WRONGNUMBEROFPARAMS;
    }
    if ((!successVar) || (successVar->clazz != MHEG5BOOLEANVARIABLE)) {
        MHEG5freeMem(buffer);
        return MHEG5ERR_WRONGPARAM;
    }
    rc = (MHEG5BooleanVariable *)successVar;

    program->resultValue = &rc->value;

    /* Set the forkSuceeded to default to FALSE */
    program->forkSucceededValue = &((MHEG5BooleanVariable *) callVar)->value;

    /* For a called program disable event processing until the program ends */
    if (!program->forked) {
        MHEG5enableEventProcessing(MHEG5FALSE);
    }

    if (success)
    {
        data.len = used;
        data.data = buffer;
    }
    else
    {
        data.len = 0;
        data.data = NULL;
    }

    application_launch_program = program;
    MHEG5ApplicationLaunch(&location, &data);
    MHEG5freeMem(buffer);

    return MHEG5ERR_NOERROR;
}

/*******************************************************************************
*@begin
* NAME: MHEG5prgGetLaunchArguments
*       Implementation of the GetLaunchArguments (GLA) resident program
*
* Returns : MHEG5ErrorCode - see mh5base.h
*
* Parameter     Flow    Description
* ------------------------------------------------------------------------------
* program       IN/OUT  Program object that is running
*
* Externals     Flow    Usage
* ------------------------------------------------------------------------------
*
* Additional information:
*
*   B.4.3.1.2.2 GetLaunchArguments
*
*   Synopsis: Retrieves an argument set by another application of an
*             arbitrary type.
*
*   Arguments: GLA( name, value )
*
*   Retrieves the value of the named argument. Arguments can be set by
*   applications of an arbitrary type, other than MHEG, when launching
*   an MHEG application.
*
*   The value of the argument is provided to the application as an
*   OctetStringVariable. It is the responsibility of the application
*   to convert this value into another type (using the SetVariable
*   elementary action or one of the type conversion resident programs)
*   if required.
*
*   If the argument to be retrieved does not exist then the resident
*   program succeeds and the value parameter is a zero length string.
*
*   Flow    Type                    Name        Comment
*   Input   GenericOctetString      name
*   Output  GenericOctetString [1]  value
*
*   [1] (Shall provide an IndirectReference to an OctetStringVariable)
*
*@end
*******************************************************************************/
static MHEG5ErrorCode MHEG5prgGetLaunchArguments(MHEG5Program *program)
{
    MHEG5GList *secondParam = 0, *thirdParam = 0;
    MHEG5Root *callVar = 0, *osVar = 0;
    MHEG5String name;
    MHEG5OctetStringVariable *value;
    MHEG5Bool invalidString;

    assert(program);

    secondParam = MHEG5resolveORef(program->parameter, &callVar);
    if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE)) {
        return MHEG5ERR_WRONGPARAM;
    }
    if (!secondParam) {
        return MHEG5ERR_WRONGNUMBEROFPARAMS;
    }
    thirdParam = MHEG5resolveGenericOctetString(secondParam, &name, &invalidString);
    if (!thirdParam) {
        return MHEG5ERR_WRONGNUMBEROFPARAMS;
    }
    if (invalidString) {
        /* Parameter was not an octet string */
        return MHEG5ERR_WRONGPARAM;
    }

    MHEG5resolveORef(thirdParam, &osVar);
    if ((!callVar) || (callVar->clazz != MHEG5BOOLEANVARIABLE) ||
        (!osVar) || (osVar->clazz != MHEG5OCTETSTRINGVARIABLE)) {
        return MHEG5ERR_WRONGPARAM;
    }
    value = (MHEG5OctetStringVariable *) osVar;
    ((MHEG5BooleanVariable *) callVar)->value = MHEG5TRUE;

    MHEG5stringDestruct(&value->value);
    value->value.len = 0;
    value->value.data = NULL;

    return MHEG5ERR_NOERROR;
}
#endif  /* INCLUDE_CONNECTED_TV */



void MHEG5ProgramSetStartFunc(MHEG5Program *program)
{
   S32BIT i;

   /* List of resident programs supported by UK1.05 profile */
   static const ResidentProgramTableEntry_t ProgramTable[] = {
      /* Short names */
      { "GCD", &MHEG5prgGetCurrentDate, NULL },
      { "FDa", &MHEG5prgFormatDate, NULL },
      { "GDW", &MHEG5prgGetDayOfWeek, NULL },
      { "Rnd", &MHEG5prgRandom, NULL },
      { "CTC", &MHEG5prgCastToContentRef, NULL },
      { "CTO", &MHEG5prgCastToObjectRef, NULL },
      { "CSI", &MHEG5prgCastToStringInt, NULL },
      { "GSL", &MHEG5prgGetStringLength, NULL },
      { "GSS", &MHEG5prgGetSubString, NULL },
      { "SSS", &MHEG5prgSearchSubString, NULL },
      { "SES", &MHEG5prgSearchAndExtractSubString, NULL },
      { "GSI", &MHEG5prgSI_GetServiceIndex, NULL },
#ifndef CI_PLUS_ONLY
      { "TIn", &MHEG5prgSI_TuneIndex, NULL },
      { "TII", &MHEG5prgSI_TuneIndexInfo, NULL },
      { "VTG", &MHEG5prgVideoToGraphics, NULL },
      { "SSM", &MHEG5prgSetSubtitleMode, NULL },
      { "SWA", &MHEG5prgSetWidescreenAlignment, NULL },
#endif
      { "BSI", &MHEG5prgSI_GetBasicSI, NULL },
      { "CCR", &MHEG5prgCheckContentRef, &clearOrmHandle },
      { "CGR", &MHEG5prgCheckGroupIDRef, &clearOrmHandle },
      { "CIS", &MHEG5prgCI_SendMessage, NULL },
#ifndef CI_PLUS_ONLY
      { "GBI", &MHEG5prgGetBootInfo, NULL },
#endif  /* !CI_PLUS_ONLY */
      { "WAI", &MHEG5prgWhoAmI, NULL },
#ifdef INCLUDE_DEBUG_PACKAGE
      { "DBG", &MHEG5prgDebug, NULL },
#endif  /* INCLUDE_DEBUG_PACKAGE*/
      { "GDA", &MHEG5prgGetDisplayAspectRatio, NULL },
#ifdef INCLUDE_NATIVE_APP
      { "SBI", &MHEG5prgSetBroadcasterInterruptions, NULL },
#endif /*INCLUDE_NATIVE_APP*/
#ifdef INCLUDE_PVR_AU
      { "PMB2", &MHEG5prgPVR_MakeBooking2, NULL },
      { "PCB2", &MHEG5prgPVR_CancelBooking2, NULL },
      { "PLB2", &MHEG5prgPVR_ListBookings2, NULL },
      { "PGD2", &MHEG5prgPVR_GetDetails2, NULL },
#endif /*INCLUDE_PVR_AU*/
#ifdef INCLUDE_MHEG_PVR
      { "PMB", &MHEG5prgPVR_MakeBooking, NULL },
      { "PCB", &MHEG5prgPVR_CancelBooking, NULL },
      { "PLB", &MHEG5prgPVR_ListBookings, NULL },
#endif /*INCLUDE_MHEG_PVR*/
#ifdef INCLUDE_SA_PROFILE
      { "GPL", &MHEG5prgLNG_GetPreferredLangs, NULL },
      { "GAu", &MHEG5prgLNG_GetAudioLangs, NULL },
      { "GSb", &MHEG5prgLNG_GetSubtitleLangs, NULL },
      { "GAD", &MHEG5prgLNG_GetADLangs, NULL },
      { "GNS", &MHEG5prgSEI_GetNumberOfServices, NULL },
      { "NSI", &MHEG5prgSEI_NextServiceIndex, NULL },
      { "GSR", &MHEG5prgSEI_GetServiceRunningStatus, NULL },
      { "GCN", &MHEG5prgSEI_GetChannelNumber, NULL },
      { "SEv", &MHEG5prgSEI_SetEventIterator, NULL },
      { "IEI", &MHEG5prgSEI_IncrementEventIterator, NULL },
      { "GSE", &MHEG5prgSEI_GetScheduledEventInfo, NULL },
      { "SCI", &MHEG5prgSEI_GetComponentInfo, NULL },
      { "SCD", &MHEG5prgSEI_GetComponentData, NULL },
      { "GID", &MHEG5prgPFEI_GetEventId, NULL },
      { "PCI", &MHEG5prgPFEI_GetComponentInfo, NULL },
      { "PCD", &MHEG5prgPFEI_GetComponentData, NULL },
      { "SNR", &MHEG5prgREM_SetNativeReminder, NULL },
      { "GNR", &MHEG5prgREM_GetNativeReminder, NULL },
      { "CNR", &MHEG5prgREM_CancelNativeReminder, NULL },
      { "GHS", &MHEG5prgSA_GetHostSetting, NULL },
#endif /*INCLUDE_SA_PROFILE*/
#ifdef INCLUDE_CI_PLUS
      { "RMD", &MHEG5prgRequestMPEGDecoder, NULL },
      { "SMG", &MHEG5prgSuppressMHEGGraphics, NULL },
#endif /*INCLUDE_CI_PLUS*/
      { "TIM", &MHEG5prgTestInputMask, NULL },
#ifdef INCLUDE_IC
      { "SHF", &MHEG5prgSetHybridFileSystem, NULL },
      { "GIS", &MHEG5prgGetICStatus, NULL },
      { "RDa", &MHEG5prgReturnData, NULL },
      { "GCk", &MHEG5prgGetCookie, NULL },
      { "SCk", &MHEG5prgSetCookie, NULL },
#ifdef INCLUDE_ICS
      { "PFG", &MHEG5prgPromptForGuidance, &stopPrompt },
      { "MSP", &MHEG5prgMeasureStreamPerformance, &stopMeasurement },
#ifdef INCLUDE_IPLAYER
      { "GPS", &MHEG5prgGetPINSupport, NULL },
#endif /*INCLUDE_IPLAYER*/
#if defined(INCLUDE_IPLAYER) || defined(INCLUDE_FREESAT)
      { "GAP", &MHEG5prgGetAudioDescPref, NULL },
      { "GSP", &MHEG5prgGetSubtitlePref, NULL },
#endif /*defined(INCLUDE_IPLAYER) || defined(INCLUDE_FREESAT)*/
#ifdef INCLUDE_FREESAT
      { "GPR", &MHEG5prgGetPINRequirement, NULL },
      { "VPP", &MHEG5prgValidatePIN, NULL },
      { "CPS", &MHEG5prgComputePrivateSignature, NULL },
#endif /*INCLUDE_FREESAT*/
#endif /*INCLUDE_ICS*/
#endif /*INCLUDE_IC*/
#ifdef INCLUDE_FREESAT
      { "FSI", &MHEG5prgGetFSIServiceReference, NULL },
#endif /*INCLUDE_FREESAT*/
#ifdef INCLUDE_SI_EXTENSION
      { "SeI", &MHEG5prgSI_GetServiceInfo, NULL },
      { "GEI", &MHEG5prgSI_GetEventInfo, NULL },
#endif
#ifdef INCLUDE_TPS
      { "PST", &MHEG5prgPersistentStorageInfo, NULL },

#endif
#ifdef INCLUDE_CONNECTED_TV
      { "GLA", &MHEG5prgGetLaunchArguments, NULL },
      { "ApL", &MHEG5prgApplicationLaunch, NULL },
#endif /*INCLUDE_CONNECTED_TV*/
      /* Long names */
      { "GetCurrentDate",
        &MHEG5prgGetCurrentDate, NULL },
      { "FormatDate",
        &MHEG5prgFormatDate, NULL },
      { "GetDayOfWeek",
        &MHEG5prgGetDayOfWeek, NULL },
      { "Random",
        &MHEG5prgRandom, NULL },
      { "CastToContentRef",
        &MHEG5prgCastToContentRef, NULL },
      { "CastToObjectRef",
        &MHEG5prgCastToObjectRef, NULL },
      { "CastToStringInt",
        &MHEG5prgCastToStringInt, NULL },
      { "GetStringLength",
        &MHEG5prgGetStringLength, NULL },
      { "GetSubString",
        &MHEG5prgGetSubString, NULL },
      { "SearchSubString",
        &MHEG5prgSearchSubString, NULL },
      { "SearchAndExtractSubString",
        &MHEG5prgSearchAndExtractSubString, NULL },
      { "SI_GetServiceIndex",
        &MHEG5prgSI_GetServiceIndex, NULL },
#ifndef CI_PLUS_ONLY
      { "SI_TuneIndex",
        &MHEG5prgSI_TuneIndex, NULL },
      { "SI_TuneIndexInfo",
        &MHEG5prgSI_TuneIndexInfo, NULL },
      { "VideoToGraphics",
        &MHEG5prgVideoToGraphics, NULL },
      { "SetSubtitleMode",
        &MHEG5prgSetSubtitleMode, NULL },
      { "SetWidescreenAlignment",
        &MHEG5prgSetWidescreenAlignment, NULL },
#endif
      { "SI_GetBasicSI",
        &MHEG5prgSI_GetBasicSI, NULL },
      { "CheckContentRef",
        &MHEG5prgCheckContentRef, &clearOrmHandle },
      { "CheckGroupIDRef",
        &MHEG5prgCheckGroupIDRef, &clearOrmHandle },
      { "CI_SendMessage",
        &MHEG5prgCI_SendMessage, NULL },
#ifndef CI_PLUS_ONLY
      { "GetBootInfo",
        &MHEG5prgGetBootInfo, NULL },
#endif  /* !CI_PLUS_ONLY */
      { "WhoAmI",
        &MHEG5prgWhoAmI, NULL },
#ifdef INCLUDE_DEBUG_PACKAGE
      { "Debug",
        &MHEG5prgDebug, NULL },
#endif  /* INCLUDE_DEBUG_PACKAGE */
      { "GetDisplayAspectRatio",
        &MHEG5prgGetDisplayAspectRatio, NULL },
#ifdef INCLUDE_NATIVE_APP
      { "SetBroadcasterInterruptions",
        &MHEG5prgSetBroadcasterInterruptions, NULL },
#endif /*INCLUDE_NATIVE_APP*/
#ifdef INCLUDE_PVR_AU
      { "PVR_MakeBooking2",
        &MHEG5prgPVR_MakeBooking2, NULL },
      { "PVR_CancelBooking2",
        &MHEG5prgPVR_CancelBooking2, NULL },
      { "PVR_ListBooking2",
        &MHEG5prgPVR_ListBookings2, NULL },
      { "PVR_GetDetails2",
        &MHEG5prgPVR_GetDetails2, NULL },
#endif /*INCLUDE_PVR_AU*/
#ifdef INCLUDE_MHEG_PVR
      { "PVR_MakeBooking",
        &MHEG5prgPVR_MakeBooking, NULL },
      { "PVR_CancelBooking",
        &MHEG5prgPVR_CancelBooking, NULL },
      { "PVR_ListBooking",
        &MHEG5prgPVR_ListBookings, NULL },
#endif /*INCLUDE_MHEG_PVR*/
#ifdef INCLUDE_SA_PROFILE
      { "LNG_GetPreferredLangs",
        &MHEG5prgLNG_GetPreferredLangs, NULL },
      { "LNG_GetAudioLangs",
        &MHEG5prgLNG_GetAudioLangs, NULL },
      { "LNG_GetSubtitleLangs",
        &MHEG5prgLNG_GetSubtitleLangs, NULL },
      { "LNG_GetADLangs",
        &MHEG5prgLNG_GetADLangs, NULL },
      { "SEI_GetNumberOfServices",
        &MHEG5prgSEI_GetNumberOfServices, NULL },
      { "SEI_NextServiceIndex",
        &MHEG5prgSEI_NextServiceIndex, NULL },
      { "SEI_GetServiceRunningStatus",
        &MHEG5prgSEI_GetServiceRunningStatus, NULL },
      { "SEI_GetChannelNumber",
        &MHEG5prgSEI_GetChannelNumber, NULL },
      { "SEI_SetEventIterator",
        &MHEG5prgSEI_SetEventIterator, NULL },
      { "SEI_IncrementEventIterator",
        &MHEG5prgSEI_IncrementEventIterator, NULL },
      { "SEI_GetScheduledEventInfo",
        &MHEG5prgSEI_GetScheduledEventInfo, NULL },
      { "SEI_GetComponentInfo",
        &MHEG5prgSEI_GetComponentInfo, NULL },
      { "SEI_GetComponentData",
        &MHEG5prgSEI_GetComponentData, NULL },
      { "PFEI_GetEventId",
        &MHEG5prgPFEI_GetEventId, NULL },
      { "PFEI_GetComponentInfo",
        &MHEG5prgPFEI_GetComponentInfo, NULL },
      { "PFEI_GetComponentData",
        &MHEG5prgPFEI_GetComponentData, NULL },
      { "REM_SetNativeReminder",
        &MHEG5prgREM_SetNativeReminder, NULL },
      { "REM_GetNativeReminder",
        &MHEG5prgREM_GetNativeReminder, NULL },
      { "REM_CancelNativeReminder",
        &MHEG5prgREM_CancelNativeReminder, NULL },
      { "SA_GetHostSetting",
        &MHEG5prgSA_GetHostSetting, NULL },
#endif /*INCLUDE_SA_PROFILE*/
#ifdef INCLUDE_CI_PLUS
      { "RequestMPEGDecoder",
        &MHEG5prgRequestMPEGDecoder, NULL },
      { "SuppressMHEGGraphics",
        &MHEG5prgSuppressMHEGGraphics, NULL },
#endif /*INCLUDE_CI_PLUS*/
      { "TestInputMask",
        &MHEG5prgTestInputMask, NULL },
#ifdef INCLUDE_IC
      { "SetHybridFileSystem",
        &MHEG5prgSetHybridFileSystem, NULL },
      { "GetICStatus",
        &MHEG5prgGetICStatus, NULL },
      { "ReturnData",
        &MHEG5prgReturnData, NULL },
      { "GetCookie",
        &MHEG5prgGetCookie, NULL },
      { "SetCookie",
        &MHEG5prgSetCookie, NULL },
#ifdef INCLUDE_ICS
      { "PromptForGuidance",
        &MHEG5prgPromptForGuidance, &stopPrompt },
      { "MeasureStreamPerformance",
        &MHEG5prgMeasureStreamPerformance, &stopMeasurement },
#ifdef INCLUDE_IPLAYER
      { "GetPINSupport",
        &MHEG5prgGetPINSupport, NULL },
#endif /*INCLUDE_IPLAYER*/
#if defined(INCLUDE_IPLAYER) || defined(INCLUDE_FREESAT)
      { "GetAudioDescPref",
        &MHEG5prgGetAudioDescPref, NULL },
      { "GetSubtitlePref",
        &MHEG5prgGetSubtitlePref, NULL },
#endif /*defined(INCLUDE_IPLAYER) || defined(INCLUDE_FREESAT)*/
#ifdef INCLUDE_FREESAT
      { "GetPINRequirement",
        &MHEG5prgGetPINRequirement, NULL },
      { "ValidatePIN",
        &MHEG5prgValidatePIN, NULL },
      { "ComputePrivateSignature",
        &MHEG5prgComputePrivateSignature, NULL },
#endif /*INCLUDE_FREESAT*/
#endif /*INCLUDE_ICS*/
#endif /*INCLUDE_IC*/
#ifdef INCLUDE_FREESAT
      { "GetFSIServiceReference",
        &MHEG5prgGetFSIServiceReference, NULL },
#endif /*INCLUDE_FREESAT*/
#ifdef INCLUDE_SI_EXTENSION
      { "SI_GetServiceInfo",
        &MHEG5prgSI_GetServiceInfo, NULL },
      { "SI_GetEventInfo",
        &MHEG5prgSI_GetEventInfo, NULL },
#endif
#ifdef INCLUDE_TPS
      { "PersistentStorageInfo",
        &MHEG5prgPersistentStorageInfo, NULL },
#endif
#ifdef INCLUDE_CONNECTED_TV
      { "GetLaunchArguments",
         &MHEG5prgGetLaunchArguments, NULL },
      { "ApplicationLaunch",
        &MHEG5prgApplicationLaunch, NULL },
#endif /*INCLUDE_CONNECTED_TV*/

      { NULL, NULL, NULL }      /* End of list */
   };

   assert(program);
   assert(program->ingredient.root.clazz == MHEG5RESIDENTPROGRAM);
   assert(program->startFunc == NULL);

   if (program->name.len == 0)
   {
        #ifdef MHEG5LOG
      MHEG5LogPrintf(MHEG5ERROR, "MHEG5Program - Empty program name\n");
        #endif
   }
   else
   {
        #ifdef MHEG5LOG
      MHEG5LogPrintf(MHEG5MESSAGE, "MHEG5Program - Executing program ");
      MHEG5LogPrintString(MHEG5MESSAGE, program->name);
      MHEG5LogPrintf(MHEG5MESSAGE, "\n");
        #endif

      program->startFunc = NULL;
      program->stopFunc = NULL;

      for (i = 0; ProgramTable[i].name != NULL; i++)
      {
         if (strcmp((char *)program->name.data,
                (char *)ProgramTable[i].name) == 0)
         {
            program->startFunc = ProgramTable[i].startFunction;
            program->stopFunc = ProgramTable[i].stopFunction;
            return;
         }
      }
   }
}