Windows CE

开发平台：
C/C++

bitstrm.h：源码内容
							/*****************************************************************************
 *
 * This program is free software ; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 * $Id: bitstrm.h 292 2005-10-14 20:30:00Z picard $
 *
 * The Core Pocket Media Player
 * Copyright (c) 2004-2005 Gabor Kovacs
 *
 ****************************************************************************/
#ifndef __BITSTRM_H
#define __BITSTRM_H
typedef struct bitstream
{
	int bits;
	int bitpos;
	const uint8_t *bitptr;
	const uint8_t *bitend;
	
} bitstream;
// n=1..24 (or ..32 after bytealign)
#define bitshow(p,n) ((uint32_t)((p)->bits << (p)->bitpos) >> (32-(n)))
// n=9..32
static INLINE int bitshowlarge(bitstream* p, int n) 
{
	int i = bitshow(p,n);
	i |= *p->bitptr >> (40-n-p->bitpos);
	return i;
}
static INLINE void bitrewind(bitstream* p,int n)
{
	p->bitpos += 32 - (n & 7);
	p->bitptr -= 4 + (n >> 3);
}
#define bitflush(p,n) (p)->bitpos += n;
// use this only in boolean expression. to get a 1 bit value use getbits(p,1)
#define bitget1(p) (((p)->bits << (p)->bitpos++) < 0)
static INLINE int bitget(bitstream* p,int n)
{
	int i = bitshow(p,n);
	bitflush(p,n);
	return i;
}
static INLINE const uint8_t* bitendptr(bitstream* p) { return p->bitend-4; }
static INLINE uintptr_t bitendbookmark(bitstream* p)
{
	return (uintptr_t)p->bitend*8;
}
static INLINE uintptr_t bitbookmark(bitstream* p)
{
	return (uintptr_t)p->bitptr*8 + p->bitpos;
}
// non-exact eof, just for error checking
static INLINE int biteof(bitstream* p)
{
	return p->bitptr >= p->bitend;
}
static INLINE void bitbytealign(bitstream* p)
{
	p->bitpos = ALIGN8(p->bitpos);
}
static INLINE int bittonextbyte(bitstream* p)
{
	return 8-(p->bitpos & 7);
}
static INLINE const uint8_t *bitbytepos(bitstream* p)
{
	return p->bitptr - 4 + ((p->bitpos+7) >> 3);
}
//************************************************************************
// optimized reader using one local variable
#define bitload_pos(p, bitpos)					
	bitpos -= 8;								
	if (bitpos >= 0) {							
		int bits = (p)->bits;					
		const uint8_t* bitptr = (p)->bitptr;	
		do {									
			bits = (bits << 8) | *bitptr++;		
			bitpos -= 8;						
		} while (bitpos>=0);					
		(p)->bits = bits;						
		(p)->bitptr = bitptr;					
	}											
	bitpos += 8;
#define bitbookmark_pos(p,bitpos) ((int)(p)->bitptr*8 + bitpos)
#define bitshow_pos(p,bitpos,n) ((uint32_t)((p)->bits << bitpos) >> (32-(n)))
#define bitflush_pos(p,bitpos,n) bitpos += n;
#define bitget1_pos(p,bitpos) (((p)->bits << bitpos++) < 0)
#define bitbytealign_pos(p,bitpos) bitpos = ALIGN8(bitpos);
#define bitrewind_pos(p,bitpos,n) bitpos += 32 - ((n) & 7); (p)->bitptr -= 4 + ((n) >> 3);
#define bitgetx_pos(p,bitpos,n,tmp)			
{												
	tmp = (p)->bits << bitpos;				
	bitflush_pos(p,bitpos,n);					
	tmp >>= 1;									
	tmp ^= 0x80000000;							
	tmp >>= 31-n;								
	n = tmp - (tmp >> 31);						
}
//************************************************************************
// optimized reader using two prenamed local variables
#define bitbegin_pos2(p)		
	int bitpos = (p)->bitpos;	
	int bits = (p)->bits;
#define bitend_pos2(p)		
	(p)->bitpos = bitpos;
#define bitload_pos2(p)						
	if (bitpos >= 8) {						
		const uint8_t* bitptr = (p)->bitptr;
		do {								
			bits = (bits << 8) | *bitptr++;	
			bitpos -= 8;					
		} while (bitpos >= 8);				
		(p)->bits = bits;					
		(p)->bitptr = bitptr;				
	}											
#define bitshow_pos2(p,n) ((uint32_t)(bits << bitpos) >> (32-(n)))
#define bitflush_pos2(p,n) bitpos += n
#define bitget1_pos2(p) ((bits << bitpos++) < 0)
#define bitsign_pos2(p) (((bits << bitpos++) >> 31)|1)
//************************************************************************
#define bitloadcond(p) if ((p)->bitpos >= 8) bitload(p);
#define DECLARE_BITLOAD										
static NOINLINE void bitload(bitstream* p)					
{															
	bitbegin_pos2(p);										
	bitload_pos2(p);										
	bitend_pos2(p);											
}
#define DECLARE_BITINIT														
static void bitinit(bitstream* p,const uint8_t *stream, int len)			
{																			
	p->bits = 0;															
	p->bitpos = 32;															
	p->bitptr = stream;														
	p->bitend = stream+len+4;												
}
static INLINE void bitsetpos(bitstream* p,const uint8_t *stream)
{
	p->bitpos = 32;
	p->bitptr = stream;
}
#ifdef MIPS
static INLINE void bitloadinline(bitstream* p)
{
	int n = p->bitpos-8;
	if (n>=0)
	{
		const uint8_t* bitptr = p->bitptr;
		int bits = p->bits;
		do
		{
			bits = (bits << 8) | *bitptr++;
			n -= 8;
		}
		while (n>=0);
		p->bits = bits;
		p->bitptr = bitptr;
		p->bitpos = n+8;
	}
}
#else
#define bitloadinline(p) if ((p)->bitpos >= 8) bitload(p)
#endif
#endif

						