3 * Copyright (c) 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/audioconvert.h"
31 #include "mpegaudiodsp.h"
35 * - test lsf / mpeg25 extensively.
38 #include "mpegaudio.h"
39 #include "mpegaudiodecheader.h"
41 #define BACKSTEP_SIZE 512
44 /* layer 3 "granule" */
45 typedef struct GranuleDef {
50 int scalefac_compress;
55 uint8_t scalefac_scale;
56 uint8_t count1table_select;
57 int region_size[3]; /* number of huffman codes in each region */
59 int short_start, long_end; /* long/short band indexes */
60 uint8_t scale_factors[40];
61 INTFLOAT sb_hybrid[SBLIMIT * 18]; /* 576 samples */
64 typedef struct MPADecodeContext {
66 uint8_t last_buf[2 * BACKSTEP_SIZE + EXTRABYTES];
68 /* next header (used in free format parsing) */
69 uint32_t free_format_next_header;
72 DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
73 int synth_buf_offset[MPA_MAX_CHANNELS];
74 DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
75 INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
76 GranuleDef granules[2][2]; /* Used in Layer 3 */
77 int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
80 AVCodecContext* avctx;
86 # define SHR(a,b) ((a)*(1.0f/(1<<(b))))
87 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
88 # define FIXR(x) ((float)(x))
89 # define FIXHR(x) ((float)(x))
90 # define MULH3(x, y, s) ((s)*(y)*(x))
91 # define MULLx(x, y, s) ((y)*(x))
92 # define RENAME(a) a ## _float
93 # define OUT_FMT AV_SAMPLE_FMT_FLT
95 # define SHR(a,b) ((a)>>(b))
96 /* WARNING: only correct for positive numbers */
97 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
98 # define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
99 # define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
100 # define MULH3(x, y, s) MULH((s)*(x), y)
101 # define MULLx(x, y, s) MULL(x,y,s)
102 # define RENAME(a) a ## _fixed
103 # define OUT_FMT AV_SAMPLE_FMT_S16
108 #define HEADER_SIZE 4
110 #include "mpegaudiodata.h"
111 #include "mpegaudiodectab.h"
113 /* vlc structure for decoding layer 3 huffman tables */
114 static VLC huff_vlc[16];
115 static VLC_TYPE huff_vlc_tables[
116 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
117 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
119 static const int huff_vlc_tables_sizes[16] = {
120 0, 128, 128, 128, 130, 128, 154, 166,
121 142, 204, 190, 170, 542, 460, 662, 414
123 static VLC huff_quad_vlc[2];
124 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
125 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
126 /* computed from band_size_long */
127 static uint16_t band_index_long[9][23];
128 #include "mpegaudio_tablegen.h"
129 /* intensity stereo coef table */
130 static INTFLOAT is_table[2][16];
131 static INTFLOAT is_table_lsf[2][2][16];
132 static INTFLOAT csa_table[8][4];
133 static INTFLOAT mdct_win[8][36];
135 static int16_t division_tab3[1<<6 ];
136 static int16_t division_tab5[1<<8 ];
137 static int16_t division_tab9[1<<11];
139 static int16_t * const division_tabs[4] = {
140 division_tab3, division_tab5, NULL, division_tab9
143 /* lower 2 bits: modulo 3, higher bits: shift */
144 static uint16_t scale_factor_modshift[64];
145 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
146 static int32_t scale_factor_mult[15][3];
147 /* mult table for layer 2 group quantization */
149 #define SCALE_GEN(v) \
150 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
152 static const int32_t scale_factor_mult2[3][3] = {
153 SCALE_GEN(4.0 / 3.0), /* 3 steps */
154 SCALE_GEN(4.0 / 5.0), /* 5 steps */
155 SCALE_GEN(4.0 / 9.0), /* 9 steps */
159 * Convert region offsets to region sizes and truncate
160 * size to big_values.
162 static void ff_region_offset2size(GranuleDef *g)
165 g->region_size[2] = 576 / 2;
166 for (i = 0; i < 3; i++) {
167 k = FFMIN(g->region_size[i], g->big_values);
168 g->region_size[i] = k - j;
173 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
175 if (g->block_type == 2)
176 g->region_size[0] = (36 / 2);
178 if (s->sample_rate_index <= 2)
179 g->region_size[0] = (36 / 2);
180 else if (s->sample_rate_index != 8)
181 g->region_size[0] = (54 / 2);
183 g->region_size[0] = (108 / 2);
185 g->region_size[1] = (576 / 2);
188 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
191 g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
192 /* should not overflow */
193 l = FFMIN(ra1 + ra2 + 2, 22);
194 g->region_size[1] = band_index_long[s->sample_rate_index][ l] >> 1;
197 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
199 if (g->block_type == 2) {
200 if (g->switch_point) {
201 /* if switched mode, we handle the 36 first samples as
202 long blocks. For 8000Hz, we handle the 48 first
203 exponents as long blocks (XXX: check this!) */
204 if (s->sample_rate_index <= 2)
206 else if (s->sample_rate_index != 8)
209 g->long_end = 4; /* 8000 Hz */
211 g->short_start = 2 + (s->sample_rate_index != 8);
222 /* layer 1 unscaling */
223 /* n = number of bits of the mantissa minus 1 */
224 static inline int l1_unscale(int n, int mant, int scale_factor)
229 shift = scale_factor_modshift[scale_factor];
232 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
234 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
235 return (int)((val + (1LL << (shift - 1))) >> shift);
238 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
242 shift = scale_factor_modshift[scale_factor];
246 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
247 /* NOTE: at this point, 0 <= shift <= 21 */
249 val = (val + (1 << (shift - 1))) >> shift;
253 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
254 static inline int l3_unscale(int value, int exponent)
259 e = table_4_3_exp [4 * value + (exponent & 3)];
260 m = table_4_3_value[4 * value + (exponent & 3)];
265 m = (m + (1 << (e - 1))) >> e;
270 static av_cold void decode_init_static(void)
275 /* scale factors table for layer 1/2 */
276 for (i = 0; i < 64; i++) {
278 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
281 scale_factor_modshift[i] = mod | (shift << 2);
284 /* scale factor multiply for layer 1 */
285 for (i = 0; i < 15; i++) {
288 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
289 scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
290 scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
291 scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
292 av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
293 scale_factor_mult[i][0],
294 scale_factor_mult[i][1],
295 scale_factor_mult[i][2]);
298 RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
300 /* huffman decode tables */
302 for (i = 1; i < 16; i++) {
303 const HuffTable *h = &mpa_huff_tables[i];
305 uint8_t tmp_bits [512];
306 uint16_t tmp_codes[512];
308 memset(tmp_bits , 0, sizeof(tmp_bits ));
309 memset(tmp_codes, 0, sizeof(tmp_codes));
314 for (x = 0; x < xsize; x++) {
315 for (y = 0; y < xsize; y++) {
316 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
317 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
322 huff_vlc[i].table = huff_vlc_tables+offset;
323 huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
324 init_vlc(&huff_vlc[i], 7, 512,
325 tmp_bits, 1, 1, tmp_codes, 2, 2,
326 INIT_VLC_USE_NEW_STATIC);
327 offset += huff_vlc_tables_sizes[i];
329 assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
332 for (i = 0; i < 2; i++) {
333 huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
334 huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
335 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
336 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
337 INIT_VLC_USE_NEW_STATIC);
338 offset += huff_quad_vlc_tables_sizes[i];
340 assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
342 for (i = 0; i < 9; i++) {
344 for (j = 0; j < 22; j++) {
345 band_index_long[i][j] = k;
346 k += band_size_long[i][j];
348 band_index_long[i][22] = k;
351 /* compute n ^ (4/3) and store it in mantissa/exp format */
353 mpegaudio_tableinit();
355 for (i = 0; i < 4; i++) {
356 if (ff_mpa_quant_bits[i] < 0) {
357 for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
358 int val1, val2, val3, steps;
360 steps = ff_mpa_quant_steps[i];
365 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
371 for (i = 0; i < 7; i++) {
375 f = tan((double)i * M_PI / 12.0);
376 v = FIXR(f / (1.0 + f));
381 is_table[1][6 - i] = v;
384 for (i = 7; i < 16; i++)
385 is_table[0][i] = is_table[1][i] = 0.0;
387 for (i = 0; i < 16; i++) {
391 for (j = 0; j < 2; j++) {
392 e = -(j + 1) * ((i + 1) >> 1);
393 f = pow(2.0, e / 4.0);
395 is_table_lsf[j][k ^ 1][i] = FIXR(f);
396 is_table_lsf[j][k ][i] = FIXR(1.0);
397 av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
398 i, j, (float) is_table_lsf[j][0][i],
399 (float) is_table_lsf[j][1][i]);
403 for (i = 0; i < 8; i++) {
406 cs = 1.0 / sqrt(1.0 + ci * ci);
409 csa_table[i][0] = FIXHR(cs/4);
410 csa_table[i][1] = FIXHR(ca/4);
411 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
412 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
414 csa_table[i][0] = cs;
415 csa_table[i][1] = ca;
416 csa_table[i][2] = ca + cs;
417 csa_table[i][3] = ca - cs;
421 /* compute mdct windows */
422 for (i = 0; i < 36; i++) {
423 for (j = 0; j < 4; j++) {
426 if (j == 2 && i % 3 != 1)
429 d = sin(M_PI * (i + 0.5) / 36.0);
432 else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);
433 else if (i >= 18) d = 1;
436 else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0);
437 else if (i < 18) d = 1;
439 //merge last stage of imdct into the window coefficients
440 d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);
443 mdct_win[j][i/3] = FIXHR((d / (1<<5)));
445 mdct_win[j][i ] = FIXHR((d / (1<<5)));
449 /* NOTE: we do frequency inversion adter the MDCT by changing
450 the sign of the right window coefs */
451 for (j = 0; j < 4; j++) {
452 for (i = 0; i < 36; i += 2) {
453 mdct_win[j + 4][i ] = mdct_win[j][i ];
454 mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
459 static av_cold int decode_init(AVCodecContext * avctx)
461 static int initialized_tables = 0;
462 MPADecodeContext *s = avctx->priv_data;
464 if (!initialized_tables) {
465 decode_init_static();
466 initialized_tables = 1;
471 ff_mpadsp_init(&s->mpadsp);
473 avctx->sample_fmt= OUT_FMT;
474 s->err_recognition = avctx->err_recognition;
476 if (avctx->codec_id == CODEC_ID_MP3ADU)
479 avcodec_get_frame_defaults(&s->frame);
480 avctx->coded_frame = &s->frame;
485 #define C3 FIXHR(0.86602540378443864676/2)
487 /* 0.5 / cos(pi*(2*i+1)/36) */
488 static const INTFLOAT icos36[9] = {
489 FIXR(0.50190991877167369479),
490 FIXR(0.51763809020504152469), //0
491 FIXR(0.55168895948124587824),
492 FIXR(0.61038729438072803416),
493 FIXR(0.70710678118654752439), //1
494 FIXR(0.87172339781054900991),
495 FIXR(1.18310079157624925896),
496 FIXR(1.93185165257813657349), //2
497 FIXR(5.73685662283492756461),
500 /* 0.5 / cos(pi*(2*i+1)/36) */
501 static const INTFLOAT icos36h[9] = {
502 FIXHR(0.50190991877167369479/2),
503 FIXHR(0.51763809020504152469/2), //0
504 FIXHR(0.55168895948124587824/2),
505 FIXHR(0.61038729438072803416/2),
506 FIXHR(0.70710678118654752439/2), //1
507 FIXHR(0.87172339781054900991/2),
508 FIXHR(1.18310079157624925896/4),
509 FIXHR(1.93185165257813657349/4), //2
510 // FIXHR(5.73685662283492756461),
513 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
515 static void imdct12(INTFLOAT *out, INTFLOAT *in)
517 INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
520 in1 = in[1*3] + in[0*3];
521 in2 = in[2*3] + in[1*3];
522 in3 = in[3*3] + in[2*3];
523 in4 = in[4*3] + in[3*3];
524 in5 = in[5*3] + in[4*3];
528 in2 = MULH3(in2, C3, 2);
529 in3 = MULH3(in3, C3, 4);
532 t2 = MULH3(in1 - in5, icos36h[4], 2);
542 in1 = MULH3(in5 + in3, icos36h[1], 1);
549 in5 = MULH3(in5 - in3, icos36h[7], 2);
557 #define C1 FIXHR(0.98480775301220805936/2)
558 #define C2 FIXHR(0.93969262078590838405/2)
559 #define C3 FIXHR(0.86602540378443864676/2)
560 #define C4 FIXHR(0.76604444311897803520/2)
561 #define C5 FIXHR(0.64278760968653932632/2)
562 #define C6 FIXHR(0.5/2)
563 #define C7 FIXHR(0.34202014332566873304/2)
564 #define C8 FIXHR(0.17364817766693034885/2)
567 /* using Lee like decomposition followed by hand coded 9 points DCT */
568 static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win)
571 INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3;
572 INTFLOAT tmp[18], *tmp1, *in1;
574 for (i = 17; i >= 1; i--)
576 for (i = 17; i >= 3; i -= 2)
579 for (j = 0; j < 2; j++) {
583 t2 = in1[2*4] + in1[2*8] - in1[2*2];
585 t3 = in1[2*0] + SHR(in1[2*6],1);
586 t1 = in1[2*0] - in1[2*6];
587 tmp1[ 6] = t1 - SHR(t2,1);
590 t0 = MULH3(in1[2*2] + in1[2*4] , C2, 2);
591 t1 = MULH3(in1[2*4] - in1[2*8] , -2*C8, 1);
592 t2 = MULH3(in1[2*2] + in1[2*8] , -C4, 2);
594 tmp1[10] = t3 - t0 - t2;
595 tmp1[ 2] = t3 + t0 + t1;
596 tmp1[14] = t3 + t2 - t1;
598 tmp1[ 4] = MULH3(in1[2*5] + in1[2*7] - in1[2*1], -C3, 2);
599 t2 = MULH3(in1[2*1] + in1[2*5], C1, 2);
600 t3 = MULH3(in1[2*5] - in1[2*7], -2*C7, 1);
601 t0 = MULH3(in1[2*3], C3, 2);
603 t1 = MULH3(in1[2*1] + in1[2*7], -C5, 2);
605 tmp1[ 0] = t2 + t3 + t0;
606 tmp1[12] = t2 + t1 - t0;
607 tmp1[ 8] = t3 - t1 - t0;
611 for (j = 0; j < 4; j++) {
619 s1 = MULH3(t3 + t2, icos36h[ j], 2);
620 s3 = MULLx(t3 - t2, icos36 [8 - j], FRAC_BITS);
624 out[(9 + j) * SBLIMIT] = MULH3(t1, win[ 9 + j], 1) + buf[9 + j];
625 out[(8 - j) * SBLIMIT] = MULH3(t1, win[ 8 - j], 1) + buf[8 - j];
626 buf[ 9 + j ] = MULH3(t0, win[18 + 9 + j], 1);
627 buf[ 8 - j ] = MULH3(t0, win[18 + 8 - j], 1);
631 out[(9 + 8 - j) * SBLIMIT] = MULH3(t1, win[ 9 + 8 - j], 1) + buf[9 + 8 - j];
632 out[ j * SBLIMIT] = MULH3(t1, win[ j], 1) + buf[ j];
633 buf[ 9 + 8 - j ] = MULH3(t0, win[18 + 9 + 8 - j], 1);
634 buf[ j ] = MULH3(t0, win[18 + j], 1);
639 s1 = MULH3(tmp[17], icos36h[4], 2);
642 out[(9 + 4) * SBLIMIT] = MULH3(t1, win[ 9 + 4], 1) + buf[9 + 4];
643 out[(8 - 4) * SBLIMIT] = MULH3(t1, win[ 8 - 4], 1) + buf[8 - 4];
644 buf[ 9 + 4 ] = MULH3(t0, win[18 + 9 + 4], 1);
645 buf[ 8 - 4 ] = MULH3(t0, win[18 + 8 - 4], 1);
648 /* return the number of decoded frames */
649 static int mp_decode_layer1(MPADecodeContext *s)
651 int bound, i, v, n, ch, j, mant;
652 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
653 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
655 if (s->mode == MPA_JSTEREO)
656 bound = (s->mode_ext + 1) * 4;
660 /* allocation bits */
661 for (i = 0; i < bound; i++) {
662 for (ch = 0; ch < s->nb_channels; ch++) {
663 allocation[ch][i] = get_bits(&s->gb, 4);
666 for (i = bound; i < SBLIMIT; i++)
667 allocation[0][i] = get_bits(&s->gb, 4);
670 for (i = 0; i < bound; i++) {
671 for (ch = 0; ch < s->nb_channels; ch++) {
672 if (allocation[ch][i])
673 scale_factors[ch][i] = get_bits(&s->gb, 6);
676 for (i = bound; i < SBLIMIT; i++) {
677 if (allocation[0][i]) {
678 scale_factors[0][i] = get_bits(&s->gb, 6);
679 scale_factors[1][i] = get_bits(&s->gb, 6);
683 /* compute samples */
684 for (j = 0; j < 12; j++) {
685 for (i = 0; i < bound; i++) {
686 for (ch = 0; ch < s->nb_channels; ch++) {
687 n = allocation[ch][i];
689 mant = get_bits(&s->gb, n + 1);
690 v = l1_unscale(n, mant, scale_factors[ch][i]);
694 s->sb_samples[ch][j][i] = v;
697 for (i = bound; i < SBLIMIT; i++) {
698 n = allocation[0][i];
700 mant = get_bits(&s->gb, n + 1);
701 v = l1_unscale(n, mant, scale_factors[0][i]);
702 s->sb_samples[0][j][i] = v;
703 v = l1_unscale(n, mant, scale_factors[1][i]);
704 s->sb_samples[1][j][i] = v;
706 s->sb_samples[0][j][i] = 0;
707 s->sb_samples[1][j][i] = 0;
714 static int mp_decode_layer2(MPADecodeContext *s)
716 int sblimit; /* number of used subbands */
717 const unsigned char *alloc_table;
718 int table, bit_alloc_bits, i, j, ch, bound, v;
719 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
720 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
721 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
722 int scale, qindex, bits, steps, k, l, m, b;
724 /* select decoding table */
725 table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
726 s->sample_rate, s->lsf);
727 sblimit = ff_mpa_sblimit_table[table];
728 alloc_table = ff_mpa_alloc_tables[table];
730 if (s->mode == MPA_JSTEREO)
731 bound = (s->mode_ext + 1) * 4;
735 av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
741 /* parse bit allocation */
743 for (i = 0; i < bound; i++) {
744 bit_alloc_bits = alloc_table[j];
745 for (ch = 0; ch < s->nb_channels; ch++)
746 bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
747 j += 1 << bit_alloc_bits;
749 for (i = bound; i < sblimit; i++) {
750 bit_alloc_bits = alloc_table[j];
751 v = get_bits(&s->gb, bit_alloc_bits);
754 j += 1 << bit_alloc_bits;
758 for (i = 0; i < sblimit; i++) {
759 for (ch = 0; ch < s->nb_channels; ch++) {
760 if (bit_alloc[ch][i])
761 scale_code[ch][i] = get_bits(&s->gb, 2);
766 for (i = 0; i < sblimit; i++) {
767 for (ch = 0; ch < s->nb_channels; ch++) {
768 if (bit_alloc[ch][i]) {
769 sf = scale_factors[ch][i];
770 switch (scale_code[ch][i]) {
773 sf[0] = get_bits(&s->gb, 6);
774 sf[1] = get_bits(&s->gb, 6);
775 sf[2] = get_bits(&s->gb, 6);
778 sf[0] = get_bits(&s->gb, 6);
783 sf[0] = get_bits(&s->gb, 6);
784 sf[2] = get_bits(&s->gb, 6);
788 sf[0] = get_bits(&s->gb, 6);
789 sf[2] = get_bits(&s->gb, 6);
798 for (k = 0; k < 3; k++) {
799 for (l = 0; l < 12; l += 3) {
801 for (i = 0; i < bound; i++) {
802 bit_alloc_bits = alloc_table[j];
803 for (ch = 0; ch < s->nb_channels; ch++) {
804 b = bit_alloc[ch][i];
806 scale = scale_factors[ch][i][k];
807 qindex = alloc_table[j+b];
808 bits = ff_mpa_quant_bits[qindex];
811 /* 3 values at the same time */
812 v = get_bits(&s->gb, -bits);
813 v2 = division_tabs[qindex][v];
814 steps = ff_mpa_quant_steps[qindex];
816 s->sb_samples[ch][k * 12 + l + 0][i] =
817 l2_unscale_group(steps, v2 & 15, scale);
818 s->sb_samples[ch][k * 12 + l + 1][i] =
819 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
820 s->sb_samples[ch][k * 12 + l + 2][i] =
821 l2_unscale_group(steps, v2 >> 8 , scale);
823 for (m = 0; m < 3; m++) {
824 v = get_bits(&s->gb, bits);
825 v = l1_unscale(bits - 1, v, scale);
826 s->sb_samples[ch][k * 12 + l + m][i] = v;
830 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
831 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
832 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
835 /* next subband in alloc table */
836 j += 1 << bit_alloc_bits;
838 /* XXX: find a way to avoid this duplication of code */
839 for (i = bound; i < sblimit; i++) {
840 bit_alloc_bits = alloc_table[j];
843 int mant, scale0, scale1;
844 scale0 = scale_factors[0][i][k];
845 scale1 = scale_factors[1][i][k];
846 qindex = alloc_table[j+b];
847 bits = ff_mpa_quant_bits[qindex];
849 /* 3 values at the same time */
850 v = get_bits(&s->gb, -bits);
851 steps = ff_mpa_quant_steps[qindex];
854 s->sb_samples[0][k * 12 + l + 0][i] =
855 l2_unscale_group(steps, mant, scale0);
856 s->sb_samples[1][k * 12 + l + 0][i] =
857 l2_unscale_group(steps, mant, scale1);
860 s->sb_samples[0][k * 12 + l + 1][i] =
861 l2_unscale_group(steps, mant, scale0);
862 s->sb_samples[1][k * 12 + l + 1][i] =
863 l2_unscale_group(steps, mant, scale1);
864 s->sb_samples[0][k * 12 + l + 2][i] =
865 l2_unscale_group(steps, v, scale0);
866 s->sb_samples[1][k * 12 + l + 2][i] =
867 l2_unscale_group(steps, v, scale1);
869 for (m = 0; m < 3; m++) {
870 mant = get_bits(&s->gb, bits);
871 s->sb_samples[0][k * 12 + l + m][i] =
872 l1_unscale(bits - 1, mant, scale0);
873 s->sb_samples[1][k * 12 + l + m][i] =
874 l1_unscale(bits - 1, mant, scale1);
878 s->sb_samples[0][k * 12 + l + 0][i] = 0;
879 s->sb_samples[0][k * 12 + l + 1][i] = 0;
880 s->sb_samples[0][k * 12 + l + 2][i] = 0;
881 s->sb_samples[1][k * 12 + l + 0][i] = 0;
882 s->sb_samples[1][k * 12 + l + 1][i] = 0;
883 s->sb_samples[1][k * 12 + l + 2][i] = 0;
885 /* next subband in alloc table */
886 j += 1 << bit_alloc_bits;
888 /* fill remaining samples to zero */
889 for (i = sblimit; i < SBLIMIT; i++) {
890 for (ch = 0; ch < s->nb_channels; ch++) {
891 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
892 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
893 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
901 #define SPLIT(dst,sf,n) \
903 int m = (sf * 171) >> 9; \
906 } else if (n == 4) { \
909 } else if (n == 5) { \
910 int m = (sf * 205) >> 10; \
913 } else if (n == 6) { \
914 int m = (sf * 171) >> 10; \
921 static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
924 SPLIT(slen[3], sf, n3)
925 SPLIT(slen[2], sf, n2)
926 SPLIT(slen[1], sf, n1)
930 static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
933 const uint8_t *bstab, *pretab;
934 int len, i, j, k, l, v0, shift, gain, gains[3];
938 gain = g->global_gain - 210;
939 shift = g->scalefac_scale + 1;
941 bstab = band_size_long[s->sample_rate_index];
942 pretab = mpa_pretab[g->preflag];
943 for (i = 0; i < g->long_end; i++) {
944 v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
946 for (j = len; j > 0; j--)
950 if (g->short_start < 13) {
951 bstab = band_size_short[s->sample_rate_index];
952 gains[0] = gain - (g->subblock_gain[0] << 3);
953 gains[1] = gain - (g->subblock_gain[1] << 3);
954 gains[2] = gain - (g->subblock_gain[2] << 3);
956 for (i = g->short_start; i < 13; i++) {
958 for (l = 0; l < 3; l++) {
959 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
960 for (j = len; j > 0; j--)
967 /* handle n = 0 too */
968 static inline int get_bitsz(GetBitContext *s, int n)
970 return n ? get_bits(s, n) : 0;
974 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
977 if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
979 s->in_gb.buffer = NULL;
980 assert((get_bits_count(&s->gb) & 7) == 0);
981 skip_bits_long(&s->gb, *pos - *end_pos);
983 *end_pos = *end_pos2 + get_bits_count(&s->gb) - *pos;
984 *pos = get_bits_count(&s->gb);
988 /* Following is a optimized code for
990 if(get_bits1(&s->gb))
995 #define READ_FLIP_SIGN(dst,src) \
996 v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31); \
999 #define READ_FLIP_SIGN(dst,src) \
1000 v = -get_bits1(&s->gb); \
1001 *(dst) = (*(src) ^ v) - v;
1004 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
1005 int16_t *exponents, int end_pos2)
1009 int last_pos, bits_left;
1011 int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
1013 /* low frequencies (called big values) */
1015 for (i = 0; i < 3; i++) {
1016 int j, k, l, linbits;
1017 j = g->region_size[i];
1020 /* select vlc table */
1021 k = g->table_select[i];
1022 l = mpa_huff_data[k][0];
1023 linbits = mpa_huff_data[k][1];
1027 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
1032 /* read huffcode and compute each couple */
1033 for (; j > 0; j--) {
1036 int pos = get_bits_count(&s->gb);
1038 if (pos >= end_pos){
1039 // av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
1040 switch_buffer(s, &pos, &end_pos, &end_pos2);
1041 // av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
1045 y = get_vlc2(&s->gb, vlc->table, 7, 3);
1048 g->sb_hybrid[s_index ] =
1049 g->sb_hybrid[s_index+1] = 0;
1054 exponent= exponents[s_index];
1056 av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
1057 i, g->region_size[i] - j, x, y, exponent);
1062 READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
1064 x += get_bitsz(&s->gb, linbits);
1065 v = l3_unscale(x, exponent);
1066 if (get_bits1(&s->gb))
1068 g->sb_hybrid[s_index] = v;
1071 READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
1073 y += get_bitsz(&s->gb, linbits);
1074 v = l3_unscale(y, exponent);
1075 if (get_bits1(&s->gb))
1077 g->sb_hybrid[s_index+1] = v;
1084 READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
1086 x += get_bitsz(&s->gb, linbits);
1087 v = l3_unscale(x, exponent);
1088 if (get_bits1(&s->gb))
1090 g->sb_hybrid[s_index+!!y] = v;
1092 g->sb_hybrid[s_index + !y] = 0;
1098 /* high frequencies */
1099 vlc = &huff_quad_vlc[g->count1table_select];
1101 while (s_index <= 572) {
1103 pos = get_bits_count(&s->gb);
1104 if (pos >= end_pos) {
1105 if (pos > end_pos2 && last_pos) {
1106 /* some encoders generate an incorrect size for this
1107 part. We must go back into the data */
1109 skip_bits_long(&s->gb, last_pos - pos);
1110 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
1111 if(s->err_recognition & AV_EF_BITSTREAM)
1115 // av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
1116 switch_buffer(s, &pos, &end_pos, &end_pos2);
1117 // av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
1123 code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
1124 av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
1125 g->sb_hybrid[s_index+0] =
1126 g->sb_hybrid[s_index+1] =
1127 g->sb_hybrid[s_index+2] =
1128 g->sb_hybrid[s_index+3] = 0;
1130 static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
1132 int pos = s_index + idxtab[code];
1133 code ^= 8 >> idxtab[code];
1134 READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
1138 /* skip extension bits */
1139 bits_left = end_pos2 - get_bits_count(&s->gb);
1140 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
1141 if (bits_left < 0 && (s->err_recognition & AV_EF_BITSTREAM)) {
1142 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
1144 } else if (bits_left > 0 && (s->err_recognition & AV_EF_BUFFER)) {
1145 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
1148 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
1149 skip_bits_long(&s->gb, bits_left);
1151 i = get_bits_count(&s->gb);
1152 switch_buffer(s, &i, &end_pos, &end_pos2);
1157 /* Reorder short blocks from bitstream order to interleaved order. It
1158 would be faster to do it in parsing, but the code would be far more
1160 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
1163 INTFLOAT *ptr, *dst, *ptr1;
1166 if (g->block_type != 2)
1169 if (g->switch_point) {
1170 if (s->sample_rate_index != 8)
1171 ptr = g->sb_hybrid + 36;
1173 ptr = g->sb_hybrid + 48;
1178 for (i = g->short_start; i < 13; i++) {
1179 len = band_size_short[s->sample_rate_index][i];
1182 for (j = len; j > 0; j--) {
1183 *dst++ = ptr[0*len];
1184 *dst++ = ptr[1*len];
1185 *dst++ = ptr[2*len];
1189 memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1193 #define ISQRT2 FIXR(0.70710678118654752440)
1195 static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1198 int sf_max, sf, len, non_zero_found;
1199 INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1200 int non_zero_found_short[3];
1202 /* intensity stereo */
1203 if (s->mode_ext & MODE_EXT_I_STEREO) {
1208 is_tab = is_table_lsf[g1->scalefac_compress & 1];
1212 tab0 = g0->sb_hybrid + 576;
1213 tab1 = g1->sb_hybrid + 576;
1215 non_zero_found_short[0] = 0;
1216 non_zero_found_short[1] = 0;
1217 non_zero_found_short[2] = 0;
1218 k = (13 - g1->short_start) * 3 + g1->long_end - 3;
1219 for (i = 12; i >= g1->short_start; i--) {
1220 /* for last band, use previous scale factor */
1223 len = band_size_short[s->sample_rate_index][i];
1224 for (l = 2; l >= 0; l--) {
1227 if (!non_zero_found_short[l]) {
1228 /* test if non zero band. if so, stop doing i-stereo */
1229 for (j = 0; j < len; j++) {
1231 non_zero_found_short[l] = 1;
1235 sf = g1->scale_factors[k + l];
1241 for (j = 0; j < len; j++) {
1243 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1244 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1248 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1249 /* lower part of the spectrum : do ms stereo
1251 for (j = 0; j < len; j++) {
1254 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1255 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1262 non_zero_found = non_zero_found_short[0] |
1263 non_zero_found_short[1] |
1264 non_zero_found_short[2];
1266 for (i = g1->long_end - 1;i >= 0;i--) {
1267 len = band_size_long[s->sample_rate_index][i];
1270 /* test if non zero band. if so, stop doing i-stereo */
1271 if (!non_zero_found) {
1272 for (j = 0; j < len; j++) {
1278 /* for last band, use previous scale factor */
1279 k = (i == 21) ? 20 : i;
1280 sf = g1->scale_factors[k];
1285 for (j = 0; j < len; j++) {
1287 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1288 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1292 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1293 /* lower part of the spectrum : do ms stereo
1295 for (j = 0; j < len; j++) {
1298 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1299 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1304 } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
1305 /* ms stereo ONLY */
1306 /* NOTE: the 1/sqrt(2) normalization factor is included in the
1308 tab0 = g0->sb_hybrid;
1309 tab1 = g1->sb_hybrid;
1310 for (i = 0; i < 576; i++) {
1313 tab0[i] = tmp0 + tmp1;
1314 tab1[i] = tmp0 - tmp1;
1320 #define AA(j) do { \
1321 float tmp0 = ptr[-1-j]; \
1322 float tmp1 = ptr[ j]; \
1323 ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
1324 ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
1327 #define AA(j) do { \
1328 int tmp0 = ptr[-1-j]; \
1329 int tmp1 = ptr[ j]; \
1330 int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
1331 ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2])); \
1332 ptr[ j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3])); \
1336 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1341 /* we antialias only "long" bands */
1342 if (g->block_type == 2) {
1343 if (!g->switch_point)
1345 /* XXX: check this for 8000Hz case */
1351 ptr = g->sb_hybrid + 18;
1352 for (i = n; i > 0; i--) {
1366 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
1367 INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1369 INTFLOAT *win, *win1, *out_ptr, *ptr, *buf, *ptr1;
1371 int i, j, mdct_long_end, sblimit;
1373 /* find last non zero block */
1374 ptr = g->sb_hybrid + 576;
1375 ptr1 = g->sb_hybrid + 2 * 18;
1376 while (ptr >= ptr1) {
1380 if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1383 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
1385 if (g->block_type == 2) {
1386 /* XXX: check for 8000 Hz */
1387 if (g->switch_point)
1392 mdct_long_end = sblimit;
1397 for (j = 0; j < mdct_long_end; j++) {
1398 /* apply window & overlap with previous buffer */
1399 out_ptr = sb_samples + j;
1401 if (g->switch_point && j < 2)
1404 win1 = mdct_win[g->block_type];
1405 /* select frequency inversion */
1406 win = win1 + ((4 * 36) & -(j & 1));
1407 imdct36(out_ptr, buf, ptr, win);
1408 out_ptr += 18 * SBLIMIT;
1412 for (j = mdct_long_end; j < sblimit; j++) {
1413 /* select frequency inversion */
1414 win = mdct_win[2] + ((4 * 36) & -(j & 1));
1415 out_ptr = sb_samples + j;
1417 for (i = 0; i < 6; i++) {
1421 imdct12(out2, ptr + 0);
1422 for (i = 0; i < 6; i++) {
1423 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*1];
1424 buf[i + 6*2] = MULH3(out2[i + 6], win[i + 6], 1);
1427 imdct12(out2, ptr + 1);
1428 for (i = 0; i < 6; i++) {
1429 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*2];
1430 buf[i + 6*0] = MULH3(out2[i + 6], win[i + 6], 1);
1433 imdct12(out2, ptr + 2);
1434 for (i = 0; i < 6; i++) {
1435 buf[i + 6*0] = MULH3(out2[i ], win[i ], 1) + buf[i + 6*0];
1436 buf[i + 6*1] = MULH3(out2[i + 6], win[i + 6], 1);
1443 for (j = sblimit; j < SBLIMIT; j++) {
1445 out_ptr = sb_samples + j;
1446 for (i = 0; i < 18; i++) {
1455 /* main layer3 decoding function */
1456 static int mp_decode_layer3(MPADecodeContext *s)
1458 int nb_granules, main_data_begin;
1459 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1461 int16_t exponents[576]; //FIXME try INTFLOAT
1463 /* read side info */
1465 main_data_begin = get_bits(&s->gb, 8);
1466 skip_bits(&s->gb, s->nb_channels);
1469 main_data_begin = get_bits(&s->gb, 9);
1470 if (s->nb_channels == 2)
1471 skip_bits(&s->gb, 3);
1473 skip_bits(&s->gb, 5);
1475 for (ch = 0; ch < s->nb_channels; ch++) {
1476 s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
1477 s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1481 for (gr = 0; gr < nb_granules; gr++) {
1482 for (ch = 0; ch < s->nb_channels; ch++) {
1483 av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1484 g = &s->granules[ch][gr];
1485 g->part2_3_length = get_bits(&s->gb, 12);
1486 g->big_values = get_bits(&s->gb, 9);
1487 if (g->big_values > 288) {
1488 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1489 return AVERROR_INVALIDDATA;
1492 g->global_gain = get_bits(&s->gb, 8);
1493 /* if MS stereo only is selected, we precompute the
1494 1/sqrt(2) renormalization factor */
1495 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1497 g->global_gain -= 2;
1499 g->scalefac_compress = get_bits(&s->gb, 9);
1501 g->scalefac_compress = get_bits(&s->gb, 4);
1502 blocksplit_flag = get_bits1(&s->gb);
1503 if (blocksplit_flag) {
1504 g->block_type = get_bits(&s->gb, 2);
1505 if (g->block_type == 0) {
1506 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1507 return AVERROR_INVALIDDATA;
1509 g->switch_point = get_bits1(&s->gb);
1510 for (i = 0; i < 2; i++)
1511 g->table_select[i] = get_bits(&s->gb, 5);
1512 for (i = 0; i < 3; i++)
1513 g->subblock_gain[i] = get_bits(&s->gb, 3);
1514 ff_init_short_region(s, g);
1516 int region_address1, region_address2;
1518 g->switch_point = 0;
1519 for (i = 0; i < 3; i++)
1520 g->table_select[i] = get_bits(&s->gb, 5);
1521 /* compute huffman coded region sizes */
1522 region_address1 = get_bits(&s->gb, 4);
1523 region_address2 = get_bits(&s->gb, 3);
1524 av_dlog(s->avctx, "region1=%d region2=%d\n",
1525 region_address1, region_address2);
1526 ff_init_long_region(s, g, region_address1, region_address2);
1528 ff_region_offset2size(g);
1529 ff_compute_band_indexes(s, g);
1533 g->preflag = get_bits1(&s->gb);
1534 g->scalefac_scale = get_bits1(&s->gb);
1535 g->count1table_select = get_bits1(&s->gb);
1536 av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1537 g->block_type, g->switch_point);
1542 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1543 assert((get_bits_count(&s->gb) & 7) == 0);
1544 /* now we get bits from the main_data_begin offset */
1545 av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1546 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1548 memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
1550 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1551 skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
1554 for (gr = 0; gr < nb_granules; gr++) {
1555 for (ch = 0; ch < s->nb_channels; ch++) {
1556 g = &s->granules[ch][gr];
1557 if (get_bits_count(&s->gb) < 0) {
1558 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",
1559 main_data_begin, s->last_buf_size, gr);
1560 skip_bits_long(&s->gb, g->part2_3_length);
1561 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1562 if (get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer) {
1563 skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
1565 s->in_gb.buffer = NULL;
1570 bits_pos = get_bits_count(&s->gb);
1574 int slen, slen1, slen2;
1576 /* MPEG1 scale factors */
1577 slen1 = slen_table[0][g->scalefac_compress];
1578 slen2 = slen_table[1][g->scalefac_compress];
1579 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1580 if (g->block_type == 2) {
1581 n = g->switch_point ? 17 : 18;
1584 for (i = 0; i < n; i++)
1585 g->scale_factors[j++] = get_bits(&s->gb, slen1);
1587 for (i = 0; i < n; i++)
1588 g->scale_factors[j++] = 0;
1591 for (i = 0; i < 18; i++)
1592 g->scale_factors[j++] = get_bits(&s->gb, slen2);
1593 for (i = 0; i < 3; i++)
1594 g->scale_factors[j++] = 0;
1596 for (i = 0; i < 21; i++)
1597 g->scale_factors[j++] = 0;
1600 sc = s->granules[ch][0].scale_factors;
1602 for (k = 0; k < 4; k++) {
1604 if ((g->scfsi & (0x8 >> k)) == 0) {
1605 slen = (k < 2) ? slen1 : slen2;
1607 for (i = 0; i < n; i++)
1608 g->scale_factors[j++] = get_bits(&s->gb, slen);
1610 for (i = 0; i < n; i++)
1611 g->scale_factors[j++] = 0;
1614 /* simply copy from last granule */
1615 for (i = 0; i < n; i++) {
1616 g->scale_factors[j] = sc[j];
1621 g->scale_factors[j++] = 0;
1624 int tindex, tindex2, slen[4], sl, sf;
1626 /* LSF scale factors */
1627 if (g->block_type == 2)
1628 tindex = g->switch_point ? 2 : 1;
1632 sf = g->scalefac_compress;
1633 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1634 /* intensity stereo case */
1637 lsf_sf_expand(slen, sf, 6, 6, 0);
1639 } else if (sf < 244) {
1640 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1643 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1649 lsf_sf_expand(slen, sf, 5, 4, 4);
1651 } else if (sf < 500) {
1652 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1655 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1662 for (k = 0; k < 4; k++) {
1663 n = lsf_nsf_table[tindex2][tindex][k];
1666 for (i = 0; i < n; i++)
1667 g->scale_factors[j++] = get_bits(&s->gb, sl);
1669 for (i = 0; i < n; i++)
1670 g->scale_factors[j++] = 0;
1673 /* XXX: should compute exact size */
1675 g->scale_factors[j] = 0;
1678 exponents_from_scale_factors(s, g, exponents);
1680 /* read Huffman coded residue */
1681 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1684 if (s->nb_channels == 2)
1685 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1687 for (ch = 0; ch < s->nb_channels; ch++) {
1688 g = &s->granules[ch][gr];
1690 reorder_block(s, g);
1691 compute_antialias(s, g);
1692 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1695 if (get_bits_count(&s->gb) < 0)
1696 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1697 return nb_granules * 18;
1700 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1701 const uint8_t *buf, int buf_size)
1703 int i, nb_frames, ch, ret;
1704 OUT_INT *samples_ptr;
1706 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1708 /* skip error protection field */
1709 if (s->error_protection)
1710 skip_bits(&s->gb, 16);
1714 s->avctx->frame_size = 384;
1715 nb_frames = mp_decode_layer1(s);
1718 s->avctx->frame_size = 1152;
1719 nb_frames = mp_decode_layer2(s);
1722 s->avctx->frame_size = s->lsf ? 576 : 1152;
1724 nb_frames = mp_decode_layer3(s);
1727 if (s->in_gb.buffer) {
1728 align_get_bits(&s->gb);
1729 i = get_bits_left(&s->gb)>>3;
1730 if (i >= 0 && i <= BACKSTEP_SIZE) {
1731 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1734 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1736 s->in_gb.buffer = NULL;
1739 align_get_bits(&s->gb);
1740 assert((get_bits_count(&s->gb) & 7) == 0);
1741 i = get_bits_left(&s->gb) >> 3;
1743 if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1745 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1746 i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1748 assert(i <= buf_size - HEADER_SIZE && i >= 0);
1749 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1750 s->last_buf_size += i;
1753 /* get output buffer */
1755 s->frame.nb_samples = s->avctx->frame_size;
1756 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1757 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1760 samples = (OUT_INT *)s->frame.data[0];
1763 /* apply the synthesis filter */
1764 for (ch = 0; ch < s->nb_channels; ch++) {
1765 samples_ptr = samples + ch;
1766 for (i = 0; i < nb_frames; i++) {
1767 RENAME(ff_mpa_synth_filter)(
1769 s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1770 RENAME(ff_mpa_synth_window), &s->dither_state,
1771 samples_ptr, s->nb_channels,
1772 s->sb_samples[ch][i]);
1773 samples_ptr += 32 * s->nb_channels;
1777 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1780 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1783 const uint8_t *buf = avpkt->data;
1784 int buf_size = avpkt->size;
1785 MPADecodeContext *s = avctx->priv_data;
1789 if (buf_size < HEADER_SIZE)
1790 return AVERROR_INVALIDDATA;
1792 header = AV_RB32(buf);
1793 if (ff_mpa_check_header(header) < 0) {
1794 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1795 return AVERROR_INVALIDDATA;
1798 if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1799 /* free format: prepare to compute frame size */
1801 return AVERROR_INVALIDDATA;
1803 /* update codec info */
1804 avctx->channels = s->nb_channels;
1805 avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1806 if (!avctx->bit_rate)
1807 avctx->bit_rate = s->bit_rate;
1808 avctx->sub_id = s->layer;
1810 if (s->frame_size <= 0 || s->frame_size > buf_size) {
1811 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1812 return AVERROR_INVALIDDATA;
1813 } else if (s->frame_size < buf_size) {
1814 av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
1815 buf_size= s->frame_size;
1818 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1819 if (out_size >= 0) {
1821 *(AVFrame *)data = s->frame;
1822 avctx->sample_rate = s->sample_rate;
1823 //FIXME maybe move the other codec info stuff from above here too
1825 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1826 /* Only return an error if the bad frame makes up the whole packet.
1827 If there is more data in the packet, just consume the bad frame
1828 instead of returning an error, which would discard the whole
1831 if (buf_size == avpkt->size)
1838 static void flush(AVCodecContext *avctx)
1840 MPADecodeContext *s = avctx->priv_data;
1841 memset(s->synth_buf, 0, sizeof(s->synth_buf));
1842 s->last_buf_size = 0;
1845 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1846 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1847 int *got_frame_ptr, AVPacket *avpkt)
1849 const uint8_t *buf = avpkt->data;
1850 int buf_size = avpkt->size;
1851 MPADecodeContext *s = avctx->priv_data;
1857 // Discard too short frames
1858 if (buf_size < HEADER_SIZE) {
1859 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1860 return AVERROR_INVALIDDATA;
1864 if (len > MPA_MAX_CODED_FRAME_SIZE)
1865 len = MPA_MAX_CODED_FRAME_SIZE;
1867 // Get header and restore sync word
1868 header = AV_RB32(buf) | 0xffe00000;
1870 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1871 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1872 return AVERROR_INVALIDDATA;
1875 avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1876 /* update codec info */
1877 avctx->sample_rate = s->sample_rate;
1878 avctx->channels = s->nb_channels;
1879 if (!avctx->bit_rate)
1880 avctx->bit_rate = s->bit_rate;
1881 avctx->sub_id = s->layer;
1883 s->frame_size = len;
1885 #if FF_API_PARSE_FRAME
1886 if (avctx->parse_only)
1887 out_size = buf_size;
1890 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1893 *(AVFrame *)data = s->frame;
1897 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1899 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1902 * Context for MP3On4 decoder
1904 typedef struct MP3On4DecodeContext {
1906 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
1907 int syncword; ///< syncword patch
1908 const uint8_t *coff; ///< channel offsets in output buffer
1909 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1910 OUT_INT *decoded_buf; ///< output buffer for decoded samples
1911 } MP3On4DecodeContext;
1913 #include "mpeg4audio.h"
1915 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1917 /* number of mp3 decoder instances */
1918 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1920 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1921 static const uint8_t chan_offset[8][5] = {
1926 { 2, 0, 3 }, // C FLR BS
1927 { 2, 0, 3 }, // C FLR BLRS
1928 { 2, 0, 4, 3 }, // C FLR BLRS LFE
1929 { 2, 0, 6, 4, 3 }, // C FLR BLRS BLR LFE
1932 /* mp3on4 channel layouts */
1933 static const int16_t chan_layout[8] = {
1936 AV_CH_LAYOUT_STEREO,
1937 AV_CH_LAYOUT_SURROUND,
1938 AV_CH_LAYOUT_4POINT0,
1939 AV_CH_LAYOUT_5POINT0,
1940 AV_CH_LAYOUT_5POINT1,
1941 AV_CH_LAYOUT_7POINT1
1944 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1946 MP3On4DecodeContext *s = avctx->priv_data;
1949 for (i = 0; i < s->frames; i++)
1950 av_free(s->mp3decctx[i]);
1952 av_freep(&s->decoded_buf);
1958 static int decode_init_mp3on4(AVCodecContext * avctx)
1960 MP3On4DecodeContext *s = avctx->priv_data;
1961 MPEG4AudioConfig cfg;
1964 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1965 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1966 return AVERROR_INVALIDDATA;
1969 avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1970 avctx->extradata_size * 8, 1);
1971 if (!cfg.chan_config || cfg.chan_config > 7) {
1972 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1973 return AVERROR_INVALIDDATA;
1975 s->frames = mp3Frames[cfg.chan_config];
1976 s->coff = chan_offset[cfg.chan_config];
1977 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
1978 avctx->channel_layout = chan_layout[cfg.chan_config];
1980 if (cfg.sample_rate < 16000)
1981 s->syncword = 0xffe00000;
1983 s->syncword = 0xfff00000;
1985 /* Init the first mp3 decoder in standard way, so that all tables get builded
1986 * We replace avctx->priv_data with the context of the first decoder so that
1987 * decode_init() does not have to be changed.
1988 * Other decoders will be initialized here copying data from the first context
1990 // Allocate zeroed memory for the first decoder context
1991 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1992 if (!s->mp3decctx[0])
1994 // Put decoder context in place to make init_decode() happy
1995 avctx->priv_data = s->mp3decctx[0];
1997 s->frame = avctx->coded_frame;
1998 // Restore mp3on4 context pointer
1999 avctx->priv_data = s;
2000 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
2002 /* Create a separate codec/context for each frame (first is already ok).
2003 * Each frame is 1 or 2 channels - up to 5 frames allowed
2005 for (i = 1; i < s->frames; i++) {
2006 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
2007 if (!s->mp3decctx[i])
2009 s->mp3decctx[i]->adu_mode = 1;
2010 s->mp3decctx[i]->avctx = avctx;
2011 s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
2014 /* Allocate buffer for multi-channel output if needed */
2015 if (s->frames > 1) {
2016 s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
2017 sizeof(*s->decoded_buf));
2018 if (!s->decoded_buf)
2024 decode_close_mp3on4(avctx);
2025 return AVERROR(ENOMEM);
2029 static void flush_mp3on4(AVCodecContext *avctx)
2032 MP3On4DecodeContext *s = avctx->priv_data;
2034 for (i = 0; i < s->frames; i++) {
2035 MPADecodeContext *m = s->mp3decctx[i];
2036 memset(m->synth_buf, 0, sizeof(m->synth_buf));
2037 m->last_buf_size = 0;
2042 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
2043 int *got_frame_ptr, AVPacket *avpkt)
2045 const uint8_t *buf = avpkt->data;
2046 int buf_size = avpkt->size;
2047 MP3On4DecodeContext *s = avctx->priv_data;
2048 MPADecodeContext *m;
2049 int fsize, len = buf_size, out_size = 0;
2051 OUT_INT *out_samples;
2052 OUT_INT *outptr, *bp;
2053 int fr, j, n, ch, ret;
2055 /* get output buffer */
2056 s->frame->nb_samples = MPA_FRAME_SIZE;
2057 if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
2058 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2061 out_samples = (OUT_INT *)s->frame->data[0];
2063 // Discard too short frames
2064 if (buf_size < HEADER_SIZE)
2065 return AVERROR_INVALIDDATA;
2067 // If only one decoder interleave is not needed
2068 outptr = s->frames == 1 ? out_samples : s->decoded_buf;
2070 avctx->bit_rate = 0;
2073 for (fr = 0; fr < s->frames; fr++) {
2074 fsize = AV_RB16(buf) >> 4;
2075 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
2076 m = s->mp3decctx[fr];
2079 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
2081 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
2084 avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
2086 if (ch + m->nb_channels > avctx->channels) {
2087 av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
2089 return AVERROR_INVALIDDATA;
2091 ch += m->nb_channels;
2093 out_size += mp_decode_frame(m, outptr, buf, fsize);
2097 if (s->frames > 1) {
2098 n = m->avctx->frame_size*m->nb_channels;
2099 /* interleave output data */
2100 bp = out_samples + s->coff[fr];
2101 if (m->nb_channels == 1) {
2102 for (j = 0; j < n; j++) {
2103 *bp = s->decoded_buf[j];
2104 bp += avctx->channels;
2107 for (j = 0; j < n; j++) {
2108 bp[0] = s->decoded_buf[j++];
2109 bp[1] = s->decoded_buf[j];
2110 bp += avctx->channels;
2114 avctx->bit_rate += m->bit_rate;
2117 /* update codec info */
2118 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
2120 s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
2122 *(AVFrame *)data = *s->frame;
2126 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
2129 #if CONFIG_MP1_DECODER
2130 AVCodec ff_mp1_decoder = {
2132 .type = AVMEDIA_TYPE_AUDIO,
2134 .priv_data_size = sizeof(MPADecodeContext),
2135 .init = decode_init,
2136 .decode = decode_frame,
2137 #if FF_API_PARSE_FRAME
2138 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2140 .capabilities = CODEC_CAP_DR1,
2143 .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
2146 #if CONFIG_MP2_DECODER
2147 AVCodec ff_mp2_decoder = {
2149 .type = AVMEDIA_TYPE_AUDIO,
2151 .priv_data_size = sizeof(MPADecodeContext),
2152 .init = decode_init,
2153 .decode = decode_frame,
2154 #if FF_API_PARSE_FRAME
2155 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2157 .capabilities = CODEC_CAP_DR1,
2160 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2163 #if CONFIG_MP3_DECODER
2164 AVCodec ff_mp3_decoder = {
2166 .type = AVMEDIA_TYPE_AUDIO,
2168 .priv_data_size = sizeof(MPADecodeContext),
2169 .init = decode_init,
2170 .decode = decode_frame,
2171 #if FF_API_PARSE_FRAME
2172 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2174 .capabilities = CODEC_CAP_DR1,
2177 .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2180 #if CONFIG_MP3ADU_DECODER
2181 AVCodec ff_mp3adu_decoder = {
2183 .type = AVMEDIA_TYPE_AUDIO,
2184 .id = CODEC_ID_MP3ADU,
2185 .priv_data_size = sizeof(MPADecodeContext),
2186 .init = decode_init,
2187 .decode = decode_frame_adu,
2188 #if FF_API_PARSE_FRAME
2189 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2191 .capabilities = CODEC_CAP_DR1,
2194 .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2197 #if CONFIG_MP3ON4_DECODER
2198 AVCodec ff_mp3on4_decoder = {
2200 .type = AVMEDIA_TYPE_AUDIO,
2201 .id = CODEC_ID_MP3ON4,
2202 .priv_data_size = sizeof(MP3On4DecodeContext),
2203 .init = decode_init_mp3on4,
2204 .close = decode_close_mp3on4,
2205 .decode = decode_frame_mp3on4,
2206 .capabilities = CODEC_CAP_DR1,
2207 .flush = flush_mp3on4,
2208 .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),