fpa1_rdf.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_cho.h"
#include "fpa1_rdf.h"
#include "fpa1_syn.h"

#include "pa1_mem.h"

#include "fpa1_BlockAlloc.h"
#include "glue_debug.h"

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

/*---constant definitions for this file--------------------------------------*/
/* shifts */
#define CLASS_SHIFT            6
#define TAG_BASE_SHIFT         7
#define LONG_LENGTH_BASE_SHIFT 8

/* masks */
#define SMALL_TAG_MASK        0x1F
#define LARGE_TAG_MASK        0x7F
#define LAST_TAG_OCTET_MASK   0x80
#define LONG_LENGTH_TEST_MASK 0x80
#define LONG_LENGTH_MASK      0x7F

#define INT_OBJ_CHOICE_COMPS 2

unsigned char *fpa1_outputBufferStart = NULL;
unsigned long fpa1_outputBufferOffset = 0;
unsigned char *fpa1_currentBufferStart = NULL;
unsigned long fpa1_currentBufferLength = 0;
unsigned long fpa1_currentBufferOffset = 0;

int fpa1_GenericDataCount = 0;
int fpa1_GroupActionCount = 0;
int fpa1_GroupParamCount = 0;

/*---local (static) variable declarations for this file----------------------*/
static int readingTagNotLength = TRUE;
static int intObjChoiceCompArr[ INT_OBJ_CHOICE_COMPS + 1 ] =
{ INT_OBJ_CHOICE_COMPS + 1,
  APPLICATION,
  SCENE };



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

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

#ifdef DEBUG_ASN

static void fpa1_rdfTestList( fpa1_syntaxList * );

static void fpa1_rdfTestList( fpa1_syntaxList *listPtr )
{
   fpa1_syntaxList *start1Ptr;
   fpa1_syntaxList *unknownPtr = NULL;

   while (listPtr != NULL)
   {
      if (listPtr->children != NULL)
      {
         /* move to contents */
         fpa1_rdfSetNewFilePosition( listPtr->tagPosition );
         fpa1_rdfMoveToContents();

         /* get any unknowns */
         unknownPtr = fpa1_synGetUnknowns( fpa1_rdfGetCurrentFilePosition(),
               listPtr->nextTagPosition,
               listPtr->children );
      }

      if (unknownPtr != NULL)
      {
         printf( "ERROR: tag %d has unrecognized items\n", listPtr->tag );

         start1Ptr = unknownPtr;

         while (unknownPtr != NULL)
         {
            printf( "      unkTag %d posn %d\n",
               unknownPtr->tag,
               unknownPtr->tagPosition );

            unknownPtr = unknownPtr->next;
         }

         fpa1_delList( start1Ptr );
      }

      fpa1_rdfTestList( listPtr->children );

      listPtr = listPtr->next;
   }
} /* fpa1_rdfTestList() */

#endif



int fpa1_rdfGetTag( void )
{
   int tag, vpa1_filePosTag, tagClass;

   int done = FALSE;

   /* Get next byte */
   tag = fpa1_rdfGetNextByte();

   if (tag != -1)
   {
#ifdef DEBUG_ASN

      if (readingTagNotLength == FALSE)
      {
         printf( "ERROR: reading tag when should be reading length.\n" );
      }

#endif

      /* ID octet bits 8,7 = class */
      tagClass = tag >> CLASS_SHIFT;
      tag &= SMALL_TAG_MASK;

      if (tag == SMALL_TAG_MASK)
      {
         /* tag spread over a number of octets */
         tag = 0;

         while (!done)
         {
            vpa1_filePosTag = fpa1_rdfGetNextByte();

            /* multiply by tag base and add the current byte value */
            tag = (tag << TAG_BASE_SHIFT) | (vpa1_filePosTag & LARGE_TAG_MASK);

            /* test to see if last octet */
            if ((vpa1_filePosTag & LAST_TAG_OCTET_MASK) == 0)
            {
               done = TRUE;
            }
            else
            {
               done = FALSE;
            }
         }
      }

      /* Context Specific tags have 2000 added */
      tag += tagClass * 1000;

      /* next "read" will read content length */
      readingTagNotLength = FALSE;
   }

   return tag;
} /* fpa1_rdfGetTag() */

vpa1_filePos fpa1_rdfGetContentLength( void )
{
   vpa1_filePos lengthCount;
   vpa1_filePos length;

   /* Get next byte */
   length = fpa1_rdfGetNextByte();

   if (length != -1)
   {
#ifdef DEBUG_ASN

      if (readingTagNotLength == TRUE)
      {
         printf( "ERROR: reading length when should be reading tag.\n" );
      }

#endif

      /* test for "vpa1_filePos" length */
      if ((length & LONG_LENGTH_TEST_MASK) != 0)
      {
         /* vpa1_filePos form if bit 8 is '1' */

         /* first byte contains the number of octets comprising the length */
         lengthCount = length & LONG_LENGTH_MASK;

         /* reset length */
         length = 0;

         while (lengthCount > 0)
         {
            /* multiply by 128 and add next byte */
            length = (length << LONG_LENGTH_BASE_SHIFT) + fpa1_rdfGetNextByte();
            lengthCount--;
         }
      }

      /* next "read" will read a tag or content */
      readingTagNotLength = TRUE;
   }

   return length;
} /* fpa1_rdfGetContentLength() */

vpa1_filePos fpa1_rdfGetCurrentFilePosition( void )
{
   return fpa1_currentBufferOffset;
} /* fpa1_rdfGetCurrentFilePosition() */

int fpa1_rdfGetNextByte( void )
{
   /* if it returns -1 is the position still incremented? (No!) */
   if (fpa1_currentBufferOffset < fpa1_currentBufferLength)
   {
      return fpa1_currentBufferStart[fpa1_currentBufferOffset++];
   }

   return EOF;
} /* fpa1_rdfGetNextByte() */

int fpa1_rdfGetInteger( vpa1_filePos intLength )
{
   int content;

   int intValue;

   content = fpa1_rdfGetNextByte();

   /* !!! not sure about the following - copied directly from ASNDecoder.cpp */
   intValue = ((content > 127) ? (~0xFF | content) : content);
   intLength--;

   while (intLength-- > 0)
   {
      intValue = (intValue << 8) | fpa1_rdfGetNextByte();
   }

   return intValue;
} /* fpa1_rdfGetInteger() */

/* void fpa1_rdfGetOctetString( char* strPtr, vpa1_filePos strLength )
   {
   while ( strLength > 0 )
   {
 * strPtr = fpa1_rdfGetNextByte();
      strPtr++;
      strLength--;
   }

 * strPtr = '\0';

   } */ /* fpa1_rdfGetOctetString() */

void fpa1_rdfMoveToContents( void )
{
   if (readingTagNotLength == TRUE)
   {
      /* move to reading length */
      fpa1_rdfGetTag();
   }

   fpa1_rdfGetContentLength();

   return;
} /* fpa1_rdfMoveToContents() */

vpa1_filePos fpa1_rdfGetNextTagPosn( void )
{
   /* No error checking !!!! */

   vpa1_filePos length;
   vpa1_filePos nextTagPosn = -1;
   vpa1_filePos curPosn = fpa1_rdfGetCurrentFilePosition();
   int oldReadTag = readingTagNotLength;

   if (readingTagNotLength == TRUE)
   {
      /* move to reading length */
      fpa1_rdfGetTag();
   }

   /* get contents length */
   length = fpa1_rdfGetContentLength();

   if (length != -1)
   {
      /* Set new position */
      fpa1_currentBufferOffset += length;

      /* store new position */
      nextTagPosn = fpa1_rdfGetCurrentFilePosition();
   }

   /* reset original position and settings */
   fpa1_rdfSetNewFilePosition( curPosn );
   readingTagNotLength = oldReadTag;

   return nextTagPosn;
} /* fpa1_rdfGetNextTagPosn () */

int fpa1_rdfSetNewFilePosition( vpa1_filePos newPosition )
{
   /* Set new position */
   readingTagNotLength = TRUE;

   if (newPosition < 0)
   {
      return 1;
   }
   else if (fpa1_currentBufferLength < (unsigned long)newPosition)
   {
      fpa1_currentBufferOffset = fpa1_currentBufferLength;
      return 1;
   }
   else
   {
      fpa1_currentBufferOffset = newPosition;
   }

   return 0;
} /* fpa1_rdfSetNewFilePosition() */

int fpa1_rdfGetByteAbsolute(vpa1_filePos pos)
{
   int retval = 0;
   if (pos < (long)fpa1_currentBufferLength)
   {
      retval = fpa1_currentBufferStart[pos];
   }
   return retval;
}

int fpa1_rdfGetIntegerAbsolute( vpa1_filePos pos, int intLength )
{
   int content;

   int intValue;

   content = fpa1_rdfGetByteAbsolute(pos);

   /* sign extend the 8 bit content to 32bit */
   intValue = ((content > 127) ? (~0xFF | content) : content);
   intLength--;
   pos++;

   while (intLength > 0)
   {
      intValue = (intValue << 8) | fpa1_rdfGetByteAbsolute(pos);
      intLength--;
      pos++;
   }

   return intValue;
}

int fpa1_rdfGetBooleanAbsolute(vpa1_filePos pos)
{
   return fpa1_rdfGetByteAbsolute(pos);
}

fpa1_syntaxList* fpa1_parseScriptASN(unsigned char *asndata, unsigned long len)
{
   fpa1_syntaxList *itemPtr;

   fpa1_currentBufferStart = asndata;
   fpa1_currentBufferLength = len;
   fpa1_currentBufferOffset = 0;

   fpa1_GenericDataCount = 0;
   fpa1_GroupActionCount = 0;
   fpa1_GroupParamCount = 0;

   itemPtr = fpa1_choiceParse( intObjChoiceCompArr );

   return itemPtr;
}