/* Returns the number of frames actually skipped, -1 on error.
*
* Values in header are not changed if retval!=nframes.
* This is not necessary because gethdr() doesn't clobber
* the contents of header, but I don't want to rely on that.
*/
int ffwd(struct AUDIO_HEADER *header, int nframes)
{
int cnt=0,g;
int hsize,bitrate,fs,mean_frame_size;
struct AUDIO_HEADER tmp;
memcpy(&tmp,header,sizeof(tmp));
while (cnt < nframes) {
if (tmp.ID)
if (tmp.mode==3) hsize=21;
else hsize=36;
else
if (tmp.mode==3) hsize=13;
else hsize=21;
if (tmp.protection_bit==0) hsize+=2;
if ((g=dummy_getinfo(hsize))) /* dummy_getinfo: reads hsize-4 bytes */
switch (g) {
case GETHDR_EOF: return cnt;
case GETHDR_ERR:
default: return -1;
}
bitrate=t_bitrate[tmp.ID][3-tmp.layer][tmp.bitrate_index];
fs=t_sampling_frequency[tmp.ID][tmp.sampling_frequency];
if (tmp.ID) mean_frame_size=144000*bitrate/fs;
else mean_frame_size=72000*bitrate/fs;
fillbfr(mean_frame_size + tmp.padding_bit - hsize);
if ((g=gethdr(&tmp)))
switch (g) {
case GETHDR_EOF: return cnt;
case GETHDR_ERR:
default: return -1;
}
cnt++;
}
memcpy(header,&tmp,sizeof(tmp));
return cnt;
}
int layer2_frame(struct AUDIO_HEADER *header,int cnt)
{
int i,s,sb,ch,gr,bitrate,bound=0;
char (*nbal)[],(*bit_alloc_index)[][16];
unsigned char allocation[2][32];
unsigned char scfsi[2][32];
float scalefactor[2][32][3];
float subband_sample[2][32][36];
int sblimit,nlevels,grouping;
float c,d;
int no_of_bits,mpi;
unsigned short sb_sample_buf[3];
int hsize,fs,mean_frame_size;
bit_alloc_index=&t_alloc0;
nbal=&t_nbal0; // shut up compiler
sblimit = 0;
hsize=4;
if (header->protection_bit==0) hsize+=2;
bitrate=t_bitrate[header->ID][3-header->layer][header->bitrate_index];
fs=t_sampling_frequency[header->ID][header->sampling_frequency];
if (header->ID) mean_frame_size=144000*bitrate/fs;
else mean_frame_size=72000*bitrate/fs;
/* layers 1 and 2 do not have a 'bit reservoir'
*/
append=data=0;
fillbfr(mean_frame_size + header->padding_bit - hsize);
switch (header->mode)
{
case 0 :
case 2 : nch=2; bound=32; bitrate=bitrate/2;
break;
case 3 : nch=1; bound=32;
break;
case 1 : nch=2; bitrate=bitrate/2; bound=(header->mode_extension+1)*4;
}
if (header->ID==1) switch (header->sampling_frequency) {
case 0 : switch (bitrate) /* 0 = 44.1 kHz */
{
case 56 :
case 64 :
case 80 : bit_alloc_index=&t_alloc0;
nbal=&t_nbal0;
sblimit=27;
break;
case 96 :
case 112 :
case 128 :
case 160 :
case 192 : bit_alloc_index=&t_alloc1;
nbal=&t_nbal1;
sblimit=30;
break;
case 32 :
case 48 : bit_alloc_index=&t_alloc2;
nbal=&t_nbal2;
sblimit=8;
break;
default : printf(" bit alloc info no gud ");
}
break;
case 1 : switch (bitrate) /* 1 = 48 kHz */
{
case 56 :
case 64 :
case 80 :
case 96 :
case 112 :
case 128 :
case 160 :
case 192 : bit_alloc_index=&t_alloc0;
nbal=&t_nbal0;
sblimit=27;
break;
case 32 :
case 48 : bit_alloc_index=&t_alloc2;
nbal=&t_nbal2;
sblimit=8;
break;
default : printf(" bit alloc info no gud ");
}
break;
case 2 : switch (bitrate) /* 2 = 32 kHz */
{
case 56 :
case 64 :
case 80 : bit_alloc_index=&t_alloc0;
nbal=&t_nbal0;
sblimit=27;
break;
case 96 :
case 112 :
case 128 :
case 160 :
case 192 : bit_alloc_index=&t_alloc1;
nbal=&t_nbal1;
sblimit=30;
break;
case 32 :
case 48 : bit_alloc_index=&t_alloc3;
nbal=&t_nbal3;
sblimit=12;
break;
default : printf("bit alloc info not ok\n");
}
break;
default : printf("sampling freq. not ok/n");
} else {
bit_alloc_index=&t_allocMPG2;
nbal=&t_nbalMPG2;
sblimit=30;
}
/*
* bit allocation per subband per channel decoding *****************************
*/
if (bound==32) bound=sblimit; /* bound=32 means there is no intensity stereo */
for (sb=0;sb<bound;sb++)
for (ch=0;ch<nch;ch++)
allocation[ch][sb]=getbits((*nbal)[sb]);
for (sb=bound;sb<sblimit;sb++)
allocation[1][sb] = allocation[0][sb] = getbits((*nbal)[sb]);
/*
* scfsi ***********************************************************************
*/
for (sb=0;sb<sblimit;sb++)
for (ch=0;ch<nch;ch++)
if (allocation[ch][sb]!=0) scfsi[ch][sb]=getbits(2);
else scfsi[ch][sb]=0;
/*
* scalefactors ****************************************************************
*/
for (sb=0;sb<sblimit;sb++)
for (ch=0;ch<nch;ch++)
if (allocation[ch][sb]!=0) {
scalefactor[ch][sb][0]=t_scalefactor[getbits(6)];
switch (scfsi[ch][sb])
{
case 0: scalefactor[ch][sb][1]=t_scalefactor[getbits(6)];
scalefactor[ch][sb][2]=t_scalefactor[getbits(6)];
break;
case 1: scalefactor[ch][sb][2]=t_scalefactor[getbits(6)];
scalefactor[ch][sb][1]=scalefactor[ch][sb][0];
break;
case 2: scalefactor[ch][sb][1]=scalefactor[ch][sb][0];
scalefactor[ch][sb][2]=scalefactor[ch][sb][0];
break;
case 3: scalefactor[ch][sb][2]=t_scalefactor[getbits(6)];
scalefactor[ch][sb][1]=scalefactor[ch][sb][2];
}
}
else scalefactor[ch][sb][0]=scalefactor[ch][sb][1]=\
scalefactor[ch][sb][2]=0.0;
/*
* samples *********************************************************************
*/
for (gr=0;gr<12;gr++) {
/*
* normal ********************************
*/
for (sb=0;sb<bound;sb++)
for (ch=0;ch<nch;ch++)
if (allocation[ch][sb]!=0) {
mpi=(*bit_alloc_index)[sb][allocation[ch][sb]];
no_of_bits=t_bpc[mpi];
c=t_c[mpi];
d=t_d[mpi];
grouping=t_grouping[mpi];
nlevels=t_nlevels[mpi];
if (grouping) {
int samplecode=getbits(no_of_bits);
convert_samplecode(samplecode,grouping,sb_sample_buf);
for (s=0;s<3;s++)
subband_sample[ch][sb][3*gr+s]=requantize_sample (sb_sample_buf[s],nlevels,c,d,scalefactor[ch][sb][gr/4]);
} else {
for (s=0;s<3;s++) sb_sample_buf[s]=getbits(no_of_bits);
for (s=0;s<3;s++) {
/*subband_sample[ch][sb][3*gr+s]=requantize_sample (sb_sample_buf[s],nlevels,c,d,scalefactor[ch][sb][gr/4]);*/
subband_sample[ch][sb][3*gr+s]=(t_dd[mpi]+sb_sample_buf[s]*t_nli[mpi])*c*scalefactor[ch][sb][gr>>2];
}
}
} else
for (s=0;s<3;s++) subband_sample[ch][sb][3*gr+s]=0;
/* this function decodes one layer3 audio frame, except for the header decoding
* which is done in main() [audio.c]. returns 0 if everything is ok.
*/
int layer3_frame(struct AUDIO_HEADER *header,int cnt)
{
static struct SIDE_INFO info;
int gr,ch,sb,i;
int mean_frame_size,bitrate,fs,hsize,ssize;
/* we need these later, hsize is the size of header+side_info
*/
if (header->ID)
if (header->mode==3) {
nch=1;
hsize=21;
} else {
nch=2;
hsize=36;
}
else
if (header->mode==3) {
nch=1;
hsize=13;
} else {
nch=2;
hsize=21;
}
/* crc increases hsize by 2
*/
if (header->protection_bit==0) hsize+=2;
/* read layer3 specific side_info
*/
getinfo(header,&info);
/* MPEG2 only has one granule
*/
bitrate=t_bitrate[header->ID][3-header->layer][header->bitrate_index];
fs=t_sampling_frequency[header->ID][header->sampling_frequency];
if (header->ID) mean_frame_size=144000*bitrate/fs;
else mean_frame_size=72000*bitrate/fs;
/* check if mdb is too big for the first few frames. this means that
* a part of the stream could be missing. We must still fill the buffer
*
* don't forget to (re)initialise bclean_bytes to 0, and f_bdirty to FALSE!!!
*/
if (f_bdirty)
if (info.main_data_begin > bclean_bytes) {
fillbfr(mean_frame_size + header->padding_bit - hsize);
bclean_bytes+=mean_frame_size + header->padding_bit - hsize;
/* warn(" frame %d discarded, incomplete main_data\n",cnt); */
return 0;
} else {
/* re-initialise */
f_bdirty=FALSE;
bclean_bytes=0;
}
/* now update the data 'pointer' (counting in bits) according to
* the main_data_begin information
*/
data = 8 * ((append - info.main_data_begin) & (BUFFER_SIZE-1));
/* read into the buffer all bytes up to the start of next header
*/
fillbfr(mean_frame_size + header->padding_bit - hsize);
/* these two should go away
*/
t_l=&t_b8_l[header->ID][header->sampling_frequency][0];
t_s=&t_b8_s[header->ID][header->sampling_frequency][0];
/* debug/dump stuff
*/
if (A_DUMP_BINARY) dump((int *)info.part2_3_length);
/* decode the scalefactors and huffman data
* this part needs to be enhanced for error robustness
*/
for (gr=0;gr < ((header->ID) ? 2 : 1);gr++) {
for (ch=0;ch<nch;ch++) {
ssize=decode_scalefactors(&info,header,gr,ch);
decode_huffman_data(&info,gr,ch,ssize);
}
/* requantization, stereo processing, reordering(shortbl)
*/
if (A_DOWNMIX && nch==2) requantize_downmix(gr,&info,header);
else
if (header->mode!=1 || (header->mode==1 && header->mode_extension==0))
for (ch=0;ch<nch;ch++) requantize_mono(gr,ch,&info,header);
else requantize_ms(gr,&info,header);
/* just which window?
*/
/* this is a very temporary, very ugly hack.
*/
if (A_DOWNMIX) nch=1;
for (ch=0; ch < (A_DOWNMIX ? 1:nch) ;ch++) {
int win_type; /* same as in the standard, long=0, start=1 ,.... */
int window_switching_flag = info.window_switching_flag[gr][ch];
int block_type = info.block_type[gr][ch];
int mixed_block_flag = info.mixed_block_flag[gr][ch];
/* antialiasing butterflies
*/
if (!(window_switching_flag &&
block_type==2))
alias_reduction(ch);
if (window_switching_flag &&
block_type==2 &&
mixed_block_flag)
win_type=0;
else
if (!window_switching_flag) win_type=0;
else win_type=block_type;
/* imdct ...
*/
for (sb=0;sb<2;sb++)
imdct(win_type,sb,ch);
if (window_switching_flag &&
block_type==2 &&
mixed_block_flag)
win_type=2;
/* no_of_imdcts tells us how many subbands from the top are all zero
* it is set by the requantize functions in misc2.c
*/
for (sb=2;sb<no_of_imdcts[ch];sb++)
imdct(win_type,sb,ch);
for (;sb<32;sb++)
for (i=0;i<18;i++) {
res[sb][i]=s[ch][sb][i];
s[ch][sb][i]=0.0f;
}
/* polyphase filterbank
*/
/* if (nch == 2) this was a bug, tomislav */
for (i=0;i<18;i++)
poly(ch,i);
}
printout();
/* this is part2 of a particularily ugly hack. this should vanish as soon as nch isn't
a global variable anymore
*/
if (A_DOWNMIX && header->mode!=3) nch=2;
} /* for (gr... */
/* return status: 0 for ok, errors will be added
*/
return 0;
}
