mp3dec: perform I/S and M/S only when frame mode is joint stereo.
[ffmpeg.git] / libavcodec / mpegaudiodec.c
1 /*
2  * MPEG Audio decoder
3  * Copyright (c) 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * MPEG Audio decoder
25  */
26
27 #include "libavutil/audioconvert.h"
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "mathops.h"
31 #include "mpegaudiodsp.h"
32 #include "dsputil.h"
33
34 /*
35  * TODO:
36  *  - test lsf / mpeg25 extensively.
37  */
38
39 #include "mpegaudio.h"
40 #include "mpegaudiodecheader.h"
41
42 #define BACKSTEP_SIZE 512
43 #define EXTRABYTES 24
44 #define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
45
46 /* layer 3 "granule" */
47 typedef struct GranuleDef {
48     uint8_t scfsi;
49     int part2_3_length;
50     int big_values;
51     int global_gain;
52     int scalefac_compress;
53     uint8_t block_type;
54     uint8_t switch_point;
55     int table_select[3];
56     int subblock_gain[3];
57     uint8_t scalefac_scale;
58     uint8_t count1table_select;
59     int region_size[3]; /* number of huffman codes in each region */
60     int preflag;
61     int short_start, long_end; /* long/short band indexes */
62     uint8_t scale_factors[40];
63     DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
64 } GranuleDef;
65
66 typedef struct MPADecodeContext {
67     MPA_DECODE_HEADER
68     uint8_t last_buf[LAST_BUF_SIZE];
69     int last_buf_size;
70     /* next header (used in free format parsing) */
71     uint32_t free_format_next_header;
72     GetBitContext gb;
73     GetBitContext in_gb;
74     DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
75     int synth_buf_offset[MPA_MAX_CHANNELS];
76     DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
77     INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
78     GranuleDef granules[2][2]; /* Used in Layer 3 */
79     int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
80     int dither_state;
81     int err_recognition;
82     AVCodecContext* avctx;
83     MPADSPContext mpadsp;
84     DSPContext dsp;
85     AVFrame frame;
86 } MPADecodeContext;
87
88 #if CONFIG_FLOAT
89 #   define SHR(a,b)       ((a)*(1.0f/(1<<(b))))
90 #   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
91 #   define FIXR(x)        ((float)(x))
92 #   define FIXHR(x)       ((float)(x))
93 #   define MULH3(x, y, s) ((s)*(y)*(x))
94 #   define MULLx(x, y, s) ((y)*(x))
95 #   define RENAME(a) a ## _float
96 #   define OUT_FMT AV_SAMPLE_FMT_FLT
97 #else
98 #   define SHR(a,b)       ((a)>>(b))
99 /* WARNING: only correct for positive numbers */
100 #   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
101 #   define FIXR(a)        ((int)((a) * FRAC_ONE + 0.5))
102 #   define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))
103 #   define MULH3(x, y, s) MULH((s)*(x), y)
104 #   define MULLx(x, y, s) MULL(x,y,s)
105 #   define RENAME(a)      a ## _fixed
106 #   define OUT_FMT AV_SAMPLE_FMT_S16
107 #endif
108
109 /****************/
110
111 #define HEADER_SIZE 4
112
113 #include "mpegaudiodata.h"
114 #include "mpegaudiodectab.h"
115
116 /* vlc structure for decoding layer 3 huffman tables */
117 static VLC huff_vlc[16];
118 static VLC_TYPE huff_vlc_tables[
119     0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
120   142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
121   ][2];
122 static const int huff_vlc_tables_sizes[16] = {
123     0,  128,  128,  128,  130,  128,  154,  166,
124   142,  204,  190,  170,  542,  460,  662,  414
125 };
126 static VLC huff_quad_vlc[2];
127 static VLC_TYPE  huff_quad_vlc_tables[128+16][2];
128 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
129 /* computed from band_size_long */
130 static uint16_t band_index_long[9][23];
131 #include "mpegaudio_tablegen.h"
132 /* intensity stereo coef table */
133 static INTFLOAT is_table[2][16];
134 static INTFLOAT is_table_lsf[2][2][16];
135 static INTFLOAT csa_table[8][4];
136
137 static int16_t division_tab3[1<<6 ];
138 static int16_t division_tab5[1<<8 ];
139 static int16_t division_tab9[1<<11];
140
141 static int16_t * const division_tabs[4] = {
142     division_tab3, division_tab5, NULL, division_tab9
143 };
144
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 */
150
151 #define SCALE_GEN(v) \
152 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
153
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 */
158 };
159
160 /**
161  * Convert region offsets to region sizes and truncate
162  * size to big_values.
163  */
164 static void ff_region_offset2size(GranuleDef *g)
165 {
166     int i, k, j = 0;
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;
171         j = k;
172     }
173 }
174
175 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
176 {
177     if (g->block_type == 2)
178         g->region_size[0] = (36 / 2);
179     else {
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);
184         else
185             g->region_size[0] = (108 / 2);
186     }
187     g->region_size[1] = (576 / 2);
188 }
189
190 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
191 {
192     int l;
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;
197 }
198
199 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
200 {
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)
207                 g->long_end = 8;
208             else if (s->sample_rate_index != 8)
209                 g->long_end = 6;
210             else
211                 g->long_end = 4; /* 8000 Hz */
212
213             g->short_start = 2 + (s->sample_rate_index != 8);
214         } else {
215             g->long_end    = 0;
216             g->short_start = 0;
217         }
218     } else {
219         g->short_start = 13;
220         g->long_end    = 22;
221     }
222 }
223
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)
227 {
228     int shift, mod;
229     int64_t val;
230
231     shift   = scale_factor_modshift[scale_factor];
232     mod     = shift & 3;
233     shift >>= 2;
234     val     = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
235     shift  += n;
236     /* NOTE: at this point, 1 <= shift >= 21 + 15 */
237     return (int)((val + (1LL << (shift - 1))) >> shift);
238 }
239
240 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
241 {
242     int shift, mod, val;
243
244     shift   = scale_factor_modshift[scale_factor];
245     mod     = shift & 3;
246     shift >>= 2;
247
248     val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
249     /* NOTE: at this point, 0 <= shift <= 21 */
250     if (shift > 0)
251         val = (val + (1 << (shift - 1))) >> shift;
252     return val;
253 }
254
255 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
256 static inline int l3_unscale(int value, int exponent)
257 {
258     unsigned int m;
259     int e;
260
261     e  = table_4_3_exp  [4 * value + (exponent & 3)];
262     m  = table_4_3_value[4 * value + (exponent & 3)];
263     e -= exponent >> 2;
264     assert(e >= 1);
265     if (e > 31)
266         return 0;
267     m = (m + (1 << (e - 1))) >> e;
268
269     return m;
270 }
271
272 static av_cold void decode_init_static(void)
273 {
274     int i, j, k;
275     int offset;
276
277     /* scale factors table for layer 1/2 */
278     for (i = 0; i < 64; i++) {
279         int shift, mod;
280         /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
281         shift = i / 3;
282         mod   = i % 3;
283         scale_factor_modshift[i] = mod | (shift << 2);
284     }
285
286     /* scale factor multiply for layer 1 */
287     for (i = 0; i < 15; i++) {
288         int n, norm;
289         n = i + 2;
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]);
298     }
299
300     RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
301
302     /* huffman decode tables */
303     offset = 0;
304     for (i = 1; i < 16; i++) {
305         const HuffTable *h = &mpa_huff_tables[i];
306         int xsize, x, y;
307         uint8_t  tmp_bits [512] = { 0 };
308         uint16_t tmp_codes[512] = { 0 };
309
310         xsize = h->xsize;
311
312         j = 0;
313         for (x = 0; x < xsize; x++) {
314             for (y = 0; y < xsize; y++) {
315                 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j  ];
316                 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
317             }
318         }
319
320         /* XXX: fail test */
321         huff_vlc[i].table = huff_vlc_tables+offset;
322         huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
323         init_vlc(&huff_vlc[i], 7, 512,
324                  tmp_bits, 1, 1, tmp_codes, 2, 2,
325                  INIT_VLC_USE_NEW_STATIC);
326         offset += huff_vlc_tables_sizes[i];
327     }
328     assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
329
330     offset = 0;
331     for (i = 0; i < 2; i++) {
332         huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
333         huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
334         init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
335                  mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
336                  INIT_VLC_USE_NEW_STATIC);
337         offset += huff_quad_vlc_tables_sizes[i];
338     }
339     assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
340
341     for (i = 0; i < 9; i++) {
342         k = 0;
343         for (j = 0; j < 22; j++) {
344             band_index_long[i][j] = k;
345             k += band_size_long[i][j];
346         }
347         band_index_long[i][22] = k;
348     }
349
350     /* compute n ^ (4/3) and store it in mantissa/exp format */
351
352     mpegaudio_tableinit();
353
354     for (i = 0; i < 4; i++) {
355         if (ff_mpa_quant_bits[i] < 0) {
356             for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
357                 int val1, val2, val3, steps;
358                 int val = j;
359                 steps   = ff_mpa_quant_steps[i];
360                 val1    = val % steps;
361                 val    /= steps;
362                 val2    = val % steps;
363                 val3    = val / steps;
364                 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
365             }
366         }
367     }
368
369
370     for (i = 0; i < 7; i++) {
371         float f;
372         INTFLOAT v;
373         if (i != 6) {
374             f = tan((double)i * M_PI / 12.0);
375             v = FIXR(f / (1.0 + f));
376         } else {
377             v = FIXR(1.0);
378         }
379         is_table[0][    i] = v;
380         is_table[1][6 - i] = v;
381     }
382     /* invalid values */
383     for (i = 7; i < 16; i++)
384         is_table[0][i] = is_table[1][i] = 0.0;
385
386     for (i = 0; i < 16; i++) {
387         double f;
388         int e, k;
389
390         for (j = 0; j < 2; j++) {
391             e = -(j + 1) * ((i + 1) >> 1);
392             f = pow(2.0, e / 4.0);
393             k = i & 1;
394             is_table_lsf[j][k ^ 1][i] = FIXR(f);
395             is_table_lsf[j][k    ][i] = FIXR(1.0);
396             av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
397                     i, j, (float) is_table_lsf[j][0][i],
398                     (float) is_table_lsf[j][1][i]);
399         }
400     }
401
402     for (i = 0; i < 8; i++) {
403         float ci, cs, ca;
404         ci = ci_table[i];
405         cs = 1.0 / sqrt(1.0 + ci * ci);
406         ca = cs * ci;
407 #if !CONFIG_FLOAT
408         csa_table[i][0] = FIXHR(cs/4);
409         csa_table[i][1] = FIXHR(ca/4);
410         csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
411         csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
412 #else
413         csa_table[i][0] = cs;
414         csa_table[i][1] = ca;
415         csa_table[i][2] = ca + cs;
416         csa_table[i][3] = ca - cs;
417 #endif
418     }
419 }
420
421 static av_cold int decode_init(AVCodecContext * avctx)
422 {
423     static int initialized_tables = 0;
424     MPADecodeContext *s = avctx->priv_data;
425
426     if (!initialized_tables) {
427         decode_init_static();
428         initialized_tables = 1;
429     }
430
431     s->avctx = avctx;
432
433     ff_mpadsp_init(&s->mpadsp);
434     ff_dsputil_init(&s->dsp, avctx);
435
436     avctx->sample_fmt= OUT_FMT;
437     s->err_recognition = avctx->err_recognition;
438
439     if (avctx->codec_id == CODEC_ID_MP3ADU)
440         s->adu_mode = 1;
441
442     avcodec_get_frame_defaults(&s->frame);
443     avctx->coded_frame = &s->frame;
444
445     return 0;
446 }
447
448 #define C3 FIXHR(0.86602540378443864676/2)
449 #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
450 #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
451 #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
452
453 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
454    cases. */
455 static void imdct12(INTFLOAT *out, INTFLOAT *in)
456 {
457     INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
458
459     in0  = in[0*3];
460     in1  = in[1*3] + in[0*3];
461     in2  = in[2*3] + in[1*3];
462     in3  = in[3*3] + in[2*3];
463     in4  = in[4*3] + in[3*3];
464     in5  = in[5*3] + in[4*3];
465     in5 += in3;
466     in3 += in1;
467
468     in2  = MULH3(in2, C3, 2);
469     in3  = MULH3(in3, C3, 4);
470
471     t1   = in0 - in4;
472     t2   = MULH3(in1 - in5, C4, 2);
473
474     out[ 7] =
475     out[10] = t1 + t2;
476     out[ 1] =
477     out[ 4] = t1 - t2;
478
479     in0    += SHR(in4, 1);
480     in4     = in0 + in2;
481     in5    += 2*in1;
482     in1     = MULH3(in5 + in3, C5, 1);
483     out[ 8] =
484     out[ 9] = in4 + in1;
485     out[ 2] =
486     out[ 3] = in4 - in1;
487
488     in0    -= in2;
489     in5     = MULH3(in5 - in3, C6, 2);
490     out[ 0] =
491     out[ 5] = in0 - in5;
492     out[ 6] =
493     out[11] = in0 + in5;
494 }
495
496 /* return the number of decoded frames */
497 static int mp_decode_layer1(MPADecodeContext *s)
498 {
499     int bound, i, v, n, ch, j, mant;
500     uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
501     uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
502
503     if (s->mode == MPA_JSTEREO)
504         bound = (s->mode_ext + 1) * 4;
505     else
506         bound = SBLIMIT;
507
508     /* allocation bits */
509     for (i = 0; i < bound; i++) {
510         for (ch = 0; ch < s->nb_channels; ch++) {
511             allocation[ch][i] = get_bits(&s->gb, 4);
512         }
513     }
514     for (i = bound; i < SBLIMIT; i++)
515         allocation[0][i] = get_bits(&s->gb, 4);
516
517     /* scale factors */
518     for (i = 0; i < bound; i++) {
519         for (ch = 0; ch < s->nb_channels; ch++) {
520             if (allocation[ch][i])
521                 scale_factors[ch][i] = get_bits(&s->gb, 6);
522         }
523     }
524     for (i = bound; i < SBLIMIT; i++) {
525         if (allocation[0][i]) {
526             scale_factors[0][i] = get_bits(&s->gb, 6);
527             scale_factors[1][i] = get_bits(&s->gb, 6);
528         }
529     }
530
531     /* compute samples */
532     for (j = 0; j < 12; j++) {
533         for (i = 0; i < bound; i++) {
534             for (ch = 0; ch < s->nb_channels; ch++) {
535                 n = allocation[ch][i];
536                 if (n) {
537                     mant = get_bits(&s->gb, n + 1);
538                     v = l1_unscale(n, mant, scale_factors[ch][i]);
539                 } else {
540                     v = 0;
541                 }
542                 s->sb_samples[ch][j][i] = v;
543             }
544         }
545         for (i = bound; i < SBLIMIT; i++) {
546             n = allocation[0][i];
547             if (n) {
548                 mant = get_bits(&s->gb, n + 1);
549                 v = l1_unscale(n, mant, scale_factors[0][i]);
550                 s->sb_samples[0][j][i] = v;
551                 v = l1_unscale(n, mant, scale_factors[1][i]);
552                 s->sb_samples[1][j][i] = v;
553             } else {
554                 s->sb_samples[0][j][i] = 0;
555                 s->sb_samples[1][j][i] = 0;
556             }
557         }
558     }
559     return 12;
560 }
561
562 static int mp_decode_layer2(MPADecodeContext *s)
563 {
564     int sblimit; /* number of used subbands */
565     const unsigned char *alloc_table;
566     int table, bit_alloc_bits, i, j, ch, bound, v;
567     unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
568     unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
569     unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
570     int scale, qindex, bits, steps, k, l, m, b;
571
572     /* select decoding table */
573     table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
574                                    s->sample_rate, s->lsf);
575     sblimit     = ff_mpa_sblimit_table[table];
576     alloc_table = ff_mpa_alloc_tables[table];
577
578     if (s->mode == MPA_JSTEREO)
579         bound = (s->mode_ext + 1) * 4;
580     else
581         bound = sblimit;
582
583     av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
584
585     /* sanity check */
586     if (bound > sblimit)
587         bound = sblimit;
588
589     /* parse bit allocation */
590     j = 0;
591     for (i = 0; i < bound; i++) {
592         bit_alloc_bits = alloc_table[j];
593         for (ch = 0; ch < s->nb_channels; ch++)
594             bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
595         j += 1 << bit_alloc_bits;
596     }
597     for (i = bound; i < sblimit; i++) {
598         bit_alloc_bits = alloc_table[j];
599         v = get_bits(&s->gb, bit_alloc_bits);
600         bit_alloc[0][i] = v;
601         bit_alloc[1][i] = v;
602         j += 1 << bit_alloc_bits;
603     }
604
605     /* scale codes */
606     for (i = 0; i < sblimit; i++) {
607         for (ch = 0; ch < s->nb_channels; ch++) {
608             if (bit_alloc[ch][i])
609                 scale_code[ch][i] = get_bits(&s->gb, 2);
610         }
611     }
612
613     /* scale factors */
614     for (i = 0; i < sblimit; i++) {
615         for (ch = 0; ch < s->nb_channels; ch++) {
616             if (bit_alloc[ch][i]) {
617                 sf = scale_factors[ch][i];
618                 switch (scale_code[ch][i]) {
619                 default:
620                 case 0:
621                     sf[0] = get_bits(&s->gb, 6);
622                     sf[1] = get_bits(&s->gb, 6);
623                     sf[2] = get_bits(&s->gb, 6);
624                     break;
625                 case 2:
626                     sf[0] = get_bits(&s->gb, 6);
627                     sf[1] = sf[0];
628                     sf[2] = sf[0];
629                     break;
630                 case 1:
631                     sf[0] = get_bits(&s->gb, 6);
632                     sf[2] = get_bits(&s->gb, 6);
633                     sf[1] = sf[0];
634                     break;
635                 case 3:
636                     sf[0] = get_bits(&s->gb, 6);
637                     sf[2] = get_bits(&s->gb, 6);
638                     sf[1] = sf[2];
639                     break;
640                 }
641             }
642         }
643     }
644
645     /* samples */
646     for (k = 0; k < 3; k++) {
647         for (l = 0; l < 12; l += 3) {
648             j = 0;
649             for (i = 0; i < bound; i++) {
650                 bit_alloc_bits = alloc_table[j];
651                 for (ch = 0; ch < s->nb_channels; ch++) {
652                     b = bit_alloc[ch][i];
653                     if (b) {
654                         scale = scale_factors[ch][i][k];
655                         qindex = alloc_table[j+b];
656                         bits = ff_mpa_quant_bits[qindex];
657                         if (bits < 0) {
658                             int v2;
659                             /* 3 values at the same time */
660                             v = get_bits(&s->gb, -bits);
661                             v2 = division_tabs[qindex][v];
662                             steps  = ff_mpa_quant_steps[qindex];
663
664                             s->sb_samples[ch][k * 12 + l + 0][i] =
665                                 l2_unscale_group(steps,  v2       & 15, scale);
666                             s->sb_samples[ch][k * 12 + l + 1][i] =
667                                 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
668                             s->sb_samples[ch][k * 12 + l + 2][i] =
669                                 l2_unscale_group(steps,  v2 >> 8      , scale);
670                         } else {
671                             for (m = 0; m < 3; m++) {
672                                 v = get_bits(&s->gb, bits);
673                                 v = l1_unscale(bits - 1, v, scale);
674                                 s->sb_samples[ch][k * 12 + l + m][i] = v;
675                             }
676                         }
677                     } else {
678                         s->sb_samples[ch][k * 12 + l + 0][i] = 0;
679                         s->sb_samples[ch][k * 12 + l + 1][i] = 0;
680                         s->sb_samples[ch][k * 12 + l + 2][i] = 0;
681                     }
682                 }
683                 /* next subband in alloc table */
684                 j += 1 << bit_alloc_bits;
685             }
686             /* XXX: find a way to avoid this duplication of code */
687             for (i = bound; i < sblimit; i++) {
688                 bit_alloc_bits = alloc_table[j];
689                 b = bit_alloc[0][i];
690                 if (b) {
691                     int mant, scale0, scale1;
692                     scale0 = scale_factors[0][i][k];
693                     scale1 = scale_factors[1][i][k];
694                     qindex = alloc_table[j+b];
695                     bits = ff_mpa_quant_bits[qindex];
696                     if (bits < 0) {
697                         /* 3 values at the same time */
698                         v = get_bits(&s->gb, -bits);
699                         steps = ff_mpa_quant_steps[qindex];
700                         mant = v % steps;
701                         v = v / steps;
702                         s->sb_samples[0][k * 12 + l + 0][i] =
703                             l2_unscale_group(steps, mant, scale0);
704                         s->sb_samples[1][k * 12 + l + 0][i] =
705                             l2_unscale_group(steps, mant, scale1);
706                         mant = v % steps;
707                         v = v / steps;
708                         s->sb_samples[0][k * 12 + l + 1][i] =
709                             l2_unscale_group(steps, mant, scale0);
710                         s->sb_samples[1][k * 12 + l + 1][i] =
711                             l2_unscale_group(steps, mant, scale1);
712                         s->sb_samples[0][k * 12 + l + 2][i] =
713                             l2_unscale_group(steps, v, scale0);
714                         s->sb_samples[1][k * 12 + l + 2][i] =
715                             l2_unscale_group(steps, v, scale1);
716                     } else {
717                         for (m = 0; m < 3; m++) {
718                             mant = get_bits(&s->gb, bits);
719                             s->sb_samples[0][k * 12 + l + m][i] =
720                                 l1_unscale(bits - 1, mant, scale0);
721                             s->sb_samples[1][k * 12 + l + m][i] =
722                                 l1_unscale(bits - 1, mant, scale1);
723                         }
724                     }
725                 } else {
726                     s->sb_samples[0][k * 12 + l + 0][i] = 0;
727                     s->sb_samples[0][k * 12 + l + 1][i] = 0;
728                     s->sb_samples[0][k * 12 + l + 2][i] = 0;
729                     s->sb_samples[1][k * 12 + l + 0][i] = 0;
730                     s->sb_samples[1][k * 12 + l + 1][i] = 0;
731                     s->sb_samples[1][k * 12 + l + 2][i] = 0;
732                 }
733                 /* next subband in alloc table */
734                 j += 1 << bit_alloc_bits;
735             }
736             /* fill remaining samples to zero */
737             for (i = sblimit; i < SBLIMIT; i++) {
738                 for (ch = 0; ch < s->nb_channels; ch++) {
739                     s->sb_samples[ch][k * 12 + l + 0][i] = 0;
740                     s->sb_samples[ch][k * 12 + l + 1][i] = 0;
741                     s->sb_samples[ch][k * 12 + l + 2][i] = 0;
742                 }
743             }
744         }
745     }
746     return 3 * 12;
747 }
748
749 #define SPLIT(dst,sf,n)             \
750     if (n == 3) {                   \
751         int m = (sf * 171) >> 9;    \
752         dst   = sf - 3 * m;         \
753         sf    = m;                  \
754     } else if (n == 4) {            \
755         dst  = sf & 3;              \
756         sf >>= 2;                   \
757     } else if (n == 5) {            \
758         int m = (sf * 205) >> 10;   \
759         dst   = sf - 5 * m;         \
760         sf    = m;                  \
761     } else if (n == 6) {            \
762         int m = (sf * 171) >> 10;   \
763         dst   = sf - 6 * m;         \
764         sf    = m;                  \
765     } else {                        \
766         dst = 0;                    \
767     }
768
769 static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
770                                            int n3)
771 {
772     SPLIT(slen[3], sf, n3)
773     SPLIT(slen[2], sf, n2)
774     SPLIT(slen[1], sf, n1)
775     slen[0] = sf;
776 }
777
778 static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
779                                          int16_t *exponents)
780 {
781     const uint8_t *bstab, *pretab;
782     int len, i, j, k, l, v0, shift, gain, gains[3];
783     int16_t *exp_ptr;
784
785     exp_ptr = exponents;
786     gain    = g->global_gain - 210;
787     shift   = g->scalefac_scale + 1;
788
789     bstab  = band_size_long[s->sample_rate_index];
790     pretab = mpa_pretab[g->preflag];
791     for (i = 0; i < g->long_end; i++) {
792         v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
793         len = bstab[i];
794         for (j = len; j > 0; j--)
795             *exp_ptr++ = v0;
796     }
797
798     if (g->short_start < 13) {
799         bstab    = band_size_short[s->sample_rate_index];
800         gains[0] = gain - (g->subblock_gain[0] << 3);
801         gains[1] = gain - (g->subblock_gain[1] << 3);
802         gains[2] = gain - (g->subblock_gain[2] << 3);
803         k        = g->long_end;
804         for (i = g->short_start; i < 13; i++) {
805             len = bstab[i];
806             for (l = 0; l < 3; l++) {
807                 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
808                 for (j = len; j > 0; j--)
809                     *exp_ptr++ = v0;
810             }
811         }
812     }
813 }
814
815 /* handle n = 0 too */
816 static inline int get_bitsz(GetBitContext *s, int n)
817 {
818     return n ? get_bits(s, n) : 0;
819 }
820
821
822 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
823                           int *end_pos2)
824 {
825     if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
826         s->gb           = s->in_gb;
827         s->in_gb.buffer = NULL;
828         assert((get_bits_count(&s->gb) & 7) == 0);
829         skip_bits_long(&s->gb, *pos - *end_pos);
830         *end_pos2 =
831         *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
832         *pos      = get_bits_count(&s->gb);
833     }
834 }
835
836 /* Following is a optimized code for
837             INTFLOAT v = *src
838             if(get_bits1(&s->gb))
839                 v = -v;
840             *dst = v;
841 */
842 #if CONFIG_FLOAT
843 #define READ_FLIP_SIGN(dst,src)                     \
844     v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \
845     AV_WN32A(dst, v);
846 #else
847 #define READ_FLIP_SIGN(dst,src)     \
848     v      = -get_bits1(&s->gb);    \
849     *(dst) = (*(src) ^ v) - v;
850 #endif
851
852 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
853                           int16_t *exponents, int end_pos2)
854 {
855     int s_index;
856     int i;
857     int last_pos, bits_left;
858     VLC *vlc;
859     int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
860
861     /* low frequencies (called big values) */
862     s_index = 0;
863     for (i = 0; i < 3; i++) {
864         int j, k, l, linbits;
865         j = g->region_size[i];
866         if (j == 0)
867             continue;
868         /* select vlc table */
869         k       = g->table_select[i];
870         l       = mpa_huff_data[k][0];
871         linbits = mpa_huff_data[k][1];
872         vlc     = &huff_vlc[l];
873
874         if (!l) {
875             memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
876             s_index += 2 * j;
877             continue;
878         }
879
880         /* read huffcode and compute each couple */
881         for (; j > 0; j--) {
882             int exponent, x, y;
883             int v;
884             int pos = get_bits_count(&s->gb);
885
886             if (pos >= end_pos){
887 //                av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
888                 switch_buffer(s, &pos, &end_pos, &end_pos2);
889 //                av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
890                 if (pos >= end_pos)
891                     break;
892             }
893             y = get_vlc2(&s->gb, vlc->table, 7, 3);
894
895             if (!y) {
896                 g->sb_hybrid[s_index  ] =
897                 g->sb_hybrid[s_index+1] = 0;
898                 s_index += 2;
899                 continue;
900             }
901
902             exponent= exponents[s_index];
903
904             av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
905                     i, g->region_size[i] - j, x, y, exponent);
906             if (y & 16) {
907                 x = y >> 5;
908                 y = y & 0x0f;
909                 if (x < 15) {
910                     READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
911                 } else {
912                     x += get_bitsz(&s->gb, linbits);
913                     v  = l3_unscale(x, exponent);
914                     if (get_bits1(&s->gb))
915                         v = -v;
916                     g->sb_hybrid[s_index] = v;
917                 }
918                 if (y < 15) {
919                     READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
920                 } else {
921                     y += get_bitsz(&s->gb, linbits);
922                     v  = l3_unscale(y, exponent);
923                     if (get_bits1(&s->gb))
924                         v = -v;
925                     g->sb_hybrid[s_index+1] = v;
926                 }
927             } else {
928                 x = y >> 5;
929                 y = y & 0x0f;
930                 x += y;
931                 if (x < 15) {
932                     READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
933                 } else {
934                     x += get_bitsz(&s->gb, linbits);
935                     v  = l3_unscale(x, exponent);
936                     if (get_bits1(&s->gb))
937                         v = -v;
938                     g->sb_hybrid[s_index+!!y] = v;
939                 }
940                 g->sb_hybrid[s_index + !y] = 0;
941             }
942             s_index += 2;
943         }
944     }
945
946     /* high frequencies */
947     vlc = &huff_quad_vlc[g->count1table_select];
948     last_pos = 0;
949     while (s_index <= 572) {
950         int pos, code;
951         pos = get_bits_count(&s->gb);
952         if (pos >= end_pos) {
953             if (pos > end_pos2 && last_pos) {
954                 /* some encoders generate an incorrect size for this
955                    part. We must go back into the data */
956                 s_index -= 4;
957                 skip_bits_long(&s->gb, last_pos - pos);
958                 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
959                 if(s->err_recognition & AV_EF_BITSTREAM)
960                     s_index=0;
961                 break;
962             }
963 //                av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
964             switch_buffer(s, &pos, &end_pos, &end_pos2);
965 //                av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
966             if (pos >= end_pos)
967                 break;
968         }
969         last_pos = pos;
970
971         code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
972         av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
973         g->sb_hybrid[s_index+0] =
974         g->sb_hybrid[s_index+1] =
975         g->sb_hybrid[s_index+2] =
976         g->sb_hybrid[s_index+3] = 0;
977         while (code) {
978             static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
979             int v;
980             int pos = s_index + idxtab[code];
981             code   ^= 8 >> idxtab[code];
982             READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
983         }
984         s_index += 4;
985     }
986     /* skip extension bits */
987     bits_left = end_pos2 - get_bits_count(&s->gb);
988 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
989     if (bits_left < 0 && (s->err_recognition & AV_EF_BUFFER)) {
990         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
991         s_index=0;
992     } else if (bits_left > 0 && (s->err_recognition & AV_EF_BUFFER)) {
993         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
994         s_index = 0;
995     }
996     memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
997     skip_bits_long(&s->gb, bits_left);
998
999     i = get_bits_count(&s->gb);
1000     switch_buffer(s, &i, &end_pos, &end_pos2);
1001
1002     return 0;
1003 }
1004
1005 /* Reorder short blocks from bitstream order to interleaved order. It
1006    would be faster to do it in parsing, but the code would be far more
1007    complicated */
1008 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
1009 {
1010     int i, j, len;
1011     INTFLOAT *ptr, *dst, *ptr1;
1012     INTFLOAT tmp[576];
1013
1014     if (g->block_type != 2)
1015         return;
1016
1017     if (g->switch_point) {
1018         if (s->sample_rate_index != 8)
1019             ptr = g->sb_hybrid + 36;
1020         else
1021             ptr = g->sb_hybrid + 48;
1022     } else {
1023         ptr = g->sb_hybrid;
1024     }
1025
1026     for (i = g->short_start; i < 13; i++) {
1027         len  = band_size_short[s->sample_rate_index][i];
1028         ptr1 = ptr;
1029         dst  = tmp;
1030         for (j = len; j > 0; j--) {
1031             *dst++ = ptr[0*len];
1032             *dst++ = ptr[1*len];
1033             *dst++ = ptr[2*len];
1034             ptr++;
1035         }
1036         ptr += 2 * len;
1037         memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1038     }
1039 }
1040
1041 #define ISQRT2 FIXR(0.70710678118654752440)
1042
1043 static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1044 {
1045     int i, j, k, l;
1046     int sf_max, sf, len, non_zero_found;
1047     INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1048     int non_zero_found_short[3];
1049
1050     /* intensity stereo */
1051     if (s->mode_ext & MODE_EXT_I_STEREO) {
1052         if (!s->lsf) {
1053             is_tab = is_table;
1054             sf_max = 7;
1055         } else {
1056             is_tab = is_table_lsf[g1->scalefac_compress & 1];
1057             sf_max = 16;
1058         }
1059
1060         tab0 = g0->sb_hybrid + 576;
1061         tab1 = g1->sb_hybrid + 576;
1062
1063         non_zero_found_short[0] = 0;
1064         non_zero_found_short[1] = 0;
1065         non_zero_found_short[2] = 0;
1066         k = (13 - g1->short_start) * 3 + g1->long_end - 3;
1067         for (i = 12; i >= g1->short_start; i--) {
1068             /* for last band, use previous scale factor */
1069             if (i != 11)
1070                 k -= 3;
1071             len = band_size_short[s->sample_rate_index][i];
1072             for (l = 2; l >= 0; l--) {
1073                 tab0 -= len;
1074                 tab1 -= len;
1075                 if (!non_zero_found_short[l]) {
1076                     /* test if non zero band. if so, stop doing i-stereo */
1077                     for (j = 0; j < len; j++) {
1078                         if (tab1[j] != 0) {
1079                             non_zero_found_short[l] = 1;
1080                             goto found1;
1081                         }
1082                     }
1083                     sf = g1->scale_factors[k + l];
1084                     if (sf >= sf_max)
1085                         goto found1;
1086
1087                     v1 = is_tab[0][sf];
1088                     v2 = is_tab[1][sf];
1089                     for (j = 0; j < len; j++) {
1090                         tmp0    = tab0[j];
1091                         tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1092                         tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1093                     }
1094                 } else {
1095 found1:
1096                     if (s->mode_ext & MODE_EXT_MS_STEREO) {
1097                         /* lower part of the spectrum : do ms stereo
1098                            if enabled */
1099                         for (j = 0; j < len; j++) {
1100                             tmp0    = tab0[j];
1101                             tmp1    = tab1[j];
1102                             tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1103                             tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1104                         }
1105                     }
1106                 }
1107             }
1108         }
1109
1110         non_zero_found = non_zero_found_short[0] |
1111                          non_zero_found_short[1] |
1112                          non_zero_found_short[2];
1113
1114         for (i = g1->long_end - 1;i >= 0;i--) {
1115             len   = band_size_long[s->sample_rate_index][i];
1116             tab0 -= len;
1117             tab1 -= len;
1118             /* test if non zero band. if so, stop doing i-stereo */
1119             if (!non_zero_found) {
1120                 for (j = 0; j < len; j++) {
1121                     if (tab1[j] != 0) {
1122                         non_zero_found = 1;
1123                         goto found2;
1124                     }
1125                 }
1126                 /* for last band, use previous scale factor */
1127                 k  = (i == 21) ? 20 : i;
1128                 sf = g1->scale_factors[k];
1129                 if (sf >= sf_max)
1130                     goto found2;
1131                 v1 = is_tab[0][sf];
1132                 v2 = is_tab[1][sf];
1133                 for (j = 0; j < len; j++) {
1134                     tmp0    = tab0[j];
1135                     tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
1136                     tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1137                 }
1138             } else {
1139 found2:
1140                 if (s->mode_ext & MODE_EXT_MS_STEREO) {
1141                     /* lower part of the spectrum : do ms stereo
1142                        if enabled */
1143                     for (j = 0; j < len; j++) {
1144                         tmp0    = tab0[j];
1145                         tmp1    = tab1[j];
1146                         tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
1147                         tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1148                     }
1149                 }
1150             }
1151         }
1152     } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
1153         /* ms stereo ONLY */
1154         /* NOTE: the 1/sqrt(2) normalization factor is included in the
1155            global gain */
1156 #if CONFIG_FLOAT
1157        s-> dsp.butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
1158 #else
1159         tab0 = g0->sb_hybrid;
1160         tab1 = g1->sb_hybrid;
1161         for (i = 0; i < 576; i++) {
1162             tmp0    = tab0[i];
1163             tmp1    = tab1[i];
1164             tab0[i] = tmp0 + tmp1;
1165             tab1[i] = tmp0 - tmp1;
1166         }
1167 #endif
1168     }
1169 }
1170
1171 #if CONFIG_FLOAT
1172 #define AA(j) do {                                                      \
1173         float tmp0 = ptr[-1-j];                                         \
1174         float tmp1 = ptr[   j];                                         \
1175         ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1];    \
1176         ptr[   j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0];    \
1177     } while (0)
1178 #else
1179 #define AA(j) do {                                              \
1180         int tmp0 = ptr[-1-j];                                   \
1181         int tmp1 = ptr[   j];                                   \
1182         int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
1183         ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
1184         ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
1185     } while (0)
1186 #endif
1187
1188 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1189 {
1190     INTFLOAT *ptr;
1191     int n, i;
1192
1193     /* we antialias only "long" bands */
1194     if (g->block_type == 2) {
1195         if (!g->switch_point)
1196             return;
1197         /* XXX: check this for 8000Hz case */
1198         n = 1;
1199     } else {
1200         n = SBLIMIT - 1;
1201     }
1202
1203     ptr = g->sb_hybrid + 18;
1204     for (i = n; i > 0; i--) {
1205         AA(0);
1206         AA(1);
1207         AA(2);
1208         AA(3);
1209         AA(4);
1210         AA(5);
1211         AA(6);
1212         AA(7);
1213
1214         ptr += 18;
1215     }
1216 }
1217
1218 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
1219                           INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1220 {
1221     INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1222     INTFLOAT out2[12];
1223     int i, j, mdct_long_end, sblimit;
1224
1225     /* find last non zero block */
1226     ptr  = g->sb_hybrid + 576;
1227     ptr1 = g->sb_hybrid + 2 * 18;
1228     while (ptr >= ptr1) {
1229         int32_t *p;
1230         ptr -= 6;
1231         p    = (int32_t*)ptr;
1232         if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1233             break;
1234     }
1235     sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
1236
1237     if (g->block_type == 2) {
1238         /* XXX: check for 8000 Hz */
1239         if (g->switch_point)
1240             mdct_long_end = 2;
1241         else
1242             mdct_long_end = 0;
1243     } else {
1244         mdct_long_end = sblimit;
1245     }
1246
1247     s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
1248                                      mdct_long_end, g->switch_point,
1249                                      g->block_type);
1250
1251     buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
1252     ptr = g->sb_hybrid + 18 * mdct_long_end;
1253
1254     for (j = mdct_long_end; j < sblimit; j++) {
1255         /* select frequency inversion */
1256         win     = RENAME(ff_mdct_win)[2 + (4  & -(j & 1))];
1257         out_ptr = sb_samples + j;
1258
1259         for (i = 0; i < 6; i++) {
1260             *out_ptr = buf[4*i];
1261             out_ptr += SBLIMIT;
1262         }
1263         imdct12(out2, ptr + 0);
1264         for (i = 0; i < 6; i++) {
1265             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*1)];
1266             buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
1267             out_ptr += SBLIMIT;
1268         }
1269         imdct12(out2, ptr + 1);
1270         for (i = 0; i < 6; i++) {
1271             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*2)];
1272             buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
1273             out_ptr += SBLIMIT;
1274         }
1275         imdct12(out2, ptr + 2);
1276         for (i = 0; i < 6; i++) {
1277             buf[4*(i + 6*0)] = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*0)];
1278             buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
1279             buf[4*(i + 6*2)] = 0;
1280         }
1281         ptr += 18;
1282         buf += (j&3) != 3 ? 1 : (4*18-3);
1283     }
1284     /* zero bands */
1285     for (j = sblimit; j < SBLIMIT; j++) {
1286         /* overlap */
1287         out_ptr = sb_samples + j;
1288         for (i = 0; i < 18; i++) {
1289             *out_ptr = buf[4*i];
1290             buf[4*i]   = 0;
1291             out_ptr += SBLIMIT;
1292         }
1293         buf += (j&3) != 3 ? 1 : (4*18-3);
1294     }
1295 }
1296
1297 /* main layer3 decoding function */
1298 static int mp_decode_layer3(MPADecodeContext *s)
1299 {
1300     int nb_granules, main_data_begin;
1301     int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1302     GranuleDef *g;
1303     int16_t exponents[576]; //FIXME try INTFLOAT
1304
1305     /* read side info */
1306     if (s->lsf) {
1307         main_data_begin = get_bits(&s->gb, 8);
1308         skip_bits(&s->gb, s->nb_channels);
1309         nb_granules = 1;
1310     } else {
1311         main_data_begin = get_bits(&s->gb, 9);
1312         if (s->nb_channels == 2)
1313             skip_bits(&s->gb, 3);
1314         else
1315             skip_bits(&s->gb, 5);
1316         nb_granules = 2;
1317         for (ch = 0; ch < s->nb_channels; ch++) {
1318             s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
1319             s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1320         }
1321     }
1322
1323     for (gr = 0; gr < nb_granules; gr++) {
1324         for (ch = 0; ch < s->nb_channels; ch++) {
1325             av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1326             g = &s->granules[ch][gr];
1327             g->part2_3_length = get_bits(&s->gb, 12);
1328             g->big_values     = get_bits(&s->gb,  9);
1329             if (g->big_values > 288) {
1330                 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1331                 return AVERROR_INVALIDDATA;
1332             }
1333
1334             g->global_gain = get_bits(&s->gb, 8);
1335             /* if MS stereo only is selected, we precompute the
1336                1/sqrt(2) renormalization factor */
1337             if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1338                 MODE_EXT_MS_STEREO)
1339                 g->global_gain -= 2;
1340             if (s->lsf)
1341                 g->scalefac_compress = get_bits(&s->gb, 9);
1342             else
1343                 g->scalefac_compress = get_bits(&s->gb, 4);
1344             blocksplit_flag = get_bits1(&s->gb);
1345             if (blocksplit_flag) {
1346                 g->block_type = get_bits(&s->gb, 2);
1347                 if (g->block_type == 0) {
1348                     av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1349                     return AVERROR_INVALIDDATA;
1350                 }
1351                 g->switch_point = get_bits1(&s->gb);
1352                 for (i = 0; i < 2; i++)
1353                     g->table_select[i] = get_bits(&s->gb, 5);
1354                 for (i = 0; i < 3; i++)
1355                     g->subblock_gain[i] = get_bits(&s->gb, 3);
1356                 ff_init_short_region(s, g);
1357             } else {
1358                 int region_address1, region_address2;
1359                 g->block_type = 0;
1360                 g->switch_point = 0;
1361                 for (i = 0; i < 3; i++)
1362                     g->table_select[i] = get_bits(&s->gb, 5);
1363                 /* compute huffman coded region sizes */
1364                 region_address1 = get_bits(&s->gb, 4);
1365                 region_address2 = get_bits(&s->gb, 3);
1366                 av_dlog(s->avctx, "region1=%d region2=%d\n",
1367                         region_address1, region_address2);
1368                 ff_init_long_region(s, g, region_address1, region_address2);
1369             }
1370             ff_region_offset2size(g);
1371             ff_compute_band_indexes(s, g);
1372
1373             g->preflag = 0;
1374             if (!s->lsf)
1375                 g->preflag = get_bits1(&s->gb);
1376             g->scalefac_scale     = get_bits1(&s->gb);
1377             g->count1table_select = get_bits1(&s->gb);
1378             av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1379                     g->block_type, g->switch_point);
1380         }
1381     }
1382
1383     if (!s->adu_mode) {
1384         int skip;
1385         const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1386         int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0,
1387                                 FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
1388         assert((get_bits_count(&s->gb) & 7) == 0);
1389         /* now we get bits from the main_data_begin offset */
1390         av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1391     //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1392
1393         memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1394         s->in_gb = s->gb;
1395         init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1396 #if !UNCHECKED_BITSTREAM_READER
1397         s->gb.size_in_bits_plus8 += extrasize * 8;
1398 #endif
1399         s->last_buf_size <<= 3;
1400         for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
1401             for (ch = 0; ch < s->nb_channels; ch++) {
1402                 g = &s->granules[ch][gr];
1403                 s->last_buf_size += g->part2_3_length;
1404                 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1405             }
1406         }
1407         skip = s->last_buf_size - 8 * main_data_begin;
1408         if (skip >= s->gb.size_in_bits && s->in_gb.buffer) {
1409             skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits);
1410             s->gb           = s->in_gb;
1411             s->in_gb.buffer = NULL;
1412         } else {
1413             skip_bits_long(&s->gb, skip);
1414         }
1415     } else {
1416         gr = 0;
1417     }
1418
1419     for (; gr < nb_granules; gr++) {
1420         for (ch = 0; ch < s->nb_channels; ch++) {
1421             g = &s->granules[ch][gr];
1422             bits_pos = get_bits_count(&s->gb);
1423
1424             if (!s->lsf) {
1425                 uint8_t *sc;
1426                 int slen, slen1, slen2;
1427
1428                 /* MPEG1 scale factors */
1429                 slen1 = slen_table[0][g->scalefac_compress];
1430                 slen2 = slen_table[1][g->scalefac_compress];
1431                 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1432                 if (g->block_type == 2) {
1433                     n = g->switch_point ? 17 : 18;
1434                     j = 0;
1435                     if (slen1) {
1436                         for (i = 0; i < n; i++)
1437                             g->scale_factors[j++] = get_bits(&s->gb, slen1);
1438                     } else {
1439                         for (i = 0; i < n; i++)
1440                             g->scale_factors[j++] = 0;
1441                     }
1442                     if (slen2) {
1443                         for (i = 0; i < 18; i++)
1444                             g->scale_factors[j++] = get_bits(&s->gb, slen2);
1445                         for (i = 0; i < 3; i++)
1446                             g->scale_factors[j++] = 0;
1447                     } else {
1448                         for (i = 0; i < 21; i++)
1449                             g->scale_factors[j++] = 0;
1450                     }
1451                 } else {
1452                     sc = s->granules[ch][0].scale_factors;
1453                     j = 0;
1454                     for (k = 0; k < 4; k++) {
1455                         n = k == 0 ? 6 : 5;
1456                         if ((g->scfsi & (0x8 >> k)) == 0) {
1457                             slen = (k < 2) ? slen1 : slen2;
1458                             if (slen) {
1459                                 for (i = 0; i < n; i++)
1460                                     g->scale_factors[j++] = get_bits(&s->gb, slen);
1461                             } else {
1462                                 for (i = 0; i < n; i++)
1463                                     g->scale_factors[j++] = 0;
1464                             }
1465                         } else {
1466                             /* simply copy from last granule */
1467                             for (i = 0; i < n; i++) {
1468                                 g->scale_factors[j] = sc[j];
1469                                 j++;
1470                             }
1471                         }
1472                     }
1473                     g->scale_factors[j++] = 0;
1474                 }
1475             } else {
1476                 int tindex, tindex2, slen[4], sl, sf;
1477
1478                 /* LSF scale factors */
1479                 if (g->block_type == 2)
1480                     tindex = g->switch_point ? 2 : 1;
1481                 else
1482                     tindex = 0;
1483
1484                 sf = g->scalefac_compress;
1485                 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1486                     /* intensity stereo case */
1487                     sf >>= 1;
1488                     if (sf < 180) {
1489                         lsf_sf_expand(slen, sf, 6, 6, 0);
1490                         tindex2 = 3;
1491                     } else if (sf < 244) {
1492                         lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1493                         tindex2 = 4;
1494                     } else {
1495                         lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1496                         tindex2 = 5;
1497                     }
1498                 } else {
1499                     /* normal case */
1500                     if (sf < 400) {
1501                         lsf_sf_expand(slen, sf, 5, 4, 4);
1502                         tindex2 = 0;
1503                     } else if (sf < 500) {
1504                         lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1505                         tindex2 = 1;
1506                     } else {
1507                         lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1508                         tindex2 = 2;
1509                         g->preflag = 1;
1510                     }
1511                 }
1512
1513                 j = 0;
1514                 for (k = 0; k < 4; k++) {
1515                     n  = lsf_nsf_table[tindex2][tindex][k];
1516                     sl = slen[k];
1517                     if (sl) {
1518                         for (i = 0; i < n; i++)
1519                             g->scale_factors[j++] = get_bits(&s->gb, sl);
1520                     } else {
1521                         for (i = 0; i < n; i++)
1522                             g->scale_factors[j++] = 0;
1523                     }
1524                 }
1525                 /* XXX: should compute exact size */
1526                 for (; j < 40; j++)
1527                     g->scale_factors[j] = 0;
1528             }
1529
1530             exponents_from_scale_factors(s, g, exponents);
1531
1532             /* read Huffman coded residue */
1533             huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1534         } /* ch */
1535
1536         if (s->mode == MPA_JSTEREO)
1537             compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1538
1539         for (ch = 0; ch < s->nb_channels; ch++) {
1540             g = &s->granules[ch][gr];
1541
1542             reorder_block(s, g);
1543             compute_antialias(s, g);
1544             compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1545         }
1546     } /* gr */
1547     if (get_bits_count(&s->gb) < 0)
1548         skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1549     return nb_granules * 18;
1550 }
1551
1552 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1553                            const uint8_t *buf, int buf_size)
1554 {
1555     int i, nb_frames, ch, ret;
1556     OUT_INT *samples_ptr;
1557
1558     init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1559
1560     /* skip error protection field */
1561     if (s->error_protection)
1562         skip_bits(&s->gb, 16);
1563
1564     switch(s->layer) {
1565     case 1:
1566         s->avctx->frame_size = 384;
1567         nb_frames = mp_decode_layer1(s);
1568         break;
1569     case 2:
1570         s->avctx->frame_size = 1152;
1571         nb_frames = mp_decode_layer2(s);
1572         break;
1573     case 3:
1574         s->avctx->frame_size = s->lsf ? 576 : 1152;
1575     default:
1576         nb_frames = mp_decode_layer3(s);
1577
1578         s->last_buf_size=0;
1579         if (s->in_gb.buffer) {
1580             align_get_bits(&s->gb);
1581             i = get_bits_left(&s->gb)>>3;
1582             if (i >= 0 && i <= BACKSTEP_SIZE) {
1583                 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1584                 s->last_buf_size=i;
1585             } else
1586                 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1587             s->gb           = s->in_gb;
1588             s->in_gb.buffer = NULL;
1589         }
1590
1591         align_get_bits(&s->gb);
1592         assert((get_bits_count(&s->gb) & 7) == 0);
1593         i = get_bits_left(&s->gb) >> 3;
1594
1595         if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1596             if (i < 0)
1597                 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1598             i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1599         }
1600         assert(i <= buf_size - HEADER_SIZE && i >= 0);
1601         memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1602         s->last_buf_size += i;
1603     }
1604
1605     /* get output buffer */
1606     if (!samples) {
1607         s->frame.nb_samples = s->avctx->frame_size;
1608         if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1609             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1610             return ret;
1611         }
1612         samples = (OUT_INT *)s->frame.data[0];
1613     }
1614
1615     /* apply the synthesis filter */
1616     for (ch = 0; ch < s->nb_channels; ch++) {
1617         samples_ptr = samples + ch;
1618         for (i = 0; i < nb_frames; i++) {
1619             RENAME(ff_mpa_synth_filter)(
1620                          &s->mpadsp,
1621                          s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1622                          RENAME(ff_mpa_synth_window), &s->dither_state,
1623                          samples_ptr, s->nb_channels,
1624                          s->sb_samples[ch][i]);
1625             samples_ptr += 32 * s->nb_channels;
1626         }
1627     }
1628
1629     return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1630 }
1631
1632 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1633                         AVPacket *avpkt)
1634 {
1635     const uint8_t *buf  = avpkt->data;
1636     int buf_size        = avpkt->size;
1637     MPADecodeContext *s = avctx->priv_data;
1638     uint32_t header;
1639     int out_size;
1640
1641     if (buf_size < HEADER_SIZE)
1642         return AVERROR_INVALIDDATA;
1643
1644     header = AV_RB32(buf);
1645     if (ff_mpa_check_header(header) < 0) {
1646         av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1647         return AVERROR_INVALIDDATA;
1648     }
1649
1650     if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1651         /* free format: prepare to compute frame size */
1652         s->frame_size = -1;
1653         return AVERROR_INVALIDDATA;
1654     }
1655     /* update codec info */
1656     avctx->channels       = s->nb_channels;
1657     avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1658     if (!avctx->bit_rate)
1659         avctx->bit_rate = s->bit_rate;
1660
1661     if (s->frame_size <= 0 || s->frame_size > buf_size) {
1662         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1663         return AVERROR_INVALIDDATA;
1664     } else if (s->frame_size < buf_size) {
1665         av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
1666         buf_size= s->frame_size;
1667     }
1668
1669     out_size = mp_decode_frame(s, NULL, buf, buf_size);
1670     if (out_size >= 0) {
1671         *got_frame_ptr   = 1;
1672         *(AVFrame *)data = s->frame;
1673         avctx->sample_rate = s->sample_rate;
1674         //FIXME maybe move the other codec info stuff from above here too
1675     } else {
1676         av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1677         /* Only return an error if the bad frame makes up the whole packet.
1678            If there is more data in the packet, just consume the bad frame
1679            instead of returning an error, which would discard the whole
1680            packet. */
1681         *got_frame_ptr = 0;
1682         if (buf_size == avpkt->size)
1683             return out_size;
1684     }
1685     s->frame_size = 0;
1686     return buf_size;
1687 }
1688
1689 static void flush(AVCodecContext *avctx)
1690 {
1691     MPADecodeContext *s = avctx->priv_data;
1692     memset(s->synth_buf, 0, sizeof(s->synth_buf));
1693     s->last_buf_size = 0;
1694 }
1695
1696 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1697 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1698                             int *got_frame_ptr, AVPacket *avpkt)
1699 {
1700     const uint8_t *buf  = avpkt->data;
1701     int buf_size        = avpkt->size;
1702     MPADecodeContext *s = avctx->priv_data;
1703     uint32_t header;
1704     int len, out_size;
1705
1706     len = buf_size;
1707
1708     // Discard too short frames
1709     if (buf_size < HEADER_SIZE) {
1710         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1711         return AVERROR_INVALIDDATA;
1712     }
1713
1714
1715     if (len > MPA_MAX_CODED_FRAME_SIZE)
1716         len = MPA_MAX_CODED_FRAME_SIZE;
1717
1718     // Get header and restore sync word
1719     header = AV_RB32(buf) | 0xffe00000;
1720
1721     if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1722         av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1723         return AVERROR_INVALIDDATA;
1724     }
1725
1726     avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
1727     /* update codec info */
1728     avctx->sample_rate = s->sample_rate;
1729     avctx->channels    = s->nb_channels;
1730     if (!avctx->bit_rate)
1731         avctx->bit_rate = s->bit_rate;
1732
1733     s->frame_size = len;
1734
1735     out_size = mp_decode_frame(s, NULL, buf, buf_size);
1736
1737     *got_frame_ptr   = 1;
1738     *(AVFrame *)data = s->frame;
1739
1740     return buf_size;
1741 }
1742 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1743
1744 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1745
1746 /**
1747  * Context for MP3On4 decoder
1748  */
1749 typedef struct MP3On4DecodeContext {
1750     AVFrame *frame;
1751     int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)
1752     int syncword;                   ///< syncword patch
1753     const uint8_t *coff;            ///< channel offsets in output buffer
1754     MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1755     OUT_INT *decoded_buf;           ///< output buffer for decoded samples
1756 } MP3On4DecodeContext;
1757
1758 #include "mpeg4audio.h"
1759
1760 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1761
1762 /* number of mp3 decoder instances */
1763 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1764
1765 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1766 static const uint8_t chan_offset[8][5] = {
1767     { 0             },
1768     { 0             },  // C
1769     { 0             },  // FLR
1770     { 2, 0          },  // C FLR
1771     { 2, 0, 3       },  // C FLR BS
1772     { 2, 0, 3       },  // C FLR BLRS
1773     { 2, 0, 4, 3    },  // C FLR BLRS LFE
1774     { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE
1775 };
1776
1777 /* mp3on4 channel layouts */
1778 static const int16_t chan_layout[8] = {
1779     0,
1780     AV_CH_LAYOUT_MONO,
1781     AV_CH_LAYOUT_STEREO,
1782     AV_CH_LAYOUT_SURROUND,
1783     AV_CH_LAYOUT_4POINT0,
1784     AV_CH_LAYOUT_5POINT0,
1785     AV_CH_LAYOUT_5POINT1,
1786     AV_CH_LAYOUT_7POINT1
1787 };
1788
1789 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1790 {
1791     MP3On4DecodeContext *s = avctx->priv_data;
1792     int i;
1793
1794     for (i = 0; i < s->frames; i++)
1795         av_free(s->mp3decctx[i]);
1796
1797     av_freep(&s->decoded_buf);
1798
1799     return 0;
1800 }
1801
1802
1803 static int decode_init_mp3on4(AVCodecContext * avctx)
1804 {
1805     MP3On4DecodeContext *s = avctx->priv_data;
1806     MPEG4AudioConfig cfg;
1807     int i;
1808
1809     if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1810         av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1811         return AVERROR_INVALIDDATA;
1812     }
1813
1814     avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1815                                  avctx->extradata_size * 8, 1);
1816     if (!cfg.chan_config || cfg.chan_config > 7) {
1817         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1818         return AVERROR_INVALIDDATA;
1819     }
1820     s->frames             = mp3Frames[cfg.chan_config];
1821     s->coff               = chan_offset[cfg.chan_config];
1822     avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
1823     avctx->channel_layout = chan_layout[cfg.chan_config];
1824
1825     if (cfg.sample_rate < 16000)
1826         s->syncword = 0xffe00000;
1827     else
1828         s->syncword = 0xfff00000;
1829
1830     /* Init the first mp3 decoder in standard way, so that all tables get builded
1831      * We replace avctx->priv_data with the context of the first decoder so that
1832      * decode_init() does not have to be changed.
1833      * Other decoders will be initialized here copying data from the first context
1834      */
1835     // Allocate zeroed memory for the first decoder context
1836     s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1837     if (!s->mp3decctx[0])
1838         goto alloc_fail;
1839     // Put decoder context in place to make init_decode() happy
1840     avctx->priv_data = s->mp3decctx[0];
1841     decode_init(avctx);
1842     s->frame = avctx->coded_frame;
1843     // Restore mp3on4 context pointer
1844     avctx->priv_data = s;
1845     s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1846
1847     /* Create a separate codec/context for each frame (first is already ok).
1848      * Each frame is 1 or 2 channels - up to 5 frames allowed
1849      */
1850     for (i = 1; i < s->frames; i++) {
1851         s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1852         if (!s->mp3decctx[i])
1853             goto alloc_fail;
1854         s->mp3decctx[i]->adu_mode = 1;
1855         s->mp3decctx[i]->avctx = avctx;
1856         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1857     }
1858
1859     /* Allocate buffer for multi-channel output if needed */
1860     if (s->frames > 1) {
1861         s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1862                                    sizeof(*s->decoded_buf));
1863         if (!s->decoded_buf)
1864             goto alloc_fail;
1865     }
1866
1867     return 0;
1868 alloc_fail:
1869     decode_close_mp3on4(avctx);
1870     return AVERROR(ENOMEM);
1871 }
1872
1873
1874 static void flush_mp3on4(AVCodecContext *avctx)
1875 {
1876     int i;
1877     MP3On4DecodeContext *s = avctx->priv_data;
1878
1879     for (i = 0; i < s->frames; i++) {
1880         MPADecodeContext *m = s->mp3decctx[i];
1881         memset(m->synth_buf, 0, sizeof(m->synth_buf));
1882         m->last_buf_size = 0;
1883     }
1884 }
1885
1886
1887 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
1888                                int *got_frame_ptr, AVPacket *avpkt)
1889 {
1890     const uint8_t *buf     = avpkt->data;
1891     int buf_size           = avpkt->size;
1892     MP3On4DecodeContext *s = avctx->priv_data;
1893     MPADecodeContext *m;
1894     int fsize, len = buf_size, out_size = 0;
1895     uint32_t header;
1896     OUT_INT *out_samples;
1897     OUT_INT *outptr, *bp;
1898     int fr, j, n, ch, ret;
1899
1900     /* get output buffer */
1901     s->frame->nb_samples = MPA_FRAME_SIZE;
1902     if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
1903         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1904         return ret;
1905     }
1906     out_samples = (OUT_INT *)s->frame->data[0];
1907
1908     // Discard too short frames
1909     if (buf_size < HEADER_SIZE)
1910         return AVERROR_INVALIDDATA;
1911
1912     // If only one decoder interleave is not needed
1913     outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1914
1915     avctx->bit_rate = 0;
1916
1917     ch = 0;
1918     for (fr = 0; fr < s->frames; fr++) {
1919         fsize = AV_RB16(buf) >> 4;
1920         fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1921         m     = s->mp3decctx[fr];
1922         assert(m != NULL);
1923
1924         if (fsize < HEADER_SIZE) {
1925             av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
1926             return AVERROR_INVALIDDATA;
1927         }
1928         header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1929
1930         if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1931             break;
1932
1933         avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1934
1935         if (ch + m->nb_channels > avctx->channels) {
1936             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1937                                         "channel count\n");
1938             return AVERROR_INVALIDDATA;
1939         }
1940         ch += m->nb_channels;
1941
1942         out_size += mp_decode_frame(m, outptr, buf, fsize);
1943         buf      += fsize;
1944         len      -= fsize;
1945
1946         if (s->frames > 1) {
1947             n = m->avctx->frame_size*m->nb_channels;
1948             /* interleave output data */
1949             bp = out_samples + s->coff[fr];
1950             if (m->nb_channels == 1) {
1951                 for (j = 0; j < n; j++) {
1952                     *bp = s->decoded_buf[j];
1953                     bp += avctx->channels;
1954                 }
1955             } else {
1956                 for (j = 0; j < n; j++) {
1957                     bp[0] = s->decoded_buf[j++];
1958                     bp[1] = s->decoded_buf[j];
1959                     bp   += avctx->channels;
1960                 }
1961             }
1962         }
1963         avctx->bit_rate += m->bit_rate;
1964     }
1965
1966     /* update codec info */
1967     avctx->sample_rate = s->mp3decctx[0]->sample_rate;
1968
1969     s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
1970     *got_frame_ptr   = 1;
1971     *(AVFrame *)data = *s->frame;
1972
1973     return buf_size;
1974 }
1975 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
1976
1977 #if !CONFIG_FLOAT
1978 #if CONFIG_MP1_DECODER
1979 AVCodec ff_mp1_decoder = {
1980     .name           = "mp1",
1981     .type           = AVMEDIA_TYPE_AUDIO,
1982     .id             = CODEC_ID_MP1,
1983     .priv_data_size = sizeof(MPADecodeContext),
1984     .init           = decode_init,
1985     .decode         = decode_frame,
1986     .capabilities   = CODEC_CAP_DR1,
1987     .flush          = flush,
1988     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
1989 };
1990 #endif
1991 #if CONFIG_MP2_DECODER
1992 AVCodec ff_mp2_decoder = {
1993     .name           = "mp2",
1994     .type           = AVMEDIA_TYPE_AUDIO,
1995     .id             = CODEC_ID_MP2,
1996     .priv_data_size = sizeof(MPADecodeContext),
1997     .init           = decode_init,
1998     .decode         = decode_frame,
1999     .capabilities   = CODEC_CAP_DR1,
2000     .flush          = flush,
2001     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2002 };
2003 #endif
2004 #if CONFIG_MP3_DECODER
2005 AVCodec ff_mp3_decoder = {
2006     .name           = "mp3",
2007     .type           = AVMEDIA_TYPE_AUDIO,
2008     .id             = CODEC_ID_MP3,
2009     .priv_data_size = sizeof(MPADecodeContext),
2010     .init           = decode_init,
2011     .decode         = decode_frame,
2012     .capabilities   = CODEC_CAP_DR1,
2013     .flush          = flush,
2014     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2015 };
2016 #endif
2017 #if CONFIG_MP3ADU_DECODER
2018 AVCodec ff_mp3adu_decoder = {
2019     .name           = "mp3adu",
2020     .type           = AVMEDIA_TYPE_AUDIO,
2021     .id             = CODEC_ID_MP3ADU,
2022     .priv_data_size = sizeof(MPADecodeContext),
2023     .init           = decode_init,
2024     .decode         = decode_frame_adu,
2025     .capabilities   = CODEC_CAP_DR1,
2026     .flush          = flush,
2027     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2028 };
2029 #endif
2030 #if CONFIG_MP3ON4_DECODER
2031 AVCodec ff_mp3on4_decoder = {
2032     .name           = "mp3on4",
2033     .type           = AVMEDIA_TYPE_AUDIO,
2034     .id             = CODEC_ID_MP3ON4,
2035     .priv_data_size = sizeof(MP3On4DecodeContext),
2036     .init           = decode_init_mp3on4,
2037     .close          = decode_close_mp3on4,
2038     .decode         = decode_frame_mp3on4,
2039     .capabilities   = CODEC_CAP_DR1,
2040     .flush          = flush_mp3on4,
2041     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
2042 };
2043 #endif
2044 #endif