mh5scene.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 "mh5base.h"
#include "mh5profile.h"
#include "mh5scene.h"
#include "mh5object.h"          /* for actions                  */
#include "mh5gate.h"
#include "mh5variable.h"        /* for actions                  */
#include "mh5memory.h"          /* for constructor/destructor   */
#include "tmcursor.h"           /* for CursorEffects            */
#include "mh5application.h"     /* get currentApplication       */
#include "mh5display.h"         /* for display of Initial Obj.  */
#include "mh5final.h"           /* for deactivation etc,        */
#include "mh5cursorshape.h"     /* for actions                  */
#include "mh5queue.h"           /* Events                       */
#include "mh5fileorm.h"
#include "mh5keypress.h"
#include "mh5debug.h"
#include "dvb_video.h"
#include "dvb_misc.h"
#include "mg_osd.h"

#include "fpa1_parserInvoke.h"

#ifdef ASN1TEST
#include "asn1_testHarness.h"
#endif /* ASN1TEST */



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

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

static MHEG5Scene *currentScene = 0;

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

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


#ifdef MH5PRINTOUT
extern int mheg_trace_source;
void MHEG5scenePrint(MHEG5Scene *scene, char *out)
{
   MHEG5String path;
   int save_indent = MHEG5setIndent(0);

   path = MHEG5convertGID(&scene->group.groupName);
   STB_DebugLogOpen( path.data );
   MHEG5stringDestruct(&path);

   /* inherited classes */
   MHEG5groupPrint(&scene->group, out);

   /* exchanged attributes */
   MHEG5indent(out);
   MHEG_PRINT(out, ":InputEventReg ");
   MHEG5intPrint(scene->inputEventRegister, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":SceneCS ");
   MHEG5intPrint(scene->sceneCoordinateSystem[0], out);
   MHEG_PRINT(out, " ");
   MHEG5intPrint(scene->sceneCoordinateSystem[1], out);
   MHEG5newLine(out);

   if (scene->aspectRatio != ASPECT_UNDEFINED)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":AspectRatio ");
      MHEG5intPrint(scene->aspectRatio, out);
      MHEG5newLine(out);
   }

   if (scene->movingCursor)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":MovingCursor :GBoolean true");
      MHEG5newLine(out);
   }
   if (scene->nextScenes.params)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":NextScenes ");
      MHEG5gListPrint(scene->nextScenes.params, out, 255);
      MHEG5newLine(out);
   }

   MHEG5decIndent();
   MHEG5indent(out);
   MHEG_PRINT(out, "}");
   MHEG5newLine(out);

   STB_DebugLogClose();
   MHEG5setIndent(save_indent);
}

#endif /* MH5PRINTOUT */

static void MHEG5sceneParseNextScenes(MHEG5GList *nextScenes)
{
   MHEG5GList *nextScene;

   nextScene = nextScenes;
   while (nextScene)
   {
      MHEG5String groupID;

      /* The first entry in the list should be an open bracket */
      if (nextScene->generic.type != MHEG5BRACKETOPEN)
      {
         ERROR_PRINT(("ERROR: NextScene parsing expected a (\n"));
         break;
      }
      nextScene = nextScene->next;

      /* The next entry is an octet string containing the group identifier
       * of a scene object that may be displayed after the current one
       */
      if ((nextScene == 0) ||
          (nextScene->generic.type != MHEG5OCTETSTRING))
      {
         ERROR_PRINT(("ERROR: NextScene parsing expected an OctetString\n"));
         break;
      }
      groupID = nextScene->generic.value.s;
      nextScene = nextScene->next;

      /* The next entry is an integer value in the range [0,255] representing
       * the weight factor with which this scene might be used.
       */
      if ((nextScene == 0) ||
          (nextScene->generic.type != MHEG5INT))
      {
         ERROR_PRINT(("ERROR: NextScene parsing expected an integer\n"));
         break;
      }
      nextScene = nextScene->next;

      /* Last entry should be a close bracket */
      if ((nextScene == 0) ||
          (nextScene->generic.type != MHEG5BRACKETCLOSE))
      {
         ERROR_PRINT(("ERROR: NextScene parsing expected an OctetString\n"));
         break;
      }
      nextScene = nextScene->next;

      /* This was a valid sequence. Pass the group ID onto DSM-CC so that it
       * can prefetch the next scene.
       */
      MHEG5FileOrmPreloadHint(groupID);
   }
}

MHEG5Scene* MHEG5getCurrentScene(void)
{
   return currentScene;
}

static void MHEG5sceneRetrieved( void *userData, S_CONTENT *content )
{
   MHEG5Application *app = MHEG5getCurrentApplication();
   MHEG5Ingredient *item;
   MHEG5Scene *newScene;
   MHEG5String path;

   USE_UNWANTED_PARAM(userData);

   assert( app );
   assert( content );
   assert( content->data );

   TRACE(TFILE | TEVNTS, ("Got Scene (datalen=%ld)", content->size))
   /* Event processing was disabled when the file load was initiated. Re-enable
    * event processing now to allow queued actions to execute.
    */
   MHEG5enableEventProcessing(MHEG5TRUE);

   TRACE_MEM();

   /* Parse Scene */
   if (*(content->data) == 0xA1) /* ASN1 */
   {
      newScene = asn1_parseScene( content->data, content->size );

        #ifdef MH5PRINTOUT
      if (mheg_trace_source)
         MHEG5scenePrint(newScene, 0);
        #endif
   }
   else  /* TEXT */
   {
      TRACE(TERROR, ("This scene is Text, and not ASN1 encoded!"))
      newScene = NULL;
   }

   if (newScene != NULL)
   {
      MHEG5FileOrmReset(MHEG5_FILE_ORM_RESET_SCENE_OBJECTS);

      /* Lock screen to prevent visibles being erased one at a time */
      app->lockCount++;
      item = app->group.itemTail;
      while (item)
      {
         if (item->shared == MHEG5FALSE)
         {
            MHEG5finalDeactivate(&item->root);
         }
         item = item->prev;
      }
      /* Unlock the screen. At this stage all visibles have been destructed */
      app->lockCount--;

      /* Destroy the old scene */
      if (currentScene)
      {
         MHEG5Scene *scene;

         scene = currentScene;

         MHEG5sceneDeactivate(scene);

         /* An Scene transition constitutes a context change, as defined in
          * section 53.3 of ISO/IEC13522-5. This causes pending elementary actions
          * and events, which were sourced from that scene, to be destroyed.
          */
         MHEG5queueResetScene((MHEG5Root *)scene );

         /* If the application contains actions with scene ingredients
          * as targets, now is a good time to "unresolve" these targets.
          * Note that this shouldn't happen according to section 51 of
          * ISO/IEC 13552-5, but it does.
          * This must be done after the queue is reset, to make sure
          * that there are no such actions in the action queue.
          */
         MHEG5applicationClearGroupTargets(app, &scene->group);

         MHEG5sceneDestruct(scene);

         MHEG5sceneFree(scene);
         MHEG5freeMem(scene);
      }
      else
      {
         /* An Scene transition constitutes a context change, as defined in
          * section 53.3 of ISO/IEC13522-5. This causes pending elementary actions
          * and events, which were sourced from the startup app, to be destroyed.
          */
         MHEG5queueResetScene( NULL );

         /* There is no scene, but the application links must still
          * be prepared to be resolved.
          */
         MHEG5applicationClearGroupTargets(app, NULL);
      }
      MHEG5displayStreamUpdate(app);

      TRACE((TFILE | TPERFORM), ("Preparing %.*s", (int)newScene->group.groupName.len, (char *)newScene->group.groupName.data))
      TRACE_MEM();

      /* Set the current scene to be the new scene */
      currentScene = newScene;

      /* Make the current scene GID an absolute reference */
      path = MHEG5convertGID(&currentScene->group.groupName);
      MHEG5stringDestruct(&currentScene->group.groupName);
      currentScene->group.groupName = path;

      /* Resolve any unresolved targets (they may be pointing at
       * scene ingredients, even though they shouldn't)
       */
      MHEG5applicationResolveTargets(app);

      /* Pass on the NextScenes information to DSM-CC */
      MHEG5sceneParseNextScenes(currentScene->nextScenes.params);

      MHEG5scenePrepare(currentScene);
      TRACE((TFILE | TPERFORM), ("Running Scene"))
      MHEG5sceneActivate(currentScene);
      TRACE((TFILE | TPERFORM), ("Started Scene"))
      TRACE_MEM();
   }
   else
   {
      /* If we failed to parse the scene then we quit the current application
         and restart the previous one - we DON'T send a GroupIDRefError EngineEvent */
      TRACE(TERROR, ("Bad Scene data"))
#ifdef MHEG5LOG
      MHEG5LogPrintf(MHEG5WARNING, "Couldn't parse scene\n");
#endif /*MHEG5LOG*/
   }
}

static void MHEG5sceneRetrieveFail( void *userData )
{
   MHEG5Root *app = (MHEG5Root *)MHEG5getCurrentApplication();

   TRACE(TERROR, (" Failed to get scene file"))

   /* Re-enable event processing following a failed Scene TransitionTo */
   MHEG5enableEventProcessing(MHEG5TRUE);
   if (app)
   {
      /* Raise a GroupIDRefError engine event */
      MHEG5sendEvent( app, MHEG5ENGINEEVENT, EE_GROUP_ID_REF_ERROR );
   }
}

void MHEG5sceneInit(MHEG5Scene *scene)
{
   assert(scene);

   MHEG5groupInit(&scene->group);

   scene->sceneCoordinateSystem[0] = 720;
   scene->sceneCoordinateSystem[1] = 576;
}

void MHEG5sceneFree(MHEG5Scene *scene)
{
   assert(scene);

   MHEG5groupFree(&scene->group);

   if (scene->nextScenes.params)
   {
      MHEG5gListDestruct(scene->nextScenes.params);
   }
}

void MHEG5scenePrepare(MHEG5Scene *scene)
{
   assert(scene);

#ifdef MHEG5LOG
   MHEG5LogPrintf(MHEG5CALLS, "Scene Prepare ");
   MHEG5LogPrintObjectPtr(MHEG5CALLS, (MHEG5Root *) scene);
   MHEG5LogPrintf(MHEG5CALLS, "\n");
#endif

   scene->currentInteractible = 0;

   MG_OSDMhegInit((U16BIT)scene->sceneCoordinateSystem[0],
      (U16BIT)scene->sceneCoordinateSystem[1], scene->aspectRatio );

   if (scene->movingCursor)
   {
      OSDshowCursor(0);
   }
   else
   {
      OSDhideCursor();
   }
   MHEG5groupPrepare(&scene->group);
   MHEG5displayShowAll();
}

void MHEG5sceneDestruct(MHEG5Scene *scene)
{
   if (!scene)
   {
      return;
   }

#ifdef MHEG5LOG
   MHEG5LogPrintf(MHEG5CALLS, "Scene Destruct ");
   MHEG5LogPrintObjectPtr(MHEG5CALLS, (MHEG5Root *) scene);
   MHEG5LogPrintf(MHEG5CALLS, "\n");
#endif

   MHEG5groupDestruct(&scene->group);

   if (scene == currentScene)
   {
      currentScene = 0;
   }
}

void MHEG5sceneActivate(MHEG5Scene *scene)
{
   assert(scene);

#ifdef MHEG5LOG
   MHEG5LogPrintf(MHEG5CALLS, "Scene Activate ");
   MHEG5LogPrintObjectPtr(MHEG5CALLS, (MHEG5Root *)scene);
   MHEG5LogPrintf(MHEG5CALLS, "\n");
#endif

   if (!scene->group.root.runningStatus)
   {
      DVB_MhegSetAspectRatio( currentScene->aspectRatio );

      MHEG5groupActivate(&scene->group);

      /* With synchronous file loading Activate can call TransitionTo, so
       * scene no longer exists. Check for this before continuing.
       */
      if (scene == currentScene)
      {
         /* Pass on the input event register value. This nofities the
          * environment which keys are required by the MHEG-5 engine.
          */
         MHEG5setInputEventRegister(scene->inputEventRegister);
         MHEG5setInputEventMask(&scene->inputMask);
      }
   }
}

void MHEG5sceneDeactivate(MHEG5Scene *scene)
{
   assert(scene);

   if (scene->group.root.runningStatus)
   {
      MHEG5groupDeactivate(&scene->group);
   }
}

MHEG5ErrorCode MHEG5transitionTo(MHEG5Root *target, MHEG5GList *params)
{
   MH5GroupRef gref;
   MHEG5Int id = 0;

   /*
      Fill groupid and id with param-values
    */
   MHEG5resolveGenericORefProper(params, &gref, &id);

   /* ID of a scene must be zero. Check it. */
   if (id != 0)
   {
      ERROR_PRINT(("ERROR: TransitionTo targeted to object with ID of %ld\n", id));
   }

   if (gref.len)
   {
      MHEG5String gname;
      if (currentScene)
      {
         if (MHEG5sameGroup(&currentScene->group, gref))
         {
            WARNING_PRINT(("MHEG5transitionTo - aborting TransitionTo, scene already active \n"));

            /* Ignore a TransitionTo to the currently running Scene */
            return MHEG5ERR_IGNORE_ACTION;
         }
      }

      /* The file retrieval process is asynchronous, but any queued actions
       * should not be processed until the file is loaded. Therefore we
       * disable event processing whilst loading this file.
       */
      MHEG5enableEventProcessing(MHEG5FALSE);

      gname.len = gref.len;
      gname.data = gref.ptr.name;

      TRACE(TFILE | TEVNTS, ("(%.*s)", (int)gname.len, gname.data));
      /* Retreive the file. We do not know the cache priority yet, so use
       * the default.
       */
      (void)MHEG5FileOrmGet( gname, FRP_SCENE | FRP_CACHE_DEFAULT, (MHEG5Root *)currentScene,
         MHEG5sceneRetrieved, MHEG5sceneRetrieveFail );
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5sendEventAction(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0, *fourthParam = 0;
   MHEG5Root *emulatedSource = 0;
   MHEG5Generic value;

   assert(target);

   if (target != (MHEG5Root *) currentScene)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericORef(params, &emulatedSource);

   if ((thirdParam) && (!thirdParam->generic.indirect) &&
       (thirdParam->generic.type == MHEG5EVENT))
   {
      int i = 0;
      fourthParam = thirdParam->next;
      if (fourthParam)
      {
         /* Get the optional EmulatedEventData parameter */
         MHEG5resolveGenericGeneric(fourthParam, &value);
         switch (value.type)
         {
            case MHEG5OCTETSTRING:
               i = LNK_GetStringIndex( value.value.s );
               break;
            case MHEG5BOOL:
               i = value.value.b;
               break;
            case MHEG5INT:
            default:
               i = value.value.i;
         }
      }
      if (thirdParam->generic.value.e >= MHEG5ANCHORFIRED)
      {
         MHEG5sendEvent(emulatedSource, thirdParam->generic.value.e, i);
      }
      else
      {
         MHEG5sendSync(emulatedSource, thirdParam->generic.value.e, i);
      }
   }
   else
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setCursorShape(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *cursorShape = 0;
   MHEG5Int newShape = 0;

   if (!currentScene)
   {
      return MHEG5ERR_NOSCENE;
   }
   if (!currentScene->movingCursor)
   {
      return MHEG5ERR_NOERROR;
   }

   assert(target);

   if (target != (MHEG5Root *) currentScene)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      OSDhideCursor();
      return MHEG5ERR_NOERROR;
   }

   MHEG5resolveGenericORef(params, &cursorShape);
   if (!cursorShape)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (cursorShape->clazz != MHEG5CURSORSHAPE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   newShape = MHEG5strToInt(((MHEG5CursorShape *)cursorShape)->ingredient.content.ref.included);

   OSDshowCursor((int)newShape);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setCursorPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Int x = 0, y = 0;

   if (!currentScene)
   {
      return MHEG5ERR_NOSCENE;
   }
   if (!currentScene->movingCursor)
   {
      return MHEG5ERR_NOERROR;
   }

   assert(target);

   if (target != (MHEG5Root *) currentScene)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &x);

   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(thirdParam, &y);

   OSDsetCursorPosition(x, y);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getCursorPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Root *x, *y;
   MHEG5Int xx, yy;

   if (!currentScene)
   {
      return MHEG5ERR_NOSCENE;
   }
   if (!currentScene->movingCursor)
   {
      return MHEG5ERR_NOERROR;
   }

   assert(target);

   if (target != (MHEG5Root *) currentScene)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveORef(params, &x);

   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(thirdParam, &y);

   OSDgetCursorPosition(&xx, &yy);

   if (x && y)
   {
      if ((x->clazz == MHEG5INTEGERVARIABLE) && (y->clazz == MHEG5INTEGERVARIABLE) &&
          (x->runningStatus) && (y->runningStatus))
      {
         ((MHEG5IntegerVariable *) x)->value = xx;
         ((MHEG5IntegerVariable *) y)->value = yy;
      }
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setInputRegister(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int inputRegister;

   if (!currentScene)
   {
      return MHEG5ERR_NOSCENE;
   }

   assert(target);

   if (target != (MHEG5Root *) currentScene)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveGenericInteger(params, &inputRegister);

   ((MHEG5Scene *)target)->inputEventRegister = inputRegister;
   MHEG5setInputEventRegister(inputRegister);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setInputMask(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Bool invalidString;
   MHEG5String inputMask;
   MHEG5Scene *scene;

   if (!currentScene)
   {
      return MHEG5ERR_NOSCENE;
   }

   assert(target);

   if (target != (MHEG5Root *) currentScene)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   scene = (MHEG5Scene *)target;

   MHEG5resolveGenericOctetString(params, &inputMask, &invalidString);
   if ((invalidString) || (inputMask.len == 0))
   {
      /* Parameter was not an octet string or a zero length string */
      return MHEG5ERR_WRONGPARAM;
   }
   MHEG5stringDestruct(&scene->inputMask);
   scene->inputMask = MHEG5stringCopy(inputMask);
   MHEG5setInputEventMask(&inputMask);

   return MHEG5ERR_NOERROR;
}