defMemUtilsMgd.h

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 © 2001 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
 *******************************************************************************/
#ifdef MEM_CONTIGUOUS

/*
-- Managed memory is CONTIGUOUS so can access via standard pointer
-- manipulation
*/
    #include "defMemUtilsContig.h"

#else

/* -- SET STANDARD MACROS TO ACCESS MANAGED/MEMSEQ MEMORY */

    #undef  MemPtr
    #undef  MemPos
    #undef  MEMPTR_SEQ_OPEN
    #undef  MEMPTR_SEQ_CLOSE
    #undef  MEMPTR_OPEN
    #undef  MEMPTR_CLOSE
    #undef  MEMPTR_GET_DIFF
    #undef  MEMPTR_DATA_COMPARE
    #undef  MEMPTR_READ
    #undef  MEMPTR_WRITE
    #undef  MEMPTR_COPY
    #undef  SET_POS_REL
    #undef  SET_POS_ABS
    #undef  GET_POS
    #undef  READ_UINT8
    #undef  READ_UINT16
    #undef  READ_UINT32
    #undef  GET_UINT8
    #undef  GET_UINT16
    #undef  GET_UINT32
    #undef  READ_OBJECT_KEY


    #define MemPtr  MemSeqRef
    #define MemPos  U32BIT

    #define MEMPTR_SEQ_OPEN( context, memArea, offset, length, async, memPtr ) \
   CHECK_MEM_ERR(                                                        \
   memSeqOpen(context, memArea, offset, length, async, &(memPtr)))

    #define MEMPTR_SEQ_CLOSE( context, memArea, memPtr )    \
   memSeqClose( memPtr )

    #define MEMPTR_OPEN( seqMemPtr, memPtr )                \
   CHECK_MEM_ERR(memSeqOpenClone( seqMemPtr, &(memPtr)))

    #define MEMPTR_CLOSE( memPtr )  memSeqClose( memPtr )

    #define MEMPTR_GET_DIFF( memPtr1, memPtr2, i32 )        \
   {                                                   \
      U32BIT pos1, pos2;                             \
      memSeqReadPos( memPtr1, &(pos1));                \
      memSeqReadPos( memPtr2, &(pos2));                \
      i32 = pos2 - pos1;                              \
   }

    #define MEMPTR_DATA_COMPARE( ui8Ptr, memPtr, length, equal )                    \
   CHECK_MEM_ERR(memSeqCompContig( ui8Ptr, memPtr, length, &(equal)))

    #define MEMPTR_READ( srcMemPtr, destUi8Ptr, numbytes )                          \
   {                                                                           \
      U32BIT dummy;                                                           \
      CHECK_MEM_ERR(memSeqRead( srcMemPtr, destUi8Ptr, numbytes, &dummy ));   \
   }

    #define MEMPTR_WRITE( srcUi8Ptr, destMemPtr, numbytes )                         \
   {                                                                           \
      U32BIT dummy;                                                           \
      CHECK_MEM_ERR(memSeqWrite( srcUi8Ptr, destMemPtr, numbytes, &dummy ));  \
   }

    #define MEMPTR_COPY( srcMemPtr, destMemPtr, numbytes )                          \
   {                                                                           \
      U32BIT dummy;                                                           \
      CHECK_MEM_ERR(memSeqCopy( srcMemPtr, destMemPtr, numbytes, &dummy ));   \
   }

    #define SET_POS_REL( memPtr, offset )                   \
   CHECK_MEM_ERR(memSeqSetPosRel( memPtr, offset ))

    #define SET_POS_ABS( memPtr, memPos )                   \
   CHECK_MEM_ERR(memSeqSetPosAbs( memPtr, memPos ))

    #define GET_POS( memPtr, memPos )                       \
   memSeqReadPos( memPtr, &(memPos))

    #define READ_UINT8( memPtr, ui8 )                       \
   CHECK_MEM_ERR(memSeqReadByte( memPtr, &(ui8)))

    #define READ_UINT16( memPtr, ui16 )     readUInt16Seq( memPtr, &(ui16))
    #define READ_UINT32( memPtr, ui32 )     readUInt32Seq( memPtr, &(ui32))
    #define GET_UINT8( memPtr, ui8 )        getUInt8Seq( memPtr, &(ui8))
    #define GET_UINT16( memPtr, ui16 )      getUInt16Seq( memPtr, &(ui16))
    #define GET_UINT32( memPtr, ui32 )      getUInt32Seq( memPtr, &(ui32))

    #define READ_OBJECT_KEY( memPtr, objKey, valid )          \
   readObjectKeySeq( memPtr, &(objKey), &(valid))


#endif

/*----------------------------------------------------------------------------*/