asn1_createVariable.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 "mh5group.h"
#include "mh5variable.h"
#include "asn1_createExtras.h"
#include "asn1_createIngredient.h"
#include "asn1_createGroup.h"
#include "asn1_createVariable.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---------------------------------------------*/

asnErr asn1_decodeObjRefVariable( fpa1_syntaxList *ItemPtr, MHEG5ObjectRefVariable *objRefVar )
{
   asnErr errVal = 0;
   if (ItemPtr != NULL)
   {
      if ((ItemPtr->tag == EXTERNAL_REFERENCE_TYPE) && (ItemPtr->children != NULL))
      {
         ItemPtr = ItemPtr->children;
         if (ItemPtr->data.stringData.len == 0)
         {
            /* this should not happen, but assume ptr to group */
            objRefVar->originalValueGid.len = 0;
            objRefVar->originalValueGid.ptr.group = asn1_mainGroupPtr;
         }
         else
         {
            objRefVar->originalValueGid.len = ItemPtr->data.stringData.len;
            objRefVar->originalValueGid.ptr.name = ItemPtr->data.stringData.data;

            ItemPtr->data.stringData.len = 0;
         }

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

         ItemPtr = ItemPtr->next;
      }
      /* GID defaults to current scene or application */
      else
      {
         objRefVar->originalValueGid.len = 0;
         objRefVar->originalValueGid.ptr.group = asn1_mainGroupPtr;
      }
      if (ItemPtr != NULL)
      {
         objRefVar->originalValueId = ItemPtr->data.intData;
      }
      else
      {
         errVal |= 0x01;
      }
   }
   else
   {
      errVal |= 0x01;
   }
   return errVal;
}

asnErr asn1_decodeVariable( fpa1_syntaxList *listPtr, MHEG5Ingredient *var )
{
   asnErr errVal = 0;
   fpa1_syntaxList *child;

   assert(listPtr);
   assert(var);

   /* searches current set of tags for local tags */
   listPtr = listPtr->children;
   while (listPtr != NULL)
   {
      switch (listPtr->tag)
      {
         case OVALUE:
            child = listPtr->children;
            if (child != NULL)
            {
               switch (var->root.clazz)
               {
                  case MHEG5BOOLEANVARIABLE:
                     if (child->data.boolData)
                        ((MHEG5BooleanVariable *)var)->originalValue = MHEG5TRUE;
                     break;

                  case MHEG5INTEGERVARIABLE:
                     ((MHEG5IntegerVariable *)var)->originalValue = child->data.intData;
                     break;

                  case MHEG5OCTETSTRINGVARIABLE:
                     ((MHEG5OctetStringVariable *)var)->originalValue = child->data.stringData;
                     /* remove the original reference to the string */
                     child->data.stringData.len = 0;
                     child->data.stringData.data = NULL;
                     break;

                  case MHEG5CONTENTREFVARIABLE:
                     if (child->tag == CONTREF)
                     {
                        ((MHEG5ContentVariable *)var)->originalContentData = child->data.stringData;
                        /* remove the original reference to the string */
                        child->data.stringData.len = 0;
                        child->data.stringData.data = NULL;
                     }
                     break;

                  case MHEG5OBJECTREFVARIABLE:
                     if (child->tag == OBJREF)
                     {
                        errVal |= asn1_decodeObjRefVariable( child->children, (MHEG5ObjectRefVariable *)var );
                     }
                     break;
                  default:;
               }
            }
            break;

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

MHEG5Ingredient* asn1_createBooleanVariable( fpa1_syntaxList *listPtr )
{
   MHEG5BooleanVariable *boolVariable;

   boolVariable = (MHEG5BooleanVariable *) MHEG5getMem( sizeof(MHEG5BooleanVariable));
   if (boolVariable)
   {
      memset(boolVariable, 0, sizeof(MHEG5BooleanVariable));
      boolVariable->ingredient.root.clazz = MHEG5BOOLEANVARIABLE;

      if (asn1_decodeVariable( listPtr, &boolVariable->ingredient ) != ASN_NO_ERROR)
      {
         #if (DPLEVEL >= 2)
         DPL2(("WARNING:[ASN.1] asn1_createIntegerVariable() fails\n"));
         #endif /* DPLEVEL >= 2 */
         MHEG5freeMem( boolVariable );
         boolVariable = NULL;
      }
   }

   return (MHEG5Ingredient *)boolVariable;
}

MHEG5Ingredient* asn1_createIntegerVariable( fpa1_syntaxList *listPtr )
{
   MHEG5IntegerVariable *integerVariable;

   integerVariable = (MHEG5IntegerVariable *) MHEG5getMem( sizeof(MHEG5IntegerVariable));
   if (integerVariable)
   {
      /* defaults */
      memset(integerVariable, 0, sizeof(MHEG5IntegerVariable));
      integerVariable->ingredient.root.clazz = MHEG5INTEGERVARIABLE;

      if (asn1_decodeVariable(listPtr, &integerVariable->ingredient) != ASN_NO_ERROR)
      {
         #if (DPLEVEL >= 2)
         DPL2(("WARNING:[ASN.1] asn1_createIntegerVariable() fails\n"));
         #endif /* DPLEVEL >= 2 */
         MHEG5freeMem( integerVariable );
         integerVariable = NULL;
      }
   }
   return (MHEG5Ingredient *)integerVariable;
}

MHEG5Ingredient* asn1_createOctetStringVariable( fpa1_syntaxList *listPtr )
{
   MHEG5OctetStringVariable *octStrVar;

   octStrVar = (MHEG5OctetStringVariable *) MHEG5getMem( sizeof(MHEG5OctetStringVariable));
   if (octStrVar)
   {
      /* defaults */
      memset(octStrVar, 0, sizeof(MHEG5OctetStringVariable));
      octStrVar->ingredient.root.clazz = MHEG5OCTETSTRINGVARIABLE;

      if (asn1_decodeVariable(listPtr, &octStrVar->ingredient) != ASN_NO_ERROR)
      {
         #if (DPLEVEL >= 2)
         DPL2(("WARNING:[ASN.1] asn1_createOctetStringVariable() Fails\n"));
         #endif /* DPLEVEL >= 2 */
         MHEG5freeMem( octStrVar );
         octStrVar = NULL;
      }
   }

   return (MHEG5Ingredient *)octStrVar;
}

MHEG5Ingredient* asn1_createObjectRefVariable( fpa1_syntaxList *listPtr )
{
   MHEG5ObjectRefVariable *objRefVar;

   objRefVar = (MHEG5ObjectRefVariable *) MHEG5getMem( sizeof(MHEG5ObjectRefVariable));
   if (objRefVar)
   {
      /* defaults */
      memset(objRefVar, 0, sizeof(MHEG5ObjectRefVariable));
      objRefVar->ingredient.root.clazz = MHEG5OBJECTREFVARIABLE;

      if (asn1_decodeVariable(listPtr, &objRefVar->ingredient) != ASN_NO_ERROR)
      {
         #if (DPLEVEL >= 2)
         DPL2(("WARNING:[ASN.1] asn1_createObjectRefVariable() Fails\n"));
         #endif /* DPLEVEL >= 2 */
         MHEG5freeMem( objRefVar );
         objRefVar = NULL;
      }
   }

   DPL5(("<< asn1_createObjectRefVariable() %X\n", objRefVar));

   return (MHEG5Ingredient *)objRefVar;
}

MHEG5Ingredient* asn1_createContentVariable( fpa1_syntaxList *listPtr )
{
   MHEG5ContentVariable *contentVar;

   contentVar = (MHEG5ContentVariable *) MHEG5getMem( sizeof(MHEG5ContentVariable));
   if (contentVar)
   {
      /* defaults */
      memset(contentVar, 0, sizeof(MHEG5ContentVariable));
      contentVar->ingredient.root.clazz = MHEG5CONTENTREFVARIABLE;

      if (asn1_decodeVariable( listPtr, &contentVar->ingredient ) != ASN_NO_ERROR)
      {
         #if (DPLEVEL >= 2)
         DPL2(("WARNING:[ASN.1] asn1_createContentVariable() Fails\n"));
         #endif /* DPLEVEL >= 2 */
         MHEG5freeMem(contentVar);
         contentVar = NULL;
      }
   }

   return (MHEG5Ingredient *)contentVar;
}