00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #ifdef HAVE_CONFIG_H
00011 # include <config.h>
00012 #endif
00013
00014 #include <stdlib.h>
00015 #include "common.h"
00016 #include "huffman.h"
00017 #include "lame.h"
00018 #include "machine.h"
00019 #include "encoder.h"
00020 #include "lame-analysis.h"
00021 #include "decode_i386.h"
00022
00023 #ifdef WITH_DMALLOC
00024 #include <dmalloc.h>
00025 #endif
00026
00027
00028
00029 static real ispow[8207];
00030 static real aa_ca[8],aa_cs[8];
00031 static real COS1[12][6];
00032 static real win[4][36];
00033 static real win1[4][36];
00034 static real gainpow2[256+118+4];
00035 static real COS9[9];
00036 static real COS6_1,COS6_2;
00037 static real tfcos36[9];
00038 static real tfcos12[3];
00039
00040 struct bandInfoStruct {
00041 short longIdx[23];
00042 short longDiff[22];
00043 short shortIdx[14];
00044 short shortDiff[13];
00045 };
00046
00047 static int longLimit[9][23];
00048 static int shortLimit[9][14];
00049
00050 const struct bandInfoStruct bandInfo[9] = {
00051
00052
00053 { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
00054 {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
00055 {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},
00056 {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
00057
00058 { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
00059 {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
00060 {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},
00061 {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
00062
00063 { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
00064 {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
00065 {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} ,
00066 {4,4,4,4,6,8,12,16,20,26,34,42,12} } ,
00067
00068
00069 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
00070 {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
00071 {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} ,
00072 {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
00073
00074 { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,332,394,464,540,576},
00075 {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36 } ,
00076 {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} ,
00077 {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
00078
00079 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
00080 {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
00081 {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},
00082 {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
00083
00084 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
00085 {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
00086 {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
00087 {4,4,4,6,8,10,12,14,18,24,30,40,18} },
00088 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
00089 {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
00090 {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
00091 {4,4,4,6,8,10,12,14,18,24,30,40,18} },
00092 { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
00093 {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
00094 {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
00095 {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
00096 };
00097
00098 static int mapbuf0[9][152];
00099 static int mapbuf1[9][156];
00100 static int mapbuf2[9][44];
00101 static int *map[9][3];
00102 static int *mapend[9][3];
00103
00104 static unsigned int n_slen2[512];
00105 static unsigned int i_slen2[256];
00106
00107 static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
00108 static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
00109
00110 static unsigned int get1bit(PMPSTR mp)
00111 {
00112 unsigned char rval;
00113 rval = *mp->wordpointer << mp->bitindex;
00114
00115 mp->bitindex++;
00116 mp->wordpointer += (mp->bitindex>>3);
00117 mp->bitindex &= 7;
00118
00119 return rval>>7;
00120 }
00121
00122
00123
00124
00125
00126
00127
00128 void init_layer3(int down_sample_sblimit)
00129 {
00130 int i,j,k;
00131
00132 for(i=-256;i<118+4;i++)
00133 gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) );
00134
00135 for(i=0;i<8207;i++)
00136 ispow[i] = pow((double)i,(double)4.0/3.0);
00137
00138 for (i=0;i<8;i++)
00139 {
00140 static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
00141 double sq=sqrt(1.0+Ci[i]*Ci[i]);
00142 aa_cs[i] = 1.0/sq;
00143 aa_ca[i] = Ci[i]/sq;
00144 }
00145
00146 for(i=0;i<18;i++)
00147 {
00148 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 );
00149 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 );
00150 }
00151 for(i=0;i<6;i++)
00152 {
00153 win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
00154 win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
00155 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 );
00156 win[1][i+30] = win[3][i] = 0.0;
00157 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 );
00158 }
00159
00160 for(i=0;i<9;i++)
00161 COS9[i] = cos( M_PI / 18.0 * (double) i);
00162
00163 for(i=0;i<9;i++)
00164 tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );
00165 for(i=0;i<3;i++)
00166 tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );
00167
00168 COS6_1 = cos( M_PI / 6.0 * (double) 1);
00169 COS6_2 = cos( M_PI / 6.0 * (double) 2);
00170
00171 for(i=0;i<12;i++)
00172 {
00173 win[2][i] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
00174 for(j=0;j<6;j++)
00175 COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
00176 }
00177
00178 for(j=0;j<4;j++) {
00179 static int len[4] = { 36,36,12,36 };
00180 for(i=0;i<len[j];i+=2)
00181 win1[j][i] = + win[j][i];
00182 for(i=1;i<len[j];i+=2)
00183 win1[j][i] = - win[j][i];
00184 }
00185
00186 for(i=0;i<16;i++)
00187 {
00188 double t = tan( (double) i * M_PI / 12.0 );
00189 tan1_1[i] = t / (1.0+t);
00190 tan2_1[i] = 1.0 / (1.0 + t);
00191 tan1_2[i] = M_SQRT2 * t / (1.0+t);
00192 tan2_2[i] = M_SQRT2 / (1.0 + t);
00193
00194 for(j=0;j<2;j++) {
00195 double base = pow(2.0,-0.25*(j+1.0));
00196 double p1=1.0,p2=1.0;
00197 if(i > 0) {
00198 if( i & 1 )
00199 p1 = pow(base,(i+1.0)*0.5);
00200 else
00201 p2 = pow(base,i*0.5);
00202 }
00203 pow1_1[j][i] = p1;
00204 pow2_1[j][i] = p2;
00205 pow1_2[j][i] = M_SQRT2 * p1;
00206 pow2_2[j][i] = M_SQRT2 * p2;
00207 }
00208 }
00209
00210 for(j=0;j<9;j++)
00211 {
00212 struct bandInfoStruct *bi = (struct bandInfoStruct *)&bandInfo[j];
00213 int *mp;
00214 int cb,lwin;
00215 short *bdf;
00216
00217 mp = map[j][0] = mapbuf0[j];
00218 bdf = bi->longDiff;
00219 for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
00220 *mp++ = (*bdf) >> 1;
00221 *mp++ = i;
00222 *mp++ = 3;
00223 *mp++ = cb;
00224 }
00225 bdf = bi->shortDiff+3;
00226 for(cb=3;cb<13;cb++) {
00227 int l = (*bdf++) >> 1;
00228 for(lwin=0;lwin<3;lwin++) {
00229 *mp++ = l;
00230 *mp++ = i + lwin;
00231 *mp++ = lwin;
00232 *mp++ = cb;
00233 }
00234 i += 6*l;
00235 }
00236 mapend[j][0] = mp;
00237
00238 mp = map[j][1] = mapbuf1[j];
00239 bdf = bi->shortDiff+0;
00240 for(i=0,cb=0;cb<13;cb++) {
00241 int l = (*bdf++) >> 1;
00242 for(lwin=0;lwin<3;lwin++) {
00243 *mp++ = l;
00244 *mp++ = i + lwin;
00245 *mp++ = lwin;
00246 *mp++ = cb;
00247 }
00248 i += 6*l;
00249 }
00250 mapend[j][1] = mp;
00251
00252 mp = map[j][2] = mapbuf2[j];
00253 bdf = bi->longDiff;
00254 for(cb = 0; cb < 22 ; cb++) {
00255 *mp++ = (*bdf++) >> 1;
00256 *mp++ = cb;
00257 }
00258 mapend[j][2] = mp;
00259
00260 }
00261
00262 for(j=0;j<9;j++) {
00263 for(i=0;i<23;i++) {
00264 longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
00265 if(longLimit[j][i] > (down_sample_sblimit) )
00266 longLimit[j][i] = down_sample_sblimit;
00267 }
00268 for(i=0;i<14;i++) {
00269 shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
00270 if(shortLimit[j][i] > (down_sample_sblimit) )
00271 shortLimit[j][i] = down_sample_sblimit;
00272 }
00273 }
00274
00275 for(i=0;i<5;i++) {
00276 for(j=0;j<6;j++) {
00277 for(k=0;k<6;k++) {
00278 int n = k + j * 6 + i * 36;
00279 i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
00280 }
00281 }
00282 }
00283 for(i=0;i<4;i++) {
00284 for(j=0;j<4;j++) {
00285 for(k=0;k<4;k++) {
00286 int n = k + j * 4 + i * 16;
00287 i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
00288 }
00289 }
00290 }
00291 for(i=0;i<4;i++) {
00292 for(j=0;j<3;j++) {
00293 int n = j + i * 3;
00294 i_slen2[n+244] = i|(j<<3) | (5<<12);
00295 n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
00296 }
00297 }
00298
00299 for(i=0;i<5;i++) {
00300 for(j=0;j<5;j++) {
00301 for(k=0;k<4;k++) {
00302 int l;
00303 for(l=0;l<4;l++) {
00304 int n = l + k * 4 + j * 16 + i * 80;
00305 n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
00306 }
00307 }
00308 }
00309 }
00310 for(i=0;i<5;i++) {
00311 for(j=0;j<5;j++) {
00312 for(k=0;k<4;k++) {
00313 int n = k + j * 4 + i * 20;
00314 n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
00315 }
00316 }
00317 }
00318 }
00319
00320
00321
00322
00323
00324 static void III_get_side_info_1(PMPSTR mp, struct III_sideinfo *si,int stereo,
00325 int ms_stereo,long sfreq,int single)
00326 {
00327 int ch, gr;
00328 int powdiff = (single == 3) ? 4 : 0;
00329
00330 si->main_data_begin = getbits(mp,9);
00331 if (stereo == 1)
00332 si->private_bits = getbits_fast(mp,5);
00333 else
00334 si->private_bits = getbits_fast(mp,3);
00335
00336 for (ch=0; ch<stereo; ch++) {
00337 si->ch[ch].gr[0].scfsi = -1;
00338 si->ch[ch].gr[1].scfsi = getbits_fast(mp,4);
00339 }
00340
00341 for (gr=0; gr<2; gr++)
00342 {
00343 for (ch=0; ch<stereo; ch++)
00344 {
00345 struct gr_info_s *gr_infos = &(si->ch[ch].gr[gr]);
00346
00347 gr_infos->part2_3_length = getbits(mp,12);
00348 gr_infos->big_values = getbits_fast(mp,9);
00349 if(gr_infos->big_values > 288) {
00350 fprintf(stderr,"big_values too large! %i\n",gr_infos->big_values);
00351 gr_infos->big_values = 288;
00352 }
00353 {
00354 unsigned int qss = getbits_fast(mp,8);
00355 gr_infos->pow2gain = gainpow2+256 - qss + powdiff;
00356 #ifndef NOANALYSIS
00357 if (mpg123_pinfo != NULL) {
00358 mpg123_pinfo->qss[gr][ch]=qss;
00359 }
00360 #endif
00361 }
00362 if(ms_stereo)
00363 gr_infos->pow2gain += 2;
00364 gr_infos->scalefac_compress = getbits_fast(mp,4);
00365
00366 if(get1bit(mp))
00367 {
00368 int i;
00369 gr_infos->block_type = getbits_fast(mp,2);
00370 gr_infos->mixed_block_flag = get1bit(mp);
00371 gr_infos->table_select[0] = getbits_fast(mp,5);
00372 gr_infos->table_select[1] = getbits_fast(mp,5);
00373
00374
00375
00376
00377
00378
00379 gr_infos->table_select[2] = 0;
00380 for(i=0;i<3;i++) {
00381 unsigned int sbg = (getbits_fast(mp,3)<<3);
00382 gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;
00383 #ifndef NOANALYSIS
00384 if (mpg123_pinfo != NULL)
00385 mpg123_pinfo->sub_gain[gr][ch][i]=sbg/8;
00386 #endif
00387 }
00388
00389 if(gr_infos->block_type == 0) {
00390 fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
00391
00392
00393 }
00394
00395 gr_infos->region1start = 36>>1;
00396 gr_infos->region2start = 576>>1;
00397 }
00398 else
00399 {
00400 int i,r0c,r1c;
00401 for (i=0; i<3; i++)
00402 gr_infos->table_select[i] = getbits_fast(mp,5);
00403 r0c = getbits_fast(mp,4);
00404 r1c = getbits_fast(mp,3);
00405 gr_infos->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
00406 gr_infos->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
00407 gr_infos->block_type = 0;
00408 gr_infos->mixed_block_flag = 0;
00409 }
00410 gr_infos->preflag = get1bit(mp);
00411 gr_infos->scalefac_scale = get1bit(mp);
00412 gr_infos->count1table_select = get1bit(mp);
00413 }
00414 }
00415 }
00416
00417
00418
00419
00420 static void III_get_side_info_2(PMPSTR mp, struct III_sideinfo *si,int stereo,
00421 int ms_stereo,long sfreq,int single)
00422 {
00423 int ch;
00424 int powdiff = (single == 3) ? 4 : 0;
00425
00426 si->main_data_begin = getbits(mp,8);
00427
00428 if (stereo == 1)
00429 si->private_bits = get1bit(mp);
00430 else
00431 si->private_bits = getbits_fast(mp,2);
00432
00433 for (ch=0; ch<stereo; ch++)
00434 {
00435 struct gr_info_s *gr_infos = &(si->ch[ch].gr[0]);
00436 unsigned int qss;
00437
00438 gr_infos->part2_3_length = getbits(mp,12);
00439 gr_infos->big_values = getbits_fast(mp,9);
00440 if(gr_infos->big_values > 288) {
00441 fprintf(stderr,"big_values too large! %i\n",gr_infos->big_values);
00442 gr_infos->big_values = 288;
00443 }
00444 qss=getbits_fast(mp,8);
00445 gr_infos->pow2gain = gainpow2+256 - qss + powdiff;
00446 #ifndef NOANALYSIS
00447 if (mpg123_pinfo!=NULL) {
00448 mpg123_pinfo->qss[0][ch]=qss;
00449 }
00450 #endif
00451
00452
00453 if(ms_stereo)
00454 gr_infos->pow2gain += 2;
00455 gr_infos->scalefac_compress = getbits(mp,9);
00456
00457 if(get1bit(mp))
00458 {
00459 int i;
00460 gr_infos->block_type = getbits_fast(mp,2);
00461 gr_infos->mixed_block_flag = get1bit(mp);
00462 gr_infos->table_select[0] = getbits_fast(mp,5);
00463 gr_infos->table_select[1] = getbits_fast(mp,5);
00464
00465
00466
00467
00468 gr_infos->table_select[2] = 0;
00469 for(i=0;i<3;i++) {
00470 unsigned int sbg = (getbits_fast(mp,3)<<3);
00471 gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;
00472 #ifndef NOANALYSIS
00473 if (mpg123_pinfo!=NULL)
00474 mpg123_pinfo->sub_gain[0][ch][i]=sbg/8;
00475 #endif
00476
00477 }
00478
00479 if(gr_infos->block_type == 0) {
00480 fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
00481
00482
00483 }
00484
00485
00486 if(gr_infos->block_type == 2) {
00487 if (sfreq == 8)
00488 gr_infos->region1start = 36;
00489 else
00490 gr_infos->region1start = 36>>1;
00491 }
00492 else if(sfreq == 8)
00493
00494 gr_infos->region1start = 108>>1;
00495 else
00496 gr_infos->region1start = 54>>1;
00497 gr_infos->region2start = 576>>1;
00498 }
00499 else
00500 {
00501 int i,r0c,r1c;
00502 for (i=0; i<3; i++)
00503 gr_infos->table_select[i] = getbits_fast(mp,5);
00504 r0c = getbits_fast(mp,4);
00505 r1c = getbits_fast(mp,3);
00506 gr_infos->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
00507 gr_infos->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
00508 gr_infos->block_type = 0;
00509 gr_infos->mixed_block_flag = 0;
00510 }
00511 gr_infos->scalefac_scale = get1bit(mp);
00512 gr_infos->count1table_select = get1bit(mp);
00513 }
00514 }
00515
00516
00517
00518
00519
00520 static int
00521 III_get_scale_factors_1(PMPSTR mp, int *scf,struct gr_info_s *gr_infos)
00522 {
00523 static const unsigned char slen[2][16] = {
00524 {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
00525 {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
00526 };
00527 int numbits;
00528 int num0 = slen[0][gr_infos->scalefac_compress];
00529 int num1 = slen[1][gr_infos->scalefac_compress];
00530
00531 if (gr_infos->block_type == 2)
00532 {
00533 int i=18;
00534 numbits = (num0 + num1) * 18;
00535
00536 if (gr_infos->mixed_block_flag) {
00537 for (i=8;i;i--)
00538 *scf++ = getbits_fast(mp,num0);
00539 i = 9;
00540 numbits -= num0;
00541 }
00542
00543 for (;i;i--)
00544 *scf++ = getbits_fast(mp,num0);
00545 for (i = 18; i; i--)
00546 *scf++ = getbits_fast(mp,num1);
00547 *scf++ = 0; *scf++ = 0; *scf++ = 0;
00548 }
00549 else
00550 {
00551 int i;
00552 int scfsi = gr_infos->scfsi;
00553
00554 if(scfsi < 0) {
00555 for(i=11;i;i--)
00556 *scf++ = getbits_fast(mp,num0);
00557 for(i=10;i;i--)
00558 *scf++ = getbits_fast(mp,num1);
00559 numbits = (num0 + num1) * 10 + num0;
00560 }
00561 else {
00562 numbits = 0;
00563 if(!(scfsi & 0x8)) {
00564 for (i=6;i;i--)
00565 *scf++ = getbits_fast(mp,num0);
00566 numbits += num0 * 6;
00567 }
00568 else {
00569 scf += 6;
00570 }
00571
00572 if(!(scfsi & 0x4)) {
00573 for (i=5;i;i--)
00574 *scf++ = getbits_fast(mp,num0);
00575 numbits += num0 * 5;
00576 }
00577 else {
00578 scf += 5;
00579 }
00580
00581 if(!(scfsi & 0x2)) {
00582 for(i=5;i;i--)
00583 *scf++ = getbits_fast(mp,num1);
00584 numbits += num1 * 5;
00585 }
00586 else {
00587 scf += 5;
00588 }
00589
00590 if(!(scfsi & 0x1)) {
00591 for (i=5;i;i--)
00592 *scf++ = getbits_fast(mp,num1);
00593 numbits += num1 * 5;
00594 }
00595 else {
00596 scf += 5;
00597 }
00598 }
00599
00600 *scf++ = 0;
00601 }
00602 return numbits;
00603 }
00604
00605
00606 static int
00607 III_get_scale_factors_2(PMPSTR mp, int *scf,struct gr_info_s *gr_infos,int i_stereo)
00608 {
00609 unsigned char *pnt;
00610 int i,j;
00611 unsigned int slen;
00612 int n = 0;
00613 int numbits = 0;
00614
00615 static const unsigned char stab[3][6][4] = {
00616 { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
00617 { 7, 7, 7,0 } , { 6, 6, 6,3 } , { 8, 8,5,0} } ,
00618 { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
00619 {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
00620 { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
00621 { 6,15,12,0 } , { 6,12, 9,6 } , { 6,18,9,0} } };
00622
00623 if(i_stereo)
00624 slen = i_slen2[gr_infos->scalefac_compress>>1];
00625 else
00626 slen = n_slen2[gr_infos->scalefac_compress];
00627
00628 gr_infos->preflag = (slen>>15) & 0x1;
00629
00630 n = 0;
00631 if( gr_infos->block_type == 2 ) {
00632 n++;
00633 if(gr_infos->mixed_block_flag)
00634 n++;
00635 }
00636
00637 pnt = (unsigned char *)stab[n][(slen>>12)&0x7];
00638
00639 for(i=0;i<4;i++) {
00640 int num = slen & 0x7;
00641 slen >>= 3;
00642 if(num) {
00643 for(j=0;j<(int)(pnt[i]);j++)
00644 *scf++ = getbits_fast(mp,num);
00645 numbits += pnt[i] * num;
00646 }
00647 else {
00648 for(j=0;j<(int)(pnt[i]);j++)
00649 *scf++ = 0;
00650 }
00651 }
00652
00653 n = (n << 1) + 1;
00654 for(i=0;i<n;i++)
00655 *scf++ = 0;
00656
00657 return numbits;
00658 }
00659
00660 static const 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};
00661 static const 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};
00662
00663
00664
00665
00666 static int III_dequantize_sample(PMPSTR mp, real xr[SBLIMIT][SSLIMIT],int *scf,
00667 struct gr_info_s *gr_infos,int sfreq,int part2bits)
00668 {
00669 int shift = 1 + gr_infos->scalefac_scale;
00670 real *xrpnt = (real *) xr;
00671 int l[3],l3;
00672 int part2remain = gr_infos->part2_3_length - part2bits;
00673 int *me;
00674
00675 {
00676 int i;
00677
00678 for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i>0;i--) {
00679 *xrpnt++ = 0.0;
00680 *xrpnt++ = 0.0;
00681 }
00682
00683 xrpnt = (real *) xr;
00684 }
00685
00686 {
00687 int bv = gr_infos->big_values;
00688 int region1 = gr_infos->region1start;
00689 int region2 = gr_infos->region2start;
00690
00691 l3 = ((576>>1)-bv)>>1;
00692
00693
00694
00695
00696 if(bv <= region1) {
00697 l[0] = bv; l[1] = 0; l[2] = 0;
00698 }
00699 else {
00700 l[0] = region1;
00701 if(bv <= region2) {
00702 l[1] = bv - l[0]; l[2] = 0;
00703 }
00704 else {
00705 l[1] = region2 - l[0]; l[2] = bv - region2;
00706 }
00707 }
00708 }
00709
00710 {
00711 int i;
00712 for (i = 0; i < 3; i++) {
00713 if (l[i] < 0) {
00714 fprintf(stderr, "mpg123: Bogus region length (%d)\n", l[i]);
00715 l[i] = 0;
00716 }
00717 }
00718 }
00719
00720
00721 if(gr_infos->block_type == 2) {
00722
00723
00724
00725 int i,max[4];
00726 int step=0,lwin=0,cb=0;
00727 real v = 0.0;
00728 int *m,mc;
00729
00730 if(gr_infos->mixed_block_flag) {
00731 max[3] = -1;
00732 max[0] = max[1] = max[2] = 2;
00733 m = map[sfreq][0];
00734 me = mapend[sfreq][0];
00735 }
00736 else {
00737 max[0] = max[1] = max[2] = max[3] = -1;
00738
00739 m = map[sfreq][1];
00740 me = mapend[sfreq][1];
00741 }
00742
00743 mc = 0;
00744 for(i=0;i<2;i++) {
00745 int lp = l[i];
00746 struct newhuff *h = (struct newhuff *)(ht+gr_infos->table_select[i]);
00747 for(;lp;lp--,mc--) {
00748 int x,y;
00749 if( (!mc) ) {
00750 mc = *m++;
00751 xrpnt = ((real *) xr) + (*m++);
00752 lwin = *m++;
00753 cb = *m++;
00754 if(lwin == 3) {
00755 v = gr_infos->pow2gain[(*scf++) << shift];
00756 step = 1;
00757 }
00758 else {
00759 v = gr_infos->full_gain[lwin][(*scf++) << shift];
00760 step = 3;
00761 }
00762 }
00763 {
00764 short *val = (short *)h->table;
00765 while((y=*val++)<0) {
00766 if (get1bit(mp))
00767 val -= y;
00768 part2remain--;
00769 }
00770 x = y >> 4;
00771 y &= 0xf;
00772 }
00773 if(x == 15) {
00774 max[lwin] = cb;
00775 part2remain -= h->linbits+1;
00776 x += getbits(mp,(int)h->linbits);
00777 if(get1bit(mp))
00778 *xrpnt = -ispow[x] * v;
00779 else
00780 *xrpnt = ispow[x] * v;
00781 }
00782 else if(x) {
00783 max[lwin] = cb;
00784 if(get1bit(mp))
00785 *xrpnt = -ispow[x] * v;
00786 else
00787 *xrpnt = ispow[x] * v;
00788 part2remain--;
00789 }
00790 else
00791 *xrpnt = 0.0;
00792 xrpnt += step;
00793 if(y == 15) {
00794 max[lwin] = cb;
00795 part2remain -= h->linbits+1;
00796 y += getbits(mp,(int)h->linbits);
00797 if(get1bit(mp))
00798 *xrpnt = -ispow[y] * v;
00799 else
00800 *xrpnt = ispow[y] * v;
00801 }
00802 else if(y) {
00803 max[lwin] = cb;
00804 if(get1bit(mp))
00805 *xrpnt = -ispow[y] * v;
00806 else
00807 *xrpnt = ispow[y] * v;
00808 part2remain--;
00809 }
00810 else
00811 *xrpnt = 0.0;
00812 xrpnt += step;
00813 }
00814 }
00815 for(;l3 && (part2remain > 0);l3--) {
00816 struct newhuff *h = (struct newhuff *)(htc+gr_infos->count1table_select);
00817 short *val = (short *)h->table,a;
00818
00819 while((a=*val++)<0) {
00820 part2remain--;
00821 if(part2remain < 0) {
00822 part2remain++;
00823 a = 0;
00824 break;
00825 }
00826 if (get1bit(mp))
00827 val -= a;
00828 }
00829 for(i=0;i<4;i++) {
00830 if(!(i & 1)) {
00831 if(!mc) {
00832 mc = *m++;
00833 xrpnt = ((real *) xr) + (*m++);
00834 lwin = *m++;
00835 cb = *m++;
00836 if(lwin == 3) {
00837 v = gr_infos->pow2gain[(*scf++) << shift];
00838 step = 1;
00839 }
00840 else {
00841 v = gr_infos->full_gain[lwin][(*scf++) << shift];
00842 step = 3;
00843 }
00844 }
00845 mc--;
00846 }
00847 if( (a & (0x8>>i)) ) {
00848 max[lwin] = cb;
00849 part2remain--;
00850 if(part2remain < 0) {
00851 part2remain++;
00852 break;
00853 }
00854 if(get1bit(mp))
00855 *xrpnt = -v;
00856 else
00857 *xrpnt = v;
00858 }
00859 else
00860 *xrpnt = 0.0;
00861 xrpnt += step;
00862 }
00863 }
00864
00865 while( m < me ) {
00866 if(!mc) {
00867 mc = *m++;
00868 xrpnt = ((real *) xr) + *m++;
00869 if( (*m++) == 3)
00870 step = 1;
00871 else
00872 step = 3;
00873 m++;
00874 }
00875 mc--;
00876 *xrpnt = 0.0;
00877 xrpnt += step;
00878 *xrpnt = 0.0;
00879 xrpnt += step;
00880
00881
00882
00883
00884
00885 }
00886
00887 gr_infos->maxband[0] = max[0]+1;
00888 gr_infos->maxband[1] = max[1]+1;
00889 gr_infos->maxband[2] = max[2]+1;
00890 gr_infos->maxbandl = max[3]+1;
00891
00892 {
00893 int rmax = max[0] > max[1] ? max[0] : max[1];
00894 rmax = (rmax > max[2] ? rmax : max[2]) + 1;
00895 gr_infos->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];
00896 }
00897
00898 }
00899 else {
00900
00901
00902
00903 int *pretab = (int *)(gr_infos->preflag ? pretab1 : pretab2);
00904 int i,max = -1;
00905 int cb = 0;
00906 int *m = map[sfreq][2];
00907 real v = 0.0;
00908 int mc = 0;
00909
00910
00911
00912
00913 for(i=0;i<3;i++) {
00914 int lp = l[i];
00915 struct newhuff *h = (struct newhuff *)(ht+gr_infos->table_select[i]);
00916
00917 for(;lp;lp--,mc--) {
00918 int x,y;
00919
00920 if(!mc) {
00921 mc = *m++;
00922 v = gr_infos->pow2gain[((*scf++) + (*pretab++)) << shift];
00923 cb = *m++;
00924 }
00925 {
00926 short *val = (short *)h->table;
00927 while((y=*val++)<0) {
00928 if (get1bit(mp))
00929 val -= y;
00930 part2remain--;
00931 }
00932 x = y >> 4;
00933 y &= 0xf;
00934 }
00935 if (x == 15) {
00936 max = cb;
00937 part2remain -= h->linbits+1;
00938 x += getbits(mp,(int)h->linbits);
00939 if(get1bit(mp))
00940 *xrpnt++ = -ispow[x] * v;
00941 else
00942 *xrpnt++ = ispow[x] * v;
00943 }
00944 else if(x) {
00945 max = cb;
00946 if(get1bit(mp))
00947 *xrpnt++ = -ispow[x] * v;
00948 else
00949 *xrpnt++ = ispow[x] * v;
00950 part2remain--;
00951 }
00952 else
00953 *xrpnt++ = 0.0;
00954
00955 if (y == 15) {
00956 max = cb;
00957 part2remain -= h->linbits+1;
00958 y += getbits(mp,(int)h->linbits);
00959 if(get1bit(mp))
00960 *xrpnt++ = -ispow[y] * v;
00961 else
00962 *xrpnt++ = ispow[y] * v;
00963 }
00964 else if(y) {
00965 max = cb;
00966 if(get1bit(mp))
00967 *xrpnt++ = -ispow[y] * v;
00968 else
00969 *xrpnt++ = ispow[y] * v;
00970 part2remain--;
00971 }
00972 else
00973 *xrpnt++ = 0.0;
00974 }
00975 }
00976
00977
00978
00979
00980 for(;l3 && (part2remain > 0);l3--) {
00981 struct newhuff *h = (struct newhuff *)(htc+gr_infos->count1table_select);
00982 short *val = (short *)h->table,a;
00983
00984 while((a=*val++)<0) {
00985 part2remain--;
00986 if(part2remain < 0) {
00987 part2remain++;
00988 a = 0;
00989 break;
00990 }
00991 if (get1bit(mp))
00992 val -= a;
00993 }
00994 for(i=0;i<4;i++) {
00995 if(!(i & 1)) {
00996 if(!mc) {
00997 mc = *m++;
00998 cb = *m++;
00999 v = gr_infos->pow2gain[((*scf++) + (*pretab++)) << shift];
01000 }
01001 mc--;
01002 }
01003 if ( (a & (0x8>>i)) ) {
01004 max = cb;
01005 part2remain--;
01006 if(part2remain < 0) {
01007 part2remain++;
01008 break;
01009 }
01010 if(get1bit(mp))
01011 *xrpnt++ = -v;
01012 else
01013 *xrpnt++ = v;
01014 }
01015 else
01016 *xrpnt++ = 0.0;
01017 }
01018 }
01019
01020
01021
01022
01023 for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) {
01024 *xrpnt++ = 0.0;
01025 *xrpnt++ = 0.0;
01026 }
01027
01028 gr_infos->maxbandl = max+1;
01029 gr_infos->maxb = longLimit[sfreq][gr_infos->maxbandl];
01030 }
01031
01032 while( part2remain > 16 ) {
01033 getbits(mp,16);
01034 part2remain -= 16;
01035 }
01036 if(part2remain > 0)
01037 getbits(mp,part2remain);
01038 else if(part2remain < 0) {
01039 fprintf(stderr,"mpg123: Can't rewind stream by %d bits!\n",-part2remain);
01040 return 1;
01041 }
01042 return 0;
01043 }
01044
01045
01046
01047
01048
01049 static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
01050 struct gr_info_s *gr_infos,int sfreq,int ms_stereo,int lsf)
01051 {
01052 real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
01053 struct bandInfoStruct *bi = (struct bandInfoStruct *)&bandInfo[sfreq];
01054 real *tabl1,*tabl2;
01055
01056 if(lsf) {
01057 int p = gr_infos->scalefac_compress & 0x1;
01058 if(ms_stereo) {
01059 tabl1 = pow1_2[p]; tabl2 = pow2_2[p];
01060 }
01061 else {
01062 tabl1 = pow1_1[p]; tabl2 = pow2_1[p];
01063 }
01064 }
01065 else {
01066 if(ms_stereo) {
01067 tabl1 = tan1_2; tabl2 = tan2_2;
01068 }
01069 else {
01070 tabl1 = tan1_1; tabl2 = tan2_1;
01071 }
01072 }
01073
01074 if (gr_infos->block_type == 2)
01075 {
01076 int lwin,do_l = 0;
01077 if( gr_infos->mixed_block_flag )
01078 do_l = 1;
01079
01080 for (lwin=0;lwin<3;lwin++)
01081 {
01082
01083 int is_p,sb,idx,sfb = gr_infos->maxband[lwin];
01084 if(sfb > 3)
01085 do_l = 0;
01086
01087 for(;sfb<12;sfb++)
01088 {
01089 is_p = scalefac[sfb*3+lwin-gr_infos->mixed_block_flag];
01090 if(is_p != 7) {
01091 real t1,t2;
01092 sb = bi->shortDiff[sfb];
01093 idx = bi->shortIdx[sfb] + lwin;
01094 t1 = tabl1[is_p]; t2 = tabl2[is_p];
01095 for (; sb > 0; sb--,idx+=3)
01096 {
01097 real v = xr[0][idx];
01098 xr[0][idx] = v * t1;
01099 xr[1][idx] = v * t2;
01100 }
01101 }
01102 }
01103
01104 #if 1
01105
01106
01107 is_p = scalefac[11*3+lwin-gr_infos->mixed_block_flag];
01108 sb = bi->shortDiff[12];
01109 idx = bi->shortIdx[12] + lwin;
01110 #else
01111 is_p = scalefac[10*3+lwin-gr_infos->mixed_block_flag];
01112 sb = bi->shortDiff[11];
01113 idx = bi->shortIdx[11] + lwin;
01114 #endif
01115 if(is_p != 7)
01116 {
01117 real t1,t2;
01118 t1 = tabl1[is_p]; t2 = tabl2[is_p];
01119 for ( ; sb > 0; sb--,idx+=3 )
01120 {
01121 real v = xr[0][idx];
01122 xr[0][idx] = v * t1;
01123 xr[1][idx] = v * t2;
01124 }
01125 }
01126 }
01127
01128 if (do_l)
01129 {
01130
01131
01132
01133 int sfb = gr_infos->maxbandl;
01134 int idx = bi->longIdx[sfb];
01135
01136 for ( ; sfb<8; sfb++ )
01137 {
01138 int sb = bi->longDiff[sfb];
01139 int is_p = scalefac[sfb];
01140 if(is_p != 7) {
01141 real t1,t2;
01142 t1 = tabl1[is_p]; t2 = tabl2[is_p];
01143 for ( ; sb > 0; sb--,idx++)
01144 {
01145 real v = xr[0][idx];
01146 xr[0][idx] = v * t1;
01147 xr[1][idx] = v * t2;
01148 }
01149 }
01150 else
01151 idx += sb;
01152 }
01153 }
01154 }
01155 else
01156 {
01157 int sfb = gr_infos->maxbandl;
01158 int is_p,idx = bi->longIdx[sfb];
01159 for ( ; sfb<21; sfb++)
01160 {
01161 int sb = bi->longDiff[sfb];
01162 is_p = scalefac[sfb];
01163 if(is_p != 7) {
01164 real t1,t2;
01165 t1 = tabl1[is_p]; t2 = tabl2[is_p];
01166 for ( ; sb > 0; sb--,idx++)
01167 {
01168 real v = xr[0][idx];
01169 xr[0][idx] = v * t1;
01170 xr[1][idx] = v * t2;
01171 }
01172 }
01173 else
01174 idx += sb;
01175 }
01176
01177 is_p = scalefac[20];
01178 if(is_p != 7)
01179 {
01180 int sb;
01181 real t1 = tabl1[is_p],t2 = tabl2[is_p];
01182
01183 for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ )
01184 {
01185 real v = xr[0][idx];
01186 xr[0][idx] = v * t1;
01187 xr[1][idx] = v * t2;
01188 }
01189 }
01190 }
01191 }
01192
01193 static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_infos)
01194 {
01195 int sblim;
01196
01197 if(gr_infos->block_type == 2)
01198 {
01199 if(!gr_infos->mixed_block_flag)
01200 return;
01201 sblim = 1;
01202 }
01203 else {
01204 sblim = gr_infos->maxb-1;
01205 }
01206
01207
01208
01209
01210 {
01211 int sb;
01212 real *xr1=(real *) xr[1];
01213
01214 for(sb=sblim;sb;sb--,xr1+=10)
01215 {
01216 int ss;
01217 real *cs=aa_cs,*ca=aa_ca;
01218 real *xr2 = xr1;
01219
01220 for(ss=7;ss>=0;ss--)
01221 {
01222 real bu = *--xr2,bd = *xr1;
01223 *xr2 = (bu * (*cs) ) - (bd * (*ca) );
01224 *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
01225 }
01226 }
01227 }
01228 }
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240 static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
01241 {
01242 {
01243 real *in = inbuf;
01244
01245 in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
01246 in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
01247 in[11]+=in[10]; in[10]+=in[9]; in[9] +=in[8];
01248 in[8] +=in[7]; in[7] +=in[6]; in[6] +=in[5];
01249 in[5] +=in[4]; in[4] +=in[3]; in[3] +=in[2];
01250 in[2] +=in[1]; in[1] +=in[0];
01251
01252 in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
01253 in[9] +=in[7]; in[7] +=in[5]; in[5] +=in[3]; in[3] +=in[1];
01254
01255
01256 {
01257
01258 #define MACRO0(v) { \
01259 real tmp; \
01260 out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \
01261 out2[8-(v)] = tmp * w[26-(v)]; } \
01262 sum0 -= sum1; \
01263 ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \
01264 ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)];
01265 #define MACRO1(v) { \
01266 real sum0,sum1; \
01267 sum0 = tmp1a + tmp2a; \
01268 sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \
01269 MACRO0(v); }
01270 #define MACRO2(v) { \
01271 real sum0,sum1; \
01272 sum0 = tmp2a - tmp1a; \
01273 sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; \
01274 MACRO0(v); }
01275
01276 const real *c = COS9;
01277 real *out2 = o2;
01278 real *w = wintab;
01279 real *out1 = o1;
01280 real *ts = tsbuf;
01281
01282 real ta33,ta66,tb33,tb66;
01283
01284 ta33 = in[2*3+0] * c[3];
01285 ta66 = in[2*6+0] * c[6];
01286 tb33 = in[2*3+1] * c[3];
01287 tb66 = in[2*6+1] * c[6];
01288
01289 {
01290 real tmp1a,tmp2a,tmp1b,tmp2b;
01291 tmp1a = in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];
01292 tmp1b = in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];
01293 tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];
01294 tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];
01295
01296 MACRO1(0);
01297 MACRO2(8);
01298 }
01299
01300 {
01301 real tmp1a,tmp2a,tmp1b,tmp2b;
01302 tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3];
01303 tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3];
01304 tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0];
01305 tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1];
01306
01307 MACRO1(1);
01308 MACRO2(7);
01309 }
01310
01311 {
01312 real tmp1a,tmp2a,tmp1b,tmp2b;
01313 tmp1a = in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1];
01314 tmp1b = in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1];
01315 tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];
01316 tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];
01317
01318 MACRO1(2);
01319 MACRO2(6);
01320 }
01321
01322 {
01323 real tmp1a,tmp2a,tmp1b,tmp2b;
01324 tmp1a = in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5];
01325 tmp1b = in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5];
01326 tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2];
01327 tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2];
01328
01329 MACRO1(3);
01330 MACRO2(5);
01331 }
01332
01333 {
01334 real sum0,sum1;
01335 sum0 = in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
01336 sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4];
01337 MACRO0(4);
01338 }
01339 }
01340
01341 }
01342 }
01343
01344
01345
01346
01347 static void dct12(real *in,real *rawout1,real *rawout2,real *wi,real *ts)
01348 {
01349 #define DCT12_PART1 \
01350 in5 = in[5*3]; \
01351 in5 += (in4 = in[4*3]); \
01352 in4 += (in3 = in[3*3]); \
01353 in3 += (in2 = in[2*3]); \
01354 in2 += (in1 = in[1*3]); \
01355 in1 += (in0 = in[0*3]); \
01356 \
01357 in5 += in3; in3 += in1; \
01358 \
01359 in2 *= COS6_1; \
01360 in3 *= COS6_1; \
01361
01362 #define DCT12_PART2 \
01363 in0 += in4 * COS6_2; \
01364 \
01365 in4 = in0 + in2; \
01366 in0 -= in2; \
01367 \
01368 in1 += in5 * COS6_2; \
01369 \
01370 in5 = (in1 + in3) * tfcos12[0]; \
01371 in1 = (in1 - in3) * tfcos12[2]; \
01372 \
01373 in3 = in4 + in5; \
01374 in4 -= in5; \
01375 \
01376 in2 = in0 + in1; \
01377 in0 -= in1;
01378
01379
01380 {
01381 real in0,in1,in2,in3,in4,in5;
01382 real *out1 = rawout1;
01383 ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
01384 ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
01385
01386 DCT12_PART1
01387
01388 {
01389 real tmp0,tmp1 = (in0 - in4);
01390 {
01391 real tmp2 = (in1 - in5) * tfcos12[1];
01392 tmp0 = tmp1 + tmp2;
01393 tmp1 -= tmp2;
01394 }
01395 ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1];
01396 ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];
01397 ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];
01398 ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1];
01399 }
01400
01401 DCT12_PART2
01402
01403 ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0];
01404 ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];
01405 ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];
01406 ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2];
01407
01408 ts[(6+0)*SBLIMIT] = out1[6+0] + in0 * wi[0];
01409 ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0];
01410 ts[(6+2)*SBLIMIT] = out1[6+2] + in4 * wi[2];
01411 ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2];
01412 }
01413
01414 in++;
01415
01416 {
01417 real in0,in1,in2,in3,in4,in5;
01418 real *out2 = rawout2;
01419
01420 DCT12_PART1
01421
01422 {
01423 real tmp0,tmp1 = (in0 - in4);
01424 {
01425 real tmp2 = (in1 - in5) * tfcos12[1];
01426 tmp0 = tmp1 + tmp2;
01427 tmp1 -= tmp2;
01428 }
01429 out2[5-1] = tmp0 * wi[11-1];
01430 out2[0+1] = tmp0 * wi[6+1];
01431 ts[(12+1)*SBLIMIT] += tmp1 * wi[1];
01432 ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1];
01433 }
01434
01435 DCT12_PART2
01436
01437 out2[5-0] = in2 * wi[11-0];
01438 out2[0+0] = in2 * wi[6+0];
01439 out2[0+2] = in3 * wi[6+2];
01440 out2[5-2] = in3 * wi[11-2];
01441
01442 ts[(12+0)*SBLIMIT] += in0 * wi[0];
01443 ts[(17-0)*SBLIMIT] += in0 * wi[5-0];
01444 ts[(12+2)*SBLIMIT] += in4 * wi[2];
01445 ts[(17-2)*SBLIMIT] += in4 * wi[5-2];
01446 }
01447
01448 in++;
01449
01450 {
01451 real in0,in1,in2,in3,in4,in5;
01452 real *out2 = rawout2;
01453 out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
01454
01455 DCT12_PART1
01456
01457 {
01458 real tmp0,tmp1 = (in0 - in4);
01459 {
01460 real tmp2 = (in1 - in5) * tfcos12[1];
01461 tmp0 = tmp1 + tmp2;
01462 tmp1 -= tmp2;
01463 }
01464 out2[11-1] = tmp0 * wi[11-1];
01465 out2[6 +1] = tmp0 * wi[6+1];
01466 out2[0+1] += tmp1 * wi[1];
01467 out2[5-1] += tmp1 * wi[5-1];
01468 }
01469
01470 DCT12_PART2
01471
01472 out2[11-0] = in2 * wi[11-0];
01473 out2[6 +0] = in2 * wi[6+0];
01474 out2[6 +2] = in3 * wi[6+2];
01475 out2[11-2] = in3 * wi[11-2];
01476
01477 out2[0+0] += in0 * wi[0];
01478 out2[5-0] += in0 * wi[5-0];
01479 out2[0+2] += in4 * wi[2];
01480 out2[5-2] += in4 * wi[5-2];
01481 }
01482 }
01483
01484
01485
01486
01487 static void III_hybrid( PMPSTR mp, real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
01488 int ch,struct gr_info_s *gr_infos)
01489 {
01490 real *tspnt = (real *) tsOut;
01491 real (*block)[2][SBLIMIT*SSLIMIT] = mp->hybrid_block;
01492 int *blc = mp->hybrid_blc;
01493 real *rawout1,*rawout2;
01494 int bt;
01495 int sb = 0;
01496
01497 {
01498 int b = blc[ch];
01499 rawout1=block[b][ch];
01500 b=-b+1;
01501 rawout2=block[b][ch];
01502 blc[ch] = b;
01503 }
01504
01505
01506 if(gr_infos->mixed_block_flag) {
01507 sb = 2;
01508 dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
01509 dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
01510 rawout1 += 36; rawout2 += 36; tspnt += 2;
01511 }
01512
01513 bt = gr_infos->block_type;
01514 if(bt == 2) {
01515 for (; sb<(int)gr_infos->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
01516 dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);
01517 dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
01518 }
01519 }
01520 else {
01521 for (; sb<(int)gr_infos->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
01522 dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
01523 dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
01524 }
01525 }
01526
01527 for(;sb<SBLIMIT;sb++,tspnt++) {
01528 int i;
01529 for(i=0;i<SSLIMIT;i++) {
01530 tspnt[i*SBLIMIT] = *rawout1++;
01531 *rawout2++ = 0.0;
01532 }
01533 }
01534 }
01535
01536
01537
01538
01539 struct III_sideinfo sideinfo;
01540
01541 int do_layer3_sideinfo(PMPSTR mp)
01542 {
01543 struct frame *fr = &mp->fr;
01544 int stereo = fr->stereo;
01545 int single = fr->single;
01546 int ms_stereo;
01547 int sfreq = fr->sampling_frequency;
01548 int granules;
01549 int ch,gr,databits;
01550
01551 if(stereo == 1) {
01552 single = 0;
01553 }
01554
01555 if(fr->mode == MPG_MD_JOINT_STEREO) {
01556 ms_stereo = fr->mode_ext & 0x2;
01557 }
01558 else
01559 ms_stereo = 0;
01560
01561
01562 if(fr->lsf) {
01563 granules = 1;
01564 III_get_side_info_2(mp,&sideinfo,stereo,ms_stereo,sfreq,single);
01565 }
01566 else {
01567 granules = 2;
01568 III_get_side_info_1(mp,&sideinfo,stereo,ms_stereo,sfreq,single);
01569 }
01570
01571 databits=0;
01572 for (gr=0 ; gr < granules ; ++gr) {
01573 for (ch=0; ch < stereo ; ++ch) {
01574 struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
01575 databits += gr_infos->part2_3_length;
01576 }
01577 }
01578 return databits-8*sideinfo.main_data_begin;
01579 }
01580
01581
01582
01583 int do_layer3( PMPSTR mp,unsigned char *pcm_sample,int *pcm_point,
01584 int (*synth_1to1_mono_ptr)(PMPSTR,real *,unsigned char *,int *),
01585 int (*synth_1to1_ptr)(PMPSTR,real *,int,unsigned char *, int *) )
01586 {
01587 int gr, ch, ss,clip=0;
01588 int scalefacs[2][39];
01589
01590 struct frame *fr=&(mp->fr);
01591 int stereo = fr->stereo;
01592 int single = fr->single;
01593 int ms_stereo,i_stereo;
01594 int sfreq = fr->sampling_frequency;
01595 int stereo1,granules;
01596
01597 if(set_pointer(mp, (int)sideinfo.main_data_begin) == MP3_ERR)
01598 return 0;
01599
01600 if(stereo == 1) {
01601 stereo1 = 1;
01602 single = 0;
01603 }
01604 else if(single >= 0)
01605 stereo1 = 1;
01606 else
01607 stereo1 = 2;
01608
01609 if(fr->mode == MPG_MD_JOINT_STEREO) {
01610 ms_stereo = fr->mode_ext & 0x2;
01611 i_stereo = fr->mode_ext & 0x1;
01612 }
01613 else
01614 ms_stereo = i_stereo = 0;
01615
01616
01617 if(fr->lsf) {
01618 granules = 1;
01619 }
01620 else {
01621 granules = 2;
01622 }
01623
01624
01625 for (gr=0;gr<granules;gr++)
01626 {
01627 static real hybridIn[2][SBLIMIT][SSLIMIT];
01628 static real hybridOut[2][SSLIMIT][SBLIMIT];
01629
01630 {
01631 struct gr_info_s *gr_infos = &(sideinfo.ch[0].gr[gr]);
01632 long part2bits;
01633
01634 if(fr->lsf)
01635 part2bits = III_get_scale_factors_2(mp,scalefacs[0],gr_infos,0);
01636 else {
01637 part2bits = III_get_scale_factors_1(mp,scalefacs[0],gr_infos);
01638 }
01639
01640 #ifndef NOANALYSIS
01641 if (mpg123_pinfo!=NULL) {
01642 int i;
01643 mpg123_pinfo->sfbits[gr][0] = part2bits;
01644 for (i=0; i<39; i++)
01645 mpg123_pinfo->sfb_s[gr][0][i]=scalefacs[0][i];
01646 }
01647 #endif
01648
01649 if(III_dequantize_sample(mp, hybridIn[0], scalefacs[0],gr_infos,sfreq,part2bits))
01650 return clip;
01651 }
01652 if(stereo == 2) {
01653 struct gr_info_s *gr_infos = &(sideinfo.ch[1].gr[gr]);
01654 long part2bits;
01655 if(fr->lsf)
01656 part2bits = III_get_scale_factors_2(mp,scalefacs[1],gr_infos,i_stereo);
01657 else {
01658 part2bits = III_get_scale_factors_1(mp,scalefacs[1],gr_infos);
01659 }
01660 #ifndef NOANALYSIS
01661 if (mpg123_pinfo!=NULL) {
01662 int i;
01663 mpg123_pinfo->sfbits[gr][1] = part2bits;
01664 for (i=0; i<39; i++)
01665 mpg123_pinfo->sfb_s[gr][1][i]=scalefacs[1][i];
01666 }
01667 #endif
01668
01669 if(III_dequantize_sample(mp, hybridIn[1],scalefacs[1],gr_infos,sfreq,part2bits))
01670 return clip;
01671
01672 if(ms_stereo) {
01673 int i;
01674 for(i=0;i<SBLIMIT*SSLIMIT;i++) {
01675 real tmp0,tmp1;
01676 tmp0 = ((real *) hybridIn[0])[i];
01677 tmp1 = ((real *) hybridIn[1])[i];
01678 ((real *) hybridIn[1])[i] = tmp0 - tmp1;
01679 ((real *) hybridIn[0])[i] = tmp0 + tmp1;
01680 }
01681 }
01682
01683 if(i_stereo)
01684 III_i_stereo(hybridIn,scalefacs[1],gr_infos,sfreq,ms_stereo,fr->lsf);
01685
01686 if(ms_stereo || i_stereo || (single == 3) ) {
01687 if(gr_infos->maxb > sideinfo.ch[0].gr[gr].maxb)
01688 sideinfo.ch[0].gr[gr].maxb = gr_infos->maxb;
01689 else
01690 gr_infos->maxb = sideinfo.ch[0].gr[gr].maxb;
01691 }
01692
01693 switch(single) {
01694 case 3:
01695 {
01696 int i;
01697 real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
01698 for(i=0;i<(int)(SSLIMIT*gr_infos->maxb);i++,in0++)
01699 *in0 = (*in0 + *in1++);
01700 }
01701 break;
01702 case 1:
01703 {
01704 int i;
01705 real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
01706 for(i=0;i<(int)(SSLIMIT*gr_infos->maxb);i++)
01707 *in0++ = *in1++;
01708 }
01709 break;
01710 }
01711 }
01712
01713 #ifndef NOANALYSIS
01714 if (mpg123_pinfo!=NULL) {
01715 int i,sb;
01716 float ifqstep;
01717
01718 mpg123_pinfo->bitrate =
01719 tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
01720 mpg123_pinfo->sampfreq = freqs[sfreq];
01721 mpg123_pinfo->emph = fr->emphasis;
01722 mpg123_pinfo->crc = fr->error_protection;
01723 mpg123_pinfo->padding = fr->padding;
01724 mpg123_pinfo->stereo = fr->stereo;
01725 mpg123_pinfo->js = (fr->mode == MPG_MD_JOINT_STEREO);
01726 mpg123_pinfo->ms_stereo = ms_stereo;
01727 mpg123_pinfo->i_stereo = i_stereo;
01728 mpg123_pinfo->maindata = sideinfo.main_data_begin;
01729
01730 for(ch=0;ch<stereo1;ch++) {
01731 struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
01732 mpg123_pinfo->big_values[gr][ch]=gr_infos->big_values;
01733 mpg123_pinfo->scalefac_scale[gr][ch]=gr_infos->scalefac_scale;
01734 mpg123_pinfo->mixed[gr][ch] = gr_infos->mixed_block_flag;
01735 mpg123_pinfo->mpg123blocktype[gr][ch]=gr_infos->block_type;
01736 mpg123_pinfo->mainbits[gr][ch] = gr_infos->part2_3_length;
01737 mpg123_pinfo->preflag[gr][ch] = gr_infos->preflag;
01738 if (gr==1) mpg123_pinfo->scfsi[ch] = gr_infos->scfsi;
01739 }
01740
01741
01742 for (ch=0;ch<stereo1;ch++) {
01743 struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
01744 ifqstep = ( mpg123_pinfo->scalefac_scale[gr][ch] == 0 ) ? .5 : 1.0;
01745 if (2==gr_infos->block_type) {
01746 for (i=0; i<3; i++) {
01747 for (sb=0; sb<12; sb++) {
01748 int j = 3*sb+i;
01749
01750
01751
01752
01753 mpg123_pinfo->sfb_s[gr][ch][j] = -ifqstep*mpg123_pinfo->sfb_s[gr][ch][j-gr_infos->mixed_block_flag];
01754 mpg123_pinfo->sfb_s[gr][ch][j] -= 2*(mpg123_pinfo->sub_gain[gr][ch][i]);
01755 }
01756 mpg123_pinfo->sfb_s[gr][ch][3*sb+i] = - 2*(mpg123_pinfo->sub_gain[gr][ch][i]);
01757 }
01758 }else{
01759 for (sb=0; sb<21; sb++) {
01760
01761 mpg123_pinfo->sfb[gr][ch][sb] = mpg123_pinfo->sfb_s[gr][ch][sb];
01762 if (gr_infos->preflag) mpg123_pinfo->sfb[gr][ch][sb] += pretab1[sb];
01763 mpg123_pinfo->sfb[gr][ch][sb] *= -ifqstep;
01764 }
01765 mpg123_pinfo->sfb[gr][ch][21]=0;
01766 }
01767 }
01768
01769
01770
01771 for(ch=0;ch<stereo1;ch++) {
01772 int j=0;
01773 for (sb=0;sb<SBLIMIT;sb++)
01774 for(ss=0;ss<SSLIMIT;ss++,j++)
01775 mpg123_pinfo->mpg123xr[gr][ch][j]=hybridIn[ch][sb][ss];
01776 }
01777 }
01778 #endif
01779
01780
01781 for(ch=0;ch<stereo1;ch++) {
01782 struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
01783 III_antialias(hybridIn[ch],gr_infos);
01784 III_hybrid(mp, hybridIn[ch], hybridOut[ch], ch,gr_infos);
01785 }
01786
01787 for(ss=0;ss<SSLIMIT;ss++) {
01788 if(single >= 0) {
01789 clip += (*synth_1to1_mono_ptr)(mp, hybridOut[0][ss],pcm_sample,pcm_point);
01790 }
01791 else {
01792 int p1 = *pcm_point;
01793 clip += (*synth_1to1_ptr)(mp, hybridOut[0][ss],0,pcm_sample,&p1);
01794 clip += (*synth_1to1_ptr)(mp, hybridOut[1][ss],1,pcm_sample,pcm_point);
01795 }
01796 }
01797 }
01798
01799 return clip;
01800 }
01801
01802