3 * Copyright (c) 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
36 * - test lsf / mpeg25 extensively.
39 #include "mpegaudio.h"
40 #include "mpegaudiodecheader.h"
42 #define BACKSTEP_SIZE 512
44 #define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
46 /* layer 3 "granule" */
47 typedef struct GranuleDef {
52 int scalefac_compress;
57 uint8_t scalefac_scale;
58 uint8_t count1table_select;
59 int region_size[3]; /* number of huffman codes in each region */
61 int short_start, long_end; /* long/short band indexes */
62 uint8_t scale_factors[40];
63 DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
66 typedef struct MPADecodeContext {
68 uint8_t last_buf[LAST_BUF_SIZE];
70 /* next header (used in free format parsing) */
71 uint32_t free_format_next_header;
74 DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
75 int synth_buf_offset[MPA_MAX_CHANNELS];
76 DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
77 INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
78 GranuleDef granules[2][2]; /* Used in Layer 3 */
79 int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
82 AVCodecContext* avctx;
89 # define SHR(a,b) ((a)*(1.0f/(1<<(b))))
90 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
91 # define FIXR(x) ((float)(x))
92 # define FIXHR(x) ((float)(x))
93 # define MULH3(x, y, s) ((s)*(y)*(x))
94 # define MULLx(x, y, s) ((y)*(x))
95 # define RENAME(a) a ## _float
96 # define OUT_FMT AV_SAMPLE_FMT_FLT
98 # define SHR(a,b) ((a)>>(b))
99 /* WARNING: only correct for positive numbers */
100 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
101 # define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
102 # define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
103 # define MULH3(x, y, s) MULH((s)*(x), y)
104 # define MULLx(x, y, s) MULL(x,y,s)
105 # define RENAME(a) a ## _fixed
106 # define OUT_FMT AV_SAMPLE_FMT_S16
111 #define HEADER_SIZE 4
113 #include "mpegaudiodata.h"
114 #include "mpegaudiodectab.h"
116 /* vlc structure for decoding layer 3 huffman tables */
117 static VLC huff_vlc[16];
118 static VLC_TYPE huff_vlc_tables[
119 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
120 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
122 static const int huff_vlc_tables_sizes[16] = {
123 0, 128, 128, 128, 130, 128, 154, 166,
124 142, 204, 190, 170, 542, 460, 662, 414
126 static VLC huff_quad_vlc[2];
127 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
128 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
129 /* computed from band_size_long */
130 static uint16_t band_index_long[9][23];
131 #include "mpegaudio_tablegen.h"
132 /* intensity stereo coef table */
133 static INTFLOAT is_table[2][16];
134 static INTFLOAT is_table_lsf[2][2][16];
135 static INTFLOAT csa_table[8][4];
137 static int16_t division_tab3[1<<6 ];
138 static int16_t division_tab5[1<<8 ];
139 static int16_t division_tab9[1<<11];
141 static int16_t * const division_tabs[4] = {
142 division_tab3, division_tab5, NULL, division_tab9
145 /* lower 2 bits: modulo 3, higher bits: shift */
146 static uint16_t scale_factor_modshift[64];
147 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
148 static int32_t scale_factor_mult[15][3];
149 /* mult table for layer 2 group quantization */
151 #define SCALE_GEN(v) \
152 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
154 static const int32_t scale_factor_mult2[3][3] = {
155 SCALE_GEN(4.0 / 3.0), /* 3 steps */
156 SCALE_GEN(4.0 / 5.0), /* 5 steps */
157 SCALE_GEN(4.0 / 9.0), /* 9 steps */
161 * Convert region offsets to region sizes and truncate
162 * size to big_values.
164 static void ff_region_offset2size(GranuleDef *g)
167 g->region_size[2] = 576 / 2;
168 for (i = 0; i < 3; i++) {
169 k = FFMIN(g->region_size[i], g->big_values);
170 g->region_size[i] = k - j;
175 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
177 if (g->block_type == 2) {
178 if (s->sample_rate_index != 8)
179 g->region_size[0] = (36 / 2);
181 g->region_size[0] = (72 / 2);
183 if (s->sample_rate_index <= 2)
184 g->region_size[0] = (36 / 2);
185 else if (s->sample_rate_index != 8)
186 g->region_size[0] = (54 / 2);
188 g->region_size[0] = (108 / 2);
190 g->region_size[1] = (576 / 2);
193 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
196 g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
197 /* should not overflow */
198 l = FFMIN(ra1 + ra2 + 2, 22);
199 g->region_size[1] = band_index_long[s->sample_rate_index][ l] >> 1;
202 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
204 if (g->block_type == 2) {
205 if (g->switch_point) {
206 /* if switched mode, we handle the 36 first samples as
207 long blocks. For 8000Hz, we handle the 72 first
208 exponents as long blocks */
209 if (s->sample_rate_index <= 2)
214 g->short_start = 2 + (s->sample_rate_index != 8);
225 /* layer 1 unscaling */
226 /* n = number of bits of the mantissa minus 1 */
227 static inline int l1_unscale(int n, int mant, int scale_factor)
232 shift = scale_factor_modshift[scale_factor];
235 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
237 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
238 return (int)((val + (1LL << (shift - 1))) >> shift);
241 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
245 shift = scale_factor_modshift[scale_factor];
249 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
250 /* NOTE: at this point, 0 <= shift <= 21 */
252 val = (val + (1 << (shift - 1))) >> shift;
256 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
257 static inline int l3_unscale(int value, int exponent)
262 e = table_4_3_exp [4 * value + (exponent & 3)];
263 m = table_4_3_value[4 * value + (exponent & 3)];
268 m = (m + (1 << (e - 1))) >> e;
273 static av_cold void decode_init_static(void)
278 /* scale factors table for layer 1/2 */
279 for (i = 0; i < 64; i++) {
281 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
284 scale_factor_modshift[i] = mod | (shift << 2);
287 /* scale factor multiply for layer 1 */
288 for (i = 0; i < 15; i++) {
291 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
292 scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
293 scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
294 scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
295 av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
296 scale_factor_mult[i][0],
297 scale_factor_mult[i][1],
298 scale_factor_mult[i][2]);
301 RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
303 /* huffman decode tables */
305 for (i = 1; i < 16; i++) {
306 const HuffTable *h = &mpa_huff_tables[i];
308 uint8_t tmp_bits [512] = { 0 };
309 uint16_t tmp_codes[512] = { 0 };
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;
422 static av_cold int decode_init(AVCodecContext * avctx)
424 static int initialized_tables = 0;
425 MPADecodeContext *s = avctx->priv_data;
427 if (!initialized_tables) {
428 decode_init_static();
429 initialized_tables = 1;
434 ff_mpadsp_init(&s->mpadsp);
435 ff_dsputil_init(&s->dsp, avctx);
437 avctx->sample_fmt= OUT_FMT;
438 s->err_recognition = avctx->err_recognition;
440 if (avctx->codec_id == CODEC_ID_MP3ADU)
443 avcodec_get_frame_defaults(&s->frame);
444 avctx->coded_frame = &s->frame;
449 #define C3 FIXHR(0.86602540378443864676/2)
450 #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
451 #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
452 #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
454 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
456 static void imdct12(INTFLOAT *out, INTFLOAT *in)
458 INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
461 in1 = in[1*3] + in[0*3];
462 in2 = in[2*3] + in[1*3];
463 in3 = in[3*3] + in[2*3];
464 in4 = in[4*3] + in[3*3];
465 in5 = in[5*3] + in[4*3];
469 in2 = MULH3(in2, C3, 2);
470 in3 = MULH3(in3, C3, 4);
473 t2 = MULH3(in1 - in5, C4, 2);
483 in1 = MULH3(in5 + in3, C5, 1);
490 in5 = MULH3(in5 - in3, C6, 2);
497 /* return the number of decoded frames */
498 static int mp_decode_layer1(MPADecodeContext *s)
500 int bound, i, v, n, ch, j, mant;
501 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
502 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
504 if (s->mode == MPA_JSTEREO)
505 bound = (s->mode_ext + 1) * 4;
509 /* allocation bits */
510 for (i = 0; i < bound; i++) {
511 for (ch = 0; ch < s->nb_channels; ch++) {
512 allocation[ch][i] = get_bits(&s->gb, 4);
515 for (i = bound; i < SBLIMIT; i++)
516 allocation[0][i] = get_bits(&s->gb, 4);
519 for (i = 0; i < bound; i++) {
520 for (ch = 0; ch < s->nb_channels; ch++) {
521 if (allocation[ch][i])
522 scale_factors[ch][i] = get_bits(&s->gb, 6);
525 for (i = bound; i < SBLIMIT; i++) {
526 if (allocation[0][i]) {
527 scale_factors[0][i] = get_bits(&s->gb, 6);
528 scale_factors[1][i] = get_bits(&s->gb, 6);
532 /* compute samples */
533 for (j = 0; j < 12; j++) {
534 for (i = 0; i < bound; i++) {
535 for (ch = 0; ch < s->nb_channels; ch++) {
536 n = allocation[ch][i];
538 mant = get_bits(&s->gb, n + 1);
539 v = l1_unscale(n, mant, scale_factors[ch][i]);
543 s->sb_samples[ch][j][i] = v;
546 for (i = bound; i < SBLIMIT; i++) {
547 n = allocation[0][i];
549 mant = get_bits(&s->gb, n + 1);
550 v = l1_unscale(n, mant, scale_factors[0][i]);
551 s->sb_samples[0][j][i] = v;
552 v = l1_unscale(n, mant, scale_factors[1][i]);
553 s->sb_samples[1][j][i] = v;
555 s->sb_samples[0][j][i] = 0;
556 s->sb_samples[1][j][i] = 0;
563 static int mp_decode_layer2(MPADecodeContext *s)
565 int sblimit; /* number of used subbands */
566 const unsigned char *alloc_table;
567 int table, bit_alloc_bits, i, j, ch, bound, v;
568 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
569 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
570 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
571 int scale, qindex, bits, steps, k, l, m, b;
573 /* select decoding table */
574 table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
575 s->sample_rate, s->lsf);
576 sblimit = ff_mpa_sblimit_table[table];
577 alloc_table = ff_mpa_alloc_tables[table];
579 if (s->mode == MPA_JSTEREO)
580 bound = (s->mode_ext + 1) * 4;
584 av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
590 /* parse bit allocation */
592 for (i = 0; i < bound; i++) {
593 bit_alloc_bits = alloc_table[j];
594 for (ch = 0; ch < s->nb_channels; ch++)
595 bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
596 j += 1 << bit_alloc_bits;
598 for (i = bound; i < sblimit; i++) {
599 bit_alloc_bits = alloc_table[j];
600 v = get_bits(&s->gb, bit_alloc_bits);
603 j += 1 << bit_alloc_bits;
607 for (i = 0; i < sblimit; i++) {
608 for (ch = 0; ch < s->nb_channels; ch++) {
609 if (bit_alloc[ch][i])
610 scale_code[ch][i] = get_bits(&s->gb, 2);
615 for (i = 0; i < sblimit; i++) {
616 for (ch = 0; ch < s->nb_channels; ch++) {
617 if (bit_alloc[ch][i]) {
618 sf = scale_factors[ch][i];
619 switch (scale_code[ch][i]) {
622 sf[0] = get_bits(&s->gb, 6);
623 sf[1] = get_bits(&s->gb, 6);
624 sf[2] = get_bits(&s->gb, 6);
627 sf[0] = get_bits(&s->gb, 6);
632 sf[0] = get_bits(&s->gb, 6);
633 sf[2] = get_bits(&s->gb, 6);
637 sf[0] = get_bits(&s->gb, 6);
638 sf[2] = get_bits(&s->gb, 6);
647 for (k = 0; k < 3; k++) {
648 for (l = 0; l < 12; l += 3) {
650 for (i = 0; i < bound; i++) {
651 bit_alloc_bits = alloc_table[j];
652 for (ch = 0; ch < s->nb_channels; ch++) {
653 b = bit_alloc[ch][i];
655 scale = scale_factors[ch][i][k];
656 qindex = alloc_table[j+b];
657 bits = ff_mpa_quant_bits[qindex];
660 /* 3 values at the same time */
661 v = get_bits(&s->gb, -bits);
662 v2 = division_tabs[qindex][v];
663 steps = ff_mpa_quant_steps[qindex];
665 s->sb_samples[ch][k * 12 + l + 0][i] =
666 l2_unscale_group(steps, v2 & 15, scale);
667 s->sb_samples[ch][k * 12 + l + 1][i] =
668 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
669 s->sb_samples[ch][k * 12 + l + 2][i] =
670 l2_unscale_group(steps, v2 >> 8 , scale);
672 for (m = 0; m < 3; m++) {
673 v = get_bits(&s->gb, bits);
674 v = l1_unscale(bits - 1, v, scale);
675 s->sb_samples[ch][k * 12 + l + m][i] = v;
679 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
680 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
681 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
684 /* next subband in alloc table */
685 j += 1 << bit_alloc_bits;
687 /* XXX: find a way to avoid this duplication of code */
688 for (i = bound; i < sblimit; i++) {
689 bit_alloc_bits = alloc_table[j];
692 int mant, scale0, scale1;
693 scale0 = scale_factors[0][i][k];
694 scale1 = scale_factors[1][i][k];
695 qindex = alloc_table[j+b];
696 bits = ff_mpa_quant_bits[qindex];
698 /* 3 values at the same time */
699 v = get_bits(&s->gb, -bits);
700 steps = ff_mpa_quant_steps[qindex];
703 s->sb_samples[0][k * 12 + l + 0][i] =
704 l2_unscale_group(steps, mant, scale0);
705 s->sb_samples[1][k * 12 + l + 0][i] =
706 l2_unscale_group(steps, mant, scale1);
709 s->sb_samples[0][k * 12 + l + 1][i] =
710 l2_unscale_group(steps, mant, scale0);
711 s->sb_samples[1][k * 12 + l + 1][i] =
712 l2_unscale_group(steps, mant, scale1);
713 s->sb_samples[0][k * 12 + l + 2][i] =
714 l2_unscale_group(steps, v, scale0);
715 s->sb_samples[1][k * 12 + l + 2][i] =
716 l2_unscale_group(steps, v, scale1);
718 for (m = 0; m < 3; m++) {
719 mant = get_bits(&s->gb, bits);
720 s->sb_samples[0][k * 12 + l + m][i] =
721 l1_unscale(bits - 1, mant, scale0);
722 s->sb_samples[1][k * 12 + l + m][i] =
723 l1_unscale(bits - 1, mant, scale1);
727 s->sb_samples[0][k * 12 + l + 0][i] = 0;
728 s->sb_samples[0][k * 12 + l + 1][i] = 0;
729 s->sb_samples[0][k * 12 + l + 2][i] = 0;
730 s->sb_samples[1][k * 12 + l + 0][i] = 0;
731 s->sb_samples[1][k * 12 + l + 1][i] = 0;
732 s->sb_samples[1][k * 12 + l + 2][i] = 0;
734 /* next subband in alloc table */
735 j += 1 << bit_alloc_bits;
737 /* fill remaining samples to zero */
738 for (i = sblimit; i < SBLIMIT; i++) {
739 for (ch = 0; ch < s->nb_channels; ch++) {
740 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
741 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
742 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
750 #define SPLIT(dst,sf,n) \
752 int m = (sf * 171) >> 9; \
755 } else if (n == 4) { \
758 } else if (n == 5) { \
759 int m = (sf * 205) >> 10; \
762 } else if (n == 6) { \
763 int m = (sf * 171) >> 10; \
770 static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
773 SPLIT(slen[3], sf, n3)
774 SPLIT(slen[2], sf, n2)
775 SPLIT(slen[1], sf, n1)
779 static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
782 const uint8_t *bstab, *pretab;
783 int len, i, j, k, l, v0, shift, gain, gains[3];
787 gain = g->global_gain - 210;
788 shift = g->scalefac_scale + 1;
790 bstab = band_size_long[s->sample_rate_index];
791 pretab = mpa_pretab[g->preflag];
792 for (i = 0; i < g->long_end; i++) {
793 v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
795 for (j = len; j > 0; j--)
799 if (g->short_start < 13) {
800 bstab = band_size_short[s->sample_rate_index];
801 gains[0] = gain - (g->subblock_gain[0] << 3);
802 gains[1] = gain - (g->subblock_gain[1] << 3);
803 gains[2] = gain - (g->subblock_gain[2] << 3);
805 for (i = g->short_start; i < 13; i++) {
807 for (l = 0; l < 3; l++) {
808 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
809 for (j = len; j > 0; j--)
816 /* handle n = 0 too */
817 static inline int get_bitsz(GetBitContext *s, int n)
819 return n ? get_bits(s, n) : 0;
823 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
826 if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
828 s->in_gb.buffer = NULL;
829 assert((get_bits_count(&s->gb) & 7) == 0);
830 skip_bits_long(&s->gb, *pos - *end_pos);
832 *end_pos = *end_pos2 + get_bits_count(&s->gb) - *pos;
833 *pos = get_bits_count(&s->gb);
837 /* Following is a optimized code for
839 if(get_bits1(&s->gb))
844 #define READ_FLIP_SIGN(dst,src) \
845 v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31); \
848 #define READ_FLIP_SIGN(dst,src) \
849 v = -get_bits1(&s->gb); \
850 *(dst) = (*(src) ^ v) - v;
853 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
854 int16_t *exponents, int end_pos2)
858 int last_pos, bits_left;
860 int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
862 /* low frequencies (called big values) */
864 for (i = 0; i < 3; i++) {
865 int j, k, l, linbits;
866 j = g->region_size[i];
869 /* select vlc table */
870 k = g->table_select[i];
871 l = mpa_huff_data[k][0];
872 linbits = mpa_huff_data[k][1];
876 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
881 /* read huffcode and compute each couple */
885 int pos = get_bits_count(&s->gb);
888 // av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
889 switch_buffer(s, &pos, &end_pos, &end_pos2);
890 // av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
894 y = get_vlc2(&s->gb, vlc->table, 7, 3);
897 g->sb_hybrid[s_index ] =
898 g->sb_hybrid[s_index+1] = 0;
903 exponent= exponents[s_index];
905 av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
906 i, g->region_size[i] - j, x, y, exponent);
911 READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
913 x += get_bitsz(&s->gb, linbits);
914 v = l3_unscale(x, exponent);
915 if (get_bits1(&s->gb))
917 g->sb_hybrid[s_index] = v;
920 READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
922 y += get_bitsz(&s->gb, linbits);
923 v = l3_unscale(y, exponent);
924 if (get_bits1(&s->gb))
926 g->sb_hybrid[s_index+1] = v;
933 READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
935 x += get_bitsz(&s->gb, linbits);
936 v = l3_unscale(x, exponent);
937 if (get_bits1(&s->gb))
939 g->sb_hybrid[s_index+!!y] = v;
941 g->sb_hybrid[s_index + !y] = 0;
947 /* high frequencies */
948 vlc = &huff_quad_vlc[g->count1table_select];
950 while (s_index <= 572) {
952 pos = get_bits_count(&s->gb);
953 if (pos >= end_pos) {
954 if (pos > end_pos2 && last_pos) {
955 /* some encoders generate an incorrect size for this
956 part. We must go back into the data */
958 skip_bits_long(&s->gb, last_pos - pos);
959 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
960 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
964 // av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
965 switch_buffer(s, &pos, &end_pos, &end_pos2);
966 // av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
972 code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
973 av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
974 g->sb_hybrid[s_index+0] =
975 g->sb_hybrid[s_index+1] =
976 g->sb_hybrid[s_index+2] =
977 g->sb_hybrid[s_index+3] = 0;
979 static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
981 int pos = s_index + idxtab[code];
982 code ^= 8 >> idxtab[code];
983 READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
987 /* skip extension bits */
988 bits_left = end_pos2 - get_bits_count(&s->gb);
989 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
990 if (bits_left < 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_COMPLIANT))) {
991 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
993 } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) {
994 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
997 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
998 skip_bits_long(&s->gb, bits_left);
1000 i = get_bits_count(&s->gb);
1001 switch_buffer(s, &i, &end_pos, &end_pos2);
1006 /* Reorder short blocks from bitstream order to interleaved order. It
1007 would be faster to do it in parsing, but the code would be far more
1009 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
1012 INTFLOAT *ptr, *dst, *ptr1;
1015 if (g->block_type != 2)
1018 if (g->switch_point) {
1019 if (s->sample_rate_index != 8)
1020 ptr = g->sb_hybrid + 36;
1022 ptr = g->sb_hybrid + 72;
1027 for (i = g->short_start; i < 13; i++) {
1028 len = band_size_short[s->sample_rate_index][i];
1031 for (j = len; j > 0; j--) {
1032 *dst++ = ptr[0*len];
1033 *dst++ = ptr[1*len];
1034 *dst++ = ptr[2*len];
1038 memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1042 #define ISQRT2 FIXR(0.70710678118654752440)
1044 static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1047 int sf_max, sf, len, non_zero_found;
1048 INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1049 int non_zero_found_short[3];
1051 /* intensity stereo */
1052 if (s->mode_ext & MODE_EXT_I_STEREO) {
1057 is_tab = is_table_lsf[g1->scalefac_compress & 1];
1061 tab0 = g0->sb_hybrid + 576;
1062 tab1 = g1->sb_hybrid + 576;
1064 non_zero_found_short[0] = 0;
1065 non_zero_found_short[1] = 0;
1066 non_zero_found_short[2] = 0;
1067 k = (13 - g1->short_start) * 3 + g1->long_end - 3;
1068 for (i = 12; i >= g1->short_start; i--) {
1069 /* for last band, use previous scale factor */
1072 len = band_size_short[s->sample_rate_index][i];
1073 for (l = 2; l >= 0; l--) {
1076 if (!non_zero_found_short[l]) {
1077 /* test if non zero band. if so, stop doing i-stereo */
1078 for (j = 0; j < len; j++) {
1080 non_zero_found_short[l] = 1;
1084 sf = g1->scale_factors[k + l];
1090 for (j = 0; j < len; j++) {
1092 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1093 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1097 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1098 /* lower part of the spectrum : do ms stereo
1100 for (j = 0; j < len; j++) {
1103 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1104 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1111 non_zero_found = non_zero_found_short[0] |
1112 non_zero_found_short[1] |
1113 non_zero_found_short[2];
1115 for (i = g1->long_end - 1;i >= 0;i--) {
1116 len = band_size_long[s->sample_rate_index][i];
1119 /* test if non zero band. if so, stop doing i-stereo */
1120 if (!non_zero_found) {
1121 for (j = 0; j < len; j++) {
1127 /* for last band, use previous scale factor */
1128 k = (i == 21) ? 20 : i;
1129 sf = g1->scale_factors[k];
1134 for (j = 0; j < len; j++) {
1136 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1137 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1141 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1142 /* lower part of the spectrum : do ms stereo
1144 for (j = 0; j < len; j++) {
1147 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1148 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1153 } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
1154 /* ms stereo ONLY */
1155 /* NOTE: the 1/sqrt(2) normalization factor is included in the
1158 s-> dsp.butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
1160 tab0 = g0->sb_hybrid;
1161 tab1 = g1->sb_hybrid;
1162 for (i = 0; i < 576; i++) {
1165 tab0[i] = tmp0 + tmp1;
1166 tab1[i] = tmp0 - tmp1;
1174 # include "mips/compute_antialias_float.h"
1175 #endif /* HAVE_MIPSFPU */
1178 # include "mips/compute_antialias_fixed.h"
1179 #endif /* HAVE_MIPSDSPR1 */
1180 #endif /* CONFIG_FLOAT */
1182 #ifndef compute_antialias
1184 #define AA(j) do { \
1185 float tmp0 = ptr[-1-j]; \
1186 float tmp1 = ptr[ j]; \
1187 ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
1188 ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
1191 #define AA(j) do { \
1192 int tmp0 = ptr[-1-j]; \
1193 int tmp1 = ptr[ j]; \
1194 int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
1195 ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2])); \
1196 ptr[ j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3])); \
1200 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1205 /* we antialias only "long" bands */
1206 if (g->block_type == 2) {
1207 if (!g->switch_point)
1209 /* XXX: check this for 8000Hz case */
1215 ptr = g->sb_hybrid + 18;
1216 for (i = n; i > 0; i--) {
1229 #endif /* compute_antialias */
1231 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
1232 INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1234 INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1236 int i, j, mdct_long_end, sblimit;
1238 /* find last non zero block */
1239 ptr = g->sb_hybrid + 576;
1240 ptr1 = g->sb_hybrid + 2 * 18;
1241 while (ptr >= ptr1) {
1245 if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1248 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
1250 if (g->block_type == 2) {
1251 /* XXX: check for 8000 Hz */
1252 if (g->switch_point)
1257 mdct_long_end = sblimit;
1260 s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
1261 mdct_long_end, g->switch_point,
1264 buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
1265 ptr = g->sb_hybrid + 18 * mdct_long_end;
1267 for (j = mdct_long_end; j < sblimit; j++) {
1268 /* select frequency inversion */
1269 win = RENAME(ff_mdct_win)[2 + (4 & -(j & 1))];
1270 out_ptr = sb_samples + j;
1272 for (i = 0; i < 6; i++) {
1273 *out_ptr = buf[4*i];
1276 imdct12(out2, ptr + 0);
1277 for (i = 0; i < 6; i++) {
1278 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*1)];
1279 buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
1282 imdct12(out2, ptr + 1);
1283 for (i = 0; i < 6; i++) {
1284 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*2)];
1285 buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
1288 imdct12(out2, ptr + 2);
1289 for (i = 0; i < 6; i++) {
1290 buf[4*(i + 6*0)] = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*0)];
1291 buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
1292 buf[4*(i + 6*2)] = 0;
1295 buf += (j&3) != 3 ? 1 : (4*18-3);
1298 for (j = sblimit; j < SBLIMIT; j++) {
1300 out_ptr = sb_samples + j;
1301 for (i = 0; i < 18; i++) {
1302 *out_ptr = buf[4*i];
1306 buf += (j&3) != 3 ? 1 : (4*18-3);
1310 /* main layer3 decoding function */
1311 static int mp_decode_layer3(MPADecodeContext *s)
1313 int nb_granules, main_data_begin;
1314 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1316 int16_t exponents[576]; //FIXME try INTFLOAT
1318 /* read side info */
1320 main_data_begin = get_bits(&s->gb, 8);
1321 skip_bits(&s->gb, s->nb_channels);
1324 main_data_begin = get_bits(&s->gb, 9);
1325 if (s->nb_channels == 2)
1326 skip_bits(&s->gb, 3);
1328 skip_bits(&s->gb, 5);
1330 for (ch = 0; ch < s->nb_channels; ch++) {
1331 s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
1332 s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1336 for (gr = 0; gr < nb_granules; gr++) {
1337 for (ch = 0; ch < s->nb_channels; ch++) {
1338 av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1339 g = &s->granules[ch][gr];
1340 g->part2_3_length = get_bits(&s->gb, 12);
1341 g->big_values = get_bits(&s->gb, 9);
1342 if (g->big_values > 288) {
1343 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1344 return AVERROR_INVALIDDATA;
1347 g->global_gain = get_bits(&s->gb, 8);
1348 /* if MS stereo only is selected, we precompute the
1349 1/sqrt(2) renormalization factor */
1350 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1352 g->global_gain -= 2;
1354 g->scalefac_compress = get_bits(&s->gb, 9);
1356 g->scalefac_compress = get_bits(&s->gb, 4);
1357 blocksplit_flag = get_bits1(&s->gb);
1358 if (blocksplit_flag) {
1359 g->block_type = get_bits(&s->gb, 2);
1360 if (g->block_type == 0) {
1361 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1362 return AVERROR_INVALIDDATA;
1364 g->switch_point = get_bits1(&s->gb);
1365 for (i = 0; i < 2; i++)
1366 g->table_select[i] = get_bits(&s->gb, 5);
1367 for (i = 0; i < 3; i++)
1368 g->subblock_gain[i] = get_bits(&s->gb, 3);
1369 ff_init_short_region(s, g);
1371 int region_address1, region_address2;
1373 g->switch_point = 0;
1374 for (i = 0; i < 3; i++)
1375 g->table_select[i] = get_bits(&s->gb, 5);
1376 /* compute huffman coded region sizes */
1377 region_address1 = get_bits(&s->gb, 4);
1378 region_address2 = get_bits(&s->gb, 3);
1379 av_dlog(s->avctx, "region1=%d region2=%d\n",
1380 region_address1, region_address2);
1381 ff_init_long_region(s, g, region_address1, region_address2);
1383 ff_region_offset2size(g);
1384 ff_compute_band_indexes(s, g);
1388 g->preflag = get_bits1(&s->gb);
1389 g->scalefac_scale = get_bits1(&s->gb);
1390 g->count1table_select = get_bits1(&s->gb);
1391 av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1392 g->block_type, g->switch_point);
1398 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1399 int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0, EXTRABYTES);
1400 assert((get_bits_count(&s->gb) & 7) == 0);
1401 /* now we get bits from the main_data_begin offset */
1402 av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1403 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1405 memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1407 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1408 #if !UNCHECKED_BITSTREAM_READER
1409 s->gb.size_in_bits_plus8 += FFMAX(extrasize, LAST_BUF_SIZE - s->last_buf_size) * 8;
1411 s->last_buf_size <<= 3;
1412 for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
1413 for (ch = 0; ch < s->nb_channels; ch++) {
1414 g = &s->granules[ch][gr];
1415 s->last_buf_size += g->part2_3_length;
1416 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1419 skip = s->last_buf_size - 8 * main_data_begin;
1420 if (skip >= s->gb.size_in_bits && s->in_gb.buffer) {
1421 skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits);
1423 s->in_gb.buffer = NULL;
1425 skip_bits_long(&s->gb, skip);
1431 for (; gr < nb_granules; gr++) {
1432 for (ch = 0; ch < s->nb_channels; ch++) {
1433 g = &s->granules[ch][gr];
1434 bits_pos = get_bits_count(&s->gb);
1438 int slen, slen1, slen2;
1440 /* MPEG1 scale factors */
1441 slen1 = slen_table[0][g->scalefac_compress];
1442 slen2 = slen_table[1][g->scalefac_compress];
1443 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1444 if (g->block_type == 2) {
1445 n = g->switch_point ? 17 : 18;
1448 for (i = 0; i < n; i++)
1449 g->scale_factors[j++] = get_bits(&s->gb, slen1);
1451 for (i = 0; i < n; i++)
1452 g->scale_factors[j++] = 0;
1455 for (i = 0; i < 18; i++)
1456 g->scale_factors[j++] = get_bits(&s->gb, slen2);
1457 for (i = 0; i < 3; i++)
1458 g->scale_factors[j++] = 0;
1460 for (i = 0; i < 21; i++)
1461 g->scale_factors[j++] = 0;
1464 sc = s->granules[ch][0].scale_factors;
1466 for (k = 0; k < 4; k++) {
1468 if ((g->scfsi & (0x8 >> k)) == 0) {
1469 slen = (k < 2) ? slen1 : slen2;
1471 for (i = 0; i < n; i++)
1472 g->scale_factors[j++] = get_bits(&s->gb, slen);
1474 for (i = 0; i < n; i++)
1475 g->scale_factors[j++] = 0;
1478 /* simply copy from last granule */
1479 for (i = 0; i < n; i++) {
1480 g->scale_factors[j] = sc[j];
1485 g->scale_factors[j++] = 0;
1488 int tindex, tindex2, slen[4], sl, sf;
1490 /* LSF scale factors */
1491 if (g->block_type == 2)
1492 tindex = g->switch_point ? 2 : 1;
1496 sf = g->scalefac_compress;
1497 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1498 /* intensity stereo case */
1501 lsf_sf_expand(slen, sf, 6, 6, 0);
1503 } else if (sf < 244) {
1504 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1507 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1513 lsf_sf_expand(slen, sf, 5, 4, 4);
1515 } else if (sf < 500) {
1516 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1519 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1526 for (k = 0; k < 4; k++) {
1527 n = lsf_nsf_table[tindex2][tindex][k];
1530 for (i = 0; i < n; i++)
1531 g->scale_factors[j++] = get_bits(&s->gb, sl);
1533 for (i = 0; i < n; i++)
1534 g->scale_factors[j++] = 0;
1537 /* XXX: should compute exact size */
1539 g->scale_factors[j] = 0;
1542 exponents_from_scale_factors(s, g, exponents);
1544 /* read Huffman coded residue */
1545 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1548 if (s->mode == MPA_JSTEREO)
1549 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1551 for (ch = 0; ch < s->nb_channels; ch++) {
1552 g = &s->granules[ch][gr];
1554 reorder_block(s, g);
1555 compute_antialias(s, g);
1556 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1559 if (get_bits_count(&s->gb) < 0)
1560 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1561 return nb_granules * 18;
1564 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1565 const uint8_t *buf, int buf_size)
1567 int i, nb_frames, ch, ret;
1568 OUT_INT *samples_ptr;
1570 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1572 /* skip error protection field */
1573 if (s->error_protection)
1574 skip_bits(&s->gb, 16);
1578 s->avctx->frame_size = 384;
1579 nb_frames = mp_decode_layer1(s);
1582 s->avctx->frame_size = 1152;
1583 nb_frames = mp_decode_layer2(s);
1586 s->avctx->frame_size = s->lsf ? 576 : 1152;
1588 nb_frames = mp_decode_layer3(s);
1591 if (s->in_gb.buffer) {
1592 align_get_bits(&s->gb);
1593 i = get_bits_left(&s->gb)>>3;
1594 if (i >= 0 && i <= BACKSTEP_SIZE) {
1595 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1598 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1600 s->in_gb.buffer = NULL;
1603 align_get_bits(&s->gb);
1604 assert((get_bits_count(&s->gb) & 7) == 0);
1605 i = get_bits_left(&s->gb) >> 3;
1607 if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1609 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1610 i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1612 assert(i <= buf_size - HEADER_SIZE && i >= 0);
1613 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1614 s->last_buf_size += i;
1617 /* get output buffer */
1619 s->frame.nb_samples = s->avctx->frame_size;
1620 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1621 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1624 samples = (OUT_INT *)s->frame.data[0];
1627 /* apply the synthesis filter */
1628 for (ch = 0; ch < s->nb_channels; ch++) {
1629 samples_ptr = samples + ch;
1630 for (i = 0; i < nb_frames; i++) {
1631 RENAME(ff_mpa_synth_filter)(
1633 s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1634 RENAME(ff_mpa_synth_window), &s->dither_state,
1635 samples_ptr, s->nb_channels,
1636 s->sb_samples[ch][i]);
1637 samples_ptr += 32 * s->nb_channels;
1641 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1644 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1647 const uint8_t *buf = avpkt->data;
1648 int buf_size = avpkt->size;
1649 MPADecodeContext *s = avctx->priv_data;
1653 while(buf_size && !*buf){
1658 if (buf_size < HEADER_SIZE)
1659 return AVERROR_INVALIDDATA;
1661 header = AV_RB32(buf);
1662 if (header>>8 == AV_RB32("TAG")>>8) {
1663 av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
1666 if (ff_mpa_check_header(header) < 0) {
1667 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1668 return AVERROR_INVALIDDATA;
1671 if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1672 /* free format: prepare to compute frame size */
1674 return AVERROR_INVALIDDATA;
1676 /* update codec info */
1677 avctx->channels = s->nb_channels;
1678 avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1679 if (!avctx->bit_rate)
1680 avctx->bit_rate = s->bit_rate;
1682 if (s->frame_size <= 0 || s->frame_size > buf_size) {
1683 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1684 return AVERROR_INVALIDDATA;
1685 }else if(s->frame_size < buf_size){
1686 av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
1687 buf_size= s->frame_size;
1690 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1691 if (out_size >= 0) {
1693 *(AVFrame *)data = s->frame;
1694 avctx->sample_rate = s->sample_rate;
1695 //FIXME maybe move the other codec info stuff from above here too
1697 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1698 /* Only return an error if the bad frame makes up the whole packet.
1699 If there is more data in the packet, just consume the bad frame
1700 instead of returning an error, which would discard the whole
1703 if (buf_size == avpkt->size)
1710 static void flush(AVCodecContext *avctx)
1712 MPADecodeContext *s = avctx->priv_data;
1713 memset(s->synth_buf, 0, sizeof(s->synth_buf));
1714 s->last_buf_size = 0;
1717 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1718 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1719 int *got_frame_ptr, AVPacket *avpkt)
1721 const uint8_t *buf = avpkt->data;
1722 int buf_size = avpkt->size;
1723 MPADecodeContext *s = avctx->priv_data;
1726 int av_unused out_size;
1730 // Discard too short frames
1731 if (buf_size < HEADER_SIZE) {
1732 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1733 return AVERROR_INVALIDDATA;
1737 if (len > MPA_MAX_CODED_FRAME_SIZE)
1738 len = MPA_MAX_CODED_FRAME_SIZE;
1740 // Get header and restore sync word
1741 header = AV_RB32(buf) | 0xffe00000;
1743 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1744 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1745 return AVERROR_INVALIDDATA;
1748 avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1749 /* update codec info */
1750 avctx->sample_rate = s->sample_rate;
1751 avctx->channels = s->nb_channels;
1752 if (!avctx->bit_rate)
1753 avctx->bit_rate = s->bit_rate;
1755 s->frame_size = len;
1757 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1759 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1760 return AVERROR_INVALIDDATA;
1764 *(AVFrame *)data = s->frame;
1768 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1770 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1773 * Context for MP3On4 decoder
1775 typedef struct MP3On4DecodeContext {
1777 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
1778 int syncword; ///< syncword patch
1779 const uint8_t *coff; ///< channel offsets in output buffer
1780 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1781 OUT_INT *decoded_buf; ///< output buffer for decoded samples
1782 } MP3On4DecodeContext;
1784 #include "mpeg4audio.h"
1786 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1788 /* number of mp3 decoder instances */
1789 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1791 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1792 static const uint8_t chan_offset[8][5] = {
1797 { 2, 0, 3 }, // C FLR BS
1798 { 2, 0, 3 }, // C FLR BLRS
1799 { 2, 0, 4, 3 }, // C FLR BLRS LFE
1800 { 2, 0, 6, 4, 3 }, // C FLR BLRS BLR LFE
1803 /* mp3on4 channel layouts */
1804 static const int16_t chan_layout[8] = {
1807 AV_CH_LAYOUT_STEREO,
1808 AV_CH_LAYOUT_SURROUND,
1809 AV_CH_LAYOUT_4POINT0,
1810 AV_CH_LAYOUT_5POINT0,
1811 AV_CH_LAYOUT_5POINT1,
1812 AV_CH_LAYOUT_7POINT1
1815 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1817 MP3On4DecodeContext *s = avctx->priv_data;
1820 for (i = 0; i < s->frames; i++)
1821 av_free(s->mp3decctx[i]);
1823 av_freep(&s->decoded_buf);
1829 static int decode_init_mp3on4(AVCodecContext * avctx)
1831 MP3On4DecodeContext *s = avctx->priv_data;
1832 MPEG4AudioConfig cfg;
1835 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1836 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1837 return AVERROR_INVALIDDATA;
1840 avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1841 avctx->extradata_size * 8, 1);
1842 if (!cfg.chan_config || cfg.chan_config > 7) {
1843 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1844 return AVERROR_INVALIDDATA;
1846 s->frames = mp3Frames[cfg.chan_config];
1847 s->coff = chan_offset[cfg.chan_config];
1848 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
1849 avctx->channel_layout = chan_layout[cfg.chan_config];
1851 if (cfg.sample_rate < 16000)
1852 s->syncword = 0xffe00000;
1854 s->syncword = 0xfff00000;
1856 /* Init the first mp3 decoder in standard way, so that all tables get builded
1857 * We replace avctx->priv_data with the context of the first decoder so that
1858 * decode_init() does not have to be changed.
1859 * Other decoders will be initialized here copying data from the first context
1861 // Allocate zeroed memory for the first decoder context
1862 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1863 if (!s->mp3decctx[0])
1865 // Put decoder context in place to make init_decode() happy
1866 avctx->priv_data = s->mp3decctx[0];
1868 s->frame = avctx->coded_frame;
1869 // Restore mp3on4 context pointer
1870 avctx->priv_data = s;
1871 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1873 /* Create a separate codec/context for each frame (first is already ok).
1874 * Each frame is 1 or 2 channels - up to 5 frames allowed
1876 for (i = 1; i < s->frames; i++) {
1877 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1878 if (!s->mp3decctx[i])
1880 s->mp3decctx[i]->adu_mode = 1;
1881 s->mp3decctx[i]->avctx = avctx;
1882 s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1885 /* Allocate buffer for multi-channel output if needed */
1886 if (s->frames > 1) {
1887 s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1888 sizeof(*s->decoded_buf));
1889 if (!s->decoded_buf)
1895 decode_close_mp3on4(avctx);
1896 return AVERROR(ENOMEM);
1900 static void flush_mp3on4(AVCodecContext *avctx)
1903 MP3On4DecodeContext *s = avctx->priv_data;
1905 for (i = 0; i < s->frames; i++) {
1906 MPADecodeContext *m = s->mp3decctx[i];
1907 memset(m->synth_buf, 0, sizeof(m->synth_buf));
1908 m->last_buf_size = 0;
1913 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
1914 int *got_frame_ptr, AVPacket *avpkt)
1916 const uint8_t *buf = avpkt->data;
1917 int buf_size = avpkt->size;
1918 MP3On4DecodeContext *s = avctx->priv_data;
1919 MPADecodeContext *m;
1920 int fsize, len = buf_size, out_size = 0;
1922 OUT_INT *out_samples;
1923 OUT_INT *outptr, *bp;
1924 int fr, j, n, ch, ret;
1926 /* get output buffer */
1927 s->frame->nb_samples = s->frames * MPA_FRAME_SIZE;
1928 if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
1929 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1932 out_samples = (OUT_INT *)s->frame->data[0];
1934 // Discard too short frames
1935 if (buf_size < HEADER_SIZE)
1936 return AVERROR_INVALIDDATA;
1938 // If only one decoder interleave is not needed
1939 outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1941 avctx->bit_rate = 0;
1944 for (fr = 0; fr < s->frames; fr++) {
1945 fsize = AV_RB16(buf) >> 4;
1946 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1947 m = s->mp3decctx[fr];
1950 if (fsize < HEADER_SIZE) {
1951 av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
1952 return AVERROR_INVALIDDATA;
1954 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1956 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1959 avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1961 if (ch + m->nb_channels > avctx->channels) {
1962 av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1964 return AVERROR_INVALIDDATA;
1966 ch += m->nb_channels;
1968 out_size += mp_decode_frame(m, outptr, buf, fsize);
1972 if (s->frames > 1) {
1973 n = m->avctx->frame_size*m->nb_channels;
1974 /* interleave output data */
1975 bp = out_samples + s->coff[fr];
1976 if (m->nb_channels == 1) {
1977 for (j = 0; j < n; j++) {
1978 *bp = s->decoded_buf[j];
1979 bp += avctx->channels;
1982 for (j = 0; j < n; j++) {
1983 bp[0] = s->decoded_buf[j++];
1984 bp[1] = s->decoded_buf[j];
1985 bp += avctx->channels;
1989 avctx->bit_rate += m->bit_rate;
1992 /* update codec info */
1993 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
1995 s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
1997 *(AVFrame *)data = *s->frame;
2001 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
2004 #if CONFIG_MP1_DECODER
2005 AVCodec ff_mp1_decoder = {
2007 .type = AVMEDIA_TYPE_AUDIO,
2009 .priv_data_size = sizeof(MPADecodeContext),
2010 .init = decode_init,
2011 .decode = decode_frame,
2012 .capabilities = CODEC_CAP_DR1,
2014 .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
2017 #if CONFIG_MP2_DECODER
2018 AVCodec ff_mp2_decoder = {
2020 .type = AVMEDIA_TYPE_AUDIO,
2022 .priv_data_size = sizeof(MPADecodeContext),
2023 .init = decode_init,
2024 .decode = decode_frame,
2025 .capabilities = CODEC_CAP_DR1,
2027 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2030 #if CONFIG_MP3_DECODER
2031 AVCodec ff_mp3_decoder = {
2033 .type = AVMEDIA_TYPE_AUDIO,
2035 .priv_data_size = sizeof(MPADecodeContext),
2036 .init = decode_init,
2037 .decode = decode_frame,
2038 .capabilities = CODEC_CAP_DR1,
2040 .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2043 #if CONFIG_MP3ADU_DECODER
2044 AVCodec ff_mp3adu_decoder = {
2046 .type = AVMEDIA_TYPE_AUDIO,
2047 .id = CODEC_ID_MP3ADU,
2048 .priv_data_size = sizeof(MPADecodeContext),
2049 .init = decode_init,
2050 .decode = decode_frame_adu,
2051 .capabilities = CODEC_CAP_DR1,
2053 .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2056 #if CONFIG_MP3ON4_DECODER
2057 AVCodec ff_mp3on4_decoder = {
2059 .type = AVMEDIA_TYPE_AUDIO,
2060 .id = CODEC_ID_MP3ON4,
2061 .priv_data_size = sizeof(MP3On4DecodeContext),
2062 .init = decode_init_mp3on4,
2063 .close = decode_close_mp3on4,
2064 .decode = decode_frame_mp3on4,
2065 .capabilities = CODEC_CAP_DR1,
2066 .flush = flush_mp3on4,
2067 .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),