www.pudn.com > mp3_source.rar > common.c

#include  
#include  
#include  
#include "common.h" 
 
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} 
}; 
double  s_freq[4] = {44.1, 48, 32, 0}; 
char *mode_names[4] = { "stereo", "j-stereo", "dual-ch", "single-ch" }; 
 
 
FILE *OpenTableFile(char *name) 
{ 
	char fulname[80]; 
	FILE *f; 
 
	fulname[0] = '\0'; 
 
	strcat(fulname, name); 
	if( (f=fopen(fulname,"r"))==NULL ) { 
		fprintf(stderr,"\nOpenTable: could not find %s\n", fulname); 
    } 
    return f; 
} 
 
 
void WriteHdr(frame_params *fr_ps) 
{ 
	layer *info = fr_ps->header; 
 
	printf("HDR:  sync=FFF, id=%X, layer=%X, ep=%X, br=%X, sf=%X, pd=%X, ", 
		info->version, info->lay, !info->error_protection, 
		info->bitrate_index, info->sampling_frequency, info->padding); 
 
	printf("pr=%X, m=%X, js=%X, c=%X, o=%X, e=%X\n", 
		info->extension, info->mode, info->mode_ext, 
		info->copyright, info->original, info->emphasis); 
 
	printf("layer=%s, tot bitrate=%d, sfrq=%.1f, mode=%s, ", 
		layer_names[info->lay-1], bitrate[info->lay-1][info->bitrate_index], 
		s_freq[info->sampling_frequency], mode_names[info->mode]); 
 
	printf("sblim=%d, jsbd=%d, ch=%d\n", 
		fr_ps->sblimit, fr_ps->jsbound, fr_ps->stereo); 
} 
 
void *mem_alloc(unsigned long block, char *item) 
{ 
	void *ptr; 
	ptr = (void *)malloc((unsigned long)block); 
	if (ptr != NULL) 
		memset(ptr, 0, block); 
	else{ 
		printf("Unable to allocate %s\n", item); 
		exit(0); 
	} 
	return ptr; 
} 
 
/*open and initialize the buffer; */ 
void alloc_buffer(Bit_stream_struc *bs, int size) 
{ 
	bs->buf = (unsigned char *) mem_alloc(size*sizeof(unsigned char), "buffer"); 
	bs->buf_size = size; 
} 
 
void desalloc_buffer(Bit_stream_struc *bs) 
{ 
	free(bs->buf); 
} 
 
/* open the device to read the bit stream from it */ 
void open_bit_stream_r(Bit_stream_struc *bs, char *bs_filenam, int size) 
{ 
	register unsigned char flag = 1; 
 
	if ((bs->pt = fopen(bs_filenam, "rb")) == NULL) { 
		printf("Could not find \"%s\".\n", bs_filenam); 
		exit(1); 
	} 
 
	bs->format = BINARY; 
	alloc_buffer(bs, size); 
	bs->buf_byte_idx=0; 
	bs->buf_bit_idx=0; 
	bs->totbit=0; 
	bs->mode = READ_MODE; 
	bs->eob = FALSE; 
	bs->eobs = FALSE; 
} 
 
void close_bit_stream_r(Bit_stream_struc *bs) 
{ 
	fclose(bs->pt); 
	desalloc_buffer(bs); 
} 
 
/*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 end_bs(Bit_stream_struc *bs) 
{ 
  return(bs->eobs); 
} 
 
 
/*return the current bit stream length (in bits)*/ 
unsigned long sstell(Bit_stream_struc *bs) 
{ 
  return(bs->totbit); 
} 
 
 
void refill_buffer(Bit_stream_struc *bs) 
{ 
	register int i=bs->buf_size-2-bs->buf_byte_idx; 
	register unsigned long n=1; 
 
	while ((i>=0) && (!bs->eob)) { 
			n=fread(&bs->buf[i--], sizeof(unsigned char), 1, bs->pt); 
		if (!n) 
		bs->eob= i+1; 
	} 
} 
 
 
int mask[8]={0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80}; 
 
/*read 1 bit from the bit stream */ 
unsigned int get1bit(Bit_stream_struc *bs) 
{ 
   unsigned int bit; 
   register int i; 
 
   bs->totbit++; 
 
   if (!bs->buf_bit_idx) { 
        bs->buf_bit_idx = 8; 
        bs->buf_byte_idx--; 
        if ((bs->buf_byte_idx < MINIMUM) || (bs->buf_byte_idx < bs->eob)) { 
             if (bs->eob) 
                bs->eobs = TRUE; 
             else { 
                for (i=bs->buf_byte_idx; i>=0;i--) 
                  bs->buf[bs->buf_size-1-bs->buf_byte_idx+i] = bs->buf[i]; 
                refill_buffer(bs); 
                bs->buf_byte_idx = bs->buf_size-1; 
             } 
        } 
   } 
   bit = bs->buf[bs->buf_byte_idx]&mask[bs->buf_bit_idx-1]; 
   bit = bit >> (bs->buf_bit_idx-1); 
   bs->buf_bit_idx--; 
   return(bit); 
} 
 
int putmask[9]={0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff}; 
 
/*read N bit from the bit stream */ 
unsigned long getbits(Bit_stream_struc *bs, int N) 
{ 
	unsigned long val=0; 
	register int i; 
	register int j = N; 
	register int k, tmp; 
 
	if (N > MAX_LENGTH) 
		printf("Cannot read or write more than %d bits at a time.\n", MAX_LENGTH); 
 
	bs->totbit += N; 
	while (j > 0) { 
		if (!bs->buf_bit_idx) { 
			bs->buf_bit_idx = 8; 
			bs->buf_byte_idx--; 
			if ((bs->buf_byte_idx < MINIMUM) || (bs->buf_byte_idx < bs->eob)) { 
				if (bs->eob) 
					bs->eobs = TRUE; 
				else { 
					for (i=bs->buf_byte_idx; i>=0;i--) 
						bs->buf[bs->buf_size-1-bs->buf_byte_idx+i] = bs->buf[i]; 
						refill_buffer(bs); 
					bs->buf_byte_idx = bs->buf_size-1; 
				} 
			} 
		} 
		k = MIN(j, bs->buf_bit_idx); 
		tmp = bs->buf[bs->buf_byte_idx]&putmask[bs->buf_bit_idx]; 
		tmp = tmp >> (bs->buf_bit_idx-k); 
		val |= tmp << (j-k); 
		bs->buf_bit_idx -= k; 
		j -= k; 
	} 
	return val; 
} 
 
 
int seek_sync(Bit_stream_struc *bs, unsigned long sync, int N) 
{ 
	unsigned long aligning; 
	unsigned long val; 
	long maxi = (int)pow(2.0, (double)N) - 1; 
 
	aligning = sstell(bs)%ALIGNING; 
	if (aligning) 
		getbits(bs, (int)(ALIGNING-aligning)); 
 
	val = getbits(bs, N); 
	while (((val&maxi) != sync) && (!end_bs(bs))) { 
		val <<= ALIGNING; 
		val |= getbits(bs, ALIGNING); 
	} 
 
	if (end_bs(bs)) 
		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(frame_params *fr_ps) 
{ 
	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; 
} 
 
#define	BUFSIZE	4096 
static unsigned int buf[BUFSIZE]; 
static unsigned int buf_bit_idx=8; 
static unsigned long offset, totbit=0, buf_byte_idx=0; 
 
void hputbuf(unsigned int val, int N) 
{ 
	if (N != 8) { 
		printf("Not Supported yet!!\n"); 
		exit(-3); 
	} 
	buf[offset % BUFSIZE] = val; 
	offset++; 
} 
 
/*return the current bit stream length (in bits)*/ 
unsigned long hsstell() 
{ 
	return(totbit); 
} 
 
/*read N bit from the bit stream */ 
unsigned long hgetbits(int N) 
{ 
	unsigned long val=0; 
	register int j = N; 
	register int k, tmp; 
 
/* 
	 if (N > MAX_LENGTH) 
		 printf("Cannot read or write more than %d bits at a time.\n", MAX_LENGTH); 
*/ 
	totbit += N; 
	while (j > 0) { 
		if (!buf_bit_idx) { 
			buf_bit_idx = 8; 
			buf_byte_idx++; 
			if (buf_byte_idx > offset) { 
				printf("Buffer overflow !!\n"); 
				exit(3); 
			} 
		} 
		k = MIN(j, buf_bit_idx); 
		tmp = buf[buf_byte_idx%BUFSIZE]&putmask[buf_bit_idx]; 
		tmp = tmp >> (buf_bit_idx-k); 
		val |= tmp << (j-k); 
		buf_bit_idx -= k; 
		j -= k; 
	} 
	return(val); 
} 
 
 
unsigned int hget1bit() 
{ 
	return(hgetbits(1)); 
} 
 
 
void rewindNbits(int N) 
{ 
	totbit -= N; 
	buf_bit_idx += N; 
	while( buf_bit_idx >= 8 ){ 
		buf_bit_idx -= 8; 
		buf_byte_idx--; 
	} 
} 
 
 
void rewindNbytes(int N) 
{ 
	totbit -= N*8; 
	buf_byte_idx -= N; 
}