3 * Copyright (c) 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/audioconvert.h"
31 #include "mpegaudiodsp.h"
35 * - test lsf / mpeg25 extensively.
38 #include "mpegaudio.h"
39 #include "mpegaudiodecheader.h"
41 #define BACKSTEP_SIZE 512
44 /* layer 3 "granule" */
45 typedef struct GranuleDef {
50 int scalefac_compress;
55 uint8_t scalefac_scale;
56 uint8_t count1table_select;
57 int region_size[3]; /* number of huffman codes in each region */
59 int short_start, long_end; /* long/short band indexes */
60 uint8_t scale_factors[40];
61 DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
64 typedef struct MPADecodeContext {
66 uint8_t last_buf[2 * BACKSTEP_SIZE + EXTRABYTES];
68 /* next header (used in free format parsing) */
69 uint32_t free_format_next_header;
72 DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
73 int synth_buf_offset[MPA_MAX_CHANNELS];
74 DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
75 INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
76 GranuleDef granules[2][2]; /* Used in Layer 3 */
77 int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
80 AVCodecContext* avctx;
85 # define SHR(a,b) ((a)*(1.0f/(1<<(b))))
86 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
87 # define FIXR(x) ((float)(x))
88 # define FIXHR(x) ((float)(x))
89 # define MULH3(x, y, s) ((s)*(y)*(x))
90 # define MULLx(x, y, s) ((y)*(x))
91 # define RENAME(a) a ## _float
92 # define OUT_FMT AV_SAMPLE_FMT_FLT
94 # define SHR(a,b) ((a)>>(b))
95 /* WARNING: only correct for positive numbers */
96 # define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
97 # define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
98 # define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
99 # define MULH3(x, y, s) MULH((s)*(x), y)
100 # define MULLx(x, y, s) MULL(x,y,s)
101 # define RENAME(a) a ## _fixed
102 # define OUT_FMT AV_SAMPLE_FMT_S16
107 #define HEADER_SIZE 4
109 #include "mpegaudiodata.h"
110 #include "mpegaudiodectab.h"
112 /* vlc structure for decoding layer 3 huffman tables */
113 static VLC huff_vlc[16];
114 static VLC_TYPE huff_vlc_tables[
115 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
116 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
118 static const int huff_vlc_tables_sizes[16] = {
119 0, 128, 128, 128, 130, 128, 154, 166,
120 142, 204, 190, 170, 542, 460, 662, 414
122 static VLC huff_quad_vlc[2];
123 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
124 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
125 /* computed from band_size_long */
126 static uint16_t band_index_long[9][23];
127 #include "mpegaudio_tablegen.h"
128 /* intensity stereo coef table */
129 static INTFLOAT is_table[2][16];
130 static INTFLOAT is_table_lsf[2][2][16];
131 static INTFLOAT csa_table[8][4];
132 /** Window for MDCT. Note that only the component [0,17] and [20,37] are used,
133 the components 18 and 19 are there only to assure 128-bit alignment for asm
135 DECLARE_ALIGNED(16, static INTFLOAT, mdct_win)[8][40];
137 static int16_t division_tab3[1<<6 ];
138 static int16_t division_tab5[1<<8 ];
139 static int16_t division_tab9[1<<11];
141 static int16_t * const division_tabs[4] = {
142 division_tab3, division_tab5, NULL, division_tab9
145 /* lower 2 bits: modulo 3, higher bits: shift */
146 static uint16_t scale_factor_modshift[64];
147 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
148 static int32_t scale_factor_mult[15][3];
149 /* mult table for layer 2 group quantization */
151 #define SCALE_GEN(v) \
152 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
154 static const int32_t scale_factor_mult2[3][3] = {
155 SCALE_GEN(4.0 / 3.0), /* 3 steps */
156 SCALE_GEN(4.0 / 5.0), /* 5 steps */
157 SCALE_GEN(4.0 / 9.0), /* 9 steps */
161 * Convert region offsets to region sizes and truncate
162 * size to big_values.
164 static void ff_region_offset2size(GranuleDef *g)
167 g->region_size[2] = 576 / 2;
168 for (i = 0; i < 3; i++) {
169 k = FFMIN(g->region_size[i], g->big_values);
170 g->region_size[i] = k - j;
175 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
177 if (g->block_type == 2)
178 g->region_size[0] = (36 / 2);
180 if (s->sample_rate_index <= 2)
181 g->region_size[0] = (36 / 2);
182 else if (s->sample_rate_index != 8)
183 g->region_size[0] = (54 / 2);
185 g->region_size[0] = (108 / 2);
187 g->region_size[1] = (576 / 2);
190 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
193 g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
194 /* should not overflow */
195 l = FFMIN(ra1 + ra2 + 2, 22);
196 g->region_size[1] = band_index_long[s->sample_rate_index][ l] >> 1;
199 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
201 if (g->block_type == 2) {
202 if (g->switch_point) {
203 /* if switched mode, we handle the 36 first samples as
204 long blocks. For 8000Hz, we handle the 48 first
205 exponents as long blocks (XXX: check this!) */
206 if (s->sample_rate_index <= 2)
208 else if (s->sample_rate_index != 8)
211 g->long_end = 4; /* 8000 Hz */
213 g->short_start = 2 + (s->sample_rate_index != 8);
224 /* layer 1 unscaling */
225 /* n = number of bits of the mantissa minus 1 */
226 static inline int l1_unscale(int n, int mant, int scale_factor)
231 shift = scale_factor_modshift[scale_factor];
234 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
236 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
237 return (int)((val + (1LL << (shift - 1))) >> shift);
240 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
244 shift = scale_factor_modshift[scale_factor];
248 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
249 /* NOTE: at this point, 0 <= shift <= 21 */
251 val = (val + (1 << (shift - 1))) >> shift;
255 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
256 static inline int l3_unscale(int value, int exponent)
261 e = table_4_3_exp [4 * value + (exponent & 3)];
262 m = table_4_3_value[4 * value + (exponent & 3)];
267 m = (m + (1 << (e - 1))) >> e;
272 static av_cold void decode_init_static(void)
277 /* scale factors table for layer 1/2 */
278 for (i = 0; i < 64; i++) {
280 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
283 scale_factor_modshift[i] = mod | (shift << 2);
286 /* scale factor multiply for layer 1 */
287 for (i = 0; i < 15; i++) {
290 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
291 scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
292 scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
293 scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
294 av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
295 scale_factor_mult[i][0],
296 scale_factor_mult[i][1],
297 scale_factor_mult[i][2]);
300 RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
302 /* huffman decode tables */
304 for (i = 1; i < 16; i++) {
305 const HuffTable *h = &mpa_huff_tables[i];
307 uint8_t tmp_bits [512];
308 uint16_t tmp_codes[512];
310 memset(tmp_bits , 0, sizeof(tmp_bits ));
311 memset(tmp_codes, 0, sizeof(tmp_codes));
316 for (x = 0; x < xsize; x++) {
317 for (y = 0; y < xsize; y++) {
318 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
319 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
324 huff_vlc[i].table = huff_vlc_tables+offset;
325 huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
326 init_vlc(&huff_vlc[i], 7, 512,
327 tmp_bits, 1, 1, tmp_codes, 2, 2,
328 INIT_VLC_USE_NEW_STATIC);
329 offset += huff_vlc_tables_sizes[i];
331 assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
334 for (i = 0; i < 2; i++) {
335 huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
336 huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
337 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
338 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
339 INIT_VLC_USE_NEW_STATIC);
340 offset += huff_quad_vlc_tables_sizes[i];
342 assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
344 for (i = 0; i < 9; i++) {
346 for (j = 0; j < 22; j++) {
347 band_index_long[i][j] = k;
348 k += band_size_long[i][j];
350 band_index_long[i][22] = k;
353 /* compute n ^ (4/3) and store it in mantissa/exp format */
355 mpegaudio_tableinit();
357 for (i = 0; i < 4; i++) {
358 if (ff_mpa_quant_bits[i] < 0) {
359 for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
360 int val1, val2, val3, steps;
362 steps = ff_mpa_quant_steps[i];
367 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
373 for (i = 0; i < 7; i++) {
377 f = tan((double)i * M_PI / 12.0);
378 v = FIXR(f / (1.0 + f));
383 is_table[1][6 - i] = v;
386 for (i = 7; i < 16; i++)
387 is_table[0][i] = is_table[1][i] = 0.0;
389 for (i = 0; i < 16; i++) {
393 for (j = 0; j < 2; j++) {
394 e = -(j + 1) * ((i + 1) >> 1);
395 f = pow(2.0, e / 4.0);
397 is_table_lsf[j][k ^ 1][i] = FIXR(f);
398 is_table_lsf[j][k ][i] = FIXR(1.0);
399 av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
400 i, j, (float) is_table_lsf[j][0][i],
401 (float) is_table_lsf[j][1][i]);
405 for (i = 0; i < 8; i++) {
408 cs = 1.0 / sqrt(1.0 + ci * ci);
411 csa_table[i][0] = FIXHR(cs/4);
412 csa_table[i][1] = FIXHR(ca/4);
413 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
414 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
416 csa_table[i][0] = cs;
417 csa_table[i][1] = ca;
418 csa_table[i][2] = ca + cs;
419 csa_table[i][3] = ca - cs;
423 /* compute mdct windows */
424 for (i = 0; i < 36; i++) {
425 for (j = 0; j < 4; j++) {
428 if (j == 2 && i % 3 != 1)
431 d = sin(M_PI * (i + 0.5) / 36.0);
434 else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);
435 else if (i >= 18) d = 1;
438 else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0);
439 else if (i < 18) d = 1;
441 //merge last stage of imdct into the window coefficients
442 d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);
445 mdct_win[j][i/3] = FIXHR((d / (1<<5)));
447 int idx = i < 18 ? i : i + 2;
448 mdct_win[j][idx] = FIXHR((d / (1<<5)));
453 /* NOTE: we do frequency inversion adter the MDCT by changing
454 the sign of the right window coefs */
455 for (j = 0; j < 4; j++) {
456 for (i = 0; i < 40; i += 2) {
457 mdct_win[j + 4][i ] = mdct_win[j][i ];
458 mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
463 static av_cold int decode_init(AVCodecContext * avctx)
465 static int initialized_tables = 0;
466 MPADecodeContext *s = avctx->priv_data;
468 if (!initialized_tables) {
469 decode_init_static();
470 initialized_tables = 1;
475 ff_mpadsp_init(&s->mpadsp);
477 avctx->sample_fmt= OUT_FMT;
478 s->err_recognition = avctx->err_recognition;
480 if (avctx->codec_id == CODEC_ID_MP3ADU)
485 #define C3 FIXHR(0.86602540378443864676/2)
486 #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
487 #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
488 #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
490 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
492 static void imdct12(INTFLOAT *out, INTFLOAT *in)
494 INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
497 in1 = in[1*3] + in[0*3];
498 in2 = in[2*3] + in[1*3];
499 in3 = in[3*3] + in[2*3];
500 in4 = in[4*3] + in[3*3];
501 in5 = in[5*3] + in[4*3];
505 in2 = MULH3(in2, C3, 2);
506 in3 = MULH3(in3, C3, 4);
509 t2 = MULH3(in1 - in5, C4, 2);
519 in1 = MULH3(in5 + in3, C5, 1);
526 in5 = MULH3(in5 - in3, C6, 2);
533 /* return the number of decoded frames */
534 static int mp_decode_layer1(MPADecodeContext *s)
536 int bound, i, v, n, ch, j, mant;
537 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
538 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
540 if (s->mode == MPA_JSTEREO)
541 bound = (s->mode_ext + 1) * 4;
545 /* allocation bits */
546 for (i = 0; i < bound; i++) {
547 for (ch = 0; ch < s->nb_channels; ch++) {
548 allocation[ch][i] = get_bits(&s->gb, 4);
551 for (i = bound; i < SBLIMIT; i++)
552 allocation[0][i] = get_bits(&s->gb, 4);
555 for (i = 0; i < bound; i++) {
556 for (ch = 0; ch < s->nb_channels; ch++) {
557 if (allocation[ch][i])
558 scale_factors[ch][i] = get_bits(&s->gb, 6);
561 for (i = bound; i < SBLIMIT; i++) {
562 if (allocation[0][i]) {
563 scale_factors[0][i] = get_bits(&s->gb, 6);
564 scale_factors[1][i] = get_bits(&s->gb, 6);
568 /* compute samples */
569 for (j = 0; j < 12; j++) {
570 for (i = 0; i < bound; i++) {
571 for (ch = 0; ch < s->nb_channels; ch++) {
572 n = allocation[ch][i];
574 mant = get_bits(&s->gb, n + 1);
575 v = l1_unscale(n, mant, scale_factors[ch][i]);
579 s->sb_samples[ch][j][i] = v;
582 for (i = bound; i < SBLIMIT; i++) {
583 n = allocation[0][i];
585 mant = get_bits(&s->gb, n + 1);
586 v = l1_unscale(n, mant, scale_factors[0][i]);
587 s->sb_samples[0][j][i] = v;
588 v = l1_unscale(n, mant, scale_factors[1][i]);
589 s->sb_samples[1][j][i] = v;
591 s->sb_samples[0][j][i] = 0;
592 s->sb_samples[1][j][i] = 0;
599 static int mp_decode_layer2(MPADecodeContext *s)
601 int sblimit; /* number of used subbands */
602 const unsigned char *alloc_table;
603 int table, bit_alloc_bits, i, j, ch, bound, v;
604 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
605 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
606 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
607 int scale, qindex, bits, steps, k, l, m, b;
609 /* select decoding table */
610 table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
611 s->sample_rate, s->lsf);
612 sblimit = ff_mpa_sblimit_table[table];
613 alloc_table = ff_mpa_alloc_tables[table];
615 if (s->mode == MPA_JSTEREO)
616 bound = (s->mode_ext + 1) * 4;
620 av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
626 /* parse bit allocation */
628 for (i = 0; i < bound; i++) {
629 bit_alloc_bits = alloc_table[j];
630 for (ch = 0; ch < s->nb_channels; ch++)
631 bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
632 j += 1 << bit_alloc_bits;
634 for (i = bound; i < sblimit; i++) {
635 bit_alloc_bits = alloc_table[j];
636 v = get_bits(&s->gb, bit_alloc_bits);
639 j += 1 << bit_alloc_bits;
643 for (i = 0; i < sblimit; i++) {
644 for (ch = 0; ch < s->nb_channels; ch++) {
645 if (bit_alloc[ch][i])
646 scale_code[ch][i] = get_bits(&s->gb, 2);
651 for (i = 0; i < sblimit; i++) {
652 for (ch = 0; ch < s->nb_channels; ch++) {
653 if (bit_alloc[ch][i]) {
654 sf = scale_factors[ch][i];
655 switch (scale_code[ch][i]) {
658 sf[0] = get_bits(&s->gb, 6);
659 sf[1] = get_bits(&s->gb, 6);
660 sf[2] = get_bits(&s->gb, 6);
663 sf[0] = get_bits(&s->gb, 6);
668 sf[0] = get_bits(&s->gb, 6);
669 sf[2] = get_bits(&s->gb, 6);
673 sf[0] = get_bits(&s->gb, 6);
674 sf[2] = get_bits(&s->gb, 6);
683 for (k = 0; k < 3; k++) {
684 for (l = 0; l < 12; l += 3) {
686 for (i = 0; i < bound; i++) {
687 bit_alloc_bits = alloc_table[j];
688 for (ch = 0; ch < s->nb_channels; ch++) {
689 b = bit_alloc[ch][i];
691 scale = scale_factors[ch][i][k];
692 qindex = alloc_table[j+b];
693 bits = ff_mpa_quant_bits[qindex];
696 /* 3 values at the same time */
697 v = get_bits(&s->gb, -bits);
698 v2 = division_tabs[qindex][v];
699 steps = ff_mpa_quant_steps[qindex];
701 s->sb_samples[ch][k * 12 + l + 0][i] =
702 l2_unscale_group(steps, v2 & 15, scale);
703 s->sb_samples[ch][k * 12 + l + 1][i] =
704 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
705 s->sb_samples[ch][k * 12 + l + 2][i] =
706 l2_unscale_group(steps, v2 >> 8 , scale);
708 for (m = 0; m < 3; m++) {
709 v = get_bits(&s->gb, bits);
710 v = l1_unscale(bits - 1, v, scale);
711 s->sb_samples[ch][k * 12 + l + m][i] = v;
715 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
716 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
717 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
720 /* next subband in alloc table */
721 j += 1 << bit_alloc_bits;
723 /* XXX: find a way to avoid this duplication of code */
724 for (i = bound; i < sblimit; i++) {
725 bit_alloc_bits = alloc_table[j];
728 int mant, scale0, scale1;
729 scale0 = scale_factors[0][i][k];
730 scale1 = scale_factors[1][i][k];
731 qindex = alloc_table[j+b];
732 bits = ff_mpa_quant_bits[qindex];
734 /* 3 values at the same time */
735 v = get_bits(&s->gb, -bits);
736 steps = ff_mpa_quant_steps[qindex];
739 s->sb_samples[0][k * 12 + l + 0][i] =
740 l2_unscale_group(steps, mant, scale0);
741 s->sb_samples[1][k * 12 + l + 0][i] =
742 l2_unscale_group(steps, mant, scale1);
745 s->sb_samples[0][k * 12 + l + 1][i] =
746 l2_unscale_group(steps, mant, scale0);
747 s->sb_samples[1][k * 12 + l + 1][i] =
748 l2_unscale_group(steps, mant, scale1);
749 s->sb_samples[0][k * 12 + l + 2][i] =
750 l2_unscale_group(steps, v, scale0);
751 s->sb_samples[1][k * 12 + l + 2][i] =
752 l2_unscale_group(steps, v, scale1);
754 for (m = 0; m < 3; m++) {
755 mant = get_bits(&s->gb, bits);
756 s->sb_samples[0][k * 12 + l + m][i] =
757 l1_unscale(bits - 1, mant, scale0);
758 s->sb_samples[1][k * 12 + l + m][i] =
759 l1_unscale(bits - 1, mant, scale1);
763 s->sb_samples[0][k * 12 + l + 0][i] = 0;
764 s->sb_samples[0][k * 12 + l + 1][i] = 0;
765 s->sb_samples[0][k * 12 + l + 2][i] = 0;
766 s->sb_samples[1][k * 12 + l + 0][i] = 0;
767 s->sb_samples[1][k * 12 + l + 1][i] = 0;
768 s->sb_samples[1][k * 12 + l + 2][i] = 0;
770 /* next subband in alloc table */
771 j += 1 << bit_alloc_bits;
773 /* fill remaining samples to zero */
774 for (i = sblimit; i < SBLIMIT; i++) {
775 for (ch = 0; ch < s->nb_channels; ch++) {
776 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
777 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
778 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
786 #define SPLIT(dst,sf,n) \
788 int m = (sf * 171) >> 9; \
791 } else if (n == 4) { \
794 } else if (n == 5) { \
795 int m = (sf * 205) >> 10; \
798 } else if (n == 6) { \
799 int m = (sf * 171) >> 10; \
806 static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
809 SPLIT(slen[3], sf, n3)
810 SPLIT(slen[2], sf, n2)
811 SPLIT(slen[1], sf, n1)
815 static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
818 const uint8_t *bstab, *pretab;
819 int len, i, j, k, l, v0, shift, gain, gains[3];
823 gain = g->global_gain - 210;
824 shift = g->scalefac_scale + 1;
826 bstab = band_size_long[s->sample_rate_index];
827 pretab = mpa_pretab[g->preflag];
828 for (i = 0; i < g->long_end; i++) {
829 v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
831 for (j = len; j > 0; j--)
835 if (g->short_start < 13) {
836 bstab = band_size_short[s->sample_rate_index];
837 gains[0] = gain - (g->subblock_gain[0] << 3);
838 gains[1] = gain - (g->subblock_gain[1] << 3);
839 gains[2] = gain - (g->subblock_gain[2] << 3);
841 for (i = g->short_start; i < 13; i++) {
843 for (l = 0; l < 3; l++) {
844 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
845 for (j = len; j > 0; j--)
852 /* handle n = 0 too */
853 static inline int get_bitsz(GetBitContext *s, int n)
855 return n ? get_bits(s, n) : 0;
859 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
862 if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
864 s->in_gb.buffer = NULL;
865 assert((get_bits_count(&s->gb) & 7) == 0);
866 skip_bits_long(&s->gb, *pos - *end_pos);
868 *end_pos = *end_pos2 + get_bits_count(&s->gb) - *pos;
869 *pos = get_bits_count(&s->gb);
873 /* Following is a optimized code for
875 if(get_bits1(&s->gb))
880 #define READ_FLIP_SIGN(dst,src) \
881 v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31); \
884 #define READ_FLIP_SIGN(dst,src) \
885 v = -get_bits1(&s->gb); \
886 *(dst) = (*(src) ^ v) - v;
889 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
890 int16_t *exponents, int end_pos2)
894 int last_pos, bits_left;
896 int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
898 /* low frequencies (called big values) */
900 for (i = 0; i < 3; i++) {
901 int j, k, l, linbits;
902 j = g->region_size[i];
905 /* select vlc table */
906 k = g->table_select[i];
907 l = mpa_huff_data[k][0];
908 linbits = mpa_huff_data[k][1];
912 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
917 /* read huffcode and compute each couple */
921 int pos = get_bits_count(&s->gb);
924 // av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
925 switch_buffer(s, &pos, &end_pos, &end_pos2);
926 // av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
930 y = get_vlc2(&s->gb, vlc->table, 7, 3);
933 g->sb_hybrid[s_index ] =
934 g->sb_hybrid[s_index+1] = 0;
939 exponent= exponents[s_index];
941 av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
942 i, g->region_size[i] - j, x, y, exponent);
947 READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
949 x += get_bitsz(&s->gb, linbits);
950 v = l3_unscale(x, exponent);
951 if (get_bits1(&s->gb))
953 g->sb_hybrid[s_index] = v;
956 READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
958 y += get_bitsz(&s->gb, linbits);
959 v = l3_unscale(y, exponent);
960 if (get_bits1(&s->gb))
962 g->sb_hybrid[s_index+1] = v;
969 READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
971 x += get_bitsz(&s->gb, linbits);
972 v = l3_unscale(x, exponent);
973 if (get_bits1(&s->gb))
975 g->sb_hybrid[s_index+!!y] = v;
977 g->sb_hybrid[s_index + !y] = 0;
983 /* high frequencies */
984 vlc = &huff_quad_vlc[g->count1table_select];
986 while (s_index <= 572) {
988 pos = get_bits_count(&s->gb);
989 if (pos >= end_pos) {
990 if (pos > end_pos2 && last_pos) {
991 /* some encoders generate an incorrect size for this
992 part. We must go back into the data */
994 skip_bits_long(&s->gb, last_pos - pos);
995 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
996 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
1000 // av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
1001 switch_buffer(s, &pos, &end_pos, &end_pos2);
1002 // av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
1008 code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
1009 av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
1010 g->sb_hybrid[s_index+0] =
1011 g->sb_hybrid[s_index+1] =
1012 g->sb_hybrid[s_index+2] =
1013 g->sb_hybrid[s_index+3] = 0;
1015 static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
1017 int pos = s_index + idxtab[code];
1018 code ^= 8 >> idxtab[code];
1019 READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
1023 /* skip extension bits */
1024 bits_left = end_pos2 - get_bits_count(&s->gb);
1025 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
1026 if (bits_left < 0 && (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) {
1027 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
1029 } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE))) {
1030 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
1033 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
1034 skip_bits_long(&s->gb, bits_left);
1036 i = get_bits_count(&s->gb);
1037 switch_buffer(s, &i, &end_pos, &end_pos2);
1042 /* Reorder short blocks from bitstream order to interleaved order. It
1043 would be faster to do it in parsing, but the code would be far more
1045 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
1048 INTFLOAT *ptr, *dst, *ptr1;
1051 if (g->block_type != 2)
1054 if (g->switch_point) {
1055 if (s->sample_rate_index != 8)
1056 ptr = g->sb_hybrid + 36;
1058 ptr = g->sb_hybrid + 48;
1063 for (i = g->short_start; i < 13; i++) {
1064 len = band_size_short[s->sample_rate_index][i];
1067 for (j = len; j > 0; j--) {
1068 *dst++ = ptr[0*len];
1069 *dst++ = ptr[1*len];
1070 *dst++ = ptr[2*len];
1074 memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1078 #define ISQRT2 FIXR(0.70710678118654752440)
1080 static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1083 int sf_max, sf, len, non_zero_found;
1084 INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1085 int non_zero_found_short[3];
1087 /* intensity stereo */
1088 if (s->mode_ext & MODE_EXT_I_STEREO) {
1093 is_tab = is_table_lsf[g1->scalefac_compress & 1];
1097 tab0 = g0->sb_hybrid + 576;
1098 tab1 = g1->sb_hybrid + 576;
1100 non_zero_found_short[0] = 0;
1101 non_zero_found_short[1] = 0;
1102 non_zero_found_short[2] = 0;
1103 k = (13 - g1->short_start) * 3 + g1->long_end - 3;
1104 for (i = 12; i >= g1->short_start; i--) {
1105 /* for last band, use previous scale factor */
1108 len = band_size_short[s->sample_rate_index][i];
1109 for (l = 2; l >= 0; l--) {
1112 if (!non_zero_found_short[l]) {
1113 /* test if non zero band. if so, stop doing i-stereo */
1114 for (j = 0; j < len; j++) {
1116 non_zero_found_short[l] = 1;
1120 sf = g1->scale_factors[k + l];
1126 for (j = 0; j < len; j++) {
1128 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1129 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1133 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1134 /* lower part of the spectrum : do ms stereo
1136 for (j = 0; j < len; j++) {
1139 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1140 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1147 non_zero_found = non_zero_found_short[0] |
1148 non_zero_found_short[1] |
1149 non_zero_found_short[2];
1151 for (i = g1->long_end - 1;i >= 0;i--) {
1152 len = band_size_long[s->sample_rate_index][i];
1155 /* test if non zero band. if so, stop doing i-stereo */
1156 if (!non_zero_found) {
1157 for (j = 0; j < len; j++) {
1163 /* for last band, use previous scale factor */
1164 k = (i == 21) ? 20 : i;
1165 sf = g1->scale_factors[k];
1170 for (j = 0; j < len; j++) {
1172 tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1173 tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1177 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1178 /* lower part of the spectrum : do ms stereo
1180 for (j = 0; j < len; j++) {
1183 tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1184 tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1189 } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
1190 /* ms stereo ONLY */
1191 /* NOTE: the 1/sqrt(2) normalization factor is included in the
1193 tab0 = g0->sb_hybrid;
1194 tab1 = g1->sb_hybrid;
1195 for (i = 0; i < 576; i++) {
1198 tab0[i] = tmp0 + tmp1;
1199 tab1[i] = tmp0 - tmp1;
1205 #define AA(j) do { \
1206 float tmp0 = ptr[-1-j]; \
1207 float tmp1 = ptr[ j]; \
1208 ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
1209 ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
1212 #define AA(j) do { \
1213 int tmp0 = ptr[-1-j]; \
1214 int tmp1 = ptr[ j]; \
1215 int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
1216 ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2])); \
1217 ptr[ j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3])); \
1221 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1226 /* we antialias only "long" bands */
1227 if (g->block_type == 2) {
1228 if (!g->switch_point)
1230 /* XXX: check this for 8000Hz case */
1236 ptr = g->sb_hybrid + 18;
1237 for (i = n; i > 0; i--) {
1251 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
1252 INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1254 INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1256 int i, j, mdct_long_end, sblimit;
1258 /* find last non zero block */
1259 ptr = g->sb_hybrid + 576;
1260 ptr1 = g->sb_hybrid + 2 * 18;
1261 while (ptr >= ptr1) {
1265 if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1268 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
1270 if (g->block_type == 2) {
1271 /* XXX: check for 8000 Hz */
1272 if (g->switch_point)
1277 mdct_long_end = sblimit;
1282 for (j = 0; j < mdct_long_end; j++) {
1283 int win_idx = (g->switch_point && j < 2) ? 0 : g->block_type;
1284 /* apply window & overlap with previous buffer */
1285 out_ptr = sb_samples + j;
1287 win = mdct_win[win_idx + (4 & -(j & 1))];
1288 s->mpadsp.RENAME(imdct36)(out_ptr, buf, ptr, win);
1289 out_ptr += 18 * SBLIMIT;
1293 for (j = mdct_long_end; j < sblimit; j++) {
1294 /* select frequency inversion */
1295 win = mdct_win[2 + (4 & -(j & 1))];
1296 out_ptr = sb_samples + j;
1298 for (i = 0; i < 6; i++) {
1302 imdct12(out2, ptr + 0);
1303 for (i = 0; i < 6; i++) {
1304 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*1];
1305 buf[i + 6*2] = MULH3(out2[i + 6], win[i + 6], 1);
1308 imdct12(out2, ptr + 1);
1309 for (i = 0; i < 6; i++) {
1310 *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*2];
1311 buf[i + 6*0] = MULH3(out2[i + 6], win[i + 6], 1);
1314 imdct12(out2, ptr + 2);
1315 for (i = 0; i < 6; i++) {
1316 buf[i + 6*0] = MULH3(out2[i ], win[i ], 1) + buf[i + 6*0];
1317 buf[i + 6*1] = MULH3(out2[i + 6], win[i + 6], 1);
1324 for (j = sblimit; j < SBLIMIT; j++) {
1326 out_ptr = sb_samples + j;
1327 for (i = 0; i < 18; i++) {
1336 /* main layer3 decoding function */
1337 static int mp_decode_layer3(MPADecodeContext *s)
1339 int nb_granules, main_data_begin;
1340 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1342 int16_t exponents[576]; //FIXME try INTFLOAT
1344 /* read side info */
1346 main_data_begin = get_bits(&s->gb, 8);
1347 skip_bits(&s->gb, s->nb_channels);
1350 main_data_begin = get_bits(&s->gb, 9);
1351 if (s->nb_channels == 2)
1352 skip_bits(&s->gb, 3);
1354 skip_bits(&s->gb, 5);
1356 for (ch = 0; ch < s->nb_channels; ch++) {
1357 s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
1358 s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1362 for (gr = 0; gr < nb_granules; gr++) {
1363 for (ch = 0; ch < s->nb_channels; ch++) {
1364 av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1365 g = &s->granules[ch][gr];
1366 g->part2_3_length = get_bits(&s->gb, 12);
1367 g->big_values = get_bits(&s->gb, 9);
1368 if (g->big_values > 288) {
1369 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1370 return AVERROR_INVALIDDATA;
1373 g->global_gain = get_bits(&s->gb, 8);
1374 /* if MS stereo only is selected, we precompute the
1375 1/sqrt(2) renormalization factor */
1376 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1378 g->global_gain -= 2;
1380 g->scalefac_compress = get_bits(&s->gb, 9);
1382 g->scalefac_compress = get_bits(&s->gb, 4);
1383 blocksplit_flag = get_bits1(&s->gb);
1384 if (blocksplit_flag) {
1385 g->block_type = get_bits(&s->gb, 2);
1386 if (g->block_type == 0) {
1387 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1388 return AVERROR_INVALIDDATA;
1390 g->switch_point = get_bits1(&s->gb);
1391 for (i = 0; i < 2; i++)
1392 g->table_select[i] = get_bits(&s->gb, 5);
1393 for (i = 0; i < 3; i++)
1394 g->subblock_gain[i] = get_bits(&s->gb, 3);
1395 ff_init_short_region(s, g);
1397 int region_address1, region_address2;
1399 g->switch_point = 0;
1400 for (i = 0; i < 3; i++)
1401 g->table_select[i] = get_bits(&s->gb, 5);
1402 /* compute huffman coded region sizes */
1403 region_address1 = get_bits(&s->gb, 4);
1404 region_address2 = get_bits(&s->gb, 3);
1405 av_dlog(s->avctx, "region1=%d region2=%d\n",
1406 region_address1, region_address2);
1407 ff_init_long_region(s, g, region_address1, region_address2);
1409 ff_region_offset2size(g);
1410 ff_compute_band_indexes(s, g);
1414 g->preflag = get_bits1(&s->gb);
1415 g->scalefac_scale = get_bits1(&s->gb);
1416 g->count1table_select = get_bits1(&s->gb);
1417 av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1418 g->block_type, g->switch_point);
1423 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1424 assert((get_bits_count(&s->gb) & 7) == 0);
1425 /* now we get bits from the main_data_begin offset */
1426 av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1427 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1429 memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
1431 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1432 skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
1435 for (gr = 0; gr < nb_granules; gr++) {
1436 for (ch = 0; ch < s->nb_channels; ch++) {
1437 g = &s->granules[ch][gr];
1438 if (get_bits_count(&s->gb) < 0) {
1439 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",
1440 main_data_begin, s->last_buf_size, gr);
1441 skip_bits_long(&s->gb, g->part2_3_length);
1442 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1443 if (get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer) {
1444 skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
1446 s->in_gb.buffer = NULL;
1451 bits_pos = get_bits_count(&s->gb);
1455 int slen, slen1, slen2;
1457 /* MPEG1 scale factors */
1458 slen1 = slen_table[0][g->scalefac_compress];
1459 slen2 = slen_table[1][g->scalefac_compress];
1460 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1461 if (g->block_type == 2) {
1462 n = g->switch_point ? 17 : 18;
1465 for (i = 0; i < n; i++)
1466 g->scale_factors[j++] = get_bits(&s->gb, slen1);
1468 for (i = 0; i < n; i++)
1469 g->scale_factors[j++] = 0;
1472 for (i = 0; i < 18; i++)
1473 g->scale_factors[j++] = get_bits(&s->gb, slen2);
1474 for (i = 0; i < 3; i++)
1475 g->scale_factors[j++] = 0;
1477 for (i = 0; i < 21; i++)
1478 g->scale_factors[j++] = 0;
1481 sc = s->granules[ch][0].scale_factors;
1483 for (k = 0; k < 4; k++) {
1485 if ((g->scfsi & (0x8 >> k)) == 0) {
1486 slen = (k < 2) ? slen1 : slen2;
1488 for (i = 0; i < n; i++)
1489 g->scale_factors[j++] = get_bits(&s->gb, slen);
1491 for (i = 0; i < n; i++)
1492 g->scale_factors[j++] = 0;
1495 /* simply copy from last granule */
1496 for (i = 0; i < n; i++) {
1497 g->scale_factors[j] = sc[j];
1502 g->scale_factors[j++] = 0;
1505 int tindex, tindex2, slen[4], sl, sf;
1507 /* LSF scale factors */
1508 if (g->block_type == 2)
1509 tindex = g->switch_point ? 2 : 1;
1513 sf = g->scalefac_compress;
1514 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1515 /* intensity stereo case */
1518 lsf_sf_expand(slen, sf, 6, 6, 0);
1520 } else if (sf < 244) {
1521 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1524 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1530 lsf_sf_expand(slen, sf, 5, 4, 4);
1532 } else if (sf < 500) {
1533 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1536 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1543 for (k = 0; k < 4; k++) {
1544 n = lsf_nsf_table[tindex2][tindex][k];
1547 for (i = 0; i < n; i++)
1548 g->scale_factors[j++] = get_bits(&s->gb, sl);
1550 for (i = 0; i < n; i++)
1551 g->scale_factors[j++] = 0;
1554 /* XXX: should compute exact size */
1556 g->scale_factors[j] = 0;
1559 exponents_from_scale_factors(s, g, exponents);
1561 /* read Huffman coded residue */
1562 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1565 if (s->nb_channels == 2)
1566 compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1568 for (ch = 0; ch < s->nb_channels; ch++) {
1569 g = &s->granules[ch][gr];
1571 reorder_block(s, g);
1572 compute_antialias(s, g);
1573 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1576 if (get_bits_count(&s->gb) < 0)
1577 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1578 return nb_granules * 18;
1581 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1582 const uint8_t *buf, int buf_size)
1584 int i, nb_frames, ch;
1585 OUT_INT *samples_ptr;
1587 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1589 /* skip error protection field */
1590 if (s->error_protection)
1591 skip_bits(&s->gb, 16);
1595 s->avctx->frame_size = 384;
1596 nb_frames = mp_decode_layer1(s);
1599 s->avctx->frame_size = 1152;
1600 nb_frames = mp_decode_layer2(s);
1603 s->avctx->frame_size = s->lsf ? 576 : 1152;
1605 nb_frames = mp_decode_layer3(s);
1608 if (s->in_gb.buffer) {
1609 align_get_bits(&s->gb);
1610 i = get_bits_left(&s->gb)>>3;
1611 if (i >= 0 && i <= BACKSTEP_SIZE) {
1612 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1615 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1617 s->in_gb.buffer = NULL;
1620 align_get_bits(&s->gb);
1621 assert((get_bits_count(&s->gb) & 7) == 0);
1622 i = get_bits_left(&s->gb) >> 3;
1624 if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1626 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1627 i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1629 assert(i <= buf_size - HEADER_SIZE && i >= 0);
1630 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1631 s->last_buf_size += i;
1636 /* apply the synthesis filter */
1637 for (ch = 0; ch < s->nb_channels; ch++) {
1638 samples_ptr = samples + ch;
1639 for (i = 0; i < nb_frames; i++) {
1640 RENAME(ff_mpa_synth_filter)(
1642 s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1643 RENAME(ff_mpa_synth_window), &s->dither_state,
1644 samples_ptr, s->nb_channels,
1645 s->sb_samples[ch][i]);
1646 samples_ptr += 32 * s->nb_channels;
1650 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1653 static int decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1656 const uint8_t *buf = avpkt->data;
1657 int buf_size = avpkt->size;
1658 MPADecodeContext *s = avctx->priv_data;
1661 OUT_INT *out_samples = data;
1663 if (buf_size < HEADER_SIZE)
1664 return AVERROR_INVALIDDATA;
1666 header = AV_RB32(buf);
1667 if (ff_mpa_check_header(header) < 0) {
1668 av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1669 return AVERROR_INVALIDDATA;
1672 if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1673 /* free format: prepare to compute frame size */
1675 return AVERROR_INVALIDDATA;
1677 /* update codec info */
1678 avctx->channels = s->nb_channels;
1679 avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1680 if (!avctx->bit_rate)
1681 avctx->bit_rate = s->bit_rate;
1682 avctx->sub_id = s->layer;
1684 if (*data_size < avctx->frame_size * avctx->channels * sizeof(OUT_INT))
1685 return AVERROR(EINVAL);
1688 if (s->frame_size <= 0 || s->frame_size > buf_size) {
1689 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1690 return AVERROR_INVALIDDATA;
1691 }else if(s->frame_size < buf_size){
1692 av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
1693 buf_size= s->frame_size;
1696 out_size = mp_decode_frame(s, out_samples, buf, buf_size);
1697 if (out_size >= 0) {
1698 *data_size = out_size;
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
1707 if (buf_size == avpkt->size)
1714 static void flush(AVCodecContext *avctx)
1716 MPADecodeContext *s = avctx->priv_data;
1717 memset(s->synth_buf, 0, sizeof(s->synth_buf));
1718 s->last_buf_size = 0;
1721 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1722 static int decode_frame_adu(AVCodecContext *avctx, void *data, int *data_size,
1725 const uint8_t *buf = avpkt->data;
1726 int buf_size = avpkt->size;
1727 MPADecodeContext *s = avctx->priv_data;
1730 OUT_INT *out_samples = data;
1734 // Discard too short frames
1735 if (buf_size < HEADER_SIZE) {
1736 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1737 return AVERROR_INVALIDDATA;
1741 if (len > MPA_MAX_CODED_FRAME_SIZE)
1742 len = MPA_MAX_CODED_FRAME_SIZE;
1744 // Get header and restore sync word
1745 header = AV_RB32(buf) | 0xffe00000;
1747 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1748 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1749 return AVERROR_INVALIDDATA;
1752 avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1753 /* update codec info */
1754 avctx->sample_rate = s->sample_rate;
1755 avctx->channels = s->nb_channels;
1756 if (!avctx->bit_rate)
1757 avctx->bit_rate = s->bit_rate;
1758 avctx->sub_id = s->layer;
1760 if (*data_size < avctx->frame_size * avctx->channels * sizeof(OUT_INT))
1761 return AVERROR(EINVAL);
1763 s->frame_size = len;
1765 #if FF_API_PARSE_FRAME
1766 if (avctx->parse_only)
1767 out_size = buf_size;
1770 out_size = mp_decode_frame(s, out_samples, buf, buf_size);
1772 *data_size = out_size;
1775 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1777 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1780 * Context for MP3On4 decoder
1782 typedef struct MP3On4DecodeContext {
1783 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
1784 int syncword; ///< syncword patch
1785 const uint8_t *coff; ///< channel offsets in output buffer
1786 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1787 OUT_INT *decoded_buf; ///< output buffer for decoded samples
1788 } MP3On4DecodeContext;
1790 #include "mpeg4audio.h"
1792 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1794 /* number of mp3 decoder instances */
1795 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1797 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1798 static const uint8_t chan_offset[8][5] = {
1803 { 2, 0, 3 }, // C FLR BS
1804 { 2, 0, 3 }, // C FLR BLRS
1805 { 2, 0, 4, 3 }, // C FLR BLRS LFE
1806 { 2, 0, 6, 4, 3 }, // C FLR BLRS BLR LFE
1809 /* mp3on4 channel layouts */
1810 static const int16_t chan_layout[8] = {
1813 AV_CH_LAYOUT_STEREO,
1814 AV_CH_LAYOUT_SURROUND,
1815 AV_CH_LAYOUT_4POINT0,
1816 AV_CH_LAYOUT_5POINT0,
1817 AV_CH_LAYOUT_5POINT1,
1818 AV_CH_LAYOUT_7POINT1
1821 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1823 MP3On4DecodeContext *s = avctx->priv_data;
1826 for (i = 0; i < s->frames; i++)
1827 av_free(s->mp3decctx[i]);
1829 av_freep(&s->decoded_buf);
1835 static int decode_init_mp3on4(AVCodecContext * avctx)
1837 MP3On4DecodeContext *s = avctx->priv_data;
1838 MPEG4AudioConfig cfg;
1841 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1842 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1843 return AVERROR_INVALIDDATA;
1846 avpriv_mpeg4audio_get_config(&cfg, avctx->extradata, avctx->extradata_size);
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 // Restore mp3on4 context pointer
1874 avctx->priv_data = s;
1875 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1877 /* Create a separate codec/context for each frame (first is already ok).
1878 * Each frame is 1 or 2 channels - up to 5 frames allowed
1880 for (i = 1; i < s->frames; i++) {
1881 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1882 if (!s->mp3decctx[i])
1884 s->mp3decctx[i]->adu_mode = 1;
1885 s->mp3decctx[i]->avctx = avctx;
1886 s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1889 /* Allocate buffer for multi-channel output if needed */
1890 if (s->frames > 1) {
1891 s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1892 sizeof(*s->decoded_buf));
1893 if (!s->decoded_buf)
1899 decode_close_mp3on4(avctx);
1900 return AVERROR(ENOMEM);
1904 static void flush_mp3on4(AVCodecContext *avctx)
1907 MP3On4DecodeContext *s = avctx->priv_data;
1909 for (i = 0; i < s->frames; i++) {
1910 MPADecodeContext *m = s->mp3decctx[i];
1911 memset(m->synth_buf, 0, sizeof(m->synth_buf));
1912 m->last_buf_size = 0;
1917 static int decode_frame_mp3on4(AVCodecContext * avctx,
1918 void *data, int *data_size,
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 = data;
1928 OUT_INT *outptr, *bp;
1931 if (*data_size < MPA_FRAME_SIZE * avctx->channels * sizeof(OUT_INT)) {
1932 av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
1933 return AVERROR(EINVAL);
1936 // Discard too short frames
1937 if (buf_size < HEADER_SIZE)
1938 return AVERROR_INVALIDDATA;
1940 // If only one decoder interleave is not needed
1941 outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1943 avctx->bit_rate = 0;
1946 for (fr = 0; fr < s->frames; fr++) {
1947 fsize = AV_RB16(buf) >> 4;
1948 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1949 m = s->mp3decctx[fr];
1952 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1954 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1957 avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1959 if (ch + m->nb_channels > avctx->channels) {
1960 av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1962 return AVERROR_INVALIDDATA;
1964 ch += m->nb_channels;
1966 out_size += mp_decode_frame(m, outptr, buf, fsize);
1970 if (s->frames > 1) {
1971 n = m->avctx->frame_size*m->nb_channels;
1972 /* interleave output data */
1973 bp = out_samples + s->coff[fr];
1974 if (m->nb_channels == 1) {
1975 for (j = 0; j < n; j++) {
1976 *bp = s->decoded_buf[j];
1977 bp += avctx->channels;
1980 for (j = 0; j < n; j++) {
1981 bp[0] = s->decoded_buf[j++];
1982 bp[1] = s->decoded_buf[j];
1983 bp += avctx->channels;
1987 avctx->bit_rate += m->bit_rate;
1990 /* update codec info */
1991 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
1993 *data_size = out_size;
1996 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
1999 #if CONFIG_MP1_DECODER
2000 AVCodec ff_mp1_decoder = {
2002 .type = AVMEDIA_TYPE_AUDIO,
2004 .priv_data_size = sizeof(MPADecodeContext),
2005 .init = decode_init,
2006 .decode = decode_frame,
2007 #if FF_API_PARSE_FRAME
2008 .capabilities = CODEC_CAP_PARSE_ONLY,
2011 .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
2014 #if CONFIG_MP2_DECODER
2015 AVCodec ff_mp2_decoder = {
2017 .type = AVMEDIA_TYPE_AUDIO,
2019 .priv_data_size = sizeof(MPADecodeContext),
2020 .init = decode_init,
2021 .decode = decode_frame,
2022 #if FF_API_PARSE_FRAME
2023 .capabilities = CODEC_CAP_PARSE_ONLY,
2026 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2029 #if CONFIG_MP3_DECODER
2030 AVCodec ff_mp3_decoder = {
2032 .type = AVMEDIA_TYPE_AUDIO,
2034 .priv_data_size = sizeof(MPADecodeContext),
2035 .init = decode_init,
2036 .decode = decode_frame,
2037 #if FF_API_PARSE_FRAME
2038 .capabilities = CODEC_CAP_PARSE_ONLY,
2041 .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2044 #if CONFIG_MP3ADU_DECODER
2045 AVCodec ff_mp3adu_decoder = {
2047 .type = AVMEDIA_TYPE_AUDIO,
2048 .id = CODEC_ID_MP3ADU,
2049 .priv_data_size = sizeof(MPADecodeContext),
2050 .init = decode_init,
2051 .decode = decode_frame_adu,
2052 #if FF_API_PARSE_FRAME
2053 .capabilities = CODEC_CAP_PARSE_ONLY,
2056 .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2059 #if CONFIG_MP3ON4_DECODER
2060 AVCodec ff_mp3on4_decoder = {
2062 .type = AVMEDIA_TYPE_AUDIO,
2063 .id = CODEC_ID_MP3ON4,
2064 .priv_data_size = sizeof(MP3On4DecodeContext),
2065 .init = decode_init_mp3on4,
2066 .close = decode_close_mp3on4,
2067 .decode = decode_frame_mp3on4,
2068 .flush = flush_mp3on4,
2069 .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),