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