mh5stream.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 "mh5application.h"
#include "mh5scene.h"
#include "mh5stream.h"
#include "mh5object.h"          /* for actions                  */
#include "mh5variable.h"        /* for actions                  */
#include "mh5memory.h"          /* for constructor/destructor   */
#include "mh5display.h"         /* for actions                  */
#include "mh5streamevent.h"     /* for stream events            */
#include "mh5final.h"
#include "mh5queue.h"           /* Events                       */
#include "mh5audio.h"           /* for events                   */
#include "mh5video.h"
#include "mh5rtgraphics.h"
#include "mh5debug.h"
#include "mh5misc.h"
#include "mh5profile.h"

#include "glue_main.h"
#include "dvb_service.h"

#ifdef INCLUDE_ICS
#include "mh5streamer.h"
#endif

#ifdef MH5PRINTOUT
#include <string.h>
#endif

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


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

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

static S_DVB_LOCATOR currentService = {0, 0, 0};
static MHEG5Int audioComponentTag = -1;
static MHEG5Int videoComponentTag = -1;
#ifndef MHEG5PROFILE_UK1_06
static MHEG5Int rtgraphicsComponentTag = -1;
#endif

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

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


#ifdef MH5PRINTOUT
void MHEG5streamPrint(MHEG5Stream *stream, char *out)
{
   MHEG5Ingredient **currMultiplex = stream->multiplex;

   MHEG5ingredientPrint(&stream->ingredient, out);

   /*exchanged attributes */
   MHEG5indent(out);
   MHEG_PRINT(out, ":Multiplex (");
   MHEG5newLine(out);
   MHEG5incIndent();
   while (*currMultiplex)
   {
      switch ((*currMultiplex)->root.clazz)
      {
         case MHEG5AUDIO:
            MHEG5audioPrint((MHEG5Audio *) (*currMultiplex), out);
            break;
         case MHEG5VIDEO:
            MHEG5videoPrint((MHEG5Video *) (*currMultiplex), out);
            break;
     #ifndef MHEG5PROFILE_UK1_06
         case MHEG5RTGRAPHICS:
            MHEG5rtgraphicsPrint((MHEG5RTGraphics *) (*currMultiplex), out);
            break;
     #endif
         default:
            MHEG5incIndent();
            MHEG5indent(out);
            MHEG_PRINT(out, "{");
            MHEG5newLine(out);
      }
      MHEG5decIndent();
      MHEG5indent(out);
      MHEG_PRINT(out, "}");
      MHEG5newLine(out);
      currMultiplex++;
   }
   MHEG5decIndent();
   MHEG5indent(out);
   MHEG_PRINT(out, ")");
   MHEG5newLine(out);

   if (stream->storageMemory)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":Storage ");
      MHEG_PRINT(out, "memory");
      MHEG5newLine(out);
   }
   if (stream->looping != 1)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":Looping ");
      MHEG5intPrint(stream->looping, out);
      MHEG5newLine(out);
   }

/* internal attributes
    MHEG5indent(out);
    MHEG_PRINT(out,"//:Speed: ");
    MHEG5intPrint(stream->speed[0],out);
    MHEG5newLine(out);

    MHEG5indent(out);
    MHEG_PRINT(out," ");
    MHEG5intPrint(stream->speed[1],out);
    MHEG5newLine(out);

    MHEG5indent(out);
    MHEG_PRINT(out,"//:CounterPosition: ");
    MHEG5intPrint(stream->counterPosition,out);
    MHEG5newLine(out);

    MHEG5indent(out);
    MHEG_PRINT(out,"//:CounterEndPosition: ");
    MHEG5intPrint(stream->counterEndPosition,out);
    MHEG5newLine(out);

    MHEG5indent(out);
    MHEG_PRINT(out,"//:CounterMaxPosition: ");
    MHEG5intPrint(stream->counterMaxPosition,out);
    MHEG5newLine(out);
 */
/* engine data
   MHEG5indent(out);
   MHEG_PRINT(out,"// LoopsCompleted ");
   MHEG5intPrint((int)stream->streamState,out);
   MHEG5newLine(out);
 */
}

#endif

void MHEG5streamInit(MHEG5Stream *stream)
{
   assert(stream);

   MHEG5ingredientInit(&stream->ingredient);

   stream->storageMemory = MHEG5FALSE;
   stream->looping = 1;
}

void MHEG5streamFree(MHEG5Stream *stream)
{
   assert(stream);

   if (!stream->storageMemory)
   {
      MHEG5streamRemove(stream);
   }

   MHEG5ingredientFree(&stream->ingredient);
}

void MHEG5streamPrepare(MHEG5Stream *stream)
{
   MHEG5Ingredient *item;
   MHEG5Int index;

   assert(stream);

   /* 1.  Apply the first three steps of the Preparation behaviour as defined
    *     in the Root class.
    * Root Prepare:
    *      1. If the AvailabilityStatus attribute of the object is True, abort
    *         the behaviour.
    */
   assert(!stream->ingredient.root.runningStatus);
   /* Root Prepare:
    *      Otherwise:
    *      2. Retrieve the object from an entity outside the engine.
    *         - note - entity already retreived.
    */

   /* Root Prepare:
    *      3. Set each internal attribute of the object to its initial value.
    */
   stream->ingredient.content.referenced = stream->ingredient.originalContent.referenced;
   if (stream->ingredient.originalContent.referenced)
   {
      /* Copy content reference */
      stream->ingredient.content.ref.referenced.reference = MHEG5stringCopy(stream->ingredient.originalContent.ref.referenced.reference);
      stream->ingredient.content.ref.referenced.priority = stream->ingredient.originalContent.ref.referenced.priority;
   }
   else
   {
      /* Copy the included content */
      stream->ingredient.content.ref.included = MHEG5stringCopy(stream->ingredient.originalContent.ref.included);
   }
   stream->speed[0] = 1;
   stream->speed[1] = 1;
   stream->counterPosition = 0;
   stream->counterEndPosition = -1;
   stream->counterMaxPosition = -1;

   if (!stream->storageMemory)
   {
      MHEG5streamAdd(stream);
   }

   assert(stream->counterTriggers == 0);

   /* 2.  Apply the Activation behaviour to all StreamComponents of the Stream
    *     that have the InitiallyActive attribute set to True, in the order
    *     they appear in the Stream Multiplex.
    */
   for (index = 0; index < MAX_MLTPLX; index++)
   {
      item = stream->multiplex[index];
      if (item == NULL)
      {
         break;
      }

      if (!item->initiallyStopped)
      {
         switch (item->root.clazz)
         {
            case MHEG5VIDEO:
               MHEG5videoActivate((MHEG5Video *) item);
               break;
            case MHEG5AUDIO:
               MHEG5audioActivate((MHEG5Audio *) item);
               break;
            #ifndef MHEG5PROFILE_UK1_06
            case MHEG5RTGRAPHICS:
            #endif
            default:;
         }
      }
   }

   /* 3.  Apply steps four to six of the Preparation behaviour as defined in
    *     the Root class.
    */

   /* Root Prepare:
    *      4. Set the AvailabilityStatus attribute to True.
    */
   stream->ingredient.root.availabilityStatus = MHEG5TRUE;

   /* Root Prepare:
    *      5. Generate an IsAvailable event.
    */
   MHEG5sendSync(&stream->ingredient.root, MHEG5ISAVAILABLE, 0);

   /* Root Prepare:
    *      6. Perform the ContentPreparation behaviour.
    */
   TRACE(TSTRM, (" sp id=%ld", stream->ingredient.root.id))
   MHEG5ingredientContentPrepare(&stream->ingredient);
}

void MHEG5streamActivate(MHEG5Stream *stream)
{
   MHEG5Bool validContentHook;
   assert(stream);

   if (!stream->ingredient.root.runningStatus)
   {
      TRACE(TSTRM, (" sa id=%ld name=%s", stream->ingredient.root.id, stream->ingredient.content.ref.referenced.reference.data))
      if (!stream->ingredient.root.availabilityStatus)
      {
         MHEG5streamPrepare( stream );
      }
      /* Could call the base class activation behaviour, but *
         MHEG5ingredientActivate(&stream->ingredient); <- does nothing, so don't bother */

      validContentHook = MHEG5FALSE;

      if (stream->storageMemory)
      {
         if (stream->ingredient.contentHook == CHOOK_STREAM_MEMORY)
         {
            validContentHook = MHEG5TRUE;
         }
      }
      else
      {
         if (stream->ingredient.contentHook == CHOOK_STREAM_NORMAL ||
             stream->ingredient.contentHook == CHOOK_STREAM_IC)
         {
            validContentHook = MHEG5TRUE;
         }
      }

      if (validContentHook)
      {
         if (stream->ingredient.contentHook == CHOOK_STREAM_NORMAL)
         {
            /* Stream events are only relevant to broadcast streams */
            MHEG5notifyStreamRunning(stream);
         }

         /* Play all stream items in the multiplex */
         MHEG5displayStreamPlay(stream);
      }
      else
      {
         MHEG5displayStreamStop(stream);
      }

      stream->ingredient.root.runningStatus = MHEG5TRUE;
      MHEG5sendSync((MHEG5Root *) stream, MHEG5ISRUNNING, 0);

      MHEG5displayUpdate();
   }
}

void MHEG5streamDeactivate(MHEG5Stream *stream)
{
   MHEG5Bool update = MHEG5FALSE;

   assert(stream);

   if (stream->ingredient.root.runningStatus)
   {
      if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
      {
           #ifdef INCLUDE_ICS
         MHEG5StreamerStop(stream);
           #endif

         MHEG5displayStreamStop(stream);
      }
      else
      {
         assert( MHEG5getCurrentApplication());
         if (MHEG5getCurrentApplication()->streamContinuanceFlag == MHEG5FALSE)
         {
            MHEG5displayStreamStop(stream);
            update = MHEG5TRUE;
         }
      }

      MHEG5notifyStreamStopped(stream);
      MHEG5ingredientDeactivate(&stream->ingredient);

      if (update)
      {
         MHEG5displayUpdate();
      }
   }
}

void MHEG5streamDestruct(MHEG5Stream *stream)
{
   MHEG5CounterTrigger *ct2;

   assert(stream);

   MHEG5ingredientDestruct(&stream->ingredient);

   while (stream->counterTriggers)
   {
      ct2 = stream->counterTriggers;
      stream->counterTriggers = stream->counterTriggers->next;
      MHEG5freeMem(ct2);
   }

    #ifdef INCLUDE_ICS
   if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
   {
      MHEG5StreamerRemove(stream);
   }
    #endif
}

MHEG5ErrorCode MHEG5setCounterTrigger(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Stream *stream;
   MHEG5GList *thirdParam = 0;
   MHEG5Int ti = 0, value = 0;
   MHEG5CounterTrigger *ct, *ct2;

   assert(target);

   if (target->clazz != MHEG5STREAM)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   stream = (MHEG5Stream *)target;
   thirdParam = MHEG5resolveGenericInteger(params, &ti);
   if (thirdParam)
   {
      MHEG5resolveGenericInteger(thirdParam, &value);
        #ifdef INCLUDE_ICS
      if (stream->ingredient.contentHook == CHOOK_STREAM_IC && value >= 0)
      {
         MHEG5StreamerSetCounterTrigger(stream, ti, value);
      }
        #endif
      ct = stream->counterTriggers;
      while (ct)
      {
         if (ct->id == ti)
         {
            ct->pos = value;
            return MHEG5ERR_NOERROR;
         }
         ct = ct->next;
      }
      ct = MHEG5getMem(sizeof(MHEG5CounterTrigger));
      if (ct == 0)
      {
         /* Out of memory - Silently ignore action */
         return MHEG5ERR_NOERROR;
      }
      ct->id = ti;
      ct->pos = value;
      ct->next = stream->counterTriggers;
      stream->counterTriggers = ct;
   }
   else
   {
        #ifdef INCLUDE_ICS
      if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
      {
         MHEG5StreamerSetCounterTrigger(stream, ti, -1);
      }
        #endif
      ct = stream->counterTriggers;
      ct2 = 0;
      while (ct)
      {
         if (ct->id == ti)
         {
            if (ct2)
            {
               ct2->next = ct->next;
            }
            else
            {
               stream->counterTriggers = stream->counterTriggers->next;
            }
            MHEG5freeMem(ct);
            return MHEG5ERR_NOERROR;
         }
         ct2 = ct;
         ct = ct->next;
      }
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setSpeed(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Int s1 = 0;     /* Numerator */
   MHEG5Int s2 = 1;     /* Denominator */
   MHEG5Stream *s;

   /* Resolve target */
   assert(target);

   if (target->clazz != MHEG5STREAM)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   /* Resolve numerator */
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &s1);

   /* Resolve optional denominator */
   if (thirdParam)
   {
      MHEG5resolveGenericInteger(thirdParam, &s2);
   }

#ifndef MHEG5_STREAM_TRICK_MODES
   /* If we do not support trick modes then set speed to be either 1/1 or 0/1
    * for play or freeze respectivly.
    */
   if (((s1 > 0) && (s2 < 0)) || ((s1 < 0) && (s2 > 0)))
   {
      /* Result is negative - set numerator to 0 to freeze */
      s1 = 0;
   }
   else if (s1 != 0)
   {
      /* Positive - set numerator to 1 for normal speed play */
      s1 = 1;
   }

   /* Always set denominator to 1 when trick modes are not supported */
   s2 = 1;
#endif

   s = (MHEG5Stream *) target;
   if (s1 != s->speed[0] || s2 != s->speed[1])
   {
      s->speed[0] = s1;
      s->speed[1] = s2;

      if (target->runningStatus)
      {
            #ifdef INCLUDE_ICS
         if (s->ingredient.contentHook == CHOOK_STREAM_IC)
         {
            if (s1 == 0)
            {
               MHEG5StreamerPause(s);
            }
            else
            {
               MHEG5StreamerResume(s);
            }
         }
         else
         {
            MHEG5displayStreamPlay(s);
         }
            #else
         MHEG5displayStreamPlay(s);
            #endif
      }
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setCounterPosition(MHEG5Root *target, MHEG5GList *params)
{
   /* This action only has an effect on engines supporting stream trick
    * modes.
    */
   MHEG5Int cp = 0;
   MHEG5Stream *stream;

   if (target->clazz != MHEG5STREAM)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   stream = (MHEG5Stream *)target;

   MHEG5resolveGenericInteger(params, &cp);
   stream->counterPosition = cp;
    #ifdef INCLUDE_ICS
   if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
   {
      MHEG5StreamerSetCounterPosition(stream);
      if (target->availabilityStatus && !target->runningStatus)
      {
         /* Set counter position on available / non-running
          * stream = prepare (according to buffering model).
          */
         MHEG5StreamerPrepare(stream);
      }
   }
    #endif

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setCounterEndPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Stream *stream;
   MHEG5Int cp = 0;

   if (target->clazz != MHEG5STREAM)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &cp);

   stream = (MHEG5Stream *)target;

   /*  2.  Set the value of the CounterEndPosition attribute of the target
    *      Stream to NewCounterEndPosition.
    */
   stream->counterEndPosition = cp;

   /*  3.  If the target Stream is active and NewCounterEndPosition is already
    *      passed, stop the target Stream. If Looping is not equal to 1, a new
    *      looping play back shall be played. (from COR.1)
    */
   if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
   {
        #ifdef INCLUDE_ICS
      MHEG5StreamerSetCounterEndPosition(stream);
        #endif
   }
   else
   {
      if ((target->runningStatus) && (cp < stream->counterPosition))
      {
         MHEG5displayStreamStop(stream);
         if (stream->looping != 1)
         {
            MHEG5displayStreamPlay(stream);
         }
      }
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getCounterPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;
   MHEG5Root *cpVar;

   if (target->clazz != MHEG5STREAM)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(params, &cpVar);
   if (!cpVar)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else if (!cpVar->runningStatus)
   {
      error_val = MHEG5ERR_PARAMNOTACTIVE;
   }
   else if (cpVar->clazz == MHEG5INTEGERVARIABLE)
   {
      MHEG5Stream *s = (MHEG5Stream *)target;
       #ifdef INCLUDE_ICS
      if (s->ingredient.contentHook == CHOOK_STREAM_IC)
      {
         s->counterPosition = MHEG5StreamerGetCounterPosition(s);
      }
       #endif  /* INCLUDE_ICS */
      ((MHEG5IntegerVariable *) cpVar)->value = s->counterPosition;
      error_val = MHEG5ERR_NOERROR;
   }
   else
   {
      error_val = MHEG5ERR_WRONGPARAM;
   }

   return error_val;
}

MHEG5ErrorCode MHEG5getCounterMaxPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;
   MHEG5Root *cmpVar;

   if (!target)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (target->clazz != MHEG5STREAM)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(params, &cmpVar);
   if (!cmpVar->runningStatus)
   {
      error_val = MHEG5ERR_PARAMNOTACTIVE;
   }
   else if (cmpVar->clazz == MHEG5INTEGERVARIABLE)
   {
      MHEG5Stream *s = (MHEG5Stream *)target;
       #ifdef INCLUDE_ICS
      if (s->ingredient.contentHook == CHOOK_STREAM_IC)
      {
         s->counterMaxPosition = MHEG5StreamerGetCounterMaxPosition(s);
      }
       #endif  /* INCLUDE_ICS */
      ((MHEG5IntegerVariable *) cmpVar)->value = s->counterMaxPosition;
      error_val = MHEG5ERR_NOERROR;
   }
   else
   {
      error_val = MHEG5ERR_WRONGPARAM;
   }

   return error_val;
}

void MHEG5streamContentClear( MHEG5Stream *stream )
{
   if (stream->dvbLocator.service_id != 0)
   {
      S_DVB_LOCATOR defaultLocator;
      MHEG5GetDefaultService(&defaultLocator);
      if (stream->dvbLocator.service_id != defaultLocator.service_id)
      {
         DVB_MhegServiceRemovePmtListen(stream->dvbLocator);
      }
   }
   /* Clear the multiplex reference for stream objects. */
   memset(&stream->dvbLocator, 0, sizeof(S_DVB_LOCATOR));
}

void MHEG5streamContentAdapt( MHEG5Stream *stream, S_CONTENT *content )
{
   /* Check the content hook */
   TRACE(TSTRM, (" strm cntnt %d", stream->ingredient.root.runningStatus))
   if (stream->ingredient.contentHook == CHOOK_STREAM_MEMORY)
   {
      /* Content hook indicates a memory format. We expect the Storage
       * exchanged attribute to indicate storage type memory.
       */
      if (stream->storageMemory)
      {
         /* This is an MPEG2 audio file */
         TRACE(TSTRM, (" cRef=%d", stream->ingredient.content.referenced))
         if (stream->ingredient.content.referenced)
         {
            /* Make a copy of the referenced content */
            stream->ingredient.data = MHEG5getMem(content->size);
            if (stream->ingredient.data)
            {
               memcpy(stream->ingredient.data, content->data, content->size );
               stream->ingredient.dataLen = content->size;
            }
            else
            {
               ERROR_PRINT(("ERROR: failed to get memory\n"));
            }
         }
         else
         {
            ERROR_PRINT(("ERROR: Illegal included content for stream from memory\n"));
         }
      }
      else
      {
         ERROR_PRINT(("ERROR: Illegal combination of cHook %ld and storage stream\n", stream->ingredient.contentHook));
      }
   }
   else if (stream->ingredient.contentHook == CHOOK_STREAM_NORMAL)
   {
      /* Content hook indicates a stream format. We expect the Storage
       * exchanged attribute to indicate storage type stream.
       */
      if (!stream->storageMemory)
      {
         S_DVB_LOCATOR defaultLocator;

         MHEG5GetDefaultService(&defaultLocator);
         if (stream->dvbLocator.service_id != 0 &&
             stream->dvbLocator.service_id != defaultLocator.service_id)
         {
            DVB_MhegServiceRemovePmtListen(stream->dvbLocator);
         }

         if (content->size == sizeof(S_DVB_LOCATOR))
         { /* This is a dsmcc stream object or DVB URL */
           /* retrieve dvb locator from 'data' field */
            stream->dvbLocator = *((S_DVB_LOCATOR *)content->data);

            if (stream->dvbLocator.service_id != 0 &&
                stream->dvbLocator.service_id != defaultLocator.service_id)
            {
               DVB_MhegServiceAddPmtListen(stream->dvbLocator);
            }

            if (stream->dsmClearFunc)
            {
               assert( stream->dsmRef != NULL );
               stream->dsmClearFunc(stream->dsmRef);
            }
            else
            {
               assert( stream->dsmRef == NULL );
            }

            if (content->destroy != NULL)
            {
               /* retrieve DSM-CC clear function stuff */
               stream->dsmClearFunc = content->destroy;
               stream->dsmRef = content->fs_handle;
               content->destroy = NULL;
               content->fs_handle = NULL;
            }
            else
            {
               stream->dsmClearFunc = NULL;
               stream->dsmRef = NULL;
            }
         }
         else
         {
            ERROR_PRINT(("ERROR: Illegal content length %d for storage stream\n", content->size));
            stream->dvbLocator = defaultLocator;
         }
      }
      else
      {
         ERROR_PRINT(("ERROR: Illegal combination of cHook %ld and storage stream\n", stream->ingredient.contentHook));
      }
   }
   else if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
   {
      /* Nothing to do */
   }
   else
   {
      ERROR_PRINT(("ERROR: invalid chook for Stream %ld\n", stream->ingredient.contentHook));
   }
}

MHEG5Bool MHEG5streamGetCurrentService(S_DVB_LOCATOR *multiplexRef)
{
   TRACE(TSTRM, ("netw_id=0x%x srv_id=0x%x (%d)", currentService.original_network_id, currentService.service_id, currentService.service_id))
   /* Already caching the current service */
   if (currentService.original_network_id != 0)
   {
      *multiplexRef = currentService;
      return MHEG5TRUE;
   }

   /* Try to find the current service */
   MHEG5streamFindCurrentService();
   if (currentService.original_network_id != 0)
   {
      *multiplexRef = currentService;
      return MHEG5TRUE;
   }

   /* Unable to find a running Stream multiplex object -
    * set multiplex ref to default service.
    */
   MHEG5GetDefaultService(multiplexRef);
   return MHEG5FALSE;
}

void MHEG5streamFindCurrentService(void)
{
   MHEG5Group *group;
   MHEG5Bool found = MHEG5FALSE;
   int i;

   if (currentService.original_network_id != 0)
   {
      /* Current service already known */
      return;
   }

   /* Search application first */
   group = (MHEG5Group *)MHEG5getCurrentApplication();
   for (i = 0; i < 2; i++)
   {
      MHEG5Ingredient *item = 0;

      /* The first time we enter this loop, group is set to the current
       * application. The second time round it is set to the current scene.
       */
      if (group)
      {
         item = group->itemHead;
      }

      /* Search all items in this group looking for stream objects */
      while (item != 0)
      {
         if ((item->root.clazz == MHEG5STREAM) &&
             (((MHEG5Stream *)item)->dvbLocator.original_network_id != 0))
         {
            MHEG5Ingredient *multiplexItem;
            MHEG5Int index;

            /* Search all multiplex items */
            for (index = 0; index < MAX_MLTPLX; index++)
            {
               multiplexItem = ((MHEG5Stream *)item)->multiplex[index];
               if (multiplexItem == NULL)
               {
                  break;
               }

               if (multiplexItem->root.runningStatus)
               {
                  switch (multiplexItem->root.clazz)
                  {
                     case MHEG5VIDEO:
                        /* Found a video object. These have priority, so
                         * the search is over.
                         */
                        currentService = ((MHEG5Stream *)item)->dvbLocator;
                        TRACE(TSTRM, ("STM=%p netw_id=0x%x srv_id=0x%x (%d)", item, currentService.original_network_id,
                                      currentService.service_id, currentService.service_id))
                        return;
                     case MHEG5AUDIO:
                        /* Found an audio object. Remember the
                         * reference and the fact that we've found
                         * an audio object to avoid overwriting
                         * with RTGraphics reference
                         */
                        currentService = ((MHEG5Stream *)item)->dvbLocator;
                        found = MHEG5TRUE;
                        break;
                      #ifndef MHEG5PROFILE_UK1_06
                     case MHEG5RTGRAPHICS:
                        if (!found)
                        {
                           /* This is an RTGraphics object. Only
                            * remember the reference if we have not
                            * already found either an Audio or
                            * RTGraphics object.
                            */
                           currentService = ((MHEG5Stream *)item)->streamRef.multiplex;
                           found = MHEG5TRUE;
                        }
                      #endif
                     default:;
                  }
               }
            }
         }
         item = item->next;
      }
      /* Repeat the loop searching the scene objects */
      group = (MHEG5Group *)MHEG5getCurrentScene();
   }
   if (!found)
   {
      currentService.original_network_id = 0;
      currentService.transport_stream_id = 0;
      currentService.service_id = 0;
   }
   TRACE(TSTRM, ("netw_id=0x%x srv_id=0x%x (%d)", currentService.original_network_id,
                 currentService.service_id, currentService.service_id))
}

void MHEG5streamSetCurrentService(MHEG5Ingredient *item,
   S_DvbComponent *service)
{
   if (item != 0 && service != 0)
   {
      if (service->original_network_id != 0)
      {
         currentService.original_network_id = service->original_network_id;
      }
      if (service->transport_stream_id != 0)
      {
         currentService.transport_stream_id = service->transport_stream_id;
      }
      if (service->service_id != 0)
      {
         currentService.service_id = service->service_id;
      }
      switch (((MHEG5Root *)item)->clazz)
      {
         case MHEG5AUDIO:
            audioComponentTag = service->ComponentTag;
            break;
         case MHEG5VIDEO:
            videoComponentTag = service->ComponentTag;
            break;
      #ifndef MHEG5PROFILE_UK1_06
         case MHEG5RTGRAPHICS:
            rtgraphicsComponentTag = service->componentTag;
            break;
      #endif
         default:
            ERROR_PRINT(("ERROR: MHEG5streamSetCurrentService: Invalid object class in stream object multiplex\n"));
      }
      TRACE(TSTRM, ("srv_id=0x%x AC=%d VC=%d", currentService.service_id, audioComponentTag, videoComponentTag))
   }
}

void MHEG5streamClearCurrentService(void)
{
   TRACE(TSTRM, ("srv_id=0x%x AC=%d VC=%d", currentService.service_id, audioComponentTag, videoComponentTag))
   currentService.original_network_id = 0;
   currentService.transport_stream_id = 0;
   currentService.service_id = 0;
   audioComponentTag = -1;
   videoComponentTag = -1;
   #ifndef MHEG5PROFILE_UK1_06
   rtgraphicsComponentTag = -1;
   #endif
}

MHEG5Int MHEG5streamGetComponentTag(MHEG5Ingredient *item)
{
   MHEG5Stream *stream = 0;
   MHEG5Int componentTag = -1;
   MHEG5Int currentComponentTag = -1;
   MHEG5Int result = -1;

   switch (item->root.clazz)
   {
      case MHEG5AUDIO:
         stream = ((MHEG5Audio *)item)->parent;
         componentTag = ((MHEG5Audio *)item)->componentTag;
         currentComponentTag = audioComponentTag;
         break;
      case MHEG5VIDEO:
         stream = ((MHEG5Video *)item)->parent;
         componentTag = ((MHEG5Video *)item)->componentTag;
         currentComponentTag = videoComponentTag;
         break;
  #ifndef MHEG5PROFILE_UK1_06
      case MHEG5RTGRAPHICS:
         stream = ((MHEG5RTGraphics *)item)->parent;
         componentTag = ((MHEG5RTGraphics *)item)->componentTag;
         currentComponentTag = rtgraphicsComponentTag;
         break;
  #endif
      default:
         ERROR_PRINT(("ERROR: MHEG5streamGetComponentTag: ingredient is not a multiplex component\n"));
   }

   if (stream != 0)
   {
      /* Valid multiplex component */
      MHEG5String *ref = &stream->ingredient.content.ref.referenced.reference;
      if (strncmp((char *)ref->data, "rec://svc/cur", ref->len) == 0)
      {
         TRACE(TSTRM, ("srv_id=0x%x AC=%d VC=%d", currentService.service_id, audioComponentTag, videoComponentTag))
         if (componentTag == -1)
         {
            result = currentComponentTag;
         }
         else
         {
            result = -1;
         }
      }
      else
      {
         result = componentTag;
      }
      TRACE(TSTRM, ("CT=%d", result))
   }

   return result;
}