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"
28 #include "libavutil/avassert.h"
29 #include "libavutil/libm.h"
33 #include "mpegaudiodsp.h"
38 * - test lsf / mpeg25 extensively.
41 #include "mpegaudio.h"
42 #include "mpegaudiodecheader.h"
44 #define BACKSTEP_SIZE 512
46 #define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
48 /* layer 3 "granule" */
49 typedef struct GranuleDef {
54 int scalefac_compress;
59 uint8_t scalefac_scale;
60 uint8_t count1table_select;
61 int region_size[3]; /* number of huffman codes in each region */
63 int short_start, long_end; /* long/short band indexes */
64 uint8_t scale_factors[40];
65 DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
68 typedef struct MPADecodeContext {
70 uint8_t last_buf[LAST_BUF_SIZE];
72 /* next header (used in free format parsing) */
73 uint32_t free_format_next_header;
76 DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
77 int synth_buf_offset[MPA_MAX_CHANNELS];
78 DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
79 INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
80 GranuleDef granules[2][2]; /* Used in Layer 3 */
81 int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
84 AVCodecContext* avctx;
91 # define SHR(a,b) ((a)*(1.0f/(1<<(b))))
92 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
93 # define FIXR(x) ((float)(x))
94 # define FIXHR(x) ((float)(x))
95 # define MULH3(x, y, s) ((s)*(y)*(x))
96 # define MULLx(x, y, s) ((y)*(x))
97 # define RENAME(a) a ## _float
98 # define OUT_FMT AV_SAMPLE_FMT_FLT
100 # define SHR(a,b) ((a)>>(b))
101 /* WARNING: only correct for positive numbers */
102 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
103 # define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
104 # define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
105 # define MULH3(x, y, s) MULH((s)*(x), y)
106 # define MULLx(x, y, s) MULL(x,y,s)
107 # define RENAME(a) a ## _fixed
108 # define OUT_FMT AV_SAMPLE_FMT_S16
113 #define HEADER_SIZE 4
115 #include "mpegaudiodata.h"
116 #include "mpegaudiodectab.h"
118 /* vlc structure for decoding layer 3 huffman tables */
119 static VLC huff_vlc[16];
120 static VLC_TYPE huff_vlc_tables[
121 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
122 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
124 static const int huff_vlc_tables_sizes[16] = {
125 0, 128, 128, 128, 130, 128, 154, 166,
126 142, 204, 190, 170, 542, 460, 662, 414
128 static VLC huff_quad_vlc[2];
129 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
130 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
131 /* computed from band_size_long */
132 static uint16_t band_index_long[9][23];
133 #include "mpegaudio_tablegen.h"
134 /* intensity stereo coef table */
135 static INTFLOAT is_table[2][16];
136 static INTFLOAT is_table_lsf[2][2][16];
137 static INTFLOAT csa_table[8][4];
139 static int16_t division_tab3[1<<6 ];
140 static int16_t division_tab5[1<<8 ];
141 static int16_t division_tab9[1<<11];
143 static int16_t * const division_tabs[4] = {
144 division_tab3, division_tab5, NULL, division_tab9
147 /* lower 2 bits: modulo 3, higher bits: shift */
148 static uint16_t scale_factor_modshift[64];
149 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
150 static int32_t scale_factor_mult[15][3];
151 /* mult table for layer 2 group quantization */
153 #define SCALE_GEN(v) \
154 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
156 static const int32_t scale_factor_mult2[3][3] = {
157 SCALE_GEN(4.0 / 3.0), /* 3 steps */
158 SCALE_GEN(4.0 / 5.0), /* 5 steps */
159 SCALE_GEN(4.0 / 9.0), /* 9 steps */
163 * Convert region offsets to region sizes and truncate
164 * size to big_values.
166 static void ff_region_offset2size(GranuleDef *g)
169 g->region_size[2] = 576 / 2;
170 for (i = 0; i < 3; i++) {
171 k = FFMIN(g->region_size[i], g->big_values);
172 g->region_size[i] = k - j;
177 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
179 if (g->block_type == 2) {
180 if (s->sample_rate_index != 8)
181 g->region_size[0] = (36 / 2);
183 g->region_size[0] = (72 / 2);
185 if (s->sample_rate_index <= 2)
186 g->region_size[0] = (36 / 2);
187 else if (s->sample_rate_index != 8)
188 g->region_size[0] = (54 / 2);
190 g->region_size[0] = (108 / 2);
192 g->region_size[1] = (576 / 2);
195 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
198 g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
199 /* should not overflow */
200 l = FFMIN(ra1 + ra2 + 2, 22);
201 g->region_size[1] = band_index_long[s->sample_rate_index][ l] >> 1;
204 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
206 if (g->block_type == 2) {
207 if (g->switch_point) {
208 /* if switched mode, we handle the 36 first samples as
209 long blocks. For 8000Hz, we handle the 72 first
210 exponents as long blocks */
211 if (s->sample_rate_index <= 2)
216 g->short_start = 2 + (s->sample_rate_index != 8);
227 /* layer 1 unscaling */
228 /* n = number of bits of the mantissa minus 1 */
229 static inline int l1_unscale(int n, int mant, int scale_factor)
234 shift = scale_factor_modshift[scale_factor];
237 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
239 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
240 return (int)((val + (1LL << (shift - 1))) >> shift);
243 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
247 shift = scale_factor_modshift[scale_factor];
251 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
252 /* NOTE: at this point, 0 <= shift <= 21 */
254 val = (val + (1 << (shift - 1))) >> shift;
258 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
259 static inline int l3_unscale(int value, int exponent)
264 e = table_4_3_exp [4 * value + (exponent & 3)];
265 m = table_4_3_value[4 * value + (exponent & 3)];
269 av_log(0, AV_LOG_WARNING, "l3_unscale: e is %d\n", e);
273 m = (m + (1 << (e - 1))) >> e;
278 static av_cold void decode_init_static(void)
283 /* scale factors table for layer 1/2 */
284 for (i = 0; i < 64; i++) {
286 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
289 scale_factor_modshift[i] = mod | (shift << 2);
292 /* scale factor multiply for layer 1 */
293 for (i = 0; i < 15; i++) {
296 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
297 scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
298 scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
299 scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
300 av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
301 scale_factor_mult[i][0],
302 scale_factor_mult[i][1],
303 scale_factor_mult[i][2]);
306 RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
308 /* huffman decode tables */
310 for (i = 1; i < 16; i++) {
311 const HuffTable *h = &mpa_huff_tables[i];
313 uint8_t tmp_bits [512] = { 0 };
314 uint16_t tmp_codes[512] = { 0 };
319 for (x = 0; x < xsize; x++) {
320 for (y = 0; y < xsize; y++) {
321 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
322 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
327 huff_vlc[i].table = huff_vlc_tables+offset;
328 huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
329 init_vlc(&huff_vlc[i], 7, 512,
330 tmp_bits, 1, 1, tmp_codes, 2, 2,
331 INIT_VLC_USE_NEW_STATIC);
332 offset += huff_vlc_tables_sizes[i];
334 av_assert0(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
337 for (i = 0; i < 2; i++) {
338 huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
339 huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
340 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
341 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
342 INIT_VLC_USE_NEW_STATIC);
343 offset += huff_quad_vlc_tables_sizes[i];
345 av_assert0(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
347 for (i = 0; i < 9; i++) {
349 for (j = 0; j < 22; j++) {
350 band_index_long[i][j] = k;
351 k += band_size_long[i][j];
353 band_index_long[i][22] = k;
356 /* compute n ^ (4/3) and store it in mantissa/exp format */
358 mpegaudio_tableinit();
360 for (i = 0; i < 4; i++) {
361 if (ff_mpa_quant_bits[i] < 0) {
362 for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
363 int val1, val2, val3, steps;
365 steps = ff_mpa_quant_steps[i];
370 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
376 for (i = 0; i < 7; i++) {
380 f = tan((double)i * M_PI / 12.0);
381 v = FIXR(f / (1.0 + f));
386 is_table[1][6 - i] = v;
389 for (i = 7; i < 16; i++)
390 is_table[0][i] = is_table[1][i] = 0.0;
392 for (i = 0; i < 16; i++) {
396 for (j = 0; j < 2; j++) {
397 e = -(j + 1) * ((i + 1) >> 1);
400 is_table_lsf[j][k ^ 1][i] = FIXR(f);
401 is_table_lsf[j][k ][i] = FIXR(1.0);
402 av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
403 i, j, (float) is_table_lsf[j][0][i],
404 (float) is_table_lsf[j][1][i]);
408 for (i = 0; i < 8; i++) {
411 cs = 1.0 / sqrt(1.0 + ci * ci);
414 csa_table[i][0] = FIXHR(cs/4);
415 csa_table[i][1] = FIXHR(ca/4);
416 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
417 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
419 csa_table[i][0] = cs;
420 csa_table[i][1] = ca;
421 csa_table[i][2] = ca + cs;
422 csa_table[i][3] = ca - cs;
427 static av_cold int decode_init(AVCodecContext * avctx)
429 static int initialized_tables = 0;
430 MPADecodeContext *s = avctx->priv_data;
432 if (!initialized_tables) {
433 decode_init_static();
434 initialized_tables = 1;
439 ff_mpadsp_init(&s->mpadsp);
440 ff_dsputil_init(&s->dsp, avctx);
442 avctx->sample_fmt= OUT_FMT;
443 s->err_recognition = avctx->err_recognition;
445 if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
448 avcodec_get_frame_defaults(&s->frame);
449 avctx->coded_frame = &s->frame;
454 #define C3 FIXHR(0.86602540378443864676/2)
455 #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
456 #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
457 #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
459 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
461 static void imdct12(INTFLOAT *out, INTFLOAT *in)
463 INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
466 in1 = in[1*3] + in[0*3];
467 in2 = in[2*3] + in[1*3];
468 in3 = in[3*3] + in[2*3];
469 in4 = in[4*3] + in[3*3];
470 in5 = in[5*3] + in[4*3];
474 in2 = MULH3(in2, C3, 2);
475 in3 = MULH3(in3, C3, 4);
478 t2 = MULH3(in1 - in5, C4, 2);
488 in1 = MULH3(in5 + in3, C5, 1);
495 in5 = MULH3(in5 - in3, C6, 2);
502 /* return the number of decoded frames */
503 static int mp_decode_layer1(MPADecodeContext *s)
505 int bound, i, v, n, ch, j, mant;
506 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
507 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
509 if (s->mode == MPA_JSTEREO)
510 bound = (s->mode_ext + 1) * 4;
514 /* allocation bits */
515 for (i = 0; i < bound; i++) {
516 for (ch = 0; ch < s->nb_channels; ch++) {
517 allocation[ch][i] = get_bits(&s->gb, 4);
520 for (i = bound; i < SBLIMIT; i++)
521 allocation[0][i] = get_bits(&s->gb, 4);
524 for (i = 0; i < bound; i++) {
525 for (ch = 0; ch < s->nb_channels; ch++) {
526 if (allocation[ch][i])
527 scale_factors[ch][i] = get_bits(&s->gb, 6);
530 for (i = bound; i < SBLIMIT; i++) {
531 if (allocation[0][i]) {
532 scale_factors[0][i] = get_bits(&s->gb, 6);
533 scale_factors[1][i] = get_bits(&s->gb, 6);
537 /* compute samples */
538 for (j = 0; j < 12; j++) {
539 for (i = 0; i < bound; i++) {
540 for (ch = 0; ch < s->nb_channels; ch++) {
541 n = allocation[ch][i];
543 mant = get_bits(&s->gb, n + 1);
544 v = l1_unscale(n, mant, scale_factors[ch][i]);
548 s->sb_samples[ch][j][i] = v;
551 for (i = bound; i < SBLIMIT; i++) {
552 n = allocation[0][i];
554 mant = get_bits(&s->gb, n + 1);
555 v = l1_unscale(n, mant, scale_factors[0][i]);
556 s->sb_samples[0][j][i] = v;
557 v = l1_unscale(n, mant, scale_factors[1][i]);
558 s->sb_samples[1][j][i] = v;
560 s->sb_samples[0][j][i] = 0;
561 s->sb_samples[1][j][i] = 0;
568 static int mp_decode_layer2(MPADecodeContext *s)
570 int sblimit; /* number of used subbands */
571 const unsigned char *alloc_table;
572 int table, bit_alloc_bits, i, j, ch, bound, v;
573 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
574 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
575 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
576 int scale, qindex, bits, steps, k, l, m, b;
578 /* select decoding table */
579 table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
580 s->sample_rate, s->lsf);
581 sblimit = ff_mpa_sblimit_table[table];
582 alloc_table = ff_mpa_alloc_tables[table];
584 if (s->mode == MPA_JSTEREO)
585 bound = (s->mode_ext + 1) * 4;
589 av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
595 /* parse bit allocation */
597 for (i = 0; i < bound; i++) {
598 bit_alloc_bits = alloc_table[j];
599 for (ch = 0; ch < s->nb_channels; ch++)
600 bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
601 j += 1 << bit_alloc_bits;
603 for (i = bound; i < sblimit; i++) {
604 bit_alloc_bits = alloc_table[j];
605 v = get_bits(&s->gb, bit_alloc_bits);
608 j += 1 << bit_alloc_bits;
612 for (i = 0; i < sblimit; i++) {
613 for (ch = 0; ch < s->nb_channels; ch++) {
614 if (bit_alloc[ch][i])
615 scale_code[ch][i] = get_bits(&s->gb, 2);
620 for (i = 0; i < sblimit; i++) {
621 for (ch = 0; ch < s->nb_channels; ch++) {
622 if (bit_alloc[ch][i]) {
623 sf = scale_factors[ch][i];
624 switch (scale_code[ch][i]) {
627 sf[0] = get_bits(&s->gb, 6);
628 sf[1] = get_bits(&s->gb, 6);
629 sf[2] = get_bits(&s->gb, 6);
632 sf[0] = get_bits(&s->gb, 6);
637 sf[0] = get_bits(&s->gb, 6);
638 sf[2] = get_bits(&s->gb, 6);
642 sf[0] = get_bits(&s->gb, 6);
643 sf[2] = get_bits(&s->gb, 6);
652 for (k = 0; k < 3; k++) {
653 for (l = 0; l < 12; l += 3) {
655 for (i = 0; i < bound; i++) {
656 bit_alloc_bits = alloc_table[j];
657 for (ch = 0; ch < s->nb_channels; ch++) {
658 b = bit_alloc[ch][i];
660 scale = scale_factors[ch][i][k];
661 qindex = alloc_table[j+b];
662 bits = ff_mpa_quant_bits[qindex];
665 /* 3 values at the same time */
666 v = get_bits(&s->gb, -bits);
667 v2 = division_tabs[qindex][v];
668 steps = ff_mpa_quant_steps[qindex];
670 s->sb_samples[ch][k * 12 + l + 0][i] =
671 l2_unscale_group(steps, v2 & 15, scale);
672 s->sb_samples[ch][k * 12 + l + 1][i] =
673 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
674 s->sb_samples[ch][k * 12 + l + 2][i] =
675 l2_unscale_group(steps, v2 >> 8 , scale);
677 for (m = 0; m < 3; m++) {
678 v = get_bits(&s->gb, bits);
679 v = l1_unscale(bits - 1, v, scale);
680 s->sb_samples[ch][k * 12 + l + m][i] = v;
684 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
685 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
686 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
689 /* next subband in alloc table */
690 j += 1 << bit_alloc_bits;
692 /* XXX: find a way to avoid this duplication of code */
693 for (i = bound; i < sblimit; i++) {
694 bit_alloc_bits = alloc_table[j];
697 int mant, scale0, scale1;
698 scale0 = scale_factors[0][i][k];
699 scale1 = scale_factors[1][i][k];
700 qindex = alloc_table[j+b];
701 bits = ff_mpa_quant_bits[qindex];
703 /* 3 values at the same time */
704 v = get_bits(&s->gb, -bits);
705 steps = ff_mpa_quant_steps[qindex];
708 s->sb_samples[0][k * 12 + l + 0][i] =
709 l2_unscale_group(steps, mant, scale0);
710 s->sb_samples[1][k * 12 + l + 0][i] =
711 l2_unscale_group(steps, mant, scale1);
714 s->sb_samples[0][k * 12 + l + 1][i] =
715 l2_unscale_group(steps, mant, scale0);
716 s->sb_samples[1][k * 12 + l + 1][i] =
717 l2_unscale_group(steps, mant, scale1);
718 s->sb_samples[0][k * 12 + l + 2][i] =
719 l2_unscale_group(steps, v, scale0);
720 s->sb_samples[1][k * 12 + l + 2][i] =
721 l2_unscale_group(steps, v, scale1);
723 for (m = 0; m < 3; m++) {
724 mant = get_bits(&s->gb, bits);
725 s->sb_samples[0][k * 12 + l + m][i] =
726 l1_unscale(bits - 1, mant, scale0);
727 s->sb_samples[1][k * 12 + l + m][i] =
728 l1_unscale(bits - 1, mant, scale1);
732 s->sb_samples[0][k * 12 + l + 0][i] = 0;
733 s->sb_samples[0][k * 12 + l + 1][i] = 0;
734 s->sb_samples[0][k * 12 + l + 2][i] = 0;
735 s->sb_samples[1][k * 12 + l + 0][i] = 0;
736 s->sb_samples[1][k * 12 + l + 1][i] = 0;
737 s->sb_samples[1][k * 12 + l + 2][i] = 0;
739 /* next subband in alloc table */
740 j += 1 << bit_alloc_bits;
742 /* fill remaining samples to zero */
743 for (i = sblimit; i < SBLIMIT; i++) {
744 for (ch = 0; ch < s->nb_channels; ch++) {
745 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
746 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
747 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
755 #define SPLIT(dst,sf,n) \
757 int m = (sf * 171) >> 9; \
760 } else if (n == 4) { \
763 } else if (n == 5) { \
764 int m = (sf * 205) >> 10; \
767 } else if (n == 6) { \
768 int m = (sf * 171) >> 10; \
775 static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
778 SPLIT(slen[3], sf, n3)
779 SPLIT(slen[2], sf, n2)
780 SPLIT(slen[1], sf, n1)
784 static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
787 const uint8_t *bstab, *pretab;
788 int len, i, j, k, l, v0, shift, gain, gains[3];
792 gain = g->global_gain - 210;
793 shift = g->scalefac_scale + 1;
795 bstab = band_size_long[s->sample_rate_index];
796 pretab = mpa_pretab[g->preflag];
797 for (i = 0; i < g->long_end; i++) {
798 v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
800 for (j = len; j > 0; j--)
804 if (g->short_start < 13) {
805 bstab = band_size_short[s->sample_rate_index];
806 gains[0] = gain - (g->subblock_gain[0] << 3);
807 gains[1] = gain - (g->subblock_gain[1] << 3);
808 gains[2] = gain - (g->subblock_gain[2] << 3);
810 for (i = g->short_start; i < 13; i++) {
812 for (l = 0; l < 3; l++) {
813 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
814 for (j = len; j > 0; j--)
821 /* handle n = 0 too */
822 static inline int get_bitsz(GetBitContext *s, int n)
824 return n ? get_bits(s, n) : 0;
828 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
831 if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
833 s->in_gb.buffer = NULL;
834 av_assert2((get_bits_count(&s->gb) & 7) == 0);
835 skip_bits_long(&s->gb, *pos - *end_pos);
837 *end_pos = *end_pos2 + get_bits_count(&s->gb) - *pos;
838 *pos = get_bits_count(&s->gb);
842 /* Following is a optimized code for
844 if(get_bits1(&s->gb))
849 #define READ_FLIP_SIGN(dst,src) \
850 v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31); \
853 #define READ_FLIP_SIGN(dst,src) \
854 v = -get_bits1(&s->gb); \
855 *(dst) = (*(src) ^ v) - v;
858 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
859 int16_t *exponents, int end_pos2)
863 int last_pos, bits_left;
865 int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
867 /* low frequencies (called big values) */
869 for (i = 0; i < 3; i++) {
870 int j, k, l, linbits;
871 j = g->region_size[i];
874 /* select vlc table */
875 k = g->table_select[i];
876 l = mpa_huff_data[k][0];
877 linbits = mpa_huff_data[k][1];
881 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
886 /* read huffcode and compute each couple */
890 int pos = get_bits_count(&s->gb);
893 // av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
894 switch_buffer(s, &pos, &end_pos, &end_pos2);
895 // av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
899 y = get_vlc2(&s->gb, vlc->table, 7, 3);
902 g->sb_hybrid[s_index ] =
903 g->sb_hybrid[s_index+1] = 0;
908 exponent= exponents[s_index];
910 av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
911 i, g->region_size[i] - j, x, y, exponent);
916 READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
918 x += get_bitsz(&s->gb, linbits);
919 v = l3_unscale(x, exponent);
920 if (get_bits1(&s->gb))
922 g->sb_hybrid[s_index] = v;
925 READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
927 y += get_bitsz(&s->gb, linbits);
928 v = l3_unscale(y, exponent);
929 if (get_bits1(&s->gb))
931 g->sb_hybrid[s_index+1] = v;
938 READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
940 x += get_bitsz(&s->gb, linbits);
941 v = l3_unscale(x, exponent);
942 if (get_bits1(&s->gb))
944 g->sb_hybrid[s_index+!!y] = v;
946 g->sb_hybrid[s_index + !y] = 0;
952 /* high frequencies */
953 vlc = &huff_quad_vlc[g->count1table_select];
955 while (s_index <= 572) {
957 pos = get_bits_count(&s->gb);
958 if (pos >= end_pos) {
959 if (pos > end_pos2 && last_pos) {
960 /* some encoders generate an incorrect size for this
961 part. We must go back into the data */
963 skip_bits_long(&s->gb, last_pos - pos);
964 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
965 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
969 // av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
970 switch_buffer(s, &pos, &end_pos, &end_pos2);
971 // av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
977 code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
978 av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
979 g->sb_hybrid[s_index+0] =
980 g->sb_hybrid[s_index+1] =
981 g->sb_hybrid[s_index+2] =
982 g->sb_hybrid[s_index+3] = 0;
984 static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
986 int pos = s_index + idxtab[code];
987 code ^= 8 >> idxtab[code];
988 READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
992 /* skip extension bits */
993 bits_left = end_pos2 - get_bits_count(&s->gb);
994 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
995 if (bits_left < 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_COMPLIANT))) {
996 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
998 } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) {
999 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
1002 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
1003 skip_bits_long(&s->gb, bits_left);
1005 i = get_bits_count(&s->gb);
1006 switch_buffer(s, &i, &end_pos, &end_pos2);
1011 /* Reorder short blocks from bitstream order to interleaved order. It
1012 would be faster to do it in parsing, but the code would be far more
1014 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
1017 INTFLOAT *ptr, *dst, *ptr1;
1020 if (g->block_type != 2)
1023 if (g->switch_point) {
1024 if (s->sample_rate_index != 8)
1025 ptr = g->sb_hybrid + 36;
1027 ptr = g->sb_hybrid + 72;
1032 for (i = g->short_start; i < 13; i++) {
1033 len = band_size_short[s->sample_rate_index][i];
1036 for (j = len; j > 0; j--) {
1037 *dst++ = ptr[0*len];
1038 *dst++ = ptr[1*len];
1039 *dst++ = ptr[2*len];
1043 memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1047 #define ISQRT2 FIXR(0.70710678118654752440)
1049 static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1052 int sf_max, sf, len, non_zero_found;
1053 INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1054 int non_zero_found_short[3];
1056 /* intensity stereo */
1057 if (s->mode_ext & MODE_EXT_I_STEREO) {
1062 is_tab = is_table_lsf[g1->scalefac_compress & 1];
1066 tab0 = g0->sb_hybrid + 576;
1067 tab1 = g1->sb_hybrid + 576;
1069 non_zero_found_short[0] = 0;
1070 non_zero_found_short[1] = 0;
1071 non_zero_found_short[2] = 0;
1072 k = (13 - g1->short_start) * 3 + g1->long_end - 3;
1073 for (i = 12; i >= g1->short_start; i--) {
1074 /* for last band, use previous scale factor */
1077 len = band_size_short[s->sample_rate_index][i];
1078 for (l = 2; l >= 0; l--) {
1081 if (!non_zero_found_short[l]) {
1082 /* test if non zero band. if so, stop doing i-stereo */
1083 for (j = 0; j < len; j++) {
1085 non_zero_found_short[l] = 1;
1089 sf = g1->scale_factors[k + l];
1095 for (j = 0; j < len; j++) {
1097 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1098 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1102 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1103 /* lower part of the spectrum : do ms stereo
1105 for (j = 0; j < len; j++) {
1108 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1109 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1116 non_zero_found = non_zero_found_short[0] |
1117 non_zero_found_short[1] |
1118 non_zero_found_short[2];
1120 for (i = g1->long_end - 1;i >= 0;i--) {
1121 len = band_size_long[s->sample_rate_index][i];
1124 /* test if non zero band. if so, stop doing i-stereo */
1125 if (!non_zero_found) {
1126 for (j = 0; j < len; j++) {
1132 /* for last band, use previous scale factor */
1133 k = (i == 21) ? 20 : i;
1134 sf = g1->scale_factors[k];
1139 for (j = 0; j < len; j++) {
1141 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1142 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1146 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1147 /* lower part of the spectrum : do ms stereo
1149 for (j = 0; j < len; j++) {
1152 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1153 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1158 } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
1159 /* ms stereo ONLY */
1160 /* NOTE: the 1/sqrt(2) normalization factor is included in the
1163 s-> dsp.butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
1165 tab0 = g0->sb_hybrid;
1166 tab1 = g1->sb_hybrid;
1167 for (i = 0; i < 576; i++) {
1170 tab0[i] = tmp0 + tmp1;
1171 tab1[i] = tmp0 - tmp1;
1179 # include "mips/compute_antialias_float.h"
1180 #endif /* HAVE_MIPSFPU */
1183 # include "mips/compute_antialias_fixed.h"
1184 #endif /* HAVE_MIPSDSPR1 */
1185 #endif /* CONFIG_FLOAT */
1187 #ifndef compute_antialias
1189 #define AA(j) do { \
1190 float tmp0 = ptr[-1-j]; \
1191 float tmp1 = ptr[ j]; \
1192 ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
1193 ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
1196 #define AA(j) do { \
1197 int tmp0 = ptr[-1-j]; \
1198 int tmp1 = ptr[ j]; \
1199 int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
1200 ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2])); \
1201 ptr[ j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3])); \
1205 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1210 /* we antialias only "long" bands */
1211 if (g->block_type == 2) {
1212 if (!g->switch_point)
1214 /* XXX: check this for 8000Hz case */
1220 ptr = g->sb_hybrid + 18;
1221 for (i = n; i > 0; i--) {
1234 #endif /* compute_antialias */
1236 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
1237 INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1239 INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1241 int i, j, mdct_long_end, sblimit;
1243 /* find last non zero block */
1244 ptr = g->sb_hybrid + 576;
1245 ptr1 = g->sb_hybrid + 2 * 18;
1246 while (ptr >= ptr1) {
1250 if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1253 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
1255 if (g->block_type == 2) {
1256 /* XXX: check for 8000 Hz */
1257 if (g->switch_point)
1262 mdct_long_end = sblimit;
1265 s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
1266 mdct_long_end, g->switch_point,
1269 buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
1270 ptr = g->sb_hybrid + 18 * mdct_long_end;
1272 for (j = mdct_long_end; j < sblimit; j++) {
1273 /* select frequency inversion */
1274 win = RENAME(ff_mdct_win)[2 + (4 & -(j & 1))];
1275 out_ptr = sb_samples + j;
1277 for (i = 0; i < 6; i++) {
1278 *out_ptr = buf[4*i];
1281 imdct12(out2, ptr + 0);
1282 for (i = 0; i < 6; i++) {
1283 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*1)];
1284 buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
1287 imdct12(out2, ptr + 1);
1288 for (i = 0; i < 6; i++) {
1289 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*2)];
1290 buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
1293 imdct12(out2, ptr + 2);
1294 for (i = 0; i < 6; i++) {
1295 buf[4*(i + 6*0)] = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*0)];
1296 buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
1297 buf[4*(i + 6*2)] = 0;
1300 buf += (j&3) != 3 ? 1 : (4*18-3);
1303 for (j = sblimit; j < SBLIMIT; j++) {
1305 out_ptr = sb_samples + j;
1306 for (i = 0; i < 18; i++) {
1307 *out_ptr = buf[4*i];
1311 buf += (j&3) != 3 ? 1 : (4*18-3);
1315 /* main layer3 decoding function */
1316 static int mp_decode_layer3(MPADecodeContext *s)
1318 int nb_granules, main_data_begin;
1319 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1321 int16_t exponents[576]; //FIXME try INTFLOAT
1323 /* read side info */
1325 main_data_begin = get_bits(&s->gb, 8);
1326 skip_bits(&s->gb, s->nb_channels);
1329 main_data_begin = get_bits(&s->gb, 9);
1330 if (s->nb_channels == 2)
1331 skip_bits(&s->gb, 3);
1333 skip_bits(&s->gb, 5);
1335 for (ch = 0; ch < s->nb_channels; ch++) {
1336 s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
1337 s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1341 for (gr = 0; gr < nb_granules; gr++) {
1342 for (ch = 0; ch < s->nb_channels; ch++) {
1343 av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1344 g = &s->granules[ch][gr];
1345 g->part2_3_length = get_bits(&s->gb, 12);
1346 g->big_values = get_bits(&s->gb, 9);
1347 if (g->big_values > 288) {
1348 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1349 return AVERROR_INVALIDDATA;
1352 g->global_gain = get_bits(&s->gb, 8);
1353 /* if MS stereo only is selected, we precompute the
1354 1/sqrt(2) renormalization factor */
1355 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1357 g->global_gain -= 2;
1359 g->scalefac_compress = get_bits(&s->gb, 9);
1361 g->scalefac_compress = get_bits(&s->gb, 4);
1362 blocksplit_flag = get_bits1(&s->gb);
1363 if (blocksplit_flag) {
1364 g->block_type = get_bits(&s->gb, 2);
1365 if (g->block_type == 0) {
1366 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1367 return AVERROR_INVALIDDATA;
1369 g->switch_point = get_bits1(&s->gb);
1370 for (i = 0; i < 2; i++)
1371 g->table_select[i] = get_bits(&s->gb, 5);
1372 for (i = 0; i < 3; i++)
1373 g->subblock_gain[i] = get_bits(&s->gb, 3);
1374 ff_init_short_region(s, g);
1376 int region_address1, region_address2;
1378 g->switch_point = 0;
1379 for (i = 0; i < 3; i++)
1380 g->table_select[i] = get_bits(&s->gb, 5);
1381 /* compute huffman coded region sizes */
1382 region_address1 = get_bits(&s->gb, 4);
1383 region_address2 = get_bits(&s->gb, 3);
1384 av_dlog(s->avctx, "region1=%d region2=%d\n",
1385 region_address1, region_address2);
1386 ff_init_long_region(s, g, region_address1, region_address2);
1388 ff_region_offset2size(g);
1389 ff_compute_band_indexes(s, g);
1393 g->preflag = get_bits1(&s->gb);
1394 g->scalefac_scale = get_bits1(&s->gb);
1395 g->count1table_select = get_bits1(&s->gb);
1396 av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1397 g->block_type, g->switch_point);
1403 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1404 int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0, EXTRABYTES);
1405 av_assert1((get_bits_count(&s->gb) & 7) == 0);
1406 /* now we get bits from the main_data_begin offset */
1407 av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1408 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1410 memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1412 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1413 #if !UNCHECKED_BITSTREAM_READER
1414 s->gb.size_in_bits_plus8 += FFMAX(extrasize, LAST_BUF_SIZE - s->last_buf_size) * 8;
1416 s->last_buf_size <<= 3;
1417 for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
1418 for (ch = 0; ch < s->nb_channels; ch++) {
1419 g = &s->granules[ch][gr];
1420 s->last_buf_size += g->part2_3_length;
1421 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1424 skip = s->last_buf_size - 8 * main_data_begin;
1425 if (skip >= s->gb.size_in_bits && s->in_gb.buffer) {
1426 skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits);
1428 s->in_gb.buffer = NULL;
1430 skip_bits_long(&s->gb, skip);
1436 for (; gr < nb_granules; gr++) {
1437 for (ch = 0; ch < s->nb_channels; ch++) {
1438 g = &s->granules[ch][gr];
1439 bits_pos = get_bits_count(&s->gb);
1443 int slen, slen1, slen2;
1445 /* MPEG1 scale factors */
1446 slen1 = slen_table[0][g->scalefac_compress];
1447 slen2 = slen_table[1][g->scalefac_compress];
1448 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1449 if (g->block_type == 2) {
1450 n = g->switch_point ? 17 : 18;
1453 for (i = 0; i < n; i++)
1454 g->scale_factors[j++] = get_bits(&s->gb, slen1);
1456 for (i = 0; i < n; i++)
1457 g->scale_factors[j++] = 0;
1460 for (i = 0; i < 18; i++)
1461 g->scale_factors[j++] = get_bits(&s->gb, slen2);
1462 for (i = 0; i < 3; i++)
1463 g->scale_factors[j++] = 0;
1465 for (i = 0; i < 21; i++)
1466 g->scale_factors[j++] = 0;
1469 sc = s->granules[ch][0].scale_factors;
1471 for (k = 0; k < 4; k++) {
1473 if ((g->scfsi & (0x8 >> k)) == 0) {
1474 slen = (k < 2) ? slen1 : slen2;
1476 for (i = 0; i < n; i++)
1477 g->scale_factors[j++] = get_bits(&s->gb, slen);
1479 for (i = 0; i < n; i++)
1480 g->scale_factors[j++] = 0;
1483 /* simply copy from last granule */
1484 for (i = 0; i < n; i++) {
1485 g->scale_factors[j] = sc[j];
1490 g->scale_factors[j++] = 0;
1493 int tindex, tindex2, slen[4], sl, sf;
1495 /* LSF scale factors */
1496 if (g->block_type == 2)
1497 tindex = g->switch_point ? 2 : 1;
1501 sf = g->scalefac_compress;
1502 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1503 /* intensity stereo case */
1506 lsf_sf_expand(slen, sf, 6, 6, 0);
1508 } else if (sf < 244) {
1509 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1512 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1518 lsf_sf_expand(slen, sf, 5, 4, 4);
1520 } else if (sf < 500) {
1521 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1524 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1531 for (k = 0; k < 4; k++) {
1532 n = lsf_nsf_table[tindex2][tindex][k];
1535 for (i = 0; i < n; i++)
1536 g->scale_factors[j++] = get_bits(&s->gb, sl);
1538 for (i = 0; i < n; i++)
1539 g->scale_factors[j++] = 0;
1542 /* XXX: should compute exact size */
1544 g->scale_factors[j] = 0;
1547 exponents_from_scale_factors(s, g, exponents);
1549 /* read Huffman coded residue */
1550 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1553 if (s->mode == MPA_JSTEREO)
1554 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1556 for (ch = 0; ch < s->nb_channels; ch++) {
1557 g = &s->granules[ch][gr];
1559 reorder_block(s, g);
1560 compute_antialias(s, g);
1561 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1564 if (get_bits_count(&s->gb) < 0)
1565 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1566 return nb_granules * 18;
1569 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1570 const uint8_t *buf, int buf_size)
1572 int i, nb_frames, ch, ret;
1573 OUT_INT *samples_ptr;
1575 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1577 /* skip error protection field */
1578 if (s->error_protection)
1579 skip_bits(&s->gb, 16);
1583 s->avctx->frame_size = 384;
1584 nb_frames = mp_decode_layer1(s);
1587 s->avctx->frame_size = 1152;
1588 nb_frames = mp_decode_layer2(s);
1591 s->avctx->frame_size = s->lsf ? 576 : 1152;
1593 nb_frames = mp_decode_layer3(s);
1596 if (s->in_gb.buffer) {
1597 align_get_bits(&s->gb);
1598 i = get_bits_left(&s->gb)>>3;
1599 if (i >= 0 && i <= BACKSTEP_SIZE) {
1600 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1603 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1605 s->in_gb.buffer = NULL;
1608 align_get_bits(&s->gb);
1609 av_assert1((get_bits_count(&s->gb) & 7) == 0);
1610 i = get_bits_left(&s->gb) >> 3;
1612 if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1614 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1615 i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1617 av_assert1(i <= buf_size - HEADER_SIZE && i >= 0);
1618 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1619 s->last_buf_size += i;
1622 /* get output buffer */
1624 s->frame.nb_samples = s->avctx->frame_size;
1625 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1626 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1629 samples = (OUT_INT *)s->frame.data[0];
1632 /* apply the synthesis filter */
1633 for (ch = 0; ch < s->nb_channels; ch++) {
1634 samples_ptr = samples + ch;
1635 for (i = 0; i < nb_frames; i++) {
1636 RENAME(ff_mpa_synth_filter)(
1638 s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1639 RENAME(ff_mpa_synth_window), &s->dither_state,
1640 samples_ptr, s->nb_channels,
1641 s->sb_samples[ch][i]);
1642 samples_ptr += 32 * s->nb_channels;
1646 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1649 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1652 const uint8_t *buf = avpkt->data;
1653 int buf_size = avpkt->size;
1654 MPADecodeContext *s = avctx->priv_data;
1658 while(buf_size && !*buf){
1663 if (buf_size < HEADER_SIZE)
1664 return AVERROR_INVALIDDATA;
1666 header = AV_RB32(buf);
1667 if (header>>8 == AV_RB32("TAG")>>8) {
1668 av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
1671 if (ff_mpa_check_header(header) < 0) {
1672 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1673 return AVERROR_INVALIDDATA;
1676 if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1677 /* free format: prepare to compute frame size */
1679 return AVERROR_INVALIDDATA;
1681 /* update codec info */
1682 avctx->channels = s->nb_channels;
1683 avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1684 if (!avctx->bit_rate)
1685 avctx->bit_rate = s->bit_rate;
1687 if (s->frame_size <= 0 || s->frame_size > buf_size) {
1688 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1689 return AVERROR_INVALIDDATA;
1690 } else if (s->frame_size < buf_size) {
1691 av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
1692 buf_size= s->frame_size;
1695 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1696 if (out_size >= 0) {
1698 *(AVFrame *)data = s->frame;
1699 avctx->sample_rate = s->sample_rate;
1700 //FIXME maybe move the other codec info stuff from above here too
1702 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1703 /* Only return an error if the bad frame makes up the whole packet.
1704 If there is more data in the packet, just consume the bad frame
1705 instead of returning an error, which would discard the whole
1708 if (buf_size == avpkt->size)
1715 static void flush(AVCodecContext *avctx)
1717 MPADecodeContext *s = avctx->priv_data;
1718 memset(s->synth_buf, 0, sizeof(s->synth_buf));
1719 s->last_buf_size = 0;
1722 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1723 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1724 int *got_frame_ptr, AVPacket *avpkt)
1726 const uint8_t *buf = avpkt->data;
1727 int buf_size = avpkt->size;
1728 MPADecodeContext *s = avctx->priv_data;
1731 int av_unused out_size;
1735 // Discard too short frames
1736 if (buf_size < HEADER_SIZE) {
1737 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1738 return AVERROR_INVALIDDATA;
1742 if (len > MPA_MAX_CODED_FRAME_SIZE)
1743 len = MPA_MAX_CODED_FRAME_SIZE;
1745 // Get header and restore sync word
1746 header = AV_RB32(buf) | 0xffe00000;
1748 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1749 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1750 return AVERROR_INVALIDDATA;
1753 avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1754 /* update codec info */
1755 avctx->sample_rate = s->sample_rate;
1756 avctx->channels = s->nb_channels;
1757 if (!avctx->bit_rate)
1758 avctx->bit_rate = s->bit_rate;
1760 s->frame_size = len;
1762 out_size = mp_decode_frame(s, NULL, buf, buf_size);
1764 av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1765 return AVERROR_INVALIDDATA;
1769 *(AVFrame *)data = s->frame;
1773 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1775 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1778 * Context for MP3On4 decoder
1780 typedef struct MP3On4DecodeContext {
1782 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
1783 int syncword; ///< syncword patch
1784 const uint8_t *coff; ///< channel offsets in output buffer
1785 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1786 OUT_INT *decoded_buf; ///< output buffer for decoded samples
1787 } MP3On4DecodeContext;
1789 #include "mpeg4audio.h"
1791 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1793 /* number of mp3 decoder instances */
1794 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1796 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1797 static const uint8_t chan_offset[8][5] = {
1802 { 2, 0, 3 }, // C FLR BS
1803 { 2, 0, 3 }, // C FLR BLRS
1804 { 2, 0, 4, 3 }, // C FLR BLRS LFE
1805 { 2, 0, 6, 4, 3 }, // C FLR BLRS BLR LFE
1808 /* mp3on4 channel layouts */
1809 static const int16_t chan_layout[8] = {
1812 AV_CH_LAYOUT_STEREO,
1813 AV_CH_LAYOUT_SURROUND,
1814 AV_CH_LAYOUT_4POINT0,
1815 AV_CH_LAYOUT_5POINT0,
1816 AV_CH_LAYOUT_5POINT1,
1817 AV_CH_LAYOUT_7POINT1
1820 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1822 MP3On4DecodeContext *s = avctx->priv_data;
1825 for (i = 0; i < s->frames; i++)
1826 av_free(s->mp3decctx[i]);
1828 av_freep(&s->decoded_buf);
1834 static int decode_init_mp3on4(AVCodecContext * avctx)
1836 MP3On4DecodeContext *s = avctx->priv_data;
1837 MPEG4AudioConfig cfg;
1840 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1841 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1842 return AVERROR_INVALIDDATA;
1845 avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1846 avctx->extradata_size * 8, 1);
1847 if (!cfg.chan_config || cfg.chan_config > 7) {
1848 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1849 return AVERROR_INVALIDDATA;
1851 s->frames = mp3Frames[cfg.chan_config];
1852 s->coff = chan_offset[cfg.chan_config];
1853 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
1854 avctx->channel_layout = chan_layout[cfg.chan_config];
1856 if (cfg.sample_rate < 16000)
1857 s->syncword = 0xffe00000;
1859 s->syncword = 0xfff00000;
1861 /* Init the first mp3 decoder in standard way, so that all tables get builded
1862 * We replace avctx->priv_data with the context of the first decoder so that
1863 * decode_init() does not have to be changed.
1864 * Other decoders will be initialized here copying data from the first context
1866 // Allocate zeroed memory for the first decoder context
1867 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1868 if (!s->mp3decctx[0])
1870 // Put decoder context in place to make init_decode() happy
1871 avctx->priv_data = s->mp3decctx[0];
1873 s->frame = avctx->coded_frame;
1874 // Restore mp3on4 context pointer
1875 avctx->priv_data = s;
1876 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1878 /* Create a separate codec/context for each frame (first is already ok).
1879 * Each frame is 1 or 2 channels - up to 5 frames allowed
1881 for (i = 1; i < s->frames; i++) {
1882 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1883 if (!s->mp3decctx[i])
1885 s->mp3decctx[i]->adu_mode = 1;
1886 s->mp3decctx[i]->avctx = avctx;
1887 s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1890 /* Allocate buffer for multi-channel output if needed */
1891 if (s->frames > 1) {
1892 s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1893 sizeof(*s->decoded_buf));
1894 if (!s->decoded_buf)
1900 decode_close_mp3on4(avctx);
1901 return AVERROR(ENOMEM);
1905 static void flush_mp3on4(AVCodecContext *avctx)
1908 MP3On4DecodeContext *s = avctx->priv_data;
1910 for (i = 0; i < s->frames; i++) {
1911 MPADecodeContext *m = s->mp3decctx[i];
1912 memset(m->synth_buf, 0, sizeof(m->synth_buf));
1913 m->last_buf_size = 0;
1918 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
1919 int *got_frame_ptr, AVPacket *avpkt)
1921 const uint8_t *buf = avpkt->data;
1922 int buf_size = avpkt->size;
1923 MP3On4DecodeContext *s = avctx->priv_data;
1924 MPADecodeContext *m;
1925 int fsize, len = buf_size, out_size = 0;
1927 OUT_INT *out_samples;
1928 OUT_INT *outptr, *bp;
1929 int fr, j, n, ch, ret;
1931 /* get output buffer */
1932 s->frame->nb_samples = s->frames * MPA_FRAME_SIZE;
1933 if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
1934 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1937 out_samples = (OUT_INT *)s->frame->data[0];
1939 // Discard too short frames
1940 if (buf_size < HEADER_SIZE)
1941 return AVERROR_INVALIDDATA;
1943 // If only one decoder interleave is not needed
1944 outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1946 avctx->bit_rate = 0;
1949 for (fr = 0; fr < s->frames; fr++) {
1950 fsize = AV_RB16(buf) >> 4;
1951 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1952 m = s->mp3decctx[fr];
1955 if (fsize < HEADER_SIZE) {
1956 av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
1957 return AVERROR_INVALIDDATA;
1959 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1961 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1964 avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1966 if (ch + m->nb_channels > avctx->channels) {
1967 av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1969 return AVERROR_INVALIDDATA;
1971 ch += m->nb_channels;
1973 out_size += mp_decode_frame(m, outptr, buf, fsize);
1977 if (s->frames > 1) {
1978 n = m->avctx->frame_size*m->nb_channels;
1979 /* interleave output data */
1980 bp = out_samples + s->coff[fr];
1981 if (m->nb_channels == 1) {
1982 for (j = 0; j < n; j++) {
1983 *bp = s->decoded_buf[j];
1984 bp += avctx->channels;
1987 for (j = 0; j < n; j++) {
1988 bp[0] = s->decoded_buf[j++];
1989 bp[1] = s->decoded_buf[j];
1990 bp += avctx->channels;
1994 avctx->bit_rate += m->bit_rate;
1997 /* update codec info */
1998 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
2000 s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
2002 *(AVFrame *)data = *s->frame;
2006 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
2009 #if CONFIG_MP1_DECODER
2010 AVCodec ff_mp1_decoder = {
2012 .type = AVMEDIA_TYPE_AUDIO,
2013 .id = AV_CODEC_ID_MP1,
2014 .priv_data_size = sizeof(MPADecodeContext),
2015 .init = decode_init,
2016 .decode = decode_frame,
2017 .capabilities = CODEC_CAP_DR1,
2019 .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
2022 #if CONFIG_MP2_DECODER
2023 AVCodec ff_mp2_decoder = {
2025 .type = AVMEDIA_TYPE_AUDIO,
2026 .id = AV_CODEC_ID_MP2,
2027 .priv_data_size = sizeof(MPADecodeContext),
2028 .init = decode_init,
2029 .decode = decode_frame,
2030 .capabilities = CODEC_CAP_DR1,
2032 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2035 #if CONFIG_MP3_DECODER
2036 AVCodec ff_mp3_decoder = {
2038 .type = AVMEDIA_TYPE_AUDIO,
2039 .id = AV_CODEC_ID_MP3,
2040 .priv_data_size = sizeof(MPADecodeContext),
2041 .init = decode_init,
2042 .decode = decode_frame,
2043 .capabilities = CODEC_CAP_DR1,
2045 .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2048 #if CONFIG_MP3ADU_DECODER
2049 AVCodec ff_mp3adu_decoder = {
2051 .type = AVMEDIA_TYPE_AUDIO,
2052 .id = AV_CODEC_ID_MP3ADU,
2053 .priv_data_size = sizeof(MPADecodeContext),
2054 .init = decode_init,
2055 .decode = decode_frame_adu,
2056 .capabilities = CODEC_CAP_DR1,
2058 .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2061 #if CONFIG_MP3ON4_DECODER
2062 AVCodec ff_mp3on4_decoder = {
2064 .type = AVMEDIA_TYPE_AUDIO,
2065 .id = AV_CODEC_ID_MP3ON4,
2066 .priv_data_size = sizeof(MP3On4DecodeContext),
2067 .init = decode_init_mp3on4,
2068 .close = decode_close_mp3on4,
2069 .decode = decode_frame_mp3on4,
2070 .capabilities = CODEC_CAP_DR1,
2071 .flush = flush_mp3on4,
2072 .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),