www.pudn.com > mp3decoder.rar > COMMON.C

/*********************************************** 
copyright by Haia Tech 
www.haia2004.com 
************************************************/ 
 
 
 
#include  
#include  
#include  
#include  
#include "common.h" 
  
//extern FILE *file_p;  
FILE *file_p;  
extern frame_params fr_ps;  
extern unsigned int   frameNum; 
Bit_stream_struc  bs; 
unsigned short *mp3_dat; 
 
 
double  s_freq[4] = {44.1, 48, 32, 0}; 
char *mode_names[4] = { "stereo", "j-stereo", "dual-ch", "single-ch" }; 
 
char *layer_names[3] = { "I", "II", "III" }; 
 
int bitrate[3][15] = { 
	{0,32,64,96,128,160,192,224,256,288,320,352,384,416,448}, 
	{0,32,48,56,64,80,96,112,128,160,192,224,256,320,384}, 
	{0,32,40,48,56,64,80,96,112,128,160,192,224,256,320} 
}; 
 
unsigned short buffer[BUFFER_SIZE]; 
 
 
/* open the device to read the bit stream from it */ 
void open_bit_stream_r() 
{ 
	bs.buf=buffer; 
	bs.read_ptr=0; 
	bs.write_ptr=0; 
	bs.bit_len=16; 
	bs.totbit=0; 
	bs.eof = FALSE; 
	bs.eobs = FALSE; 
	quest_stream(&bs.write_ptr); 
} 
 
 
/*return the status of the bit stream*/ 
/* returns 1 if end of bit stream was reached */ 
/* returns 0 if end of bit stream was not reached */ 
 
int mask[8]={0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80}; 
 
int seek_sync(unsigned int sync) 
{ 
	unsigned int aligning; 
	unsigned int val; 
 
    aligning = bs.totbit%ALIGNING; 
    if (aligning) 
		getbit((int)(ALIGNING-aligning));   //×Ö½Ú¶ÔÆë 
 
    val = getbit(12); 
	while( ((val&0xfff)!= sync) && (!bs.eobs)) 
	{ 
		val<<=ALIGNING; 
		val|=getbit(ALIGNING); 
	} 
 
	if (bs.eobs) 
		return(0); 
	else 
		return(1); 
} 
 
int js_bound(int lay, int m_ext) 
{ 
	static int jsb_table[3][4] =  { 
		{ 4, 8, 12, 16 }, 
		{ 4, 8, 12, 16}, 
		{ 0, 4, 8, 16} 
	};  /* lay+m_e -> jsbound */ 
 
 //   if(lay<1 || lay >3 || m_ext<0 || m_ext>3) { 
 //       fprintf(stderr, "js_bound bad layer/modext (%d/%d)\n", lay, m_ext); 
 //       exit(1); 
//    } 
	return(jsb_table[lay-1][m_ext]); 
} 
 
/* interpret data in hdr str to fields in fr_ps */ 
void hdr_to_frps()  
{ 
	layer *hdr = fr_ps.header;     /* (or pass in as arg?) */ 
 
	fr_ps.actual_mode = hdr->mode; 
	fr_ps.stereo = (hdr->mode == MPG_MD_MONO) ? 1 : 2; 
	fr_ps.sblimit = SBLIMIT; 
	if(hdr->mode == MPG_MD_JOINT_STEREO) 
		fr_ps.jsbound = js_bound(hdr->lay, hdr->mode_ext); 
	else 
		fr_ps.jsbound = fr_ps.sblimit; 
} 
  
 
int putmask[9]={0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff}; 
 
 
/*read N bit from the bit stream */ 
unsigned int getbit(int N) 
{ 
	unsigned short val=0; 
	unsigned long  word; 
	register unsigned int n = N; 
    unsigned short x1,x2; 
 
	bs.totbit += n; 
    if (bs.bit_len<=n) 
	{ 
		x1=bs.buf[bs.read_ptr]; 
		x2=bs.buf[(++bs.read_ptr)%BUFFER_SIZE];     
		word=(x1<<16)|x2; 
//  	    word=bs.buf[bs.read_ptr]<<16|bs.buf[(++bs.read_ptr)%BUFFER_SIZE];  //???  !!!! 
		word=word<<(16-bs.bit_len); 
		val=(short)(word>>(32-n));   
		bs.bit_len =16+bs.bit_len-n ; 
		if(bs.bit_len==0) 
			bs.bit_len=16; 
	    bs.read_ptr%=BUFFER_SIZE; 
	} 
    else 
	{ 
		val=bs.buf[bs.read_ptr]<<(16-bs.bit_len); 
		val=val>>(16-n); 
		bs.bit_len -=n ; 
	} 
	if(bs.read_ptr>bs.write_ptr) 
	{ 
	  if(bs.read_ptr-bs.write_ptr>ETHER_SIZE) 
		 quest_stream(&bs.write_ptr); 
	} 
	else 
	{ 
	  if(BUFFER_SIZE-(bs.write_ptr-bs.read_ptr)>ETHER_SIZE) 
		 quest_stream(&bs.write_ptr); 
	} 
	return val; 
} 
 
void quest_stream(unsigned int *ptr) 
{ 
	register int i; 
	unsigned char temp[2]; 
	for (i=0;i