glue_dsmcc.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2013 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "stb_os.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "glue_queue.h"
#include "glue_main.h"
#include "dsm_client.h"
#include "dsm_control.h"
#include "mh5queue.h"
#include "mh5control.h"
#include "mh5display.h"
#include "dvb_service.h"
#ifdef MULTI_OSD_LANGS
#include "dvb_misc.h"
#else
#include "dvb_native.h"
#endif
#include "glue_dsmcc.h"
#include "glue_events.h"
#ifdef INCLUDE_DSM_FG
#include "mh5filegroup.h"
#include "mh5fileorm.h"
#endif

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

#define DBC_ID_SSU            0x000A
#define DBC_ID_MHEG5          0x0106
#define DBC_ID_OAD            0x0111
#define DBC_ID_HBBTV          0x0123
#define DBC_ID_MHP0           0x00F0
#define DBC_ID_MHP1           0x00F1

#define MHEG_NETBOOT_DESC     0x01
#define MHEG_SERVICE_DESC     0x02

#define DBC_PREF_NONE         0x0000
#define DBC_PREF_MHEG5        0x0100
//#define DBC_APP_TYPE_MHEG5 0x0008
//#define DBC_APP_TYPE_HBBTV 0x0010
#define INVALID_ATAG          0xFFFF
#define LIFECYCLE_EVENT_ID    0xFFFF
#define INVALID_NB            0xFF

#define MAX_PATH_NAME_SIZE 65

#ifndef DSMCC_SECTION_CACHE_64K_BUFFERS
#define DSMCC_SECTION_CACHE_64K_BUFFERS 16
#endif

#ifndef DSMCC_WORKING_4K_BUFFER_POOL
#define DSMCC_WORKING_4K_BUFFER_POOL 180
#endif
#ifdef MULTI_OSD_LANGS
#define MAX_LANG_CODES  4
#else
#define MAX_LANG_CODES  1
#define DVB_MhegOsdLanguageCodes MhegOsdLanguageCodes
#endif

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

typedef struct s_dbc_app
{
   struct s_dbc_app *next;
   U32BIT carouselId;
   U32BIT appId;
   U16BIT associationTag;
   U8BIT nb_version;
   U8BIT nb_action;
   S_STRING nb_info;
} S_DBC_APP;

typedef struct s_service_dbc
{
   struct s_service_dbc *next;
   U16BIT service_id;
   S_DBC_APP *dbc_apps;
} S_SERVICE_DBC;

/*---local (static) variable declarations for this file----------------------*/
/*   (internal variables declared static to make them local) */

static H_DsmControl dsmccControl = NULL;
static const S_STRING null_str = { 0, NULL };

static S_SERVICE_DBC *service_dbcs = NULL;
static S_DBC_APP *temp_apps = NULL;
static H_DsmEvent lifecycle_ehdl = 0;
static U32BIT boot_carousel_id = INVALID_CAROUSEL_ID;
static void *dbc_mutex = 0;

/*------------------- Local function definitions ----------------------------*/

#ifndef MULTI_OSD_LANGS
U8BIT MhegOsdLanguageCodes(U32BIT *langcodes, U8BIT max)
{
   U8BIT lang[4] = { 0, 0, 0, 0 };
   if (DVB_MhegGetOSDLanguage(lang) == MHERR_OK)
   {
      *langcodes = (lang[0]<<16)|(lang[1]<<8)|lang[2];
      return 1;
   }
   return 0;
}
#endif

static S_SERVICE_DBC* FindServiceDbc( U16BIT service_id )
{
   S_SERVICE_DBC *sdbc = service_dbcs;
   while (sdbc != NULL && sdbc->service_id != service_id)
   {
      sdbc = sdbc->next;
   }
   return sdbc;
}

static H_PmtRef ParsePmtStartup( U16BIT service_id )
{
   S_SERVICE_DBC *sdbc;
   DBGTRACE(TSERVICE,"****> service_id=%d",service_id)
   if (service_id == MHEG5GetVideoSid()
   ||  service_id == MHEG5GetAudioSid()
   ||  service_id == MHEG5DefaultServiceId())
   {
      MHEG5RefreshStreams(service_id);
   }
   STB_OSMutexLock(dbc_mutex);
   sdbc = FindServiceDbc( service_id );
   if (sdbc == NULL)
   {
      sdbc = STB_MemAlloc( sizeof(S_SERVICE_DBC));
      if (sdbc != NULL)
      {
         sdbc->service_id = service_id;
         sdbc->dbc_apps = NULL;
         sdbc->next = service_dbcs;
         service_dbcs = sdbc;
      }
   }
   return (H_PmtRef)sdbc;
}

static S_DBC_APP* FindDbcApp( S_SERVICE_DBC *dbc, U32BIT carouselId )
{
   S_DBC_APP *app;
   if (dbc == NULL)
   {
      app = NULL;
   }
   else
   {
      app = dbc->dbc_apps;
      while (app != NULL && app->carouselId != carouselId)
      {
         app = app->next;
      }
   }
   return app;
}

static S_DBC_APP* CreateDbcApp( U32BIT carouselId, U32BIT appId )
{
   S_DBC_APP *app;
   app = STB_MemAlloc( sizeof(S_DBC_APP));
   if (app != NULL)
   {
      app->carouselId = carouselId;
      app->appId = appId;
      app->associationTag = INVALID_ATAG;
      app->nb_version = INVALID_NB;
      app->nb_action = INVALID_NB;
      app->nb_info.zlen = 0;
      app->nb_info.zptr = NULL;
      app->next = temp_apps;
      temp_apps = app;
   }
   return app;
}

static S_DBC_APP* RemoveDbcApp( S_SERVICE_DBC *dbc, U32BIT carouselId )
{
   S_DBC_APP *app, **pApp;
   if (dbc == NULL)
   {
      app = NULL;
   }
   else
   {
      app = dbc->dbc_apps;
      pApp = &(dbc->dbc_apps);
      while (app != NULL)
      {
         if (app->carouselId == carouselId)
         {
            *pApp = app->next;
            break;
         }
         pApp = &(app->next);
         app = app->next;
      }
   }
   return app;
}

static void ClearDbcApps( S_SERVICE_DBC *dbc )
{
   S_DBC_APP *app, *nxt;
   app = dbc->dbc_apps;
   while (app != NULL)
   {
      nxt = app->next;
      STB_MemFree( app );
      app = nxt;
   }
   dbc->dbc_apps = NULL;
}

static void ClearServiceDbcs( void )
{
   S_SERVICE_DBC *dbc, *nxt;
   dbc = service_dbcs;
   while (dbc != NULL)
   {
      nxt = dbc->next;
      ClearDbcApps( dbc );
      STB_MemFree( dbc );
      dbc = nxt;
   }
   service_dbcs = NULL;
}

static void ParseMhegDescriptors( S_DBC_APP *app, U8BIT *dptr, U16BIT dlen )
{
   U8BIT *dptr_end, tag, len;
   U8BIT nb_len = 0, *nb_ptr;
   FUNCTION_START(ParseMhegDescriptors)
   dptr_end = dptr + dlen;
   while (dptr < dptr_end)
   {
      tag = *dptr++;
      len = *dptr++;
      switch (tag)
      {
         case MHEG_NETBOOT_DESC:
            /* Network boot info sub-descriptor */
            app->nb_version = dptr[0];
            app->nb_action = dptr[1];
            if (len > 2)
            {
               nb_len = len - 2;
               nb_ptr = &dptr[2];
            }
            DBGTRACE(TSERVICE, " nb_version=0x%x nb_action=0x%x nb_length=0x%x", app->nb_version, app->nb_action, nb_len )
            break;

         case MHEG_SERVICE_DESC:
            /* Service boot info sub-descriptor */
            app->associationTag = dptr[0] << 8 | dptr[1];
            DBGTRACE(TSERVICE, " SERVICE-BOOT-INFO: assoc_tag=0x%x", app->associationTag)
            break;

         default:
            DBGTRACE(TERROR, "Unknown Mheg tag 0x%x", tag);
      }
      dptr += len;
   }
   if (nb_len)
   {
      app->nb_info = MH5GlueStringCreate( nb_len, nb_ptr );
   }
   FUNCTION_FINISH(ParseMhegDescriptors)
}

static void LifecycleFunc( void *userData, U8BIT *name, U32BIT dataLen, U8BIT *dataPtr )
{
   DBGTRACE(TALWAYS, " ***************************** Rebooting! ")

   // Strictly, clearing the PMT in cache is not required by MHEG spec,
   // but DTG's NDT009 test has lifecycle event just before PMT change
   // and test fails if gets earlier PMT.
   // Clearing of the cached PMT here, makes some sense, but...
   // DTG HD test version 7.50 to 7.80 has such bad timing between LC event and PMT change,
   // that even this (not too unreasonable bodge) does not always 'fix' it. See Squish #3748.
   DSMCC_SiqCacheClearPmt( dsmccControl, MHEG5DefaultServiceId() );

   MHEG5_Reboot();
}

void StopLifecycle(void)
{
   if (lifecycle_ehdl != 0)
   {
      DBGTRACE(TSERVICE, "clear Lifecycle")
      DSMCC_ClientEventUnsubscribe(dsmccControl, lifecycle_ehdl);
      lifecycle_ehdl = 0;
   }
}

static void StartLifecycle( U16BIT atag )
{
   static U16BIT lastatag = INVALID_ATAG;
   if (lastatag != atag)
   {
      DBGTRACE(TSERVICE, "clear Lifecycle atag=0x%x", lastatag)
      StopLifecycle();
   }
   if (lifecycle_ehdl == 0)
   {
      DBGTRACE(TSERVICE, "Starting Lifecycle listen on atag=0x%x", atag)
      if (DSMCC_ClientEventSubscribeId( dsmccControl, atag, LIFECYCLE_EVENT_ID,
             LifecycleFunc, NULL, &lifecycle_ehdl ))
      {
         TRACE(TERROR, (""))
      }
      else
      {
         lastatag = atag;
      }
   }
}

static void ProcessMhegDescriptorChange( S_DBC_APP *oldapp, S_DBC_APP *newapp )
{
   if (newapp == NULL)
   {
      DBGTRACE(TERROR, "No new application")
   }
   else
   {
      DBGTRACE(TSERVICE, "updated application, LC-atag=0x%x nbact=%d nbver=%d oldapp=%p",
         newapp->associationTag, newapp->nb_action, newapp->nb_version, oldapp)
      if (newapp->associationTag != INVALID_ATAG)
      {
         StartLifecycle( newapp->associationTag );
      }
      if (oldapp == NULL ||
          newapp->nb_version != oldapp->nb_version)
      {
         switch (newapp->nb_action)
         {
            case 0x01:
               if (!MHEG5engineIsCiAppRunning())
               {
                  MHEG5_Reboot();
                  break;
               }
               /*else fall tho, and send netboot to CI App */
            case 0x02:
               DBGTRACE(TSERVICE, "Send EE_NETWORK_BOOT_INFO")
               MHEG5_SendEngineEvent( EE_NETWORK_BOOT_INFO );
               break;
            default:;
         }
      }
   }
}

static void ParsePmtFinished(H_PmtRef pmtref)
{
   S_DBC_APP *oldapp, *nxtapp;
   S_SERVICE_DBC *sdbc = (S_SERVICE_DBC *)pmtref;

   DBGTRACE(TSERVICE, "<*** sid=%d boot_cid=%d",sdbc->service_id,boot_carousel_id)
   oldapp = sdbc->dbc_apps;
   while (oldapp != NULL)
   {
      /* there is no longer a data_broadcast id for apps (with carousel id) */
      nxtapp = oldapp->next;
      if (boot_carousel_id == oldapp->carouselId &&
          sdbc->service_id == MHEG5DefaultServiceId())
      {
         DBGTRACE(TALWAYS, " ***************************** Rebooting! ")
         MHEG5_Reboot();
         boot_carousel_id = INVALID_CAROUSEL_ID;
      }
      MH5GlueStringFree( &oldapp->nb_info );
      STB_MemFree( oldapp );
      oldapp = nxtapp;
   }
   sdbc->dbc_apps = temp_apps;
   temp_apps = NULL;
   STB_OSMutexUnlock(dbc_mutex);
}

static U32BIT ParseDataBcastId( H_PmtRef pmtref, U32BIT carouselId,
   U8BIT *dbcPtr, U8BIT dbcLen )
{
   U32BIT pref = DBC_PREF_NONE;
   U16BIT dbcId, appType;
   U8BIT *dptr_end, *dptr;
   U8BIT app_len;
   U16BIT boot_priority = 0;
   S_SERVICE_DBC *dbc;
   S_DBC_APP *oldapp, *newapp;

   FUNCTION_START(ParseDataBcastId)

   dptr = dbcPtr;
   dptr_end = dptr + dbcLen;
   dbcId = dptr[0] << 8 | dptr[1];
   dptr += 2;
   switch (dbcId)
   {
      case DBC_ID_MHEG5:
         dbc = (S_SERVICE_DBC *)pmtref;
         assert( dbc != NULL ); /* SiqProcessPmt ensures this */
         oldapp = RemoveDbcApp(dbc, carouselId);
         newapp = NULL;
         while (dptr < dptr_end)
         {
            appType = dptr[0] << 8 | dptr[1];
            dptr += 2;
            boot_priority = DBC_PREF_MHEG5 + *dptr;
            dptr++;
            app_len = *dptr++;
            switch (appType)
            {
               case 0x0505:
               case 0x0101:
                  if (pref < boot_priority)
                  {
                     pref = boot_priority;
                  }
               /* now fall through to 0x0000 app type */
               case 0x0000: /* this is when no auto-boot app is present, see DBook7 A, C.1 */
                  assert( newapp == NULL );
                  newapp = CreateDbcApp(carouselId, (dbcId << 16) | appType);
                  if (newapp == NULL)
                  {
                     DBGTRACE(TERROR, "Memory failure")
                  }
                  else
                  {
                     DBGTRACE(TSERVICE, "MHEG app type 0x%x (bp=%x)",appType,boot_priority)
                     ParseMhegDescriptors( newapp, dptr, app_len );
                  }
                  break;

               default:
                  DBGTRACE(TERROR, "Unsupported MHEG app type 0x%x", appType);
            }
            dptr += app_len;
         }
         if (dbc->service_id == MHEG5DefaultServiceId())
         {
            /* Pmt Update on current service */
            if (DSMCC_CurrentCarouselId(dsmccControl) == carouselId)
            {
               DBGTRACE(TSERVICE, "carouselId=%d",carouselId)
               ProcessMhegDescriptorChange( oldapp, newapp );
            }
         }
         if (oldapp != NULL)
         {
            MH5GlueStringFree( &oldapp->nb_info );
            STB_MemFree( oldapp );
         }
         break;

      default:
         DBGTRACE(TERROR, "Unsupported Data Broadcast ID 0x%x", dbcId);
   }
   FUNCTION_FINISH(ParseDataBcastId)
   return pref;
}

/*------------------- Global function definitions ---------------------------*/




static U32BIT MH5GlueSiqCurrentApplicationId(void)
{
   S_SERVICE_DBC *sdbc;
   S_DBC_APP *app;
   U32BIT id;
   id = DSMCC_CurrentCarouselId(dsmccControl);
   STB_OSMutexLock(dbc_mutex);
   sdbc = FindServiceDbc( MHEG5DefaultServiceId() );
   DBGTRACE(TSERVICE, "sid=%d,cid=%d", MHEG5DefaultServiceId(), id)
   app = FindDbcApp( sdbc, id );
   if (app == NULL)
   {
      DBGTRACE(TERROR, "No current app")
      id = 0;
   }
   else
   {
      id = app->appId;
   }
   STB_OSMutexUnlock(dbc_mutex);
   DBGTRACE(TSERVICE, "appId=0x%x", id)
   return id;
}

BOOLEAN MH5GlueSiqNetBootInfo(S_STRING *nbinfo)
{
   S_DBC_APP *app;
   S_SERVICE_DBC *sdbc;
   U32BIT carouselId;
   BOOLEAN result;
   carouselId = DSMCC_CurrentCarouselId(dsmccControl);
   STB_OSMutexLock(dbc_mutex);
   sdbc = FindServiceDbc( MHEG5DefaultServiceId() );
   DBGTRACE(TSERVICE, "sid=%d,cid=%d", MHEG5DefaultServiceId(), carouselId)
   app = FindDbcApp( sdbc, carouselId );
   if (app == NULL || app->nb_action == INVALID_NB)
   {
      DBGTRACE(TERROR, "No app (%p) or no net boot desc", app)
      result = FALSE;
   }
   else
   {
      DBGTRACE(TSERVICE, "nb_info=%d %s", app->nb_info.zlen, app->nb_info.zptr) *
      nbinfo = app->nb_info;
      result = TRUE;
   }
   STB_OSMutexUnlock(dbc_mutex);
   return result;
}

static void MH5GlueSiqNewBootCarousel( U32BIT carouselId )
{
   S_DBC_APP *app;
   U16BIT atag;
   DBGTRACE(TSERVICE, "sid=%d,cid=%d", MHEG5DefaultServiceId(), carouselId)
   STB_OSMutexLock(dbc_mutex);
   app = FindDbcApp( FindServiceDbc( MHEG5DefaultServiceId() ), carouselId );
   if (app != NULL)
   {
      atag = app->associationTag;
      DBGTRACE(TSERVICE, "LC-atag=0x%x", atag)
   }
   else
   {
      atag = INVALID_ATAG;
   }
   STB_OSMutexUnlock(dbc_mutex);
   if (atag != INVALID_ATAG)
   {
      StartLifecycle( atag );
   }
}

static void CarouselLoadEvent( H_ObjCarousel carouselRef, E_OCLoadStatus status, U32BIT carouselId )
{
   S_MhegMessage msg;
   DBGTRACE(TMHBOOT|TDSMFG, " ( 0x%x, %d, 0x%x )", carouselRef, status, carouselId )

   switch (status)
   {
      case OC_LOAD_BOOTED:
         TRACE(TMHBOOT, ("OC_LOAD_BOOTED"));
         if (boot_carousel_id == INVALID_CAROUSEL_ID)
         {
            boot_carousel_id = carouselId;
            MH5GlueSiqNewBootCarousel( carouselId );
         }
         msg.proc_msg_func = (F_MSG_PROCESS)MHEG5NotifyCarouselBooted;
         msg.data_type = DT_VALUE;
         msg.data.dsmEvent.hCarousel = carouselRef;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;

      case OC_LOAD_ABORTED_TIMEOUT:
      case OC_LOAD_ABORTED_PATH_ERROR:
      case OC_LOAD_ABORTED_ERROR:
         TRACE(TERROR, ("OC_LOAD_ABORTED_... %d", status));
         msg.proc_msg_func = MHEG5StartReboot;
         msg.data_type = DT_NONE;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;

      case OC_LOAD_COMPLETED:
         TRACE(TMHBOOT, ("OC_LOAD_COMPLETED"));
         msg.proc_msg_func = (F_MSG_PROCESS)MHEG5NotifyCarouselLoaded;
         msg.data_type = DT_VALUE;
         msg.data.dsmEvent.hCarousel = carouselRef;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;

   #ifdef INCLUDE_DSM_FG
      case OC_FILE_GROUP_LIST_LOADED:
         TRACE(TMHBOOT, ("OC_FILE_GROUP_LIST_LOADED"));
         msg.proc_msg_func = (F_MSG_PROCESS)FG_NotifyListLoaded;
         msg.data_type = DT_VALUE;
         msg.data.dsmEvent.hCarousel = carouselRef;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;

      case OC_FILE_GROUP_LIST_CHANGE:
         TRACE(TMHBOOT, ("OC_FILE_GROUP_LIST_CHANGE"));
         msg.proc_msg_func = (F_MSG_PROCESS)FG_NotifyListChanged;
         msg.data_type = DT_VALUE;
         msg.data.dsmEvent.hCarousel = carouselRef;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;

      case OC_FILE_GROUP_VERS_CHANGE:
         TRACE(TMHBOOT, ("OC_FILE_GROUP_VERS_CHANGE"));
         msg.proc_msg_func = (F_MSG_PROCESS)FG_NotifyVersionChanged;
         msg.data_type = DT_VALUE;
         msg.data.dsmEvent.hCarousel = carouselRef;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;
   #endif

      case OC_LOAD_ABORTED_UNLOAD:
         TRACE(TMHBOOT, ("OC_LOAD_ABORTED_UNLOAD"));
         if (boot_carousel_id == carouselId)
         {
            boot_carousel_id = INVALID_CAROUSEL_ID;
         }
         msg.proc_msg_func = (F_MSG_PROCESS)MHEG5NotifyCarouselUnload;
         msg.data_type = DT_VALUE;
         msg.data.dsmEvent.hCarousel = carouselRef;
         VQ_PutMsg(&msg, PRTY_HIGH);
         break;

      case OC_LOAD_IN_PROGRESS:
      default:
         TRACE(TERROR, ("Ignore status %d", status));
         break;
   }
}

E_MhegErr MH5GlueDsmccOpen( U32BIT taskPriority )
{
   E_MhegErr err;
   S_DsmccConfig config;

   err = MHERR_OK;

   config.taskPriority = taskPriority - 1;

   config.sectionBuffPoolSize = DSMCC_WORKING_4K_BUFFER_POOL;

   config.sectionBuffCacheSize = DSMCC_SECTION_CACHE_64K_BUFFERS;

   config.memAlloc = STB_MemAlloc;
   config.memFree = STB_MemFree;

   config.parsePmtInit = ParsePmtStartup;
   config.parseDataBroadcastId = ParseDataBcastId;
   config.parsePmtDone = ParsePmtFinished;

   config.carouselLoad = CarouselLoadEvent;

   config.notifyAitInfo = NULL;
   config.obtainSiDirect = FALSE;

   dbc_mutex = STB_OSCreateMutex();
   if (dbc_mutex == NULL)
   {
      err = MHERR_SYSTEM_RESOURCE_MUTEX;
   }
   else
   {
      dsmccControl = DSMCC_Open( &config );
      if (dsmccControl == NULL)
      {
         STB_OSDeleteMutex(dbc_mutex);
         err = MHERR_DSMCC_INSTANCE_CREATE;
      }
   }
   return err;
}

void MH5GlueDsmccClose(void)
{
   DSMCC_Close( dsmccControl );
   STB_OSDeleteMutex(dbc_mutex);
}

E_MhegErr MH5GlueDsmccStart( S_DVB_LOCATOR *pDvbLoc, U32BIT carouselId, BOOLEAN clear )
{
   if (clear)
   {
      DBGTRACE(TSERVICE, "tid=0x%x", pDvbLoc->transport_stream_id );
      STB_OSMutexLock(dbc_mutex);
      ClearServiceDbcs();
      STB_OSMutexUnlock(dbc_mutex);
   }
   if (!DSMCC_Start( dsmccControl, pDvbLoc, carouselId, DVB_MhegGetDemuxPath()))
   {
      /* This may be a failed NDT. Sensible to clear down and try again (and this time: autoboot) */
      DSMCC_Stop( dsmccControl, RST_MODE_FORCE );
      MHEG5engineDsmTerminate();
      if (!DSMCC_Start( dsmccControl, pDvbLoc, INVALID_CAROUSEL_ID, DVB_MhegGetDemuxPath()))
      {
         return MHERR_OTHER;
      }
   }
   return MHERR_OK;
}

void MH5GlueDsmccStop( U8BIT action )
{
   if (action == STOP_ACTION_MHEG_TUNE)
   {
      DSMCC_Stop( dsmccControl, RST_MODE_PENDING );
   }
   else
   {
      StopLifecycle();
      DSMCC_Stop( dsmccControl, RST_MODE_FORCE );
   }
}

/*******************************************************************************
 * @brief Get the DSMCC instance handle.
 * @return   dsmcc instance
 *******************************************************************************/
void* MHEG5_DsmccInstance(void)
{
   return dsmccControl;
}

static void AutobootClear( void *data )
{
   STR_DataFree( data, MAX_PATH_NAME_SIZE );
}

static U8BIT* ParseServiceContext( U32BIT size, U8BIT *data, U32BIT languageCode,
   S_CONTENT *pContent )
{
   U32BIT iso_639_language_code;
   U8BIT langNum, number_languages;
   U8BIT initial_object_length;
   U8BIT *pathname = NULL;

   TRACE(TMHBOOT, ("lang code %x", languageCode))

   number_languages = *data++;

   for (langNum = 0; langNum != number_languages && size > 4; langNum++)
   {
      TRACE(TMHBOOT, ("try language %c%c%c", data[0],data[1],data[2]))
      iso_639_language_code = (U32BIT)data[0];
      iso_639_language_code = (U32BIT)((iso_639_language_code << 8) | data[1]);
      iso_639_language_code = (U32BIT)((iso_639_language_code << 8) | data[2]);
      data += 3;
      initial_object_length = (U16BIT)*data++;
      size -= 4;
      if (size < initial_object_length)
      {
         break;
      }
      if (iso_639_language_code == languageCode)
      {
         pathname = STR_DataAlloc(MAX_PATH_NAME_SIZE);
         if (pathname)
         {
            /* We have found the required language */
            pathname[0] = '/';
            pathname[1] = '/';
            memcpy( pathname + 2, data, initial_object_length );
            pContent->size = MAX_PATH_NAME_SIZE;
            pContent->data = pathname;
            pContent->destroy = AutobootClear;
            pContent->fs_handle = pathname;
            TRACE(TMHBOOT, ("Found language %c%c%c path=%s", data[-4],data[-3],data[-2], pathname))
         }
         break;
      }
      /* Skip Application Boot Context Service List */
      data += initial_object_length;
      size -= initial_object_length;
   }
   return pathname;
}

void RunAutoboot( S_CONTENT *pContent )
{
   TRACE(TMHBOOT, ("%p",pContent->data))
   MHEG5engineStart(pContent->data, FALSE, FALSE);
   if (pContent->destroy)
   {
      pContent->destroy( pContent->fs_handle );
   }
}

static void ServiceContextComplete( E_FsStatus status, S_CONTENT *content )
{
   S_MhegMessage msg;
   if (status == FS_STATUS_OK)
   {
      msg.data.content.size = 0;
      msg.data.content.data = NULL;
      msg.data.content.destroy = NULL;
      if (content->data != NULL && content->size > 4)
      {
         U32BIT langcodes[MAX_LANG_CODES+1];
         U8BIT langcode_num, id;
         langcode_num = DVB_MhegOsdLanguageCodes(langcodes,MAX_LANG_CODES);
         langcodes[langcode_num] = ISO_639_LANG_CODE_UND;
         langcode_num++;
         for (id = 0; id != langcode_num; id++)
         {
            if (ParseServiceContext(content->size, content->data, langcodes[id], &msg.data.content) != NULL)
            {
               break;
            }
         }
      }
      if (content->destroy)
      {
         content->destroy( content->fs_handle );
      }
      msg.proc_msg_func = (F_MSG_PROCESS)RunAutoboot;
      msg.data_type = DT_CONTENT;
      if (VQ_PutMsg( &msg, PRTY_NORMAL ) != MHERR_OK)
      {
         TRACE(TERROR, ("VQ_PutMsg failed"));
         if (msg.data.content.destroy)
         {
            msg.data.content.destroy( msg.data.content.fs_handle );
         }
      }
   }
   else
   {
      MHEG5AutoPathComplete( status );
   }
}

void MH5GlueDsmccMHEGInitialBoot( void )
{
   E_FsStatus retval;
   U32BIT appId;
   S_CONTENT dsmcontent;
   S_CONTENT pathcontent;

   appId = MH5GlueSiqCurrentApplicationId();
   if ((appId >> 16) != 0x0106)
   {
      /* PMT is not signalling carousel with MHEG - could be for HBBTV */
      TRACE(TMHBOOT, ("Not MHEG data_broadcast_id 0x%x", (appId >> 16)))
      MHEG5AutoPathComplete( FS_STATUS_NONE );
   }
   else
   {
      /* DSMCC_ClientLoadObject uses content's 'size' parameter as means of passing ServiceID for Service context */
      dsmcontent.size = appId;

      retval = DSMCC_ClientLoadObject( MHEG5_DsmccInstance(), (U8BIT *)"", /* NULL pathname for SRG object */
            LOAD_FLAGS_REQUEST_SERVICE_CONTEXT_BIT | LOAD_FLAGS_DEFAULT,
            ServiceContextComplete, &dsmcontent );
      TRACE(TFILE|TMHBOOT, ("rtn=%d", retval))
      if (retval == FS_STATUS_OK)
      {
         pathcontent.size = 0;
         pathcontent.data = NULL;
         pathcontent.destroy = NULL;
         if (dsmcontent.data != NULL && dsmcontent.size > 4)
         {
            U32BIT langcodes[MAX_LANG_CODES+1];
            U8BIT langcode_num, id;
            langcode_num = DVB_MhegOsdLanguageCodes(langcodes,MAX_LANG_CODES);
            langcodes[langcode_num] = ISO_639_LANG_CODE_UND;
            langcode_num++;
            for (id = 0; id != langcode_num; id++)
            {
               if (ParseServiceContext(dsmcontent.size, dsmcontent.data, langcodes[id], &pathcontent) != NULL)
               {
                  break;
               }
            }
         }
         if (dsmcontent.destroy)
         {
            /* Now can unload SRG object */
            dsmcontent.destroy( dsmcontent.fs_handle );
         }
         RunAutoboot( &pathcontent );
      }
      else
      {
         /* An error ocurred */
         TRACE(TERROR, ("retval is %d", retval));
         MHEG5AutoPathComplete( retval );
      }
   }
}

void MH5GlueDsmccReboot( void )
{
   DSMCC_Reboot( dsmccControl );
}