mh5control.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 "mheg5_events.h"
#include "dvb_service.h"
#include "dvb_native.h"

#include "mh5application.h"     /* For Termination      */
#include "mh5scene.h"           /* UserInput for Scene  */
#include "mh5queue.h"           /* Events               */
#include "glue_memory.h"
#include "glue_queue.h"
#include "glue_timers.h"
#include "glue_main.h"
#include "glue_debug.h"
#include "mh5display.h"
#include "mh5fileorm.h"
#include "mh5misc.h"
#include "mh5streamevent.h"
#include "mh5gate.h"
#include "mg_osd.h"
#include "mg_api.h"
#include "dvb_video.h"
#include "dvb_audio.h"
#ifdef INCLUDE_IC
#include "mh5hfs.h"
#include "mh5tls.h"
#include "mh5access.h"
#include "mh5hash.h"
#include "mh5sig.h"
#include "mh5cookies.h"
/* HTTP control */
#include "http_interface.h"
#include "mh5support.h"
#else
#if defined(INCLUDE_DSM_FG) || defined(INCLUDE_NVM)
#include "mh5support.h"
#endif
#endif
#ifdef INCLUDE_SA_PROFILE
#include "dvb_native.h"
#endif
#include "mh5storage.h"
#ifdef INCLUDE_TPS
#include "mh5tps.h"
#endif

#ifdef INCLUDE_FREESAT
 #include "mh5fsnvm.h"
#elif defined(INCLUDE_NVM)
 #include "mh5nvm.h"
#endif
#ifndef CI_PLUS_ONLY
 #ifdef INCLUDE_DSM_FG
  #include "mh5filegroup.h"
 #endif
 #include "glue_dsmcc.h"
 #include "dsm_control.h"
#endif
#include "mh5control.h"
#include "mh5keypress.h"

#include "mheg5_ci.h"
#ifdef COMMON_INTERFACE
#include "stbci.h"
#endif
#ifdef INCLUDE_CI_PLUS
#include "ci_appmmi.h"
#endif

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

#define MAX_HANDLERS  2

#define ENG_STAT_STRING()  (mheg_engine_status == ENG_STOPPED) ? "STOPPED" : \
   (mheg_engine_status == ENG_DSM_STARTING) ? "STARTING DSM" : \
   (mheg_engine_status == ENG_DSM_STARTED) ? "STARTED DSM" : \
   (mheg_engine_status == ENG_CI_STARTING) ? "STARTING CI" : "STARTED CI"

#define TINFO_QUIET_BIT          0x01
#define TINFO_NON_DESTRUCT_BIT   0x02
#define TINFO_EXPLICIT_CRSL_BIT  0x04
#define TINFO_MAP_CRSL_INIT_BIT  0x08
#define TINFO_NATIVE_APP_BIT     0x10

#define LC_STATE_NONE            0x00
#define LC_STATE_QUIET           TINFO_QUIET_BIT
#define LC_STATE_NDT_ENABLE      TINFO_NON_DESTRUCT_BIT
#define LC_STATE_NATIVE_APP      TINFO_NATIVE_APP_BIT
#define LC_STATE_MHG_TUNING      0x80

#define INVALID_CI_MODULE        0xFFFFFFFF

#ifndef INCLUDE_CI_PLUS
#define InformCiAppStopped(sc)
#define CI_APP_ABORT_SYSTEM      0x02
#else
#define CI_APP_ABORT_USER       STB_CI_APP_ABORT_USER
#define CI_APP_ABORT_SYSTEM     STB_CI_APP_ABORT_SYSTEM
#endif

/*---local typedef structs for this file-------------------------------------*/
/* Engine status enumerations */
typedef enum
{
   /* No currently running application */
   ENG_STOPPED,

   /* Starting DSM application */
   ENG_DSM_STARTING,

   /* Currently running DSM application */
   ENG_DSM_STARTED,

   /* Starting CI application */
   ENG_CI_STARTING,

   /* Currently running CI application */
   ENG_CI_STARTED
} E_ENGINE_STATUS;

typedef enum
{
   SA_NORMAL,
   SA_EPG,
   SA_INFO,
   SA_LIST,
} E_SPECIAL_APP;

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

static E_ENGINE_STATUS mheg_engine_status = ENG_STOPPED;
#ifdef INCLUDE_SA_PROFILE
static E_ChannelStartMode chan_suppress = CHANNEL_START_NORMAL;
static E_SPECIAL_APP mheg_special_app = SA_NORMAL;
static H_Timer special_timer = 0;
static const char specialEpgApp[]  = "DSM://navigator/epg";
static const char specialInfoApp[] = "DSM://navigator/info";
static const char specialListApp[] = "DSM://navigator/slist";
#endif
static BOOLEAN changedScreenResolution = FALSE;
static F_NotifyMhegEvent mhegEventHandlers[MAX_HANDLERS] = { NULL, NULL };
#ifdef COMMON_INTERFACE
/* Common Interface module ID for current CI application */
static U32BIT ci_module_id = INVALID_CI_MODULE;
#endif

#ifndef CI_PLUS_ONLY
static H_Timer retryTimerHandle = 0;
static U32BIT ndt_new_carousel_id = INVALID_CAROUSEL_ID;
static U8BIT lifecycle_state = LC_STATE_NONE;
static S32BIT tuneServiceIndex = 0;
#endif

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

#ifdef INCLUDE_CI_PLUS
static BOOLEAN EngineStartCi(U32BIT module, U8BIT *appstr, U8BIT applen,
   U8BIT* optstr, U8BIT optlen);
static void CiFileAck(U32BIT module, BOOLEAN fileOK, U8BIT *pFileData, U32BIT fileSize);
static void CiAbortApp(U32BIT module, U8BIT *code, U32BIT length);
static void InformCiAppStopped(U8BIT stop_code);
#endif

/*---global function definitions---------------------------------------------*/
extern int  ASN1_MemInit(void);
extern void ASN1_MemExit(void);


E_MhegErr MHEG5Initialise( S_MhegConfig *cfg_params )
{
#if defined(INCLUDE_DSM_FG) || defined(INCLUDE_NVM)
   U32BIT nvmSize;

   if (MH5_SupportMhegProfile( CPROFILE_SA ))
   {
      nvmSize = (512 * 1024); /*512k*/
   }
   else // Aus
   {
      nvmSize = (64 * 1024); /*64k*/
   }
#endif

   if (!ASN1_MemInit() || !MHEG5InitQueues())
   {
      TRACE(TERROR, ("ASN1_MemInit or MHEG5InitQueues FAILED"))
      return MHERR_ALLOCATING_MEMORY;
   }
   MH5_GroupInit();

#ifdef MHEG5LOG
   /* Set up engine debug logging */
   #ifdef ENGINE_LOG_LEVEL
   MHEG5LogInit(ENGINE_LOG_LEVEL);
   #else   /* #ifdef ENGINE_LOG_LEVEL */
   /* Default to error and warning logging setting */
   MHEG5LogInit(2);
   #endif  /* #ifdef ENGINE_LOG_LEVEL #else */
#endif  /* MHEG5LOG */

#ifdef INCLUDE_DSM_FG
   FG_Initialise( cfg_params->nvmSize - nvmSize );
#endif

   MHEG5InitStore();
#ifdef INCLUDE_FREESAT
   MHEG5FSnvmStoreOpen();
#elif defined(INCLUDE_NVM)
   MHEG5nvmInitialise( nvmSize );
#endif

   /* Initialise the file ORM. */
   MHEG5FileOrmInit();

#ifdef INCLUDE_CI_PLUS
   /* register engine with CI stack */
   STB_CIRegisterMmiEngine(CI_MHEG5_DOMAIN_ID,EngineStartCi);
#endif

   TRACE(TMHBOOT, ("done"))

   return MHERR_OK;
}

void MHEG5_Terminate( void )
{
   TRACE(TMHBOOT, (""))

   /* Destroy the fileOrm. */
   MHEG5FileOrmReset(MHEG5_FILE_ORM_RESET_ALL);

#ifdef INCLUDE_DSM_FG
   FG_Terminate();
#endif

   MHEG5ExitQueues();

   MHEG5ResetStore();
#ifdef INCLUDE_FREESAT
   MHEG5FSnvmStoreClose();
#elif defined(INCLUDE_NVM)
   MHEG5nvmReset();
#endif
   ASN1_MemExit();
}

void MHEG5RefreshDisplay(void)
{
   MHEG5Application *app;
   MHEG5Scene *scn;

   app = MHEG5getCurrentApplication();
   if (app == NULL)
   {
      TRACE(TMHBOOT, ("No App "))
      changedScreenResolution = FALSE;
   }
   else
   {
      TRACE(TMHBOOT, (""))
      if (changedScreenResolution)
      {
         scn = MHEG5getCurrentScene();

         if (scn)
         {
            MG_OSDMhegInit((U16BIT)scn->sceneCoordinateSystem[0],
               (U16BIT)scn->sceneCoordinateSystem[1], scn->aspectRatio );

            MHEG5ActivateCurrentApplication();

            MHEG5groupRedraw((MHEG5Root *)app );
            MHEG5groupRedraw((MHEG5Root *)scn );
         }
         changedScreenResolution = FALSE;
      }
      else
      {
         MHEG5ActivateCurrentApplication();
      }

      /* Make sure we update the screen */
      MHEG5displayShowAll();
      MHEG5displayResume();

      /* Send a resume event to the MHEG-5 application */
      MHEG5sendEvent((MHEG5Root *)app, MHEG5ENGINEEVENT, EE_ENGINE_RESUME );
   }
}

E_MhegErr MHEG5ResetResolution( U16BIT screenWidth, U16BIT screenHeight )
{
   E_MhegErr result;
   MHEG5Root *grp;

   TRACE(TGRAPHICS, (""))

   grp = (MHEG5Root *)MHEG5getCurrentScene();
   if (grp)
   {
      MHEG5groupClearImages( grp );
   }
   grp = (MHEG5Root *)MHEG5getCurrentApplication();
   if (grp)
   {
      MHEG5groupClearImages( grp );
   }

   MG_Terminate();

   result = MG_Initialise( screenWidth, screenHeight, 0 );

   if (grp)   /*application*/
   {
      changedScreenResolution = TRUE;
      /* wait for Resume */
   }
   return result;
}

#if defined(INCLUDE_NVM) || defined(INCLUDE_DSM_FG)

static void MHEG5FactoryReset( void *dummy )
{
#ifdef INCLUDE_DSM_FG
   FG_FactoryReset();
#endif

   MHEG5ResetStore();
#ifdef INCLUDE_FREESAT
   MHEG5FSnvmStoreClose();
#elif defined(INCLUDE_NVM)
   MHEG5nvmReset();
#endif
}

E_MhegErr MHEG5_ExecuteFactoryReset(void)
{
   E_MhegErr result;
   MHEG5eventMessage_t event_msg;

   event_msg.proc_msg_func = MHEG5FactoryReset;
   event_msg.data_type = DT_NONE;

   result = VQ_PutMsg(&event_msg, PRTY_CRITICAL);
   if (result != MHERR_OK)
   {
      TRACE(TERROR, ("VQ_PutMsg Failed"));
   }
   return result;
}

#endif /* INCLUDE_NVM || INCLUDE_DSM_FG */

void MHEG5NotifyEvent( E_MhegEvent event, U32BIT data )
{
   int i;
   for (i = 0; i != MAX_HANDLERS; i++)
   {
      if (mhegEventHandlers[i] != NULL)
      {
         mhegEventHandlers[i]( event, data );
      }
   }
}

BOOLEAN MHEG5_DvbRegisterEventHandler( F_NotifyMhegEvent handler )
{
   int i;
   for (i = 0; i != MAX_HANDLERS; i++)
   {
      if (mhegEventHandlers[i] == NULL)
      {
         mhegEventHandlers[i] = handler;
         return TRUE;
      }
   }
   return FALSE;
}

void MHEG5_DvbUnregisterEventHandler( F_NotifyMhegEvent handler )
{
   int i;
   for (i = 0; i != MAX_HANDLERS; i++)
   {
      if (mhegEventHandlers[i] == handler)
      {
         mhegEventHandlers[i] = NULL;
         break;
      }
   }
}

void MHEG5engineStart( U8BIT *app_name, BOOLEAN isCi, BOOLEAN special )
{
   MHEG5String workingDir;
#ifdef INCLUDE_IC
   HttpCookieManager_t manager;
#endif

   if (mheg_engine_status != ENG_STOPPED)
   {
      TRACE(TMHBOOT, ("Engine Status not stopped",mheg_engine_status))
   }
   else
   {
   #ifdef INCLUDE_IC
      /* Completely clear the hybrid file system */
      MHEG5ClearHybridFileSystem();
      /* Clear the TLS certificate store */
      MHEG5ClearTlsCertStore();
      /* Clear server access information */
      MHEG5ResetServerAccess();
      /* Clear verification information */
      MHEG5ResetVerification();
      /* Clear signature certificate cache */
      MHEG5ClearSigCertCache();
      /* Clear current IC status */
      MHEG5clearICStatus();
      /* Set cookie manager */
      manager.parse = MHEG5CookieParse;
      manager.generate_header = MHEG5CookieGenerateHeader;
      manager.ack_header = MHEG5CookieAckHeader;
      httpSetCookieManager(&manager);
      /* Set User Agent */
      httpSetUserAgent(MH5_GetUserAgent());
      /* Set working dir to hybrid:// if IC is enabled */
      if (MH5_SupportInteractionChannel())
      {
         workingDir.data = (U8BIT *)"hybrid://";
         workingDir.len = 9;
      }
      else
   #endif
      {
         workingDir.data = (U8BIT *)"DSM://";
         workingDir.len = 6;
      }
      MHEG5setWorkingDir(workingDir);

   #ifdef TRACING
      if (app_name)
      {
         TRACE(TMHBOOT, ("Eng Start %s", (char *)app_name))
      }
      else
      {
         TRACE(TMHBOOT, ("Engine Start Auto"))
      }
   #endif

      /* Need to set status before calling Bootup func, because
       * MHEG5NotifyEngineStarted could be called before returning from Bootup
       */
      mheg_engine_status = isCi ? ENG_CI_STARTING : ENG_DSM_STARTING;

      MG_OSDMhegInit( SD_WIDTH, SD_HEIGHT, ASPECT_UNDEFINED );

      if (MHEG5applicationBootup((char *)app_name,isCi|special) == MHEG5ERR_NOERROR)
      {
         if (MH5GlueActiveState() || special)
         {
            TRACE(TMHBOOT, ("start processing"));
            MH5GlueSetMainPostFunc( MHEG5processQueue );
         }
         else
         {
            TRACE(TMHBOOT, ("Waiting state!"));
         }
      }
      else
      {
         TRACE(TERROR, ("bootup failed ci?=%d",isCi));
         if (!special)
         {
            if (isCi)
            {
               MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_START_FAILED, 0);
               InformCiAppStopped(CI_APP_ABORT_SYSTEM);
            }
            else
            {
               /* Unable to start the autoboot application. */
               MHEG5NotifyEvent(MHEG_EVENT_DSM_APPLICATION_START_FAILED, 0);
            }
         }
         mheg_engine_status = ENG_STOPPED;
      }
   }
}

void MHEG5NotifyEngineStarted(void)
{
   switch (mheg_engine_status)
   {
      case ENG_DSM_STARTING:
         MHEG5NotifyEvent(MHEG_EVENT_DSM_APPLICATION_STARTED, 0);
         mheg_engine_status = ENG_DSM_STARTED;
         break;
      case ENG_CI_STARTING:
         MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_STARTED, 0);
         mheg_engine_status = ENG_CI_STARTED;
         break;
      default:
         TRACE(TERROR, ("Unexpected state"));
   }
}

#ifndef CI_PLUS_ONLY

void MHEG5NotifyCarouselBooted(S_DsmccEvent *param)
{
   TRACE(TPERFORM | TSTATE, ("engine_status=%s", ENG_STAT_STRING()))
   if (mheg_engine_status == ENG_DSM_STARTED)
   {
      /* Non-destructive tuning - see DBook6.1 sec 16.2.9 */
      MHEG5sendAppEngineEvent( EE_NON_DESTRUCTIVE_TUNE_OK );

      MHEG5applicationNDTcarouselAttach(param->hCarousel);

      MHEG5streamClearCurrentService();

      MHEG5streamReloadAll();

      #ifdef INCLUDE_IC
      MHEG5InvalidateSigCertCache();
      MHEG5InvalidateTlsCertStore();
      MHEG5ResetServerAccess();
      #endif
   }
}

void MHEG5AutoPathComplete( E_FsStatus result )
{
   switch (result)
   {
      case FS_STATUS_OK:
         break;

      default:
         /* Signal to the controlling application that an internal error has ocurred */
         TRACE(TERROR, ("autoboot object failed"));
         MHEG5NotifyEvent(MHEG_EVENT_DSM_APPLICATION_START_FAILED, 0);
      /* fallthrough */

      case FS_STATUS_NONE:
         /* did not find data_broadcast_id with 0x0106 (i.e. not DSMCC with MHEG). Probably HbbTv DSM-CC */
         MHEG5NotifyEngineStartFailed(); /* Sets timer to restart, and set state to 'stopped' */
   }
}

static void StartAutoboot(void *dummy)
{
   if (mheg_engine_status > ENG_DSM_STARTING)
   {
      TRACE(TERROR, ("Unexpected state %d", mheg_engine_status));
   }
   else
   {
      TRACE(TMHBOOT, (""))
   #ifdef INCLUDE_IC
      MHEG5ClearHybridFileSystem();
      MHEG5CookieClearStore();
   #endif
      /* (re)start the autoboot application */
      MH5GlueDsmccMHEGInitialBoot();
   }
}

static void startRetryMhegFunc( BOOLEAN triggered, void *callerRef, H_Timer timerHandle )
{
   MHEG5eventMessage_t event_msg;

   TRACE(TMHBOOT, (" trig=%d", triggered))

   if (triggered == TRUE)
   {
      /* Maybe could check that DSM-CC is still booted? */
      event_msg.proc_msg_func = StartAutoboot;
      event_msg.data_type = DT_NONE;
      VQ_PutMsg(&event_msg, PRTY_NORMAL);
   }
}

#endif  /* !CI_PLUS_ONLY */

void MHEG5NotifyEngineStartFailed(void)
{
   TRACE(TMHBOOT, (" engine_status=%s", ENG_STAT_STRING()))
   switch (mheg_engine_status)
   {
      #ifndef CI_PLUS_ONLY
      case ENG_DSM_STARTING:
         if (mhegTimerCreate( 2000 /*msecs*/,
                (F_TimerCallback) startRetryMhegFunc,
                0, &retryTimerHandle ) == MHERR_OK)
         {
            TRACE(TMHBOOT, ("started timer"))
         }
         else
         {
            TRACE(TERROR, ("mhegTimerCreate FAILED"));
         }
       #ifdef INCLUDE_SA_PROFILE
         if (special_timer != 0)
         {
            mhegTimerDestroy(special_timer);
            special_timer = 0;
         }
         mheg_special_app = SA_NORMAL;
       #endif
         break;
      #endif  /* !CI_PLUS_ONLY */

      case ENG_CI_STARTING:
         MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_START_FAILED, 0);
         InformCiAppStopped(CI_APP_ABORT_SYSTEM);
         break;

      default:
         TRACE(TERROR, ("Unexpected state"));
   }
   mheg_engine_status = ENG_STOPPED;
}

void MHEG5NotifyEngineQuit(void)
{
   switch (mheg_engine_status)
   {
      case ENG_CI_STARTED:
         TRACE(TPERFORM, ("MHEG5_CI_APPLICATION_STOPPED"))
         MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_STOPPED, 0);
         InformCiAppStopped(CI_APP_ABORT_SYSTEM);
         break;

      case ENG_DSM_STARTED:
         TRACE(TPERFORM, ("MHEG5_DSM_APPLICATION_STOPPED"))
         MHEG5NotifyEvent(MHEG_EVENT_DSM_APPLICATION_STOPPED, 0);
       #ifdef INCLUDE_SA_PROFILE
         if (special_timer != 0)
         {
            mhegTimerDestroy(special_timer);
            special_timer = 0;
         }
         mheg_special_app = SA_NORMAL;
       #endif
         break;

      default:
         break;
   }
   MH5GlueSetMainPostFunc( NULL );
}

void MHEG5engineTerminate(void)
{
   MHEG5Scene *scene;
   MHEG5Application *application;
   BOOLEAN update;
   MHEG5String workingDir = {0,NULL};

   /* Check if currently engine starting */
   MHEG5applicationBootAbort();

   /* Notify component that start attempt has been aborted */
   if (mheg_engine_status == ENG_CI_STARTED)
   {
      TRACE(TPERFORM, ("MHEG5_CI_APPLICATION_STOPPED"))
      MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_STOPPED, 0);
      InformCiAppStopped(CI_APP_ABORT_USER);
   }

   /* Prevent event processing while we destruct the scene and application,
    * And reset the event and action queues*/
   MHEG5stopEventsAndResetQueue();

   /* Abort any pending file loads */
   MHEG5FileOrmReset(MHEG5_FILE_ORM_RESET_ALL);

   update = MH5GlueActiveState();

   application = MHEG5getCurrentApplication();
   if (application != 0)
   {
      scene = MHEG5getCurrentScene();
      if (scene != 0)
      {
         if (!update)
         {
            /* Engine is NOT active, so as far as MHEG is concerned there is
             * "stream continuance". Importantly, setting this flag prevents
             * MHEG5displayUpdate() call in MHEG5streamDeactivate() */
            application->streamContinuanceFlag = MHEG5TRUE;
         }
         MHEG5sceneDestruct(scene);
         MHEG5sceneFree(scene);
         MHEG5freeMem(scene);
      }

      /* During destruction of an application triggered by Quit, Launch or Spawn
       * actions, any stream decoder associated with Stream objects are not
       * stopped. See UK1.05 section 6.3.4
       */
      application->streamContinuanceFlag = MHEG5TRUE;
      MHEG5applicationDestruct(application);
      MHEG5applicationFree(application);
      MHEG5freeMem(application);

      /* Notify that the final Application has Quit. */
      MHEG5NotifyEngineQuit();
   }
   /* Reset the media decoders to their default state */
   MHEG5displayResetStreamDecoders(update);

   /* Clear current service */
   MHEG5streamClearCurrentService();

#ifdef INCLUDE_NATIVE_APP
   MHEG5PromotionalLinkControl( TRUE );
#endif

   /* Force the display to be cleared */
   if (update)
   {
      MHEG5displayClear();
   }

   #ifdef INCLUDE_IC
   /* Clear cookie manager */
   httpSetCookieManager(NULL);
   /* Completely clear the hybrid file system */
   MHEG5ClearHybridFileSystem();
   /* Clear the TLS certificate store */
   MHEG5ClearTlsCertStore();
   /* Clear server access information */
   MHEG5ResetServerAccess();
   /* Clear verification information */
   MHEG5ResetVerification();
   /* Clear signature certificate cache */
   MHEG5ClearSigCertCache();
   /*Clear the stored cookies*/
   MHEG5CookieClearStore();
   /* Clear current IC status */
   MHEG5clearICStatus();
   #endif

   MHEG5setWorkingDir(workingDir);

   /* Clear the MHEG-5 application stack */
   MHEG5applicationStackClear(FALSE);

   /* Reset the event processing enable flag. This will allow the MHEG-5 engine
    * to recover in the case of programming errors leaving events processing
    * disabled.
    */
   MHEG5eventProcessingReset();
#ifdef INCLUDE_SA_PROFILE
   if (special_timer != 0)
   {
      mhegTimerDestroy(special_timer);
      special_timer = 0;
   }
   mheg_special_app = SA_NORMAL;
#endif
   mheg_engine_status = ENG_STOPPED;
}

#ifndef CI_PLUS_ONLY

void MHEG5engineDsmTerminate(void)
{
   if (mheg_engine_status == ENG_DSM_STARTED ||
       mheg_engine_status == ENG_DSM_STARTING)
   {
      MHEG5engineTerminate();
   }
   lifecycle_state = LC_STATE_NONE;
}

MHEG5Bool MHEG5TuneIndex(MHEG5Int serviceIndex)
{
   MHEG5Bool rc = MHEG5FALSE;
   TRACE(TSTATE, ("LCS=0x%x, serviceIndex=%d", lifecycle_state, serviceIndex))
   if (serviceIndex != -1)
   {
      tuneServiceIndex = serviceIndex;
      lifecycle_state |= LC_STATE_MHG_TUNING;
      /* Call the environment's tune index function */
      if (DVB_MhegTuneIndex(serviceIndex) == MHERR_OK)
      {
         rc = MHEG5TRUE;
      }
   }
   return rc;
}

void MHEG5TuneIndexInfo(MHEG5Int tuneInfo)
{
   if (tuneInfo & TINFO_QUIET_BIT)
   {
      lifecycle_state |= LC_STATE_QUIET;
   }
   else
   {
      lifecycle_state &= ~LC_STATE_QUIET;
   }

   if (tuneInfo & TINFO_NON_DESTRUCT_BIT)
   {
      lifecycle_state |= LC_STATE_NDT_ENABLE;

      if (tuneInfo & TINFO_EXPLICIT_CRSL_BIT)
      {
         ndt_new_carousel_id = (tuneInfo >> 8) & 0xff;
      }
      else if (tuneInfo & TINFO_MAP_CRSL_INIT_BIT)
      {
         ndt_new_carousel_id = INVALID_CAROUSEL_ID;
      }
      else
      {
         /* new carousel id will be same as current one */
         ndt_new_carousel_id = DSMCC_CurrentCarouselId( MHEG5_DsmccInstance());
      }
   }
   else
   {
      lifecycle_state &= ~LC_STATE_NDT_ENABLE;
   }

   if (tuneInfo & TINFO_NATIVE_APP_BIT)
   {
      lifecycle_state |= LC_STATE_NATIVE_APP;
   }
   else
   {
      lifecycle_state &= ~LC_STATE_NATIVE_APP;
   }

   TRACE(TSTATE, ("LCS=0x%x", lifecycle_state))
}

E_ChannelStartMode MHEG5_GetTuningInfoMode( S32BIT serviceIndex )
{
   E_ChannelStartMode suppress = CHANNEL_START_NORMAL;
   TRACE(TSTATE | TTUNE, ("LCS=0x%x", lifecycle_state))
   if (lifecycle_state & LC_STATE_MHG_TUNING)
   {
      if (tuneServiceIndex == serviceIndex)
      {
         if (lifecycle_state & LC_STATE_QUIET)
         {
            suppress = CHANNEL_START_QUIETLY;
         }
         else if (lifecycle_state & LC_STATE_NDT_ENABLE)
         {
            suppress = CHANNEL_START_QUIET_SHOW_INFO;
         }
      }
   }
   return suppress;
}

U32BIT MHEG5tuneProcess( S_DvbLocator *pDvbLoc, S32BIT serviceIndex )
{
   U32BIT cid;
#ifdef INCLUDE_TPS
   BOOLEAN ndt = FALSE;
#endif
#ifdef INCLUDE_NATIVE_APP
   BOOLEAN native_app_ok = TRUE;
#endif
#ifdef INCLUDE_SA_PROFILE
   chan_suppress = MHEG5_GetTuningInfoMode(serviceIndex);
#endif
   TRACE(TSTATE | TTUNE, ("serv_id=%d,net_id=%d", pDvbLoc->service_id, pDvbLoc->original_network_id))
   cid = INVALID_CAROUSEL_ID;
   if (pDvbLoc->service_id == 0 || pDvbLoc->original_network_id == 0)
   {
      /* NDT failed */
      TRACE(TERROR, ("NDT Failed serv_id=%d,net_id=%d", pDvbLoc->service_id, pDvbLoc->original_network_id))
      MHEG5engineDsmTerminate();
   }
   else
   {
      if (lifecycle_state & LC_STATE_MHG_TUNING)
      {
         if (tuneServiceIndex == serviceIndex)
         {
            TRACE(TSTATE | TSTRM | TTUNE, (" MHEG Tune to service_id=0x%x(%d)", pDvbLoc->service_id, pDvbLoc->service_id))
            #ifdef INCLUDE_NATIVE_APP
            if (lifecycle_state & LC_STATE_NATIVE_APP)
            {
               native_app_ok = FALSE;
            }
            #endif
            if (lifecycle_state & LC_STATE_NDT_ENABLE)
            {
               TRACE(TSTATE | TFILE | TSTRM | TTUNE, ("==== Non Destructive Tune (crsl=0x%x) =====", ndt_new_carousel_id))
               cid = ndt_new_carousel_id;
            #ifdef INCLUDE_TPS
               ndt = TRUE;
            #endif
            }
            else
            {
               TRACE(TSTATE | TTUNE, (" MHEG5 Tune "))
            }
            lifecycle_state &= ~LC_STATE_MHG_TUNING;
         }
         else
         {
            TRACE(TERROR, ("Supposed to be MHEG tune, but wrong service: serv_id=%d", pDvbLoc->service_id))
            /* Resquest for NDT happened just before user did a channel change
             * - this is the user's channel change, so we must destroy the MHEG application */
            MHEG5engineDsmTerminate();
         }
      }
      else
      {
         TRACE(TSTATE | TTUNE, (" Normal Tune "))
      }
#ifdef INCLUDE_TPS
      if (!ndt)
      {
         MHEG5TpsSetCurrentService(pDvbLoc);
      }
#endif
   }

#ifdef INCLUDE_SA_PROFILE
   if (chan_suppress == CHANNEL_START_NORMAL &&
      MH5_SupportMhegProfile(CPROFILE_SA) &&
      FG_FileExists(ORIGIN_DSM, specialInfoApp) == FS_STATUS_OK)
   {
      /*Launch Now/Next Banner*/
      MHEG5StartInfoApp(TRUE);
   }
#endif
#ifdef INCLUDE_NATIVE_APP
   MHEG5PromotionalLinkControl( native_app_ok );
#endif
   return cid;
}

void MHEG5NotifyCarouselLoaded(S_DsmccEvent *param)
{
   TRACE(TMHBOOT | TPERFORM | TSTATE, ("engine_status=%s", ENG_STAT_STRING()))
   if (mheg_engine_status == ENG_DSM_STARTED)
   {
      /* This was an NDT, process any pending requests in fileOrm */
      MHEG5FileOrmProcess();
   }
#ifdef INCLUDE_SA_PROFILE
   else if (chan_suppress == CHANNEL_START_NORMAL &&
      MH5_SupportMhegProfile(CPROFILE_SA) &&
      mheg_special_app != SA_INFO)
   {
      /*Launch Now/Next Banner*/
      MHEG5StartInfoApp(TRUE);
   }
#endif

   else
   {
      StartAutoboot(0);
   }
}

void MHEG5NotifyCarouselUnload(S_DsmccEvent *param)
{
   BOOLEAN isNdt;
   isNdt = ((lifecycle_state & (LC_STATE_MHG_TUNING|LC_STATE_NDT_ENABLE))
            == (LC_STATE_MHG_TUNING|LC_STATE_NDT_ENABLE))? TRUE : FALSE;
   MHEG5applicationCarouselUnload(param->hCarousel,isNdt);
#ifdef INCLUDE_DSM_FG
   FG_NotifyCarouselUnLoaded(param->hCarousel);
#endif
}

#endif /* CI_PLUS_ONLY*/

BOOLEAN MHEG5isProcessingNDT( BOOLEAN *native_app_ok )
{
   BOOLEAN isNdt = FALSE;
#ifndef CI_PLUS_ONLY
   assert( *native_app_ok == TRUE );
   TRACE(TSTATE | TTUNE, ("LCS=0x%x", lifecycle_state))
   if (lifecycle_state & LC_STATE_MHG_TUNING)
   {
      if (lifecycle_state & LC_STATE_NDT_ENABLE)
      {
         TRACE(TSTATE | TFILE | TSTRM, ("==== About to do Non Destructive Tune ====="))
         isNdt = TRUE;
      }
      if (lifecycle_state & LC_STATE_NATIVE_APP)
      {
         *native_app_ok = FALSE;
      }
   }
#endif /* CI_PLUS_ONLY*/
   return isNdt;
}

U8BIT MHEG5HandleEngineStopAction( U8BIT action )
{
   BOOLEAN native_app_ok = TRUE;

   TRACE(TSTATE, ("action=0x%x Eng_stat=%s", action, ENG_STAT_STRING()))
   /* Check application running */
   if (mheg_engine_status == ENG_STOPPED)
   {
      TRACE(TERROR, ("no application running"));
      action = 0;
   }
   else
   {
      if ( action & STOP_ACTION_CI_PLUS_NDT )
      {
         /* Non-destructive tuning for CI Plus  */
         TRACE(TSTATE,(""))
         MHEG5streamUnloadAll();
         MHEG5applicationStackClear(TRUE);
      }
     else if ((action & STOP_ACTION_MHEG_TUNE) == 0 ||
          !MHEG5isProcessingNDT(&native_app_ok))
      {
         action = 0;
         if (mheg_engine_status != ENG_STOPPED)
         {
            MHEG5engineTerminate();
         }
      }
      else
      {
         TRACE(TSTATE, (""))
         /* Non-destructive tuning - see DBook6.1 sec 16.2.9
          * clear app stack (except current application) */
         MHEG5streamUnloadAll();
         MHEG5applicationStackClear(TRUE);
         /*DBook spec is not clear about whether promotional linking should be changed
          * when doing NDT and still apply the native_app bit of tune-info
            - so we will apply it below anyway*/
      }
   #ifdef INCLUDE_NATIVE_APP
      MHEG5PromotionalLinkControl( native_app_ok );
   #endif
   }

#ifdef MHG_TRACK_MEM
   /* -- Debug code - print engine memory tracking state */
   TRACE(TMEMORY, (""))
   mh5emt_print(3 << SRCMEM_APP);
#endif

#ifdef MHEG5_COMP_MEM_TRACKING
   /* -- Debug code - print component memory tracking state */
   mh5cmt_print();
#endif
#ifdef SRF_MEM_DGB
   OSD_DbgListSrf();
#endif

   return action;
}

BOOLEAN MHEG5engineIsCiAppRunning(void)
{
   return (mheg_engine_status == ENG_CI_STARTED ||
           mheg_engine_status == ENG_CI_STARTING) ? TRUE : FALSE;
}

void MHEG5StartReboot(void *param)
{
   if (MHEG5engineIsCiAppRunning())
   {
      TRACE(TMHBOOT, ("CI application running - ignore external reboot"))
   }
#ifndef CI_PLUS_ONLY
   else
   {
      MHEG5engineDsmTerminate();
      MH5GlueDsmccReboot();
   }
#endif
   if (param != NULL)
   {
      MH5GlueDoneRebootMessage();
   }
}

void MHEG5Pause(void)
{
   TRACE(TSTATE|TMHBOOT, ("engine_status=%s", ENG_STAT_STRING()))
   MH5GlueSetMainPostFunc( NULL );
   MHEG5displayPause();
   MHEG5NotifyEvent(MHEG_EVENT_STATE_PAUSED, 0);
}

void MHEG5Resume(void)
{
   TRACE(TSTATE|TMHBOOT, ("engine_status=%s", ENG_STAT_STRING()))
   if (mheg_engine_status != ENG_STOPPED)
   {
      MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
      MH5GlueSetMainPostFunc( MHEG5processQueue );
   }
   MHEG5NotifyEvent(MHEG_EVENT_STATE_RESUME, 0);
   MHEG5RefreshDisplay();
}

static void RefreshStreams(S_DvpEventType *param)
{
   if (mheg_engine_status == ENG_DSM_STARTED)
   {
      MHEG5displayRefreshStreams((U16BIT)param->eData);
   }
}

void MHEG5RefreshStreams(U16BIT service_id)
{
   MHEG5eventMessage_t event_msg;
   event_msg.proc_msg_func = (F_MSG_PROCESS)RefreshStreams;
   event_msg.data_type = DT_VALUE;
   event_msg.data.dvpEvent.eType = DVB_EVENT_NONE;
   event_msg.data.dvpEvent.eData = service_id;
   if (VQ_PutMsg(&event_msg, PRTY_HIGH) != MHERR_OK)
   {
      DBGTRACE(TERROR,"")
   }
}

static void RefreshDefaultAudio(S_DvpEventType *param)
{
   if (mheg_engine_status == ENG_DSM_STARTED)
   {
      MHEG5displayRefreshDefaultAudio((U16BIT)param->eData);
   }
}

void MHEG5RefreshDefaultAudio(void)
{
   MHEG5eventMessage_t event_msg;
   event_msg.proc_msg_func = (F_MSG_PROCESS)RefreshDefaultAudio;
   event_msg.data_type = DT_VALUE;
   event_msg.data.dvpEvent.eType = DVB_EVENT_NONE;
   event_msg.data.dvpEvent.eData = MHEG5DefaultServiceId();
   if (VQ_PutMsg(&event_msg, PRTY_HIGH) != MHERR_OK)
   {
      DBGTRACE(TERROR,"")
   }
}

#ifdef COMMON_INTERFACE
U32BIT MHEG5GetCiModuleId(void)
{
   return ci_module_id;
}

static void startCIApplication(S_CiStart *params)
{
   ASSERTL1((params->name.zptr));

   /* Check if any application currently running *
    * Stop any currently running applications.   */
   if (MHEG5engineIsCiAppRunning())
   {
      MHEG5engineTerminate();
   }
#ifndef CI_PLUS_ONLY
   else
   {
      MHEG5engineDsmTerminate();
   }
#endif

   ci_module_id = params->module_id;

   /* Attempt start */
   DPL3(("INFO: startCIApplication - calling engineStart\n"));
   MHEG5engineStart(params->name.zptr, TRUE, FALSE);

   /* Free memory allcated for application name in MHEG5_StartCIApplication */
   SYS_Free(params->name.zptr);
}

E_MhegErr MHEG5_StartCIApplication(U32BIT module, U8BIT *application)
{
   MHEG5eventMessage_t event_msg;
   E_MhegErr cqu_err;

   /* Check function parameter */
   if ((application == NULL) || (strlen((char *)application) == 0))
   {
      /* Invalid filename */
      DPL1(("- Invalid CI application name\n"));
      return MHERR_BAD_PARAMETER;
   }

   if (!MH5GlueIsStarted())
   {
      return MHERR_COMP_NOT_STARTED;
   }

   /* Set up event structure and associated data */
   event_msg.proc_msg_func = (F_MSG_PROCESS)startCIApplication;
   event_msg.data_type = DT_ALLOC;
   event_msg.data.ciStart.module_id = module;

   /* Allocate memory for pathname parameter, remembering the "CI://" and
    * terminating null.
    */
   event_msg.data.ciStart.name.zptr = (U8BIT *)MHEG5getMem(strlen((char *)application) + 6);
   if (event_msg.data.string.zptr == NULL)
   {
      DPL1(("- Memory Allocation Error\n"));
      return MHERR_BAD_PARAMETER;
   }

   /* Copy pathname parameter */
   event_msg.data.ciStart.name.zptr[0] = '\0';
   if (strncmp((char *)application, "CI://", 5) != 0)
   {
      strcpy((char *)event_msg.data.ciStart.name.zptr, "CI://");
   }
   strcat((char *)event_msg.data.ciStart.name.zptr, (char *)application);

   /* Send start event to component */
   cqu_err = VQ_PutMsg(&event_msg, PRTY_CRITICAL);
   if (cqu_err != MHERR_OK)
   {
      TRACE(TERROR, ("VQ_PutMsg Failed %d", cqu_err));
      MHEG5freeMem(event_msg.data.ciStart.name.zptr);
      MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_START_FAILED, 0);
      InformCiAppStopped(CI_APP_ABORT_SYSTEM);
      return MHERR_INTERNAL;
   }

   return MHERR_OK;
}

static void stopCIApplications(MHEG5StopEventParams_t *params)
{
   USE_UNWANTED_PARAM(params);
   /* Check whether there is a CI application running */
   if (MHEG5engineIsCiAppRunning())
   {
      MHEG5engineTerminate();
      ci_module_id = INVALID_CI_MODULE;
#ifndef CI_PLUS_ONLY
      MH5GlueDsmccReboot(); // TODO: is this the right thing to do?
#endif
   }
   else
   {
      DPL2(("WARNING: stopCIApplications - no CI application running\n"));
      /* Notify that stop CI event has been processed */
      MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_STOPPED, 0);
      InformCiAppStopped(params->action);
   }
}

E_MhegErr MHEG5_StopCIApplication(void)
{
   MHEG5eventMessage_t event_msg;

   if (!MH5GlueIsStarted())
   {
      return MHERR_COMP_NOT_STARTED;
   }
   event_msg.proc_msg_func = (F_MSG_PROCESS)stopCIApplications;
   event_msg.data_type = DT_VALUE;
   event_msg.data.ciStop.module_id = ci_module_id;
   event_msg.data.ciStop.code = CI_APP_ABORT_SYSTEM;
   return VQ_PutMsg(&event_msg, PRTY_CRITICAL);
}

static void ciFileAck(MHEG5CiFileAcknowledgeEventParams_t *params)
{
   MHEG5ciFileAcknowledge(params->fileOK, params->pFileData, params->fileSize);
}

E_MhegErr MHEG5_CiFileAcknowledge(U32BIT module, BOOLEAN fileOK, U8BIT *pFileData,
   U32BIT fileSize)
{
   MHEG5eventMessage_t event_msg;

   if (!MH5GlueIsStarted())
   {
      return MHERR_COMP_NOT_STARTED;
   }
   event_msg.data.ciFileAcknowledge.pFileData = STB_MemAlloc(fileSize);
   if (event_msg.data.ciFileAcknowledge.pFileData == NULL)
   {
      fileSize = 0;
   }
   else
   {
      memcpy(event_msg.data.ciFileAcknowledge.pFileData, pFileData, fileSize);
      event_msg.data.ciFileAcknowledge.clr_func = (F_DESTROY)STB_MemFree;
      event_msg.data.ciFileAcknowledge.clr_hdl = (FS_HANDLE)event_msg.data.ciFileAcknowledge.pFileData;
   }
   event_msg.proc_msg_func = (F_MSG_PROCESS)ciFileAck;
   event_msg.data_type = DT_CONTENT;
   event_msg.data.ciFileAcknowledge.fileSize = fileSize;
   event_msg.data.ciFileAcknowledge.fileOK = fileOK;
   return VQ_PutMsg(&event_msg, PRTY_NORMAL);
}

void MHEG5CiAckData(U8BIT *pData)
{
   if (pData)
   {
      STB_MemFree(pData);
   }
}

void MHEG5notifyCiCamRemove(U32BIT slot_id)
{
   if (ci_module_id != INVALID_CI_MODULE &&
      STB_GetCIConditionalAccessSlotId(ci_module_id) == slot_id)
   {
      MHEG5_StopCIApplication();
   }
}

#endif /*COMMON_INTERFACE*/
#ifdef INCLUDE_CI_PLUS

static BOOLEAN EngineStartCi(U32BIT module, U8BIT *appstr, U8BIT applen,
   U8BIT* optstr, U8BIT optlen)
{
   BOOLEAN result;
   MHEG5eventMessage_t event_msg;
   U8BIT *zptr;

   /* Check function parameter */
   if ((appstr == NULL) || (applen == 0))
   {
      TRACE(TERROR,("Invalid CI application name"));
      result = FALSE;
   }
   else if (!MH5GlueIsStarted())
   {
      TRACE(TERROR,("- not started"));
      result = FALSE;
   }
   else
   {
      /* Set up event structure and associated data */
      event_msg.proc_msg_func = (F_MSG_PROCESS)startCIApplication;
      event_msg.data_type = DT_ALLOC;
      event_msg.data.ciStart.module_id = module;

      /* Allocate memory for pathname parameter, remembering the "CI://" and terminating null */
      event_msg.data.ciStart.name.zptr = (U8BIT *)MHEG5getMem(applen + 6);
      if (event_msg.data.string.zptr == NULL)
      {
         DPL1(("- Memory Allocation Error\n"));
         result = FALSE;
      }
      else
      {
         zptr = event_msg.data.ciStart.name.zptr;
         if (memcmp(appstr, "CI://", 5) != 0)
         {
            memcpy(zptr, "CI://", 5);
            zptr += 5;
         }
         memcpy(zptr, appstr, applen);
         zptr[applen] = 0;

         /* Send start event to component */
         if (VQ_PutMsg(&event_msg, PRTY_CRITICAL) != MHERR_OK)
         {
            MHEG5freeMem(event_msg.data.ciStart.name.zptr);
            MHEG5NotifyEvent(MHEG_EVENT_CI_APPLICATION_START_FAILED, 0);
            InformCiAppStopped(CI_APP_ABORT_SYSTEM);
            result = FALSE;
         }
         else
         {
            STB_CISetAppMmiCallbacks(CiFileAck, CiAbortApp);
            result = TRUE;
         }
      }
   }
   return result;
}

static void CiFileAck(U32BIT module, BOOLEAN fileOK, U8BIT *pFileData, U32BIT fileSize)
{
   MHEG5eventMessage_t event_msg;

   if (!MH5GlueIsStarted())
   {
      TRACE(TERROR,("- not started"));
   }
   else
   {
      event_msg.data.ciFileAcknowledge.pFileData = STB_MemAlloc(fileSize);
      if (event_msg.data.ciFileAcknowledge.pFileData == NULL)
      {
         fileSize = 0;
      }
      else
      {
         memcpy(event_msg.data.ciFileAcknowledge.pFileData, pFileData, fileSize);
         event_msg.data.ciFileAcknowledge.clr_func = (F_DESTROY)STB_MemFree;
         event_msg.data.ciFileAcknowledge.clr_hdl = (FS_HANDLE)event_msg.data.ciFileAcknowledge.pFileData;
      }
      event_msg.proc_msg_func = (F_MSG_PROCESS)ciFileAck;
      event_msg.data_type = DT_CONTENT;
      event_msg.data.ciFileAcknowledge.fileSize = fileSize;
      event_msg.data.ciFileAcknowledge.fileOK = fileOK;
      VQ_PutMsg(&event_msg, PRTY_NORMAL);
   }
}

static void CiAbortApp(U32BIT module, U8BIT *code, U32BIT length)
{
   MHEG5eventMessage_t event_msg;
   if (module == ci_module_id && MH5GlueIsStarted())
   {
      event_msg.proc_msg_func = (F_MSG_PROCESS)stopCIApplications;
      event_msg.data_type = DT_VALUE;
      event_msg.data.ciStop.module_id = module;
      if (code && length >= 1)
      {
         event_msg.data.ciStop.code = *code;
      }
      else
      {
         event_msg.data.ciStop.code = CI_APP_ABORT_SYSTEM;
      }
      VQ_PutMsg(&event_msg, PRTY_CRITICAL);
   }
}

static void InformCiAppStopped(U8BIT stop_code)
{
   STB_CISendAppAbortRequest(ci_module_id, &stop_code, 1);
}

#endif /*INCLUDE_CI_PLUS*/


#ifdef INCLUDE_SA_PROFILE
static void ClearSpecialApp(void *dummy)
{
   if (mheg_special_app == SA_INFO)
   {
      MHEG5engineTerminate();
      /* (re)start the autoboot application */
      MH5GlueDsmccMHEGInitialBoot();
   }
}

static void SpecialAppTimeout( BOOLEAN triggered, void *callerRef, H_Timer timerHandle )
{
   MHEG5eventMessage_t event_msg;
   TRACE(TMHBOOT, (" trig=%d", triggered))
   if (triggered == TRUE)
   {
      event_msg.proc_msg_func = ClearSpecialApp;
      event_msg.data_type = DT_NONE;
      VQ_PutMsg(&event_msg, PRTY_NORMAL);
   }
}


void MHEG5StartEpgApp(void)
{
   if (mheg_engine_status != ENG_STOPPED)
   {
      MHEG5engineTerminate();
   }
   MHEG5engineStart((U8BIT*)specialEpgApp, FALSE, TRUE);
   if (mheg_engine_status == ENG_DSM_STARTING)
   {
      mheg_special_app = SA_EPG;
   }
}

void MHEG5StartInfoApp(BOOLEAN doTimeout)
{
   if (mheg_engine_status != ENG_STOPPED)
   {
      MHEG5engineTerminate();
   }
   MHEG5engineStart((U8BIT*)specialInfoApp, FALSE, TRUE);
   if (mheg_engine_status == ENG_DSM_STARTING)
   {
      mheg_special_app = SA_INFO;
      if ( doTimeout )
      {
         S32BIT timeout = 30;
         DVB_MhegGetBannerTimeout(&timeout);
         timeout *= 1000;
         if (mhegTimerCreate(timeout, SpecialAppTimeout, 0, &special_timer) != MHERR_OK)
         {
            TRACE(TERROR, ("mhegTimerCreate FAILED"));
         }
      }
   }
}

void MHEG5StartListApp(void)
{
   if (mheg_engine_status != ENG_STOPPED)
   {
      MHEG5engineTerminate();
   }
   MHEG5engineStart((U8BIT*)specialListApp, FALSE, TRUE);
   if (mheg_engine_status == ENG_DSM_STARTING)
   {
      mheg_special_app = SA_LIST;
   }
}

#endif /*INCLUDE_SA_PROFILE*/