asn1_createTokenGroup.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 <stdio.h>
#include "vpa1_sys.h"
#include "vpa1_tgs.h"
#include "fpa1_syn.h"
#include "asn1_sys.h"

#include "mh5base.h"
#include "mh5tokengroup.h"
#include "asn1_createAction.h"
#include "asn1_createExtras.h"
#include "asn1_createIngredient.h"
#include "asn1_createTokenManager.h"
#include "asn1_createGroup.h"
#include "asn1_createTokenGroup.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---------------------------------------------*/

static MHEG5ActionList* decodeActionSlot(fpa1_syntaxList *currItem,
   MHEG5TokenSlot *token_ptr, MHEG5ActionList *actions_ptr )
{
   U32BIT actions_cnt = 0;
   assert(token_ptr);

   token_ptr->actions_ptr = actions_ptr;

   while (currItem != NULL)
   {
      if (currItem->tag == SEQ_SIZE_OF_ELEMENTARY_ACTION)
      {
         /* fill the actionSlot with the action */
         asn1_decodeActions( currItem, actions_ptr );
      }
      /* else a NULL action, therefore actionSlot remains empty */
      actions_ptr++;
      actions_cnt++;
      currItem = currItem->next;
   }
   token_ptr->actions_num = actions_cnt;

   return actions_ptr;
}

static asnErr decodeTokenSlotRef(fpa1_syntaxList *tmpItem, MHEG5TokenSlot *token_ptr)
{
   asnErr errVal = 0;
   assert( tmpItem != NULL );
   /* object reference */
   if (tmpItem->tag == EXTERNAL_REFERENCE_TYPE)
   {
      tmpItem = tmpItem->children;
      if (tmpItem == NULL)
      {
         errVal |= 1;
      }
      else
      {
         if (tmpItem->data.stringData.len == 0)
         {
            /* this would be an Mheg authoring cock-up, so assume ptr to group */
            token_ptr->groupid.len = 0;
            token_ptr->groupid.ptr.group = asn1_mainGroupPtr;
         }
         else
         {
            token_ptr->groupid.len = tmpItem->data.stringData.len;
            token_ptr->groupid.ptr.name = tmpItem->data.stringData.data;
         }

         /* remove the original reference to the string */
         tmpItem->data.stringData.len = 0;
         tmpItem->data.stringData.data = NULL;

         tmpItem = tmpItem->next;
         if (tmpItem == NULL)
         {
            errVal |= 1;
         }
         else
         {
            token_ptr->id = tmpItem->data.intData;
         }
      }
   }
   else /* internal reference */
   {
      token_ptr->id = tmpItem->data.intData;
      /* use the scene/app GID */
      token_ptr->groupid.len = 0;
      token_ptr->groupid.ptr.group = asn1_mainGroupPtr;
   }
   return errVal;
}

asnErr asn1_decodeTokenGroup(fpa1_syntaxList *listPtr, MHEG5TokenGroup *tokenGrp)
{
   MHEG5ActionList *actions_ptr;
   MHEG5TokenSlot *token_ptr;
   asnErr errVal = 0;
   fpa1_syntaxList *currItem = listPtr->children;
   fpa1_syntaxList *child, *gchild;

   DPL5((">> asn1_decodeTokenGroup(%X,%X)\n", listPtr, tokenGrp));

   assert(tokenGrp);
   assert(listPtr);

   token_ptr = tokenGrp->tokens_ptr;
   actions_ptr = (MHEG5ActionList *)(token_ptr + tokenGrp->tokens_num);

   token_ptr++;   /* zero token position for the "No Token" actions */

   currItem = listPtr->children;

   /* searches current set of tags for local tags */
   while (currItem != NULL)
   {
      /* most objects will have more than one local tag */
      switch (currItem->tag)
      {
         case TGITEMS:
            child = currItem->children;
            while (child != NULL)
            {
               if (child->tag == TOKEN_GROUP_ITEM_TYPE)
               {
                  gchild = child->children;
                  if (gchild != NULL)
                  {
                     errVal |= decodeTokenSlotRef(gchild, token_ptr);
                     gchild = gchild->next;
                     if (gchild != NULL)
                     {
                        actions_ptr = decodeActionSlot(gchild->children, token_ptr, actions_ptr);
                     }
                  }
                  token_ptr++;
               }
               child = child->next;
            }
            break;
         case NOTOKEN:
            actions_ptr = decodeActionSlot(currItem->children, tokenGrp->tokens_ptr, actions_ptr);
            break;

         /**** decode inherited tags from TokenManager *****/
         case MOVEMENTTABLE:
            child = currItem->children;
            while (child != NULL)
            {
               if (child->tag == SEQ_SIZE_OF_INTEGER)
               {
                  MHEG5tokenManagerAddRow( &tokenGrp->tokenManager );
                  gchild = child->children;
                  while (gchild != NULL)
                  {
                     if (gchild->tag == INTEGER)
                     {
                        MHEG5tokenManagerAddNumber( &tokenGrp->tokenManager, gchild->data.intData );
                     }
                     else
                     {
                        DPL2(("WARNING:[ASN.1] Unexpected tag in movementTable\n"));
                        errVal |= 0x01;
                     }
                     gchild = gchild->next;
                  }
               }
               child = child->next;
            }
            break;

         /**** decode inherited tags from Ingredient *****/
         case EXTERNAL_REFERENCE_TYPE:
            /* skip the Group ref 'child', as this must always reference current group */
            assert( currItem->children );
            child = currItem->children->next;
            if (child == NULL ||
                child->data.intData < 1)
            {
               /* illegal to have zero or negative object numbers for an ingredient */
               errVal |= 0x01;
            }
            else
            {
               tokenGrp->ingredient.root.id = child->data.intData;
            }
            break;
         case INTEGER: /* internal reference */
            if (currItem->data.intData < 1)
            {
               /* illegal to have zero or negative object numbers for an ingredient */
               errVal |= 0x01;
            }
            else
            {
               tokenGrp->ingredient.root.id = currItem->data.intData;
            }
            break;
         case INITACTIVE:
            if (currItem->data.boolData == 0)
            {
               tokenGrp->ingredient.initiallyStopped = MHEG5TRUE;
            }
            break;
         case CHOOK:
            tokenGrp->ingredient.contentHook = currItem->data.intData;
            break;
         case SHARED:
            if (currItem->data.boolData != 0)
            {
               tokenGrp->ingredient.shared = MHEG5TRUE;
            }
            break;

         default:
            break;
      }
      currItem = currItem->next;
   }

#if (DPLEVEL >= 2)
   if (errVal != 0)
   {
      DPL2(("WARNING:[ASN.1] asn1_decodeTokenGroup() returns errVal = %d\n", errVal));
   }
#endif /* DPLEVEL >= 2 */

   DPL5(("<< asn1_decodeTokenGroup() Returns %d\n", errVal));

   return errVal;
}

U32BIT asn1_getTokenGroupItemCount( fpa1_syntaxList *currItem )
{
   U32BIT itm_cnt = 1, ast_cnt = 0;

   /* searches current set of tags for local tags */
   while (currItem != NULL)
   {
      /* most objects will have more than one local tag */
      switch (currItem->tag)
      {
         case TGITEMS:
            itm_cnt += currItem->childCount[0];
            ast_cnt += currItem->childCount[2];
            break;
         case NOTOKEN:
            ast_cnt += currItem->childCount[0];
            break;
         default:
            break;
      }
      currItem = currItem->next;
   }
   return itm_cnt << 16 | ast_cnt;
}

MHEG5Ingredient* asn1_createTokenGroup( fpa1_syntaxList *listPtr )
{
   MHEG5TokenGroup *tokenGrp;
   U32BIT itm_cnt, ast_cnt, size;

   assert( listPtr );

   itm_cnt = asn1_getTokenGroupItemCount( listPtr->children );
   ast_cnt = itm_cnt & 0xffff;
   itm_cnt >>= 16;

   size = sizeof(MHEG5TokenGroup) +
      (itm_cnt * sizeof(MHEG5TokenSlot)) +
      (ast_cnt * sizeof(MHEG5ActionList));

   tokenGrp = (MHEG5TokenGroup *)MHEG5getMem( size );
   if (tokenGrp != NULL)
   {
      memset(tokenGrp, 0, size);
      tokenGrp->ingredient.root.clazz = MHEG5TOKENGROUP;
      tokenGrp->tokens_num = itm_cnt;
      tokenGrp->tokens_ptr = (MHEG5TokenSlot *)(tokenGrp + 1);

      if (asn1_decodeTokenGroup(listPtr, tokenGrp) != ASN_NO_ERROR)
      {
         MHEG5freeMem( tokenGrp );
         tokenGrp = NULL;
      }
   }
   return (MHEG5Ingredient *)tokenGrp;
}