Mercurial > libavcodec.hg
comparison mpegaudiodec.c @ 2967:ef2149182f1c libavcodec
COSMETICS: Remove all trailing whitespace.
author | diego |
---|---|
date | Sat, 17 Dec 2005 18:14:38 +0000 |
parents | cc55bc1f8d92 |
children | bfabfdf9ce55 |
comparison
equal
deleted
inserted
replaced
2966:564788471dd4 | 2967:ef2149182f1c |
---|---|
18 */ | 18 */ |
19 | 19 |
20 /** | 20 /** |
21 * @file mpegaudiodec.c | 21 * @file mpegaudiodec.c |
22 * MPEG Audio decoder. | 22 * MPEG Audio decoder. |
23 */ | 23 */ |
24 | 24 |
25 //#define DEBUG | 25 //#define DEBUG |
26 #include "avcodec.h" | 26 #include "avcodec.h" |
27 #include "bitstream.h" | 27 #include "bitstream.h" |
28 #include "dsputil.h" | 28 #include "dsputil.h" |
69 uint8_t *inbuf_ptr, *inbuf; | 69 uint8_t *inbuf_ptr, *inbuf; |
70 int frame_size; | 70 int frame_size; |
71 int free_format_frame_size; /* frame size in case of free format | 71 int free_format_frame_size; /* frame size in case of free format |
72 (zero if currently unknown) */ | 72 (zero if currently unknown) */ |
73 /* next header (used in free format parsing) */ | 73 /* next header (used in free format parsing) */ |
74 uint32_t free_format_next_header; | 74 uint32_t free_format_next_header; |
75 int error_protection; | 75 int error_protection; |
76 int layer; | 76 int layer; |
77 int sample_rate; | 77 int sample_rate; |
78 int sample_rate_index; /* between 0 and 8 */ | 78 int sample_rate_index; /* between 0 and 8 */ |
79 int bit_rate; | 79 int bit_rate; |
138 | 138 |
139 static void compute_antialias_integer(MPADecodeContext *s, GranuleDef *g); | 139 static void compute_antialias_integer(MPADecodeContext *s, GranuleDef *g); |
140 static void compute_antialias_float(MPADecodeContext *s, GranuleDef *g); | 140 static void compute_antialias_float(MPADecodeContext *s, GranuleDef *g); |
141 | 141 |
142 /* vlc structure for decoding layer 3 huffman tables */ | 142 /* vlc structure for decoding layer 3 huffman tables */ |
143 static VLC huff_vlc[16]; | 143 static VLC huff_vlc[16]; |
144 static uint8_t *huff_code_table[16]; | 144 static uint8_t *huff_code_table[16]; |
145 static VLC huff_quad_vlc[2]; | 145 static VLC huff_quad_vlc[2]; |
146 /* computed from band_size_long */ | 146 /* computed from band_size_long */ |
147 static uint16_t band_index_long[9][23]; | 147 static uint16_t band_index_long[9][23]; |
148 /* XXX: free when all decoders are closed */ | 148 /* XXX: free when all decoders are closed */ |
171 SCALE_GEN(4.0 / 9.0), /* 9 steps */ | 171 SCALE_GEN(4.0 / 9.0), /* 9 steps */ |
172 }; | 172 }; |
173 | 173 |
174 void ff_mpa_synth_init(MPA_INT *window); | 174 void ff_mpa_synth_init(MPA_INT *window); |
175 static MPA_INT window[512] __attribute__((aligned(16))); | 175 static MPA_INT window[512] __attribute__((aligned(16))); |
176 | 176 |
177 /* layer 1 unscaling */ | 177 /* layer 1 unscaling */ |
178 /* n = number of bits of the mantissa minus 1 */ | 178 /* n = number of bits of the mantissa minus 1 */ |
179 static inline int l1_unscale(int n, int mant, int scale_factor) | 179 static inline int l1_unscale(int n, int mant, int scale_factor) |
180 { | 180 { |
181 int shift, mod; | 181 int shift, mod; |
255 /* return the mantissa and the binary exponent */ | 255 /* return the mantissa and the binary exponent */ |
256 static int int_pow(int i, int *exp_ptr) | 256 static int int_pow(int i, int *exp_ptr) |
257 { | 257 { |
258 int e, er, eq, j; | 258 int e, er, eq, j; |
259 int a, a1; | 259 int a, a1; |
260 | 260 |
261 /* renormalize */ | 261 /* renormalize */ |
262 a = i; | 262 a = i; |
263 e = POW_FRAC_BITS; | 263 e = POW_FRAC_BITS; |
264 while (a < (1 << (POW_FRAC_BITS - 1))) { | 264 while (a < (1 << (POW_FRAC_BITS - 1))) { |
265 a = a << 1; | 265 a = a << 1; |
306 | 306 |
307 #if defined(USE_HIGHPRECISION) && defined(CONFIG_AUDIO_NONSHORT) | 307 #if defined(USE_HIGHPRECISION) && defined(CONFIG_AUDIO_NONSHORT) |
308 avctx->sample_fmt= SAMPLE_FMT_S32; | 308 avctx->sample_fmt= SAMPLE_FMT_S32; |
309 #else | 309 #else |
310 avctx->sample_fmt= SAMPLE_FMT_S16; | 310 avctx->sample_fmt= SAMPLE_FMT_S16; |
311 #endif | 311 #endif |
312 | 312 |
313 if(avctx->antialias_algo != FF_AA_FLOAT) | 313 if(avctx->antialias_algo != FF_AA_FLOAT) |
314 s->compute_antialias= compute_antialias_integer; | 314 s->compute_antialias= compute_antialias_integer; |
315 else | 315 else |
316 s->compute_antialias= compute_antialias_float; | 316 s->compute_antialias= compute_antialias_float; |
317 | 317 |
332 norm = ((int64_t_C(1) << n) * FRAC_ONE) / ((1 << n) - 1); | 332 norm = ((int64_t_C(1) << n) * FRAC_ONE) / ((1 << n) - 1); |
333 scale_factor_mult[i][0] = MULL(FIXR(1.0 * 2.0), norm); | 333 scale_factor_mult[i][0] = MULL(FIXR(1.0 * 2.0), norm); |
334 scale_factor_mult[i][1] = MULL(FIXR(0.7937005259 * 2.0), norm); | 334 scale_factor_mult[i][1] = MULL(FIXR(0.7937005259 * 2.0), norm); |
335 scale_factor_mult[i][2] = MULL(FIXR(0.6299605249 * 2.0), norm); | 335 scale_factor_mult[i][2] = MULL(FIXR(0.6299605249 * 2.0), norm); |
336 dprintf("%d: norm=%x s=%x %x %x\n", | 336 dprintf("%d: norm=%x s=%x %x %x\n", |
337 i, norm, | 337 i, norm, |
338 scale_factor_mult[i][0], | 338 scale_factor_mult[i][0], |
339 scale_factor_mult[i][1], | 339 scale_factor_mult[i][1], |
340 scale_factor_mult[i][2]); | 340 scale_factor_mult[i][2]); |
341 } | 341 } |
342 | 342 |
343 ff_mpa_synth_init(window); | 343 ff_mpa_synth_init(window); |
344 | 344 |
345 /* huffman decode tables */ | 345 /* huffman decode tables */ |
346 huff_code_table[0] = NULL; | 346 huff_code_table[0] = NULL; |
347 for(i=1;i<16;i++) { | 347 for(i=1;i<16;i++) { |
348 const HuffTable *h = &mpa_huff_tables[i]; | 348 const HuffTable *h = &mpa_huff_tables[i]; |
349 int xsize, x, y; | 349 int xsize, x, y; |
351 uint8_t *code_table; | 351 uint8_t *code_table; |
352 | 352 |
353 xsize = h->xsize; | 353 xsize = h->xsize; |
354 n = xsize * xsize; | 354 n = xsize * xsize; |
355 /* XXX: fail test */ | 355 /* XXX: fail test */ |
356 init_vlc(&huff_vlc[i], 8, n, | 356 init_vlc(&huff_vlc[i], 8, n, |
357 h->bits, 1, 1, h->codes, 2, 2, 1); | 357 h->bits, 1, 1, h->codes, 2, 2, 1); |
358 | 358 |
359 code_table = av_mallocz(n); | 359 code_table = av_mallocz(n); |
360 j = 0; | 360 j = 0; |
361 for(x=0;x<xsize;x++) { | 361 for(x=0;x<xsize;x++) { |
362 for(y=0;y<xsize;y++) | 362 for(y=0;y<xsize;y++) |
363 code_table[j++] = (x << 4) | y; | 363 code_table[j++] = (x << 4) | y; |
364 } | 364 } |
365 huff_code_table[i] = code_table; | 365 huff_code_table[i] = code_table; |
366 } | 366 } |
367 for(i=0;i<2;i++) { | 367 for(i=0;i<2;i++) { |
368 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16, | 368 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16, |
369 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1, 1); | 369 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1, 1); |
370 } | 370 } |
371 | 371 |
372 for(i=0;i<9;i++) { | 372 for(i=0;i<9;i++) { |
373 k = 0; | 373 k = 0; |
383 if(!table_4_3_exp) | 383 if(!table_4_3_exp) |
384 return -1; | 384 return -1; |
385 table_4_3_value= av_mallocz_static(TABLE_4_3_SIZE * sizeof(table_4_3_value[0])); | 385 table_4_3_value= av_mallocz_static(TABLE_4_3_SIZE * sizeof(table_4_3_value[0])); |
386 if(!table_4_3_value) | 386 if(!table_4_3_value) |
387 return -1; | 387 return -1; |
388 | 388 |
389 int_pow_init(); | 389 int_pow_init(); |
390 for(i=1;i<TABLE_4_3_SIZE;i++) { | 390 for(i=1;i<TABLE_4_3_SIZE;i++) { |
391 double f, fm; | 391 double f, fm; |
392 int e, m; | 392 int e, m; |
393 f = pow((double)(i/4), 4.0 / 3.0) * pow(2, (i&3)*0.25); | 393 f = pow((double)(i/4), 4.0 / 3.0) * pow(2, (i&3)*0.25); |
398 /* normalized to FRAC_BITS */ | 398 /* normalized to FRAC_BITS */ |
399 table_4_3_value[i] = m; | 399 table_4_3_value[i] = m; |
400 // av_log(NULL, AV_LOG_DEBUG, "%d %d %f\n", i, m, pow((double)i, 4.0 / 3.0)); | 400 // av_log(NULL, AV_LOG_DEBUG, "%d %d %f\n", i, m, pow((double)i, 4.0 / 3.0)); |
401 table_4_3_exp[i] = -e; | 401 table_4_3_exp[i] = -e; |
402 } | 402 } |
403 | 403 |
404 for(i=0;i<7;i++) { | 404 for(i=0;i<7;i++) { |
405 float f; | 405 float f; |
406 int v; | 406 int v; |
407 if (i != 6) { | 407 if (i != 6) { |
408 f = tan((double)i * M_PI / 12.0); | 408 f = tan((double)i * M_PI / 12.0); |
425 e = -(j + 1) * ((i + 1) >> 1); | 425 e = -(j + 1) * ((i + 1) >> 1); |
426 f = pow(2.0, e / 4.0); | 426 f = pow(2.0, e / 4.0); |
427 k = i & 1; | 427 k = i & 1; |
428 is_table_lsf[j][k ^ 1][i] = FIXR(f); | 428 is_table_lsf[j][k ^ 1][i] = FIXR(f); |
429 is_table_lsf[j][k][i] = FIXR(1.0); | 429 is_table_lsf[j][k][i] = FIXR(1.0); |
430 dprintf("is_table_lsf %d %d: %x %x\n", | 430 dprintf("is_table_lsf %d %d: %x %x\n", |
431 i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]); | 431 i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]); |
432 } | 432 } |
433 } | 433 } |
434 | 434 |
435 for(i=0;i<8;i++) { | 435 for(i=0;i<8;i++) { |
438 cs = 1.0 / sqrt(1.0 + ci * ci); | 438 cs = 1.0 / sqrt(1.0 + ci * ci); |
439 ca = cs * ci; | 439 ca = cs * ci; |
440 csa_table[i][0] = FIXHR(cs/4); | 440 csa_table[i][0] = FIXHR(cs/4); |
441 csa_table[i][1] = FIXHR(ca/4); | 441 csa_table[i][1] = FIXHR(ca/4); |
442 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4); | 442 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4); |
443 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4); | 443 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4); |
444 csa_table_float[i][0] = cs; | 444 csa_table_float[i][0] = cs; |
445 csa_table_float[i][1] = ca; | 445 csa_table_float[i][1] = ca; |
446 csa_table_float[i][2] = ca + cs; | 446 csa_table_float[i][2] = ca + cs; |
447 csa_table_float[i][3] = ca - cs; | 447 csa_table_float[i][3] = ca - cs; |
448 // printf("%d %d %d %d\n", FIX(cs), FIX(cs-1), FIX(ca), FIX(cs)-FIX(ca)); | 448 // printf("%d %d %d %d\n", FIX(cs), FIX(cs-1), FIX(ca), FIX(cs)-FIX(ca)); |
449 // av_log(NULL, AV_LOG_DEBUG,"%f %f %f %f\n", cs, ca, ca+cs, ca-cs); | 449 // av_log(NULL, AV_LOG_DEBUG,"%f %f %f %f\n", cs, ca, ca+cs, ca-cs); |
450 } | 450 } |
451 | 451 |
452 /* compute mdct windows */ | 452 /* compute mdct windows */ |
453 for(i=0;i<36;i++) { | 453 for(i=0;i<36;i++) { |
454 for(j=0; j<4; j++){ | 454 for(j=0; j<4; j++){ |
455 double d; | 455 double d; |
456 | 456 |
457 if(j==2 && i%3 != 1) | 457 if(j==2 && i%3 != 1) |
458 continue; | 458 continue; |
459 | 459 |
460 d= sin(M_PI * (i + 0.5) / 36.0); | 460 d= sin(M_PI * (i + 0.5) / 36.0); |
461 if(j==1){ | 461 if(j==1){ |
462 if (i>=30) d= 0; | 462 if (i>=30) d= 0; |
463 else if(i>=24) d= sin(M_PI * (i - 18 + 0.5) / 12.0); | 463 else if(i>=24) d= sin(M_PI * (i - 18 + 0.5) / 12.0); |
464 else if(i>=18) d= 1; | 464 else if(i>=18) d= 1; |
607 BF(3, 12, COS1_3); | 607 BF(3, 12, COS1_3); |
608 BF(4, 11, COS1_4); | 608 BF(4, 11, COS1_4); |
609 BF(5, 10, COS1_5); | 609 BF(5, 10, COS1_5); |
610 BF(6, 9, COS1_6); | 610 BF(6, 9, COS1_6); |
611 BF(7, 8, COS1_7); | 611 BF(7, 8, COS1_7); |
612 | 612 |
613 BF(16, 31, -COS1_0); | 613 BF(16, 31, -COS1_0); |
614 BF(17, 30, -COS1_1); | 614 BF(17, 30, -COS1_1); |
615 BF(18, 29, -COS1_2); | 615 BF(18, 29, -COS1_2); |
616 BF(19, 28, -COS1_3); | 616 BF(19, 28, -COS1_3); |
617 BF(20, 27, -COS1_4); | 617 BF(20, 27, -COS1_4); |
618 BF(21, 26, -COS1_5); | 618 BF(21, 26, -COS1_5); |
619 BF(22, 25, -COS1_6); | 619 BF(22, 25, -COS1_6); |
620 BF(23, 24, -COS1_7); | 620 BF(23, 24, -COS1_7); |
621 | 621 |
622 /* pass 3 */ | 622 /* pass 3 */ |
623 BF(0, 7, COS2_0); | 623 BF(0, 7, COS2_0); |
624 BF(1, 6, COS2_1); | 624 BF(1, 6, COS2_1); |
625 BF(2, 5, COS2_2); | 625 BF(2, 5, COS2_2); |
626 BF(3, 4, COS2_3); | 626 BF(3, 4, COS2_3); |
627 | 627 |
628 BF(8, 15, -COS2_0); | 628 BF(8, 15, -COS2_0); |
629 BF(9, 14, -COS2_1); | 629 BF(9, 14, -COS2_1); |
630 BF(10, 13, -COS2_2); | 630 BF(10, 13, -COS2_2); |
631 BF(11, 12, -COS2_3); | 631 BF(11, 12, -COS2_3); |
632 | 632 |
633 BF(16, 23, COS2_0); | 633 BF(16, 23, COS2_0); |
634 BF(17, 22, COS2_1); | 634 BF(17, 22, COS2_1); |
635 BF(18, 21, COS2_2); | 635 BF(18, 21, COS2_2); |
636 BF(19, 20, COS2_3); | 636 BF(19, 20, COS2_3); |
637 | 637 |
638 BF(24, 31, -COS2_0); | 638 BF(24, 31, -COS2_0); |
639 BF(25, 30, -COS2_1); | 639 BF(25, 30, -COS2_1); |
640 BF(26, 29, -COS2_2); | 640 BF(26, 29, -COS2_2); |
641 BF(27, 28, -COS2_3); | 641 BF(27, 28, -COS2_3); |
642 | 642 |
643 /* pass 4 */ | 643 /* pass 4 */ |
644 BF(0, 3, COS3_0); | 644 BF(0, 3, COS3_0); |
645 BF(1, 2, COS3_1); | 645 BF(1, 2, COS3_1); |
646 | 646 |
647 BF(4, 7, -COS3_0); | 647 BF(4, 7, -COS3_0); |
648 BF(5, 6, -COS3_1); | 648 BF(5, 6, -COS3_1); |
649 | 649 |
650 BF(8, 11, COS3_0); | 650 BF(8, 11, COS3_0); |
651 BF(9, 10, COS3_1); | 651 BF(9, 10, COS3_1); |
652 | 652 |
653 BF(12, 15, -COS3_0); | 653 BF(12, 15, -COS3_0); |
654 BF(13, 14, -COS3_1); | 654 BF(13, 14, -COS3_1); |
655 | 655 |
656 BF(16, 19, COS3_0); | 656 BF(16, 19, COS3_0); |
657 BF(17, 18, COS3_1); | 657 BF(17, 18, COS3_1); |
658 | 658 |
659 BF(20, 23, -COS3_0); | 659 BF(20, 23, -COS3_0); |
660 BF(21, 22, -COS3_1); | 660 BF(21, 22, -COS3_1); |
661 | 661 |
662 BF(24, 27, COS3_0); | 662 BF(24, 27, COS3_0); |
663 BF(25, 26, COS3_1); | 663 BF(25, 26, COS3_1); |
664 | 664 |
665 BF(28, 31, -COS3_0); | 665 BF(28, 31, -COS3_0); |
666 BF(29, 30, -COS3_1); | 666 BF(29, 30, -COS3_1); |
667 | 667 |
668 /* pass 5 */ | 668 /* pass 5 */ |
669 BF1(0, 1, 2, 3); | 669 BF1(0, 1, 2, 3); |
670 BF2(4, 5, 6, 7); | 670 BF2(4, 5, 6, 7); |
671 BF1(8, 9, 10, 11); | 671 BF1(8, 9, 10, 11); |
672 BF2(12, 13, 14, 15); | 672 BF2(12, 13, 14, 15); |
673 BF1(16, 17, 18, 19); | 673 BF1(16, 17, 18, 19); |
674 BF2(20, 21, 22, 23); | 674 BF2(20, 21, 22, 23); |
675 BF1(24, 25, 26, 27); | 675 BF1(24, 25, 26, 27); |
676 BF2(28, 29, 30, 31); | 676 BF2(28, 29, 30, 31); |
677 | 677 |
678 /* pass 6 */ | 678 /* pass 6 */ |
679 | 679 |
680 ADD( 8, 12); | 680 ADD( 8, 12); |
681 ADD(12, 10); | 681 ADD(12, 10); |
682 ADD(10, 14); | 682 ADD(10, 14); |
683 ADD(14, 9); | 683 ADD(14, 9); |
684 ADD( 9, 13); | 684 ADD( 9, 13); |
699 out[26] = tab[11]; | 699 out[26] = tab[11]; |
700 out[ 6] = tab[12]; | 700 out[ 6] = tab[12]; |
701 out[22] = tab[13]; | 701 out[22] = tab[13]; |
702 out[14] = tab[14]; | 702 out[14] = tab[14]; |
703 out[30] = tab[15]; | 703 out[30] = tab[15]; |
704 | 704 |
705 ADD(24, 28); | 705 ADD(24, 28); |
706 ADD(28, 26); | 706 ADD(28, 26); |
707 ADD(26, 30); | 707 ADD(26, 30); |
708 ADD(30, 25); | 708 ADD(30, 25); |
709 ADD(25, 29); | 709 ADD(25, 29); |
762 | 762 |
763 #endif | 763 #endif |
764 | 764 |
765 #else | 765 #else |
766 | 766 |
767 static inline int round_sample(int64_t *sum) | 767 static inline int round_sample(int64_t *sum) |
768 { | 768 { |
769 int sum1; | 769 int sum1; |
770 sum1 = (int)((*sum) >> OUT_SHIFT); | 770 sum1 = (int)((*sum) >> OUT_SHIFT); |
771 *sum &= (1<<OUT_SHIFT)-1; | 771 *sum &= (1<<OUT_SHIFT)-1; |
772 if (sum1 < OUT_MIN) | 772 if (sum1 < OUT_MIN) |
835 window[i] = v; | 835 window[i] = v; |
836 if ((i & 63) != 0) | 836 if ((i & 63) != 0) |
837 v = -v; | 837 v = -v; |
838 if (i != 0) | 838 if (i != 0) |
839 window[512 - i] = v; | 839 window[512 - i] = v; |
840 } | 840 } |
841 } | 841 } |
842 | 842 |
843 /* 32 sub band synthesis filter. Input: 32 sub band samples, Output: | 843 /* 32 sub band synthesis filter. Input: 32 sub band samples, Output: |
844 32 samples. */ | 844 32 samples. */ |
845 /* XXX: optimize by avoiding ring buffer usage */ | 845 /* XXX: optimize by avoiding ring buffer usage */ |
846 void ff_mpa_synth_filter(MPA_INT *synth_buf_ptr, int *synth_buf_offset, | 846 void ff_mpa_synth_filter(MPA_INT *synth_buf_ptr, int *synth_buf_offset, |
847 MPA_INT *window, int *dither_state, | 847 MPA_INT *window, int *dither_state, |
848 OUT_INT *samples, int incr, | 848 OUT_INT *samples, int incr, |
849 int32_t sb_samples[SBLIMIT]) | 849 int32_t sb_samples[SBLIMIT]) |
850 { | 850 { |
851 int32_t tmp[32]; | 851 int32_t tmp[32]; |
852 register MPA_INT *synth_buf; | 852 register MPA_INT *synth_buf; |
853 register const MPA_INT *w, *w2, *p; | 853 register const MPA_INT *w, *w2, *p; |
858 #else | 858 #else |
859 int64_t sum, sum2; | 859 int64_t sum, sum2; |
860 #endif | 860 #endif |
861 | 861 |
862 dct32(tmp, sb_samples); | 862 dct32(tmp, sb_samples); |
863 | 863 |
864 offset = *synth_buf_offset; | 864 offset = *synth_buf_offset; |
865 synth_buf = synth_buf_ptr + offset; | 865 synth_buf = synth_buf_ptr + offset; |
866 | 866 |
867 for(j=0;j<32;j++) { | 867 for(j=0;j<32;j++) { |
868 v = tmp[j]; | 868 v = tmp[j]; |
907 *samples2 = round_sample(&sum); | 907 *samples2 = round_sample(&sum); |
908 samples2 -= incr; | 908 samples2 -= incr; |
909 w++; | 909 w++; |
910 w2--; | 910 w2--; |
911 } | 911 } |
912 | 912 |
913 p = synth_buf + 32; | 913 p = synth_buf + 32; |
914 SUM8(sum, -=, w + 32, p); | 914 SUM8(sum, -=, w + 32, p); |
915 *samples = round_sample(&sum); | 915 *samples = round_sample(&sum); |
916 *dither_state= sum; | 916 *dither_state= sum; |
917 | 917 |
949 in5 += in3; | 949 in5 += in3; |
950 in3 += in1; | 950 in3 += in1; |
951 | 951 |
952 in2= MULH(2*in2, C3); | 952 in2= MULH(2*in2, C3); |
953 in3= MULH(2*in3, C3); | 953 in3= MULH(2*in3, C3); |
954 | 954 |
955 t1 = in0 - in4; | 955 t1 = in0 - in4; |
956 t2 = MULL(in1 - in5, icos36[4]); | 956 t2 = MULL(in1 - in5, icos36[4]); |
957 | 957 |
958 out[ 7]= | 958 out[ 7]= |
959 out[10]= t1 + t2; | 959 out[10]= t1 + t2; |
960 out[ 1]= | 960 out[ 1]= |
961 out[ 4]= t1 - t2; | 961 out[ 4]= t1 - t2; |
962 | 962 |
963 in0 += in4>>1; | 963 in0 += in4>>1; |
964 in4 = in0 + in2; | 964 in4 = in0 + in2; |
965 in1 += in5>>1; | 965 in1 += in5>>1; |
966 in5 = MULL(in1 + in3, icos36[1]); | 966 in5 = MULL(in1 + in3, icos36[1]); |
967 out[ 8]= | 967 out[ 8]= |
968 out[ 9]= in4 + in5; | 968 out[ 9]= in4 + in5; |
969 out[ 2]= | 969 out[ 2]= |
970 out[ 3]= in4 - in5; | 970 out[ 3]= in4 - in5; |
971 | 971 |
972 in0 -= in2; | 972 in0 -= in2; |
973 in1 = MULL(in1 - in3, icos36[7]); | 973 in1 = MULL(in1 - in3, icos36[7]); |
974 out[ 0]= | 974 out[ 0]= |
975 out[ 5]= in0 - in1; | 975 out[ 5]= in0 - in1; |
976 out[ 6]= | 976 out[ 6]= |
977 out[11]= in0 + in1; | 977 out[11]= in0 + in1; |
978 } | 978 } |
979 | 979 |
980 /* cos(pi*i/18) */ | 980 /* cos(pi*i/18) */ |
981 #define C1 FIXHR(0.98480775301220805936/2) | 981 #define C1 FIXHR(0.98480775301220805936/2) |
982 #define C2 FIXHR(0.93969262078590838405/2) | 982 #define C2 FIXHR(0.93969262078590838405/2) |
1004 in1 = in + j; | 1004 in1 = in + j; |
1005 #if 0 | 1005 #if 0 |
1006 //more accurate but slower | 1006 //more accurate but slower |
1007 int64_t t0, t1, t2, t3; | 1007 int64_t t0, t1, t2, t3; |
1008 t2 = in1[2*4] + in1[2*8] - in1[2*2]; | 1008 t2 = in1[2*4] + in1[2*8] - in1[2*2]; |
1009 | 1009 |
1010 t3 = (in1[2*0] + (int64_t)(in1[2*6]>>1))<<32; | 1010 t3 = (in1[2*0] + (int64_t)(in1[2*6]>>1))<<32; |
1011 t1 = in1[2*0] - in1[2*6]; | 1011 t1 = in1[2*0] - in1[2*6]; |
1012 tmp1[ 6] = t1 - (t2>>1); | 1012 tmp1[ 6] = t1 - (t2>>1); |
1013 tmp1[16] = t1 + t2; | 1013 tmp1[16] = t1 + t2; |
1014 | 1014 |
1015 t0 = MUL64(2*(in1[2*2] + in1[2*4]), C2); | 1015 t0 = MUL64(2*(in1[2*2] + in1[2*4]), C2); |
1016 t1 = MUL64( in1[2*4] - in1[2*8] , -2*C8); | 1016 t1 = MUL64( in1[2*4] - in1[2*8] , -2*C8); |
1017 t2 = MUL64(2*(in1[2*2] + in1[2*8]), -C4); | 1017 t2 = MUL64(2*(in1[2*2] + in1[2*8]), -C4); |
1018 | 1018 |
1019 tmp1[10] = (t3 - t0 - t2) >> 32; | 1019 tmp1[10] = (t3 - t0 - t2) >> 32; |
1020 tmp1[ 2] = (t3 + t0 + t1) >> 32; | 1020 tmp1[ 2] = (t3 + t0 + t1) >> 32; |
1021 tmp1[14] = (t3 + t2 - t1) >> 32; | 1021 tmp1[14] = (t3 + t2 - t1) >> 32; |
1022 | 1022 |
1023 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3); | 1023 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3); |
1024 t2 = MUL64(2*(in1[2*1] + in1[2*5]), C1); | 1024 t2 = MUL64(2*(in1[2*1] + in1[2*5]), C1); |
1025 t3 = MUL64( in1[2*5] - in1[2*7] , -2*C7); | 1025 t3 = MUL64( in1[2*5] - in1[2*7] , -2*C7); |
1026 t0 = MUL64(2*in1[2*3], C3); | 1026 t0 = MUL64(2*in1[2*3], C3); |
1027 | 1027 |
1030 tmp1[ 0] = (t2 + t3 + t0) >> 32; | 1030 tmp1[ 0] = (t2 + t3 + t0) >> 32; |
1031 tmp1[12] = (t2 + t1 - t0) >> 32; | 1031 tmp1[12] = (t2 + t1 - t0) >> 32; |
1032 tmp1[ 8] = (t3 - t1 - t0) >> 32; | 1032 tmp1[ 8] = (t3 - t1 - t0) >> 32; |
1033 #else | 1033 #else |
1034 t2 = in1[2*4] + in1[2*8] - in1[2*2]; | 1034 t2 = in1[2*4] + in1[2*8] - in1[2*2]; |
1035 | 1035 |
1036 t3 = in1[2*0] + (in1[2*6]>>1); | 1036 t3 = in1[2*0] + (in1[2*6]>>1); |
1037 t1 = in1[2*0] - in1[2*6]; | 1037 t1 = in1[2*0] - in1[2*6]; |
1038 tmp1[ 6] = t1 - (t2>>1); | 1038 tmp1[ 6] = t1 - (t2>>1); |
1039 tmp1[16] = t1 + t2; | 1039 tmp1[16] = t1 + t2; |
1040 | 1040 |
1041 t0 = MULH(2*(in1[2*2] + in1[2*4]), C2); | 1041 t0 = MULH(2*(in1[2*2] + in1[2*4]), C2); |
1042 t1 = MULH( in1[2*4] - in1[2*8] , -2*C8); | 1042 t1 = MULH( in1[2*4] - in1[2*8] , -2*C8); |
1043 t2 = MULH(2*(in1[2*2] + in1[2*8]), -C4); | 1043 t2 = MULH(2*(in1[2*2] + in1[2*8]), -C4); |
1044 | 1044 |
1045 tmp1[10] = t3 - t0 - t2; | 1045 tmp1[10] = t3 - t0 - t2; |
1046 tmp1[ 2] = t3 + t0 + t1; | 1046 tmp1[ 2] = t3 + t0 + t1; |
1047 tmp1[14] = t3 + t2 - t1; | 1047 tmp1[14] = t3 + t2 - t1; |
1048 | 1048 |
1049 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3); | 1049 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3); |
1050 t2 = MULH(2*(in1[2*1] + in1[2*5]), C1); | 1050 t2 = MULH(2*(in1[2*1] + in1[2*5]), C1); |
1051 t3 = MULH( in1[2*5] - in1[2*7] , -2*C7); | 1051 t3 = MULH( in1[2*5] - in1[2*7] , -2*C7); |
1052 t0 = MULH(2*in1[2*3], C3); | 1052 t0 = MULH(2*in1[2*3], C3); |
1053 | 1053 |
1068 | 1068 |
1069 t2 = tmp[i + 1]; | 1069 t2 = tmp[i + 1]; |
1070 t3 = tmp[i + 3]; | 1070 t3 = tmp[i + 3]; |
1071 s1 = MULL(t3 + t2, icos36[j]); | 1071 s1 = MULL(t3 + t2, icos36[j]); |
1072 s3 = MULL(t3 - t2, icos36[8 - j]); | 1072 s3 = MULL(t3 - t2, icos36[8 - j]); |
1073 | 1073 |
1074 t0 = s0 + s1; | 1074 t0 = s0 + s1; |
1075 t1 = s0 - s1; | 1075 t1 = s0 - s1; |
1076 out[(9 + j)*SBLIMIT] = MULH(t1, win[9 + j]) + buf[9 + j]; | 1076 out[(9 + j)*SBLIMIT] = MULH(t1, win[9 + j]) + buf[9 + j]; |
1077 out[(8 - j)*SBLIMIT] = MULH(t1, win[8 - j]) + buf[8 - j]; | 1077 out[(8 - j)*SBLIMIT] = MULH(t1, win[8 - j]) + buf[8 - j]; |
1078 buf[9 + j] = MULH(t0, win[18 + 9 + j]); | 1078 buf[9 + j] = MULH(t0, win[18 + 9 + j]); |
1079 buf[8 - j] = MULH(t0, win[18 + 8 - j]); | 1079 buf[8 - j] = MULH(t0, win[18 + 8 - j]); |
1080 | 1080 |
1081 t0 = s2 + s3; | 1081 t0 = s2 + s3; |
1082 t1 = s2 - s3; | 1082 t1 = s2 - s3; |
1083 out[(9 + 8 - j)*SBLIMIT] = MULH(t1, win[9 + 8 - j]) + buf[9 + 8 - j]; | 1083 out[(9 + 8 - j)*SBLIMIT] = MULH(t1, win[9 + 8 - j]) + buf[9 + 8 - j]; |
1084 out[( j)*SBLIMIT] = MULH(t1, win[ j]) + buf[ j]; | 1084 out[( j)*SBLIMIT] = MULH(t1, win[ j]) + buf[ j]; |
1085 buf[9 + 8 - j] = MULH(t0, win[18 + 9 + 8 - j]); | 1085 buf[9 + 8 - j] = MULH(t0, win[18 + 9 + 8 - j]); |
1109 mpeg25 = 0; | 1109 mpeg25 = 0; |
1110 } else { | 1110 } else { |
1111 s->lsf = 1; | 1111 s->lsf = 1; |
1112 mpeg25 = 1; | 1112 mpeg25 = 1; |
1113 } | 1113 } |
1114 | 1114 |
1115 s->layer = 4 - ((header >> 17) & 3); | 1115 s->layer = 4 - ((header >> 17) & 3); |
1116 /* extract frequency */ | 1116 /* extract frequency */ |
1117 sample_rate_index = (header >> 10) & 3; | 1117 sample_rate_index = (header >> 10) & 3; |
1118 sample_rate = mpa_freq_tab[sample_rate_index] >> (s->lsf + mpeg25); | 1118 sample_rate = mpa_freq_tab[sample_rate_index] >> (s->lsf + mpeg25); |
1119 sample_rate_index += 3 * (s->lsf + mpeg25); | 1119 sample_rate_index += 3 * (s->lsf + mpeg25); |
1132 | 1132 |
1133 if (s->mode == MPA_MONO) | 1133 if (s->mode == MPA_MONO) |
1134 s->nb_channels = 1; | 1134 s->nb_channels = 1; |
1135 else | 1135 else |
1136 s->nb_channels = 2; | 1136 s->nb_channels = 2; |
1137 | 1137 |
1138 if (bitrate_index != 0) { | 1138 if (bitrate_index != 0) { |
1139 frame_size = mpa_bitrate_tab[s->lsf][s->layer - 1][bitrate_index]; | 1139 frame_size = mpa_bitrate_tab[s->lsf][s->layer - 1][bitrate_index]; |
1140 s->bit_rate = frame_size * 1000; | 1140 s->bit_rate = frame_size * 1000; |
1141 switch(s->layer) { | 1141 switch(s->layer) { |
1142 case 1: | 1142 case 1: |
1175 s->frame_size += padding; | 1175 s->frame_size += padding; |
1176 s->bit_rate = (s->frame_size * (sample_rate << s->lsf)) / 144000; | 1176 s->bit_rate = (s->frame_size * (sample_rate << s->lsf)) / 144000; |
1177 break; | 1177 break; |
1178 } | 1178 } |
1179 } | 1179 } |
1180 | 1180 |
1181 #if defined(DEBUG) | 1181 #if defined(DEBUG) |
1182 printf("layer%d, %d Hz, %d kbits/s, ", | 1182 printf("layer%d, %d Hz, %d kbits/s, ", |
1183 s->layer, s->sample_rate, s->bit_rate); | 1183 s->layer, s->sample_rate, s->bit_rate); |
1184 if (s->nb_channels == 2) { | 1184 if (s->nb_channels == 2) { |
1185 if (s->layer == 3) { | 1185 if (s->layer == 3) { |
1239 { | 1239 { |
1240 int bound, i, v, n, ch, j, mant; | 1240 int bound, i, v, n, ch, j, mant; |
1241 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT]; | 1241 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT]; |
1242 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT]; | 1242 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT]; |
1243 | 1243 |
1244 if (s->mode == MPA_JSTEREO) | 1244 if (s->mode == MPA_JSTEREO) |
1245 bound = (s->mode_ext + 1) * 4; | 1245 bound = (s->mode_ext + 1) * 4; |
1246 else | 1246 else |
1247 bound = SBLIMIT; | 1247 bound = SBLIMIT; |
1248 | 1248 |
1249 /* allocation bits */ | 1249 /* allocation bits */ |
1267 if (allocation[0][i]) { | 1267 if (allocation[0][i]) { |
1268 scale_factors[0][i] = get_bits(&s->gb, 6); | 1268 scale_factors[0][i] = get_bits(&s->gb, 6); |
1269 scale_factors[1][i] = get_bits(&s->gb, 6); | 1269 scale_factors[1][i] = get_bits(&s->gb, 6); |
1270 } | 1270 } |
1271 } | 1271 } |
1272 | 1272 |
1273 /* compute samples */ | 1273 /* compute samples */ |
1274 for(j=0;j<12;j++) { | 1274 for(j=0;j<12;j++) { |
1275 for(i=0;i<bound;i++) { | 1275 for(i=0;i<bound;i++) { |
1276 for(ch=0;ch<s->nb_channels;ch++) { | 1276 for(ch=0;ch<s->nb_channels;ch++) { |
1277 n = allocation[ch][i]; | 1277 n = allocation[ch][i]; |
1303 | 1303 |
1304 /* bitrate is in kb/s */ | 1304 /* bitrate is in kb/s */ |
1305 int l2_select_table(int bitrate, int nb_channels, int freq, int lsf) | 1305 int l2_select_table(int bitrate, int nb_channels, int freq, int lsf) |
1306 { | 1306 { |
1307 int ch_bitrate, table; | 1307 int ch_bitrate, table; |
1308 | 1308 |
1309 ch_bitrate = bitrate / nb_channels; | 1309 ch_bitrate = bitrate / nb_channels; |
1310 if (!lsf) { | 1310 if (!lsf) { |
1311 if ((freq == 48000 && ch_bitrate >= 56) || | 1311 if ((freq == 48000 && ch_bitrate >= 56) || |
1312 (ch_bitrate >= 56 && ch_bitrate <= 80)) | 1312 (ch_bitrate >= 56 && ch_bitrate <= 80)) |
1313 table = 0; | 1313 table = 0; |
1314 else if (freq != 48000 && ch_bitrate >= 96) | 1314 else if (freq != 48000 && ch_bitrate >= 96) |
1315 table = 1; | 1315 table = 1; |
1316 else if (freq != 32000 && ch_bitrate <= 48) | 1316 else if (freq != 32000 && ch_bitrate <= 48) |
1317 table = 2; | 1317 table = 2; |
1318 else | 1318 else |
1319 table = 3; | 1319 table = 3; |
1320 } else { | 1320 } else { |
1321 table = 4; | 1321 table = 4; |
1322 } | 1322 } |
1323 return table; | 1323 return table; |
1332 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT]; | 1332 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT]; |
1333 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf; | 1333 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf; |
1334 int scale, qindex, bits, steps, k, l, m, b; | 1334 int scale, qindex, bits, steps, k, l, m, b; |
1335 | 1335 |
1336 /* select decoding table */ | 1336 /* select decoding table */ |
1337 table = l2_select_table(s->bit_rate / 1000, s->nb_channels, | 1337 table = l2_select_table(s->bit_rate / 1000, s->nb_channels, |
1338 s->sample_rate, s->lsf); | 1338 s->sample_rate, s->lsf); |
1339 sblimit = sblimit_table[table]; | 1339 sblimit = sblimit_table[table]; |
1340 alloc_table = alloc_tables[table]; | 1340 alloc_table = alloc_tables[table]; |
1341 | 1341 |
1342 if (s->mode == MPA_JSTEREO) | 1342 if (s->mode == MPA_JSTEREO) |
1343 bound = (s->mode_ext + 1) * 4; | 1343 bound = (s->mode_ext + 1) * 4; |
1344 else | 1344 else |
1345 bound = sblimit; | 1345 bound = sblimit; |
1346 | 1346 |
1347 dprintf("bound=%d sblimit=%d\n", bound, sblimit); | 1347 dprintf("bound=%d sblimit=%d\n", bound, sblimit); |
1377 #endif | 1377 #endif |
1378 | 1378 |
1379 /* scale codes */ | 1379 /* scale codes */ |
1380 for(i=0;i<sblimit;i++) { | 1380 for(i=0;i<sblimit;i++) { |
1381 for(ch=0;ch<s->nb_channels;ch++) { | 1381 for(ch=0;ch<s->nb_channels;ch++) { |
1382 if (bit_alloc[ch][i]) | 1382 if (bit_alloc[ch][i]) |
1383 scale_code[ch][i] = get_bits(&s->gb, 2); | 1383 scale_code[ch][i] = get_bits(&s->gb, 2); |
1384 } | 1384 } |
1385 } | 1385 } |
1386 | 1386 |
1387 /* scale factors */ | 1387 /* scale factors */ |
1388 for(i=0;i<sblimit;i++) { | 1388 for(i=0;i<sblimit;i++) { |
1389 for(ch=0;ch<s->nb_channels;ch++) { | 1389 for(ch=0;ch<s->nb_channels;ch++) { |
1390 if (bit_alloc[ch][i]) { | 1390 if (bit_alloc[ch][i]) { |
1391 sf = scale_factors[ch][i]; | 1391 sf = scale_factors[ch][i]; |
1444 bits = quant_bits[qindex]; | 1444 bits = quant_bits[qindex]; |
1445 if (bits < 0) { | 1445 if (bits < 0) { |
1446 /* 3 values at the same time */ | 1446 /* 3 values at the same time */ |
1447 v = get_bits(&s->gb, -bits); | 1447 v = get_bits(&s->gb, -bits); |
1448 steps = quant_steps[qindex]; | 1448 steps = quant_steps[qindex]; |
1449 s->sb_samples[ch][k * 12 + l + 0][i] = | 1449 s->sb_samples[ch][k * 12 + l + 0][i] = |
1450 l2_unscale_group(steps, v % steps, scale); | 1450 l2_unscale_group(steps, v % steps, scale); |
1451 v = v / steps; | 1451 v = v / steps; |
1452 s->sb_samples[ch][k * 12 + l + 1][i] = | 1452 s->sb_samples[ch][k * 12 + l + 1][i] = |
1453 l2_unscale_group(steps, v % steps, scale); | 1453 l2_unscale_group(steps, v % steps, scale); |
1454 v = v / steps; | 1454 v = v / steps; |
1455 s->sb_samples[ch][k * 12 + l + 2][i] = | 1455 s->sb_samples[ch][k * 12 + l + 2][i] = |
1456 l2_unscale_group(steps, v, scale); | 1456 l2_unscale_group(steps, v, scale); |
1457 } else { | 1457 } else { |
1458 for(m=0;m<3;m++) { | 1458 for(m=0;m<3;m++) { |
1459 v = get_bits(&s->gb, bits); | 1459 v = get_bits(&s->gb, bits); |
1460 v = l1_unscale(bits - 1, v, scale); | 1460 v = l1_unscale(bits - 1, v, scale); |
1466 s->sb_samples[ch][k * 12 + l + 1][i] = 0; | 1466 s->sb_samples[ch][k * 12 + l + 1][i] = 0; |
1467 s->sb_samples[ch][k * 12 + l + 2][i] = 0; | 1467 s->sb_samples[ch][k * 12 + l + 2][i] = 0; |
1468 } | 1468 } |
1469 } | 1469 } |
1470 /* next subband in alloc table */ | 1470 /* next subband in alloc table */ |
1471 j += 1 << bit_alloc_bits; | 1471 j += 1 << bit_alloc_bits; |
1472 } | 1472 } |
1473 /* XXX: find a way to avoid this duplication of code */ | 1473 /* XXX: find a way to avoid this duplication of code */ |
1474 for(i=bound;i<sblimit;i++) { | 1474 for(i=bound;i<sblimit;i++) { |
1475 bit_alloc_bits = alloc_table[j]; | 1475 bit_alloc_bits = alloc_table[j]; |
1476 b = bit_alloc[0][i]; | 1476 b = bit_alloc[0][i]; |
1484 /* 3 values at the same time */ | 1484 /* 3 values at the same time */ |
1485 v = get_bits(&s->gb, -bits); | 1485 v = get_bits(&s->gb, -bits); |
1486 steps = quant_steps[qindex]; | 1486 steps = quant_steps[qindex]; |
1487 mant = v % steps; | 1487 mant = v % steps; |
1488 v = v / steps; | 1488 v = v / steps; |
1489 s->sb_samples[0][k * 12 + l + 0][i] = | 1489 s->sb_samples[0][k * 12 + l + 0][i] = |
1490 l2_unscale_group(steps, mant, scale0); | 1490 l2_unscale_group(steps, mant, scale0); |
1491 s->sb_samples[1][k * 12 + l + 0][i] = | 1491 s->sb_samples[1][k * 12 + l + 0][i] = |
1492 l2_unscale_group(steps, mant, scale1); | 1492 l2_unscale_group(steps, mant, scale1); |
1493 mant = v % steps; | 1493 mant = v % steps; |
1494 v = v / steps; | 1494 v = v / steps; |
1495 s->sb_samples[0][k * 12 + l + 1][i] = | 1495 s->sb_samples[0][k * 12 + l + 1][i] = |
1496 l2_unscale_group(steps, mant, scale0); | 1496 l2_unscale_group(steps, mant, scale0); |
1497 s->sb_samples[1][k * 12 + l + 1][i] = | 1497 s->sb_samples[1][k * 12 + l + 1][i] = |
1498 l2_unscale_group(steps, mant, scale1); | 1498 l2_unscale_group(steps, mant, scale1); |
1499 s->sb_samples[0][k * 12 + l + 2][i] = | 1499 s->sb_samples[0][k * 12 + l + 2][i] = |
1500 l2_unscale_group(steps, v, scale0); | 1500 l2_unscale_group(steps, v, scale0); |
1501 s->sb_samples[1][k * 12 + l + 2][i] = | 1501 s->sb_samples[1][k * 12 + l + 2][i] = |
1502 l2_unscale_group(steps, v, scale1); | 1502 l2_unscale_group(steps, v, scale1); |
1503 } else { | 1503 } else { |
1504 for(m=0;m<3;m++) { | 1504 for(m=0;m<3;m++) { |
1505 mant = get_bits(&s->gb, bits); | 1505 mant = get_bits(&s->gb, bits); |
1506 s->sb_samples[0][k * 12 + l + m][i] = | 1506 s->sb_samples[0][k * 12 + l + m][i] = |
1507 l1_unscale(bits - 1, mant, scale0); | 1507 l1_unscale(bits - 1, mant, scale0); |
1508 s->sb_samples[1][k * 12 + l + m][i] = | 1508 s->sb_samples[1][k * 12 + l + m][i] = |
1509 l1_unscale(bits - 1, mant, scale1); | 1509 l1_unscale(bits - 1, mant, scale1); |
1510 } | 1510 } |
1511 } | 1511 } |
1512 } else { | 1512 } else { |
1513 s->sb_samples[0][k * 12 + l + 0][i] = 0; | 1513 s->sb_samples[0][k * 12 + l + 0][i] = 0; |
1516 s->sb_samples[1][k * 12 + l + 0][i] = 0; | 1516 s->sb_samples[1][k * 12 + l + 0][i] = 0; |
1517 s->sb_samples[1][k * 12 + l + 1][i] = 0; | 1517 s->sb_samples[1][k * 12 + l + 1][i] = 0; |
1518 s->sb_samples[1][k * 12 + l + 2][i] = 0; | 1518 s->sb_samples[1][k * 12 + l + 2][i] = 0; |
1519 } | 1519 } |
1520 /* next subband in alloc table */ | 1520 /* next subband in alloc table */ |
1521 j += 1 << bit_alloc_bits; | 1521 j += 1 << bit_alloc_bits; |
1522 } | 1522 } |
1523 /* fill remaining samples to zero */ | 1523 /* fill remaining samples to zero */ |
1524 for(i=sblimit;i<SBLIMIT;i++) { | 1524 for(i=sblimit;i<SBLIMIT;i++) { |
1525 for(ch=0;ch<s->nb_channels;ch++) { | 1525 for(ch=0;ch<s->nb_channels;ch++) { |
1526 s->sb_samples[ch][k * 12 + l + 0][i] = 0; | 1526 s->sb_samples[ch][k * 12 + l + 0][i] = 0; |
1543 /* compute current position in stream */ | 1543 /* compute current position in stream */ |
1544 ptr = (uint8_t *)(s->gb.buffer + (get_bits_count(&s->gb)>>3)); | 1544 ptr = (uint8_t *)(s->gb.buffer + (get_bits_count(&s->gb)>>3)); |
1545 | 1545 |
1546 /* copy old data before current one */ | 1546 /* copy old data before current one */ |
1547 ptr -= backstep; | 1547 ptr -= backstep; |
1548 memcpy(ptr, s->inbuf1[s->inbuf_index ^ 1] + | 1548 memcpy(ptr, s->inbuf1[s->inbuf_index ^ 1] + |
1549 BACKSTEP_SIZE + s->old_frame_size - backstep, backstep); | 1549 BACKSTEP_SIZE + s->old_frame_size - backstep, backstep); |
1550 /* init get bits again */ | 1550 /* init get bits again */ |
1551 init_get_bits(&s->gb, ptr, (s->frame_size + backstep)*8); | 1551 init_get_bits(&s->gb, ptr, (s->frame_size + backstep)*8); |
1552 | 1552 |
1553 /* prepare next buffer */ | 1553 /* prepare next buffer */ |
1574 slen[1] = sf % n1; | 1574 slen[1] = sf % n1; |
1575 sf /= n1; | 1575 sf /= n1; |
1576 slen[0] = sf; | 1576 slen[0] = sf; |
1577 } | 1577 } |
1578 | 1578 |
1579 static void exponents_from_scale_factors(MPADecodeContext *s, | 1579 static void exponents_from_scale_factors(MPADecodeContext *s, |
1580 GranuleDef *g, | 1580 GranuleDef *g, |
1581 int16_t *exponents) | 1581 int16_t *exponents) |
1582 { | 1582 { |
1583 const uint8_t *bstab, *pretab; | 1583 const uint8_t *bstab, *pretab; |
1584 int len, i, j, k, l, v0, shift, gain, gains[3]; | 1584 int len, i, j, k, l, v0, shift, gain, gains[3]; |
1658 y = y & 0x0f; | 1658 y = y & 0x0f; |
1659 } else { | 1659 } else { |
1660 x = 0; | 1660 x = 0; |
1661 y = 0; | 1661 y = 0; |
1662 } | 1662 } |
1663 dprintf("region=%d n=%d x=%d y=%d exp=%d\n", | 1663 dprintf("region=%d n=%d x=%d y=%d exp=%d\n", |
1664 i, g->region_size[i] - j, x, y, exponents[s_index]); | 1664 i, g->region_size[i] - j, x, y, exponents[s_index]); |
1665 if (x) { | 1665 if (x) { |
1666 if (x == 15) | 1666 if (x == 15) |
1667 x += get_bitsz(&s->gb, linbits); | 1667 x += get_bitsz(&s->gb, linbits); |
1668 v = l3_unscale(x, exponents[s_index]); | 1668 v = l3_unscale(x, exponents[s_index]); |
1682 v = 0; | 1682 v = 0; |
1683 } | 1683 } |
1684 g->sb_hybrid[s_index++] = v; | 1684 g->sb_hybrid[s_index++] = v; |
1685 } | 1685 } |
1686 } | 1686 } |
1687 | 1687 |
1688 /* high frequencies */ | 1688 /* high frequencies */ |
1689 vlc = &huff_quad_vlc[g->count1table_select]; | 1689 vlc = &huff_quad_vlc[g->count1table_select]; |
1690 last_gb.buffer = NULL; | 1690 last_gb.buffer = NULL; |
1691 while (s_index <= 572) { | 1691 while (s_index <= 572) { |
1692 pos = get_bits_count(&s->gb); | 1692 pos = get_bits_count(&s->gb); |
1742 ptr = g->sb_hybrid + 48; | 1742 ptr = g->sb_hybrid + 48; |
1743 } | 1743 } |
1744 } else { | 1744 } else { |
1745 ptr = g->sb_hybrid; | 1745 ptr = g->sb_hybrid; |
1746 } | 1746 } |
1747 | 1747 |
1748 for(i=g->short_start;i<13;i++) { | 1748 for(i=g->short_start;i<13;i++) { |
1749 len = band_size_short[s->sample_rate_index][i]; | 1749 len = band_size_short[s->sample_rate_index][i]; |
1750 ptr1 = ptr; | 1750 ptr1 = ptr; |
1751 for(k=0;k<3;k++) { | 1751 for(k=0;k<3;k++) { |
1752 dst = tmp + k; | 1752 dst = tmp + k; |
1778 sf_max = 7; | 1778 sf_max = 7; |
1779 } else { | 1779 } else { |
1780 is_tab = is_table_lsf[g1->scalefac_compress & 1]; | 1780 is_tab = is_table_lsf[g1->scalefac_compress & 1]; |
1781 sf_max = 16; | 1781 sf_max = 16; |
1782 } | 1782 } |
1783 | 1783 |
1784 tab0 = g0->sb_hybrid + 576; | 1784 tab0 = g0->sb_hybrid + 576; |
1785 tab1 = g1->sb_hybrid + 576; | 1785 tab1 = g1->sb_hybrid + 576; |
1786 | 1786 |
1787 non_zero_found_short[0] = 0; | 1787 non_zero_found_short[0] = 0; |
1788 non_zero_found_short[1] = 0; | 1788 non_zero_found_short[1] = 0; |
1829 } | 1829 } |
1830 } | 1830 } |
1831 } | 1831 } |
1832 } | 1832 } |
1833 | 1833 |
1834 non_zero_found = non_zero_found_short[0] | | 1834 non_zero_found = non_zero_found_short[0] | |
1835 non_zero_found_short[1] | | 1835 non_zero_found_short[1] | |
1836 non_zero_found_short[2]; | 1836 non_zero_found_short[2]; |
1837 | 1837 |
1838 for(i = g1->long_end - 1;i >= 0;i--) { | 1838 for(i = g1->long_end - 1;i >= 0;i--) { |
1839 len = band_size_long[s->sample_rate_index][i]; | 1839 len = band_size_long[s->sample_rate_index][i]; |
1840 tab0 -= len; | 1840 tab0 -= len; |
1901 /* XXX: check this for 8000Hz case */ | 1901 /* XXX: check this for 8000Hz case */ |
1902 n = 1; | 1902 n = 1; |
1903 } else { | 1903 } else { |
1904 n = SBLIMIT - 1; | 1904 n = SBLIMIT - 1; |
1905 } | 1905 } |
1906 | 1906 |
1907 ptr = g->sb_hybrid + 18; | 1907 ptr = g->sb_hybrid + 18; |
1908 for(i = n;i > 0;i--) { | 1908 for(i = n;i > 0;i--) { |
1909 int tmp0, tmp1, tmp2; | 1909 int tmp0, tmp1, tmp2; |
1910 csa = &csa_table[0][0]; | 1910 csa = &csa_table[0][0]; |
1911 #define INT_AA(j) \ | 1911 #define INT_AA(j) \ |
1921 INT_AA(3) | 1921 INT_AA(3) |
1922 INT_AA(4) | 1922 INT_AA(4) |
1923 INT_AA(5) | 1923 INT_AA(5) |
1924 INT_AA(6) | 1924 INT_AA(6) |
1925 INT_AA(7) | 1925 INT_AA(7) |
1926 | 1926 |
1927 ptr += 18; | 1927 ptr += 18; |
1928 } | 1928 } |
1929 } | 1929 } |
1930 | 1930 |
1931 static void compute_antialias_float(MPADecodeContext *s, | 1931 static void compute_antialias_float(MPADecodeContext *s, |
1932 GranuleDef *g) | 1932 GranuleDef *g) |
1941 /* XXX: check this for 8000Hz case */ | 1941 /* XXX: check this for 8000Hz case */ |
1942 n = 1; | 1942 n = 1; |
1943 } else { | 1943 } else { |
1944 n = SBLIMIT - 1; | 1944 n = SBLIMIT - 1; |
1945 } | 1945 } |
1946 | 1946 |
1947 ptr = g->sb_hybrid + 18; | 1947 ptr = g->sb_hybrid + 18; |
1948 for(i = n;i > 0;i--) { | 1948 for(i = n;i > 0;i--) { |
1949 float tmp0, tmp1; | 1949 float tmp0, tmp1; |
1950 float *csa = &csa_table_float[0][0]; | 1950 float *csa = &csa_table_float[0][0]; |
1951 #define FLOAT_AA(j)\ | 1951 #define FLOAT_AA(j)\ |
1952 tmp0= ptr[-1-j];\ | 1952 tmp0= ptr[-1-j];\ |
1953 tmp1= ptr[ j];\ | 1953 tmp1= ptr[ j];\ |
1954 ptr[-1-j] = lrintf(tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j]);\ | 1954 ptr[-1-j] = lrintf(tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j]);\ |
1955 ptr[ j] = lrintf(tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j]); | 1955 ptr[ j] = lrintf(tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j]); |
1956 | 1956 |
1957 FLOAT_AA(0) | 1957 FLOAT_AA(0) |
1958 FLOAT_AA(1) | 1958 FLOAT_AA(1) |
1959 FLOAT_AA(2) | 1959 FLOAT_AA(2) |
1960 FLOAT_AA(3) | 1960 FLOAT_AA(3) |
1961 FLOAT_AA(4) | 1961 FLOAT_AA(4) |
1962 FLOAT_AA(5) | 1962 FLOAT_AA(5) |
1963 FLOAT_AA(6) | 1963 FLOAT_AA(6) |
1964 FLOAT_AA(7) | 1964 FLOAT_AA(7) |
1965 | 1965 |
1966 ptr += 18; | 1966 ptr += 18; |
1967 } | 1967 } |
1968 } | 1968 } |
1969 | 1969 |
1970 static void compute_imdct(MPADecodeContext *s, | 1970 static void compute_imdct(MPADecodeContext *s, |
1971 GranuleDef *g, | 1971 GranuleDef *g, |
1972 int32_t *sb_samples, | 1972 int32_t *sb_samples, |
1973 int32_t *mdct_buf) | 1973 int32_t *mdct_buf) |
1974 { | 1974 { |
1975 int32_t *ptr, *win, *win1, *buf, *out_ptr, *ptr1; | 1975 int32_t *ptr, *win, *win1, *buf, *out_ptr, *ptr1; |
1976 int32_t out2[12]; | 1976 int32_t out2[12]; |
2016 } | 2016 } |
2017 for(j=mdct_long_end;j<sblimit;j++) { | 2017 for(j=mdct_long_end;j<sblimit;j++) { |
2018 /* select frequency inversion */ | 2018 /* select frequency inversion */ |
2019 win = mdct_win[2] + ((4 * 36) & -(j & 1)); | 2019 win = mdct_win[2] + ((4 * 36) & -(j & 1)); |
2020 out_ptr = sb_samples + j; | 2020 out_ptr = sb_samples + j; |
2021 | 2021 |
2022 for(i=0; i<6; i++){ | 2022 for(i=0; i<6; i++){ |
2023 *out_ptr = buf[i]; | 2023 *out_ptr = buf[i]; |
2024 out_ptr += SBLIMIT; | 2024 out_ptr += SBLIMIT; |
2025 } | 2025 } |
2026 imdct12(out2, ptr + 0); | 2026 imdct12(out2, ptr + 0); |
2062 { | 2062 { |
2063 static FILE *files[16], *f; | 2063 static FILE *files[16], *f; |
2064 char buf[512]; | 2064 char buf[512]; |
2065 int i; | 2065 int i; |
2066 int32_t v; | 2066 int32_t v; |
2067 | 2067 |
2068 f = files[fnum]; | 2068 f = files[fnum]; |
2069 if (!f) { | 2069 if (!f) { |
2070 snprintf(buf, sizeof(buf), "/tmp/out%d.%s.pcm", | 2070 snprintf(buf, sizeof(buf), "/tmp/out%d.%s.pcm", |
2071 fnum, | 2071 fnum, |
2072 #ifdef USE_HIGHPRECISION | 2072 #ifdef USE_HIGHPRECISION |
2073 "hp" | 2073 "hp" |
2074 #else | 2074 #else |
2075 "lp" | 2075 "lp" |
2076 #endif | 2076 #endif |
2078 f = fopen(buf, "w"); | 2078 f = fopen(buf, "w"); |
2079 if (!f) | 2079 if (!f) |
2080 return; | 2080 return; |
2081 files[fnum] = f; | 2081 files[fnum] = f; |
2082 } | 2082 } |
2083 | 2083 |
2084 if (fnum == 0) { | 2084 if (fnum == 0) { |
2085 static int pos = 0; | 2085 static int pos = 0; |
2086 av_log(NULL, AV_LOG_DEBUG, "pos=%d\n", pos); | 2086 av_log(NULL, AV_LOG_DEBUG, "pos=%d\n", pos); |
2087 for(i=0;i<n;i++) { | 2087 for(i=0;i<n;i++) { |
2088 av_log(NULL, AV_LOG_DEBUG, " %0.4f", (double)tab[i] / FRAC_ONE); | 2088 av_log(NULL, AV_LOG_DEBUG, " %0.4f", (double)tab[i] / FRAC_ONE); |
2126 for(ch=0;ch<s->nb_channels;ch++) { | 2126 for(ch=0;ch<s->nb_channels;ch++) { |
2127 granules[ch][0].scfsi = 0; /* all scale factors are transmitted */ | 2127 granules[ch][0].scfsi = 0; /* all scale factors are transmitted */ |
2128 granules[ch][1].scfsi = get_bits(&s->gb, 4); | 2128 granules[ch][1].scfsi = get_bits(&s->gb, 4); |
2129 } | 2129 } |
2130 } | 2130 } |
2131 | 2131 |
2132 for(gr=0;gr<nb_granules;gr++) { | 2132 for(gr=0;gr<nb_granules;gr++) { |
2133 for(ch=0;ch<s->nb_channels;ch++) { | 2133 for(ch=0;ch<s->nb_channels;ch++) { |
2134 dprintf("gr=%d ch=%d: side_info\n", gr, ch); | 2134 dprintf("gr=%d ch=%d: side_info\n", gr, ch); |
2135 g = &granules[ch][gr]; | 2135 g = &granules[ch][gr]; |
2136 g->part2_3_length = get_bits(&s->gb, 12); | 2136 g->part2_3_length = get_bits(&s->gb, 12); |
2137 g->big_values = get_bits(&s->gb, 9); | 2137 g->big_values = get_bits(&s->gb, 9); |
2138 g->global_gain = get_bits(&s->gb, 8); | 2138 g->global_gain = get_bits(&s->gb, 8); |
2139 /* if MS stereo only is selected, we precompute the | 2139 /* if MS stereo only is selected, we precompute the |
2140 1/sqrt(2) renormalization factor */ | 2140 1/sqrt(2) renormalization factor */ |
2141 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) == | 2141 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) == |
2142 MODE_EXT_MS_STEREO) | 2142 MODE_EXT_MS_STEREO) |
2143 g->global_gain -= 2; | 2143 g->global_gain -= 2; |
2144 if (s->lsf) | 2144 if (s->lsf) |
2145 g->scalefac_compress = get_bits(&s->gb, 9); | 2145 g->scalefac_compress = get_bits(&s->gb, 9); |
2146 else | 2146 else |
2151 if (g->block_type == 0) | 2151 if (g->block_type == 0) |
2152 return -1; | 2152 return -1; |
2153 g->switch_point = get_bits(&s->gb, 1); | 2153 g->switch_point = get_bits(&s->gb, 1); |
2154 for(i=0;i<2;i++) | 2154 for(i=0;i<2;i++) |
2155 g->table_select[i] = get_bits(&s->gb, 5); | 2155 g->table_select[i] = get_bits(&s->gb, 5); |
2156 for(i=0;i<3;i++) | 2156 for(i=0;i<3;i++) |
2157 g->subblock_gain[i] = get_bits(&s->gb, 3); | 2157 g->subblock_gain[i] = get_bits(&s->gb, 3); |
2158 /* compute huffman coded region sizes */ | 2158 /* compute huffman coded region sizes */ |
2159 if (g->block_type == 2) | 2159 if (g->block_type == 2) |
2160 g->region_size[0] = (36 / 2); | 2160 g->region_size[0] = (36 / 2); |
2161 else { | 2161 else { |
2162 if (s->sample_rate_index <= 2) | 2162 if (s->sample_rate_index <= 2) |
2163 g->region_size[0] = (36 / 2); | 2163 g->region_size[0] = (36 / 2); |
2164 else if (s->sample_rate_index != 8) | 2164 else if (s->sample_rate_index != 8) |
2165 g->region_size[0] = (54 / 2); | 2165 g->region_size[0] = (54 / 2); |
2166 else | 2166 else |
2167 g->region_size[0] = (108 / 2); | 2167 g->region_size[0] = (108 / 2); |
2168 } | 2168 } |
2169 g->region_size[1] = (576 / 2); | 2169 g->region_size[1] = (576 / 2); |
2174 for(i=0;i<3;i++) | 2174 for(i=0;i<3;i++) |
2175 g->table_select[i] = get_bits(&s->gb, 5); | 2175 g->table_select[i] = get_bits(&s->gb, 5); |
2176 /* compute huffman coded region sizes */ | 2176 /* compute huffman coded region sizes */ |
2177 region_address1 = get_bits(&s->gb, 4); | 2177 region_address1 = get_bits(&s->gb, 4); |
2178 region_address2 = get_bits(&s->gb, 3); | 2178 region_address2 = get_bits(&s->gb, 3); |
2179 dprintf("region1=%d region2=%d\n", | 2179 dprintf("region1=%d region2=%d\n", |
2180 region_address1, region_address2); | 2180 region_address1, region_address2); |
2181 g->region_size[0] = | 2181 g->region_size[0] = |
2182 band_index_long[s->sample_rate_index][region_address1 + 1] >> 1; | 2182 band_index_long[s->sample_rate_index][region_address1 + 1] >> 1; |
2183 l = region_address1 + region_address2 + 2; | 2183 l = region_address1 + region_address2 + 2; |
2184 /* should not overflow */ | 2184 /* should not overflow */ |
2185 if (l > 22) | 2185 if (l > 22) |
2186 l = 22; | 2186 l = 22; |
2187 g->region_size[1] = | 2187 g->region_size[1] = |
2188 band_index_long[s->sample_rate_index][l] >> 1; | 2188 band_index_long[s->sample_rate_index][l] >> 1; |
2189 } | 2189 } |
2190 /* convert region offsets to region sizes and truncate | 2190 /* convert region offsets to region sizes and truncate |
2191 size to big_values */ | 2191 size to big_values */ |
2192 g->region_size[2] = (576 / 2); | 2192 g->region_size[2] = (576 / 2); |
2209 g->long_end = 8; | 2209 g->long_end = 8; |
2210 else if (s->sample_rate_index != 8) | 2210 else if (s->sample_rate_index != 8) |
2211 g->long_end = 6; | 2211 g->long_end = 6; |
2212 else | 2212 else |
2213 g->long_end = 4; /* 8000 Hz */ | 2213 g->long_end = 4; /* 8000 Hz */ |
2214 | 2214 |
2215 if (s->sample_rate_index != 8) | 2215 if (s->sample_rate_index != 8) |
2216 g->short_start = 3; | 2216 g->short_start = 3; |
2217 else | 2217 else |
2218 g->short_start = 2; | 2218 g->short_start = 2; |
2219 } else { | 2219 } else { |
2220 g->long_end = 0; | 2220 g->long_end = 0; |
2221 g->short_start = 0; | 2221 g->short_start = 0; |
2222 } | 2222 } |
2223 } else { | 2223 } else { |
2224 g->short_start = 13; | 2224 g->short_start = 13; |
2225 g->long_end = 22; | 2225 g->long_end = 22; |
2226 } | 2226 } |
2227 | 2227 |
2228 g->preflag = 0; | 2228 g->preflag = 0; |
2229 if (!s->lsf) | 2229 if (!s->lsf) |
2230 g->preflag = get_bits(&s->gb, 1); | 2230 g->preflag = get_bits(&s->gb, 1); |
2231 g->scalefac_scale = get_bits(&s->gb, 1); | 2231 g->scalefac_scale = get_bits(&s->gb, 1); |
2232 g->count1table_select = get_bits(&s->gb, 1); | 2232 g->count1table_select = get_bits(&s->gb, 1); |
2242 } | 2242 } |
2243 | 2243 |
2244 for(gr=0;gr<nb_granules;gr++) { | 2244 for(gr=0;gr<nb_granules;gr++) { |
2245 for(ch=0;ch<s->nb_channels;ch++) { | 2245 for(ch=0;ch<s->nb_channels;ch++) { |
2246 g = &granules[ch][gr]; | 2246 g = &granules[ch][gr]; |
2247 | 2247 |
2248 bits_pos = get_bits_count(&s->gb); | 2248 bits_pos = get_bits_count(&s->gb); |
2249 | 2249 |
2250 if (!s->lsf) { | 2250 if (!s->lsf) { |
2251 uint8_t *sc; | 2251 uint8_t *sc; |
2252 int slen, slen1, slen2; | 2252 int slen, slen1, slen2; |
2253 | 2253 |
2254 /* MPEG1 scale factors */ | 2254 /* MPEG1 scale factors */ |
2283 } | 2283 } |
2284 g->scale_factors[j++] = 0; | 2284 g->scale_factors[j++] = 0; |
2285 } | 2285 } |
2286 #if defined(DEBUG) | 2286 #if defined(DEBUG) |
2287 { | 2287 { |
2288 printf("scfsi=%x gr=%d ch=%d scale_factors:\n", | 2288 printf("scfsi=%x gr=%d ch=%d scale_factors:\n", |
2289 g->scfsi, gr, ch); | 2289 g->scfsi, gr, ch); |
2290 for(i=0;i<j;i++) | 2290 for(i=0;i<j;i++) |
2291 printf(" %d", g->scale_factors[i]); | 2291 printf(" %d", g->scale_factors[i]); |
2292 printf("\n"); | 2292 printf("\n"); |
2293 } | 2293 } |
2340 /* XXX: should compute exact size */ | 2340 /* XXX: should compute exact size */ |
2341 for(;j<40;j++) | 2341 for(;j<40;j++) |
2342 g->scale_factors[j] = 0; | 2342 g->scale_factors[j] = 0; |
2343 #if defined(DEBUG) | 2343 #if defined(DEBUG) |
2344 { | 2344 { |
2345 printf("gr=%d ch=%d scale_factors:\n", | 2345 printf("gr=%d ch=%d scale_factors:\n", |
2346 gr, ch); | 2346 gr, ch); |
2347 for(i=0;i<40;i++) | 2347 for(i=0;i<40;i++) |
2348 printf(" %d", g->scale_factors[i]); | 2348 printf(" %d", g->scale_factors[i]); |
2349 printf("\n"); | 2349 printf("\n"); |
2350 } | 2350 } |
2387 #endif | 2387 #endif |
2388 s->compute_antialias(s, g); | 2388 s->compute_antialias(s, g); |
2389 #if defined(DEBUG) | 2389 #if defined(DEBUG) |
2390 sample_dump(1, g->sb_hybrid, 576); | 2390 sample_dump(1, g->sb_hybrid, 576); |
2391 #endif | 2391 #endif |
2392 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]); | 2392 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]); |
2393 #if defined(DEBUG) | 2393 #if defined(DEBUG) |
2394 sample_dump(2, &s->sb_samples[ch][18 * gr][0], 576); | 2394 sample_dump(2, &s->sb_samples[ch][18 * gr][0], 576); |
2395 #endif | 2395 #endif |
2396 } | 2396 } |
2397 } /* gr */ | 2397 } /* gr */ |
2398 return nb_granules * 18; | 2398 return nb_granules * 18; |
2399 } | 2399 } |
2400 | 2400 |
2401 static int mp_decode_frame(MPADecodeContext *s, | 2401 static int mp_decode_frame(MPADecodeContext *s, |
2402 OUT_INT *samples) | 2402 OUT_INT *samples) |
2403 { | 2403 { |
2404 int i, nb_frames, ch; | 2404 int i, nb_frames, ch; |
2405 OUT_INT *samples_ptr; | 2405 OUT_INT *samples_ptr; |
2406 | 2406 |
2407 init_get_bits(&s->gb, s->inbuf + HEADER_SIZE, | 2407 init_get_bits(&s->gb, s->inbuf + HEADER_SIZE, |
2408 (s->inbuf_ptr - s->inbuf - HEADER_SIZE)*8); | 2408 (s->inbuf_ptr - s->inbuf - HEADER_SIZE)*8); |
2409 | 2409 |
2410 /* skip error protection field */ | 2410 /* skip error protection field */ |
2411 if (s->error_protection) | 2411 if (s->error_protection) |
2412 get_bits(&s->gb, 16); | 2412 get_bits(&s->gb, 16); |
2413 | 2413 |
2414 dprintf("frame %d:\n", s->frame_count); | 2414 dprintf("frame %d:\n", s->frame_count); |
2445 s->sb_samples[ch][i]); | 2445 s->sb_samples[ch][i]); |
2446 samples_ptr += 32 * s->nb_channels; | 2446 samples_ptr += 32 * s->nb_channels; |
2447 } | 2447 } |
2448 } | 2448 } |
2449 #ifdef DEBUG | 2449 #ifdef DEBUG |
2450 s->frame_count++; | 2450 s->frame_count++; |
2451 #endif | 2451 #endif |
2452 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels; | 2452 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels; |
2453 } | 2453 } |
2454 | 2454 |
2455 static int decode_frame(AVCodecContext * avctx, | 2455 static int decode_frame(AVCodecContext * avctx, |
2566 padding = (header1 >> 9) & 1; | 2566 padding = (header1 >> 9) & 1; |
2567 if (s->layer == 1) | 2567 if (s->layer == 1) |
2568 s->free_format_frame_size -= padding * 4; | 2568 s->free_format_frame_size -= padding * 4; |
2569 else | 2569 else |
2570 s->free_format_frame_size -= padding; | 2570 s->free_format_frame_size -= padding; |
2571 dprintf("free frame size=%d padding=%d\n", | 2571 dprintf("free frame size=%d padding=%d\n", |
2572 s->free_format_frame_size, padding); | 2572 s->free_format_frame_size, padding); |
2573 decode_header(s, header1); | 2573 decode_header(s, header1); |
2574 goto next_data; | 2574 goto next_data; |
2575 } | 2575 } |
2576 p++; | 2576 p++; |
2590 buf_ptr += len; | 2590 buf_ptr += len; |
2591 s->inbuf_ptr += len; | 2591 s->inbuf_ptr += len; |
2592 buf_size -= len; | 2592 buf_size -= len; |
2593 } | 2593 } |
2594 next_data: | 2594 next_data: |
2595 if (s->frame_size > 0 && | 2595 if (s->frame_size > 0 && |
2596 (s->inbuf_ptr - s->inbuf) >= s->frame_size) { | 2596 (s->inbuf_ptr - s->inbuf) >= s->frame_size) { |
2597 if (avctx->parse_only) { | 2597 if (avctx->parse_only) { |
2598 /* simply return the frame data */ | 2598 /* simply return the frame data */ |
2599 *(uint8_t **)data = s->inbuf; | 2599 *(uint8_t **)data = s->inbuf; |
2600 out_size = s->inbuf_ptr - s->inbuf; | 2600 out_size = s->inbuf_ptr - s->inbuf; |