bitwriter.h

1. 8623L平台

/************************************************************
	Copyright (C) 2002

	Sigma Designs, Inc. All Rights Reserved
	Proprietary and Confidential

    Author: David Weiguo Zheng
			<[e-mail]>

    File Name: bitWrite.h

	Purpose: All functions to handle bit writing

**************************************************************/

#ifndef _BITWRITE_H_
#define _BITWRITE_H_

typedef struct
{
	RMint32 pos;
	RMuint32 reg;

	RMuint32 * buf;
	RMuint32 * ptr;
	RMuint32 * tmp;
} BitWriter;

static void __inline bw_init(BitWriter * const bw, void * const pointer, const RMuint32 start_byte, const RMuint32 start_bit);
static void __inline bw_reset(BitWriter * const bw);
static RMuint32 __inline bw_byte_length(BitWriter * const bw);
static RMuint32 __inline bw_bit_length(BitWriter * const bw);
static void __inline bw_put1(BitWriter * const bw, const RMuint32 bit);
static void __inline bw_put(BitWriter * const bw, const RMuint32 value, const RMint32 size);
static void __inline bw_byte_align(BitWriter * const bw);
static void __inline bw_dword_align(BitWriter * const bw);


/* 
  initialize bitstream structure 
  data in buffer need to be byte_aligned already
*/

static void __inline bw_init(BitWriter * const bw, void * const pointer, const RMuint32 start_byte, const RMuint32 start_bit)
{
	RMuint32 aligned = start_byte & 3;
	//printf("Aligned in bw_init = %lu, start_bit = %lu\n", aligned, start_bit);	
	if(aligned)
	{
	  RMuint32 i;
	  RMuint8  *ptr;
	  bw->buf = (RMuint32 *)pointer;
	  bw->ptr = bw->buf + (start_byte >> 2);
	  ptr = (RMuint8 *)bw->ptr;	  
	
	  bw->reg = 0;
	  bw->pos = 0;

	  for(i=0; i<aligned; i++)
	  {
		  bw->reg <<= 8;
		  bw->reg |= *ptr++;
		  bw->pos += 8;
	  }	  
	  bw->reg <<= (32 - bw->pos);
	  if(start_bit)
	  {
		  i = *ptr;
		  bw->reg |= i << ((32 - bw->pos) - 8);
		  bw->pos += start_bit;		  	
		  bw->reg &= (0xffffffff << (32 - bw->pos));
	  }

	}
	else
	{
	  bw->reg = bw->pos = 0;
	  bw->buf = (RMuint32 *)pointer;
	  bw->ptr = bw->buf + (start_byte >> 2);
	  if(start_bit)
	  {
	    RMuint32 i;
	    RMuint8  *ptr;

	    ptr = (RMuint8 *)bw->ptr;
		i = *ptr;
	    bw->reg |= i << 24;
		
		bw->pos += start_bit;		
	    bw->reg &= (0xffffffff << (32 - bw->pos));
	  }
	}

}

static void __inline bw_reset(BitWriter * const bw)
{
    bw->reg = bw->pos = 0;	
	bw->ptr = bw->buf;
}

/* bitstream length (unit bits) */

static RMuint32 __inline bw_byte_length(BitWriter * const bw)
{
	RMuint32 len = (RMuint32) bw->ptr - (RMuint32) bw->buf;

    if (bw->pos)
    {
		RMuint32 ui32 = bw->reg;
                RMuint32ToBeBuf(ui32, (RMuint8 *) &ui32);
		*bw->ptr = ui32;

		len += ((bw->pos + 7) >> 3);
    }

	return len;
}

static RMuint32 __inline bw_bit_length(BitWriter * const bw)
{
	RMuint32 len = ((RMuint32) bw->ptr - (RMuint32) bw->buf)<<3;

    len += bw->pos;

	return len;
}

/* write single bit to bitstream */

static void __inline bw_put1(BitWriter * const bw, const RMuint32 bit)
{
    if (bit)
		bw->reg |= (0x80000000 >> bw->pos);

    bw->pos ++;

    if (bw->pos > 31)
    {
		RMuint32 ui32 = bw->reg;
		bw->reg = 0;
                RMuint32ToBeBuf(ui32, (RMuint8 *) &ui32);
		*bw->ptr++ = ui32;
		bw->pos -= 32;
    }

}


/* put n bits to bitwriter */
static void __inline bw_put(BitWriter * const bw, const RMuint32 value, const RMint32 size)
{
  if(size)
  {
	RMint32 shift = 32 - bw->pos - size;

	if (shift>0) {		// there is more than enough bits available to insert the data
		bw->reg |= (value << shift);
		bw->pos += size;
		return;
	} 
	else
	{
	   if(shift)    // no enough bits to insert data	
	   {
		// 32bit cache buffer full, need to flush the cache and update again
		RMint32 room = 32-bw->pos;
		RMint32 first_shift = size-room;

		RMuint32 ui32 = bw->reg | (value >> first_shift);		
		room = 32-first_shift;
                RMuint32ToBeBuf(ui32, (RMuint8 *) &ui32);
		*bw->ptr++ = ui32;
		bw->reg = (value << room);		
		bw->pos = first_shift;
		return;
	   }
	   else//	if(shift == 0)
	   {
		RMuint32 ui32 = bw->reg | (value << shift);

                RMuint32ToBeBuf(ui32, (RMuint8 *) &ui32);
		*bw->ptr++ = ui32;

		bw->pos = 0;
		bw->reg = 0;

		return;
	   }

	}
  }
}


/* pad bitwriter bitstream to align byte boundary */
static void __inline bw_byte_align(BitWriter * const bw)
{
	RMint32 remainder = bw->pos & 7;

    if (remainder)
    {		
		if(remainder < 8)
		{
		bw_put1(bw, 0);
		remainder ++;
		}

		// still needs padding
		if(remainder < 8)
		{
		  RMuint32 padding_bits = 0xff >> remainder;
		  bw_put(bw, padding_bits, 8-remainder);
		}

    }

}

/* pad bitwriter bitstream to align 32bit (dword) boundary */
static void __inline bw_dword_align(BitWriter * const bw)
{
	RMint32 remainder = bw->pos & 31;

    if (remainder)
    {		
		//padding
		  RMuint32 padding_bits = 0xffffffff >> remainder;
		  bw_put(bw, padding_bits, 32-remainder);

    }

}

#endif /* _BITWRITE_H_ */