00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00027 #include "avcodec.h"
00028 #include "get_bits.h"
00029 #include "dsputil.h"
00030
00031
00032
00033
00034
00035
00036
00037 #include "mpegaudio.h"
00038 #include "mpegaudiodecheader.h"
00039
00040 #include "mathops.h"
00041
00042
00043 #define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
00044 #define FRAC_RND(a) (((a) + (FRAC_ONE/2)) >> FRAC_BITS)
00045
00046 #define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
00047
00048
00049
00050 #define HEADER_SIZE 4
00051
00052 #include "mpegaudiodata.h"
00053 #include "mpegaudiodectab.h"
00054
00055 static void compute_antialias_integer(MPADecodeContext *s, GranuleDef *g);
00056 static void compute_antialias_float(MPADecodeContext *s, GranuleDef *g);
00057
00058
00059 static VLC huff_vlc[16];
00060 static VLC_TYPE huff_vlc_tables[
00061 0+128+128+128+130+128+154+166+
00062 142+204+190+170+542+460+662+414
00063 ][2];
00064 static const int huff_vlc_tables_sizes[16] = {
00065 0, 128, 128, 128, 130, 128, 154, 166,
00066 142, 204, 190, 170, 542, 460, 662, 414
00067 };
00068 static VLC huff_quad_vlc[2];
00069 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
00070 static const int huff_quad_vlc_tables_sizes[2] = {
00071 128, 16
00072 };
00073
00074 static uint16_t band_index_long[9][23];
00075 #include "mpegaudio_tablegen.h"
00076
00077 static int32_t is_table[2][16];
00078 static int32_t is_table_lsf[2][2][16];
00079 static int32_t csa_table[8][4];
00080 static float csa_table_float[8][4];
00081 static int32_t mdct_win[8][36];
00082
00083
00084 static uint16_t scale_factor_modshift[64];
00085
00086 static int32_t scale_factor_mult[15][3];
00087
00088
00089 #define SCALE_GEN(v) \
00090 { FIXR(1.0 * (v)), FIXR(0.7937005259 * (v)), FIXR(0.6299605249 * (v)) }
00091
00092 static const int32_t scale_factor_mult2[3][3] = {
00093 SCALE_GEN(4.0 / 3.0),
00094 SCALE_GEN(4.0 / 5.0),
00095 SCALE_GEN(4.0 / 9.0),
00096 };
00097
00098 DECLARE_ALIGNED(16, MPA_INT, ff_mpa_synth_window)[512];
00099
00104 static void ff_region_offset2size(GranuleDef *g){
00105 int i, k, j=0;
00106 g->region_size[2] = (576 / 2);
00107 for(i=0;i<3;i++) {
00108 k = FFMIN(g->region_size[i], g->big_values);
00109 g->region_size[i] = k - j;
00110 j = k;
00111 }
00112 }
00113
00114 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g){
00115 if (g->block_type == 2)
00116 g->region_size[0] = (36 / 2);
00117 else {
00118 if (s->sample_rate_index <= 2)
00119 g->region_size[0] = (36 / 2);
00120 else if (s->sample_rate_index != 8)
00121 g->region_size[0] = (54 / 2);
00122 else
00123 g->region_size[0] = (108 / 2);
00124 }
00125 g->region_size[1] = (576 / 2);
00126 }
00127
00128 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2){
00129 int l;
00130 g->region_size[0] =
00131 band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
00132
00133 l = FFMIN(ra1 + ra2 + 2, 22);
00134 g->region_size[1] =
00135 band_index_long[s->sample_rate_index][l] >> 1;
00136 }
00137
00138 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g){
00139 if (g->block_type == 2) {
00140 if (g->switch_point) {
00141
00142
00143
00144 if (s->sample_rate_index <= 2)
00145 g->long_end = 8;
00146 else if (s->sample_rate_index != 8)
00147 g->long_end = 6;
00148 else
00149 g->long_end = 4;
00150
00151 g->short_start = 2 + (s->sample_rate_index != 8);
00152 } else {
00153 g->long_end = 0;
00154 g->short_start = 0;
00155 }
00156 } else {
00157 g->short_start = 13;
00158 g->long_end = 22;
00159 }
00160 }
00161
00162
00163
00164 static inline int l1_unscale(int n, int mant, int scale_factor)
00165 {
00166 int shift, mod;
00167 int64_t val;
00168
00169 shift = scale_factor_modshift[scale_factor];
00170 mod = shift & 3;
00171 shift >>= 2;
00172 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
00173 shift += n;
00174
00175 return (int)((val + (1LL << (shift - 1))) >> shift);
00176 }
00177
00178 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
00179 {
00180 int shift, mod, val;
00181
00182 shift = scale_factor_modshift[scale_factor];
00183 mod = shift & 3;
00184 shift >>= 2;
00185
00186 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
00187
00188 if (shift > 0)
00189 val = (val + (1 << (shift - 1))) >> shift;
00190 return val;
00191 }
00192
00193
00194 static inline int l3_unscale(int value, int exponent)
00195 {
00196 unsigned int m;
00197 int e;
00198
00199 e = table_4_3_exp [4*value + (exponent&3)];
00200 m = table_4_3_value[4*value + (exponent&3)];
00201 e -= (exponent >> 2);
00202 assert(e>=1);
00203 if (e > 31)
00204 return 0;
00205 m = (m + (1 << (e-1))) >> e;
00206
00207 return m;
00208 }
00209
00210
00211 #define DEV_ORDER 13
00212
00213 #define POW_FRAC_BITS 24
00214 #define POW_FRAC_ONE (1 << POW_FRAC_BITS)
00215 #define POW_FIX(a) ((int)((a) * POW_FRAC_ONE))
00216 #define POW_MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> POW_FRAC_BITS)
00217
00218 static int dev_4_3_coefs[DEV_ORDER];
00219
00220 #if 0
00221 static int pow_mult3[3] = {
00222 POW_FIX(1.0),
00223 POW_FIX(1.25992104989487316476),
00224 POW_FIX(1.58740105196819947474),
00225 };
00226 #endif
00227
00228 static av_cold void int_pow_init(void)
00229 {
00230 int i, a;
00231
00232 a = POW_FIX(1.0);
00233 for(i=0;i<DEV_ORDER;i++) {
00234 a = POW_MULL(a, POW_FIX(4.0 / 3.0) - i * POW_FIX(1.0)) / (i + 1);
00235 dev_4_3_coefs[i] = a;
00236 }
00237 }
00238
00239 #if 0
00240
00241 static int int_pow(int i, int *exp_ptr)
00242 {
00243 int e, er, eq, j;
00244 int a, a1;
00245
00246
00247 a = i;
00248 e = POW_FRAC_BITS;
00249 while (a < (1 << (POW_FRAC_BITS - 1))) {
00250 a = a << 1;
00251 e--;
00252 }
00253 a -= (1 << POW_FRAC_BITS);
00254 a1 = 0;
00255 for(j = DEV_ORDER - 1; j >= 0; j--)
00256 a1 = POW_MULL(a, dev_4_3_coefs[j] + a1);
00257 a = (1 << POW_FRAC_BITS) + a1;
00258
00259 e = e * 4;
00260 er = e % 3;
00261 eq = e / 3;
00262 a = POW_MULL(a, pow_mult3[er]);
00263 while (a >= 2 * POW_FRAC_ONE) {
00264 a = a >> 1;
00265 eq++;
00266 }
00267
00268 while (a < POW_FRAC_ONE) {
00269 a = a << 1;
00270 eq--;
00271 }
00272
00273 #if POW_FRAC_BITS > FRAC_BITS
00274 a = (a + (1 << (POW_FRAC_BITS - FRAC_BITS - 1))) >> (POW_FRAC_BITS - FRAC_BITS);
00275
00276 if (a >= 2 * (1 << FRAC_BITS)) {
00277 a = a >> 1;
00278 eq++;
00279 }
00280 #endif
00281 *exp_ptr = eq;
00282 return a;
00283 }
00284 #endif
00285
00286 static av_cold int decode_init(AVCodecContext * avctx)
00287 {
00288 MPADecodeContext *s = avctx->priv_data;
00289 static int init=0;
00290 int i, j, k;
00291
00292 s->avctx = avctx;
00293
00294 avctx->sample_fmt= OUT_FMT;
00295 s->error_recognition= avctx->error_recognition;
00296
00297 if(avctx->antialias_algo != FF_AA_FLOAT)
00298 s->compute_antialias= compute_antialias_integer;
00299 else
00300 s->compute_antialias= compute_antialias_float;
00301
00302 if (!init && !avctx->parse_only) {
00303 int offset;
00304
00305
00306 for(i=0;i<64;i++) {
00307 int shift, mod;
00308
00309 shift = (i / 3);
00310 mod = i % 3;
00311 scale_factor_modshift[i] = mod | (shift << 2);
00312 }
00313
00314
00315 for(i=0;i<15;i++) {
00316 int n, norm;
00317 n = i + 2;
00318 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
00319 scale_factor_mult[i][0] = MULL(FIXR(1.0 * 2.0), norm, FRAC_BITS);
00320 scale_factor_mult[i][1] = MULL(FIXR(0.7937005259 * 2.0), norm, FRAC_BITS);
00321 scale_factor_mult[i][2] = MULL(FIXR(0.6299605249 * 2.0), norm, FRAC_BITS);
00322 dprintf(avctx, "%d: norm=%x s=%x %x %x\n",
00323 i, norm,
00324 scale_factor_mult[i][0],
00325 scale_factor_mult[i][1],
00326 scale_factor_mult[i][2]);
00327 }
00328
00329 ff_mpa_synth_init(ff_mpa_synth_window);
00330
00331
00332 offset = 0;
00333 for(i=1;i<16;i++) {
00334 const HuffTable *h = &mpa_huff_tables[i];
00335 int xsize, x, y;
00336 uint8_t tmp_bits [512];
00337 uint16_t tmp_codes[512];
00338
00339 memset(tmp_bits , 0, sizeof(tmp_bits ));
00340 memset(tmp_codes, 0, sizeof(tmp_codes));
00341
00342 xsize = h->xsize;
00343
00344 j = 0;
00345 for(x=0;x<xsize;x++) {
00346 for(y=0;y<xsize;y++){
00347 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
00348 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
00349 }
00350 }
00351
00352
00353 huff_vlc[i].table = huff_vlc_tables+offset;
00354 huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
00355 init_vlc(&huff_vlc[i], 7, 512,
00356 tmp_bits, 1, 1, tmp_codes, 2, 2,
00357 INIT_VLC_USE_NEW_STATIC);
00358 offset += huff_vlc_tables_sizes[i];
00359 }
00360 assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
00361
00362 offset = 0;
00363 for(i=0;i<2;i++) {
00364 huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
00365 huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
00366 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
00367 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
00368 INIT_VLC_USE_NEW_STATIC);
00369 offset += huff_quad_vlc_tables_sizes[i];
00370 }
00371 assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
00372
00373 for(i=0;i<9;i++) {
00374 k = 0;
00375 for(j=0;j<22;j++) {
00376 band_index_long[i][j] = k;
00377 k += band_size_long[i][j];
00378 }
00379 band_index_long[i][22] = k;
00380 }
00381
00382
00383
00384 int_pow_init();
00385 mpegaudio_tableinit();
00386
00387 for(i=0;i<7;i++) {
00388 float f;
00389 int v;
00390 if (i != 6) {
00391 f = tan((double)i * M_PI / 12.0);
00392 v = FIXR(f / (1.0 + f));
00393 } else {
00394 v = FIXR(1.0);
00395 }
00396 is_table[0][i] = v;
00397 is_table[1][6 - i] = v;
00398 }
00399
00400 for(i=7;i<16;i++)
00401 is_table[0][i] = is_table[1][i] = 0.0;
00402
00403 for(i=0;i<16;i++) {
00404 double f;
00405 int e, k;
00406
00407 for(j=0;j<2;j++) {
00408 e = -(j + 1) * ((i + 1) >> 1);
00409 f = pow(2.0, e / 4.0);
00410 k = i & 1;
00411 is_table_lsf[j][k ^ 1][i] = FIXR(f);
00412 is_table_lsf[j][k][i] = FIXR(1.0);
00413 dprintf(avctx, "is_table_lsf %d %d: %x %x\n",
00414 i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]);
00415 }
00416 }
00417
00418 for(i=0;i<8;i++) {
00419 float ci, cs, ca;
00420 ci = ci_table[i];
00421 cs = 1.0 / sqrt(1.0 + ci * ci);
00422 ca = cs * ci;
00423 csa_table[i][0] = FIXHR(cs/4);
00424 csa_table[i][1] = FIXHR(ca/4);
00425 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
00426 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
00427 csa_table_float[i][0] = cs;
00428 csa_table_float[i][1] = ca;
00429 csa_table_float[i][2] = ca + cs;
00430 csa_table_float[i][3] = ca - cs;
00431 }
00432
00433
00434 for(i=0;i<36;i++) {
00435 for(j=0; j<4; j++){
00436 double d;
00437
00438 if(j==2 && i%3 != 1)
00439 continue;
00440
00441 d= sin(M_PI * (i + 0.5) / 36.0);
00442 if(j==1){
00443 if (i>=30) d= 0;
00444 else if(i>=24) d= sin(M_PI * (i - 18 + 0.5) / 12.0);
00445 else if(i>=18) d= 1;
00446 }else if(j==3){
00447 if (i< 6) d= 0;
00448 else if(i< 12) d= sin(M_PI * (i - 6 + 0.5) / 12.0);
00449 else if(i< 18) d= 1;
00450 }
00451
00452 d*= 0.5 / cos(M_PI*(2*i + 19)/72);
00453
00454 if(j==2)
00455 mdct_win[j][i/3] = FIXHR((d / (1<<5)));
00456 else
00457 mdct_win[j][i ] = FIXHR((d / (1<<5)));
00458 }
00459 }
00460
00461
00462
00463 for(j=0;j<4;j++) {
00464 for(i=0;i<36;i+=2) {
00465 mdct_win[j + 4][i] = mdct_win[j][i];
00466 mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
00467 }
00468 }
00469
00470 init = 1;
00471 }
00472
00473 if (avctx->codec_id == CODEC_ID_MP3ADU)
00474 s->adu_mode = 1;
00475 return 0;
00476 }
00477
00478
00479
00480
00481
00482 #define COS0_0 FIXHR(0.50060299823519630134/2)
00483 #define COS0_1 FIXHR(0.50547095989754365998/2)
00484 #define COS0_2 FIXHR(0.51544730992262454697/2)
00485 #define COS0_3 FIXHR(0.53104259108978417447/2)
00486 #define COS0_4 FIXHR(0.55310389603444452782/2)
00487 #define COS0_5 FIXHR(0.58293496820613387367/2)
00488 #define COS0_6 FIXHR(0.62250412303566481615/2)
00489 #define COS0_7 FIXHR(0.67480834145500574602/2)
00490 #define COS0_8 FIXHR(0.74453627100229844977/2)
00491 #define COS0_9 FIXHR(0.83934964541552703873/2)
00492 #define COS0_10 FIXHR(0.97256823786196069369/2)
00493 #define COS0_11 FIXHR(1.16943993343288495515/4)
00494 #define COS0_12 FIXHR(1.48416461631416627724/4)
00495 #define COS0_13 FIXHR(2.05778100995341155085/8)
00496 #define COS0_14 FIXHR(3.40760841846871878570/8)
00497 #define COS0_15 FIXHR(10.19000812354805681150/32)
00498
00499 #define COS1_0 FIXHR(0.50241928618815570551/2)
00500 #define COS1_1 FIXHR(0.52249861493968888062/2)
00501 #define COS1_2 FIXHR(0.56694403481635770368/2)
00502 #define COS1_3 FIXHR(0.64682178335999012954/2)
00503 #define COS1_4 FIXHR(0.78815462345125022473/2)
00504 #define COS1_5 FIXHR(1.06067768599034747134/4)
00505 #define COS1_6 FIXHR(1.72244709823833392782/4)
00506 #define COS1_7 FIXHR(5.10114861868916385802/16)
00507
00508 #define COS2_0 FIXHR(0.50979557910415916894/2)
00509 #define COS2_1 FIXHR(0.60134488693504528054/2)
00510 #define COS2_2 FIXHR(0.89997622313641570463/2)
00511 #define COS2_3 FIXHR(2.56291544774150617881/8)
00512
00513 #define COS3_0 FIXHR(0.54119610014619698439/2)
00514 #define COS3_1 FIXHR(1.30656296487637652785/4)
00515
00516 #define COS4_0 FIXHR(0.70710678118654752439/2)
00517
00518
00519 #define BF(a, b, c, s)\
00520 {\
00521 tmp0 = tab[a] + tab[b];\
00522 tmp1 = tab[a] - tab[b];\
00523 tab[a] = tmp0;\
00524 tab[b] = MULH(tmp1<<(s), c);\
00525 }
00526
00527 #define BF1(a, b, c, d)\
00528 {\
00529 BF(a, b, COS4_0, 1);\
00530 BF(c, d,-COS4_0, 1);\
00531 tab[c] += tab[d];\
00532 }
00533
00534 #define BF2(a, b, c, d)\
00535 {\
00536 BF(a, b, COS4_0, 1);\
00537 BF(c, d,-COS4_0, 1);\
00538 tab[c] += tab[d];\
00539 tab[a] += tab[c];\
00540 tab[c] += tab[b];\
00541 tab[b] += tab[d];\
00542 }
00543
00544 #define ADD(a, b) tab[a] += tab[b]
00545
00546
00547 static void dct32(int32_t *out, int32_t *tab)
00548 {
00549 int tmp0, tmp1;
00550
00551
00552 BF( 0, 31, COS0_0 , 1);
00553 BF(15, 16, COS0_15, 5);
00554
00555 BF( 0, 15, COS1_0 , 1);
00556 BF(16, 31,-COS1_0 , 1);
00557
00558 BF( 7, 24, COS0_7 , 1);
00559 BF( 8, 23, COS0_8 , 1);
00560
00561 BF( 7, 8, COS1_7 , 4);
00562 BF(23, 24,-COS1_7 , 4);
00563
00564 BF( 0, 7, COS2_0 , 1);
00565 BF( 8, 15,-COS2_0 , 1);
00566 BF(16, 23, COS2_0 , 1);
00567 BF(24, 31,-COS2_0 , 1);
00568
00569 BF( 3, 28, COS0_3 , 1);
00570 BF(12, 19, COS0_12, 2);
00571
00572 BF( 3, 12, COS1_3 , 1);
00573 BF(19, 28,-COS1_3 , 1);
00574
00575 BF( 4, 27, COS0_4 , 1);
00576 BF(11, 20, COS0_11, 2);
00577
00578 BF( 4, 11, COS1_4 , 1);
00579 BF(20, 27,-COS1_4 , 1);
00580
00581 BF( 3, 4, COS2_3 , 3);
00582 BF(11, 12,-COS2_3 , 3);
00583 BF(19, 20, COS2_3 , 3);
00584 BF(27, 28,-COS2_3 , 3);
00585
00586 BF( 0, 3, COS3_0 , 1);
00587 BF( 4, 7,-COS3_0 , 1);
00588 BF( 8, 11, COS3_0 , 1);
00589 BF(12, 15,-COS3_0 , 1);
00590 BF(16, 19, COS3_0 , 1);
00591 BF(20, 23,-COS3_0 , 1);
00592 BF(24, 27, COS3_0 , 1);
00593 BF(28, 31,-COS3_0 , 1);
00594
00595
00596
00597
00598 BF( 1, 30, COS0_1 , 1);
00599 BF(14, 17, COS0_14, 3);
00600
00601 BF( 1, 14, COS1_1 , 1);
00602 BF(17, 30,-COS1_1 , 1);
00603
00604 BF( 6, 25, COS0_6 , 1);
00605 BF( 9, 22, COS0_9 , 1);
00606
00607 BF( 6, 9, COS1_6 , 2);
00608 BF(22, 25,-COS1_6 , 2);
00609
00610 BF( 1, 6, COS2_1 , 1);
00611 BF( 9, 14,-COS2_1 , 1);
00612 BF(17, 22, COS2_1 , 1);
00613 BF(25, 30,-COS2_1 , 1);
00614
00615
00616 BF( 2, 29, COS0_2 , 1);
00617 BF(13, 18, COS0_13, 3);
00618
00619 BF( 2, 13, COS1_2 , 1);
00620 BF(18, 29,-COS1_2 , 1);
00621
00622 BF( 5, 26, COS0_5 , 1);
00623 BF(10, 21, COS0_10, 1);
00624
00625 BF( 5, 10, COS1_5 , 2);
00626 BF(21, 26,-COS1_5 , 2);
00627
00628 BF( 2, 5, COS2_2 , 1);
00629 BF(10, 13,-COS2_2 , 1);
00630 BF(18, 21, COS2_2 , 1);
00631 BF(26, 29,-COS2_2 , 1);
00632
00633 BF( 1, 2, COS3_1 , 2);
00634 BF( 5, 6,-COS3_1 , 2);
00635 BF( 9, 10, COS3_1 , 2);
00636 BF(13, 14,-COS3_1 , 2);
00637 BF(17, 18, COS3_1 , 2);
00638 BF(21, 22,-COS3_1 , 2);
00639 BF(25, 26, COS3_1 , 2);
00640 BF(29, 30,-COS3_1 , 2);
00641
00642
00643 BF1( 0, 1, 2, 3);
00644 BF2( 4, 5, 6, 7);
00645 BF1( 8, 9, 10, 11);
00646 BF2(12, 13, 14, 15);
00647 BF1(16, 17, 18, 19);
00648 BF2(20, 21, 22, 23);
00649 BF1(24, 25, 26, 27);
00650 BF2(28, 29, 30, 31);
00651
00652
00653
00654 ADD( 8, 12);
00655 ADD(12, 10);
00656 ADD(10, 14);
00657 ADD(14, 9);
00658 ADD( 9, 13);
00659 ADD(13, 11);
00660 ADD(11, 15);
00661
00662 out[ 0] = tab[0];
00663 out[16] = tab[1];
00664 out[ 8] = tab[2];
00665 out[24] = tab[3];
00666 out[ 4] = tab[4];
00667 out[20] = tab[5];
00668 out[12] = tab[6];
00669 out[28] = tab[7];
00670 out[ 2] = tab[8];
00671 out[18] = tab[9];
00672 out[10] = tab[10];
00673 out[26] = tab[11];
00674 out[ 6] = tab[12];
00675 out[22] = tab[13];
00676 out[14] = tab[14];
00677 out[30] = tab[15];
00678
00679 ADD(24, 28);
00680 ADD(28, 26);
00681 ADD(26, 30);
00682 ADD(30, 25);
00683 ADD(25, 29);
00684 ADD(29, 27);
00685 ADD(27, 31);
00686
00687 out[ 1] = tab[16] + tab[24];
00688 out[17] = tab[17] + tab[25];
00689 out[ 9] = tab[18] + tab[26];
00690 out[25] = tab[19] + tab[27];
00691 out[ 5] = tab[20] + tab[28];
00692 out[21] = tab[21] + tab[29];
00693 out[13] = tab[22] + tab[30];
00694 out[29] = tab[23] + tab[31];
00695 out[ 3] = tab[24] + tab[20];
00696 out[19] = tab[25] + tab[21];
00697 out[11] = tab[26] + tab[22];
00698 out[27] = tab[27] + tab[23];
00699 out[ 7] = tab[28] + tab[18];
00700 out[23] = tab[29] + tab[19];
00701 out[15] = tab[30] + tab[17];
00702 out[31] = tab[31];
00703 }
00704
00705 #if FRAC_BITS <= 15
00706
00707 static inline int round_sample(int *sum)
00708 {
00709 int sum1;
00710 sum1 = (*sum) >> OUT_SHIFT;
00711 *sum &= (1<<OUT_SHIFT)-1;
00712 return av_clip(sum1, OUT_MIN, OUT_MAX);
00713 }
00714
00715
00716 #define MACS(rt, ra, rb) MAC16(rt, ra, rb)
00717
00718
00719 #define MULS(ra, rb) MUL16(ra, rb)
00720
00721 #define MLSS(rt, ra, rb) MLS16(rt, ra, rb)
00722
00723 #else
00724
00725 static inline int round_sample(int64_t *sum)
00726 {
00727 int sum1;
00728 sum1 = (int)((*sum) >> OUT_SHIFT);
00729 *sum &= (1<<OUT_SHIFT)-1;
00730 return av_clip(sum1, OUT_MIN, OUT_MAX);
00731 }
00732
00733 # define MULS(ra, rb) MUL64(ra, rb)
00734 # define MACS(rt, ra, rb) MAC64(rt, ra, rb)
00735 # define MLSS(rt, ra, rb) MLS64(rt, ra, rb)
00736 #endif
00737
00738 #define SUM8(op, sum, w, p) \
00739 { \
00740 op(sum, (w)[0 * 64], (p)[0 * 64]); \
00741 op(sum, (w)[1 * 64], (p)[1 * 64]); \
00742 op(sum, (w)[2 * 64], (p)[2 * 64]); \
00743 op(sum, (w)[3 * 64], (p)[3 * 64]); \
00744 op(sum, (w)[4 * 64], (p)[4 * 64]); \
00745 op(sum, (w)[5 * 64], (p)[5 * 64]); \
00746 op(sum, (w)[6 * 64], (p)[6 * 64]); \
00747 op(sum, (w)[7 * 64], (p)[7 * 64]); \
00748 }
00749
00750 #define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
00751 { \
00752 int tmp;\
00753 tmp = p[0 * 64];\
00754 op1(sum1, (w1)[0 * 64], tmp);\
00755 op2(sum2, (w2)[0 * 64], tmp);\
00756 tmp = p[1 * 64];\
00757 op1(sum1, (w1)[1 * 64], tmp);\
00758 op2(sum2, (w2)[1 * 64], tmp);\
00759 tmp = p[2 * 64];\
00760 op1(sum1, (w1)[2 * 64], tmp);\
00761 op2(sum2, (w2)[2 * 64], tmp);\
00762 tmp = p[3 * 64];\
00763 op1(sum1, (w1)[3 * 64], tmp);\
00764 op2(sum2, (w2)[3 * 64], tmp);\
00765 tmp = p[4 * 64];\
00766 op1(sum1, (w1)[4 * 64], tmp);\
00767 op2(sum2, (w2)[4 * 64], tmp);\
00768 tmp = p[5 * 64];\
00769 op1(sum1, (w1)[5 * 64], tmp);\
00770 op2(sum2, (w2)[5 * 64], tmp);\
00771 tmp = p[6 * 64];\
00772 op1(sum1, (w1)[6 * 64], tmp);\
00773 op2(sum2, (w2)[6 * 64], tmp);\
00774 tmp = p[7 * 64];\
00775 op1(sum1, (w1)[7 * 64], tmp);\
00776 op2(sum2, (w2)[7 * 64], tmp);\
00777 }
00778
00779 void av_cold ff_mpa_synth_init(MPA_INT *window)
00780 {
00781 int i;
00782
00783
00784 for(i=0;i<257;i++) {
00785 int v;
00786 v = ff_mpa_enwindow[i];
00787 #if WFRAC_BITS < 16
00788 v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
00789 #endif
00790 window[i] = v;
00791 if ((i & 63) != 0)
00792 v = -v;
00793 if (i != 0)
00794 window[512 - i] = v;
00795 }
00796 }
00797
00798
00799
00800
00801 void ff_mpa_synth_filter(MPA_INT *synth_buf_ptr, int *synth_buf_offset,
00802 MPA_INT *window, int *dither_state,
00803 OUT_INT *samples, int incr,
00804 int32_t sb_samples[SBLIMIT])
00805 {
00806 register MPA_INT *synth_buf;
00807 register const MPA_INT *w, *w2, *p;
00808 int j, offset;
00809 OUT_INT *samples2;
00810 #if FRAC_BITS <= 15
00811 int32_t tmp[32];
00812 int sum, sum2;
00813 #else
00814 int64_t sum, sum2;
00815 #endif
00816
00817 offset = *synth_buf_offset;
00818 synth_buf = synth_buf_ptr + offset;
00819
00820 #if FRAC_BITS <= 15
00821 dct32(tmp, sb_samples);
00822 for(j=0;j<32;j++) {
00823
00824
00825 synth_buf[j] = av_clip_int16(tmp[j]);
00826 }
00827 #else
00828 dct32(synth_buf, sb_samples);
00829 #endif
00830
00831
00832 memcpy(synth_buf + 512, synth_buf, 32 * sizeof(MPA_INT));
00833
00834 samples2 = samples + 31 * incr;
00835 w = window;
00836 w2 = window + 31;
00837
00838 sum = *dither_state;
00839 p = synth_buf + 16;
00840 SUM8(MACS, sum, w, p);
00841 p = synth_buf + 48;
00842 SUM8(MLSS, sum, w + 32, p);
00843 *samples = round_sample(&sum);
00844 samples += incr;
00845 w++;
00846
00847
00848
00849 for(j=1;j<16;j++) {
00850 sum2 = 0;
00851 p = synth_buf + 16 + j;
00852 SUM8P2(sum, MACS, sum2, MLSS, w, w2, p);
00853 p = synth_buf + 48 - j;
00854 SUM8P2(sum, MLSS, sum2, MLSS, w + 32, w2 + 32, p);
00855
00856 *samples = round_sample(&sum);
00857 samples += incr;
00858 sum += sum2;
00859 *samples2 = round_sample(&sum);
00860 samples2 -= incr;
00861 w++;
00862 w2--;
00863 }
00864
00865 p = synth_buf + 32;
00866 SUM8(MLSS, sum, w + 32, p);
00867 *samples = round_sample(&sum);
00868 *dither_state= sum;
00869
00870 offset = (offset - 32) & 511;
00871 *synth_buf_offset = offset;
00872 }
00873
00874 #define C3 FIXHR(0.86602540378443864676/2)
00875
00876
00877 static const int icos36[9] = {
00878 FIXR(0.50190991877167369479),
00879 FIXR(0.51763809020504152469),
00880 FIXR(0.55168895948124587824),
00881 FIXR(0.61038729438072803416),
00882 FIXR(0.70710678118654752439),
00883 FIXR(0.87172339781054900991),
00884 FIXR(1.18310079157624925896),
00885 FIXR(1.93185165257813657349),
00886 FIXR(5.73685662283492756461),
00887 };
00888
00889
00890 static const int icos36h[9] = {
00891 FIXHR(0.50190991877167369479/2),
00892 FIXHR(0.51763809020504152469/2),
00893 FIXHR(0.55168895948124587824/2),
00894 FIXHR(0.61038729438072803416/2),
00895 FIXHR(0.70710678118654752439/2),
00896 FIXHR(0.87172339781054900991/2),
00897 FIXHR(1.18310079157624925896/4),
00898 FIXHR(1.93185165257813657349/4),
00899
00900 };
00901
00902
00903
00904 static void imdct12(int *out, int *in)
00905 {
00906 int in0, in1, in2, in3, in4, in5, t1, t2;
00907
00908 in0= in[0*3];
00909 in1= in[1*3] + in[0*3];
00910 in2= in[2*3] + in[1*3];
00911 in3= in[3*3] + in[2*3];
00912 in4= in[4*3] + in[3*3];
00913 in5= in[5*3] + in[4*3];
00914 in5 += in3;
00915 in3 += in1;
00916
00917 in2= MULH(2*in2, C3);
00918 in3= MULH(4*in3, C3);
00919
00920 t1 = in0 - in4;
00921 t2 = MULH(2*(in1 - in5), icos36h[4]);
00922
00923 out[ 7]=
00924 out[10]= t1 + t2;
00925 out[ 1]=
00926 out[ 4]= t1 - t2;
00927
00928 in0 += in4>>1;
00929 in4 = in0 + in2;
00930 in5 += 2*in1;
00931 in1 = MULH(in5 + in3, icos36h[1]);
00932 out[ 8]=
00933 out[ 9]= in4 + in1;
00934 out[ 2]=
00935 out[ 3]= in4 - in1;
00936
00937 in0 -= in2;
00938 in5 = MULH(2*(in5 - in3), icos36h[7]);
00939 out[ 0]=
00940 out[ 5]= in0 - in5;
00941 out[ 6]=
00942 out[11]= in0 + in5;
00943 }
00944
00945
00946 #define C1 FIXHR(0.98480775301220805936/2)
00947 #define C2 FIXHR(0.93969262078590838405/2)
00948 #define C3 FIXHR(0.86602540378443864676/2)
00949 #define C4 FIXHR(0.76604444311897803520/2)
00950 #define C5 FIXHR(0.64278760968653932632/2)
00951 #define C6 FIXHR(0.5/2)
00952 #define C7 FIXHR(0.34202014332566873304/2)
00953 #define C8 FIXHR(0.17364817766693034885/2)
00954
00955
00956
00957 static void imdct36(int *out, int *buf, int *in, int *win)
00958 {
00959 int i, j, t0, t1, t2, t3, s0, s1, s2, s3;
00960 int tmp[18], *tmp1, *in1;
00961
00962 for(i=17;i>=1;i--)
00963 in[i] += in[i-1];
00964 for(i=17;i>=3;i-=2)
00965 in[i] += in[i-2];
00966
00967 for(j=0;j<2;j++) {
00968 tmp1 = tmp + j;
00969 in1 = in + j;
00970 #if 0
00971
00972 int64_t t0, t1, t2, t3;
00973 t2 = in1[2*4] + in1[2*8] - in1[2*2];
00974
00975 t3 = (in1[2*0] + (int64_t)(in1[2*6]>>1))<<32;
00976 t1 = in1[2*0] - in1[2*6];
00977 tmp1[ 6] = t1 - (t2>>1);
00978 tmp1[16] = t1 + t2;
00979
00980 t0 = MUL64(2*(in1[2*2] + in1[2*4]), C2);
00981 t1 = MUL64( in1[2*4] - in1[2*8] , -2*C8);
00982 t2 = MUL64(2*(in1[2*2] + in1[2*8]), -C4);
00983
00984 tmp1[10] = (t3 - t0 - t2) >> 32;
00985 tmp1[ 2] = (t3 + t0 + t1) >> 32;
00986 tmp1[14] = (t3 + t2 - t1) >> 32;
00987
00988 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);
00989 t2 = MUL64(2*(in1[2*1] + in1[2*5]), C1);
00990 t3 = MUL64( in1[2*5] - in1[2*7] , -2*C7);
00991 t0 = MUL64(2*in1[2*3], C3);
00992
00993 t1 = MUL64(2*(in1[2*1] + in1[2*7]), -C5);
00994
00995 tmp1[ 0] = (t2 + t3 + t0) >> 32;
00996 tmp1[12] = (t2 + t1 - t0) >> 32;
00997 tmp1[ 8] = (t3 - t1 - t0) >> 32;
00998 #else
00999 t2 = in1[2*4] + in1[2*8] - in1[2*2];
01000
01001 t3 = in1[2*0] + (in1[2*6]>>1);
01002 t1 = in1[2*0] - in1[2*6];
01003 tmp1[ 6] = t1 - (t2>>1);
01004 tmp1[16] = t1 + t2;
01005
01006 t0 = MULH(2*(in1[2*2] + in1[2*4]), C2);
01007 t1 = MULH( in1[2*4] - in1[2*8] , -2*C8);
01008 t2 = MULH(2*(in1[2*2] + in1[2*8]), -C4);
01009
01010 tmp1[10] = t3 - t0 - t2;
01011 tmp1[ 2] = t3 + t0 + t1;
01012 tmp1[14] = t3 + t2 - t1;
01013
01014 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);
01015 t2 = MULH(2*(in1[2*1] + in1[2*5]), C1);
01016 t3 = MULH( in1[2*5] - in1[2*7] , -2*C7);
01017 t0 = MULH(2*in1[2*3], C3);
01018
01019 t1 = MULH(2*(in1[2*1] + in1[2*7]), -C5);
01020
01021 tmp1[ 0] = t2 + t3 + t0;
01022 tmp1[12] = t2 + t1 - t0;
01023 tmp1[ 8] = t3 - t1 - t0;
01024 #endif
01025 }
01026
01027 i = 0;
01028 for(j=0;j<4;j++) {
01029 t0 = tmp[i];
01030 t1 = tmp[i + 2];
01031 s0 = t1 + t0;
01032 s2 = t1 - t0;
01033
01034 t2 = tmp[i + 1];
01035 t3 = tmp[i + 3];
01036 s1 = MULH(2*(t3 + t2), icos36h[j]);
01037 s3 = MULL(t3 - t2, icos36[8 - j], FRAC_BITS);
01038
01039 t0 = s0 + s1;
01040 t1 = s0 - s1;
01041 out[(9 + j)*SBLIMIT] = MULH(t1, win[9 + j]) + buf[9 + j];
01042 out[(8 - j)*SBLIMIT] = MULH(t1, win[8 - j]) + buf[8 - j];
01043 buf[9 + j] = MULH(t0, win[18 + 9 + j]);
01044 buf[8 - j] = MULH(t0, win[18 + 8 - j]);
01045
01046 t0 = s2 + s3;
01047 t1 = s2 - s3;
01048 out[(9 + 8 - j)*SBLIMIT] = MULH(t1, win[9 + 8 - j]) + buf[9 + 8 - j];
01049 out[( j)*SBLIMIT] = MULH(t1, win[ j]) + buf[ j];
01050 buf[9 + 8 - j] = MULH(t0, win[18 + 9 + 8 - j]);
01051 buf[ + j] = MULH(t0, win[18 + j]);
01052 i += 4;
01053 }
01054
01055 s0 = tmp[16];
01056 s1 = MULH(2*tmp[17], icos36h[4]);
01057 t0 = s0 + s1;
01058 t1 = s0 - s1;
01059 out[(9 + 4)*SBLIMIT] = MULH(t1, win[9 + 4]) + buf[9 + 4];
01060 out[(8 - 4)*SBLIMIT] = MULH(t1, win[8 - 4]) + buf[8 - 4];
01061 buf[9 + 4] = MULH(t0, win[18 + 9 + 4]);
01062 buf[8 - 4] = MULH(t0, win[18 + 8 - 4]);
01063 }
01064
01065
01066 static int mp_decode_layer1(MPADecodeContext *s)
01067 {
01068 int bound, i, v, n, ch, j, mant;
01069 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
01070 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
01071
01072 if (s->mode == MPA_JSTEREO)
01073 bound = (s->mode_ext + 1) * 4;
01074 else
01075 bound = SBLIMIT;
01076
01077
01078 for(i=0;i<bound;i++) {
01079 for(ch=0;ch<s->nb_channels;ch++) {
01080 allocation[ch][i] = get_bits(&s->gb, 4);
01081 }
01082 }
01083 for(i=bound;i<SBLIMIT;i++) {
01084 allocation[0][i] = get_bits(&s->gb, 4);
01085 }
01086
01087
01088 for(i=0;i<bound;i++) {
01089 for(ch=0;ch<s->nb_channels;ch++) {
01090 if (allocation[ch][i])
01091 scale_factors[ch][i] = get_bits(&s->gb, 6);
01092 }
01093 }
01094 for(i=bound;i<SBLIMIT;i++) {
01095 if (allocation[0][i]) {
01096 scale_factors[0][i] = get_bits(&s->gb, 6);
01097 scale_factors[1][i] = get_bits(&s->gb, 6);
01098 }
01099 }
01100
01101
01102 for(j=0;j<12;j++) {
01103 for(i=0;i<bound;i++) {
01104 for(ch=0;ch<s->nb_channels;ch++) {
01105 n = allocation[ch][i];
01106 if (n) {
01107 mant = get_bits(&s->gb, n + 1);
01108 v = l1_unscale(n, mant, scale_factors[ch][i]);
01109 } else {
01110 v = 0;
01111 }
01112 s->sb_samples[ch][j][i] = v;
01113 }
01114 }
01115 for(i=bound;i<SBLIMIT;i++) {
01116 n = allocation[0][i];
01117 if (n) {
01118 mant = get_bits(&s->gb, n + 1);
01119 v = l1_unscale(n, mant, scale_factors[0][i]);
01120 s->sb_samples[0][j][i] = v;
01121 v = l1_unscale(n, mant, scale_factors[1][i]);
01122 s->sb_samples[1][j][i] = v;
01123 } else {
01124 s->sb_samples[0][j][i] = 0;
01125 s->sb_samples[1][j][i] = 0;
01126 }
01127 }
01128 }
01129 return 12;
01130 }
01131
01132 static int mp_decode_layer2(MPADecodeContext *s)
01133 {
01134 int sblimit;
01135 const unsigned char *alloc_table;
01136 int table, bit_alloc_bits, i, j, ch, bound, v;
01137 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
01138 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
01139 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
01140 int scale, qindex, bits, steps, k, l, m, b;
01141
01142
01143 table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
01144 s->sample_rate, s->lsf);
01145 sblimit = ff_mpa_sblimit_table[table];
01146 alloc_table = ff_mpa_alloc_tables[table];
01147
01148 if (s->mode == MPA_JSTEREO)
01149 bound = (s->mode_ext + 1) * 4;
01150 else
01151 bound = sblimit;
01152
01153 dprintf(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
01154
01155
01156 if( bound > sblimit ) bound = sblimit;
01157
01158
01159 j = 0;
01160 for(i=0;i<bound;i++) {
01161 bit_alloc_bits = alloc_table[j];
01162 for(ch=0;ch<s->nb_channels;ch++) {
01163 bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
01164 }
01165 j += 1 << bit_alloc_bits;
01166 }
01167 for(i=bound;i<sblimit;i++) {
01168 bit_alloc_bits = alloc_table[j];
01169 v = get_bits(&s->gb, bit_alloc_bits);
01170 bit_alloc[0][i] = v;
01171 bit_alloc[1][i] = v;
01172 j += 1 << bit_alloc_bits;
01173 }
01174
01175
01176 for(i=0;i<sblimit;i++) {
01177 for(ch=0;ch<s->nb_channels;ch++) {
01178 if (bit_alloc[ch][i])
01179 scale_code[ch][i] = get_bits(&s->gb, 2);
01180 }
01181 }
01182
01183
01184 for(i=0;i<sblimit;i++) {
01185 for(ch=0;ch<s->nb_channels;ch++) {
01186 if (bit_alloc[ch][i]) {
01187 sf = scale_factors[ch][i];
01188 switch(scale_code[ch][i]) {
01189 default:
01190 case 0:
01191 sf[0] = get_bits(&s->gb, 6);
01192 sf[1] = get_bits(&s->gb, 6);
01193 sf[2] = get_bits(&s->gb, 6);
01194 break;
01195 case 2:
01196 sf[0] = get_bits(&s->gb, 6);
01197 sf[1] = sf[0];
01198 sf[2] = sf[0];
01199 break;
01200 case 1:
01201 sf[0] = get_bits(&s->gb, 6);
01202 sf[2] = get_bits(&s->gb, 6);
01203 sf[1] = sf[0];
01204 break;
01205 case 3:
01206 sf[0] = get_bits(&s->gb, 6);
01207 sf[2] = get_bits(&s->gb, 6);
01208 sf[1] = sf[2];
01209 break;
01210 }
01211 }
01212 }
01213 }
01214
01215
01216 for(k=0;k<3;k++) {
01217 for(l=0;l<12;l+=3) {
01218 j = 0;
01219 for(i=0;i<bound;i++) {
01220 bit_alloc_bits = alloc_table[j];
01221 for(ch=0;ch<s->nb_channels;ch++) {
01222 b = bit_alloc[ch][i];
01223 if (b) {
01224 scale = scale_factors[ch][i][k];
01225 qindex = alloc_table[j+b];
01226 bits = ff_mpa_quant_bits[qindex];
01227 if (bits < 0) {
01228
01229 v = get_bits(&s->gb, -bits);
01230 steps = ff_mpa_quant_steps[qindex];
01231 s->sb_samples[ch][k * 12 + l + 0][i] =
01232 l2_unscale_group(steps, v % steps, scale);
01233 v = v / steps;
01234 s->sb_samples[ch][k * 12 + l + 1][i] =
01235 l2_unscale_group(steps, v % steps, scale);
01236 v = v / steps;
01237 s->sb_samples[ch][k * 12 + l + 2][i] =
01238 l2_unscale_group(steps, v, scale);
01239 } else {
01240 for(m=0;m<3;m++) {
01241 v = get_bits(&s->gb, bits);
01242 v = l1_unscale(bits - 1, v, scale);
01243 s->sb_samples[ch][k * 12 + l + m][i] = v;
01244 }
01245 }
01246 } else {
01247 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
01248 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
01249 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
01250 }
01251 }
01252
01253 j += 1 << bit_alloc_bits;
01254 }
01255
01256 for(i=bound;i<sblimit;i++) {
01257 bit_alloc_bits = alloc_table[j];
01258 b = bit_alloc[0][i];
01259 if (b) {
01260 int mant, scale0, scale1;
01261 scale0 = scale_factors[0][i][k];
01262 scale1 = scale_factors[1][i][k];
01263 qindex = alloc_table[j+b];
01264 bits = ff_mpa_quant_bits[qindex];
01265 if (bits < 0) {
01266
01267 v = get_bits(&s->gb, -bits);
01268 steps = ff_mpa_quant_steps[qindex];
01269 mant = v % steps;
01270 v = v / steps;
01271 s->sb_samples[0][k * 12 + l + 0][i] =
01272 l2_unscale_group(steps, mant, scale0);
01273 s->sb_samples[1][k * 12 + l + 0][i] =
01274 l2_unscale_group(steps, mant, scale1);
01275 mant = v % steps;
01276 v = v / steps;
01277 s->sb_samples[0][k * 12 + l + 1][i] =
01278 l2_unscale_group(steps, mant, scale0);
01279 s->sb_samples[1][k * 12 + l + 1][i] =
01280 l2_unscale_group(steps, mant, scale1);
01281 s->sb_samples[0][k * 12 + l + 2][i] =
01282 l2_unscale_group(steps, v, scale0);
01283 s->sb_samples[1][k * 12 + l + 2][i] =
01284 l2_unscale_group(steps, v, scale1);
01285 } else {
01286 for(m=0;m<3;m++) {
01287 mant = get_bits(&s->gb, bits);
01288 s->sb_samples[0][k * 12 + l + m][i] =
01289 l1_unscale(bits - 1, mant, scale0);
01290 s->sb_samples[1][k * 12 + l + m][i] =
01291 l1_unscale(bits - 1, mant, scale1);
01292 }
01293 }
01294 } else {
01295 s->sb_samples[0][k * 12 + l + 0][i] = 0;
01296 s->sb_samples[0][k * 12 + l + 1][i] = 0;
01297 s->sb_samples[0][k * 12 + l + 2][i] = 0;
01298 s->sb_samples[1][k * 12 + l + 0][i] = 0;
01299 s->sb_samples[1][k * 12 + l + 1][i] = 0;
01300 s->sb_samples[1][k * 12 + l + 2][i] = 0;
01301 }
01302
01303 j += 1 << bit_alloc_bits;
01304 }
01305
01306 for(i=sblimit;i<SBLIMIT;i++) {
01307 for(ch=0;ch<s->nb_channels;ch++) {
01308 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
01309 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
01310 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
01311 }
01312 }
01313 }
01314 }
01315 return 3 * 12;
01316 }
01317
01318 static inline void lsf_sf_expand(int *slen,
01319 int sf, int n1, int n2, int n3)
01320 {
01321 if (n3) {
01322 slen[3] = sf % n3;
01323 sf /= n3;
01324 } else {
01325 slen[3] = 0;
01326 }
01327 if (n2) {
01328 slen[2] = sf % n2;
01329 sf /= n2;
01330 } else {
01331 slen[2] = 0;
01332 }
01333 slen[1] = sf % n1;
01334 sf /= n1;
01335 slen[0] = sf;
01336 }
01337
01338 static void exponents_from_scale_factors(MPADecodeContext *s,
01339 GranuleDef *g,
01340 int16_t *exponents)
01341 {
01342 const uint8_t *bstab, *pretab;
01343 int len, i, j, k, l, v0, shift, gain, gains[3];
01344 int16_t *exp_ptr;
01345
01346 exp_ptr = exponents;
01347 gain = g->global_gain - 210;
01348 shift = g->scalefac_scale + 1;
01349
01350 bstab = band_size_long[s->sample_rate_index];
01351 pretab = mpa_pretab[g->preflag];
01352 for(i=0;i<g->long_end;i++) {
01353 v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
01354 len = bstab[i];
01355 for(j=len;j>0;j--)
01356 *exp_ptr++ = v0;
01357 }
01358
01359 if (g->short_start < 13) {
01360 bstab = band_size_short[s->sample_rate_index];
01361 gains[0] = gain - (g->subblock_gain[0] << 3);
01362 gains[1] = gain - (g->subblock_gain[1] << 3);
01363 gains[2] = gain - (g->subblock_gain[2] << 3);
01364 k = g->long_end;
01365 for(i=g->short_start;i<13;i++) {
01366 len = bstab[i];
01367 for(l=0;l<3;l++) {
01368 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
01369 for(j=len;j>0;j--)
01370 *exp_ptr++ = v0;
01371 }
01372 }
01373 }
01374 }
01375
01376
01377 static inline int get_bitsz(GetBitContext *s, int n)
01378 {
01379 if (n == 0)
01380 return 0;
01381 else
01382 return get_bits(s, n);
01383 }
01384
01385
01386 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos, int *end_pos2){
01387 if(s->in_gb.buffer && *pos >= s->gb.size_in_bits){
01388 s->gb= s->in_gb;
01389 s->in_gb.buffer=NULL;
01390 assert((get_bits_count(&s->gb) & 7) == 0);
01391 skip_bits_long(&s->gb, *pos - *end_pos);
01392 *end_pos2=
01393 *end_pos= *end_pos2 + get_bits_count(&s->gb) - *pos;
01394 *pos= get_bits_count(&s->gb);
01395 }
01396 }
01397
01398 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
01399 int16_t *exponents, int end_pos2)
01400 {
01401 int s_index;
01402 int i;
01403 int last_pos, bits_left;
01404 VLC *vlc;
01405 int end_pos= FFMIN(end_pos2, s->gb.size_in_bits);
01406
01407
01408 s_index = 0;
01409 for(i=0;i<3;i++) {
01410 int j, k, l, linbits;
01411 j = g->region_size[i];
01412 if (j == 0)
01413 continue;
01414
01415 k = g->table_select[i];
01416 l = mpa_huff_data[k][0];
01417 linbits = mpa_huff_data[k][1];
01418 vlc = &huff_vlc[l];
01419
01420 if(!l){
01421 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*2*j);
01422 s_index += 2*j;
01423 continue;
01424 }
01425
01426
01427 for(;j>0;j--) {
01428 int exponent, x, y, v;
01429 int pos= get_bits_count(&s->gb);
01430
01431 if (pos >= end_pos){
01432
01433 switch_buffer(s, &pos, &end_pos, &end_pos2);
01434
01435 if(pos >= end_pos)
01436 break;
01437 }
01438 y = get_vlc2(&s->gb, vlc->table, 7, 3);
01439
01440 if(!y){
01441 g->sb_hybrid[s_index ] =
01442 g->sb_hybrid[s_index+1] = 0;
01443 s_index += 2;
01444 continue;
01445 }
01446
01447 exponent= exponents[s_index];
01448
01449 dprintf(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
01450 i, g->region_size[i] - j, x, y, exponent);
01451 if(y&16){
01452 x = y >> 5;
01453 y = y & 0x0f;
01454 if (x < 15){
01455 v = expval_table[ exponent ][ x ];
01456
01457 }else{
01458 x += get_bitsz(&s->gb, linbits);
01459 v = l3_unscale(x, exponent);
01460 }
01461 if (get_bits1(&s->gb))
01462 v = -v;
01463 g->sb_hybrid[s_index] = v;
01464 if (y < 15){
01465 v = expval_table[ exponent ][ y ];
01466 }else{
01467 y += get_bitsz(&s->gb, linbits);
01468 v = l3_unscale(y, exponent);
01469 }
01470 if (get_bits1(&s->gb))
01471 v = -v;
01472 g->sb_hybrid[s_index+1] = v;
01473 }else{
01474 x = y >> 5;
01475 y = y & 0x0f;
01476 x += y;
01477 if (x < 15){
01478 v = expval_table[ exponent ][ x ];
01479 }else{
01480 x += get_bitsz(&s->gb, linbits);
01481 v = l3_unscale(x, exponent);
01482 }
01483 if (get_bits1(&s->gb))
01484 v = -v;
01485 g->sb_hybrid[s_index+!!y] = v;
01486 g->sb_hybrid[s_index+ !y] = 0;
01487 }
01488 s_index+=2;
01489 }
01490 }
01491
01492
01493 vlc = &huff_quad_vlc[g->count1table_select];
01494 last_pos=0;
01495 while (s_index <= 572) {
01496 int pos, code;
01497 pos = get_bits_count(&s->gb);
01498 if (pos >= end_pos) {
01499 if (pos > end_pos2 && last_pos){
01500
01501
01502 s_index -= 4;
01503 skip_bits_long(&s->gb, last_pos - pos);
01504 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
01505 if(s->error_recognition >= FF_ER_COMPLIANT)
01506 s_index=0;
01507 break;
01508 }
01509
01510 switch_buffer(s, &pos, &end_pos, &end_pos2);
01511
01512 if(pos >= end_pos)
01513 break;
01514 }
01515 last_pos= pos;
01516
01517 code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
01518 dprintf(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
01519 g->sb_hybrid[s_index+0]=
01520 g->sb_hybrid[s_index+1]=
01521 g->sb_hybrid[s_index+2]=
01522 g->sb_hybrid[s_index+3]= 0;
01523 while(code){
01524 static const int idxtab[16]={3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0};
01525 int v;
01526 int pos= s_index+idxtab[code];
01527 code ^= 8>>idxtab[code];
01528 v = exp_table[ exponents[pos] ];
01529
01530 if(get_bits1(&s->gb))
01531 v = -v;
01532 g->sb_hybrid[pos] = v;
01533 }
01534 s_index+=4;
01535 }
01536
01537 bits_left = end_pos2 - get_bits_count(&s->gb);
01538
01539 if (bits_left < 0 && s->error_recognition >= FF_ER_COMPLIANT) {
01540 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
01541 s_index=0;
01542 }else if(bits_left > 0 && s->error_recognition >= FF_ER_AGGRESSIVE){
01543 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
01544 s_index=0;
01545 }
01546 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index));
01547 skip_bits_long(&s->gb, bits_left);
01548
01549 i= get_bits_count(&s->gb);
01550 switch_buffer(s, &i, &end_pos, &end_pos2);
01551
01552 return 0;
01553 }
01554
01555
01556
01557
01558 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
01559 {
01560 int i, j, len;
01561 int32_t *ptr, *dst, *ptr1;
01562 int32_t tmp[576];
01563
01564 if (g->block_type != 2)
01565 return;
01566
01567 if (g->switch_point) {
01568 if (s->sample_rate_index != 8) {
01569 ptr = g->sb_hybrid + 36;
01570 } else {
01571 ptr = g->sb_hybrid + 48;
01572 }
01573 } else {
01574 ptr = g->sb_hybrid;
01575 }
01576
01577 for(i=g->short_start;i<13;i++) {
01578 len = band_size_short[s->sample_rate_index][i];
01579 ptr1 = ptr;
01580 dst = tmp;
01581 for(j=len;j>0;j--) {
01582 *dst++ = ptr[0*len];
01583 *dst++ = ptr[1*len];
01584 *dst++ = ptr[2*len];
01585 ptr++;
01586 }
01587 ptr+=2*len;
01588 memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
01589 }
01590 }
01591
01592 #define ISQRT2 FIXR(0.70710678118654752440)
01593
01594 static void compute_stereo(MPADecodeContext *s,
01595 GranuleDef *g0, GranuleDef *g1)
01596 {
01597 int i, j, k, l;
01598 int32_t v1, v2;
01599 int sf_max, tmp0, tmp1, sf, len, non_zero_found;
01600 int32_t (*is_tab)[16];
01601 int32_t *tab0, *tab1;
01602 int non_zero_found_short[3];
01603
01604
01605 if (s->mode_ext & MODE_EXT_I_STEREO) {
01606 if (!s->lsf) {
01607 is_tab = is_table;
01608 sf_max = 7;
01609 } else {
01610 is_tab = is_table_lsf[g1->scalefac_compress & 1];
01611 sf_max = 16;
01612 }
01613
01614 tab0 = g0->sb_hybrid + 576;
01615 tab1 = g1->sb_hybrid + 576;
01616
01617 non_zero_found_short[0] = 0;
01618 non_zero_found_short[1] = 0;
01619 non_zero_found_short[2] = 0;
01620 k = (13 - g1->short_start) * 3 + g1->long_end - 3;
01621 for(i = 12;i >= g1->short_start;i--) {
01622
01623 if (i != 11)
01624 k -= 3;
01625 len = band_size_short[s->sample_rate_index][i];
01626 for(l=2;l>=0;l--) {
01627 tab0 -= len;
01628 tab1 -= len;
01629 if (!non_zero_found_short[l]) {
01630
01631 for(j=0;j<len;j++) {
01632 if (tab1[j] != 0) {
01633 non_zero_found_short[l] = 1;
01634 goto found1;
01635 }
01636 }
01637 sf = g1->scale_factors[k + l];
01638 if (sf >= sf_max)
01639 goto found1;
01640
01641 v1 = is_tab[0][sf];
01642 v2 = is_tab[1][sf];
01643 for(j=0;j<len;j++) {
01644 tmp0 = tab0[j];
01645 tab0[j] = MULL(tmp0, v1, FRAC_BITS);
01646 tab1[j] = MULL(tmp0, v2, FRAC_BITS);
01647 }
01648 } else {
01649 found1:
01650 if (s->mode_ext & MODE_EXT_MS_STEREO) {
01651
01652
01653 for(j=0;j<len;j++) {
01654 tmp0 = tab0[j];
01655 tmp1 = tab1[j];
01656 tab0[j] = MULL(tmp0 + tmp1, ISQRT2, FRAC_BITS);
01657 tab1[j] = MULL(tmp0 - tmp1, ISQRT2, FRAC_BITS);
01658 }
01659 }
01660 }
01661 }
01662 }
01663
01664 non_zero_found = non_zero_found_short[0] |
01665 non_zero_found_short[1] |
01666 non_zero_found_short[2];
01667
01668 for(i = g1->long_end - 1;i >= 0;i--) {
01669 len = band_size_long[s->sample_rate_index][i];
01670 tab0 -= len;
01671 tab1 -= len;
01672
01673 if (!non_zero_found) {
01674 for(j=0;j<len;j++) {
01675 if (tab1[j] != 0) {
01676 non_zero_found = 1;
01677 goto found2;
01678 }
01679 }
01680
01681 k = (i == 21) ? 20 : i;
01682 sf = g1->scale_factors[k];
01683 if (sf >= sf_max)
01684 goto found2;
01685 v1 = is_tab[0][sf];
01686 v2 = is_tab[1][sf];
01687 for(j=0;j<len;j++) {
01688 tmp0 = tab0[j];
01689 tab0[j] = MULL(tmp0, v1, FRAC_BITS);
01690 tab1[j] = MULL(tmp0, v2, FRAC_BITS);
01691 }
01692 } else {
01693 found2:
01694 if (s->mode_ext & MODE_EXT_MS_STEREO) {
01695
01696
01697 for(j=0;j<len;j++) {
01698 tmp0 = tab0[j];
01699 tmp1 = tab1[j];
01700 tab0[j] = MULL(tmp0 + tmp1, ISQRT2, FRAC_BITS);
01701 tab1[j] = MULL(tmp0 - tmp1, ISQRT2, FRAC_BITS);
01702 }
01703 }
01704 }
01705 }
01706 } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
01707
01708
01709
01710 tab0 = g0->sb_hybrid;
01711 tab1 = g1->sb_hybrid;
01712 for(i=0;i<576;i++) {
01713 tmp0 = tab0[i];
01714 tmp1 = tab1[i];
01715 tab0[i] = tmp0 + tmp1;
01716 tab1[i] = tmp0 - tmp1;
01717 }
01718 }
01719 }
01720
01721 static void compute_antialias_integer(MPADecodeContext *s,
01722 GranuleDef *g)
01723 {
01724 int32_t *ptr, *csa;
01725 int n, i;
01726
01727
01728 if (g->block_type == 2) {
01729 if (!g->switch_point)
01730 return;
01731
01732 n = 1;
01733 } else {
01734 n = SBLIMIT - 1;
01735 }
01736
01737 ptr = g->sb_hybrid + 18;
01738 for(i = n;i > 0;i--) {
01739 int tmp0, tmp1, tmp2;
01740 csa = &csa_table[0][0];
01741 #define INT_AA(j) \
01742 tmp0 = ptr[-1-j];\
01743 tmp1 = ptr[ j];\
01744 tmp2= MULH(tmp0 + tmp1, csa[0+4*j]);\
01745 ptr[-1-j] = 4*(tmp2 - MULH(tmp1, csa[2+4*j]));\
01746 ptr[ j] = 4*(tmp2 + MULH(tmp0, csa[3+4*j]));
01747
01748 INT_AA(0)
01749 INT_AA(1)
01750 INT_AA(2)
01751 INT_AA(3)
01752 INT_AA(4)
01753 INT_AA(5)
01754 INT_AA(6)
01755 INT_AA(7)
01756
01757 ptr += 18;
01758 }
01759 }
01760
01761 static void compute_antialias_float(MPADecodeContext *s,
01762 GranuleDef *g)
01763 {
01764 int32_t *ptr;
01765 int n, i;
01766
01767
01768 if (g->block_type == 2) {
01769 if (!g->switch_point)
01770 return;
01771
01772 n = 1;
01773 } else {
01774 n = SBLIMIT - 1;
01775 }
01776
01777 ptr = g->sb_hybrid + 18;
01778 for(i = n;i > 0;i--) {
01779 float tmp0, tmp1;
01780 float *csa = &csa_table_float[0][0];
01781 #define FLOAT_AA(j)\
01782 tmp0= ptr[-1-j];\
01783 tmp1= ptr[ j];\
01784 ptr[-1-j] = lrintf(tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j]);\
01785 ptr[ j] = lrintf(tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j]);
01786
01787 FLOAT_AA(0)
01788 FLOAT_AA(1)
01789 FLOAT_AA(2)
01790 FLOAT_AA(3)
01791 FLOAT_AA(4)
01792 FLOAT_AA(5)
01793 FLOAT_AA(6)
01794 FLOAT_AA(7)
01795
01796 ptr += 18;
01797 }
01798 }
01799
01800 static void compute_imdct(MPADecodeContext *s,
01801 GranuleDef *g,
01802 int32_t *sb_samples,
01803 int32_t *mdct_buf)
01804 {
01805 int32_t *ptr, *win, *win1, *buf, *out_ptr, *ptr1;
01806 int32_t out2[12];
01807 int i, j, mdct_long_end, v, sblimit;
01808
01809
01810 ptr = g->sb_hybrid + 576;
01811 ptr1 = g->sb_hybrid + 2 * 18;
01812 while (ptr >= ptr1) {
01813 ptr -= 6;
01814 v = ptr[0] | ptr[1] | ptr[2] | ptr[3] | ptr[4] | ptr[5];
01815 if (v != 0)
01816 break;
01817 }
01818 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
01819
01820 if (g->block_type == 2) {
01821
01822 if (g->switch_point)
01823 mdct_long_end = 2;
01824 else
01825 mdct_long_end = 0;
01826 } else {
01827 mdct_long_end = sblimit;
01828 }
01829
01830 buf = mdct_buf;
01831 ptr = g->sb_hybrid;
01832 for(j=0;j<mdct_long_end;j++) {
01833
01834 out_ptr = sb_samples + j;
01835
01836 if (g->switch_point && j < 2)
01837 win1 = mdct_win[0];
01838 else
01839 win1 = mdct_win[g->block_type];
01840
01841 win = win1 + ((4 * 36) & -(j & 1));
01842 imdct36(out_ptr, buf, ptr, win);
01843 out_ptr += 18*SBLIMIT;
01844 ptr += 18;
01845 buf += 18;
01846 }
01847 for(j=mdct_long_end;j<sblimit;j++) {
01848
01849 win = mdct_win[2] + ((4 * 36) & -(j & 1));
01850 out_ptr = sb_samples + j;
01851
01852 for(i=0; i<6; i++){
01853 *out_ptr = buf[i];
01854 out_ptr += SBLIMIT;
01855 }
01856 imdct12(out2, ptr + 0);
01857 for(i=0;i<6;i++) {
01858 *out_ptr = MULH(out2[i], win[i]) + buf[i + 6*1];
01859 buf[i + 6*2] = MULH(out2[i + 6], win[i + 6]);
01860 out_ptr += SBLIMIT;
01861 }
01862 imdct12(out2, ptr + 1);
01863 for(i=0;i<6;i++) {
01864 *out_ptr = MULH(out2[i], win[i]) + buf[i + 6*2];
01865 buf[i + 6*0] = MULH(out2[i + 6], win[i + 6]);
01866 out_ptr += SBLIMIT;
01867 }
01868 imdct12(out2, ptr + 2);
01869 for(i=0;i<6;i++) {
01870 buf[i + 6*0] = MULH(out2[i], win[i]) + buf[i + 6*0];
01871 buf[i + 6*1] = MULH(out2[i + 6], win[i + 6]);
01872 buf[i + 6*2] = 0;
01873 }
01874 ptr += 18;
01875 buf += 18;
01876 }
01877
01878 for(j=sblimit;j<SBLIMIT;j++) {
01879
01880 out_ptr = sb_samples + j;
01881 for(i=0;i<18;i++) {
01882 *out_ptr = buf[i];
01883 buf[i] = 0;
01884 out_ptr += SBLIMIT;
01885 }
01886 buf += 18;
01887 }
01888 }
01889
01890
01891 static int mp_decode_layer3(MPADecodeContext *s)
01892 {
01893 int nb_granules, main_data_begin, private_bits;
01894 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
01895 GranuleDef *g;
01896 int16_t exponents[576];
01897
01898
01899 if (s->lsf) {
01900 main_data_begin = get_bits(&s->gb, 8);
01901 private_bits = get_bits(&s->gb, s->nb_channels);
01902 nb_granules = 1;
01903 } else {
01904 main_data_begin = get_bits(&s->gb, 9);
01905 if (s->nb_channels == 2)
01906 private_bits = get_bits(&s->gb, 3);
01907 else
01908 private_bits = get_bits(&s->gb, 5);
01909 nb_granules = 2;
01910 for(ch=0;ch<s->nb_channels;ch++) {
01911 s->granules[ch][0].scfsi = 0;
01912 s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
01913 }
01914 }
01915
01916 for(gr=0;gr<nb_granules;gr++) {
01917 for(ch=0;ch<s->nb_channels;ch++) {
01918 dprintf(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
01919 g = &s->granules[ch][gr];
01920 g->part2_3_length = get_bits(&s->gb, 12);
01921 g->big_values = get_bits(&s->gb, 9);
01922 if(g->big_values > 288){
01923 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
01924 return -1;
01925 }
01926
01927 g->global_gain = get_bits(&s->gb, 8);
01928
01929
01930 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
01931 MODE_EXT_MS_STEREO)
01932 g->global_gain -= 2;
01933 if (s->lsf)
01934 g->scalefac_compress = get_bits(&s->gb, 9);
01935 else
01936 g->scalefac_compress = get_bits(&s->gb, 4);
01937 blocksplit_flag = get_bits1(&s->gb);
01938 if (blocksplit_flag) {
01939 g->block_type = get_bits(&s->gb, 2);
01940 if (g->block_type == 0){
01941 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
01942 return -1;
01943 }
01944 g->switch_point = get_bits1(&s->gb);
01945 for(i=0;i<2;i++)
01946 g->table_select[i] = get_bits(&s->gb, 5);
01947 for(i=0;i<3;i++)
01948 g->subblock_gain[i] = get_bits(&s->gb, 3);
01949 ff_init_short_region(s, g);
01950 } else {
01951 int region_address1, region_address2;
01952 g->block_type = 0;
01953 g->switch_point = 0;
01954 for(i=0;i<3;i++)
01955 g->table_select[i] = get_bits(&s->gb, 5);
01956
01957 region_address1 = get_bits(&s->gb, 4);
01958 region_address2 = get_bits(&s->gb, 3);
01959 dprintf(s->avctx, "region1=%d region2=%d\n",
01960 region_address1, region_address2);
01961 ff_init_long_region(s, g, region_address1, region_address2);
01962 }
01963 ff_region_offset2size(g);
01964 ff_compute_band_indexes(s, g);
01965
01966 g->preflag = 0;
01967 if (!s->lsf)
01968 g->preflag = get_bits1(&s->gb);
01969 g->scalefac_scale = get_bits1(&s->gb);
01970 g->count1table_select = get_bits1(&s->gb);
01971 dprintf(s->avctx, "block_type=%d switch_point=%d\n",
01972 g->block_type, g->switch_point);
01973 }
01974 }
01975
01976 if (!s->adu_mode) {
01977 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
01978 assert((get_bits_count(&s->gb) & 7) == 0);
01979
01980 dprintf(s->avctx, "seekback: %d\n", main_data_begin);
01981
01982
01983 memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
01984 s->in_gb= s->gb;
01985 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
01986 skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
01987 }
01988
01989 for(gr=0;gr<nb_granules;gr++) {
01990 for(ch=0;ch<s->nb_channels;ch++) {
01991 g = &s->granules[ch][gr];
01992 if(get_bits_count(&s->gb)<0){
01993 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",
01994 main_data_begin, s->last_buf_size, gr);
01995 skip_bits_long(&s->gb, g->part2_3_length);
01996 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
01997 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer){
01998 skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
01999 s->gb= s->in_gb;
02000 s->in_gb.buffer=NULL;
02001 }
02002 continue;
02003 }
02004
02005 bits_pos = get_bits_count(&s->gb);
02006
02007 if (!s->lsf) {
02008 uint8_t *sc;
02009 int slen, slen1, slen2;
02010
02011
02012 slen1 = slen_table[0][g->scalefac_compress];
02013 slen2 = slen_table[1][g->scalefac_compress];
02014 dprintf(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
02015 if (g->block_type == 2) {
02016 n = g->switch_point ? 17 : 18;
02017 j = 0;
02018 if(slen1){
02019 for(i=0;i<n;i++)
02020 g->scale_factors[j++] = get_bits(&s->gb, slen1);
02021 }else{
02022 for(i=0;i<n;i++)
02023 g->scale_factors[j++] = 0;
02024 }
02025 if(slen2){
02026 for(i=0;i<18;i++)
02027 g->scale_factors[j++] = get_bits(&s->gb, slen2);
02028 for(i=0;i<3;i++)
02029 g->scale_factors[j++] = 0;
02030 }else{
02031 for(i=0;i<21;i++)
02032 g->scale_factors[j++] = 0;
02033 }
02034 } else {
02035 sc = s->granules[ch][0].scale_factors;
02036 j = 0;
02037 for(k=0;k<4;k++) {
02038 n = (k == 0 ? 6 : 5);
02039 if ((g->scfsi & (0x8 >> k)) == 0) {
02040 slen = (k < 2) ? slen1 : slen2;
02041 if(slen){
02042 for(i=0;i<n;i++)
02043 g->scale_factors[j++] = get_bits(&s->gb, slen);
02044 }else{
02045 for(i=0;i<n;i++)
02046 g->scale_factors[j++] = 0;
02047 }
02048 } else {
02049
02050 for(i=0;i<n;i++) {
02051 g->scale_factors[j] = sc[j];
02052 j++;
02053 }
02054 }
02055 }
02056 g->scale_factors[j++] = 0;
02057 }
02058 } else {
02059 int tindex, tindex2, slen[4], sl, sf;
02060
02061
02062 if (g->block_type == 2) {
02063 tindex = g->switch_point ? 2 : 1;
02064 } else {
02065 tindex = 0;
02066 }
02067 sf = g->scalefac_compress;
02068 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
02069
02070 sf >>= 1;
02071 if (sf < 180) {
02072 lsf_sf_expand(slen, sf, 6, 6, 0);
02073 tindex2 = 3;
02074 } else if (sf < 244) {
02075 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
02076 tindex2 = 4;
02077 } else {
02078 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
02079 tindex2 = 5;
02080 }
02081 } else {
02082
02083 if (sf < 400) {
02084 lsf_sf_expand(slen, sf, 5, 4, 4);
02085 tindex2 = 0;
02086 } else if (sf < 500) {
02087 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
02088 tindex2 = 1;
02089 } else {
02090 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
02091 tindex2 = 2;
02092 g->preflag = 1;
02093 }
02094 }
02095
02096 j = 0;
02097 for(k=0;k<4;k++) {
02098 n = lsf_nsf_table[tindex2][tindex][k];
02099 sl = slen[k];
02100 if(sl){
02101 for(i=0;i<n;i++)
02102 g->scale_factors[j++] = get_bits(&s->gb, sl);
02103 }else{
02104 for(i=0;i<n;i++)
02105 g->scale_factors[j++] = 0;
02106 }
02107 }
02108
02109 for(;j<40;j++)
02110 g->scale_factors[j] = 0;
02111 }
02112
02113 exponents_from_scale_factors(s, g, exponents);
02114
02115
02116 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
02117 }
02118
02119 if (s->nb_channels == 2)
02120 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
02121
02122 for(ch=0;ch<s->nb_channels;ch++) {
02123 g = &s->granules[ch][gr];
02124
02125 reorder_block(s, g);
02126 s->compute_antialias(s, g);
02127 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
02128 }
02129 }
02130 if(get_bits_count(&s->gb)<0)
02131 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
02132 return nb_granules * 18;
02133 }
02134
02135 static int mp_decode_frame(MPADecodeContext *s,
02136 OUT_INT *samples, const uint8_t *buf, int buf_size)
02137 {
02138 int i, nb_frames, ch;
02139 OUT_INT *samples_ptr;
02140
02141 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE)*8);
02142
02143
02144 if (s->error_protection)
02145 skip_bits(&s->gb, 16);
02146
02147 dprintf(s->avctx, "frame %d:\n", s->frame_count);
02148 switch(s->layer) {
02149 case 1:
02150 s->avctx->frame_size = 384;
02151 nb_frames = mp_decode_layer1(s);
02152 break;
02153 case 2:
02154 s->avctx->frame_size = 1152;
02155 nb_frames = mp_decode_layer2(s);
02156 break;
02157 case 3:
02158 s->avctx->frame_size = s->lsf ? 576 : 1152;
02159 default:
02160 nb_frames = mp_decode_layer3(s);
02161
02162 s->last_buf_size=0;
02163 if(s->in_gb.buffer){
02164 align_get_bits(&s->gb);
02165 i= get_bits_left(&s->gb)>>3;
02166 if(i >= 0 && i <= BACKSTEP_SIZE){
02167 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
02168 s->last_buf_size=i;
02169 }else
02170 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
02171 s->gb= s->in_gb;
02172 s->in_gb.buffer= NULL;
02173 }
02174
02175 align_get_bits(&s->gb);
02176 assert((get_bits_count(&s->gb) & 7) == 0);
02177 i= get_bits_left(&s->gb)>>3;
02178
02179 if(i<0 || i > BACKSTEP_SIZE || nb_frames<0){
02180 if(i<0)
02181 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
02182 i= FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
02183 }
02184 assert(i <= buf_size - HEADER_SIZE && i>= 0);
02185 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
02186 s->last_buf_size += i;
02187
02188 break;
02189 }
02190
02191
02192 for(ch=0;ch<s->nb_channels;ch++) {
02193 samples_ptr = samples + ch;
02194 for(i=0;i<nb_frames;i++) {
02195 ff_mpa_synth_filter(s->synth_buf[ch], &(s->synth_buf_offset[ch]),
02196 ff_mpa_synth_window, &s->dither_state,
02197 samples_ptr, s->nb_channels,
02198 s->sb_samples[ch][i]);
02199 samples_ptr += 32 * s->nb_channels;
02200 }
02201 }
02202
02203 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
02204 }
02205
02206 static int decode_frame(AVCodecContext * avctx,
02207 void *data, int *data_size,
02208 AVPacket *avpkt)
02209 {
02210 const uint8_t *buf = avpkt->data;
02211 int buf_size = avpkt->size;
02212 MPADecodeContext *s = avctx->priv_data;
02213 uint32_t header;
02214 int out_size;
02215 OUT_INT *out_samples = data;
02216
02217 if(buf_size < HEADER_SIZE)
02218 return -1;
02219
02220 header = AV_RB32(buf);
02221 if(ff_mpa_check_header(header) < 0){
02222 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
02223 return -1;
02224 }
02225
02226 if (ff_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
02227
02228 s->frame_size = -1;
02229 return -1;
02230 }
02231
02232 avctx->channels = s->nb_channels;
02233 avctx->bit_rate = s->bit_rate;
02234 avctx->sub_id = s->layer;
02235
02236 if(*data_size < 1152*avctx->channels*sizeof(OUT_INT))
02237 return -1;
02238 *data_size = 0;
02239
02240 if(s->frame_size<=0 || s->frame_size > buf_size){
02241 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
02242 return -1;
02243 }else if(s->frame_size < buf_size){
02244 av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
02245 buf_size= s->frame_size;
02246 }
02247
02248 out_size = mp_decode_frame(s, out_samples, buf, buf_size);
02249 if(out_size>=0){
02250 *data_size = out_size;
02251 avctx->sample_rate = s->sample_rate;
02252
02253 }else
02254 av_log(avctx, AV_LOG_DEBUG, "Error while decoding MPEG audio frame.\n");
02255 s->frame_size = 0;
02256 return buf_size;
02257 }
02258
02259 static void flush(AVCodecContext *avctx){
02260 MPADecodeContext *s = avctx->priv_data;
02261 memset(s->synth_buf, 0, sizeof(s->synth_buf));
02262 s->last_buf_size= 0;
02263 }
02264
02265 #if CONFIG_MP3ADU_DECODER
02266 static int decode_frame_adu(AVCodecContext * avctx,
02267 void *data, int *data_size,
02268 AVPacket *avpkt)
02269 {
02270 const uint8_t *buf = avpkt->data;
02271 int buf_size = avpkt->size;
02272 MPADecodeContext *s = avctx->priv_data;
02273 uint32_t header;
02274 int len, out_size;
02275 OUT_INT *out_samples = data;
02276
02277 len = buf_size;
02278
02279
02280 if (buf_size < HEADER_SIZE) {
02281 *data_size = 0;
02282 return buf_size;
02283 }
02284
02285
02286 if (len > MPA_MAX_CODED_FRAME_SIZE)
02287 len = MPA_MAX_CODED_FRAME_SIZE;
02288
02289
02290 header = AV_RB32(buf) | 0xffe00000;
02291
02292 if (ff_mpa_check_header(header) < 0) {
02293 *data_size = 0;
02294 return buf_size;
02295 }
02296
02297 ff_mpegaudio_decode_header((MPADecodeHeader *)s, header);
02298
02299 avctx->sample_rate = s->sample_rate;
02300 avctx->channels = s->nb_channels;
02301 avctx->bit_rate = s->bit_rate;
02302 avctx->sub_id = s->layer;
02303
02304 s->frame_size = len;
02305
02306 if (avctx->parse_only) {
02307 out_size = buf_size;
02308 } else {
02309 out_size = mp_decode_frame(s, out_samples, buf, buf_size);
02310 }
02311
02312 *data_size = out_size;
02313 return buf_size;
02314 }
02315 #endif
02316
02317 #if CONFIG_MP3ON4_DECODER
02318
02322 typedef struct MP3On4DecodeContext {
02323 int frames;
02324 int syncword;
02325 const uint8_t *coff;
02326 MPADecodeContext *mp3decctx[5];
02327 } MP3On4DecodeContext;
02328
02329 #include "mpeg4audio.h"
02330
02331
02332 static const uint8_t mp3Frames[8] = {0,1,1,2,3,3,4,5};
02333
02334 static const uint8_t chan_offset[8][5] = {
02335 {0},
02336 {0},
02337 {0},
02338 {2,0},
02339 {2,0,3},
02340 {4,0,2},
02341 {4,0,2,5},
02342 {4,0,2,6,5},
02343 };
02344
02345
02346 static int decode_init_mp3on4(AVCodecContext * avctx)
02347 {
02348 MP3On4DecodeContext *s = avctx->priv_data;
02349 MPEG4AudioConfig cfg;
02350 int i;
02351
02352 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
02353 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
02354 return -1;
02355 }
02356
02357 ff_mpeg4audio_get_config(&cfg, avctx->extradata, avctx->extradata_size);
02358 if (!cfg.chan_config || cfg.chan_config > 7) {
02359 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
02360 return -1;
02361 }
02362 s->frames = mp3Frames[cfg.chan_config];
02363 s->coff = chan_offset[cfg.chan_config];
02364 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
02365
02366 if (cfg.sample_rate < 16000)
02367 s->syncword = 0xffe00000;
02368 else
02369 s->syncword = 0xfff00000;
02370
02371
02372
02373
02374
02375
02376
02377 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
02378
02379 avctx->priv_data = s->mp3decctx[0];
02380 decode_init(avctx);
02381
02382 avctx->priv_data = s;
02383 s->mp3decctx[0]->adu_mode = 1;
02384
02385
02386
02387
02388 for (i = 1; i < s->frames; i++) {
02389 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
02390 s->mp3decctx[i]->compute_antialias = s->mp3decctx[0]->compute_antialias;
02391 s->mp3decctx[i]->adu_mode = 1;
02392 s->mp3decctx[i]->avctx = avctx;
02393 }
02394
02395 return 0;
02396 }
02397
02398
02399 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
02400 {
02401 MP3On4DecodeContext *s = avctx->priv_data;
02402 int i;
02403
02404 for (i = 0; i < s->frames; i++)
02405 if (s->mp3decctx[i])
02406 av_free(s->mp3decctx[i]);
02407
02408 return 0;
02409 }
02410
02411
02412 static int decode_frame_mp3on4(AVCodecContext * avctx,
02413 void *data, int *data_size,
02414 AVPacket *avpkt)
02415 {
02416 const uint8_t *buf = avpkt->data;
02417 int buf_size = avpkt->size;
02418 MP3On4DecodeContext *s = avctx->priv_data;
02419 MPADecodeContext *m;
02420 int fsize, len = buf_size, out_size = 0;
02421 uint32_t header;
02422 OUT_INT *out_samples = data;
02423 OUT_INT decoded_buf[MPA_FRAME_SIZE * MPA_MAX_CHANNELS];
02424 OUT_INT *outptr, *bp;
02425 int fr, j, n;
02426
02427 if(*data_size < MPA_FRAME_SIZE * MPA_MAX_CHANNELS * s->frames * sizeof(OUT_INT))
02428 return -1;
02429
02430 *data_size = 0;
02431
02432 if (buf_size < HEADER_SIZE)
02433 return -1;
02434
02435
02436 outptr = s->frames == 1 ? out_samples : decoded_buf;
02437
02438 avctx->bit_rate = 0;
02439
02440 for (fr = 0; fr < s->frames; fr++) {
02441 fsize = AV_RB16(buf) >> 4;
02442 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
02443 m = s->mp3decctx[fr];
02444 assert (m != NULL);
02445
02446 header = (AV_RB32(buf) & 0x000fffff) | s->syncword;
02447
02448 if (ff_mpa_check_header(header) < 0)
02449 break;
02450
02451 ff_mpegaudio_decode_header((MPADecodeHeader *)m, header);
02452 out_size += mp_decode_frame(m, outptr, buf, fsize);
02453 buf += fsize;
02454 len -= fsize;
02455
02456 if(s->frames > 1) {
02457 n = m->avctx->frame_size*m->nb_channels;
02458
02459 bp = out_samples + s->coff[fr];
02460 if(m->nb_channels == 1) {
02461 for(j = 0; j < n; j++) {
02462 *bp = decoded_buf[j];
02463 bp += avctx->channels;
02464 }
02465 } else {
02466 for(j = 0; j < n; j++) {
02467 bp[0] = decoded_buf[j++];
02468 bp[1] = decoded_buf[j];
02469 bp += avctx->channels;
02470 }
02471 }
02472 }
02473 avctx->bit_rate += m->bit_rate;
02474 }
02475
02476
02477 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
02478
02479 *data_size = out_size;
02480 return buf_size;
02481 }
02482 #endif
02483
02484 #if CONFIG_MP1_DECODER
02485 AVCodec mp1_decoder =
02486 {
02487 "mp1",
02488 AVMEDIA_TYPE_AUDIO,
02489 CODEC_ID_MP1,
02490 sizeof(MPADecodeContext),
02491 decode_init,
02492 NULL,
02493 NULL,
02494 decode_frame,
02495 CODEC_CAP_PARSE_ONLY,
02496 .flush= flush,
02497 .long_name= NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
02498 };
02499 #endif
02500 #if CONFIG_MP2_DECODER
02501 AVCodec mp2_decoder =
02502 {
02503 "mp2",
02504 AVMEDIA_TYPE_AUDIO,
02505 CODEC_ID_MP2,
02506 sizeof(MPADecodeContext),
02507 decode_init,
02508 NULL,
02509 NULL,
02510 decode_frame,
02511 CODEC_CAP_PARSE_ONLY,
02512 .flush= flush,
02513 .long_name= NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
02514 };
02515 #endif
02516 #if CONFIG_MP3_DECODER
02517 AVCodec mp3_decoder =
02518 {
02519 "mp3",
02520 AVMEDIA_TYPE_AUDIO,
02521 CODEC_ID_MP3,
02522 sizeof(MPADecodeContext),
02523 decode_init,
02524 NULL,
02525 NULL,
02526 decode_frame,
02527 CODEC_CAP_PARSE_ONLY,
02528 .flush= flush,
02529 .long_name= NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
02530 };
02531 #endif
02532 #if CONFIG_MP3ADU_DECODER
02533 AVCodec mp3adu_decoder =
02534 {
02535 "mp3adu",
02536 AVMEDIA_TYPE_AUDIO,
02537 CODEC_ID_MP3ADU,
02538 sizeof(MPADecodeContext),
02539 decode_init,
02540 NULL,
02541 NULL,
02542 decode_frame_adu,
02543 CODEC_CAP_PARSE_ONLY,
02544 .flush= flush,
02545 .long_name= NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
02546 };
02547 #endif
02548 #if CONFIG_MP3ON4_DECODER
02549 AVCodec mp3on4_decoder =
02550 {
02551 "mp3on4",
02552 AVMEDIA_TYPE_AUDIO,
02553 CODEC_ID_MP3ON4,
02554 sizeof(MP3On4DecodeContext),
02555 decode_init_mp3on4,
02556 NULL,
02557 decode_close_mp3on4,
02558 decode_frame_mp3on4,
02559 .flush= flush,
02560 .long_name= NULL_IF_CONFIG_SMALL("MP3onMP4"),
02561 };
02562 #endif