mh5ingredient.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 <string.h>
#include "mh5ingredient.h"
#include "mh5object.h"
#include "mh5final.h"
#include "mh5display.h"         /*for SetData Action    */
#include "mh5visible.h"         /*for SetData Action    */
#include "mh5fileorm.h"         /*for SetData Action    */
#include "mh5streamevent.h"     /*for Prepare Action    */
#include "mh5memory.h"
#include "mh5queue.h"           /* Events       */
#include "mh5scene.h"
#include "mh5application.h"
#include "mh5variable.h"        /*for Clone Action  */
#include "mh5hypertext.h"
#include "mh5listgroup.h"
#include "mh5stream.h"
#include "mh5video.h"
#include "mh5debug.h"
/* for print functions */
#include "mh5palette.h"
#include "mh5cursorshape.h"
#include "mh5font.h"
#include "mh5program.h"
#include "mh5variable.h"
#include "mh5audio.h"
#include "mh5rtgraphics.h"
#include "mh5slider.h"
#include "mh5dynamiclineart.h"
#include "mh5entryfield.h"
#include "mh5hotspot.h"
#include "mh5pushbutton.h"
#include "mh5switchbutton.h"
#include "mh5profile.h"
#if defined(INCLUDE_IC) && defined(INCLUDE_ICS)
#include "mh5streamer.h"
#endif

#include "mg_api.h"
#include "mg_fontapi.h"
#include "mh5drawtext.h"

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


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

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

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

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

#ifdef MH5PRINTOUT

static void MHEG5contentBodyPrint(MHEG5ContentBody b, char *out)
{
   if (b.referenced)
   {
      MHEG_PRINT(out, " :ContentRef ( ");
      MHEG5stringPrint(b.ref.referenced.reference, out);
      if (b.ref.referenced.priority != FRP_CACHE_DEFAULT)
      {
         MHEG_PRINT(out, " :CCPriority ");
         MHEG5intPrint(b.ref.referenced.priority, out);
      }
      MHEG_PRINT(out, " )");
   }
   else
   {
      MHEG5stringPrint(b.ref.included, out);
   }
   MHEG5newLine(out);
}

void MHEG5ingredientPrint(MHEG5Ingredient *ingredient, char *out)
{
   MHEG5rootPrint(&ingredient->root, out);

   /* Exchanged attributes */
   if (ingredient->initiallyStopped)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":InitiallyActive FALSE");
      MHEG5newLine(out);
   }

   if (ingredient->contentHook != MHEG5CHOOK_UNDEFINED && ingredient->contentHook != 0)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":CHook ");
      MHEG5intPrint(ingredient->contentHook, out);
      MHEG5newLine(out);
   }

   if (ingredient->originalContent.referenced || ingredient->originalContent.ref.included.data)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":OrigContent ");
      MHEG5contentBodyPrint(ingredient->originalContent, out);
   }

   if (ingredient->shared &&
       ingredient->root.clazz != MHEG5AUDIO &&
       ingredient->root.clazz != MHEG5VIDEO)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":Shared TRUE");
      MHEG5newLine(out);
   }

   /* local attributes */
   if (ingredient->content.referenced || ingredient->content.ref.included.len)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// :Content ");
      MHEG5contentBodyPrint(ingredient->content, out);
   }
}

#endif  /* #ifdef MH5PRINTOUT */


static void MHEG5updateContentHook(MHEG5Ingredient *item)
{
   MHEG5Application *application = MHEG5getCurrentApplication();

   if (!application)
   {
      return;
   }

   /* If content hook was not encoded, use the default from the application.
    * This depends on the type of object. Store the application default back
    * in the ingredient object to avoid this lookup elsewhere.
    */
   if (item->contentHook == MHEG5CHOOK_UNDEFINED)
   {
      switch (item->root.clazz)
      {
         case MHEG5BITMAP:
            item->contentHook = application->bitmapContentHook;
            break;
         case MHEG5STREAM:
            item->contentHook = application->streamContentHook;
            break;
         case MHEG5TEXT:
         case MHEG5ENTRYFIELD:
         case MHEG5HYPERTEXT:
            item->contentHook = application->textContentHook;
            break;
         case MHEG5LINEART:
         case MHEG5RECTANGLE:
         case MHEG5DYNAMICLINEART:
            item->contentHook = application->lineArtContentHook;
            break;
         case MHEG5INTERCHANGEDPROGRAM:
            item->contentHook = application->interchangedProgramContentHook;
            break;
         default:
            /* This type does not have an application default content hook.
             * Do nothing - an error will be produced by the switch statement
             * below
             */
            break;
      }
   }
}

static void MHEG5contentAdapt( MHEG5Ingredient *item, S_CONTENT *content )
{
   MHEG5Visible *vis;

   assert(item);

   /* Set default adapted content values */
   item->data = 0;
   item->dataLen = 0;

   /* Interpret the content hook. The interpretation is different depending on
    * the type of the object
    */
   switch (item->root.clazz)
   {
      case MHEG5PALETTE:
      case MHEG5CURSORSHAPE:
         /* No content encoding for this class in UK1 profile */
         ERROR_PRINT(("ERROR: content not allowed for this type %d\n", item->root.clazz));
         return;
      case MHEG5FONT:
         if (item->contentHook == CHOOK_FONT_TRUE_TYPE)
         {
            /* Store the 'font index' provided by Mheg Graphics module  */
            ((MHEG5Font *)item)->mg_fnt_index = MG_FontLoadFile( content->data, content->size );
            MHEG5fontRefreshTexts((MHEG5Font *)item );
         }
         else
         {
            /* Defensive behaviour (see D-Book 15.3.1.3)*/
            ((MHEG5Font *)item)->mg_fnt_index = 0;
            MHEG5fontRefreshTexts((MHEG5Font *)item );
         }
         return;
      case MHEG5STREAM:
         MHEG5streamContentAdapt((MHEG5Stream *)item, content );
         return;
      case MHEG5BITMAP:
         vis = (MHEG5Visible *) item;
         assert( vis->graphic_data == 0 );
         switch (item->contentHook)
         {
            case CHOOK_BITMAP_PNG:
         #ifdef DRAW_IN_ADVANCE
               MG_DrawPng( content->data, content->size, vis );
               break;
         #endif /*DRAW_IN_ADVANCE*/
            case CHOOK_BITMAP_JPG:
         #ifdef DRAW_IN_ADVANCE
               MG_DrawJpg( content->data, content->size, vis );
               break;
         #endif /*DRAW_IN_ADVANCE*/
            case CHOOK_BITMAP_NORMAL_IFRAME:
            case CHOOK_BITMAP_H264_IFRAME:
        #ifdef INCLUDE_FREESAT
            case CHOOK_BITMAP_IMAGE_PLANE_IFRAME:
        #endif
               /* Bitmap object - Copy IFrame data below */
               break;
            default:
               ERROR_PRINT(("ERROR: invalid chook for Bitmap %ld\n", item->contentHook));
               return;
         }
         break;
      case MHEG5TEXT:
      case MHEG5ENTRYFIELD:
      case MHEG5HYPERTEXT:
         switch (item->contentHook)
         {
            case CHOOK_TEXT_UTF8:
               MHEG5textUtf8Content((MHEG5Text *)item, content->data, content->size );
               break;

            case CHOOK_TEXT_UTF16:
               MHEG5textUtf16Content((MHEG5Text *)item, content->data, content->size );
               break;
            default:
               ERROR_PRINT(("ERROR: invalid chook for Text %ld\n", item->contentHook));
         }
         return;

      default:
         /* This is an internal error - this function should not have been called
          * with an item that cannot have content
          */
         ERROR_PRINT(("INTERNAL ERROR: invalid object class\n"));
         assert(0);
         return;
   }

   /* Copy the input data */
   if (item->content.referenced)
   {
      /* Make a copy of the referenced content */
      item->data = MHEG5getMem( content->size );
      if (item->data)
      {
         memcpy(item->data, content->data, content->size );
         item->dataLen = content->size;
         TRACE(TFILE, ("Cref: id=%ld, clz=%d ptr=0x%p len=%d", item->root.id, item->root.clazz, item->data, item->dataLen))
      }
   }
   else
   {
      /* Set pointers to the included content */
      item->data = item->content.ref.included.data;
      item->dataLen = item->content.ref.included.len;
      TRACE(TFILE, ("Cinc: id=%ld, clz=%d ptr=0x%p len=%d", item->root.id, item->root.clazz, item->data, item->dataLen))
   }
}

static void MHEG5contentFree(MHEG5Ingredient *item)
{
   assert(item);

   switch (item->root.clazz)
   {
      case MHEG5STREAM:
         MHEG5streamContentClear((MHEG5Stream *)item);
         break;

      case MHEG5BITMAP:
         switch (item->contentHook)
         {
            case CHOOK_BITMAP_PNG:
            case CHOOK_BITMAP_JPG:
               if (((MHEG5Visible *)item)->graphic_data)
               {
                  /* free resources for png data */
                  MG_FreeData(((MHEG5Visible *)item)->graphic_data );
                  ((MHEG5Visible *)item)->graphic_data = 0;
               }
               break;

            case CHOOK_BITMAP_NORMAL_IFRAME:
            case CHOOK_BITMAP_H264_IFRAME:
             #ifdef INCLUDE_FREESAT
            case CHOOK_BITMAP_IMAGE_PLANE_IFRAME:
             #endif
               break;
            default:
               if (item->data)
               {
                  ERROR_PRINT(("\nERROR: invalid Bmp chook %ld, id=%d data=%p", item->contentHook, item->root.id, item->data));
               }
               return;
         }
         break;

      case MHEG5TEXT:
      case MHEG5ENTRYFIELD:
      case MHEG5HYPERTEXT:
         if (((MHEG5Visible *)item)->graphic_data)
         {
            MG_FreeData(((MHEG5Visible *)item)->graphic_data );
            ((MHEG5Visible *)item)->graphic_data = 0;
         }
         if (item->dataLen > 0)
         {
            MHEG5freeMem(item->data);
            item->data = 0;
            item->dataLen = 0;
         }
         break;

      case MHEG5FONT:
         if (((MHEG5Font *)item)->mg_fnt_index != INVALID_MG_FNT_INDEX)
            MG_FontFreeFile(((MHEG5Font *)item)->mg_fnt_index );
         break;

      default:;
   }

   if ((item->content.referenced) && (item->data))
   {
      TRACE(TFILE, ("Cfree id=%ld, clz=%d ptr=0x%p len=%d", item->root.id, item->root.clazz, item->data, item->dataLen))
      /* Free off memory for referenced content */
      MHEG5freeMem(item->data);
      /* Ensure that old data cannot be used. */
      item->data = 0;
      item->dataLen = 0;
   }
}

static void MHEG5ingredientContentPrepareAsync(
   MHEG5Ingredient *ingredient, S_CONTENT *content )
{
   /*
    * The visible object does not have it's own implementation of
    * ContentAvailable since it is very similar to the ingredient one.
    * The difference is that the visible must be redisplayed once new content
    * is available.
    */

   /* Destroy the existing content for this object */
   MHEG5contentFree(ingredient);

   //TRACE(TEVNTS,(" c=%d id=%ld len=%d",ingredient->root.clazz,ingredient->root.id, content->size ))

   /* For a hypertext object reset the current hypertext link */
   if (((MHEG5Root *) ingredient)->clazz == MHEG5HYPERTEXT)
   {
      MHEG5hyperTextInitCurrentLink((MHEG5Hypertext *)ingredient);
   }
   /* For text objects, take a straight copy of the content. For other objects
    * we need to adapt it (e.g. PNG decode)
    */
   if (content->data != NULL && content->size != 0)
   {
      MHEG5contentAdapt( ingredient, content );
   }

   /* For a text object clear text data if len is 0 */
   if (((MHEG5Root *) ingredient)->clazz == MHEG5TEXT && content->size == 0)
   {
      MHEG5textClearTextData((MHEG5Text *)ingredient);
   }

   /* Refresh Stream Object for stream events */
   if (ingredient->root.clazz == MHEG5STREAM)
   {
      MHEG5refreshStreamObject((MHEG5Stream *)ingredient);
   }

   /* Generate the event to say that new content is available for this object
    */
   MHEG5sendEvent((MHEG5Root *) ingredient, MHEG5CONTENTAVAILABLE, 0);

   if (((MHEG5Root *) ingredient)->runningStatus)
   {
      /* Display I-Frame bitmap objects */
      if (ingredient->root.clazz == MHEG5BITMAP &&
          (ingredient->contentHook == CHOOK_BITMAP_NORMAL_IFRAME ||
           ingredient->contentHook == CHOOK_BITMAP_H264_IFRAME
             #ifdef INCLUDE_FREESAT
           || ingredient->contentHook == CHOOK_BITMAP_IMAGE_PLANE_IFRAME
             #endif
          )
          )
      {
         /* Check that we have something to show */
         if ((ingredient->data != NULL) && (ingredient->dataLen > 0))
         {
            MHEG5displayIFrameStart((MHEG5Bitmap *)ingredient );
         }
      }

      /* If we have a running visible, redraw it to display the new content.
       */
      if (MHEG5visibleIs((MHEG5Root *) ingredient))
      {
         MHEG5displayRedraw((MHEG5Visible *) ingredient);
#ifndef NO_SCREEN_UPDATE_ON_SYNC
         if (ingredient->cpState == CP_STATE_CHANGED)
         {
            /* Data will have changed in the visible so update display */
            MHEG5requestDisplayUpdate();
         }
#endif
      }

      /* Display stream objects */
      if (ingredient->root.clazz == MHEG5STREAM)
      {
         MHEG5displayStreamPlay((MHEG5Stream *)ingredient);
      }
   }
   ingredient->cpState = CP_STATE_INITIAL;
}

static void MHEG5ingredientContentRetrieved( void *userData, S_CONTENT *content )
{
   MHEG5Ingredient *ingredient = (MHEG5Ingredient *)userData;

   assert(ingredient);     /* valid object pointer */
   if (!ingredient)
   {
      /* should never get here */
      TRACE(TERROR, (" Null pointer to Ingredient"))
   }
   else
   {
      ingredient->ormHandle = NULL; /* after callback this handle  is no longer valid */

      assert(ingredient->root.id); /* object is not a group */
      if (ingredient->root.id == 0)
      {
         /* should never get here */
         TRACE(TERROR, (" Null object: %p", ingredient))
      }
      else
      {
         TRACE(TFILE, (" got id=%ld", ingredient->root.id))
         /* Prepare included ingredient content */
         MHEG5ingredientContentPrepareAsync( ingredient, content );
      }
   }
}

static void MHEG5ingredientContentRetrievalFail( void *userData )
{
   MHEG5Ingredient *ingredient = (MHEG5Ingredient *)userData;
   MHEG5Root *application = (MHEG5Root *)MHEG5getCurrentApplication();

   if (!ingredient)
   {
      /* No object - should never get here! */
      TRACE(TERROR, (" No object %p", userData))
   }
   else
   {
      TRACE(TFILE, (" No content: id=%ld", ingredient->root.id))

      /* Check that an application is running,
       * and that this result of direct MHEG action (i.e. Setdata action)*/
      if (application && ingredient->cpState != CP_STATE_PRELOAD &&
          !MHEG5FileOrmIsReset(NULL))
      {
         /* Raise a ContentRefError engine event */
         MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_CONTENT_REF_ERROR );
      }

      ingredient->ormHandle = NULL; /* after callback this handle is no longer valid */

      if (((MHEG5Root *)ingredient)->clazz == MHEG5STREAM)
      {
         if (((MHEG5Root *)ingredient)->runningStatus)
         {
            /* Stop the stream */
            MHEG5displayStreamStop((MHEG5Stream *)ingredient );
         }

         /* Clear the stream (there is no ContentRefError event) */
         MHEG5contentFree(ingredient);
      }

      if (((MHEG5Root *)ingredient)->clazz == MHEG5FONT)
      {
         /* Font cannot be loaded, use in-built font */
         ((MHEG5Font *)ingredient)->mg_fnt_index = 0;
         MHEG5fontRefreshTexts((MHEG5Font *)ingredient );
      }

      if (((MHEG5Root *) ingredient)->runningStatus)
      {
         /* If we have a running visible, redraw it to display the new content.
          */
         if (MHEG5visibleIs((MHEG5Root *) ingredient))
         {
            MHEG5displayRedraw((MHEG5Visible *) ingredient);
         }
      }
      ingredient->cpState = CP_STATE_INITIAL;
   }
}

void MHEG5ingredientInit(MHEG5Ingredient *ingredient)
{
   assert(ingredient);

   MHEG5rootInit(&ingredient->root);

   ingredient->originalContent.ref.referenced.priority = FRP_CACHE_DEFAULT;
   ingredient->contentHook = MHEG5CHOOK_UNDEFINED;
}

void MHEG5ingredientFree(MHEG5Ingredient *ingredient)
{
   assert(ingredient);

   MHEG5rootFree(&ingredient->root);

   if (ingredient->originalContent.referenced)
   {
      MHEG5stringDestruct(&ingredient->originalContent.ref.referenced.reference);
   }
   else
   {
      MHEG5stringDestruct(&ingredient->originalContent.ref.included);
   }
}

void MHEG5ingredientClone(MHEG5Ingredient *destination, MHEG5Ingredient *source)
{
   assert(source);
   assert(destination);

   MHEG5rootClone(&destination->root, &source->root);

   destination->initiallyStopped = source->initiallyStopped;
   destination->contentHook = source->contentHook;
   destination->originalContent.referenced = source->originalContent.referenced;
   if (source->originalContent.referenced)
   {
      destination->originalContent.ref.referenced.reference = MHEG5stringCopy(source->originalContent.ref.referenced.reference);
      destination->originalContent.ref.referenced.priority = source->originalContent.ref.referenced.priority;
   }
   else
   {
      destination->originalContent.ref.included = MHEG5stringCopy(source->originalContent.ref.included);
   }
   destination->shared = source->shared;
}

static MHEG5Bool MHEG5canHaveContent(MHEG5Ingredient *ingredient)
{
   MHEG5Bool hasContent = MHEG5FALSE;

   assert(ingredient);

   switch (ingredient->root.clazz)
   {
      case MHEG5STREAM:
         TRACE(TSTRM, ("Stream CHook=%d", ingredient->contentHook))
         /* fallthrough */

#ifndef MHEG5PROFILE_UK1_06
      case MHEG5PALETTE:
      case MHEG5CURSORSHAPE:
#endif
      case MHEG5FONT:
      case MHEG5BITMAP:
      case MHEG5TEXT:
      case MHEG5ENTRYFIELD:
      case MHEG5HYPERTEXT:
         hasContent = MHEG5TRUE;

      default:;
   }
   return hasContent;
}

/*
 *   Internal behaviours
 */

void MHEG5ingredientPrepare(MHEG5Ingredient *ingredient)
{
   CALL_PRINT((">> MHEG5ingredientPrepare(%p)\n", ingredient));

   assert(ingredient);

   ingredient->content.referenced = ingredient->originalContent.referenced;
   if (ingredient->originalContent.referenced)
   {
      /* Copy content reference */
      ingredient->content.ref.referenced.reference = MHEG5stringCopy(ingredient->originalContent.ref.referenced.reference);
      ingredient->content.ref.referenced.priority = ingredient->originalContent.ref.referenced.priority;
   }
   else
   {
      /* Copy the included content */
      ingredient->content.ref.included = MHEG5stringCopy(ingredient->originalContent.ref.included);
   }

   MHEG5rootPrepare(&ingredient->root);

   /* 6. Perform the ContentPreparation behaviour.
    */
   if (MHEG5canHaveContent(ingredient))
   {
      MHEG5ingredientContentPrepare(ingredient);
   }

   CALL_PRINT(("<< MHEG5ingredientPrepare\n"));
}

void MHEG5ingredientContentPrepare(MHEG5Ingredient *ingredient)
{
   MHEG5String ref;
   U16BIT priority;

   CALL_PRINT((">> MHEG5ingredientContentPrepare(%p)\n", ingredient));

   assert(ingredient);

   MHEG5updateContentHook(ingredient);

   if (!ingredient->content.referenced)
   {
      /* Included content */
      S_CONTENT content;
      /* Prepare retrieved ingredient content */
      content.size = ingredient->content.ref.included.len;
      content.data = ingredient->content.ref.included.data;
      content.destroy = NULL;
      content.fs_handle = NULL;
      MHEG5ingredientContentPrepareAsync( ingredient, &content );
   }
   else
   {
      /* Referenced content */
      INFO_PRINT(("MHEG5ingredientContentPrepare referenced content\n"));
      ref = ingredient->content.ref.referenced.reference;
      if (ref.len != 0)
      {
         TRACE(TFILE, ("id=%ld running=%d ref=%d,%s", ingredient->root.id, ingredient->root.runningStatus, ref.len, ref.data))
         if ((ingredient->root.clazz == MHEG5STREAM) &&
             (ingredient->contentHook == CHOOK_STREAM_IC))
         {
           #ifdef INCLUDE_ICS
            /* Stream from IP connection */
            MHEG5StreamerPrepare((MHEG5Stream *)ingredient);
           #endif  /* INCLUDE_ICS */
         }
         else
         {
            /* Initiate file request */
            priority = ingredient->content.ref.referenced.priority & FRP_CACHE_MASK;
            if (ingredient->root.grp == (MHEG5Group *)MHEG5getCurrentApplication())
            {
               /* When fileorm does reset for scene, this request should live on */
               priority |= FRP_IN_APP;
            }
            if ((ingredient->root.clazz == MHEG5STREAM) &&
                (ingredient->contentHook == CHOOK_STREAM_NORMAL))
            {
               /* Request deferred service locator */
               priority |= FRP_DEFER_SERV;
            }
            ingredient->ormHandle =
               MHEG5FileOrmGet( ref, priority, &ingredient->root,
                  MHEG5ingredientContentRetrieved,
                  MHEG5ingredientContentRetrievalFail );
         }
      }
      else
      {
         TRACE(TERROR, ("referenced content, but len is zero: id=%ld", ingredient->root.id))
      }
   }
   CALL_PRINT(("<< MHEG5ingredientContentPrepare\n"));
}

void MHEG5ingredientDestruct(MHEG5Ingredient *ingredient)
{
   assert(ingredient);

   if (MHEG5canHaveContent(ingredient))
   {
      if (ingredient->content.referenced && ingredient->ormHandle != NULL)
      {
         MHEG5FileOrmClear( ingredient->ormHandle );
      }
      MHEG5contentFree(ingredient);
   }

   MHEG5rootDestruct(&ingredient->root);

   if (ingredient->content.referenced)
   {
      MHEG5stringDestruct(&ingredient->content.ref.referenced.reference);
   }
   else
   {
      MHEG5stringDestruct(&ingredient->content.ref.included);
   }
}

void MHEG5ingredientActivate(MHEG5Ingredient *ingredient)
{
   assert(ingredient);
   MHEG5rootActivate(&ingredient->root);
}

void MHEG5ingredientDeactivate(MHEG5Ingredient *ingredient)
{
   assert(ingredient);
   MHEG5rootDeactivate(&ingredient->root);
}

/*
 *   Actions
 */


MHEG5ErrorCode MHEG5setData(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *optionalParam = 0;
   MHEG5String newRef;
   MHEG5Bool valid = MHEG5FALSE;
   MHEG5Bool referenced = MHEG5FALSE;

   assert(target);

   if (!params)
   {
      TRACE(TERROR, ("err wrong no param"))
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (!MHEG5canHaveContent((MHEG5Ingredient *) target ))
   {
      if (target->clazz != MHEG5OCTETSTRINGVARIABLE)
      {
         TRACE(TERROR, ("err wrong class=%d", target->clazz))
      }
      return MHEG5ERR_WRONGTARGET;
   }

   optionalParam = MHEG5resolveGenericCRef(params, &newRef, &referenced, &valid);
   if (valid == MHEG5FALSE)
   {
      TRACE(TERROR, ("err wrong param"))
      return MHEG5ERR_WRONGPARAM;
   }

   if (((MHEG5Ingredient *) target)->content.referenced != referenced)
   {
      /* Do not allow ingredient to change from included to referenced data and vice versa */
      return MHEG5ERR_WRONGPARAM;
   }

   if (((MHEG5Ingredient *) target)->content.referenced)
   {
      MHEG5stringDestruct(&((MHEG5Ingredient *) target)->content.ref.referenced.reference);
   }
   else
   {
      MHEG5stringDestruct(&((MHEG5Ingredient *) target)->content.ref.included);
   }
   ((MHEG5Ingredient *) target)->content.referenced = referenced;
   if (referenced)
   {
      /*Setting ContentCachePriority back to default.
         May be set by optional parameter*/
      ((MHEG5Ingredient *) target)->content.ref.referenced.priority = FRP_CACHE_DEFAULT;

      if (optionalParam)
      {
         /* NewContSize */
         MHEG5Int contentSize = 0;
         optionalParam = MHEG5resolveGenericInteger(optionalParam, &contentSize);

         if (optionalParam)
         {
            /* NewContentCachePriority */
            MHEG5resolveGenericInteger(optionalParam,
               &(((MHEG5Ingredient *) target)->content.ref.referenced.priority));
         }
      }
      ((MHEG5Ingredient *) target)->content.ref.referenced.reference = MHEG5stringCopy(newRef);
   }
   else
   {                      /* Included Content */
      ((MHEG5Ingredient *) target)->content.ref.included = MHEG5stringCopy(newRef);
   }
   ((MHEG5Ingredient *) target)->cpState = CP_STATE_CHANGED;

#ifdef TRACING
   if (mheg_trace_debug & (TACTIONS | TFILE))
   {
      DBG_PRINTF(T_NL "SetData( %ld, %s=\"%s\" )", target->id, (referenced) ? "Ref" : "Txt", newRef.data);
   }
#endif

#ifndef MHEG5PROFILE_UK1
   /* The following corrigenda changes have been overridden by UK1 profile. */

   /* COR1: 16.1 : When a setdata is performed on a bitmap, scaling is reset.
    * NOTE: Redraw is forced as part of ContentPrepare, either with new content
    * or with a place holder.
    */
   if (target->clazz == MHEG5BITMAP)
   {
      ((MHEG5Bitmap *)target)->scaleSet = MHEG5FALSE;
   }

   /* COR1: 20.8 : When a setdata is performed on a stream, scaling of
    * contained video objects is reset
    */
   if (target->clazz == MHEG5STREAM)
   {
      MHEG5Ingredient **multiplexItem;

      multiplexItem = ((MHEG5Stream *)target)->multiplex;

      while (*multiplexItem)
      {
         if ((*multiplexItem)->root.clazz == MHEG5VIDEO)
         {
            ((MHEG5Video *)*multiplexItem)->scaleSet = MHEG5FALSE;
         }
         multiplexItem++;
      }
   }
#endif

#ifdef INCLUDE_ICS
   if (target->clazz == MHEG5STREAM)
   {
      /* SetData on Stream object implicitly resets the counter position and
       * the counter end position.
       * This behaviour is not specified anywhere, but is required
       * by IP streaming tests.
       */
      MHEG5Stream *stream = (MHEG5Stream *)target;

      if (stream->ingredient.contentHook == CHOOK_STREAM_IC)
      {
         stream->counterPosition = 0;
         stream->counterEndPosition = -1;
      }
   }
#endif  /* INCLUDE_ICS */

   MHEG5ingredientContentPrepare((MHEG5Ingredient *)target);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5clone(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *cloneRefVar = 0, *newItem = 0;
   MHEG5ObjectRefVariable *objref;
   MHEG5Int newId = 5555;
   MH5GroupRef gref;

   assert(target);

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(params, &cloneRefVar);
   if (!cloneRefVar)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   switch (target->clazz)
   {
      case MHEG5SCENE:
      case MHEG5APPLICATION:
      case MHEG5STREAM:
      case MHEG5AUDIO:
      case MHEG5VIDEO:
      case MHEG5RTGRAPHICS:
         ERROR_PRINT(("ERROR: Clone not supported for class %d\n", target->clazz));
         return MHEG5ERR_WRONGPARAM;

      default:
         ERROR_PRINT(("ERROR: Clone not supported by this engine for class %d\n", target->clazz));
         return MHEG5ERR_NOTSUPPORTEDBYPROFILE;

      case MHEG5BITMAP:
         newItem = (MHEG5Root *)MHEG5bitmapClone((MHEG5Bitmap *)target);
         break;

      case MHEG5TEXT:
         newItem = (MHEG5Root *)MHEG5textClone((MHEG5Text *)target);
         break;

      case MHEG5RECTANGLE:
         newItem = (MHEG5Root *)MHEG5rectangleClone((MHEG5Rectangle *)target);
         break;
   }
   if (newItem != NULL)
   {
      newId += target->id;

      gref.len = 0;
      gref.ptr.group = target->grp;
      while (MHEG5findObject(gref, newId))
      {
         newId++;
      }

      newItem->id = newId;
      MHEG5groupAddItem((MHEG5Group *)target->grp, (MHEG5Ingredient *)newItem );

      objref = (MHEG5ObjectRefVariable *)cloneRefVar;

      MHEG5objRefStoreValue( objref, gref, newId );

      ((MHEG5Ingredient *)newItem)->cloned = MHEG5TRUE;

      switch (newItem->clazz)
      {
         case MHEG5BITMAP:
            MHEG5bitmapPrepare((MHEG5Bitmap *)newItem );
            break;
         case MHEG5TEXT:
            MHEG5textPrepare((MHEG5Text *)newItem );
            break;
         case MHEG5RECTANGLE:
            MHEG5rectanglePrepare((MHEG5Rectangle *)newItem );
            break;
         default:;
      }
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5preload(MHEG5Root *target, MHEG5GList *params)
{
   assert(target);
   if (!target->availabilityStatus)
   {
      ((MHEG5Ingredient *) target)->cpState = CP_STATE_PRELOAD;
      switch (target->clazz)
      {
         case MHEG5SCENE:
         case MHEG5APPLICATION:
            ERROR_PRINT(("ERROR: target invalid class %d\n", target->clazz));
            break;
         case MHEG5LINK:
            MHEG5linkPrepare((MHEG5Link *) target);
            break;
         case MHEG5BITMAP:
            MHEG5bitmapPrepare((MHEG5Bitmap *) target);
            break;
         case MHEG5TEXT:
            MHEG5textPrepare((MHEG5Text *) target);
            break;
         case MHEG5LINEART:
            MHEG5lineartPrepare((MHEG5Lineart *) target);
            break;
         case MHEG5DYNAMICLINEART:
            MHEG5dynamicLineartPrepare((MHEG5DynamicLineart *) target);
            break;
         case MHEG5RECTANGLE:
            MHEG5rectanglePrepare((MHEG5Rectangle *) target);
            break;
         case MHEG5RESIDENTPROGRAM:
         case MHEG5REMOTEPROGRAM:
         case MHEG5INTERCHANGEDPROGRAM:
            MHEG5programPrepare((MHEG5Program *) target);
            break;
         case MHEG5BOOLEANVARIABLE:
            MHEG5booleanVariablePrepare((MHEG5BooleanVariable *)target);
            break;
         case MHEG5INTEGERVARIABLE:
            MHEG5integerVariablePrepare((MHEG5IntegerVariable *)target);
            break;
         case MHEG5OCTETSTRINGVARIABLE:
            MHEG5octetStringVariablePrepare((MHEG5OctetStringVariable *)target);
            break;
         case MHEG5OBJECTREFVARIABLE:
            MHEG5objectRefVariablePrepare((MHEG5ObjectRefVariable *)target);
            break;
         case MHEG5CONTENTREFVARIABLE:
            MHEG5contentVariablePrepare((MHEG5ContentVariable *)target);
            break;
         case MHEG5STREAM:
            MHEG5streamPrepare((MHEG5Stream *) target);
            break;
         case MHEG5AUDIO:
            MHEG5audioPrepare((MHEG5Audio *) target);
            break;
         case MHEG5VIDEO:
            MHEG5videoPrepare((MHEG5Video *) target);
            break;
      #ifndef MHEG5PROFILE_UK1_06
         case MHEG5HOTSPOT:
            MHEG5hotspotPrepare((MHEG5Hotspot *)target);
            break;
         case MHEG5PUSHBUTTON:
            MHEG5pushbuttonPrepare((MHEG5Pushbutton *)target);
            break;
         case MHEG5SWITCHBUTTON:
            MHEG5switchbuttonPrepare((MHEG5Switchbutton *)target);
            break;
         case MHEG5RTGRAPHICS:
            MHEG5rtgraphicsPrepare((MHEG5RTGraphics *) target);
            break;
         case MHEG5PALETTE:
            MHEG5palettePrepare((MHEG5Palette *)target);
            break;
         case MHEG5CURSORSHAPE:
            MHEG5cursorShapePrepare((MHEG5CursorShape *)target);
            break;
      #endif 
         case MHEG5FONT:
            MHEG5fontPrepare((MHEG5Font *)target);
            break;
         case MHEG5TOKENGROUP:
            MHEG5tokenGroupPrepare((MHEG5TokenGroup *)target);
            break;
         case MHEG5LISTGROUP:
            MHEG5listGroupPrepare((MHEG5ListGroup *)target);
            break;
         case MHEG5ENTRYFIELD:
            MHEG5entryfieldPrepare((MHEG5Entryfield *)target);
            break;
         case MHEG5HYPERTEXT:
            MHEG5hypertextPrepare((MHEG5Hypertext *)target);
            break;
         case MHEG5SLIDER:
            MHEG5sliderPrepare((MHEG5Slider *)target);
            break;
         default:
            ERROR_PRINT(("ERROR: Preload: Unrecognised class %d\n", target->clazz));
            assert(0);
      }
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5unload(MHEG5Root *target, MHEG5GList *params)
{
   assert(target);

   if (target->runningStatus)
   {
      TRACE(TERROR, ("**** object still running! id=%d ****", target->id))
   }
   else if (target->clazz != MHEG5APPLICATION && target->clazz != MHEG5SCENE)
   {
      MHEG5finalDeactivate(target);
      MHEG5finalDestruct(target);

      if (((MHEG5Ingredient *)target)->cloned)
      {
         TRACE(TSTATE, ("cloned id=%d", target->id))

         MHEG5groupDelItem( target->grp, (MHEG5Ingredient *)target );

         switch (target->clazz)
         {
            case MHEG5BITMAP:
               MHEG5bitmapFree((MHEG5Bitmap *)target);
               break;
            case MHEG5TEXT:
               MHEG5textFree((MHEG5Text *)target);
               break;
            case MHEG5RECTANGLE:
               MHEG5rectangleFree((MHEG5Rectangle *)target);
               break;
            default:
               TRACE(TERROR, ("Unrecognised cloned class %d", target->clazz));
               assert(0);
         }

         MHEG5freeMem(target);
      }
   }
   else
   {
      TRACE(TERROR, ("*** unload on App/Scene %d ***", target->clazz))
   }
   return MHEG5ERR_NOERROR;
}