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