mh5object.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 "mh5object.h"
#include "mh5gate.h"
#include "mh5application.h"
#include "mh5scene.h"
#include "mh5variable.h"
#include "mh5stream.h"
#include "mh5memory.h"
#include "mh5profile.h"
#include "mh5debug.h"

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


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

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

static const char dummy_str[] = "\0";

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

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

MHEG5String MHEG5getGroupId(MHEG5Root *root)
{
   assert(root);
   return root->grp->groupName;
}

/*
     Find an object in Scene or Application Scope
 */
MHEG5Root* MHEG5findObject(MH5GroupRef gref, MHEG5Int id)
{
   MHEG5Ingredient *search = 0;
   MH5GroupPtr pGroup;

   /* is object from current scene ? */
   pGroup = (MH5GroupPtr)MHEG5getCurrentScene();
   if (pGroup)
   {
      if ((pGroup == gref.ptr.group) ||
          ((gref.len != 0) && MHEG5sameGroup(pGroup, gref)))
      {
         if (id == 0)
         {
            return (MHEG5Root *) pGroup;
         }
         else
         {
            search = pGroup->hashIngred[id & 0xff];
         }
      }
   }

   /* is object from current application ? */
   if (!search)
   {
      pGroup = (MH5GroupPtr)MHEG5getCurrentApplication();
      if (pGroup)
      {
         if ((pGroup == gref.ptr.group) ||
             ((gref.len != 0) && MHEG5sameGroup(pGroup, gref)))
         {
            if (id == 0)
            {
               return (MHEG5Root *) pGroup;
            }
            else
            {
               search = pGroup->hashIngred[id & 0xff];
            }
         }
      }
   }

   while (search && (search->root.id != id))
   {
      search = search->hnxt;
   }
   return (MHEG5Root *) search;
}

/*
 *  Resolve a direct Object Reference
 *
 *  An object reference can by internal or external. An external reference is
 *  of the form :
 *      ( 'group_id_string' id )
 *  An internal reference is of the form
 *      id
 *  where group_id_string is an OctetString and id is an Integer.
 */
MHEG5GList* MHEG5resolveORef(MHEG5GList *params, MHEG5Root **object)
{
   MHEG5GList *next;

   assert(object);

   if (!params)
   {
      TRACE(TERROR, ("INTERNAL: NULL params")) *
      object = 0;
      next = 0;
   }
   else
   {
      switch (params->generic.type)
      {
         case MHEG5OBJECTREF:
         case MHEG5OBJREFEXT:
            *object = MHEG5findObject(params->generic.value.o.gref, params->generic.value.o.id);
            if (*object == NULL)
            {
               TRACE(TEVNTS, ("Object reference %d not found", params->generic.value.o.id));
            }
            next = params->next;
            break;

         default:
            TRACE(TERROR, ("INTERNAL: type=%d", params->generic.type)) *
            object = 0;
            next = 0;
            break;
      }
   }
   return next;
}

MHEG5GList* MHEG5resolveGenericORefProper(MHEG5GList *params,
   MH5GroupRef *pgroupRef,
   MHEG5Int *id)
{
   MHEG5Root *object;
   MHEG5GList *next;

   assert(pgroupRef);
   assert(id);

   if (!params)
   {
      TRACE(TERROR, ("INTERNAL: NULL params"))
      pgroupRef->len = 0;
      pgroupRef->ptr.group = 0;
      *id = 0;
      next = 0;
   }
   else
   {
      if (params->generic.indirect)
      {
         /* Indirect Reference */
         object = MHEG5findObject(params->generic.value.o.gref, params->generic.value.o.id);
         if (object && object->clazz == MHEG5OBJECTREFVARIABLE)
         {
            if (((MHEG5ObjectRefVariable *) object)->valueGrp.len != 0)
            {
               pgroupRef->len = ((MHEG5ObjectRefVariable *) object)->valueGrp.len;
               pgroupRef->ptr.name = ((MHEG5ObjectRefVariable *) object)->valueGrp.data;
            }
            else
            {
               pgroupRef->len = 0;
               pgroupRef->ptr.group = object->grp;
            }
            *id = ((MHEG5ObjectRefVariable *) object)->valueId;
         }
         else
         {
            pgroupRef->len = 0;
            pgroupRef->ptr.group = 0;
            *id = 0;
         }
      }
      else
      {
         switch (params->generic.type)
         {
            case MHEG5OBJREFEXT:
               if (params->generic.value.o.gref.len == 0)
               {
                  /* NULL Object ref - as seen in "3.10.7 Scene 3, CGR Null ref" */
                  pgroupRef->len = 1;
                  pgroupRef->ptr.name = (MHEG5Byte *)dummy_str;
                  break;
               }
            case MHEG5OBJECTREF:
               *pgroupRef = params->generic.value.o.gref;
               *id = params->generic.value.o.id;
               break;

            default:
               TRACE(TERROR, ("Invalid direct reference %d", params->generic.type));
               pgroupRef->len = 0;
               pgroupRef->ptr.group = 0;
               *id = 0;
         }
      }
      next = params->next;
   }
   return next;
}

/*
     Resolve final real object from an indirect Objectreference
 */
MHEG5Root* MHEG5resolveRealObject( MHEG5Root *objref )
{
   MH5GroupRef gref;

   assert( objref );

   if (objref->clazz != MHEG5OBJECTREFVARIABLE)
   {
      TRACE(TERROR, ("Indirect reference is not ObjRefVariable"))
      return NULL;
   }

   if (((MHEG5ObjectRefVariable *)objref)->valueGrp.len == 0)
   {
      TRACE(TERROR, ("ObjRefVariable does not have target group"))
      return NULL;
   }

   gref.len = ((MHEG5ObjectRefVariable *)objref)->valueGrp.len;
   gref.ptr.name = ((MHEG5ObjectRefVariable *)objref)->valueGrp.data;

   return MHEG5findObject( gref, ((MHEG5ObjectRefVariable *)objref)->valueId );
}

/*
     Resolve Generic Objectreference - can be direct or indirect
 */
MHEG5GList* MHEG5resolveGenericORef(MHEG5GList *params, MHEG5Root **object)
{
   MHEG5GList *next = 0;

   assert(object);
   if (!params)
      return 0;
   next = MHEG5resolveORef(params, object);
   if (params->generic.indirect && *object != NULL)
   {
      *object = MHEG5resolveRealObject( *object );
   }
   return next;
}

/*
     Resolve Generic ContentReference - can be direct or indirect
 */
MHEG5GList* MHEG5resolveGenericCRef(MHEG5GList *params, MHEG5String *data,
   MHEG5Bool *referenced, MHEG5Bool *valid)
{
   MHEG5Root *object = 0;
   MHEG5GList *next = 0;

   assert(data);
   assert(referenced);

   if (!params)
      return 0;

   /* Default values */
   data->len = 0;
   data->data = 0;
   *valid = MHEG5FALSE;

   if (params->generic.indirect)
   {   /* Indirect Reference */
      next = MHEG5resolveORef(params, &object);
      if (object)
      {
         if (object->clazz == MHEG5CONTENTREFVARIABLE)
         {
            *data = ((MHEG5ContentVariable *) object)->contentData;
            *referenced = MHEG5TRUE;
            *valid = MHEG5TRUE;
         }
         else if (object->clazz == MHEG5OCTETSTRINGVARIABLE)
         {
            /* let's be forgiving and figure that the Mheg app writer wants the string */
            *data = ((MHEG5OctetStringVariable *) object)->value;
            *referenced = MHEG5FALSE;
            *valid = MHEG5TRUE;
         }
      }
   }
   else
   {
      switch (params->generic.type)
      {
         case MHEG5OCTETSTRING:
            *data = params->generic.value.s;
            *referenced = MHEG5FALSE;
            *valid = MHEG5TRUE;
            break;

         case MHEG5CONTENTREF:
            *data = params->generic.value.s;
            *referenced = MHEG5TRUE;
            *valid = MHEG5TRUE;
            break;

         default:
            /* can it get here ? */
            break;
      }
      next = params->next;
   }
   return next;
}

/*
     Resolve Generic GenericType - can be direct or indirect
 */
MHEG5GList* MHEG5resolveGenericGeneric(MHEG5GList *params, MHEG5Generic *value)
{
   MHEG5Root *object = 0;
   MHEG5GList *next = 0;
   MHEG5ObjectRefVariable *objref;

   assert(value);
   if (!params)
      return 0;

   /*
    * initialise isfirst - otherwise later checks using this field in the structure may be undefined
    */
   value->isfirst = MHEG5FALSE;
   value->indirect = MHEG5FALSE;
   if (params->generic.indirect)
   {   /* Indirect Reference */
      next = MHEG5resolveORef(params, &object);
      if (object)
      {
         switch (object->clazz)
         {
            case MHEG5BOOLEANVARIABLE:
               value->type = MHEG5BOOL;
               value->value.b = ((MHEG5BooleanVariable *) object)->value;
               return next;
            case MHEG5INTEGERVARIABLE:
               value->type = MHEG5INT;
               value->value.i = ((MHEG5IntegerVariable *) object)->value;
               return next;
            case MHEG5OCTETSTRINGVARIABLE:
               value->type = MHEG5OCTETSTRING;
               value->value.s = ((MHEG5OctetStringVariable *) object)->value;
               return next;
            case MHEG5CONTENTREFVARIABLE:
               value->type = MHEG5CONTENTREF;
               value->value.s = ((MHEG5ContentVariable *) object)->contentData;
               return next;
            case MHEG5OBJECTREFVARIABLE:
               value->type = MHEG5OBJECTREF;
               objref = (MHEG5ObjectRefVariable *) object;
               value->value.o.gref.len = objref->valueGrp.len;
               value->value.o.gref.ptr.name = objref->valueGrp.data;
               value->value.o.id = objref->valueId;
               return next;
            default:
               value->type = MHEG5NONE;
               return next;
         }
      }
      value->type = MHEG5NONE;
   }
   else
   {
      value->type = params->generic.type;
      switch (params->generic.type)
      {
         case MHEG5BOOL:
            value->value.b = params->generic.value.b;
            next = params->next;
            break;
         case MHEG5INT:
            value->value.i = params->generic.value.i;
            next = params->next;
            break;
         case MHEG5OCTETSTRING:
            value->value.s = params->generic.value.s;
            next = params->next;
            break;
         case MHEG5CONTENTREF:
            value->value.s = params->generic.value.s;
            next = params->next;
            break;
         case MHEG5OBJREFEXT:
            value->type = MHEG5OBJECTREF;
         case MHEG5OBJECTREF:
            /* direct object reference */
            next = MHEG5resolveGenericORefProper(params, &value->value.o.gref, &value->value.o.id);
            break;
         default:
            value->type = MHEG5NONE;
            next = params->next;
      }
   }
   return next;
}

/*
     Resolve Generic Boolean - can be direct or indirect
 */
MHEG5GList* MHEG5resolveGenericBoolean(MHEG5GList *params, MHEG5Bool *value)
{
   MHEG5GList *next = 0;
   MHEG5Generic g;

   assert(value);
   next = MHEG5resolveGenericGeneric(params, &g);
   if (g.type == MHEG5BOOL)
      *value = g.value.b;
   return next;
}

MHEG5GList* MHEG5resolveGenericOctetString(MHEG5GList *params,
   MHEG5String *value,
   MHEG5Bool *invalidString)
{
   MHEG5GList *next = 0;
   MHEG5Generic g;

   assert(value);
   assert(invalidString);

   /* Resolve the reference to a generic type */
   next = MHEG5resolveGenericGeneric(params, &g);

   if (g.type == MHEG5OCTETSTRING)
   {
      /* It's an octet string */
      *value = g.value.s;
      *invalidString = MHEG5FALSE;
   }
   else
   {
      /* It's not an octet string */
      value->len = 0;
      value->data = 0;
      *invalidString = MHEG5TRUE;
   }
   return next;
}

/*
     Resolve Generic Integer - can be direct or indirect
 */
MHEG5GList* MHEG5resolveGenericInteger(MHEG5GList *params, MHEG5Int *value)
{
   MHEG5GList *next = 0;
   MHEG5Generic g;

   assert(value);
   next = MHEG5resolveGenericGeneric(params, &g);
   if (g.type == MHEG5INT)
      *value = g.value.i;
   return next;
}