fpa1_set.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_rdf.h"
#include "vpa1_sys.h"
#include "vpa1_tgs.h"

#include "fpa1_rdf.h"
#include "fpa1_seq.h"
#include "fpa1_set.h"
#include "fpa1_rdf.h"
#include "fpa1_tgs.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---------------------------------------------*/
static int fpa1_setCheckTags( int, int * );

static int fpa1_setCheckTags( int tag, int *optArr )
{
   int count = 1;
   int arrLimit = optArr[0];

   while (count < arrLimit)
   {
      if (tag == optArr[ count ])
      {
         break;
      }

      /* tags every second element */
      count += 2;
   }

   return count;
} /* fpa1_setCheckTags() */

static fpa1_syntaxList* fpa1_setCheckConstraints( int *optArr, fpa1_syntaxList *itemPtr )
{
   int count = 1;
   int arrLimit = optArr[0];
   fpa1_syntaxList *tempPtr;

   while (count < arrLimit)
   {
      if (optArr[ count + 1 ] == SYN_NEEDED)
      {
         tempPtr = itemPtr;
         while (tempPtr != NULL)
         {
            if (tempPtr->tag == optArr[ count ])
            {
               /* found a match - carry on */
               break;
            }

            tempPtr = tempPtr->next;
         }

         if (tempPtr == NULL)
         {
#ifdef DEBUG_ASN

            /* "NEEDED" item missing - delete list */
            printf( "NEEDED tag = %d \n", optArr[ count ] );

            tempPtr = itemPtr;
            while (tempPtr != NULL)
            {
/*               printf( "\nFree %p tag %d posn %d\n",
                       tempPtr,
                       tempPtr->tag,
                       tempPtr->tagPosition ); */

               tempPtr = tempPtr->next;
            }

            printf( "SET removed \n" );

#endif

            fpa1_delList( itemPtr );
            itemPtr = NULL;
            break;
         }
      }

      /* tags every second element */
      count += 2;
   }

   return itemPtr;
} /* fpa1_setCheckConstraints() */

static fpa1_syntaxList* fpa1_setResetTypeTags( fpa1_syntaxList *itemPtr )
{
   fpa1_syntaxList *newPtr = NULL;

   fpa1_syntaxList *tempPtr = itemPtr;

   while (tempPtr != NULL)
   {
      if (tempPtr->tag > MHEG5_TYPE)
      {
         fpa1_rdfSetNewFilePosition( tempPtr->tagPosition );
         newPtr = fpa1_typeParse( tempPtr->tag, tempPtr->nextTagPosition );

         if (newPtr != NULL)
         {
            tempPtr->tag = newPtr->tag;
         }

         fpa1_delList( newPtr );
         newPtr = NULL;
      }

      tempPtr = tempPtr->next;
   }

   return itemPtr;
} /* fpa1_setResetTypeTags() */

fpa1_syntaxList* fpa1_setParse( int *setArrPtr, vpa1_filePos filePosLimit )
{
   int limit = setArrPtr[0];
   int count = 1;

   fpa1_syntaxList *itemPtr = NULL;
   fpa1_syntaxList *setTagPtr = NULL;

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

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

   /* got some items to check */
   while (tagListPtr != NULL)
   {
      /* is it a Context Specific tag */
      if (fpa1_setCheckTags( tagListPtr->tag, setArrPtr ) < limit)
      {
         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;
         }
      }
      else
      {
         /* try TYPES */
         count = 1;

         /* looking for a TYPE */
         fpa1_rdfSetNewFilePosition( tagListPtr->tagPosition );

         while (count < limit)
         {
            if (setArrPtr[count] > MHEG5_TYPE)
            {
               itemPtr = fpa1_typeParse( setArrPtr[count],
                     filePosLimit );
               if (itemPtr != NULL)
               {
                  /* store tag value - for checking later */
                  itemPtr->tag = setArrPtr[count];
               }
            }
            count += 2;
         }
      }

      /* add tag to list */
      if (itemPtr != NULL)
      {
         /* add to list of sequence tags */
         setTagPtr = fpa1_synAddItemToList( setTagPtr, itemPtr );
         itemPtr = NULL;
      }

      tagListPtr = fpa1_delFirstItem( tagListPtr );
   }

   /* check the constraints */
   if (setTagPtr != NULL)
   {
      setTagPtr = fpa1_setCheckConstraints( setArrPtr, setTagPtr );
   }

   if (setTagPtr != NULL)
   {
      setTagPtr = fpa1_setResetTypeTags( setTagPtr );
   }

   return setTagPtr;
} /* fpa1_setTxtParse() */