1  /********************************************************************** <BR>


2  This file is part of Crack dot Com's free source code release of


3  Golgotha. <a href="http://www.crack.com/golgotha_release"> <BR> for


4  information about compiling & licensing issues visit this URL</a>


5  <PRE> If that doesn't help, contact Jonathan Clark at


6  golgotha_source@usa.net (Subject should have "GOLG" in it)


7  ***********************************************************************/


8 


9  /*


10  * Mpeg Layer3 audio decoder


11  * 


12  * copyright (c) 1995,1996,1997 by Michael Hipp.


13  * All rights reserved. See also 'README'


14  *


15  *  I'm currently working on that .. needs a few more optimizations,


16  * though the code is now fast enough to run in realtime on a 100Mhz 486


17  *  a few personal notes are in german ..


18  *


19  * used source:


20  * mpeg1_iis package


21  */


22 


23  #include "loaders/mp3/mpg123.hh"


24  #include "loaders/mp3/huffman.hh"


25 


26  #if 0


27  #include "loaders/mp3/get1bit.hh"


28  #endif


29 


30  static real ispow[8207];


31  static real aa_ca[8],aa_cs[8];


32  static real COS1[12][6];


33  static real win[4][36];


34  static real win1[4][36];


35  static real gainpow2[256+118+4];


36  static real COS9[9];


37  static real COS6_1,COS6_2;


38  static real tfcos36[9];


39  static real tfcos12[3];


40  #ifdef NEW_DCT9


41  static real cos9[3],cos18[3];


42  #endif


43 


44  struct bandInfoStruct {


45  int longIdx[23];


46  int longDiff[22];


47  int shortIdx[14];


48  int shortDiff[13];


49  };


50 


51  int longLimit[7][23];


52  int shortLimit[7][14];


53 


54  struct bandInfoStruct bandInfo[7] = {


55 


56  /* MPEG 1.0 */


57  { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},


58  {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},


59  {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},


60  {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,


61 


62  { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},


63  {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},


64  {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},


65  {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,


66 


67  { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,


68  {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,


69  {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,


70  {4,4,4,4,6,8,12,16,20,26,34,42,12} } ,


71 


72  /* MPEG 2.0 */


73  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},


74  {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,


75  {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,


76  {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,


77 


78  { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},


79  {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } ,


80  {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,


81  {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,


82 


83  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},


84  {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },


85  {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},


86  {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,


87 


88  /* MPEG 2.5, wrong! table (it's just a copy of MPEG 2.0/44.1kHz) */


89  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},


90  {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,


91  {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,


92  {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,


93  };


94 


95  static int mapbuf0[7][152];


96  static int mapbuf1[7][156];


97  static int mapbuf2[7][44];


98  static int *map[7][3];


99  static int *mapend[7][3];


100 


101  static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */


102  static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */


103 


104  static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];


105  static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];


106 


107  static real block[2][2][SBLIMIT*SSLIMIT] = { { { 0, } } };


108  static int blc[2]={0,0};


109 


110  /*


111  * init tables for layer3


112  */


113  void init_layer3(int down_samp)


114  {


115  int i,j,k,l;


116 


117  memset(block, 0, sizeof(block));


118  memset(blc, 0, sizeof(blc));


119 


120  for(i=256;i<118+4;i++)


121  gainpow2[i+256] = pow((double)2.0,0.25 * (double) (i+210) );


122 


123  for(i=0;i<8207;i++)


124  ispow[i] = pow((double)i,(double)4.0/3.0);


125 


126  for (i=0;i<8;i++)


127  {


128  static double Ci[8]={0.6,0.535,0.33,0.185,0.095,0.041,0.0142,0.0037};


129  double sq=sqrt(1.0+Ci[i]*Ci[i]);


130  aa_cs[i] = 1.0/sq;


131  aa_ca[i] = Ci[i]/sq;


132  }


133 


134  for(i=0;i<18;i++)


135  {


136  win[0][i] = win[1][i] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 );


137  win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );


138  }


139  for(i=0;i<6;i++)


140  {


141  win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );


142  win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );


143  win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 );


144  win[1][i+30] = win[3][i] = 0.0;


145  win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 );


146  }


147 


148  for(i=0;i<9;i++)


149  COS9[i] = cos( M_PI / 18.0 * (double) i);


150 


151  for(i=0;i<9;i++)


152  tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );


153  for(i=0;i<3;i++)


154  tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );


155 


156  COS6_1 = cos( M_PI / 6.0 * (double) 1);


157  COS6_2 = cos( M_PI / 6.0 * (double) 2);


158 


159  #ifdef NEW_DCT9


160  cos9[0] = cos(1.0*M_PI/9.0);


161  cos9[1] = cos(5.0*M_PI/9.0);


162  cos9[2] = cos(7.0*M_PI/9.0);


163  cos18[0] = cos(1.0*M_PI/18.0);


164  cos18[1] = cos(11.0*M_PI/18.0);


165  cos18[2] = cos(13.0*M_PI/18.0);


166  #endif


167 


168  for(i=0;i<12;i++)


169  {


170  win[2][i] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );


171  for(j=0;j<6;j++)


172  COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );


173  }


174 


175  for(j=0;j<4;j++) {


176  static int len[4] = { 36,36,12,36 };


177  for(i=0;i<len[j];i+=2)


178  win1[j][i] = + win[j][i];


179  for(i=1;i<len[j];i+=2)


180  win1[j][i] =  win[j][i];


181  }


182 


183  for(i=0;i<16;i++)


184  {


185  double t = tan( (double) i * M_PI / 12.0 );


186  tan1_1[i] = t / (1.0+t);


187  tan2_1[i] = 1.0 / (1.0 + t);


188  tan1_2[i] = M_SQRT2 * t / (1.0+t);


189  tan2_2[i] = M_SQRT2 / (1.0 + t);


190 


191  for(j=0;j<2;j++) {


192  double base = pow(2.0,0.25*(j+1.0));


193  double p1=1.0,p2=1.0;


194  if(i > 0) {


195  if( i & 1 )


196  p1 = pow(base,(i+1.0)*0.5);


197  else


198  p2 = pow(base,i*0.5);


199  }


200  pow1_1[j][i] = p1;


201  pow2_1[j][i] = p2;


202  pow1_2[j][i] = M_SQRT2 * p1;


203  pow2_2[j][i] = M_SQRT2 * p2;


204  }


205  }


206 


207  for(j=0;j<7;j++)


208  {


209  struct bandInfoStruct *bi = &bandInfo[j];


210  int *mp;


211  int cb,lwin;


212  int *bdf;


213 


214  mp = map[j][0] = mapbuf0[j];


215  bdf = bi>longDiff;


216  for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {


217  *mp++ = (*bdf) >> 1;


218  *mp++ = i;


219  *mp++ = 3;


220  *mp++ = cb;


221  }


222  bdf = bi>shortDiff+3;


223  for(cb=3;cb<13;cb++) {


224  int l = (*bdf++) >> 1;


225  for(lwin=0;lwin<3;lwin++) {


226  *mp++ = l;


227  *mp++ = i + lwin;


228  *mp++ = lwin;


229  *mp++ = cb;


230  }


231  i += 6*l;


232  }


233  mapend[j][0] = mp;


234 


235  mp = map[j][1] = mapbuf1[j];


236  bdf = bi>shortDiff+0;


237  for(i=0,cb=0;cb<13;cb++) {


238  int l = (*bdf++) >> 1;


239  for(lwin=0;lwin<3;lwin++) {


240  *mp++ = l;


241  *mp++ = i + lwin;


242  *mp++ = lwin;


243  *mp++ = cb;


244  }


245  i += 6*l;


246  }


247  mapend[j][1] = mp;


248 


249  mp = map[j][2] = mapbuf2[j];


250  bdf = bi>longDiff;


251  for(cb = 0; cb < 22 ; cb++) {


252  *mp++ = (*bdf++) >> 1;


253  *mp++ = cb;


254  }


255  mapend[j][2] = mp;


256 


257  }


258 


259  for(j=0;j<7;j++) {


260  for(i=0;i<23;i++) {


261  longLimit[j][i] = (bandInfo[j].longIdx[i]  1 + 8) / 18 + 1;


262  if(longLimit[j][i] > (SBLIMIT >> down_samp) )


263  longLimit[j][i] = SBLIMIT >> down_samp;


264  }


265  for(i=0;i<14;i++) {


266  shortLimit[j][i] = (bandInfo[j].shortIdx[i]  1) / 18 + 1;


267  if(shortLimit[j][i] > (SBLIMIT >> down_samp) )


268  shortLimit[j][i] = SBLIMIT >> down_samp;


269  }


270  }


271 


272  for(i=0;i<5;i++) {


273  for(j=0;j<6;j++) {


274  for(k=0;k<6;k++) {


275  int n = k + j * 6 + i * 36;


276  i_slen2[n] = i(j<<3)(k<<6)(3<<12);


277  }


278  }


279  }


280  for(i=0;i<4;i++) {


281  for(j=0;j<4;j++) {


282  for(k=0;k<4;k++) {


283  int n = k + j * 4 + i * 16;


284  i_slen2[n+180] = i(j<<3)(k<<6)(4<<12);


285  }


286  }


287  }


288  for(i=0;i<4;i++) {


289  for(j=0;j<3;j++) {


290  int n = j + i * 3;


291  i_slen2[n+244] = i(j<<3)  (5<<12);


292  n_slen2[n+500] = i(j<<3)  (2<<12)  (1<<15);


293  }


294  }


295 


296  for(i=0;i<5;i++) {


297  for(j=0;j<5;j++) {


298  for(k=0;k<4;k++) {


299  for(l=0;l<4;l++) {


300  int n = l + k * 4 + j * 16 + i * 80;


301  n_slen2[n] = i(j<<3)(k<<6)(l<<9)(0<<12);


302  }


303  }


304  }


305  }


306  for(i=0;i<5;i++) {


307  for(j=0;j<5;j++) {


308  for(k=0;k<4;k++) {


309  int n = k + j * 4 + i * 20;


310  n_slen2[n+400] = i(j<<3)(k<<6)(1<<12);


311  }


312  }


313  }


314  }


315 


316  /*


317  * read additional side information


318  */


319  static void III_get_side_info_1(struct III_sideinfo *si,int stereo,


320  int ms_stereo,long sfreq,int single)


321  {


322  int ch, gr;


323  int powdiff = (single == 3) ? 4 : 0;


324 


325  si>main_data_begin = getbits(9);


326  if (stereo == 1)


327  si>private_bits = getbits_fast(5);


328  else


329  si>private_bits = getbits_fast(3);


330 


331  for (ch=0; ch<stereo; ch++) {


332  si>ch[ch].gr[0].scfsi = 1;


333  si>ch[ch].gr[1].scfsi = getbits_fast(4);


334  }


335 


336  for (gr=0; gr<2; gr++)


337  {


338  for (ch=0; ch<stereo; ch++)


339  {


340  III_sideinfo::what_the::gr_info_s *gr_info = (III_sideinfo::what_the::gr_info_s *)(&(si>ch[ch].gr[gr]));


341 


342  gr_info>part2_3_length = getbits(12);


343  gr_info>big_values = getbits_fast(9);


344  gr_info>pow2gain = gainpow2+256  getbits_fast(8) + powdiff;


345  if(ms_stereo)


346  gr_info>pow2gain += 2;


347  gr_info>scalefac_compress = getbits_fast(4);


348  /* windowswitching flag == 1 for block_Type != 0 .. and blocktype == 0 > winswflag = 0 */


349  if(get1bit())


350  {


351  int i;


352  gr_info>block_type = getbits_fast(2);


353  gr_info>mixed_block_flag = get1bit();


354  gr_info>table_select[0] = getbits_fast(5);


355  gr_info>table_select[1] = getbits_fast(5);


356  /*


357  * table_select[2] not needed, because there is no region2,


358  * but to satisfy some verifications tools we set it either.


359  */


360  gr_info>table_select[2] = 0;


361  for(i=0;i<3;i++)


362  gr_info>full_gain[i] = gr_info>pow2gain + (getbits_fast(3)<<3);


363 


364  if(gr_info>block_type == 0) {


365  exit(1);


366  }


367  /* region_count/start parameters are implicit in this case. */


368  gr_info>region1start = 36>>1;


369  gr_info>region2start = 576>>1;


370  }


371  else


372  {


373  int i,r0c,r1c;


374  for (i=0; i<3; i++)


375  gr_info>table_select[i] = getbits_fast(5);


376  r0c = getbits_fast(4);


377  r1c = getbits_fast(3);


378  gr_info>region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;


379  gr_info>region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;


380  gr_info>block_type = 0;


381  gr_info>mixed_block_flag = 0;


382  }


383  gr_info>preflag = get1bit();


384  gr_info>scalefac_scale = get1bit();


385  gr_info>count1table_select = get1bit();


386  }


387  }


388  }


389 


390  /*


391  * Side Info for MPEG 2.0 / LSF


392  */


393  static void III_get_side_info_2(struct III_sideinfo *si,int stereo,


394  int ms_stereo,long sfreq,int single)


395  {


396  int ch;


397  int powdiff = (single == 3) ? 4 : 0;


398 


399  si>main_data_begin = getbits(8);


400  if (stereo == 1)


401  si>private_bits = get1bit();


402  else


403  si>private_bits = getbits_fast(2);


404 


405  for (ch=0; ch<stereo; ch++)


406  {


407  III_sideinfo::what_the::gr_info_s *gr_info = (III_sideinfo::what_the::gr_info_s *)&(si>ch[ch].gr[0]);


408 


409  gr_info>part2_3_length = getbits(12);


410  gr_info>big_values = getbits_fast(9);


411  gr_info>pow2gain = gainpow2+256  getbits_fast(8) + powdiff;


412  if(ms_stereo)


413  gr_info>pow2gain += 2;


414  gr_info>scalefac_compress = getbits(9);


415  /* windowswitching flag == 1 for block_Type != 0 .. and blocktype == 0 > winswflag = 0 */


416  if(get1bit())


417  {


418  int i;


419  gr_info>block_type = getbits_fast(2);


420  gr_info>mixed_block_flag = get1bit();


421  gr_info>table_select[0] = getbits_fast(5);


422  gr_info>table_select[1] = getbits_fast(5);


423  /*


424  * table_select[2] not needed, because there is no region2,


425  * but to satisfy some verifications tools we set it either.


426  */


427  gr_info>table_select[2] = 0;


428  for(i=0;i<3;i++)


429  gr_info>full_gain[i] = gr_info>pow2gain + (getbits_fast(3)<<3);


430 


431  if(gr_info>block_type == 0) {


432  exit(1);


433  }


434  /* region_count/start parameters are implicit in this case. */


435  /* check this again! */


436  if(gr_info>block_type == 2)


437  gr_info>region1start = 36>>1;


438  else {


439  gr_info>region1start = 54>>1;


440  }


441  gr_info>region2start = 576>>1;


442  }


443  else


444  {


445  int i,r0c,r1c;


446  for (i=0; i<3; i++)


447  gr_info>table_select[i] = getbits_fast(5);


448  r0c = getbits_fast(4);


449  r1c = getbits_fast(3);


450  gr_info>region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;


451  gr_info>region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;


452  gr_info>block_type = 0;


453  gr_info>mixed_block_flag = 0;


454  }


455  gr_info>scalefac_scale = get1bit();


456  gr_info>count1table_select = get1bit();


457  }


458  }


459 


460  /*


461  * read scalefactors


462  */


463  static int III_get_scale_factors_1(int *scf,struct III_sideinfo::what_the::gr_info_s *gr_info)


464  {


465  static unsigned char slen[2][16] = {


466  {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},


467  {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}


468  };


469  int numbits;


470  int num0 = slen[0][gr_info>scalefac_compress];


471  int num1 = slen[1][gr_info>scalefac_compress];


472 


473  if (gr_info>block_type == 2)


474  {


475  int i=18;


476  numbits = (num0 + num1) * 18;


477 


478  if (gr_info>mixed_block_flag) {


479  for (i=8;i;i)


480  *scf++ = getbits_fast(num0);


481  i = 9;


482  numbits = num0; /* num0 * 17 + num1 * 18 */


483  }


484 


485  for (;i;i)


486  *scf++ = getbits_fast(num0);


487  for (i = 18; i; i)


488  *scf++ = getbits_fast(num1);


489  *scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */


490  }


491  else


492  {


493  int i;


494  int scfsi = gr_info>scfsi;


495 


496  if(scfsi < 0) { /* scfsi < 0 => granule == 0 */


497  for(i=11;i;i)


498  *scf++ = getbits_fast(num0);


499  for(i=10;i;i)


500  *scf++ = getbits_fast(num1);


501  numbits = (num0 + num1) * 10 + num0;


502  }


503  else {


504  numbits = 0;


505  if(!(scfsi & 0x8)) {


506  for (i=6;i;i)


507  *scf++ = getbits_fast(num0);


508  numbits += num0 * 6;


509  }


510  else {


511  *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */


512  *scf++ = 0; *scf++ = 0; *scf++ = 0;


513  }


514 


515  if(!(scfsi & 0x4)) {


516  for (i=5;i;i)


517  *scf++ = getbits_fast(num0);


518  numbits += num0 * 5;


519  }


520  else {


521  *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */


522  *scf++ = 0; *scf++ = 0;


523  }


524 


525  if(!(scfsi & 0x2)) {


526  for(i=5;i;i)


527  *scf++ = getbits_fast(num1);


528  numbits += num1 * 5;


529  }


530  else {


531  *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */


532  *scf++ = 0; *scf++ = 0;


533  }


534 


535  if(!(scfsi & 0x1)) {


536  for (i=5;i;i)


537  *scf++ = getbits_fast(num1);


538  numbits += num1 * 5;


539  }


540  else {


541  *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */


542  *scf++ = 0; *scf++ = 0;


543  }


544  }


545 


546  *scf++ = 0; /* no l[21] in original sources */


547  }


548  return numbits;


549  }


550 


551  static int III_get_scale_factors_2(int *scf, III_sideinfo::what_the::gr_info_s *gr_info,int i_stereo)


552  {


553  unsigned char *pnt;


554  int i,j;


555  unsigned int slen;


556  int n = 0;


557  int numbits = 0;


558 


559  static unsigned char stab[3][6][4] = {


560  { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,


561  { 7, 7, 7,0 } , { 6, 6, 6,3 } , { 8, 8,5,0} } ,


562  { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,


563  {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,


564  { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,


565  { 6,15,12,0 } , { 6,12, 9,6 } , { 6,18,9,0} } };


566 


567  if(i_stereo) /* i_stereo AND second channel > do_layer3() checks this */


568  slen = i_slen2[gr_info>scalefac_compress>>1];


569  else


570  slen = n_slen2[gr_info>scalefac_compress];


571 


572  gr_info>preflag = (slen>>15) & 0x1;


573 


574  n = 0;


575  if( gr_info>block_type == 2 ) {


576  n++;


577  if(gr_info>mixed_block_flag)


578  n++;


579  }


580 


581  pnt = stab[n][(slen>>12)&0x7];


582 


583  for(i=0;i<4;i++) {


584  int num = slen & 0x7;


585  slen >>= 3;


586  if(num) {


587  for(j=0;j<pnt[i];j++)


588  *scf++ = getbits(num);


589  numbits += pnt[i] * num;


590  }


591  else {


592  for(j=0;j<pnt[i];j++)


593  *scf++ = 0;


594  }


595  }


596 


597  n = (n << 1) + 1;


598  for(i=0;i<n;i++)


599  *scf++ = 0;


600 


601  return numbits;


602  }


603 


604  static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};


605  static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};


606 


607  /*


608  * don't forget to apply the same changes to III_dequantize_sample_ms() !!!


609  */


610  static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf,


611  III_sideinfo::what_the::gr_info_s *gr_info,int sfreq,int part2bits)


612  {


613  int shift = 1 + gr_info>scalefac_scale;


614  real *xrpnt = (real *) xr;


615  int l[3],l3;


616  int part2remain = gr_info>part2_3_length  part2bits;


617  int *me;


618 


619  {


620  int bv = gr_info>big_values;


621  int region1 = gr_info>region1start;


622  int region2 = gr_info>region2start;


623 


624  l3 = ((576>>1)bv)>>1;


625  /*


626  * we may lose the 'odd' bit here !!


627  * check this later again


628  */


629  if(bv <= region1) {


630  l[0] = bv; l[1] = 0; l[2] = 0;


631  }


632  else {


633  l[0] = region1;


634  if(bv <= region2) {


635  l[1] = bv  l[0]; l[2] = 0;


636  }


637  else {


638  l[1] = region2  l[0]; l[2] = bv  region2;


639  }


640  }


641  }


642 


643  if(gr_info>block_type == 2) {


644  /*


645  * decoding with short or mixed mode BandIndex table


646  */


647  int i,max[4];


648  int step=0,lwin=0,cb=0;


649  register real v = 0.0;


650  register int *m,mc;


651 


652  if(gr_info>mixed_block_flag) {


653  max[3] = 1;


654  max[0] = max[1] = max[2] = 2;


655  m = map[sfreq][0];


656  me = mapend[sfreq][0];


657  }


658  else {


659  max[0] = max[1] = max[2] = max[3] = 1;


660  /* max[3] not really needed in this case */


661  m = map[sfreq][1];


662  me = mapend[sfreq][1];


663  }


664 


665  mc = 0;


666  for(i=0;i<2;i++) {


667  int lp = l[i];


668  struct newhuff *h = ht+gr_info>table_select[i];


669  for(;lp;lp,mc) {


670  register int x,y;


671  if( (!mc) ) {


672  mc = *m++;


673  xrpnt = ((real *) xr) + (*m++);


674  lwin = *m++;


675  cb = *m++;


676  if(lwin == 3) {


677  v = gr_info>pow2gain[(*scf++) << shift];


678  step = 1;


679  }


680  else {


681  v = gr_info>full_gain[lwin][(*scf++) << shift];


682  step = 3;


683  }


684  }


685  {


686  register short *val = h>table;


687  while((y=*val++)<0) {


688  if (get1bit())


689  val = y;


690  part2remain;


691  }


692  x = y >> 4;


693  y &= 0xf;


694  }


695  if(x == 15) {


696  max[lwin] = cb;


697  part2remain = h>linbits+1;


698  x += getbits(h>linbits);


699  if(get1bit())


700  *xrpnt = ispow[x] * v;


701  else


702  *xrpnt = ispow[x] * v;


703  }


704  else if(x) {


705  max[lwin] = cb;


706  if(get1bit())


707  *xrpnt = ispow[x] * v;


708  else


709  *xrpnt = ispow[x] * v;


710  part2remain;


711  }


712  else


713  *xrpnt = 0.0;


714  xrpnt += step;


715  if(y == 15) {


716  max[lwin] = cb;


717  part2remain = h>linbits+1;


718  y += getbits(h>linbits);


719  if(get1bit())


720  *xrpnt = ispow[y] * v;


721  else


722  *xrpnt = ispow[y] * v;


723  }


724  else if(y) {


725  max[lwin] = cb;


726  if(get1bit())


727  *xrpnt = ispow[y] * v;


728  else


729  *xrpnt = ispow[y] * v;


730  part2remain;


731  }


732  else


733  *xrpnt = 0.0;


734  xrpnt += step;


735  }


736  }


737  for(;l3 && (part2remain > 0);l3) {


738  struct newhuff *h = htc+gr_info>count1table_select;


739  register short *val = h>table,a;


740 


741  while((a=*val++)<0) {


742  part2remain;


743  if(part2remain < 0) {


744  part2remain++;


745  a = 0;


746  break;


747  }


748  if (get1bit())


749  val = a;


750  }


751 


752  for(i=0;i<4;i++) {


753  if(!(i & 1)) {


754  if(!mc) {


755  mc = *m++;


756  xrpnt = ((real *) xr) + (*m++);


757  lwin = *m++;


758  cb = *m++;


759  if(lwin == 3) {


760  v = gr_info>pow2gain[(*scf++) << shift];


761  step = 1;


762  }


763  else {


764  v = gr_info>full_gain[lwin][(*scf++) << shift];


765  step = 3;


766  }


767  }


768  mc;


769  }


770  if( (a & (0x8>>i)) ) {


771  max[lwin] = cb;


772  part2remain;


773  if(part2remain < 0) {


774  part2remain++;


775  break;


776  }


777  if(get1bit())


778  *xrpnt = v;


779  else


780  *xrpnt = v;


781  }


782  else


783  *xrpnt = 0.0;


784  xrpnt += step;


785  }


786  }


787 


788  while( m < me ) {


789  if(!mc) {


790  mc = *m++;


791  xrpnt = ((real *) xr) + *m++;


792  if( (*m++) == 3)


793  step = 1;


794  else


795  step = 3;


796  m++; /* cb */


797  }


798  mc;


799  *xrpnt = 0.0;


800  xrpnt += step;


801  *xrpnt = 0.0;


802  xrpnt += step;


803  /* we could add a little opt. here:


804  * if we finished a band for window 3 or a long band


805  * further bands could copied in a simple loop without a


806  * special 'map' decoding


807  */


808  }


809 


810  gr_info>maxband[0] = max[0]+1;


811  gr_info>maxband[1] = max[1]+1;


812  gr_info>maxband[2] = max[2]+1;


813  gr_info>maxbandl = max[3]+1;


814 


815  {


816  int rmax = max[0] > max[1] ? max[0] : max[1];


817  rmax = (rmax > max[2] ? rmax : max[2]) + 1;


818  gr_info>maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];


819  }


820 


821  }


822  else {


823  /*


824  * decoding with 'long' BandIndex table (block_type != 2)


825  */


826  int *pretab = gr_info>preflag ? pretab1 : pretab2;


827  int i,max = 1;


828  int cb = 0;


829  register int *m = map[sfreq][2];


830  register real v = 0.0;


831  register int mc = 0;


832  #if 0


833  me = mapend[sfreq][2];


834  #endif


835 


836  /*


837  * long hash table values


838  */


839  for(i=0;i<3;i++) {


840  int lp = l[i];


841  struct newhuff *h = ht+gr_info>table_select[i];


842 


843  for(;lp;lp,mc) {


844  int x,y;


845 


846  if(!mc) {


847  mc = *m++;


848  v = gr_info>pow2gain[((*scf++) + (*pretab++)) << shift];


849  cb = *m++;


850  }


851  {


852  register short *val = h>table;


853  while((y=*val++)<0) {


854  if (get1bit())


855  val = y;


856  part2remain;


857  }


858  x = y >> 4;


859  y &= 0xf;


860  }


861  if (x == 15) {


862  max = cb;


863  part2remain = h>linbits+1;


864  x += getbits(h>linbits);


865  if(get1bit())


866  *xrpnt++ = ispow[x] * v;


867  else


868  *xrpnt++ = ispow[x] * v;


869  }


870  else if(x) {


871  max = cb;


872  if(get1bit())


873  *xrpnt++ = ispow[x] * v;


874  else


875  *xrpnt++ = ispow[x] * v;


876  part2remain;


877  }


878  else


879  *xrpnt++ = 0.0;


880 


881  if (y == 15) {


882  max = cb;


883  part2remain = h>linbits+1;


884  y += getbits(h>linbits);


885  if(get1bit())


886  *xrpnt++ = ispow[y] * v;


887  else


888  *xrpnt++ = ispow[y] * v;


889  }


890  else if(y) {


891  max = cb;


892  if(get1bit())


893  *xrpnt++ = ispow[y] * v;


894  else


895  *xrpnt++ = ispow[y] * v;


896  part2remain;


897  }


898  else


899  *xrpnt++ = 0.0;


900  }


901  }


902 


903  /*


904  * short (count1table) values


905  */


906  for(;l3 && (part2remain > 0);l3) {


907  struct newhuff *h = htc+gr_info>count1table_select;


908  register short *val = h>table,a;


909 


910  while((a=*val++)<0) {


911  part2remain;


912  if(part2remain < 0) {


913  part2remain++;


914  a = 0;


915  break;


916  }


917  if (get1bit())


918  val = a;


919  }


920 


921  for(i=0;i<4;i++) {


922  if(!(i & 1)) {


923  if(!mc) {


924  mc = *m++;


925  cb = *m++;


926  v = gr_info>pow2gain[((*scf++) + (*pretab++)) << shift];


927  }


928  mc;


929  }


930  if ( (a & (0x8>>i)) ) {


931  max = cb;


932  part2remain;


933  if(part2remain < 0) {


934  part2remain++;


935  break;


936  }


937  if(get1bit())


938  *xrpnt++ = v;


939  else


940  *xrpnt++ = v;


941  }


942  else


943  *xrpnt++ = 0.0;


944  }


945  }


946 


947  /*


948  * zero part


949  */


950  for(i=(&xr[SBLIMIT][SSLIMIT]xrpnt)>>1;i;i) {


951  *xrpnt++ = 0.0;


952  *xrpnt++ = 0.0;


953  }


954 


955  gr_info>maxbandl = max+1;


956  gr_info>maxb = longLimit[sfreq][gr_info>maxbandl];


957  }


958 


959  while( part2remain > 16 ) {


960  getbits(16); /* Dismiss stuffing Bits */


961  part2remain = 16;


962  }


963  if(part2remain > 0)


964  getbits(part2remain);


965  else if(part2remain < 0) {


966  return 1; /* > error */


967  }


968  return 0;


969  }


970 


971  static int III_dequantize_sample_ms(real xr[2][SBLIMIT][SSLIMIT],int *scf,


972  III_sideinfo::what_the::gr_info_s *gr_info,int sfreq,int part2bits)


973  {


974  int shift = 1 + gr_info>scalefac_scale;


975  real *xrpnt = (real *) xr[1];


976  real *xr0pnt = (real *) xr[0];


977  int l[3],l3;


978  int part2remain = gr_info>part2_3_length  part2bits;


979  int *me;


980 


981  {


982  int bv = gr_info>big_values;


983  int region1 = gr_info>region1start;


984  int region2 = gr_info>region2start;


985 


986  l3 = ((576>>1)bv)>>1;


987  /*


988  * we may lose the 'odd' bit here !!


989  * check this later gain


990  */


991  if(bv <= region1) {


992  l[0] = bv; l[1] = 0; l[2] = 0;


993  }


994  else {


995  l[0] = region1;


996  if(bv <= region2) {


997  l[1] = bv  l[0]; l[2] = 0;


998  }


999  else {


1000  l[1] = region2  l[0]; l[2] = bv  region2;


1001  }


1002  }


1003  }


1004 


1005  if(gr_info>block_type == 2) {


1006  int i,max[4];


1007  int step=0,lwin=0,cb=0;


1008  register real v = 0.0;


1009  register int *m,mc = 0;


1010 


1011  if(gr_info>mixed_block_flag) {


1012  max[3] = 1;


1013  max[0] = max[1] = max[2] = 2;


1014  m = map[sfreq][0];


1015  me = mapend[sfreq][0];


1016  }


1017  else {


1018  max[0] = max[1] = max[2] = max[3] = 1;


1019  /* max[3] not really needed in this case */


1020  m = map[sfreq][1];


1021  me = mapend[sfreq][1];


1022  }


1023 


1024  for(i=0;i<2;i++) {


1025  int lp = l[i];


1026  struct newhuff *h = ht+gr_info>table_select[i];


1027  for(;lp;lp,mc) {


1028  int x,y;


1029 


1030  if(!mc) {


1031  mc = *m++;


1032  xrpnt = ((real *) xr[1]) + *m;


1033  xr0pnt = ((real *) xr[0]) + *m++;


1034  lwin = *m++;


1035  cb = *m++;


1036  if(lwin == 3) {


1037  v = gr_info>pow2gain[(*scf++) << shift];


1038  step = 1;


1039  }


1040  else {


1041  v = gr_info>full_gain[lwin][(*scf++) << shift];


1042  step = 3;


1043  }


1044  }


1045  {


1046  register short *val = h>table;


1047  while((y=*val++)<0) {


1048  if (get1bit())


1049  val = y;


1050  part2remain;


1051  }


1052  x = y >> 4;


1053  y &= 0xf;


1054  }


1055  if(x == 15) {


1056  max[lwin] = cb;


1057  part2remain = h>linbits+1;


1058  x += getbits(h>linbits);


1059  if(get1bit()) {


1060  real a = ispow[x] * v;


1061  *xrpnt = *xr0pnt + a;


1062  *xr0pnt = a;


1063  }


1064  else {


1065  real a = ispow[x] * v;


1066  *xrpnt = *xr0pnt  a;


1067  *xr0pnt += a;


1068  }


1069  }


1070  else if(x) {


1071  max[lwin] = cb;


1072  if(get1bit()) {


1073  real a = ispow[x] * v;


1074  *xrpnt = *xr0pnt + a;


1075  *xr0pnt = a;


1076  }


1077  else {


1078  real a = ispow[x] * v;


1079  *xrpnt = *xr0pnt  a;


1080  *xr0pnt += a;


1081  }


1082  part2remain;


1083  }


1084  else


1085  *xrpnt = *xr0pnt;


1086  xrpnt += step;


1087  xr0pnt += step;


1088 


1089  if(y == 15) {


1090  max[lwin] = cb;


1091  part2remain = h>linbits+1;


1092  y += getbits(h>linbits);


1093  if(get1bit()) {


1094  real a = ispow[y] * v;


1095  *xrpnt = *xr0pnt + a;


1096  *xr0pnt = a;


1097  }


1098  else {


1099  real a = ispow[y] * v;


1100  *xrpnt = *xr0pnt  a;


1101  *xr0pnt += a;


1102  }


1103  }


1104  else if(y) {


1105  max[lwin] = cb;


1106  if(get1bit()) {


1107  real a = ispow[y] * v;


1108  *xrpnt = *xr0pnt + a;


1109  *xr0pnt = a;


1110  }


1111  else {


1112  real a = ispow[y] * v;


1113  *xrpnt = *xr0pnt  a;


1114  *xr0pnt += a;


1115  }


1116  part2remain;


1117  }


1118  else


1119  *xrpnt = *xr0pnt;


1120  xrpnt += step;


1121  xr0pnt += step;


1122  }


1123  }


1124 


1125  for(;l3 && (part2remain > 0);l3) {


1126  struct newhuff *h = htc+gr_info>count1table_select;


1127  register short *val = h>table,a;


1128 


1129  while((a=*val++)<0) {


1130  part2remain;


1131  if(part2remain < 0) {


1132  part2remain++;


1133  a = 0;


1134  break;


1135  }


1136  if (get1bit())


1137  val = a;


1138  }


1139 


1140  for(i=0;i<4;i++) {


1141  if(!(i & 1)) {


1142  if(!mc) {


1143  mc = *m++;


1144  xrpnt = ((real *) xr[1]) + *m;


1145  xr0pnt = ((real *) xr[0]) + *m++;


1146  lwin = *m++;


1147  cb = *m++;


1148  if(lwin == 3) {


1149  v = gr_info>pow2gain[(*scf++) << shift];


1150  step = 1;


1151  }


1152  else {


1153  v = gr_info>full_gain[lwin][(*scf++) << shift];


1154  step = 3;


1155  }


1156  }


1157  mc;


1158  }


1159  if( (a & (0x8>>i)) ) {


1160  max[lwin] = cb;


1161  part2remain;


1162  if(part2remain < 0) {


1163  part2remain++;


1164  break;


1165  }


1166  if(get1bit()) {


1167  *xrpnt = *xr0pnt + v;


1168  *xr0pnt = v;


1169  }


1170  else {


1171  *xrpnt = *xr0pnt  v;


1172  *xr0pnt += v;


1173  }


1174  }


1175  else


1176  *xrpnt = *xr0pnt;


1177  xrpnt += step;


1178  xr0pnt += step;


1179  }


1180  }


1181 


1182  while( m < me ) {


1183  if(!mc) {


1184  mc = *m++;


1185  xrpnt = ((real *) xr[1]) + *m;


1186  xr0pnt = ((real *) xr[0]) + *m++;


1187  if(*m++ == 3)


1188  step = 1;


1189  else


1190  step = 3;


1191  m++; /* cb */


1192  }


1193  mc;


1194  *xrpnt = *xr0pnt;


1195  xrpnt += step;


1196  xr0pnt += step;


1197  *xrpnt = *xr0pnt;


1198  xrpnt += step;


1199  xr0pnt += step;


1200  /* we could add a little opt. here:


1201  * if we finished a band for window 3 or a long band


1202  * further bands could copied in a simple loop without a


1203  * special 'map' decoding


1204  */


1205  }


1206 


1207  gr_info>maxband[0] = max[0]+1;


1208  gr_info>maxband[1] = max[1]+1;


1209  gr_info>maxband[2] = max[2]+1;


1210  gr_info>maxbandl = max[3]+1;


1211 


1212  {


1213  int rmax = max[0] > max[1] ? max[0] : max[1];


1214  rmax = (rmax > max[2] ? rmax : max[2]) + 1;


1215  gr_info>maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];


1216  }


1217  }


1218  else {


1219  int *pretab = gr_info>preflag ? pretab1 : pretab2;


1220  int i,max = 1;


1221  int cb = 0;


1222  register int mc=0,*m = map[sfreq][2];


1223  register real v = 0.0;


1224  #if 0


1225  me = mapend[sfreq][2];


1226  #endif


1227 


1228  for(i=0;i<3;i++) {


1229  int lp = l[i];


1230  struct newhuff *h = ht+gr_info>table_select[i];


1231 


1232  for(;lp;lp,mc) {


1233  int x,y;


1234  if(!mc) {


1235  mc = *m++;


1236  cb = *m++;


1237  v = gr_info>pow2gain[((*scf++) + (*pretab++)) << shift];


1238  }


1239  {


1240  register short *val = h>table;


1241  while((y=*val++)<0) {


1242  if (get1bit())


1243  val = y;


1244  part2remain;


1245  }


1246  x = y >> 4;


1247  y &= 0xf;


1248  }


1249  if (x == 15) {


1250  max = cb;


1251  part2remain = h>linbits+1;


1252  x += getbits(h>linbits);


1253  if(get1bit()) {


1254  real a = ispow[x] * v;


1255  *xrpnt++ = *xr0pnt + a;


1256  *xr0pnt++ = a;


1257  }


1258  else {


1259  real a = ispow[x] * v;


1260  *xrpnt++ = *xr0pnt  a;


1261  *xr0pnt++ += a;


1262  }


1263  }


1264  else if(x) {


1265  max = cb;


1266  if(get1bit()) {


1267  real a = ispow[x] * v;


1268  *xrpnt++ = *xr0pnt + a;


1269  *xr0pnt++ = a;


1270  }


1271  else {


1272  real a = ispow[x] * v;


1273  *xrpnt++ = *xr0pnt  a;


1274  *xr0pnt++ += a;


1275  }


1276  part2remain;


1277  }


1278  else


1279  *xrpnt++ = *xr0pnt++;


1280 


1281  if (y == 15) {


1282  max = cb;


1283  part2remain = h>linbits+1;


1284  y += getbits(h>linbits);


1285  if(get1bit()) {


1286  real a = ispow[y] * v;


1287  *xrpnt++ = *xr0pnt + a;


1288  *xr0pnt++ = a;


1289  }


1290  else {


1291  real a = ispow[y] * v;


1292  *xrpnt++ = *xr0pnt  a;


1293  *xr0pnt++ += a;


1294  }


1295  }


1296  else if(y) {


1297  max = cb;


1298  if(get1bit()) {


1299  real a = ispow[y] * v;


1300  *xrpnt++ = *xr0pnt + a;


1301  *xr0pnt++ = a;


1302  }


1303  else {


1304  real a = ispow[y] * v;


1305  *xrpnt++ = *xr0pnt  a;


1306  *xr0pnt++ += a;


1307  }


1308  part2remain;


1309  }


1310  else


1311  *xrpnt++ = *xr0pnt++;


1312  }


1313  }


1314 


1315  for(;l3 && (part2remain > 0);l3) {


1316  struct newhuff *h = htc+gr_info>count1table_select;


1317  register short *val = h>table,a;


1318 


1319  while((a=*val++)<0) {


1320  part2remain;


1321  if(part2remain < 0) {


1322  part2remain++;


1323  a = 0;


1324  break;


1325  }


1326  if (get1bit())


1327  val = a;


1328  }


1329 


1330  for(i=0;i<4;i++) {


1331  if(!(i & 1)) {


1332  if(!mc) {


1333  mc = *m++;


1334  cb = *m++;


1335  v = gr_info>pow2gain[((*scf++) + (*pretab++)) << shift];


1336  }


1337  mc;


1338  }


1339  if ( (a & (0x8>>i)) ) {


1340  max = cb;


1341  part2remain;


1342  if(part2remain <= 0) {


1343  part2remain++;


1344  break;


1345  }


1346  if(get1bit()) {


1347  *xrpnt++ = *xr0pnt + v;


1348  *xr0pnt++ = v;


1349  }


1350  else {


1351  *xrpnt++ = *xr0pnt  v;


1352  *xr0pnt++ += v;


1353  }


1354  }


1355  else


1356  *xrpnt++ = *xr0pnt++;


1357  }


1358  }


1359  for(i=(&xr[1][SBLIMIT][SSLIMIT]xrpnt)>>1;i;i) {


1360  *xrpnt++ = *xr0pnt++;


1361  *xrpnt++ = *xr0pnt++;


1362  }


1363 


1364  gr_info>maxbandl = max+1;


1365  gr_info>maxb = longLimit[sfreq][gr_info>maxbandl];


1366  }


1367 


1368  while ( part2remain > 16 ) {


1369  getbits(16); /* Dismiss stuffing Bits */


1370  part2remain = 16;


1371  }


1372  if(part2remain > 0 )


1373  getbits(part2remain);


1374  else if(part2remain < 0) {


1375  return 1; /* > error */


1376  }


1377  return 0;


1378  }


1379 


1380  /*


1381  * III_stereo: calculate real channel values for JointIStereomode


1382  */


1383  static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,


1384  III_sideinfo::what_the::gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf)


1385  {


1386  real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;


1387  struct bandInfoStruct *bi = &bandInfo[sfreq];


1388  real *tab1,*tab2;


1389 


1390  if(lsf) {


1391  int p = gr_info>scalefac_compress & 0x1;


1392  if(ms_stereo) {


1393  tab1 = pow1_2[p]; tab2 = pow2_2[p];


1394  }


1395  else {


1396  tab1 = pow1_1[p]; tab2 = pow2_1[p];


1397  }


1398  }


1399  else {


1400  if(ms_stereo) {


1401  tab1 = tan1_2; tab2 = tan2_2;


1402  }


1403  else {


1404  tab1 = tan1_1; tab2 = tan2_1;


1405  }


1406  }


1407 


1408  if (gr_info>block_type == 2)


1409  {


1410  int lwin,do_l = 0;


1411  if( gr_info>mixed_block_flag )


1412  do_l = 1;


1413 


1414  for (lwin=0;lwin<3;lwin++) /* process each window */


1415  {


1416  /* get first band with zero values */


1417  int is_p,sb,idx,sfb = gr_info>maxband[lwin]; /* sfb is minimal 3 for mixed mode */


1418  if(sfb > 3)


1419  do_l = 0;


1420 


1421  for(;sfb<12;sfb++)


1422  {


1423  is_p = scalefac[sfb*3+lwingr_info>mixed_block_flag]; /* scale: 015 */


1424  if(is_p != 7) {


1425  real t1,t2;


1426  sb = bi>shortDiff[sfb];


1427  idx = bi>shortIdx[sfb] + lwin;


1428  t1 = tab1[is_p]; t2 = tab2[is_p];


1429  for (; sb > 0; sb,idx+=3)


1430  {


1431  real v = xr[0][idx];


1432  xr[0][idx] = v * t1;


1433  xr[1][idx] = v * t2;


1434  }


1435  }


1436  }


1437 


1438  #if 1


1439  /* in the original: copy 10 to 11 , here: copy 11 to 12


1440  maybe still wrong??? (copy 12 to 13?) */


1441  is_p = scalefac[11*3+lwingr_info>mixed_block_flag]; /* scale: 015 */


1442  sb = bi>shortDiff[12];


1443  idx = bi>shortIdx[12] + lwin;


1444  #else


1445  is_p = scalefac[10*3+lwingr_info>mixed_block_flag]; /* scale: 015 */


1446  sb = bi>shortDiff[11];


1447  idx = bi>shortIdx[11] + lwin;


1448  #endif


1449  if(is_p != 7)


1450  {


1451  real t1,t2;


1452  t1 = tab1[is_p]; t2 = tab2[is_p];


1453  for ( ; sb > 0; sb,idx+=3 )


1454  {


1455  real v = xr[0][idx];


1456  xr[0][idx] = v * t1;


1457  xr[1][idx] = v * t2;


1458  }


1459  }


1460  } /* end for(lwin; .. ; . ) */


1461 


1462  if (do_l)


1463  {


1464  /* also check lpart, if ALL bands in the three windows are 'empty'


1465  * and mode = mixed_mode


1466  */


1467  int sfb = gr_info>maxbandl;


1468  int idx = bi>longIdx[sfb];


1469 


1470  for ( ; sfb<8; sfb++ )


1471  {


1472  int sb = bi>longDiff[sfb];


1473  int is_p = scalefac[sfb]; /* scale: 015 */


1474  if(is_p != 7) {


1475  real t1,t2;


1476  t1 = tab1[is_p]; t2 = tab2[is_p];


1477  for ( ; sb > 0; sb,idx++)


1478  {


1479  real v = xr[0][idx];


1480  xr[0][idx] = v * t1;


1481  xr[1][idx] = v * t2;


1482  }


1483  }


1484  else


1485  idx += sb;


1486  }


1487  }


1488  }


1489  else /* ((gr_info>block_type != 2)) */


1490  {


1491  int sfb = gr_info>maxbandl;


1492  int is_p,idx = bi>longIdx[sfb];


1493  for ( ; sfb<21; sfb++)


1494  {


1495  int sb = bi>longDiff[sfb];


1496  is_p = scalefac[sfb]; /* scale: 015 */


1497  if(is_p != 7) {


1498  real t1,t2;


1499  t1 = tab1[is_p]; t2 = tab2[is_p];


1500  for ( ; sb > 0; sb,idx++)


1501  {


1502  real v = xr[0][idx];


1503  xr[0][idx] = v * t1;


1504  xr[1][idx] = v * t2;


1505  }


1506  }


1507  else


1508  idx += sb;


1509  }


1510 


1511  is_p = scalefac[20]; /* copy lband 20 to lband 21 */


1512  if(is_p != 7)


1513  {


1514  int sb;


1515  real t1 = tab1[is_p],t2 = tab2[is_p];


1516 


1517  for ( sb = bi>longDiff[21]; sb > 0; sb,idx++ )


1518  {


1519  real v = xr[0][idx];


1520  xr[0][idx] = v * t1;


1521  xr[1][idx] = v * t2;


1522  }


1523  }


1524  } /* ... */


1525  }


1526 


1527  static void III_antialias(real xr[SBLIMIT][SSLIMIT], III_sideinfo::what_the::gr_info_s *gr_info)


1528  {


1529  int sblim;


1530 


1531  if(gr_info>block_type == 2)


1532  {


1533  if(!gr_info>mixed_block_flag)


1534  return;


1535  sblim = 1;


1536  }


1537  else {


1538  sblim = gr_info>maxb1;


1539  }


1540 


1541  /* 31 aliasreduction operations between each pair of subbands */


1542  /* with 8 butterflies between each pair */


1543 


1544  {


1545  int sb;


1546  real *xr1=(real *) xr[1];


1547 


1548  for(sb=sblim;sb;sb,xr1+=10)


1549  {


1550  int ss;


1551  real *cs=aa_cs,*ca=aa_ca;


1552  real *xr2 = xr1;


1553 


1554  for(ss=7;ss>=0;ss)


1555  { /* upper and lower butterfly inputs */


1556  register real bu = *xr2,bd = *xr1;


1557  *xr2 = (bu * (*cs) )  (bd * (*ca) );


1558  *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );


1559  }


1560  }


1561  }


1562  }


1563 


1564  /*


1565  // This is an optimized DCT from Jeff Tsay's maplay 1.2+ package.


1566  // Saved one multiplication by doing the 'twiddle factor' stuff


1567  // together with the window mul. (MH)


1568  //


1569  // This uses Byeong Gi Lee's Fast Cosine Transform algorithm, but the


1570  // 9 point IDCT needs to be reduced further. Unfortunately, I don't


1571  // know how to do that, because 9 is not an even number.  Jeff.


1572  //


1573  //////////////////////////////////////////////////////////////////


1574  //


1575  // 9 Point Inverse Discrete Cosine Transform


1576  //


1577  // This piece of code is Copyright 1997 Mikko Tommila and is freely usable


1578  // by anybody. The algorithm itself is of course in the public domain.


1579  //


1580  // Again derived heuristically from the 9point WFTA.


1581  //


1582  // The algorithm is optimized (?) for speed, not for small rounding errors or


1583  // good readability.


1584  //


1585  // 36 additions, 11 multiplications


1586  //


1587  // Again this is very likely suboptimal.


1588  //


1589  // The code is optimized to use a minimum number of temporary variables,


1590  // so it should compile quite well even on 8register Intel x86 processors.


1591  // This makes the code quite obfuscated and very difficult to understand.


1592  //


1593  // References:


1594  // [1] S. Winograd: "On Computing the Discrete Fourier Transform",


1595  // Mathematics of Computation, Volume 32, Number 141, January 1978,


1596  // Pages 175199


1597  */


1598 


1599  /**/


1600  /* */


1601  /* Function: Calculation of the inverse MDCT */


1602  /* */


1603  /**/


1604 


1605  static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)


1606  {


1607  #ifdef NEW_DCT9


1608  real tmp[18];


1609  #endif


1610 


1611  {


1612  register real *in = inbuf;


1613 


1614  in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];


1615  in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];


1616  in[11]+=in[10]; in[10]+=in[9]; in[9] +=in[8];


1617  in[8] +=in[7]; in[7] +=in[6]; in[6] +=in[5];


1618  in[5] +=in[4]; in[4] +=in[3]; in[3] +=in[2];


1619  in[2] +=in[1]; in[1] +=in[0];


1620 


1621  in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];


1622  in[9] +=in[7]; in[7] +=in[5]; in[5] +=in[3]; in[3] +=in[1];


1623 


1624 


1625  #ifdef NEW_DCT9


1626  {


1627  real t0, t1, t2, t3, t4, t5, t6, t7;


1628 


1629  t1 = COS6_2 * in[12];


1630  t2 = COS6_2 * (in[8] + in[16]  in[4]);


1631 


1632  t3 = in[0] + t1;


1633  t4 = in[0]  t1  t1;


1634  t5 = t4  t2;


1635 


1636  t0 = cos9[0] * (in[4] + in[8]);


1637  t1 = cos9[1] * (in[8]  in[16]);


1638 


1639  tmp[4] = t4 + t2 + t2;


1640  t2 = cos9[2] * (in[4] + in[16]);


1641 


1642  t6 = t3  t0  t2;


1643  t0 += t3 + t1;


1644  t3 += t2  t1;


1645 


1646  t2 = cos18[0] * (in[2] + in[10]);


1647  t4 = cos18[1] * (in[10]  in[14]);


1648  t7 = COS6_1 * in[6];


1649 


1650  t1 = t2 + t4 + t7;


1651  tmp[0] = t0 + t1;


1652  tmp[8] = t0  t1;


1653  t1 = cos18[2] * (in[2] + in[14]);


1654  t2 += t1  t7;


1655 


1656  tmp[3] = t3 + t2;


1657  t0 = COS6_1 * (in[10] + in[14]  in[2]);


1658  tmp[5] = t3  t2;


1659 


1660  t4 = t1 + t7;


1661 


1662  tmp[1] = t5  t0;


1663  tmp[7] = t5 + t0;


1664  tmp[2] = t6 + t4;


1665  tmp[6] = t6  t4;


1666  }


1667 


1668  {


1669  real t0, t1, t2, t3, t4, t5, t6, t7;


1670 


1671  t1 = COS6_2 * in[13];


1672  t2 = COS6_2 * (in[9] + in[17]  in[5]);


1673 


1674  t3 = in[1] + t1;


1675  t4 = in[1]  t1  t1;


1676  t5 = t4  t2;


1677 


1678  t0 = cos9[0] * (in[5] + in[9]);


1679  t1 = cos9[1] * (in[9]  in[17]);


1680 


1681  tmp[13] = (t4 + t2 + t2) * tfcos36[1713];


1682  t2 = cos9[2] * (in[5] + in[17]);


1683 


1684  t6 = t3  t0  t2;


1685  t0 += t3 + t1;


1686  t3 += t2  t1;


1687 


1688  t2 = cos18[0] * (in[3] + in[11]);


1689  t4 = cos18[1] * (in[11]  in[15]);


1690  t7 = COS6_1 * in[7];


1691 


1692  t1 = t2 + t4 + t7;


1693  tmp[17] = (t0 + t1) * tfcos36[1717];


1694  tmp[9] = (t0  t1) * tfcos36[179];


1695  t1 = cos18[2] * (in[3] + in[15]);


1696  t2 += t1  t7;


1697 


1698  tmp[14] = (t3 + t2) * tfcos36[1714];


1699  t0 = COS6_1 * (in[11] + in[15]  in[3]);


1700  tmp[12] = (t3  t2) * tfcos36[1712];


1701 


1702  t4 = t1 + t7;


1703 


1704  tmp[16] = (t5  t0) * tfcos36[1716];


1705  tmp[10] = (t5 + t0) * tfcos36[1710];


1706  tmp[15] = (t6 + t4) * tfcos36[1715];


1707  tmp[11] = (t6  t4) * tfcos36[1711];


1708  }


1709 


1710  #define MACRO(v) { \


1711  real tmpval; \


1712  real sum0 = tmp[(v)]; \


1713  real sum1 = tmp[17(v)]; \


1714  out2[9+(v)] = (tmpval = sum0 + sum1) * w[27+(v)]; \


1715  out2[8(v)] = tmpval * w[26(v)]; \


1716  sum0 = sum1; \


1717  ts[SBLIMIT*(8(v))] = out1[8(v)] + sum0 * w[8(v)]; \


1718  ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; }


1719 


1720  {


1721  register real *out2 = o2;


1722  register real *w = wintab;


1723  register real *out1 = o1;


1724  register real *ts = tsbuf;


1725 


1726  MACRO(0);


1727  MACRO(1);


1728  MACRO(2);


1729  MACRO(3);


1730  MACRO(4);


1731  MACRO(5);


1732  MACRO(6);


1733  MACRO(7);


1734  MACRO(8);


1735  }


1736 


1737  #else


1738 


1739  {


1740 


1741  #define MACRO0(v) { \


1742  real tmp; \


1743  out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \


1744  out2[8(v)] = tmp * w[26(v)]; } \


1745  sum0 = sum1; \


1746  ts[SBLIMIT*(8(v))] = out1[8(v)] + sum0 * w[8(v)]; \


1747  ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)];


1748  #define MACRO1(v) { \


1749  real sum0,sum1; \


1750  sum0 = tmp1a + tmp2a; \


1751  sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \


1752  MACRO0(v); }


1753  #define MACRO2(v) { \


1754  real sum0,sum1; \


1755  sum0 = tmp2a  tmp1a; \


1756  sum1 = (tmp2b  tmp1b) * tfcos36[(v)]; \


1757  MACRO0(v); }


1758 


1759  register const real *c = COS9;


1760  register real *out2 = o2;


1761  register real *w = wintab;


1762  register real *out1 = o1;


1763  register real *ts = tsbuf;


1764 


1765  real ta33,ta66,tb33,tb66;


1766 


1767  ta33 = in[2*3+0] * c[3];


1768  ta66 = in[2*6+0] * c[6];


1769  tb33 = in[2*3+1] * c[3];


1770  tb66 = in[2*6+1] * c[6];


1771 


1772  {


1773  real tmp1a,tmp2a,tmp1b,tmp2b;


1774  tmp1a = in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];


1775  tmp1b = in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];


1776  tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];


1777  tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];


1778 


1779  MACRO1(0);


1780  MACRO2(8);


1781  }


1782 


1783  {


1784  real tmp1a,tmp2a,tmp1b,tmp2b;


1785  tmp1a = ( in[2*1+0]  in[2*5+0]  in[2*7+0] ) * c[3];


1786  tmp1b = ( in[2*1+1]  in[2*5+1]  in[2*7+1] ) * c[3];


1787  tmp2a = ( in[2*2+0]  in[2*4+0]  in[2*8+0] ) * c[6]  in[2*6+0] + in[2*0+0];


1788  tmp2b = ( in[2*2+1]  in[2*4+1]  in[2*8+1] ) * c[6]  in[2*6+1] + in[2*0+1];


1789 


1790  MACRO1(1);


1791  MACRO2(7);


1792  }


1793 


1794  {


1795  real tmp1a,tmp2a,tmp1b,tmp2b;


1796  tmp1a = in[2*1+0] * c[5]  ta33  in[2*5+0] * c[7] + in[2*7+0] * c[1];


1797  tmp1b = in[2*1+1] * c[5]  tb33  in[2*5+1] * c[7] + in[2*7+1] * c[1];


1798  tmp2a = in[2*0+0]  in[2*2+0] * c[8]  in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];


1799  tmp2b = in[2*0+1]  in[2*2+1] * c[8]  in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];


1800 


1801  MACRO1(2);


1802  MACRO2(6);


1803  }


1804 


1805  {


1806  real tmp1a,tmp2a,tmp1b,tmp2b;


1807  tmp1a = in[2*1+0] * c[7]  ta33 + in[2*5+0] * c[1]  in[2*7+0] * c[5];


1808  tmp1b = in[2*1+1] * c[7]  tb33 + in[2*5+1] * c[1]  in[2*7+1] * c[5];


1809  tmp2a = in[2*0+0]  in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66  in[2*8+0] * c[2];


1810  tmp2b = in[2*0+1]  in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66  in[2*8+1] * c[2];


1811 


1812  MACRO1(3);


1813  MACRO2(5);


1814  }


1815 


1816  {


1817  real sum0,sum1;


1818  sum0 = in[2*0+0]  in[2*2+0] + in[2*4+0]  in[2*6+0] + in[2*8+0];


1819  sum1 = (in[2*0+1]  in[2*2+1] + in[2*4+1]  in[2*6+1] + in[2*8+1] ) * tfcos36[4];


1820  MACRO0(4);


1821  }


1822  }


1823  #endif


1824 


1825  }


1826  }


1827 


1828  /*


1829  * new DCT12


1830  */


1831  static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)


1832  {


1833  #define DCT12_PART1 \


1834  in5 = in[5*3]; \


1835  in5 += (in4 = in[4*3]); \


1836  in4 += (in3 = in[3*3]); \


1837  in3 += (in2 = in[2*3]); \


1838  in2 += (in1 = in[1*3]); \


1839  in1 += (in0 = in[0*3]); \


1840  \


1841  in5 += in3; in3 += in1; \


1842  \


1843  in2 *= COS6_1; \


1844  in3 *= COS6_1; \


1845 


1846  #define DCT12_PART2 \


1847  in0 += in4 * COS6_2; \


1848  \


1849  in4 = in0 + in2; \


1850  in0 = in2; \


1851  \


1852  in1 += in5 * COS6_2; \


1853  \


1854  in5 = (in1 + in3) * tfcos12[0]; \


1855  in1 = (in1  in3) * tfcos12[2]; \


1856  \


1857  in3 = in4 + in5; \


1858  in4 = in5; \


1859  \


1860  in2 = in0 + in1; \


1861  in0 = in1;


1862 


1863 


1864  {


1865  real in0,in1,in2,in3,in4,in5;


1866  register real *out1 = rawout1;


1867  ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];


1868  ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];


1869 


1870  DCT12_PART1


1871 


1872  {


1873  real tmp0,tmp1 = (in0  in4);


1874  {


1875  real tmp2 = (in1  in5) * tfcos12[1];


1876  tmp0 = tmp1 + tmp2;


1877  tmp1 = tmp2;


1878  }


1879  ts[(171)*SBLIMIT] = out1[171] + tmp0 * wi[111];


1880  ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];


1881  ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];


1882  ts[(111)*SBLIMIT] = out1[111] + tmp1 * wi[51];


1883  }


1884 


1885  DCT12_PART2


1886 


1887  ts[(170)*SBLIMIT] = out1[170] + in2 * wi[110];


1888  ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];


1889  ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];


1890  ts[(172)*SBLIMIT] = out1[172] + in3 * wi[112];


1891 


1892  ts[(6+0)*SBLIMIT] = out1[6+0] + in0 * wi[0];


1893  ts[(110)*SBLIMIT] = out1[110] + in0 * wi[50];


1894  ts[(6+2)*SBLIMIT] = out1[6+2] + in4 * wi[2];


1895  ts[(112)*SBLIMIT] = out1[112] + in4 * wi[52];


1896  }


1897 


1898  in++;


1899 


1900  {


1901  real in0,in1,in2,in3,in4,in5;


1902  register real *out2 = rawout2;


1903 


1904  DCT12_PART1


1905 


1906  {


1907  real tmp0,tmp1 = (in0  in4);


1908  {


1909  real tmp2 = (in1  in5) * tfcos12[1];


1910  tmp0 = tmp1 + tmp2;


1911  tmp1 = tmp2;


1912  }


1913  out2[51] = tmp0 * wi[111];


1914  out2[0+1] = tmp0 * wi[6+1];


1915  ts[(12+1)*SBLIMIT] += tmp1 * wi[1];


1916  ts[(171)*SBLIMIT] += tmp1 * wi[51];


1917  }


1918 


1919  DCT12_PART2


1920 


1921  out2[50] = in2 * wi[110];


1922  out2[0+0] = in2 * wi[6+0];


1923  out2[0+2] = in3 * wi[6+2];


1924  out2[52] = in3 * wi[112];


1925 


1926  ts[(12+0)*SBLIMIT] += in0 * wi[0];


1927  ts[(170)*SBLIMIT] += in0 * wi[50];


1928  ts[(12+2)*SBLIMIT] += in4 * wi[2];


1929  ts[(172)*SBLIMIT] += in4 * wi[52];


1930  }


1931 


1932  in++;


1933 


1934  {


1935  real in0,in1,in2,in3,in4,in5;


1936  register real *out2 = rawout2;


1937  out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;


1938 


1939  DCT12_PART1


1940 


1941  {


1942  real tmp0,tmp1 = (in0  in4);


1943  {


1944  real tmp2 = (in1  in5) * tfcos12[1];


1945  tmp0 = tmp1 + tmp2;


1946  tmp1 = tmp2;


1947  }


1948  out2[111] = tmp0 * wi[111];


1949  out2[6 +1] = tmp0 * wi[6+1];


1950  out2[0+1] += tmp1 * wi[1];


1951  out2[51] += tmp1 * wi[51];


1952  }


1953 


1954  DCT12_PART2


1955 


1956  out2[110] = in2 * wi[110];


1957  out2[6 +0] = in2 * wi[6+0];


1958  out2[6 +2] = in3 * wi[6+2];


1959  out2[112] = in3 * wi[112];


1960 


1961  out2[0+0] += in0 * wi[0];


1962  out2[50] += in0 * wi[50];


1963  out2[0+2] += in4 * wi[2];


1964  out2[52] += in4 * wi[52];


1965  }


1966  }


1967 


1968  /*


1969  * III_hybrid


1970  */


1971  static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],


1972  int ch, III_sideinfo::what_the::gr_info_s *gr_info)


1973  {


1974  real *tspnt = (real *) tsOut;


1975  real *rawout1,*rawout2;


1976  int bt;


1977  unsigned int sb = 0;


1978 


1979  {


1980  int b = blc[ch];


1981  rawout1=block[b][ch];


1982  b=b+1;


1983  rawout2=block[b][ch];


1984  blc[ch] = b;


1985  }


1986 


1987 


1988  if(gr_info>mixed_block_flag) {


1989  sb = 2;


1990  dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);


1991  dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);


1992  rawout1 += 36; rawout2 += 36; tspnt += 2;


1993  }


1994 


1995  bt = gr_info>block_type;


1996  if(bt == 2) {


1997  for (; sb<gr_info>maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {


1998  dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);


1999  dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);


2000  }


2001  }


2002  else {


2003  for (; sb<gr_info>maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {


2004  dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);


2005  dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);


2006  }


2007  }


2008 


2009  for(;sb<SBLIMIT;sb++,tspnt++) {


2010  int i;


2011  for(i=0;i<SSLIMIT;i++) {


2012  tspnt[i*SBLIMIT] = *rawout1++;


2013  *rawout2++ = 0.0;


2014  }


2015  }


2016  }


2017 


2018  /*


2019  * main layer3 handler


2020  */


2021  int do_layer3(struct frame *fr,int outmode,struct audio_info_struct *ai)


2022  {


2023  int gr, ch, ss,clip=0;


2024  int scalefacs[39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */


2025  struct III_sideinfo sideinfo;


2026  int stereo = fr>stereo;


2027  int single = fr>single;


2028  int ms_stereo,i_stereo;


2029  int sfreq = fr>sampling_frequency;


2030  int stereo1,granules;


2031 


2032  if(stereo == 1) {


2033  stereo1 = 1;


2034  single = 0;


2035  }


2036  else if(single >= 0)


2037  stereo1 = 1;


2038  else


2039  stereo1 = 2;


2040 


2041  ms_stereo = (fr>mode == MPG_MD_JOINT_STEREO) && (fr>mode_ext & 0x2);


2042  i_stereo = (fr>mode == MPG_MD_JOINT_STEREO) && (fr>mode_ext & 0x1);


2043 


2044  if(fr>lsf) {


2045  granules = 1;


2046  III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single);


2047  }


2048  else {


2049  granules = 2;


2050  III_get_side_info_1(&sideinfo,stereo,ms_stereo,sfreq,single);


2051  }


2052 


2053  set_pointer(sideinfo.main_data_begin);


2054 


2055  for (gr=0;gr<granules;gr++)


2056  {


2057  static real hybridIn[2][SBLIMIT][SSLIMIT];


2058  static real hybridOut[2][SSLIMIT][SBLIMIT];


2059 


2060  {


2061  III_sideinfo::what_the::gr_info_s *gr_info = (III_sideinfo::what_the::gr_info_s *)&(sideinfo.ch[0].gr[gr]);


2062  long part2bits;


2063  if(fr>lsf)


2064  part2bits = III_get_scale_factors_2(scalefacs,gr_info,0);


2065  else


2066  part2bits = III_get_scale_factors_1(scalefacs,gr_info);


2067  if(III_dequantize_sample(hybridIn[0], scalefacs,gr_info,sfreq,part2bits))


2068  return clip;


2069  }


2070  if(stereo == 2)


2071  {


2072  III_sideinfo::what_the::gr_info_s *gr_info = (III_sideinfo::what_the::gr_info_s *)&(sideinfo.ch[1].gr[gr]);


2073  long part2bits;


2074  if(fr>lsf)


2075  part2bits = III_get_scale_factors_2(scalefacs,gr_info,i_stereo);


2076  else


2077  part2bits = III_get_scale_factors_1(scalefacs,gr_info);


2078  if(ms_stereo) {


2079  if(III_dequantize_sample_ms(hybridIn,scalefacs,gr_info,sfreq,part2bits))


2080  return clip;


2081  }


2082  else {


2083  if(III_dequantize_sample(hybridIn[1],scalefacs,gr_info,sfreq,part2bits))


2084  return clip;


2085  }


2086 


2087  if(i_stereo)


2088  III_i_stereo(hybridIn,scalefacs,gr_info,sfreq,ms_stereo,fr>lsf);


2089 


2090 


2091  if(ms_stereo  i_stereo  (single == 3) ) {


2092  if(gr_info>maxb > sideinfo.ch[0].gr[gr].maxb)


2093  sideinfo.ch[0].gr[gr].maxb = gr_info>maxb;


2094  else


2095  gr_info>maxb = sideinfo.ch[0].gr[gr].maxb;


2096  }


2097 


2098  switch(single) {


2099  case 3:


2100  {


2101  unsigned int i;


2102  register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];


2103  for(i=0;i<SSLIMIT*gr_info>maxb;i++,in0++)


2104  *in0 = (*in0 + *in1++); /* *0.5 done by powscale */


2105  }


2106  break;


2107  case 1:


2108  {


2109  unsigned int i;


2110  register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];


2111  for(i=0;i<SSLIMIT*gr_info>maxb;i++)


2112  *in0++ = *in1++;


2113  }


2114  break;


2115  }


2116  }


2117 


2118  for(ch=0;ch<stereo1;ch++) {


2119  III_sideinfo::what_the::gr_info_s *gr_info = (III_sideinfo::what_the::gr_info_s *)&(sideinfo.ch[ch].gr[gr]);


2120  III_antialias(hybridIn[ch],gr_info);


2121  III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_info);


2122  }


2123 


2124  for(ss=0;ss<SSLIMIT;ss++) {


2125  if(single >= 0) {


2126  clip += (fr>synth_mono)(hybridOut[0][ss],pcm_sample+pcm_point);


2127  }


2128  else {


2129  clip += (fr>synth)(hybridOut[0][ss],0,pcm_sample+pcm_point);


2130  clip += (fr>synth)(hybridOut[1][ss],1,pcm_sample+pcm_point);


2131  }


2132  pcm_point += fr>block_size;


2133 


2134  #ifdef VARMODESUPPORT


2135  if (playlimit < 128) {


2136  pcm_point = playlimit >> 1;


2137  playlimit = 0;


2138  }


2139  else


2140  playlimit = 128;


2141  #endif


2142 


2143  if(pcm_point >= audiobufsize)


2144  audio_flush(outmode,ai);


2145  }


2146  }


2147 


2148  return clip;


2149  }


2150 


2151 

