/**************************************************************************
 *                                                                        *
 * This code has been developed by Eugene Kuznetsov. This software is an  *
 * implementation of a part of one or more MPEG-4 Video tools as          *
 * specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
 * software module in hardware or software products are advised that its  *
 * use may infringe existing patents or copyrights, and any such use      *
 * would be at such party's own risk.  The original developer of this     *
 * software module and his/her company, and subsequent editors and their  *
 * companies (including Project Mayo), will have no liability for use of  *
 * this software or modifications or derivatives thereof.                 *
 *                                                                        *
 * Project Mayo gives users of the Codec a license to this software       *
 * module or modifications thereof for use in hardware or software        *
 * products claiming conformance to the MPEG-4 Video Standard as          *
 * described in the Open DivX license.                                    *
 *                                                                        *
 * The complete Open DivX license can be found at                         *
 * http://www.projectmayo.com/opendivx/license.php                        *
 *                                                                        *
 **************************************************************************/
/**
*  Copyright (C) 2001 - Project Mayo
 *
 * Eugene Kuznetsov
 *
 * DivX Advanced Research Center <darc@projectmayo.com>
*
**/

#ifndef _DECORE_GETBITS_H
#define _DECORE_GETBITS_H

void initbits (unsigned char * stream, int length);
void fillbfr (void);

/***/

#if defined(LINUX)
// 486+ specific instruction
// anybody want to use decore on 386?
#define _SWAP(a,b) b=*(int*)a; \
	__asm__ ( "bswapl %0\n" : "=g" (b) : "0" (b) )
#elif defined(WIN32)
#define _SWAP(a,b) \
	b=*(int*)a; __asm mov eax,b __asm bswap eax __asm mov b, eax
#else
#define _SWAP(a,b) (b=((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]))
#endif

#ifdef WIN32
#include <io.h>
#endif

/***/

#ifndef _DECORE

static unsigned int msk[33] =
{
  0x00000000, 0x00000001, 0x00000003, 0x00000007,
  0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
  0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
  0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
  0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
  0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
  0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
  0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
  0xffffffff
};

static void fillbfr ()
{
  int l;

  ld->inbfr[0] = ld->inbfr[8];
  ld->inbfr[1] = ld->inbfr[9];
  ld->inbfr[2] = ld->inbfr[10];
  ld->inbfr[3] = ld->inbfr[11];

  if (ld->rdptr >= ld->rdbfr + 2048)
  {
    l = read (ld->infile, ld->rdbfr, 2048);
    ld->rdptr = ld->rdbfr;
    if (l < 2048)
    {
      if (l < 0)
        l = 0;

      while (l < 2048)          /* Add recognizable sequence end code */
      {
        ld->rdbfr[l++] = 0;
        ld->rdbfr[l++] = 0;
        ld->rdbfr[l++] = (1 << 7) | (31 << 2);
      }
    }
  }
  for (l = 0; l < 8; l++)
    ld->inbfr[l + 4] = ld->rdptr[l];

  ld->rdptr += 8;
  ld->incnt += 64;
}


/* return next n bits (right adjusted) without advancing */

static unsigned int showbits (int n)
{
  unsigned char *v;
  unsigned int b;
  int c;

  if (ld->incnt < n)
    fillbfr ();

  v = ld->inbfr + ((96 - ld->incnt) >> 3);
  b = (v[0] << 24) | (v[1] << 16) | (v[2] << 8) | v[3];
  c = ((ld->incnt - 1) & 7) + 25;
  return (b >> (c - n)) & msk[n];
}

/* advance by n bits */

static void flushbits (int n)
{
  ld->bitcnt += n;
  ld->incnt -= n;

  if (ld->incnt < 0)
    fillbfr ();
}

#else

static __inline unsigned int showbits (int n)
{
	int rbit = 32 - ld->bitcnt;
	unsigned int b;
	_SWAP(ld->rdptr, b);
//	return ((b & msk[rbit]) >> (rbit-n));
// Is it platform independent???

	return (b & (0xFFFFFFFFU >> (ld->bitcnt))) >> (rbit-n);
}

static __inline void flushbits (int n)
{
	ld->bitcnt += n;
	if (ld->bitcnt >= 8) {
		ld->rdptr += ld->bitcnt / 8;
		ld->bitcnt = ld->bitcnt % 8;
	}
}

#endif // !_DECORE

static __inline unsigned int getbits (int n)
{
  unsigned int l;

  l = showbits (n);
  flushbits (n);

  return l;
}

unsigned int getbits1 (void);

#endif /* _DECORE_GETBITS_H */