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 #define UNCHECKED_BITSTREAM_READER 1
29 #include "libavutil/audioconvert.h"
33 #include "mpegaudiodsp.h"
37 * - test lsf / mpeg25 extensively.
40 #include "mpegaudio.h"
41 #include "mpegaudiodecheader.h"
43 #define BACKSTEP_SIZE 512
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[2 * BACKSTEP_SIZE + EXTRABYTES];
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;
88 # define SHR(a,b) ((a)*(1.0f/(1<<(b))))
89 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
90 # define FIXR(x) ((float)(x))
91 # define FIXHR(x) ((float)(x))
92 # define MULH3(x, y, s) ((s)*(y)*(x))
93 # define MULLx(x, y, s) ((y)*(x))
94 # define RENAME(a) a ## _float
95 # define OUT_FMT AV_SAMPLE_FMT_FLT
97 # define SHR(a,b) ((a)>>(b))
98 /* WARNING: only correct for positive numbers */
99 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
100 # define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
101 # define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
102 # define MULH3(x, y, s) MULH((s)*(x), y)
103 # define MULLx(x, y, s) MULL(x,y,s)
104 # define RENAME(a) a ## _fixed
105 # define OUT_FMT AV_SAMPLE_FMT_S16
110 #define HEADER_SIZE 4
112 #include "mpegaudiodata.h"
113 #include "mpegaudiodectab.h"
115 /* vlc structure for decoding layer 3 huffman tables */
116 static VLC huff_vlc[16];
117 static VLC_TYPE huff_vlc_tables[
118 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
119 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
121 static const int huff_vlc_tables_sizes[16] = {
122 0, 128, 128, 128, 130, 128, 154, 166,
123 142, 204, 190, 170, 542, 460, 662, 414
125 static VLC huff_quad_vlc[2];
126 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
127 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
128 /* computed from band_size_long */
129 static uint16_t band_index_long[9][23];
130 #include "mpegaudio_tablegen.h"
131 /* intensity stereo coef table */
132 static INTFLOAT is_table[2][16];
133 static INTFLOAT is_table_lsf[2][2][16];
134 static INTFLOAT csa_table[8][4];
136 static int16_t division_tab3[1<<6 ];
137 static int16_t division_tab5[1<<8 ];
138 static int16_t division_tab9[1<<11];
140 static int16_t * const division_tabs[4] = {
141 division_tab3, division_tab5, NULL, division_tab9
144 /* lower 2 bits: modulo 3, higher bits: shift */
145 static uint16_t scale_factor_modshift[64];
146 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
147 static int32_t scale_factor_mult[15][3];
148 /* mult table for layer 2 group quantization */
150 #define SCALE_GEN(v) \
151 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
153 static const int32_t scale_factor_mult2[3][3] = {
154 SCALE_GEN(4.0 / 3.0), /* 3 steps */
155 SCALE_GEN(4.0 / 5.0), /* 5 steps */
156 SCALE_GEN(4.0 / 9.0), /* 9 steps */
160 * Convert region offsets to region sizes and truncate
161 * size to big_values.
163 static void ff_region_offset2size(GranuleDef *g)
166 g->region_size[2] = 576 / 2;
167 for (i = 0; i < 3; i++) {
168 k = FFMIN(g->region_size[i], g->big_values);
169 g->region_size[i] = k - j;
174 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
176 if (g->block_type == 2)
177 g->region_size[0] = (36 / 2);
179 if (s->sample_rate_index <= 2)
180 g->region_size[0] = (36 / 2);
181 else if (s->sample_rate_index != 8)
182 g->region_size[0] = (54 / 2);
184 g->region_size[0] = (108 / 2);
186 g->region_size[1] = (576 / 2);
189 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
192 g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
193 /* should not overflow */
194 l = FFMIN(ra1 + ra2 + 2, 22);
195 g->region_size[1] = band_index_long[s->sample_rate_index][ l] >> 1;
198 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
200 if (g->block_type == 2) {
201 if (g->switch_point) {
202 /* if switched mode, we handle the 36 first samples as
203 long blocks. For 8000Hz, we handle the 48 first
204 exponents as long blocks (XXX: check this!) */
205 if (s->sample_rate_index <= 2)
207 else if (s->sample_rate_index != 8)
210 g->long_end = 4; /* 8000 Hz */
212 g->short_start = 2 + (s->sample_rate_index != 8);
223 /* layer 1 unscaling */
224 /* n = number of bits of the mantissa minus 1 */
225 static inline int l1_unscale(int n, int mant, int scale_factor)
230 shift = scale_factor_modshift[scale_factor];
233 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
235 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
236 return (int)((val + (1LL << (shift - 1))) >> shift);
239 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
243 shift = scale_factor_modshift[scale_factor];
247 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
248 /* NOTE: at this point, 0 <= shift <= 21 */
250 val = (val + (1 << (shift - 1))) >> shift;
254 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
255 static inline int l3_unscale(int value, int exponent)
260 e = table_4_3_exp [4 * value + (exponent & 3)];
261 m = table_4_3_value[4 * value + (exponent & 3)];
266 m = (m + (1 << (e - 1))) >> e;
271 static av_cold void decode_init_static(void)
276 /* scale factors table for layer 1/2 */
277 for (i = 0; i < 64; i++) {
279 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
282 scale_factor_modshift[i] = mod | (shift << 2);
285 /* scale factor multiply for layer 1 */
286 for (i = 0; i < 15; i++) {
289 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
290 scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
291 scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
292 scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
293 av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
294 scale_factor_mult[i][0],
295 scale_factor_mult[i][1],
296 scale_factor_mult[i][2]);
299 RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
301 /* huffman decode tables */
303 for (i = 1; i < 16; i++) {
304 const HuffTable *h = &mpa_huff_tables[i];
306 uint8_t tmp_bits [512];
307 uint16_t tmp_codes[512];
309 memset(tmp_bits , 0, sizeof(tmp_bits ));
310 memset(tmp_codes, 0, sizeof(tmp_codes));
315 for (x = 0; x < xsize; x++) {
316 for (y = 0; y < xsize; y++) {
317 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
318 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
323 huff_vlc[i].table = huff_vlc_tables+offset;
324 huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
325 init_vlc(&huff_vlc[i], 7, 512,
326 tmp_bits, 1, 1, tmp_codes, 2, 2,
327 INIT_VLC_USE_NEW_STATIC);
328 offset += huff_vlc_tables_sizes[i];
330 assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
333 for (i = 0; i < 2; i++) {
334 huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
335 huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
336 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
337 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
338 INIT_VLC_USE_NEW_STATIC);
339 offset += huff_quad_vlc_tables_sizes[i];
341 assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
343 for (i = 0; i < 9; i++) {
345 for (j = 0; j < 22; j++) {
346 band_index_long[i][j] = k;
347 k += band_size_long[i][j];
349 band_index_long[i][22] = k;
352 /* compute n ^ (4/3) and store it in mantissa/exp format */
354 mpegaudio_tableinit();
356 for (i = 0; i < 4; i++) {
357 if (ff_mpa_quant_bits[i] < 0) {
358 for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
359 int val1, val2, val3, steps;
361 steps = ff_mpa_quant_steps[i];
366 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
372 for (i = 0; i < 7; i++) {
376 f = tan((double)i * M_PI / 12.0);
377 v = FIXR(f / (1.0 + f));
382 is_table[1][6 - i] = v;
385 for (i = 7; i < 16; i++)
386 is_table[0][i] = is_table[1][i] = 0.0;
388 for (i = 0; i < 16; i++) {
392 for (j = 0; j < 2; j++) {
393 e = -(j + 1) * ((i + 1) >> 1);
394 f = pow(2.0, e / 4.0);
396 is_table_lsf[j][k ^ 1][i] = FIXR(f);
397 is_table_lsf[j][k ][i] = FIXR(1.0);
398 av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
399 i, j, (float) is_table_lsf[j][0][i],
400 (float) is_table_lsf[j][1][i]);
404 for (i = 0; i < 8; i++) {
407 cs = 1.0 / sqrt(1.0 + ci * ci);
410 csa_table[i][0] = FIXHR(cs/4);
411 csa_table[i][1] = FIXHR(ca/4);
412 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
413 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
415 csa_table[i][0] = cs;
416 csa_table[i][1] = ca;
417 csa_table[i][2] = ca + cs;
418 csa_table[i][3] = ca - cs;
423 static av_cold int decode_init(AVCodecContext * avctx)
425 static int initialized_tables = 0;
426 MPADecodeContext *s = avctx->priv_data;
428 if (!initialized_tables) {
429 decode_init_static();
430 initialized_tables = 1;
435 ff_mpadsp_init(&s->mpadsp);
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 + 48;
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
1157 tab0 = g0->sb_hybrid;
1158 tab1 = g1->sb_hybrid;
1159 for (i = 0; i < 576; i++) {
1162 tab0[i] = tmp0 + tmp1;
1163 tab1[i] = tmp0 - tmp1;
1169 #define AA(j) do { \
1170 float tmp0 = ptr[-1-j]; \
1171 float tmp1 = ptr[ j]; \
1172 ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
1173 ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
1176 #define AA(j) do { \
1177 int tmp0 = ptr[-1-j]; \
1178 int tmp1 = ptr[ j]; \
1179 int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
1180 ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2])); \
1181 ptr[ j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3])); \
1185 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1190 /* we antialias only "long" bands */
1191 if (g->block_type == 2) {
1192 if (!g->switch_point)
1194 /* XXX: check this for 8000Hz case */
1200 ptr = g->sb_hybrid + 18;
1201 for (i = n; i > 0; i--) {
1215 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
1216 INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1218 INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1220 int i, j, mdct_long_end, sblimit;
1222 /* find last non zero block */
1223 ptr = g->sb_hybrid + 576;
1224 ptr1 = g->sb_hybrid + 2 * 18;
1225 while (ptr >= ptr1) {
1229 if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1232 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
1234 if (g->block_type == 2) {
1235 /* XXX: check for 8000 Hz */
1236 if (g->switch_point)
1241 mdct_long_end = sblimit;
1244 s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
1245 mdct_long_end, g->switch_point,
1248 buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
1249 ptr = g->sb_hybrid + 18 * mdct_long_end;
1251 for (j = mdct_long_end; j < sblimit; j++) {
1252 /* select frequency inversion */
1253 win = RENAME(ff_mdct_win)[2 + (4 & -(j & 1))];
1254 out_ptr = sb_samples + j;
1256 for (i = 0; i < 6; i++) {
1257 *out_ptr = buf[4*i];
1260 imdct12(out2, ptr + 0);
1261 for (i = 0; i < 6; i++) {
1262 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*1)];
1263 buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
1266 imdct12(out2, ptr + 1);
1267 for (i = 0; i < 6; i++) {
1268 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*2)];
1269 buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
1272 imdct12(out2, ptr + 2);
1273 for (i = 0; i < 6; i++) {
1274 buf[4*(i + 6*0)] = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*0)];
1275 buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
1276 buf[4*(i + 6*2)] = 0;
1279 buf += (j&3) != 3 ? 1 : (4*18-3);
1282 for (j = sblimit; j < SBLIMIT; j++) {
1284 out_ptr = sb_samples + j;
1285 for (i = 0; i < 18; i++) {
1286 *out_ptr = buf[4*i];
1290 buf += (j&3) != 3 ? 1 : (4*18-3);
1294 /* main layer3 decoding function */
1295 static int mp_decode_layer3(MPADecodeContext *s)
1297 int nb_granules, main_data_begin;
1298 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1300 int16_t exponents[576]; //FIXME try INTFLOAT
1302 /* read side info */
1304 main_data_begin = get_bits(&s->gb, 8);
1305 skip_bits(&s->gb, s->nb_channels);
1308 main_data_begin = get_bits(&s->gb, 9);
1309 if (s->nb_channels == 2)
1310 skip_bits(&s->gb, 3);
1312 skip_bits(&s->gb, 5);
1314 for (ch = 0; ch < s->nb_channels; ch++) {
1315 s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
1316 s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1320 for (gr = 0; gr < nb_granules; gr++) {
1321 for (ch = 0; ch < s->nb_channels; ch++) {
1322 av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1323 g = &s->granules[ch][gr];
1324 g->part2_3_length = get_bits(&s->gb, 12);
1325 g->big_values = get_bits(&s->gb, 9);
1326 if (g->big_values > 288) {
1327 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1328 return AVERROR_INVALIDDATA;
1331 g->global_gain = get_bits(&s->gb, 8);
1332 /* if MS stereo only is selected, we precompute the
1333 1/sqrt(2) renormalization factor */
1334 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1336 g->global_gain -= 2;
1338 g->scalefac_compress = get_bits(&s->gb, 9);
1340 g->scalefac_compress = get_bits(&s->gb, 4);
1341 blocksplit_flag = get_bits1(&s->gb);
1342 if (blocksplit_flag) {
1343 g->block_type = get_bits(&s->gb, 2);
1344 if (g->block_type == 0) {
1345 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1346 return AVERROR_INVALIDDATA;
1348 g->switch_point = get_bits1(&s->gb);
1349 for (i = 0; i < 2; i++)
1350 g->table_select[i] = get_bits(&s->gb, 5);
1351 for (i = 0; i < 3; i++)
1352 g->subblock_gain[i] = get_bits(&s->gb, 3);
1353 ff_init_short_region(s, g);
1355 int region_address1, region_address2;
1357 g->switch_point = 0;
1358 for (i = 0; i < 3; i++)
1359 g->table_select[i] = get_bits(&s->gb, 5);
1360 /* compute huffman coded region sizes */
1361 region_address1 = get_bits(&s->gb, 4);
1362 region_address2 = get_bits(&s->gb, 3);
1363 av_dlog(s->avctx, "region1=%d region2=%d\n",
1364 region_address1, region_address2);
1365 ff_init_long_region(s, g, region_address1, region_address2);
1367 ff_region_offset2size(g);
1368 ff_compute_band_indexes(s, g);
1372 g->preflag = get_bits1(&s->gb);
1373 g->scalefac_scale = get_bits1(&s->gb);
1374 g->count1table_select = get_bits1(&s->gb);
1375 av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1376 g->block_type, g->switch_point);
1381 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1382 int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0, EXTRABYTES);
1383 assert((get_bits_count(&s->gb) & 7) == 0);
1384 /* now we get bits from the main_data_begin offset */
1385 av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1386 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1388 memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1390 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1391 #if !UNCHECKED_BITSTREAM_READER
1392 s->gb.size_in_bits_plus8 += extrasize * 8;
1394 skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
1397 for (gr = 0; gr < nb_granules; gr++) {
1398 for (ch = 0; ch < s->nb_channels; ch++) {
1399 g = &s->granules[ch][gr];
1400 if (get_bits_count(&s->gb) < 0) {
1401 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",
1402 main_data_begin, s->last_buf_size, gr);
1403 skip_bits_long(&s->gb, g->part2_3_length);
1404 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1405 if (get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer) {
1406 skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
1408 s->in_gb.buffer = NULL;
1413 bits_pos = get_bits_count(&s->gb);
1417 int slen, slen1, slen2;
1419 /* MPEG1 scale factors */
1420 slen1 = slen_table[0][g->scalefac_compress];
1421 slen2 = slen_table[1][g->scalefac_compress];
1422 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1423 if (g->block_type == 2) {
1424 n = g->switch_point ? 17 : 18;
1427 for (i = 0; i < n; i++)
1428 g->scale_factors[j++] = get_bits(&s->gb, slen1);
1430 for (i = 0; i < n; i++)
1431 g->scale_factors[j++] = 0;
1434 for (i = 0; i < 18; i++)
1435 g->scale_factors[j++] = get_bits(&s->gb, slen2);
1436 for (i = 0; i < 3; i++)
1437 g->scale_factors[j++] = 0;
1439 for (i = 0; i < 21; i++)
1440 g->scale_factors[j++] = 0;
1443 sc = s->granules[ch][0].scale_factors;
1445 for (k = 0; k < 4; k++) {
1447 if ((g->scfsi & (0x8 >> k)) == 0) {
1448 slen = (k < 2) ? slen1 : slen2;
1450 for (i = 0; i < n; i++)
1451 g->scale_factors[j++] = get_bits(&s->gb, slen);
1453 for (i = 0; i < n; i++)
1454 g->scale_factors[j++] = 0;
1457 /* simply copy from last granule */
1458 for (i = 0; i < n; i++) {
1459 g->scale_factors[j] = sc[j];
1464 g->scale_factors[j++] = 0;
1467 int tindex, tindex2, slen[4], sl, sf;
1469 /* LSF scale factors */
1470 if (g->block_type == 2)
1471 tindex = g->switch_point ? 2 : 1;
1475 sf = g->scalefac_compress;
1476 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1477 /* intensity stereo case */
1480 lsf_sf_expand(slen, sf, 6, 6, 0);
1482 } else if (sf < 244) {
1483 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1486 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1492 lsf_sf_expand(slen, sf, 5, 4, 4);
1494 } else if (sf < 500) {
1495 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1498 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1505 for (k = 0; k < 4; k++) {
1506 n = lsf_nsf_table[tindex2][tindex][k];
1509 for (i = 0; i < n; i++)
1510 g->scale_factors[j++] = get_bits(&s->gb, sl);
1512 for (i = 0; i < n; i++)
1513 g->scale_factors[j++] = 0;
1516 /* XXX: should compute exact size */
1518 g->scale_factors[j] = 0;
1521 exponents_from_scale_factors(s, g, exponents);
1523 /* read Huffman coded residue */
1524 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1527 if (s->nb_channels == 2)
1528 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1530 for (ch = 0; ch < s->nb_channels; ch++) {
1531 g = &s->granules[ch][gr];
1533 reorder_block(s, g);
1534 compute_antialias(s, g);
1535 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1538 if (get_bits_count(&s->gb) < 0)
1539 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1540 return nb_granules * 18;
1543 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1544 const uint8_t *buf, int buf_size)
1546 int i, nb_frames, ch, ret;
1547 OUT_INT *samples_ptr;
1549 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1551 /* skip error protection field */
1552 if (s->error_protection)
1553 skip_bits(&s->gb, 16);
1557 s->avctx->frame_size = 384;
1558 nb_frames = mp_decode_layer1(s);
1561 s->avctx->frame_size = 1152;
1562 nb_frames = mp_decode_layer2(s);
1565 s->avctx->frame_size = s->lsf ? 576 : 1152;
1567 nb_frames = mp_decode_layer3(s);
1570 if (s->in_gb.buffer) {
1571 align_get_bits(&s->gb);
1572 i = get_bits_left(&s->gb)>>3;
1573 if (i >= 0 && i <= BACKSTEP_SIZE) {
1574 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1577 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1579 s->in_gb.buffer = NULL;
1582 align_get_bits(&s->gb);
1583 assert((get_bits_count(&s->gb) & 7) == 0);
1584 i = get_bits_left(&s->gb) >> 3;
1586 if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1588 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1589 i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1591 assert(i <= buf_size - HEADER_SIZE && i >= 0);
1592 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1593 s->last_buf_size += i;
1596 /* get output buffer */
1598 s->frame.nb_samples = s->avctx->frame_size;
1599 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1600 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1603 samples = (OUT_INT *)s->frame.data[0];
1606 /* apply the synthesis filter */
1607 for (ch = 0; ch < s->nb_channels; ch++) {
1608 samples_ptr = samples + ch;
1609 for (i = 0; i < nb_frames; i++) {
1610 RENAME(ff_mpa_synth_filter)(
1612 s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1613 RENAME(ff_mpa_synth_window), &s->dither_state,
1614 samples_ptr, s->nb_channels,
1615 s->sb_samples[ch][i]);
1616 samples_ptr += 32 * s->nb_channels;
1620 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1623 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1626 const uint8_t *buf = avpkt->data;
1627 int buf_size = avpkt->size;
1628 MPADecodeContext *s = avctx->priv_data;
1632 if (buf_size < HEADER_SIZE)
1633 return AVERROR_INVALIDDATA;
1635 header = AV_RB32(buf);
1636 if (ff_mpa_check_header(header) < 0) {
1637 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1638 return AVERROR_INVALIDDATA;
1641 if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1642 /* free format: prepare to compute frame size */
1644 return AVERROR_INVALIDDATA;
1646 /* update codec info */
1647 avctx->channels = s->nb_channels;
1648 avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1649 if (!avctx->bit_rate)
1650 avctx->bit_rate = s->bit_rate;
1651 avctx->sub_id = s->layer;
1653 if (s->frame_size <= 0 || s->frame_size > buf_size) {
1654 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1655 return AVERROR_INVALIDDATA;
1656 }else if(s->frame_size < buf_size){
1657 av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
1658 buf_size= s->frame_size;
1661 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1662 if (out_size >= 0) {
1664 *(AVFrame *)data = s->frame;
1665 avctx->sample_rate = s->sample_rate;
1666 //FIXME maybe move the other codec info stuff from above here too
1668 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1669 /* Only return an error if the bad frame makes up the whole packet.
1670 If there is more data in the packet, just consume the bad frame
1671 instead of returning an error, which would discard the whole
1674 if (buf_size == avpkt->size)
1681 static void flush(AVCodecContext *avctx)
1683 MPADecodeContext *s = avctx->priv_data;
1684 memset(s->synth_buf, 0, sizeof(s->synth_buf));
1685 s->last_buf_size = 0;
1688 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1689 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1690 int *got_frame_ptr, AVPacket *avpkt)
1692 const uint8_t *buf = avpkt->data;
1693 int buf_size = avpkt->size;
1694 MPADecodeContext *s = avctx->priv_data;
1700 // Discard too short frames
1701 if (buf_size < HEADER_SIZE) {
1702 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1703 return AVERROR_INVALIDDATA;
1707 if (len > MPA_MAX_CODED_FRAME_SIZE)
1708 len = MPA_MAX_CODED_FRAME_SIZE;
1710 // Get header and restore sync word
1711 header = AV_RB32(buf) | 0xffe00000;
1713 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1714 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1715 return AVERROR_INVALIDDATA;
1718 avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1719 /* update codec info */
1720 avctx->sample_rate = s->sample_rate;
1721 avctx->channels = s->nb_channels;
1722 if (!avctx->bit_rate)
1723 avctx->bit_rate = s->bit_rate;
1724 avctx->sub_id = s->layer;
1726 s->frame_size = len;
1728 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1731 *(AVFrame *)data = s->frame;
1735 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1737 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1740 * Context for MP3On4 decoder
1742 typedef struct MP3On4DecodeContext {
1744 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
1745 int syncword; ///< syncword patch
1746 const uint8_t *coff; ///< channel offsets in output buffer
1747 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1748 OUT_INT *decoded_buf; ///< output buffer for decoded samples
1749 } MP3On4DecodeContext;
1751 #include "mpeg4audio.h"
1753 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1755 /* number of mp3 decoder instances */
1756 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1758 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1759 static const uint8_t chan_offset[8][5] = {
1764 { 2, 0, 3 }, // C FLR BS
1765 { 2, 0, 3 }, // C FLR BLRS
1766 { 2, 0, 4, 3 }, // C FLR BLRS LFE
1767 { 2, 0, 6, 4, 3 }, // C FLR BLRS BLR LFE
1770 /* mp3on4 channel layouts */
1771 static const int16_t chan_layout[8] = {
1774 AV_CH_LAYOUT_STEREO,
1775 AV_CH_LAYOUT_SURROUND,
1776 AV_CH_LAYOUT_4POINT0,
1777 AV_CH_LAYOUT_5POINT0,
1778 AV_CH_LAYOUT_5POINT1,
1779 AV_CH_LAYOUT_7POINT1
1782 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1784 MP3On4DecodeContext *s = avctx->priv_data;
1787 for (i = 0; i < s->frames; i++)
1788 av_free(s->mp3decctx[i]);
1790 av_freep(&s->decoded_buf);
1796 static int decode_init_mp3on4(AVCodecContext * avctx)
1798 MP3On4DecodeContext *s = avctx->priv_data;
1799 MPEG4AudioConfig cfg;
1802 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1803 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1804 return AVERROR_INVALIDDATA;
1807 avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1808 avctx->extradata_size * 8, 1);
1809 if (!cfg.chan_config || cfg.chan_config > 7) {
1810 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1811 return AVERROR_INVALIDDATA;
1813 s->frames = mp3Frames[cfg.chan_config];
1814 s->coff = chan_offset[cfg.chan_config];
1815 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
1816 avctx->channel_layout = chan_layout[cfg.chan_config];
1818 if (cfg.sample_rate < 16000)
1819 s->syncword = 0xffe00000;
1821 s->syncword = 0xfff00000;
1823 /* Init the first mp3 decoder in standard way, so that all tables get builded
1824 * We replace avctx->priv_data with the context of the first decoder so that
1825 * decode_init() does not have to be changed.
1826 * Other decoders will be initialized here copying data from the first context
1828 // Allocate zeroed memory for the first decoder context
1829 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1830 if (!s->mp3decctx[0])
1832 // Put decoder context in place to make init_decode() happy
1833 avctx->priv_data = s->mp3decctx[0];
1835 s->frame = avctx->coded_frame;
1836 // Restore mp3on4 context pointer
1837 avctx->priv_data = s;
1838 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1840 /* Create a separate codec/context for each frame (first is already ok).
1841 * Each frame is 1 or 2 channels - up to 5 frames allowed
1843 for (i = 1; i < s->frames; i++) {
1844 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1845 if (!s->mp3decctx[i])
1847 s->mp3decctx[i]->adu_mode = 1;
1848 s->mp3decctx[i]->avctx = avctx;
1849 s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1852 /* Allocate buffer for multi-channel output if needed */
1853 if (s->frames > 1) {
1854 s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1855 sizeof(*s->decoded_buf));
1856 if (!s->decoded_buf)
1862 decode_close_mp3on4(avctx);
1863 return AVERROR(ENOMEM);
1867 static void flush_mp3on4(AVCodecContext *avctx)
1870 MP3On4DecodeContext *s = avctx->priv_data;
1872 for (i = 0; i < s->frames; i++) {
1873 MPADecodeContext *m = s->mp3decctx[i];
1874 memset(m->synth_buf, 0, sizeof(m->synth_buf));
1875 m->last_buf_size = 0;
1880 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
1881 int *got_frame_ptr, AVPacket *avpkt)
1883 const uint8_t *buf = avpkt->data;
1884 int buf_size = avpkt->size;
1885 MP3On4DecodeContext *s = avctx->priv_data;
1886 MPADecodeContext *m;
1887 int fsize, len = buf_size, out_size = 0;
1889 OUT_INT *out_samples;
1890 OUT_INT *outptr, *bp;
1891 int fr, j, n, ch, ret;
1893 /* get output buffer */
1894 s->frame->nb_samples = MPA_FRAME_SIZE;
1895 if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
1896 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1899 out_samples = (OUT_INT *)s->frame->data[0];
1901 // Discard too short frames
1902 if (buf_size < HEADER_SIZE)
1903 return AVERROR_INVALIDDATA;
1905 // If only one decoder interleave is not needed
1906 outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1908 avctx->bit_rate = 0;
1911 for (fr = 0; fr < s->frames; fr++) {
1912 fsize = AV_RB16(buf) >> 4;
1913 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1914 m = s->mp3decctx[fr];
1917 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1919 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1922 avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1924 if (ch + m->nb_channels > avctx->channels) {
1925 av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1927 return AVERROR_INVALIDDATA;
1929 ch += m->nb_channels;
1931 out_size += mp_decode_frame(m, outptr, buf, fsize);
1935 if (s->frames > 1) {
1936 n = m->avctx->frame_size*m->nb_channels;
1937 /* interleave output data */
1938 bp = out_samples + s->coff[fr];
1939 if (m->nb_channels == 1) {
1940 for (j = 0; j < n; j++) {
1941 *bp = s->decoded_buf[j];
1942 bp += avctx->channels;
1945 for (j = 0; j < n; j++) {
1946 bp[0] = s->decoded_buf[j++];
1947 bp[1] = s->decoded_buf[j];
1948 bp += avctx->channels;
1952 avctx->bit_rate += m->bit_rate;
1955 /* update codec info */
1956 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
1958 s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
1960 *(AVFrame *)data = *s->frame;
1964 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
1967 #if CONFIG_MP1_DECODER
1968 AVCodec ff_mp1_decoder = {
1970 .type = AVMEDIA_TYPE_AUDIO,
1972 .priv_data_size = sizeof(MPADecodeContext),
1973 .init = decode_init,
1974 .decode = decode_frame,
1975 .capabilities = CODEC_CAP_DR1,
1977 .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
1980 #if CONFIG_MP2_DECODER
1981 AVCodec ff_mp2_decoder = {
1983 .type = AVMEDIA_TYPE_AUDIO,
1985 .priv_data_size = sizeof(MPADecodeContext),
1986 .init = decode_init,
1987 .decode = decode_frame,
1988 .capabilities = CODEC_CAP_DR1,
1990 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
1993 #if CONFIG_MP3_DECODER
1994 AVCodec ff_mp3_decoder = {
1996 .type = AVMEDIA_TYPE_AUDIO,
1998 .priv_data_size = sizeof(MPADecodeContext),
1999 .init = decode_init,
2000 .decode = decode_frame,
2001 .capabilities = CODEC_CAP_DR1,
2003 .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2006 #if CONFIG_MP3ADU_DECODER
2007 AVCodec ff_mp3adu_decoder = {
2009 .type = AVMEDIA_TYPE_AUDIO,
2010 .id = CODEC_ID_MP3ADU,
2011 .priv_data_size = sizeof(MPADecodeContext),
2012 .init = decode_init,
2013 .decode = decode_frame_adu,
2014 .capabilities = CODEC_CAP_DR1,
2016 .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2019 #if CONFIG_MP3ON4_DECODER
2020 AVCodec ff_mp3on4_decoder = {
2022 .type = AVMEDIA_TYPE_AUDIO,
2023 .id = CODEC_ID_MP3ON4,
2024 .priv_data_size = sizeof(MP3On4DecodeContext),
2025 .init = decode_init_mp3on4,
2026 .close = decode_close_mp3on4,
2027 .decode = decode_frame_mp3on4,
2028 .capabilities = CODEC_CAP_DR1,
2029 .flush = flush_mp3on4,
2030 .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),