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