/***********************************************
copyright by Haia Tech
www.haia2004.com
************************************************/



#include <string.h>
//#include <stdlib.h>
#include <math.h>
#include "common.h"
 
//extern 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));   //字節(jié)對齊

    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<ETHER_SIZE;i++)
	{
 	    bs.eof=0;
		if(fread(temp, sizeof(unsigned char), 2, file_p))
		{
		  bs.buf[*ptr]=temp[0]<<8|temp[1];
		  (*ptr)++;
		  (*ptr)%=BUFFER_SIZE;
		}
		else 
			bs.eobs=1;
	}
}
*/

void quest_stream(unsigned int *ptr)
{
	register int i;
	unsigned char temp[2];
	for (i=0;i<ETHER_SIZE;i++)
	{
 	    bs.eof=0;
        if(frameNum<1000)
		{
		  bs.buf[*ptr]=*mp3_dat++;
		  (*ptr)++;
		  (*ptr)%=BUFFER_SIZE;
		}

		else 
			bs.eobs=1;
	}
}