bitstream.h

基于Linux的ffmepg decoder

#ifndef _BITSTREAM_H_
#define _BITSTREAM_H_

#include <stdio.h>
#include <stdlib.h>
#include "../portab.h"
#include "../decoder.h"
#include "../encoder.h"



#ifdef __cplusplus
extern "C" {
#endif




/*****************************************************************************
 * Constants
 ****************************************************************************/

/* comment any #defs we dont use */

#define VIDOBJ_START_CODE		0x00000100	/* ..0x0000011f  */
#define VIDOBJLAY_START_CODE	0x00000120	/* ..0x0000012f */
#define VISOBJSEQ_START_CODE	0x000001b0
#define VISOBJSEQ_STOP_CODE		0x000001b1	/* ??? */
#define USERDATA_START_CODE		0x000001b2
#define GRPOFVOP_START_CODE		0x000001b3
/*#define VIDSESERR_ERROR_CODE  0x000001b4 */
#define VISOBJ_START_CODE		0x000001b5
/*#define SLICE_START_CODE      0x000001b7 */
/*#define EXT_START_CODE        0x000001b8 */


#define VISOBJ_TYPE_VIDEO				1
/*#define VISOBJ_TYPE_STILLTEXTURE      2 */
/*#define VISOBJ_TYPE_MESH              3 */
/*#define VISOBJ_TYPE_FBA               4 */
/*#define VISOBJ_TYPE_3DMESH            5 */


#define VIDOBJLAY_TYPE_SIMPLE			1
/*#define VIDOBJLAY_TYPE_SIMPLE_SCALABLE    2 */
#define VIDOBJLAY_TYPE_CORE				3
#define VIDOBJLAY_TYPE_MAIN				4


/*#define VIDOBJLAY_AR_SQUARE           1 */
/*#define VIDOBJLAY_AR_625TYPE_43       2 */
/*#define VIDOBJLAY_AR_525TYPE_43       3 */
/*#define VIDOBJLAY_AR_625TYPE_169      8 */
/*#define VIDOBJLAY_AR_525TYPE_169      9 */
#define VIDOBJLAY_AR_EXTPAR				15


#define VIDOBJLAY_SHAPE_RECTANGULAR		0
#define VIDOBJLAY_SHAPE_BINARY			1
#define VIDOBJLAY_SHAPE_BINARY_ONLY		2
#define VIDOBJLAY_SHAPE_GRAYSCALE		3

#define VO_START_CODE	0x8
#define VOL_START_CODE	0x12
#define VOP_START_CODE	0x1b6

#define READ_MARKER()	BitstreamSkip(bs, 1)
#define WRITE_MARKER()	BitstreamPutBit(bs, 1)

/* vop coding types  */
/* intra, prediction, backward, sprite, not_coded */
#define I_VOP	0
#define P_VOP	1
#define B_VOP	2
#define S_VOP	3
#define N_VOP	4
#define I_VOP_D	5
#define P_VOP_D	6

//static int32_t num_gobs_in_vop[8] = {0, 6, 9, 18, 18, 18, 0, 0};
//static int32_t num_marcoblocks_in_gob[8] = {0, 8, 11, 22, 88, 352, 0, 0};

/* resync-specific */
#define NUMBITS_VP_RESYNC_MARKER  17
#define RESYNC_MARKER 1

static const int stuffing_codes[8] =
{
	        /* nbits     stuffing code */
	0,		/* 1          0 */
	1,		/* 2          01 */
	3,		/* 3          011 */
	7,		/* 4          0111 */
	0xf,	/* 5          01111 */
	0x1f,	/* 6          011111 */
	0x3f,   /* 7          0111111 */
	0x7f,	/* 8          01111111 */
};

/*****************************************************************************
 * Prototypes
 ****************************************************************************/

int
read_video_packet_header(Bitstream *bs, DECODER *dec, const int addbits, 
			int *quant, int *fcode_forward,	int *fcode_backward);

bool
bRead_video_packet_header(DECODER * dec,
						int *fcode_forward,
						int *fcode_backward,
						int32_t * mbnum);

/* header stuff */
int BitstreamReadHeaders(Bitstream * bs,
						 DECODER * dec,
						 uint32_t * rounding,
						 uint32_t * quant,
						 uint32_t * fcode_forward,
						 uint32_t * fcode_backward,
						 uint32_t * intra_dc_threshold_bit);


void BitstreamWriteVolHeader(Bitstream * const bs,
							 const MBParam * pParam,
							 const FRAMEINFO * frame);

void BitstreamWriteVopHeader(Bitstream * const bs,
							 const MBParam * pParam,
							 const FRAMEINFO * frame,
							 int vop_coded);

/*****************************************************************************
 * Inlined functions
 ****************************************************************************/

/* initialise bitstream structure */

static void __inline
BitstreamForward(Bitstream * const bs,
				 const uint32_t bits)
{
	bs->pos += bits;

	printf("BitstreamForward not complete yet\n");
	if (bs->pos >= 32) 
	{
		uint32_t b = bs->buf;

#ifndef ARCH_IS_BIG_ENDIAN
		BSWAP(b);
#endif
		*bs->tail++ = b;
		bs->buf = 0;
		bs->pos -= 32;
	}
}

static void __inline
BitstreamPutBits(Bitstream * const bs,
				 const uint32_t value,
				 const uint32_t size)
{
	uint32_t shift = 32 - bs->pos - size;

	if (shift <= 32) {
		bs->buf |= value << shift;
		BitstreamForward(bs, size);
	} else {
		uint32_t remainder;

		shift = size - (32 - bs->pos);
		bs->buf |= value >> shift;
		BitstreamForward(bs, size - shift);
		remainder = shift;

		shift = 32 - shift;

		bs->buf |= value << shift;
		BitstreamForward(bs, remainder);
	}
}
static __inline unsigned long get_word(unsigned char *ptr)
{
#ifndef ARCH_IS_BIG_ENDIAN
	return ptr[3] | (ptr[2]<<8) | (ptr[1]<<16) | (ptr[0]<<24);
	///return *(unsigned long *)ptr;
#else	
	return ptr[0] | (ptr[1]<<8) | (ptr[2]<<16) | (ptr[3]<<24);
#endif
}


static void __inline
BitstreamInit(Bitstream * const bs,
			  void *const bitstream,
			  uint32_t length, uint32_t start_pos)
{
	bs->start = bs->tail = (uint32_t *) bitstream;
	
	bs->bufa = get_word(bitstream);
	bs->bufb = get_word((unsigned char *)((unsigned int)bitstream + 4 ));

	bs->buf = 0;
	bs->pos = bs->start_pos = start_pos;			/// 0;
	bs->length = length;
}



static void __inline BitstreamUpdatePos(Bitstream * const bs, uint32_t *tail, unsigned int pos)
{
	bs->tail = tail;
	
	bs->bufa = get_word((unsigned char *)bs->tail);
	bs->bufb = get_word((unsigned char *)((unsigned int)bs->tail + 4));
	bs->pos = pos;
}


/* reset bitstream state */

static void __inline
BitstreamReset(Bitstream * const bs)
{
	bs->tail = bs->start;
	bs->bufa = get_word((unsigned char *)bs->start);
	bs->bufb = get_word((unsigned char *)((unsigned int)bs->start + 4));
	bs->buf = 0;
	bs->pos = 0;
}


/* reads n bits from bitstream without changing the stream pos */

static uint32_t __inline
BitstreamShowBits(Bitstream * const bs,
				  const uint32_t bits)
{
	int nbit = (bits + bs->pos) - 32;

	if (nbit > 0) {
		return ((bs->bufa & (0xffffffff >> bs->pos)) << nbit) | (bs->bufb >> (32 - nbit));
	} else {
		return (bs->bufa & (0xffffffff >> bs->pos)) >> (32 - bs->pos - bits);
	}
}


/* skip n bits forward in bitstream */

static void __inline
BitstreamSkip(Bitstream * const bs,
			  const uint32_t bits)
{
	bs->pos += bits;

	if (bs->pos >= 32) {

		bs->bufa = bs->bufb;
///		tmp = *((uint32_t *) bs->tail + 2);
		bs->bufb = get_word((unsigned char *)( (unsigned int)bs->tail + 8));
		bs->tail++;
		bs->pos -= 32;
	}
}

static void __inline
BitstreamPad_1(Bitstream * const bs)
{
	int bits = 8 - (bs->pos % 8);
	if (bits < 8)
		if (BitstreamShowBits(bs,bits) == stuffing_codes[bits-1])
			BitstreamSkip(bs,bits+1);
}

/* number of bits to next byte alignment */
static uint32_t __inline
BitstreamNumBitsToByteAlign(Bitstream *bs)
{
	uint32_t n = (32 - bs->pos) % 8;
	return n == 0 ? 8 : n;
}


/* show nbits from next byte alignment */
static uint32_t __inline
BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)
{
	int bspos = bs->pos + BitstreamNumBitsToByteAlign(bs);
	int nbit = (bits + bspos) - 32;

	if (bspos >= 32) {
		return bs->bufb >> (32 - nbit);
	} else	if (nbit > 0) {
		return ((bs->bufa & (0xffffffff >> bspos)) << nbit) | (bs->bufb >> (32 - nbit));
	} else {
		return (bs->bufa & (0xffffffff >> bspos)) >> (32 - bspos - bits);
	}

}



/* move forward to the next byte boundary */

static void __inline
BitstreamByteAlign(Bitstream * const bs)
{
	uint32_t remainder = bs->pos % 8;

	if (remainder) {
		BitstreamSkip(bs, 8 - remainder);
	}
}


/* bitstream length (unit bits) */

static uint32_t __inline
BitstreamPos(const Bitstream * const bs)
{
	return((uint32_t)(8*((ptr_t)bs->tail - (ptr_t)bs->start) + bs->pos - bs->start_pos));
}


/*	flush the bitstream & return length (unit bytes)
	NOTE: assumes no futher bitstream functions will be called.
 */

static uint32_t __inline
BitstreamLength(Bitstream * const bs)
{
	uint32_t len = (uint32_t)((ptr_t)bs->tail - (ptr_t)bs->start);

	printf("BitstreamLength not complete yet\n");
	
	if (bs->pos) {
		uint32_t b = bs->buf;

#ifndef ARCH_IS_BIG_ENDIAN
		BSWAP(b);
#endif
		*bs->tail = b;

		len += (bs->pos + 7) / 8;
	}

	return len;
}


/* move bitstream position forward by n bits and write out buffer if needed */



/* pad bitstream to the next byte boundary */

static void __inline
BitstreamPad(Bitstream * const bs)
{
	int bits = 8 - (bs->pos % 8);
	if (bits < 8)
		BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
}

static void __inline
BitstreamPadAlways(Bitstream * const bs)
{
	int bits = 8 - (bs->pos % 8);
	BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
}

/* read n bits from bitstream */

static uint32_t __inline
BitstreamGetBits(Bitstream * const bs,
				 const uint32_t n)
{
	uint32_t ret = BitstreamShowBits(bs, n);

	BitstreamSkip(bs, n);
	return ret;
}


/* read single bit from bitstream */

static uint32_t __inline
BitstreamGetBit(Bitstream * const bs)
{
	return BitstreamGetBits(bs, 1);
}


/* write single bit to bitstream */

static void __inline
BitstreamPutBit(Bitstream * const bs,
				const uint32_t bit)
{
	if (bit)
		bs->buf |= (0x80000000 >> bs->pos);

	BitstreamForward(bs, 1);
}

static uint32_t __inline
BitstreamGetBuffer(Bitstream * const bs)
{
	return bs->buf;
}

static uint32_t __inline
BitstreamGetPos(Bitstream * const bs)
{
	return bs->pos;
}
/* write n bits to bitstream */

#ifdef __cplusplus
}
#endif



#endif /* _BITSTREAM_H_ */