/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

* Bit buffer reading operations.

*

*/

/*

* Includes

*/

#include "h263dConfig.h"

#include "Biblin.h"

#include "debug.h"

#ifdef DEBUG_OUTPUT

bibBuffer_t * buffer_global;

#endif

/*

* Definitions

*/

#define bibMalloc malloc

#define bibCalloc calloc

#define bibRealloc realloc

#define bibDealloc free

#ifndef bibAssert

#define bibAssert(exp) assert(exp);

#endif

/*

* Local function prototypes

*/

static void bibInitialize(

                                                    bibBuffer_t *bibBuffer,

                                                    void *srcBuffer,

                                                    unsigned srcBufferLength,

                                                    int16 *errorCode);

/*

* Imported variables

*/

/*

* Global functions

*/

/* {{-output"bibCreate.txt"}} */

/*

*

* bibCreate

*    

*

* Parameters:

*    srcBuffer                  buffer containing the data

*    srcBufferLength            the length of the buffer

*    errorCode                  error code

*

* Function:

*    This function creates a bit buffer from a buffer given as a parameter.

*

* Returns:

*    The bibCreate function returns a pointer to a bibBuffer_t

*    structure. If the function is unsuccessful NULL is returned.

*

* Error codes:

*    ERR_BIB_STRUCT_ALLOC       if the bit buffer structure could not be

*                               allocated

*

*/

bibBuffer_t *bibCreate(void *srcBuffer, unsigned srcBufferLength, int16 *errorCode)

/* {{-output"bibCreate.txt"}} */

{

    bibBuffer_t *bibBuffer = NULL;

    int16 tmpError = 0;

    bibBuffer = (bibBuffer_t *) bibMalloc(sizeof(bibBuffer_t));

    if (bibBuffer == NULL) {

        *errorCode = ERR_BIB_STRUCT_ALLOC;

        deb("bibCreate: ERROR - bibMalloc failed.\n");

        return NULL;

    }

    bibInitialize(bibBuffer, srcBuffer, srcBufferLength, &tmpError);

    if (tmpError) {

        bibDealloc(bibBuffer);

        return NULL;

    }

#ifdef DEBUG_OUTPUT

    debLoad("deb_dec.log");

    buffer_global = bibBuffer;

#endif

    return bibBuffer;

}

bibBufferEdit_t *bibBufferEditCreate(int16 *errorCode)

/* {{-output"bibCreate.txt"}} */

{

    bibBufferEdit_t *bufEdit = NULL;    

    bufEdit = (bibBufferEdit_t *) bibMalloc(sizeof(bibBufferEdit_t));

    if (bufEdit == NULL) {

        *errorCode = ERR_BIB_STRUCT_ALLOC;

        deb("bibBufferEditCreate: ERROR - bibMalloc failed.\n");

        return NULL;

    }

     bufEdit->copyMode = CopyWhole/*CopyWhole*/;

     bufEdit->numChanges=0;

     bufEdit->editParams=NULL;

   return bufEdit;

}

/* {{-output"bibDelete.txt"}} */

/*

*

* bibDelete

*    

*

* Parameters:

*    buffer                     a pointer to a bit buffer structure

*    errorCode                  error code

*

* Function:

*    The bibDelete function frees the memory allocated for the buffer.

*

* Returns:

*    Nothing

*

* Error codes:

*    None

*

*/

void bibDelete(bibBuffer_t *buffer, int16 * /*errorCode*/)

/* {{-output"bibDelete.txt"}} */

{

    if (buffer) {

        // note that the BaseAddr is just a reference to memory allocated elsewhere

        // and there is no other dynamic allocations inside buffer

        bibDealloc((void *) buffer);

    }

}

void bibBufEditDelete(bibBufferEdit_t *bufEdit, int16 * /*errorCode*/)

{

     int i;

   if (bufEdit) {

         for(i=0; i<bufEdit->numChanges; i++)

             bibDealloc((void *) bufEdit->editParams);

         bibDealloc((void *) bufEdit);

   }

}

/*

*

* bibFlushBits

* bibGetBits

* bibShowBits

*    

*

* Parameters:

*    numberOfBits               the number of bits wanted (1..32)

*    buffer                     a pointer to a bit buffer structure

*    numberOfBitsGot            the number of bits actually got

*    syncStartIndex             the number of the first bit belonging to 

*                               a synchronization code (1 .. numberOfBits).

*                               Bits are numbered starting from 1 given to

*                               the most significant bit of the returned code.

*                               Thus, syncStartIndex - 1 most significant bits

*                               of the returned code are valid coding

*                               parameters (do not belong to a sync code).

*                               0 is returned if the returned code does not

*                               contain any part of a synchronization code.

*    bitErrorIndication         indication code for bit errors,

*                               see biterr.h for the possible values

*    errorCode                  error code

*

* Function:

*    The bibFlushBits function removes the next numberOfBits bits from

*    the buffer.

*

*    The bibGetBits function gets the next numberOfBits bits from the buffer.

*    The returned bits are removed.

*

*    The bibShowBits function gets the next numberOfBits bits from the

*    buffer. The returned bits are not removed from the buffer.

*

* Returns:

*   bibGetBits and bibShowBits:

*       the next numberOfBits bits / the rest of the buffer if the end of

*       the input file has been reached

*

* Error codes:

*    ERR_BIB_NOT_ENOUGH_DATA    if one tries to get more bits from the buffer

*                               than there is left

*

*/

void bibFlushBits(int numberOfBits, bibBuffer_t *buffer)

{

    bibAssert(buffer != NULL);

    bibAssert(numberOfBits > 0 && numberOfBits <= 32);

    /* Check if enough bits are available. */

    if (buffer->bitsLeft < (u_int32) numberOfBits) {

        goto flush_underflow;

    }

    buffer->bitsLeft -= numberOfBits;

    if ( buffer->bitIndex >= numberOfBits ) {

        /* All in the current byte, bits still left */

        buffer->bitIndex -= numberOfBits;

    }

    else if ( buffer->bitIndex == (numberOfBits-1) ) {

        /* Current byte used completely */

        buffer->bitIndex = 7;

        buffer->getIndex++;

        buffer->numBytesRead++;

    }

    else {

        /* Current byte plus then some */

        numberOfBits -= buffer->bitIndex + 1; /* this many bits after current byte */

        buffer->getIndex += ((numberOfBits>>3) + 1);

        buffer->numBytesRead += ((numberOfBits>>3) + 1);

        buffer->bitIndex = 7 - (numberOfBits&7); 

    }

    return;

flush_underflow:

    buffer->error = ERR_BIB_NOT_ENOUGH_DATA;

}

/*

*

* bibGetAlignedByte

*    

*

* A fast function to get one byte from byte-boundary.

*

*/

inline u_int8 bibGetAlignedByte(bibBuffer_t *buffer)   

    {

    return buffer->baseAddr[buffer->getIndex++];

    }

/*

*

* bibGetBits

*    

*

* See bibFlushBits.

*

*/

u_int32 bibGetBits(int numberOfBits, bibBuffer_t *buffer)   

{

    static const u_char

        msbMask[8] = {1, 3, 7, 15, 31, 63, 127, 255},

        lsbMask[9] = {255, 254, 252, 248, 240, 224, 192, 128, 0};

    u_char

        *startAddr;

    int32

        bitIndex;

    u_int32

        endShift;         /* the number of shifts after masking the last byte */

    u_int32

        numBytesFlushed;  /* the number of bytes flushed from the buffer */

    u_int32

        returnValue = 0;

    bibAssert(buffer != NULL);

    bibAssert(numberOfBits > 0 && numberOfBits <= 32);

    startAddr = buffer->baseAddr + buffer->getIndex;

    bitIndex = buffer->bitIndex;

    /* Check if enough bits are available. */

    if (buffer->bitsLeft < (u_int32) numberOfBits) {

        goto get_underflow;

    }

    buffer->bitsLeft -= numberOfBits;

    if ( bitIndex >= numberOfBits ) {

        /* All in the current byte, bits still left */

        endShift = bitIndex - numberOfBits + 1;

        buffer->bitIndex -= numberOfBits;

        return ((startAddr[0] & msbMask[bitIndex] & lsbMask[endShift]) >> endShift);

    }

    else if ( bitIndex == (numberOfBits-1) ) {

        /* Current byte used completely */

        buffer->bitIndex = 7;

        buffer->getIndex++;

        buffer->numBytesRead++;

        return startAddr[0] & msbMask[bitIndex];

    }

    else {

        /* Current byte plus then some */

        /* Remainder of this byte */

        returnValue = *(startAddr++) & msbMask[bitIndex];

        numberOfBits -= bitIndex + 1;

        numBytesFlushed = 1 + (numberOfBits >> 3);

        /* Get full bytes */

        while ( numberOfBits >= 8 ) {

            returnValue = (returnValue << 8) | *(startAddr++);

            numberOfBits -= 8;

        }

        /* Get bits from last byte */

        endShift = 8 - numberOfBits;

        returnValue = (returnValue << numberOfBits) | ((startAddr[0] & lsbMask[endShift]) >> endShift);

        /* (safe, since lsbMask[8]==0) */

        /* Update position in buffer */

        buffer->bitIndex = 7 - numberOfBits;

        buffer->getIndex += numBytesFlushed;

        buffer->numBytesRead += numBytesFlushed;

    }

    return returnValue;

get_underflow:

    buffer->error = ERR_BIB_NOT_ENOUGH_DATA;

    return 0;

}

/* {{-output"bibNumberOfFlushedBits.txt"}} */

/*

*

* bibNumberOfFlushedBits

*    

*

* Parameters:

*    buffer                     a pointer to a bit buffer structure

*

* Function:

*    The bibNumberOfFlushedBytes returns the number of bits which

*    are got (bibGetBits) or flushed (bibFlushBits) from the buffer since

*    the buffer was created

*

* Returns:

*    See above.

*

* Error codes:

*    None.

*

*/

u_int32 bibNumberOfFlushedBits(bibBuffer_t *buffer)

/* {{-output"bibNumberOfFlushedBits.txt"}} */

{

    bibAssert(buffer != NULL);

    return ((buffer->numBytesRead<<3) + (7-buffer->bitIndex));

}

/* {{-output"bibNumberOfFlushedBytes.txt"}} */

/*

*

* bibNumberOfFlushedBytes

*    

*

* Parameters:

*    buffer                     a pointer to a bit buffer structure

*

* Function:

*    The bibNumberOfFlushedBytes returns the number of whole bytes which

*    are got (bibGetBits) or flushed (bibFlushBits) from the buffer since

*    bibCreate was called.

*

* Returns:

*    See above.

*

* Error codes:

*    None.

*

*/

u_int32 bibNumberOfFlushedBytes(bibBuffer_t *buffer)

/* {{-output"bibNumberOfFlushedBytes.txt"}} */

{

    bibAssert(buffer != NULL);

    return buffer->numBytesRead;

}

/* {{-output"bibNumberOfRewBits.txt"}} */

/*

*

* bibNumberOfRewBits

*    

*

* Parameters:

*    buffer                     a pointer to a bit buffer structure

*

* Function:

*    The bibNumberOfRewBits returns the number of bits which can be

*    successfully rewinded.

*

* Returns:

*    See above.

*

* Error codes:

*    None.

*

*/

u_int32 bibNumberOfRewBits(bibBuffer_t *buffer)

/* {{-output"bibNumberOfRewBits.txt"}} */

{

    bibAssert(buffer != NULL);

    return ((buffer->numBytesRead<<3) + (7-buffer->bitIndex));

}

/* {{-output"bibRewindBits.txt"}} */

/*

*

* bibRewindBits

*    

*

* Parameters:

*    numberOfBits               the number of bits to rewind

*    buffer                     a pointer to a bit buffer structure

*    errorCode                  error code

*

* Function:

*    This function rewinds the pointers to the buffer

*    so that already flushed or got bits can be read

*    again.

*

* Returns:

*    Nothing.

*

* Error codes:

*    ERR_BIB_CANNOT_REWIND      if numberOfBits is larger than which is

*                               possible to get (see also bibNumberOfRewBits).

*

*    ERR_BIB_BUFLIST            if there was a fatal error when handling

*                               buffer lists

*

*/

void bibRewindBits(u_int32 numberOfBits, bibBuffer_t *buffer, int16 *errorCode)

/* {{-output"bibRewindBits.txt"}} */

{

    bibAssert(buffer != NULL);

    /* All bits to rewind are in the latest byte */

    if (numberOfBits <= (u_int32) (7 - buffer->bitIndex)) {

        buffer->bitIndex += numberOfBits;

    }

    /* Bits to rewind are within several bytes */

    else {

        u_int32

            numBitsWithoutFirstByte = numberOfBits - (7 - buffer->bitIndex),

            numWholeBytes = (numBitsWithoutFirstByte>>3),

            numBitsInLastByte = numBitsWithoutFirstByte - (numWholeBytes<<3);

        if (numBitsInLastByte) {

            if (buffer->getIndex >= numWholeBytes + 1) {

                buffer->getIndex -= numWholeBytes + 1;

                buffer->bitIndex = numBitsInLastByte - 1;

                buffer->numBytesRead -= numWholeBytes + 1;

            }

            else {

                *errorCode = ERR_BIB_CANNOT_REWIND;

                deb("bibRewindBits: ERROR - cannot rewind.\n");

            }

        }

        else {

            if (buffer->getIndex >= numWholeBytes) {

                buffer->getIndex -= numWholeBytes;

                buffer->bitIndex = 7;

                buffer->numBytesRead -= numWholeBytes;

            }

            else {

                *errorCode = ERR_BIB_CANNOT_REWIND;

                deb("bibRewindBits: ERROR - cannot rewind.\n");

            }

        }

    }

    buffer->bitsLeft += numberOfBits;

}