fpa1_seq.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 <stdlib.h>

#include "vpa1_sys.h"
#include "vpa1_tgs.h"
#include "vpa1_rdf.h"

#include "fpa1_act.h"
#include "fpa1_app.h"
#include "fpa1_cho.h"
#include "fpa1_grp.h"
#include "fpa1_int.h"
#include "fpa1_rdf.h"
#include "fpa1_seq.h"
#include "fpa1_set.h"
#include "fpa1_stm.h"
#include "fpa1_syn.h"
#include "fpa1_tgs.h"
#include "fpa1_tok.h"
#include "fpa1_typ.h"
#include "fpa1_BlockAlloc.h"

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

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


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

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

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

fpa1_syntaxList* fpa1_sequenceParse( unsigned short *itemCnt, int *compSeqArr, vpa1_filePos filePosLimit )
{
   int limit = compSeqArr[0];
   int count = 1;

   fpa1_syntaxList *itemPtr = NULL;
   fpa1_syntaxList *seqTagPtr = NULL;

   /* file position should be set up correctly */
   /* before calling fpa1_sequenceParse()      */

   /* get all tags from current file position to limit */
   fpa1_syntaxList *tagListPtr = fpa1_synGetAllTags( filePosLimit );

   while ((count < limit) && (tagListPtr != NULL))
   {
      if (tagListPtr->tag == compSeqArr[count])
      {
         itemPtr = fpa1_synCreateListItem( tagListPtr->tag,
               tagListPtr->tagPosition,
               tagListPtr->nextTagPosition );

         /* looking for a TAG */
         if (fpa1_tagsParse( itemPtr ) == FALSE)
         {
            /* a failure of some sort - delete item */
            fpa1_delList( itemPtr );
            itemPtr = NULL;
         }
         tagListPtr = fpa1_delFirstItem( tagListPtr );
      }
      else if (compSeqArr[count] > MHEG5_TYPE)
      {
         /* looking for a TYPE */
         fpa1_rdfSetNewFilePosition( tagListPtr->tagPosition );

         itemPtr = fpa1_typeParse( compSeqArr[count],
               filePosLimit );

         tagListPtr = fpa1_delFirstItem( tagListPtr );
      }

      if (itemPtr != NULL)
      {
         /* add to list of sequence tags */
         (*itemCnt)++;
         itemCnt[1] += itemPtr->childCount[0];
         itemCnt[2] += itemPtr->childCount[1];
         seqTagPtr = fpa1_synAddItemToList( seqTagPtr, itemPtr );
         itemPtr = NULL;
      }
      else if ((compSeqArr[count + 1] != SYN_OPTIONAL) &&
               (compSeqArr[count + 1] != SYN_DEFAULT))
      {
         /* found a tag which should not be there - stop */

         /* free lists */
         fpa1_delList( seqTagPtr  );
         seqTagPtr = NULL;
         break;
      }

      count += 2;
   }

   /* free remaining list */
   fpa1_delList( tagListPtr );

   return seqTagPtr;
} /* fpa1_sequenceParse() */

fpa1_syntaxList* fpa1_sequenceOfParse( unsigned short *itemCnt, int whichType, vpa1_filePos filePosLimit  )
{
   fpa1_syntaxList *seqOfItem = NULL;
   fpa1_syntaxList *returnItem = NULL;

   /* file position should be set up correctly */
   /* before calling fpa1_sequenceOfParse()    */
   do
   {
      seqOfItem = NULL;
      switch (whichType)
      {
         case SEQ_OF_DEF_ATTRIBS:
            seqOfItem = fpa1_choiceParse( defAttChoiceCompArr );
            break;
         case SEQ_OF_GROUP_ITEM:
            seqOfItem = fpa1_choiceParse( grpItmChoiceCompArr );
            break;
         case SEQ_OF_MOVEMENT:
            seqOfItem = fpa1_typeParse( SEQ_SIZE_OF_INTEGER, filePosLimit );
            break;
         case SEQ_OF_INTEGER:
            seqOfItem = fpa1_setParse( intSetCompsArr, filePosLimit );
            break;
         case SEQ_OF_ELEMENTARY_ACTION:
            seqOfItem = fpa1_choiceParse( elemActChoiceCompArr );
            break;
         case SEQ_OF_ACTION_SLOT:
            seqOfItem = fpa1_typeParse( ACTION_SLOT_TYPE, filePosLimit );
            break;
         case SEQ_OF_TOKEN_GROUP_ITEM:
            seqOfItem = fpa1_typeParse( TOKEN_GROUP_ITEM_TYPE, filePosLimit );
            break;
         case SEQ_OF_PARAMETER:
            seqOfItem = fpa1_typeParse( PARAMETER_TYPE, filePosLimit );
            break;
         case SEQ_OF_POINT:
            seqOfItem = fpa1_typeParse( POINT_TYPE, filePosLimit );
            break;
         case SEQ_OF_OBJECT_REFERENCE:
            seqOfItem = fpa1_typeParse( OBJECT_REFERENCE_TYPE, filePosLimit );
            break;
         case SEQ_OF_NEXT_SCENE:
            seqOfItem = fpa1_typeParse( NEXT_SCENE_TYPE, filePosLimit );
            break;
         case SEQ_OF_STREAM_COMP:
            seqOfItem = fpa1_choiceParse( stmCmpChoiceCompArr );
            break;
         case SEQ_OF_XY_POSITION:
            seqOfItem = fpa1_typeParse( XY_POSITION_TYPE, filePosLimit );
            break;
         default:
            break;
      }

      if (seqOfItem != NULL)
      {
         /* add to list */
         (*itemCnt)++;
         itemCnt[1] += seqOfItem->childCount[0];
         itemCnt[2] += seqOfItem->childCount[1];
         returnItem = fpa1_synAddItemToList( returnItem, seqOfItem );

         /* set up next position */
         while (seqOfItem->next != NULL)
            seqOfItem = seqOfItem->next;

         if (seqOfItem->nextTagPosition < filePosLimit)
         {
            fpa1_rdfSetNewFilePosition( seqOfItem->nextTagPosition );
         }
         else
         {
            break;
         }
      }
      else if (whichType == SEQ_OF_ELEMENTARY_ACTION ||
               whichType == SEQ_OF_GROUP_ITEM)
      {
         /* unknown tag - skip and forget */
         vpa1_filePos nextTagPosn = fpa1_rdfGetNextTagPosn();
         if (nextTagPosn < filePosLimit)
         {
            fpa1_rdfSetNewFilePosition( nextTagPosn );
            seqOfItem = (fpa1_syntaxList *)0xdeadbeef;
         }
         else
         {
            break;
         }
      }
   }
   while (seqOfItem != NULL);

   return returnItem;
} /* fpa1_sequenceOfParse() */