/*
* 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:
*
*/


#ifndef _BITBUFFER_H_
#define _BITBUFFER_H_


#include "globals.h"
#include "nrctyp32.h"


#define BIB_ERR_BIT_ERROR          -4
#define BIB_INCORRECT_TRAILING_BIT -3
#define BIB_ERR_NO_BITS            -2
#define BIB_ERROR                  -1
#define BIB_OK                      0


typedef struct _bitbuffer_s 
{
  u_int8 *data;     /* point to the bit buffer. The physical buffer is allocated by the main module */
  int dataLen;
  int bytePos;
  int bitpos;
  int32 currentBits;
  int errorStatus;
} bitbuffer_s;


#define bibRaiseError(bitbuf, error) ((bitbuf)->errorStatus = (error))

#define bibGetStatus(bitbuf) (bitbuf)->errorStatus


bitbuffer_s *bibOpen();

int bibInit(bitbuffer_s *bitbuf, u_int8 *streamBytes, int length);

int bibEnd(bitbuffer_s *bitbuf);

void bibEndSlice(bitbuffer_s *bitbuf);

void bibClose(bitbuffer_s *bitbuf);

int bibGetBitFunc(bitbuffer_s *bitbuf);

int32 bibGetBitsFunc(bitbuffer_s *bitbuf, int n);

int32 bibShowBitsFunc(bitbuffer_s *bitbuf, int n);

int bibSkipBitsFunc(bitbuffer_s *bitbuf, int n);

int bibGetByte(bitbuffer_s *bitbuf, int *byteRet);

int bibByteAlign(bitbuffer_s *bitbuf);

int bibSkipTrailingBits(bitbuffer_s *bitbuf);

int bibMoreRbspData(bitbuffer_s *bitbuf);

int32 bibGetNumRemainingBits(bitbuffer_s *bitbuf);

//int bibGetMax16bits(bitbuffer_s *bitbuf, TInt n, u_int32* retValue);
void syncBitBufferBitpos(bitbuffer_s *bitbuf);


/*
 *
 * bibGetBit
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      bit                   Return pointer for bit
 *
 * Function:
 *      Get next bit from bitbuffer.
 *
 * Returns:
 *      -
 *
 */
#define bibGetBit(bitbuf, bit) \
  if ((bitbuf)->bitpos <= 0) { \
    if ((bitbuf)->bytePos < (bitbuf)->dataLen) { \
      (bitbuf)->currentBits = (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->bitpos = 7; \
      *(bit) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & 1; \
    } \
    else { \
      (bitbuf)->errorStatus = BIB_ERR_NO_BITS; \
      *(bit) = 0; \
    } \
  } \
  else { \
    (bitbuf)->bitpos--; \
    *(bit) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & 1; \
  }


/*
 *
 * bibGetBits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits requested
 *      bits                  Return pointer for bits
 *
 * Function:
 *      Get next n bits from bitbuffer. If bitbuffer is low on bits,
 *      call bibGetBitsFunc to get more.
 *
 *      NOTE: maximum of 24 bits can be fetched
 *
 * Returns:
 *      -
 *
 */
#define bibGetBits(bitbuf, n, bits) \
  if ((n) > (bitbuf)->bitpos) { \
    if ((bitbuf)->bytePos+2 >= (bitbuf)->dataLen) \
      *(bits) = bibGetBitsFunc(bitbuf, n); \
    else { \
      do { \
        (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
        (bitbuf)->bitpos += 8; \
      } while ((n) > (bitbuf)->bitpos); \
      (bitbuf)->bitpos -= (n); \
      *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \
    } \
  } \
  else { \
    (bitbuf)->bitpos -= (n); \
    *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \
  }


/*
 *
 * bibGetMax16bits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits requested
 *      bits                  Return pointer for bits
 *
 * Function:
 *      Get next n bits from bitbuffer. If bitbuffer is low on bits,
 *      call bibGetBitsFunc to get more.
 *
 *      NOTE: maximum of 16 bits can be fetched
 *
 * Returns:
 *      -
 *
 */
#define bibGetMax16bits(bitbuf, n, bits) \
  if ((n) > (bitbuf)->bitpos) { \
    if ((bitbuf)->bytePos+1 >= (bitbuf)->dataLen) \
      *(bits) = bibGetBitsFunc(bitbuf, n); \
    else { \
      (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->bitpos += 16; \
      (bitbuf)->bitpos -= (n); \
      *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \
    } \
  } \
  else { \
    (bitbuf)->bitpos -= (n); \
    *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \
  }


/*
 *
 * bibGetMax8bits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits requested
 *      bits                  Return pointer for bits
 *
 * Function:
 *      Get next n bits from bitbuffer. If bitbuffer is low on bits,
 *      call bibGetBitsFunc to get more.
 *
 *      NOTE: maximum of 8 bits can be fetched
 *
 * Returns:
 *      -
 *
 */
#define bibGetMax8bits(bitbuf, n, bits) \
  if ((n) > (bitbuf)->bitpos) { \
    if ((bitbuf)->bytePos >= (bitbuf)->dataLen) \
      *(bits) = bibGetBitsFunc(bitbuf, n); \
    else { \
      (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->bitpos += 8; \
      (bitbuf)->bitpos -= (n); \
      *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \
    } \
  } \
  else { \
    (bitbuf)->bitpos -= (n); \
    *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \
  }


/*
 *
 * bibShowBits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits requested
 *      bits                  Return pointer for bits
 *
 * Function:
 *      Get next n bits from bitbuffer without advancing bitbuffer pointer.
 *      If bitbuffer is low on bits, call bibShowBitsFunc to get more.
 *
 *      NOTE: maximum of 24 bits can be fetched
 *
 * Returns:
 *      -
 *
 */
#define bibShowBits(bitbuf, n, bits) \
  if ((n) > (bitbuf)->bitpos) { \
    if ((bitbuf)->bytePos+2 >= (bitbuf)->dataLen) \
      *(bits) = bibShowBitsFunc(bitbuf, n); \
    else { \
      do { \
        (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
        (bitbuf)->bitpos += 8; \
      } while ((n) > (bitbuf)->bitpos); \
      *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); \
    } \
  } \
  else \
    *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n));


/*
 *
 * bibShowMax16bits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits requested
 *      bits                  Return pointer for bits
 *
 * Function:
 *      Get next n bits from bitbuffer without advancing bitbuffer pointer.
 *      If bitbuffer is low on bits, call bibShowBitsFunc to get more.
 *
 *      NOTE: maximum of 16 bits can be fetched
 *
 * Returns:
 *      -
 *
 */
#define bibShowMax16bits(bitbuf, n, bits) \
  if ((n) > (bitbuf)->bitpos) { \
    if ((bitbuf)->bytePos+1 >= (bitbuf)->dataLen) \
      *(bits) = bibShowBitsFunc(bitbuf, n); \
    else { \
      (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->bitpos += 16; \
      *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); \
    } \
  } \
  else \
    *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n));


/*
 *
 * bibShowMax8bits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits requested
 *      bits                  Return pointer for bits
 *
 * Function:
 *      Get next n bits from bitbuffer without advancing bitbuffer pointer.
 *      If bitbuffer is low on bits, call bibShowBitsFunc to get more.
 *
 *      NOTE: maximum of 8 bits can be fetched
 *
 * Returns:
 *      -
 *
 */
#define bibShowMax8bits(bitbuf, n, bits) \
  if ((n) > (bitbuf)->bitpos) { \
    if ((bitbuf)->bytePos >= (bitbuf)->dataLen) \
      *(bits) = bibShowBitsFunc(bitbuf, n); \
    else { \
      (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \
      (bitbuf)->bitpos += 8; \
      *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); \
    } \
  } \
  else \
    *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n));


/*
 *
 * bibSkipBits
 *
 * Parameters:
 *      bitbuf                Bitbuffer object
 *      n                     Number of bits to be skipped
 *
 * Function:
 *      Called after calling bibShowBits to skip the number of bits that
 *      were actually needed. If bibShowBits fetched more bits than there were
 *      bits in bitbuf->currentBits, calls bibSkipBitsFunc to clean up.
 *
 * Returns:
 *      -
 *
 */
#define bibSkipBits(bitbuf, n) \
  (bitbuf)->bitpos -= (n); \
  if ((bitbuf)->bitpos < 0) { \
    (bitbuf)->bitpos += (n); \
    bibSkipBitsFunc(bitbuf, n); \
  }



#endif  /* #ifndef _BITBUFFER_H_ */