asn1_createLink.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 "mh5link.h"
#include "asn1_createAction.h"
#include "asn1_createExtras.h"
#include "asn1_createIngredient.h"
#include "asn1_createGroup.h"
#include "asn1_createLink.h"

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


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

/*---local (static) variable declarations for this file----------------------*/
/*
     Events - IMPORTANT: Do not modify the Sequence - it is very important
     for the ASN1LinkDecoder that the eventTypes Array is NOT modified!!!
 */
#define EVENTTYPESSIZE 35
static MHEG5EventType eventTypes[EVENTTYPESSIZE] = {
   MHEG5NONEEVENT, MHEG5ISAVAILABLE, MHEG5CONTENTAVAILABLE, MHEG5ISDELETED, MHEG5ISRUNNING,
   MHEG5ISSTOPPED, MHEG5USERINPUT, MHEG5ANCHORFIRED, MHEG5TIMERFIRED, MHEG5ASYNCHSTOPPED,
   MHEG5INTERACTIONCOMPLETED, MHEG5TOKENMOVEDFROM, MHEG5TOKENMOVEDTO, MHEG5STREAMEVENT,
   MHEG5STREAMPLAYING, MHEG5STREAMSTOPPED, MHEG5COUNTERTRIGGER, MHEG5HIGHLIGHTON,
   MHEG5HIGHLIGHTOFF, MHEG5CURSORENTER, MHEG5CURSORLEAVE, MHEG5ISSELECTED, MHEG5ISDESELECTED,
   MHEG5TESTEVENT, MHEG5FIRSTITEMPRESENTED, MHEG5LASTITEMPRESENTED, MHEG5HEADITEMS,
   MHEG5TAILITEMS, MHEG5ITEMSELECTED, MHEG5ITEMDESELECTED, MHEG5ENTRYFIELDFULL,
   MHEG5ENGINEEVENT, MHEG5FOCUSMOVED, MHEG5SLIDERVALUECHANGED,
   MHEG5LASTEVENT
};

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

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

MHEG5EventType asn1_decodeEventType( MHEG5Int evt_val )
{
   /* if the event value is invalid, default it to MHEG5LASTEVENT */
   if ((evt_val <= 0) || (evt_val >= EVENTTYPESSIZE))
   {
      evt_val = EVENTTYPESSIZE - 1;
   }
   return eventTypes[evt_val];
}

static asnErr asn1_decodeLinkCondition(fpa1_syntaxList *listPtr, MHEG5Link *link)
{
   asnErr errVal = 0;
   fpa1_syntaxList *currItem;

   DPL5((">> asn1_decodeLinkCondition(%X,%X)\n", listPtr, link));
   assert(link);
   assert(listPtr);

   currItem = listPtr->children;

   while (currItem != NULL)
   {
      switch (currItem->tag)
      {
         case EVENT_SOURCE_TYPE: /* Object Reference */
            /* Either an Integer stored in the EVENT_SOURCE_TYPE itself
               or an OctetString + Integer pair */
            if (currItem->dataType == 2)  /* Integer - Internal ref */
            {
               link->source = currItem->data.intData;
               link->sourcegid.ptr.group = asn1_mainGroupPtr;
            }
            else /* External Ref */
            {
               if (currItem->children != NULL)
               {
                  MHEG5String name;
                  errVal |= asn1_decodeOctetString(currItem->children, &name);
                  link->sourcegid.len = name.len;
                  link->sourcegid.ptr.name = name.data;
                  if (currItem->children->next != NULL)
                     link->source = currItem->children->next->data.intData;
                  else
                     errVal |= 0x01;
               }
               else
               {
                  errVal |= 0x01;
               }
            }
            break;
         case EVENT_TYPE: /* Enumeration */
            link->eventType = asn1_decodeEventType( currItem->data.intData );
            existsLinkCount[link->eventType]++;
            break;
         case EVENT_DATA_TYPE: /* choice */
            switch (currItem->dataType)
            {
               case 1: /* boolean */
                  link->eventData.value.b = (currItem->data.boolData == 0) ? MHEG5FALSE : MHEG5TRUE;
                  link->eventData.indirect = MHEG5FALSE;
                  link->eventData.type = (U16BIT)MHEG5BOOL;
                  break;
               case 2: /* Integer */
                  link->eventData.value.i = currItem->data.intData;
                  link->eventData.indirect = MHEG5FALSE;
                  link->eventData.type = (U16BIT)MHEG5INT;
                  break;
               case 4: /* OctetString */
                  link->eventData.value.i = LNK_RegisterString( currItem->data.stringData );
                  currItem->data.stringData.len = 0;
                  currItem->data.stringData.data = NULL;
                  link->eventData.indirect = MHEG5TRUE;
                  link->eventData.type = (U16BIT)MHEG5INT;
                  break;
               default:
                  DPL2(("WARNING:[ASN.1] Unexpected tag in LinkCondition\n"));
                  errVal |= 0x01;
                  break;
            }
            break;
         default:
            break;
      }
      currItem = currItem->next;
   }

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

   DPL5(("<< asn1_decodeLinkCondition() Returns %d\n", errVal));
   return errVal;
}

MHEG5Ingredient* asn1_createLink( fpa1_syntaxList *listPtr )
{
   MHEG5Link *link;
   asnErr errVal = 0;
   fpa1_syntaxList *currItem;
   fpa1_syntaxList *child;

   DPL5((">> asn1_createLink(%X,%X)\n", listPtr, link));

   assert(listPtr);

   link = (MHEG5Link *)MHEG5getMem( sizeof(MHEG5Link));
   if (link)
   {
      memset(link, 0, sizeof(MHEG5Link));
      link->ingredient.root.clazz = MHEG5LINK;
      /* default link condition *
         link->source = 0;
         link->sourcegid.len = 0;
         link->sourcegid.ptr.group = 0;
         link->eventData.type = MHEG5NONE;
       */
      link->eventData.indirect = MHEG5FALSE;

      /* searches current set of tags for local tags */
      currItem = listPtr->children;
      while (currItem != NULL)
      {
         /* most objects will have more than one local tag */
         switch (currItem->tag)
         {
            case LINKCOND:
               errVal |= asn1_decodeLinkCondition(currItem, link);
               break;
            case EFFECT:
               asn1_decodeActions( currItem, &link->linkEffect );
               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
               {
                  link->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
               {
                  link->ingredient.root.id = currItem->data.intData;
               }
               break;
            case INITACTIVE:
               if (currItem->data.boolData == 0)
               {
                  link->ingredient.initiallyStopped = MHEG5TRUE;
               }
               break;
            case SHARED:
               if (currItem->data.boolData != 0)
               {
                  link->ingredient.shared = MHEG5TRUE;
               }
               break;

            default:
               break;
         }
         currItem = currItem->next;
      }
      /* decode inherited tags */
      if (errVal != ASN_NO_ERROR)
      {
         #if (DPLEVEL >= 2)
         DPL2(("WARNING:[ASN.1] asn1_createLink() Fails\n"));
         #endif /* DPLEVEL >= 2 */
         MHEG5freeMem(link);
         link = NULL;
      }
   }

   DPL5(("<< asn1_createLink() Returns %d\n", link));

   return (MHEG5Ingredient *)link;
}