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 #if CONFIG_SAFE_BITSTREAM_READER
1552 s->gb.size_in_bits_plus8 += EXTRABYTES * 8;
1554 skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
1557 for (gr = 0; gr < nb_granules; gr++) {
1558 for (ch = 0; ch < s->nb_channels; ch++) {
1559 g = &s->granules[ch][gr];
1560 if (get_bits_count(&s->gb) < 0) {
1561 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",
1562 main_data_begin, s->last_buf_size, gr);
1563 skip_bits_long(&s->gb, g->part2_3_length);
1564 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1565 if (get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer) {
1566 skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
1568 s->in_gb.buffer = NULL;
1573 bits_pos = get_bits_count(&s->gb);
1577 int slen, slen1, slen2;
1579 /* MPEG1 scale factors */
1580 slen1 = slen_table[0][g->scalefac_compress];
1581 slen2 = slen_table[1][g->scalefac_compress];
1582 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1583 if (g->block_type == 2) {
1584 n = g->switch_point ? 17 : 18;
1587 for (i = 0; i < n; i++)
1588 g->scale_factors[j++] = get_bits(&s->gb, slen1);
1590 for (i = 0; i < n; i++)
1591 g->scale_factors[j++] = 0;
1594 for (i = 0; i < 18; i++)
1595 g->scale_factors[j++] = get_bits(&s->gb, slen2);
1596 for (i = 0; i < 3; i++)
1597 g->scale_factors[j++] = 0;
1599 for (i = 0; i < 21; i++)
1600 g->scale_factors[j++] = 0;
1603 sc = s->granules[ch][0].scale_factors;
1605 for (k = 0; k < 4; k++) {
1607 if ((g->scfsi & (0x8 >> k)) == 0) {
1608 slen = (k < 2) ? slen1 : slen2;
1610 for (i = 0; i < n; i++)
1611 g->scale_factors[j++] = get_bits(&s->gb, slen);
1613 for (i = 0; i < n; i++)
1614 g->scale_factors[j++] = 0;
1617 /* simply copy from last granule */
1618 for (i = 0; i < n; i++) {
1619 g->scale_factors[j] = sc[j];
1624 g->scale_factors[j++] = 0;
1627 int tindex, tindex2, slen[4], sl, sf;
1629 /* LSF scale factors */
1630 if (g->block_type == 2)
1631 tindex = g->switch_point ? 2 : 1;
1635 sf = g->scalefac_compress;
1636 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1637 /* intensity stereo case */
1640 lsf_sf_expand(slen, sf, 6, 6, 0);
1642 } else if (sf < 244) {
1643 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1646 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1652 lsf_sf_expand(slen, sf, 5, 4, 4);
1654 } else if (sf < 500) {
1655 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1658 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1665 for (k = 0; k < 4; k++) {
1666 n = lsf_nsf_table[tindex2][tindex][k];
1669 for (i = 0; i < n; i++)
1670 g->scale_factors[j++] = get_bits(&s->gb, sl);
1672 for (i = 0; i < n; i++)
1673 g->scale_factors[j++] = 0;
1676 /* XXX: should compute exact size */
1678 g->scale_factors[j] = 0;
1681 exponents_from_scale_factors(s, g, exponents);
1683 /* read Huffman coded residue */
1684 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1687 if (s->nb_channels == 2)
1688 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1690 for (ch = 0; ch < s->nb_channels; ch++) {
1691 g = &s->granules[ch][gr];
1693 reorder_block(s, g);
1694 compute_antialias(s, g);
1695 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1698 if (get_bits_count(&s->gb) < 0)
1699 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1700 return nb_granules * 18;
1703 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1704 const uint8_t *buf, int buf_size)
1706 int i, nb_frames, ch, ret;
1707 OUT_INT *samples_ptr;
1709 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1711 /* skip error protection field */
1712 if (s->error_protection)
1713 skip_bits(&s->gb, 16);
1717 s->avctx->frame_size = 384;
1718 nb_frames = mp_decode_layer1(s);
1721 s->avctx->frame_size = 1152;
1722 nb_frames = mp_decode_layer2(s);
1725 s->avctx->frame_size = s->lsf ? 576 : 1152;
1727 nb_frames = mp_decode_layer3(s);
1730 if (s->in_gb.buffer) {
1731 align_get_bits(&s->gb);
1732 i = get_bits_left(&s->gb)>>3;
1733 if (i >= 0 && i <= BACKSTEP_SIZE) {
1734 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1737 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1739 s->in_gb.buffer = NULL;
1742 align_get_bits(&s->gb);
1743 assert((get_bits_count(&s->gb) & 7) == 0);
1744 i = get_bits_left(&s->gb) >> 3;
1746 if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1748 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1749 i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1751 assert(i <= buf_size - HEADER_SIZE && i >= 0);
1752 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1753 s->last_buf_size += i;
1756 /* get output buffer */
1758 s->frame.nb_samples = s->avctx->frame_size;
1759 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1760 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1763 samples = (OUT_INT *)s->frame.data[0];
1766 /* apply the synthesis filter */
1767 for (ch = 0; ch < s->nb_channels; ch++) {
1768 samples_ptr = samples + ch;
1769 for (i = 0; i < nb_frames; i++) {
1770 RENAME(ff_mpa_synth_filter)(
1772 s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1773 RENAME(ff_mpa_synth_window), &s->dither_state,
1774 samples_ptr, s->nb_channels,
1775 s->sb_samples[ch][i]);
1776 samples_ptr += 32 * s->nb_channels;
1780 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1783 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1786 const uint8_t *buf = avpkt->data;
1787 int buf_size = avpkt->size;
1788 MPADecodeContext *s = avctx->priv_data;
1792 if (buf_size < HEADER_SIZE)
1793 return AVERROR_INVALIDDATA;
1795 header = AV_RB32(buf);
1796 if (ff_mpa_check_header(header) < 0) {
1797 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1798 return AVERROR_INVALIDDATA;
1801 if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1802 /* free format: prepare to compute frame size */
1804 return AVERROR_INVALIDDATA;
1806 /* update codec info */
1807 avctx->channels = s->nb_channels;
1808 avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1809 if (!avctx->bit_rate)
1810 avctx->bit_rate = s->bit_rate;
1811 avctx->sub_id = s->layer;
1813 if (s->frame_size <= 0 || s->frame_size > buf_size) {
1814 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1815 return AVERROR_INVALIDDATA;
1816 } else if (s->frame_size < buf_size) {
1817 av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
1818 buf_size= s->frame_size;
1821 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1822 if (out_size >= 0) {
1824 *(AVFrame *)data = s->frame;
1825 avctx->sample_rate = s->sample_rate;
1826 //FIXME maybe move the other codec info stuff from above here too
1828 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1829 /* Only return an error if the bad frame makes up the whole packet.
1830 If there is more data in the packet, just consume the bad frame
1831 instead of returning an error, which would discard the whole
1834 if (buf_size == avpkt->size)
1841 static void flush(AVCodecContext *avctx)
1843 MPADecodeContext *s = avctx->priv_data;
1844 memset(s->synth_buf, 0, sizeof(s->synth_buf));
1845 s->last_buf_size = 0;
1848 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1849 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1850 int *got_frame_ptr, AVPacket *avpkt)
1852 const uint8_t *buf = avpkt->data;
1853 int buf_size = avpkt->size;
1854 MPADecodeContext *s = avctx->priv_data;
1860 // Discard too short frames
1861 if (buf_size < HEADER_SIZE) {
1862 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1863 return AVERROR_INVALIDDATA;
1867 if (len > MPA_MAX_CODED_FRAME_SIZE)
1868 len = MPA_MAX_CODED_FRAME_SIZE;
1870 // Get header and restore sync word
1871 header = AV_RB32(buf) | 0xffe00000;
1873 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1874 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1875 return AVERROR_INVALIDDATA;
1878 avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1879 /* update codec info */
1880 avctx->sample_rate = s->sample_rate;
1881 avctx->channels = s->nb_channels;
1882 if (!avctx->bit_rate)
1883 avctx->bit_rate = s->bit_rate;
1884 avctx->sub_id = s->layer;
1886 s->frame_size = len;
1888 #if FF_API_PARSE_FRAME
1889 if (avctx->parse_only)
1890 out_size = buf_size;
1893 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1896 *(AVFrame *)data = s->frame;
1900 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1902 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1905 * Context for MP3On4 decoder
1907 typedef struct MP3On4DecodeContext {
1909 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
1910 int syncword; ///< syncword patch
1911 const uint8_t *coff; ///< channel offsets in output buffer
1912 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1913 OUT_INT *decoded_buf; ///< output buffer for decoded samples
1914 } MP3On4DecodeContext;
1916 #include "mpeg4audio.h"
1918 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1920 /* number of mp3 decoder instances */
1921 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1923 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1924 static const uint8_t chan_offset[8][5] = {
1929 { 2, 0, 3 }, // C FLR BS
1930 { 2, 0, 3 }, // C FLR BLRS
1931 { 2, 0, 4, 3 }, // C FLR BLRS LFE
1932 { 2, 0, 6, 4, 3 }, // C FLR BLRS BLR LFE
1935 /* mp3on4 channel layouts */
1936 static const int16_t chan_layout[8] = {
1939 AV_CH_LAYOUT_STEREO,
1940 AV_CH_LAYOUT_SURROUND,
1941 AV_CH_LAYOUT_4POINT0,
1942 AV_CH_LAYOUT_5POINT0,
1943 AV_CH_LAYOUT_5POINT1,
1944 AV_CH_LAYOUT_7POINT1
1947 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1949 MP3On4DecodeContext *s = avctx->priv_data;
1952 for (i = 0; i < s->frames; i++)
1953 av_free(s->mp3decctx[i]);
1955 av_freep(&s->decoded_buf);
1961 static int decode_init_mp3on4(AVCodecContext * avctx)
1963 MP3On4DecodeContext *s = avctx->priv_data;
1964 MPEG4AudioConfig cfg;
1967 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1968 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1969 return AVERROR_INVALIDDATA;
1972 avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1973 avctx->extradata_size * 8, 1);
1974 if (!cfg.chan_config || cfg.chan_config > 7) {
1975 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1976 return AVERROR_INVALIDDATA;
1978 s->frames = mp3Frames[cfg.chan_config];
1979 s->coff = chan_offset[cfg.chan_config];
1980 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
1981 avctx->channel_layout = chan_layout[cfg.chan_config];
1983 if (cfg.sample_rate < 16000)
1984 s->syncword = 0xffe00000;
1986 s->syncword = 0xfff00000;
1988 /* Init the first mp3 decoder in standard way, so that all tables get builded
1989 * We replace avctx->priv_data with the context of the first decoder so that
1990 * decode_init() does not have to be changed.
1991 * Other decoders will be initialized here copying data from the first context
1993 // Allocate zeroed memory for the first decoder context
1994 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1995 if (!s->mp3decctx[0])
1997 // Put decoder context in place to make init_decode() happy
1998 avctx->priv_data = s->mp3decctx[0];
2000 s->frame = avctx->coded_frame;
2001 // Restore mp3on4 context pointer
2002 avctx->priv_data = s;
2003 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
2005 /* Create a separate codec/context for each frame (first is already ok).
2006 * Each frame is 1 or 2 channels - up to 5 frames allowed
2008 for (i = 1; i < s->frames; i++) {
2009 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
2010 if (!s->mp3decctx[i])
2012 s->mp3decctx[i]->adu_mode = 1;
2013 s->mp3decctx[i]->avctx = avctx;
2014 s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
2017 /* Allocate buffer for multi-channel output if needed */
2018 if (s->frames > 1) {
2019 s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
2020 sizeof(*s->decoded_buf));
2021 if (!s->decoded_buf)
2027 decode_close_mp3on4(avctx);
2028 return AVERROR(ENOMEM);
2032 static void flush_mp3on4(AVCodecContext *avctx)
2035 MP3On4DecodeContext *s = avctx->priv_data;
2037 for (i = 0; i < s->frames; i++) {
2038 MPADecodeContext *m = s->mp3decctx[i];
2039 memset(m->synth_buf, 0, sizeof(m->synth_buf));
2040 m->last_buf_size = 0;
2045 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
2046 int *got_frame_ptr, AVPacket *avpkt)
2048 const uint8_t *buf = avpkt->data;
2049 int buf_size = avpkt->size;
2050 MP3On4DecodeContext *s = avctx->priv_data;
2051 MPADecodeContext *m;
2052 int fsize, len = buf_size, out_size = 0;
2054 OUT_INT *out_samples;
2055 OUT_INT *outptr, *bp;
2056 int fr, j, n, ch, ret;
2058 /* get output buffer */
2059 s->frame->nb_samples = MPA_FRAME_SIZE;
2060 if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
2061 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2064 out_samples = (OUT_INT *)s->frame->data[0];
2066 // Discard too short frames
2067 if (buf_size < HEADER_SIZE)
2068 return AVERROR_INVALIDDATA;
2070 // If only one decoder interleave is not needed
2071 outptr = s->frames == 1 ? out_samples : s->decoded_buf;
2073 avctx->bit_rate = 0;
2076 for (fr = 0; fr < s->frames; fr++) {
2077 fsize = AV_RB16(buf) >> 4;
2078 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
2079 m = s->mp3decctx[fr];
2082 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
2084 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
2087 avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
2089 if (ch + m->nb_channels > avctx->channels) {
2090 av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
2092 return AVERROR_INVALIDDATA;
2094 ch += m->nb_channels;
2096 out_size += mp_decode_frame(m, outptr, buf, fsize);
2100 if (s->frames > 1) {
2101 n = m->avctx->frame_size*m->nb_channels;
2102 /* interleave output data */
2103 bp = out_samples + s->coff[fr];
2104 if (m->nb_channels == 1) {
2105 for (j = 0; j < n; j++) {
2106 *bp = s->decoded_buf[j];
2107 bp += avctx->channels;
2110 for (j = 0; j < n; j++) {
2111 bp[0] = s->decoded_buf[j++];
2112 bp[1] = s->decoded_buf[j];
2113 bp += avctx->channels;
2117 avctx->bit_rate += m->bit_rate;
2120 /* update codec info */
2121 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
2123 s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
2125 *(AVFrame *)data = *s->frame;
2129 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
2132 #if CONFIG_MP1_DECODER
2133 AVCodec ff_mp1_decoder = {
2135 .type = AVMEDIA_TYPE_AUDIO,
2137 .priv_data_size = sizeof(MPADecodeContext),
2138 .init = decode_init,
2139 .decode = decode_frame,
2140 #if FF_API_PARSE_FRAME
2141 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2143 .capabilities = CODEC_CAP_DR1,
2146 .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
2149 #if CONFIG_MP2_DECODER
2150 AVCodec ff_mp2_decoder = {
2152 .type = AVMEDIA_TYPE_AUDIO,
2154 .priv_data_size = sizeof(MPADecodeContext),
2155 .init = decode_init,
2156 .decode = decode_frame,
2157 #if FF_API_PARSE_FRAME
2158 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2160 .capabilities = CODEC_CAP_DR1,
2163 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2166 #if CONFIG_MP3_DECODER
2167 AVCodec ff_mp3_decoder = {
2169 .type = AVMEDIA_TYPE_AUDIO,
2171 .priv_data_size = sizeof(MPADecodeContext),
2172 .init = decode_init,
2173 .decode = decode_frame,
2174 #if FF_API_PARSE_FRAME
2175 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2177 .capabilities = CODEC_CAP_DR1,
2180 .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2183 #if CONFIG_MP3ADU_DECODER
2184 AVCodec ff_mp3adu_decoder = {
2186 .type = AVMEDIA_TYPE_AUDIO,
2187 .id = CODEC_ID_MP3ADU,
2188 .priv_data_size = sizeof(MPADecodeContext),
2189 .init = decode_init,
2190 .decode = decode_frame_adu,
2191 #if FF_API_PARSE_FRAME
2192 .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
2194 .capabilities = CODEC_CAP_DR1,
2197 .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2200 #if CONFIG_MP3ON4_DECODER
2201 AVCodec ff_mp3on4_decoder = {
2203 .type = AVMEDIA_TYPE_AUDIO,
2204 .id = CODEC_ID_MP3ON4,
2205 .priv_data_size = sizeof(MP3On4DecodeContext),
2206 .init = decode_init_mp3on4,
2207 .close = decode_close_mp3on4,
2208 .decode = decode_frame_mp3on4,
2209 .capabilities = CODEC_CAP_DR1,
2210 .flush = flush_mp3on4,
2211 .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),