FFmpeg: libavcodec/mpegaudiodec.c Source File

00001 /*
00002  * MPEG Audio decoder
00003  * Copyright (c) 2001, 2002 Fabrice Bellard
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00027 #define UNCHECKED_BITSTREAM_READER 1
00028 
00029 #include "libavutil/audioconvert.h"
00030 #include "avcodec.h"
00031 #include "get_bits.h"
00032 #include "mathops.h"
00033 #include "mpegaudiodsp.h"
00034 
00035 /*
00036  * TODO:
00037  *  - test lsf / mpeg25 extensively.
00038  */
00039 
00040 #include "mpegaudio.h"
00041 #include "mpegaudiodecheader.h"
00042 
00043 #define BACKSTEP_SIZE 512
00044 #define EXTRABYTES 24
00045 
00046 /* layer 3 "granule" */
00047 typedef struct GranuleDef {
00048     uint8_t scfsi;
00049     int part2_3_length;
00050     int big_values;
00051     int global_gain;
00052     int scalefac_compress;
00053     uint8_t block_type;
00054     uint8_t switch_point;
00055     int table_select[3];
00056     int subblock_gain[3];
00057     uint8_t scalefac_scale;
00058     uint8_t count1table_select;
00059     int region_size[3]; /* number of huffman codes in each region */
00060     int preflag;
00061     int short_start, long_end; /* long/short band indexes */
00062     uint8_t scale_factors[40];
00063     DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
00064 } GranuleDef;
00065 
00066 typedef struct MPADecodeContext {
00067     MPA_DECODE_HEADER
00068     uint8_t last_buf[2 * BACKSTEP_SIZE + EXTRABYTES];
00069     int last_buf_size;
00070     /* next header (used in free format parsing) */
00071     uint32_t free_format_next_header;
00072     GetBitContext gb;
00073     GetBitContext in_gb;
00074     DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
00075     int synth_buf_offset[MPA_MAX_CHANNELS];
00076     DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
00077     INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
00078     GranuleDef granules[2][2]; /* Used in Layer 3 */
00079     int adu_mode; 
00080     int dither_state;
00081     int err_recognition;
00082     AVCodecContext* avctx;
00083     MPADSPContext mpadsp;
00084     AVFrame frame;
00085 } MPADecodeContext;
00086 
00087 #if CONFIG_FLOAT
00088 #   define SHR(a,b)       ((a)*(1.0f/(1<<(b))))
00089 #   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
00090 #   define FIXR(x)        ((float)(x))
00091 #   define FIXHR(x)       ((float)(x))
00092 #   define MULH3(x, y, s) ((s)*(y)*(x))
00093 #   define MULLx(x, y, s) ((y)*(x))
00094 #   define RENAME(a) a ## _float
00095 #   define OUT_FMT AV_SAMPLE_FMT_FLT
00096 #else
00097 #   define SHR(a,b)       ((a)>>(b))
00098 /* WARNING: only correct for positive numbers */
00099 #   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
00100 #   define FIXR(a)        ((int)((a) * FRAC_ONE + 0.5))
00101 #   define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))
00102 #   define MULH3(x, y, s) MULH((s)*(x), y)
00103 #   define MULLx(x, y, s) MULL(x,y,s)
00104 #   define RENAME(a)      a ## _fixed
00105 #   define OUT_FMT AV_SAMPLE_FMT_S16
00106 #endif
00107 
00108 /****************/
00109 
00110 #define HEADER_SIZE 4
00111 
00112 #include "mpegaudiodata.h"
00113 #include "mpegaudiodectab.h"
00114 
00115 /* vlc structure for decoding layer 3 huffman tables */
00116 static VLC huff_vlc[16];
00117 static VLC_TYPE huff_vlc_tables[
00118     0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
00119   142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
00120   ][2];
00121 static const int huff_vlc_tables_sizes[16] = {
00122     0,  128,  128,  128,  130,  128,  154,  166,
00123   142,  204,  190,  170,  542,  460,  662,  414
00124 };
00125 static VLC huff_quad_vlc[2];
00126 static VLC_TYPE  huff_quad_vlc_tables[128+16][2];
00127 static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
00128 /* computed from band_size_long */
00129 static uint16_t band_index_long[9][23];
00130 #include "mpegaudio_tablegen.h"
00131 /* intensity stereo coef table */
00132 static INTFLOAT is_table[2][16];
00133 static INTFLOAT is_table_lsf[2][2][16];
00134 static INTFLOAT csa_table[8][4];
00138 DECLARE_ALIGNED(16, static INTFLOAT, mdct_win)[8][40];
00139 
00140 static int16_t division_tab3[1<<6 ];
00141 static int16_t division_tab5[1<<8 ];
00142 static int16_t division_tab9[1<<11];
00143 
00144 static int16_t * const division_tabs[4] = {
00145     division_tab3, division_tab5, NULL, division_tab9
00146 };
00147 
00148 /* lower 2 bits: modulo 3, higher bits: shift */
00149 static uint16_t scale_factor_modshift[64];
00150 /* [i][j]:  2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
00151 static int32_t scale_factor_mult[15][3];
00152 /* mult table for layer 2 group quantization */
00153 
00154 #define SCALE_GEN(v) \
00155 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
00156 
00157 static const int32_t scale_factor_mult2[3][3] = {
00158     SCALE_GEN(4.0 / 3.0), /* 3 steps */
00159     SCALE_GEN(4.0 / 5.0), /* 5 steps */
00160     SCALE_GEN(4.0 / 9.0), /* 9 steps */
00161 };
00162 
00167 static void ff_region_offset2size(GranuleDef *g)
00168 {
00169     int i, k, j = 0;
00170     g->region_size[2] = 576 / 2;
00171     for (i = 0; i < 3; i++) {
00172         k = FFMIN(g->region_size[i], g->big_values);
00173         g->region_size[i] = k - j;
00174         j = k;
00175     }
00176 }
00177 
00178 static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
00179 {
00180     if (g->block_type == 2)
00181         g->region_size[0] = (36 / 2);
00182     else {
00183         if (s->sample_rate_index <= 2)
00184             g->region_size[0] = (36 / 2);
00185         else if (s->sample_rate_index != 8)
00186             g->region_size[0] = (54 / 2);
00187         else
00188             g->region_size[0] = (108 / 2);
00189     }
00190     g->region_size[1] = (576 / 2);
00191 }
00192 
00193 static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
00194 {
00195     int l;
00196     g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
00197     /* should not overflow */
00198     l = FFMIN(ra1 + ra2 + 2, 22);
00199     g->region_size[1] = band_index_long[s->sample_rate_index][      l] >> 1;
00200 }
00201 
00202 static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
00203 {
00204     if (g->block_type == 2) {
00205         if (g->switch_point) {
00206             /* if switched mode, we handle the 36 first samples as
00207                 long blocks.  For 8000Hz, we handle the 48 first
00208                 exponents as long blocks (XXX: check this!) */
00209             if (s->sample_rate_index <= 2)
00210                 g->long_end = 8;
00211             else if (s->sample_rate_index != 8)
00212                 g->long_end = 6;
00213             else
00214                 g->long_end = 4; /* 8000 Hz */
00215 
00216             g->short_start = 2 + (s->sample_rate_index != 8);
00217         } else {
00218             g->long_end    = 0;
00219             g->short_start = 0;
00220         }
00221     } else {
00222         g->short_start = 13;
00223         g->long_end    = 22;
00224     }
00225 }
00226 
00227 /* layer 1 unscaling */
00228 /* n = number of bits of the mantissa minus 1 */
00229 static inline int l1_unscale(int n, int mant, int scale_factor)
00230 {
00231     int shift, mod;
00232     int64_t val;
00233 
00234     shift   = scale_factor_modshift[scale_factor];
00235     mod     = shift & 3;
00236     shift >>= 2;
00237     val     = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
00238     shift  += n;
00239     /* NOTE: at this point, 1 <= shift >= 21 + 15 */
00240     return (int)((val + (1LL << (shift - 1))) >> shift);
00241 }
00242 
00243 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
00244 {
00245     int shift, mod, val;
00246 
00247     shift   = scale_factor_modshift[scale_factor];
00248     mod     = shift & 3;
00249     shift >>= 2;
00250 
00251     val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
00252     /* NOTE: at this point, 0 <= shift <= 21 */
00253     if (shift > 0)
00254         val = (val + (1 << (shift - 1))) >> shift;
00255     return val;
00256 }
00257 
00258 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
00259 static inline int l3_unscale(int value, int exponent)
00260 {
00261     unsigned int m;
00262     int e;
00263 
00264     e  = table_4_3_exp  [4 * value + (exponent & 3)];
00265     m  = table_4_3_value[4 * value + (exponent & 3)];
00266     e -= exponent >> 2;
00267     assert(e >= 1);
00268     if (e > 31)
00269         return 0;
00270     m = (m + (1 << (e - 1))) >> e;
00271 
00272     return m;
00273 }
00274 
00275 static av_cold void decode_init_static(void)
00276 {
00277     int i, j, k;
00278     int offset;
00279 
00280     /* scale factors table for layer 1/2 */
00281     for (i = 0; i < 64; i++) {
00282         int shift, mod;
00283         /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
00284         shift = i / 3;
00285         mod   = i % 3;
00286         scale_factor_modshift[i] = mod | (shift << 2);
00287     }
00288 
00289     /* scale factor multiply for layer 1 */
00290     for (i = 0; i < 15; i++) {
00291         int n, norm;
00292         n = i + 2;
00293         norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
00294         scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0          * 2.0), FRAC_BITS);
00295         scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
00296         scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
00297         av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
00298                 scale_factor_mult[i][0],
00299                 scale_factor_mult[i][1],
00300                 scale_factor_mult[i][2]);
00301     }
00302 
00303     RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
00304 
00305     /* huffman decode tables */
00306     offset = 0;
00307     for (i = 1; i < 16; i++) {
00308         const HuffTable *h = &mpa_huff_tables[i];
00309         int xsize, x, y;
00310         uint8_t  tmp_bits [512];
00311         uint16_t tmp_codes[512];
00312 
00313         memset(tmp_bits , 0, sizeof(tmp_bits ));
00314         memset(tmp_codes, 0, sizeof(tmp_codes));
00315 
00316         xsize = h->xsize;
00317 
00318         j = 0;
00319         for (x = 0; x < xsize; x++) {
00320             for (y = 0; y < xsize; y++) {
00321                 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j  ];
00322                 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
00323             }
00324         }
00325 
00326         /* XXX: fail test */
00327         huff_vlc[i].table = huff_vlc_tables+offset;
00328         huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
00329         init_vlc(&huff_vlc[i], 7, 512,
00330                  tmp_bits, 1, 1, tmp_codes, 2, 2,
00331                  INIT_VLC_USE_NEW_STATIC);
00332         offset += huff_vlc_tables_sizes[i];
00333     }
00334     assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
00335 
00336     offset = 0;
00337     for (i = 0; i < 2; i++) {
00338         huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
00339         huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
00340         init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
00341                  mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
00342                  INIT_VLC_USE_NEW_STATIC);
00343         offset += huff_quad_vlc_tables_sizes[i];
00344     }
00345     assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
00346 
00347     for (i = 0; i < 9; i++) {
00348         k = 0;
00349         for (j = 0; j < 22; j++) {
00350             band_index_long[i][j] = k;
00351             k += band_size_long[i][j];
00352         }
00353         band_index_long[i][22] = k;
00354     }
00355 
00356     /* compute n ^ (4/3) and store it in mantissa/exp format */
00357 
00358     mpegaudio_tableinit();
00359 
00360     for (i = 0; i < 4; i++) {
00361         if (ff_mpa_quant_bits[i] < 0) {
00362             for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
00363                 int val1, val2, val3, steps;
00364                 int val = j;
00365                 steps   = ff_mpa_quant_steps[i];
00366                 val1    = val % steps;
00367                 val    /= steps;
00368                 val2    = val % steps;
00369                 val3    = val / steps;
00370                 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
00371             }
00372         }
00373     }
00374 
00375 
00376     for (i = 0; i < 7; i++) {
00377         float f;
00378         INTFLOAT v;
00379         if (i != 6) {
00380             f = tan((double)i * M_PI / 12.0);
00381             v = FIXR(f / (1.0 + f));
00382         } else {
00383             v = FIXR(1.0);
00384         }
00385         is_table[0][    i] = v;
00386         is_table[1][6 - i] = v;
00387     }
00388     /* invalid values */
00389     for (i = 7; i < 16; i++)
00390         is_table[0][i] = is_table[1][i] = 0.0;
00391 
00392     for (i = 0; i < 16; i++) {
00393         double f;
00394         int e, k;
00395 
00396         for (j = 0; j < 2; j++) {
00397             e = -(j + 1) * ((i + 1) >> 1);
00398             f = pow(2.0, e / 4.0);
00399             k = i & 1;
00400             is_table_lsf[j][k ^ 1][i] = FIXR(f);
00401             is_table_lsf[j][k    ][i] = FIXR(1.0);
00402             av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
00403                     i, j, (float) is_table_lsf[j][0][i],
00404                     (float) is_table_lsf[j][1][i]);
00405         }
00406     }
00407 
00408     for (i = 0; i < 8; i++) {
00409         float ci, cs, ca;
00410         ci = ci_table[i];
00411         cs = 1.0 / sqrt(1.0 + ci * ci);
00412         ca = cs * ci;
00413 #if !CONFIG_FLOAT
00414         csa_table[i][0] = FIXHR(cs/4);
00415         csa_table[i][1] = FIXHR(ca/4);
00416         csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
00417         csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
00418 #else
00419         csa_table[i][0] = cs;
00420         csa_table[i][1] = ca;
00421         csa_table[i][2] = ca + cs;
00422         csa_table[i][3] = ca - cs;
00423 #endif
00424     }
00425 
00426     /* compute mdct windows */
00427     for (i = 0; i < 36; i++) {
00428         for (j = 0; j < 4; j++) {
00429             double d;
00430 
00431             if (j == 2 && i % 3 != 1)
00432                 continue;
00433 
00434             d = sin(M_PI * (i + 0.5) / 36.0);
00435             if (j == 1) {
00436                 if      (i >= 30) d = 0;
00437                 else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);
00438                 else if (i >= 18) d = 1;
00439             } else if (j == 3) {
00440                 if      (i <   6) d = 0;
00441                 else if (i <  12) d = sin(M_PI * (i -  6 + 0.5) / 12.0);
00442                 else if (i <  18) d = 1;
00443             }
00444             //merge last stage of imdct into the window coefficients
00445             d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);
00446 
00447             if (j == 2)
00448                 mdct_win[j][i/3] = FIXHR((d / (1<<5)));
00449             else {
00450                 int idx = i < 18 ? i : i + 2;
00451                 mdct_win[j][idx] = FIXHR((d / (1<<5)));
00452             }
00453         }
00454     }
00455 
00456     /* NOTE: we do frequency inversion adter the MDCT by changing
00457         the sign of the right window coefs */
00458     for (j = 0; j < 4; j++) {
00459         for (i = 0; i < 40; i += 2) {
00460             mdct_win[j + 4][i    ] =  mdct_win[j][i    ];
00461             mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
00462         }
00463     }
00464 }
00465 
00466 static av_cold int decode_init(AVCodecContext * avctx)
00467 {
00468     static int initialized_tables = 0;
00469     MPADecodeContext *s = avctx->priv_data;
00470 
00471     if (!initialized_tables) {
00472         decode_init_static();
00473         initialized_tables = 1;
00474     }
00475 
00476     s->avctx = avctx;
00477 
00478     ff_mpadsp_init(&s->mpadsp);
00479 
00480     avctx->sample_fmt= OUT_FMT;
00481     s->err_recognition = avctx->err_recognition;
00482 
00483     if (avctx->codec_id == CODEC_ID_MP3ADU)
00484         s->adu_mode = 1;
00485 
00486     avcodec_get_frame_defaults(&s->frame);
00487     avctx->coded_frame = &s->frame;
00488 
00489     return 0;
00490 }
00491 
00492 #define C3 FIXHR(0.86602540378443864676/2)
00493 #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
00494 #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
00495 #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
00496 
00497 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
00498    cases. */
00499 static void imdct12(INTFLOAT *out, INTFLOAT *in)
00500 {
00501     INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
00502 
00503     in0  = in[0*3];
00504     in1  = in[1*3] + in[0*3];
00505     in2  = in[2*3] + in[1*3];
00506     in3  = in[3*3] + in[2*3];
00507     in4  = in[4*3] + in[3*3];
00508     in5  = in[5*3] + in[4*3];
00509     in5 += in3;
00510     in3 += in1;
00511 
00512     in2  = MULH3(in2, C3, 2);
00513     in3  = MULH3(in3, C3, 4);
00514 
00515     t1   = in0 - in4;
00516     t2   = MULH3(in1 - in5, C4, 2);
00517 
00518     out[ 7] =
00519     out[10] = t1 + t2;
00520     out[ 1] =
00521     out[ 4] = t1 - t2;
00522 
00523     in0    += SHR(in4, 1);
00524     in4     = in0 + in2;
00525     in5    += 2*in1;
00526     in1     = MULH3(in5 + in3, C5, 1);
00527     out[ 8] =
00528     out[ 9] = in4 + in1;
00529     out[ 2] =
00530     out[ 3] = in4 - in1;
00531 
00532     in0    -= in2;
00533     in5     = MULH3(in5 - in3, C6, 2);
00534     out[ 0] =
00535     out[ 5] = in0 - in5;
00536     out[ 6] =
00537     out[11] = in0 + in5;
00538 }
00539 
00540 /* return the number of decoded frames */
00541 static int mp_decode_layer1(MPADecodeContext *s)
00542 {
00543     int bound, i, v, n, ch, j, mant;
00544     uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
00545     uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
00546 
00547     if (s->mode == MPA_JSTEREO)
00548         bound = (s->mode_ext + 1) * 4;
00549     else
00550         bound = SBLIMIT;
00551 
00552     /* allocation bits */
00553     for (i = 0; i < bound; i++) {
00554         for (ch = 0; ch < s->nb_channels; ch++) {
00555             allocation[ch][i] = get_bits(&s->gb, 4);
00556         }
00557     }
00558     for (i = bound; i < SBLIMIT; i++)
00559         allocation[0][i] = get_bits(&s->gb, 4);
00560 
00561     /* scale factors */
00562     for (i = 0; i < bound; i++) {
00563         for (ch = 0; ch < s->nb_channels; ch++) {
00564             if (allocation[ch][i])
00565                 scale_factors[ch][i] = get_bits(&s->gb, 6);
00566         }
00567     }
00568     for (i = bound; i < SBLIMIT; i++) {
00569         if (allocation[0][i]) {
00570             scale_factors[0][i] = get_bits(&s->gb, 6);
00571             scale_factors[1][i] = get_bits(&s->gb, 6);
00572         }
00573     }
00574 
00575     /* compute samples */
00576     for (j = 0; j < 12; j++) {
00577         for (i = 0; i < bound; i++) {
00578             for (ch = 0; ch < s->nb_channels; ch++) {
00579                 n = allocation[ch][i];
00580                 if (n) {
00581                     mant = get_bits(&s->gb, n + 1);
00582                     v = l1_unscale(n, mant, scale_factors[ch][i]);
00583                 } else {
00584                     v = 0;
00585                 }
00586                 s->sb_samples[ch][j][i] = v;
00587             }
00588         }
00589         for (i = bound; i < SBLIMIT; i++) {
00590             n = allocation[0][i];
00591             if (n) {
00592                 mant = get_bits(&s->gb, n + 1);
00593                 v = l1_unscale(n, mant, scale_factors[0][i]);
00594                 s->sb_samples[0][j][i] = v;
00595                 v = l1_unscale(n, mant, scale_factors[1][i]);
00596                 s->sb_samples[1][j][i] = v;
00597             } else {
00598                 s->sb_samples[0][j][i] = 0;
00599                 s->sb_samples[1][j][i] = 0;
00600             }
00601         }
00602     }
00603     return 12;
00604 }
00605 
00606 static int mp_decode_layer2(MPADecodeContext *s)
00607 {
00608     int sblimit; /* number of used subbands */
00609     const unsigned char *alloc_table;
00610     int table, bit_alloc_bits, i, j, ch, bound, v;
00611     unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
00612     unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
00613     unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
00614     int scale, qindex, bits, steps, k, l, m, b;
00615 
00616     /* select decoding table */
00617     table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
00618                                    s->sample_rate, s->lsf);
00619     sblimit     = ff_mpa_sblimit_table[table];
00620     alloc_table = ff_mpa_alloc_tables[table];
00621 
00622     if (s->mode == MPA_JSTEREO)
00623         bound = (s->mode_ext + 1) * 4;
00624     else
00625         bound = sblimit;
00626 
00627     av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
00628 
00629     /* sanity check */
00630     if (bound > sblimit)
00631         bound = sblimit;
00632 
00633     /* parse bit allocation */
00634     j = 0;
00635     for (i = 0; i < bound; i++) {
00636         bit_alloc_bits = alloc_table[j];
00637         for (ch = 0; ch < s->nb_channels; ch++)
00638             bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
00639         j += 1 << bit_alloc_bits;
00640     }
00641     for (i = bound; i < sblimit; i++) {
00642         bit_alloc_bits = alloc_table[j];
00643         v = get_bits(&s->gb, bit_alloc_bits);
00644         bit_alloc[0][i] = v;
00645         bit_alloc[1][i] = v;
00646         j += 1 << bit_alloc_bits;
00647     }
00648 
00649     /* scale codes */
00650     for (i = 0; i < sblimit; i++) {
00651         for (ch = 0; ch < s->nb_channels; ch++) {
00652             if (bit_alloc[ch][i])
00653                 scale_code[ch][i] = get_bits(&s->gb, 2);
00654         }
00655     }
00656 
00657     /* scale factors */
00658     for (i = 0; i < sblimit; i++) {
00659         for (ch = 0; ch < s->nb_channels; ch++) {
00660             if (bit_alloc[ch][i]) {
00661                 sf = scale_factors[ch][i];
00662                 switch (scale_code[ch][i]) {
00663                 default:
00664                 case 0:
00665                     sf[0] = get_bits(&s->gb, 6);
00666                     sf[1] = get_bits(&s->gb, 6);
00667                     sf[2] = get_bits(&s->gb, 6);
00668                     break;
00669                 case 2:
00670                     sf[0] = get_bits(&s->gb, 6);
00671                     sf[1] = sf[0];
00672                     sf[2] = sf[0];
00673                     break;
00674                 case 1:
00675                     sf[0] = get_bits(&s->gb, 6);
00676                     sf[2] = get_bits(&s->gb, 6);
00677                     sf[1] = sf[0];
00678                     break;
00679                 case 3:
00680                     sf[0] = get_bits(&s->gb, 6);
00681                     sf[2] = get_bits(&s->gb, 6);
00682                     sf[1] = sf[2];
00683                     break;
00684                 }
00685             }
00686         }
00687     }
00688 
00689     /* samples */
00690     for (k = 0; k < 3; k++) {
00691         for (l = 0; l < 12; l += 3) {
00692             j = 0;
00693             for (i = 0; i < bound; i++) {
00694                 bit_alloc_bits = alloc_table[j];
00695                 for (ch = 0; ch < s->nb_channels; ch++) {
00696                     b = bit_alloc[ch][i];
00697                     if (b) {
00698                         scale = scale_factors[ch][i][k];
00699                         qindex = alloc_table[j+b];
00700                         bits = ff_mpa_quant_bits[qindex];
00701                         if (bits < 0) {
00702                             int v2;
00703                             /* 3 values at the same time */
00704                             v = get_bits(&s->gb, -bits);
00705                             v2 = division_tabs[qindex][v];
00706                             steps  = ff_mpa_quant_steps[qindex];
00707 
00708                             s->sb_samples[ch][k * 12 + l + 0][i] =
00709                                 l2_unscale_group(steps,  v2       & 15, scale);
00710                             s->sb_samples[ch][k * 12 + l + 1][i] =
00711                                 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
00712                             s->sb_samples[ch][k * 12 + l + 2][i] =
00713                                 l2_unscale_group(steps,  v2 >> 8      , scale);
00714                         } else {
00715                             for (m = 0; m < 3; m++) {
00716                                 v = get_bits(&s->gb, bits);
00717                                 v = l1_unscale(bits - 1, v, scale);
00718                                 s->sb_samples[ch][k * 12 + l + m][i] = v;
00719                             }
00720                         }
00721                     } else {
00722                         s->sb_samples[ch][k * 12 + l + 0][i] = 0;
00723                         s->sb_samples[ch][k * 12 + l + 1][i] = 0;
00724                         s->sb_samples[ch][k * 12 + l + 2][i] = 0;
00725                     }
00726                 }
00727                 /* next subband in alloc table */
00728                 j += 1 << bit_alloc_bits;
00729             }
00730             /* XXX: find a way to avoid this duplication of code */
00731             for (i = bound; i < sblimit; i++) {
00732                 bit_alloc_bits = alloc_table[j];
00733                 b = bit_alloc[0][i];
00734                 if (b) {
00735                     int mant, scale0, scale1;
00736                     scale0 = scale_factors[0][i][k];
00737                     scale1 = scale_factors[1][i][k];
00738                     qindex = alloc_table[j+b];
00739                     bits = ff_mpa_quant_bits[qindex];
00740                     if (bits < 0) {
00741                         /* 3 values at the same time */
00742                         v = get_bits(&s->gb, -bits);
00743                         steps = ff_mpa_quant_steps[qindex];
00744                         mant = v % steps;
00745                         v = v / steps;
00746                         s->sb_samples[0][k * 12 + l + 0][i] =
00747                             l2_unscale_group(steps, mant, scale0);
00748                         s->sb_samples[1][k * 12 + l + 0][i] =
00749                             l2_unscale_group(steps, mant, scale1);
00750                         mant = v % steps;
00751                         v = v / steps;
00752                         s->sb_samples[0][k * 12 + l + 1][i] =
00753                             l2_unscale_group(steps, mant, scale0);
00754                         s->sb_samples[1][k * 12 + l + 1][i] =
00755                             l2_unscale_group(steps, mant, scale1);
00756                         s->sb_samples[0][k * 12 + l + 2][i] =
00757                             l2_unscale_group(steps, v, scale0);
00758                         s->sb_samples[1][k * 12 + l + 2][i] =
00759                             l2_unscale_group(steps, v, scale1);
00760                     } else {
00761                         for (m = 0; m < 3; m++) {
00762                             mant = get_bits(&s->gb, bits);
00763                             s->sb_samples[0][k * 12 + l + m][i] =
00764                                 l1_unscale(bits - 1, mant, scale0);
00765                             s->sb_samples[1][k * 12 + l + m][i] =
00766                                 l1_unscale(bits - 1, mant, scale1);
00767                         }
00768                     }
00769                 } else {
00770                     s->sb_samples[0][k * 12 + l + 0][i] = 0;
00771                     s->sb_samples[0][k * 12 + l + 1][i] = 0;
00772                     s->sb_samples[0][k * 12 + l + 2][i] = 0;
00773                     s->sb_samples[1][k * 12 + l + 0][i] = 0;
00774                     s->sb_samples[1][k * 12 + l + 1][i] = 0;
00775                     s->sb_samples[1][k * 12 + l + 2][i] = 0;
00776                 }
00777                 /* next subband in alloc table */
00778                 j += 1 << bit_alloc_bits;
00779             }
00780             /* fill remaining samples to zero */
00781             for (i = sblimit; i < SBLIMIT; i++) {
00782                 for (ch = 0; ch < s->nb_channels; ch++) {
00783                     s->sb_samples[ch][k * 12 + l + 0][i] = 0;
00784                     s->sb_samples[ch][k * 12 + l + 1][i] = 0;
00785                     s->sb_samples[ch][k * 12 + l + 2][i] = 0;
00786                 }
00787             }
00788         }
00789     }
00790     return 3 * 12;
00791 }
00792 
00793 #define SPLIT(dst,sf,n)             \
00794     if (n == 3) {                   \
00795         int m = (sf * 171) >> 9;    \
00796         dst   = sf - 3 * m;         \
00797         sf    = m;                  \
00798     } else if (n == 4) {            \
00799         dst  = sf & 3;              \
00800         sf >>= 2;                   \
00801     } else if (n == 5) {            \
00802         int m = (sf * 205) >> 10;   \
00803         dst   = sf - 5 * m;         \
00804         sf    = m;                  \
00805     } else if (n == 6) {            \
00806         int m = (sf * 171) >> 10;   \
00807         dst   = sf - 6 * m;         \
00808         sf    = m;                  \
00809     } else {                        \
00810         dst = 0;                    \
00811     }
00812 
00813 static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
00814                                            int n3)
00815 {
00816     SPLIT(slen[3], sf, n3)
00817     SPLIT(slen[2], sf, n2)
00818     SPLIT(slen[1], sf, n1)
00819     slen[0] = sf;
00820 }
00821 
00822 static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
00823                                          int16_t *exponents)
00824 {
00825     const uint8_t *bstab, *pretab;
00826     int len, i, j, k, l, v0, shift, gain, gains[3];
00827     int16_t *exp_ptr;
00828 
00829     exp_ptr = exponents;
00830     gain    = g->global_gain - 210;
00831     shift   = g->scalefac_scale + 1;
00832 
00833     bstab  = band_size_long[s->sample_rate_index];
00834     pretab = mpa_pretab[g->preflag];
00835     for (i = 0; i < g->long_end; i++) {
00836         v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
00837         len = bstab[i];
00838         for (j = len; j > 0; j--)
00839             *exp_ptr++ = v0;
00840     }
00841 
00842     if (g->short_start < 13) {
00843         bstab    = band_size_short[s->sample_rate_index];
00844         gains[0] = gain - (g->subblock_gain[0] << 3);
00845         gains[1] = gain - (g->subblock_gain[1] << 3);
00846         gains[2] = gain - (g->subblock_gain[2] << 3);
00847         k        = g->long_end;
00848         for (i = g->short_start; i < 13; i++) {
00849             len = bstab[i];
00850             for (l = 0; l < 3; l++) {
00851                 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
00852                 for (j = len; j > 0; j--)
00853                     *exp_ptr++ = v0;
00854             }
00855         }
00856     }
00857 }
00858 
00859 /* handle n = 0 too */
00860 static inline int get_bitsz(GetBitContext *s, int n)
00861 {
00862     return n ? get_bits(s, n) : 0;
00863 }
00864 
00865 
00866 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
00867                           int *end_pos2)
00868 {
00869     if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
00870         s->gb           = s->in_gb;
00871         s->in_gb.buffer = NULL;
00872         assert((get_bits_count(&s->gb) & 7) == 0);
00873         skip_bits_long(&s->gb, *pos - *end_pos);
00874         *end_pos2 =
00875         *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
00876         *pos      = get_bits_count(&s->gb);
00877     }
00878 }
00879 
00880 /* Following is a optimized code for
00881             INTFLOAT v = *src
00882             if(get_bits1(&s->gb))
00883                 v = -v;
00884             *dst = v;
00885 */
00886 #if CONFIG_FLOAT
00887 #define READ_FLIP_SIGN(dst,src)                     \
00888     v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \
00889     AV_WN32A(dst, v);
00890 #else
00891 #define READ_FLIP_SIGN(dst,src)     \
00892     v      = -get_bits1(&s->gb);    \
00893     *(dst) = (*(src) ^ v) - v;
00894 #endif
00895 
00896 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
00897                           int16_t *exponents, int end_pos2)
00898 {
00899     int s_index;
00900     int i;
00901     int last_pos, bits_left;
00902     VLC *vlc;
00903     int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
00904 
00905     /* low frequencies (called big values) */
00906     s_index = 0;
00907     for (i = 0; i < 3; i++) {
00908         int j, k, l, linbits;
00909         j = g->region_size[i];
00910         if (j == 0)
00911             continue;
00912         /* select vlc table */
00913         k       = g->table_select[i];
00914         l       = mpa_huff_data[k][0];
00915         linbits = mpa_huff_data[k][1];
00916         vlc     = &huff_vlc[l];
00917 
00918         if (!l) {
00919             memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
00920             s_index += 2 * j;
00921             continue;
00922         }
00923 
00924         /* read huffcode and compute each couple */
00925         for (; j > 0; j--) {
00926             int exponent, x, y;
00927             int v;
00928             int pos = get_bits_count(&s->gb);
00929 
00930             if (pos >= end_pos){
00931 //                av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
00932                 switch_buffer(s, &pos, &end_pos, &end_pos2);
00933 //                av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
00934                 if (pos >= end_pos)
00935                     break;
00936             }
00937             y = get_vlc2(&s->gb, vlc->table, 7, 3);
00938 
00939             if (!y) {
00940                 g->sb_hybrid[s_index  ] =
00941                 g->sb_hybrid[s_index+1] = 0;
00942                 s_index += 2;
00943                 continue;
00944             }
00945 
00946             exponent= exponents[s_index];
00947 
00948             av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
00949                     i, g->region_size[i] - j, x, y, exponent);
00950             if (y & 16) {
00951                 x = y >> 5;
00952                 y = y & 0x0f;
00953                 if (x < 15) {
00954                     READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
00955                 } else {
00956                     x += get_bitsz(&s->gb, linbits);
00957                     v  = l3_unscale(x, exponent);
00958                     if (get_bits1(&s->gb))
00959                         v = -v;
00960                     g->sb_hybrid[s_index] = v;
00961                 }
00962                 if (y < 15) {
00963                     READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
00964                 } else {
00965                     y += get_bitsz(&s->gb, linbits);
00966                     v  = l3_unscale(y, exponent);
00967                     if (get_bits1(&s->gb))
00968                         v = -v;
00969                     g->sb_hybrid[s_index+1] = v;
00970                 }
00971             } else {
00972                 x = y >> 5;
00973                 y = y & 0x0f;
00974                 x += y;
00975                 if (x < 15) {
00976                     READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
00977                 } else {
00978                     x += get_bitsz(&s->gb, linbits);
00979                     v  = l3_unscale(x, exponent);
00980                     if (get_bits1(&s->gb))
00981                         v = -v;
00982                     g->sb_hybrid[s_index+!!y] = v;
00983                 }
00984                 g->sb_hybrid[s_index + !y] = 0;
00985             }
00986             s_index += 2;
00987         }
00988     }
00989 
00990     /* high frequencies */
00991     vlc = &huff_quad_vlc[g->count1table_select];
00992     last_pos = 0;
00993     while (s_index <= 572) {
00994         int pos, code;
00995         pos = get_bits_count(&s->gb);
00996         if (pos >= end_pos) {
00997             if (pos > end_pos2 && last_pos) {
00998                 /* some encoders generate an incorrect size for this
00999                    part. We must go back into the data */
01000                 s_index -= 4;
01001                 skip_bits_long(&s->gb, last_pos - pos);
01002                 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
01003                 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
01004                     s_index=0;
01005                 break;
01006             }
01007 //                av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
01008             switch_buffer(s, &pos, &end_pos, &end_pos2);
01009 //                av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
01010             if (pos >= end_pos)
01011                 break;
01012         }
01013         last_pos = pos;
01014 
01015         code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
01016         av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
01017         g->sb_hybrid[s_index+0] =
01018         g->sb_hybrid[s_index+1] =
01019         g->sb_hybrid[s_index+2] =
01020         g->sb_hybrid[s_index+3] = 0;
01021         while (code) {
01022             static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
01023             int v;
01024             int pos = s_index + idxtab[code];
01025             code   ^= 8 >> idxtab[code];
01026             READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
01027         }
01028         s_index += 4;
01029     }
01030     /* skip extension bits */
01031     bits_left = end_pos2 - get_bits_count(&s->gb);
01032 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
01033     if (bits_left < 0 && (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) {
01034         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
01035         s_index=0;
01036     } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE))) {
01037         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
01038         s_index = 0;
01039     }
01040     memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
01041     skip_bits_long(&s->gb, bits_left);
01042 
01043     i = get_bits_count(&s->gb);
01044     switch_buffer(s, &i, &end_pos, &end_pos2);
01045 
01046     return 0;
01047 }
01048 
01049 /* Reorder short blocks from bitstream order to interleaved order. It
01050    would be faster to do it in parsing, but the code would be far more
01051    complicated */
01052 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
01053 {
01054     int i, j, len;
01055     INTFLOAT *ptr, *dst, *ptr1;
01056     INTFLOAT tmp[576];
01057 
01058     if (g->block_type != 2)
01059         return;
01060 
01061     if (g->switch_point) {
01062         if (s->sample_rate_index != 8)
01063             ptr = g->sb_hybrid + 36;
01064         else
01065             ptr = g->sb_hybrid + 48;
01066     } else {
01067         ptr = g->sb_hybrid;
01068     }
01069 
01070     for (i = g->short_start; i < 13; i++) {
01071         len  = band_size_short[s->sample_rate_index][i];
01072         ptr1 = ptr;
01073         dst  = tmp;
01074         for (j = len; j > 0; j--) {
01075             *dst++ = ptr[0*len];
01076             *dst++ = ptr[1*len];
01077             *dst++ = ptr[2*len];
01078             ptr++;
01079         }
01080         ptr += 2 * len;
01081         memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
01082     }
01083 }
01084 
01085 #define ISQRT2 FIXR(0.70710678118654752440)
01086 
01087 static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
01088 {
01089     int i, j, k, l;
01090     int sf_max, sf, len, non_zero_found;
01091     INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
01092     int non_zero_found_short[3];
01093 
01094     /* intensity stereo */
01095     if (s->mode_ext & MODE_EXT_I_STEREO) {
01096         if (!s->lsf) {
01097             is_tab = is_table;
01098             sf_max = 7;
01099         } else {
01100             is_tab = is_table_lsf[g1->scalefac_compress & 1];
01101             sf_max = 16;
01102         }
01103 
01104         tab0 = g0->sb_hybrid + 576;
01105         tab1 = g1->sb_hybrid + 576;
01106 
01107         non_zero_found_short[0] = 0;
01108         non_zero_found_short[1] = 0;
01109         non_zero_found_short[2] = 0;
01110         k = (13 - g1->short_start) * 3 + g1->long_end - 3;
01111         for (i = 12; i >= g1->short_start; i--) {
01112             /* for last band, use previous scale factor */
01113             if (i != 11)
01114                 k -= 3;
01115             len = band_size_short[s->sample_rate_index][i];
01116             for (l = 2; l >= 0; l--) {
01117                 tab0 -= len;
01118                 tab1 -= len;
01119                 if (!non_zero_found_short[l]) {
01120                     /* test if non zero band. if so, stop doing i-stereo */
01121                     for (j = 0; j < len; j++) {
01122                         if (tab1[j] != 0) {
01123                             non_zero_found_short[l] = 1;
01124                             goto found1;
01125                         }
01126                     }
01127                     sf = g1->scale_factors[k + l];
01128                     if (sf >= sf_max)
01129                         goto found1;
01130 
01131                     v1 = is_tab[0][sf];
01132                     v2 = is_tab[1][sf];
01133                     for (j = 0; j < len; j++) {
01134                         tmp0    = tab0[j];
01135                         tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
01136                         tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
01137                     }
01138                 } else {
01139 found1:
01140                     if (s->mode_ext & MODE_EXT_MS_STEREO) {
01141                         /* lower part of the spectrum : do ms stereo
01142                            if enabled */
01143                         for (j = 0; j < len; j++) {
01144                             tmp0    = tab0[j];
01145                             tmp1    = tab1[j];
01146                             tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
01147                             tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
01148                         }
01149                     }
01150                 }
01151             }
01152         }
01153 
01154         non_zero_found = non_zero_found_short[0] |
01155                          non_zero_found_short[1] |
01156                          non_zero_found_short[2];
01157 
01158         for (i = g1->long_end - 1;i >= 0;i--) {
01159             len   = band_size_long[s->sample_rate_index][i];
01160             tab0 -= len;
01161             tab1 -= len;
01162             /* test if non zero band. if so, stop doing i-stereo */
01163             if (!non_zero_found) {
01164                 for (j = 0; j < len; j++) {
01165                     if (tab1[j] != 0) {
01166                         non_zero_found = 1;
01167                         goto found2;
01168                     }
01169                 }
01170                 /* for last band, use previous scale factor */
01171                 k  = (i == 21) ? 20 : i;
01172                 sf = g1->scale_factors[k];
01173                 if (sf >= sf_max)
01174                     goto found2;
01175                 v1 = is_tab[0][sf];
01176                 v2 = is_tab[1][sf];
01177                 for (j = 0; j < len; j++) {
01178                     tmp0    = tab0[j];
01179                     tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
01180                     tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
01181                 }
01182             } else {
01183 found2:
01184                 if (s->mode_ext & MODE_EXT_MS_STEREO) {
01185                     /* lower part of the spectrum : do ms stereo
01186                        if enabled */
01187                     for (j = 0; j < len; j++) {
01188                         tmp0    = tab0[j];
01189                         tmp1    = tab1[j];
01190                         tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
01191                         tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
01192                     }
01193                 }
01194             }
01195         }
01196     } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
01197         /* ms stereo ONLY */
01198         /* NOTE: the 1/sqrt(2) normalization factor is included in the
01199            global gain */
01200         tab0 = g0->sb_hybrid;
01201         tab1 = g1->sb_hybrid;
01202         for (i = 0; i < 576; i++) {
01203             tmp0    = tab0[i];
01204             tmp1    = tab1[i];
01205             tab0[i] = tmp0 + tmp1;
01206             tab1[i] = tmp0 - tmp1;
01207         }
01208     }
01209 }
01210 
01211 #if CONFIG_FLOAT
01212 #define AA(j) do {                                                      \
01213         float tmp0 = ptr[-1-j];                                         \
01214         float tmp1 = ptr[   j];                                         \
01215         ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1];    \
01216         ptr[   j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0];    \
01217     } while (0)
01218 #else
01219 #define AA(j) do {                                              \
01220         int tmp0 = ptr[-1-j];                                   \
01221         int tmp1 = ptr[   j];                                   \
01222         int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
01223         ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
01224         ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
01225     } while (0)
01226 #endif
01227 
01228 static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
01229 {
01230     INTFLOAT *ptr;
01231     int n, i;
01232 
01233     /* we antialias only "long" bands */
01234     if (g->block_type == 2) {
01235         if (!g->switch_point)
01236             return;
01237         /* XXX: check this for 8000Hz case */
01238         n = 1;
01239     } else {
01240         n = SBLIMIT - 1;
01241     }
01242 
01243     ptr = g->sb_hybrid + 18;
01244     for (i = n; i > 0; i--) {
01245         AA(0);
01246         AA(1);
01247         AA(2);
01248         AA(3);
01249         AA(4);
01250         AA(5);
01251         AA(6);
01252         AA(7);
01253 
01254         ptr += 18;
01255     }
01256 }
01257 
01258 static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
01259                           INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
01260 {
01261     INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
01262     INTFLOAT out2[12];
01263     int i, j, mdct_long_end, sblimit;
01264 
01265     /* find last non zero block */
01266     ptr  = g->sb_hybrid + 576;
01267     ptr1 = g->sb_hybrid + 2 * 18;
01268     while (ptr >= ptr1) {
01269         int32_t *p;
01270         ptr -= 6;
01271         p    = (int32_t*)ptr;
01272         if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
01273             break;
01274     }
01275     sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
01276 
01277     if (g->block_type == 2) {
01278         /* XXX: check for 8000 Hz */
01279         if (g->switch_point)
01280             mdct_long_end = 2;
01281         else
01282             mdct_long_end = 0;
01283     } else {
01284         mdct_long_end = sblimit;
01285     }
01286 
01287     buf = mdct_buf;
01288     ptr = g->sb_hybrid;
01289     for (j = 0; j < mdct_long_end; j++) {
01290         int win_idx = (g->switch_point && j < 2) ? 0 : g->block_type;
01291         /* apply window & overlap with previous buffer */
01292         out_ptr = sb_samples + j;
01293         /* select window */
01294         win = mdct_win[win_idx + (4 & -(j & 1))];
01295         s->mpadsp.RENAME(imdct36)(out_ptr, buf, ptr, win);
01296         out_ptr += 18 * SBLIMIT;
01297         ptr     += 18;
01298         buf     += 18;
01299     }
01300     for (j = mdct_long_end; j < sblimit; j++) {
01301         /* select frequency inversion */
01302         win     = mdct_win[2 + (4  & -(j & 1))];
01303         out_ptr = sb_samples + j;
01304 
01305         for (i = 0; i < 6; i++) {
01306             *out_ptr = buf[i];
01307             out_ptr += SBLIMIT;
01308         }
01309         imdct12(out2, ptr + 0);
01310         for (i = 0; i < 6; i++) {
01311             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[i + 6*1];
01312             buf[i + 6*2] = MULH3(out2[i + 6], win[i + 6], 1);
01313             out_ptr += SBLIMIT;
01314         }
01315         imdct12(out2, ptr + 1);
01316         for (i = 0; i < 6; i++) {
01317             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[i + 6*2];
01318             buf[i + 6*0] = MULH3(out2[i + 6], win[i + 6], 1);
01319             out_ptr += SBLIMIT;
01320         }
01321         imdct12(out2, ptr + 2);
01322         for (i = 0; i < 6; i++) {
01323             buf[i + 6*0] = MULH3(out2[i    ], win[i    ], 1) + buf[i + 6*0];
01324             buf[i + 6*1] = MULH3(out2[i + 6], win[i + 6], 1);
01325             buf[i + 6*2] = 0;
01326         }
01327         ptr += 18;
01328         buf += 18;
01329     }
01330     /* zero bands */
01331     for (j = sblimit; j < SBLIMIT; j++) {
01332         /* overlap */
01333         out_ptr = sb_samples + j;
01334         for (i = 0; i < 18; i++) {
01335             *out_ptr = buf[i];
01336             buf[i]   = 0;
01337             out_ptr += SBLIMIT;
01338         }
01339         buf += 18;
01340     }
01341 }
01342 
01343 /* main layer3 decoding function */
01344 static int mp_decode_layer3(MPADecodeContext *s)
01345 {
01346     int nb_granules, main_data_begin;
01347     int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
01348     GranuleDef *g;
01349     int16_t exponents[576]; //FIXME try INTFLOAT
01350 
01351     /* read side info */
01352     if (s->lsf) {
01353         main_data_begin = get_bits(&s->gb, 8);
01354         skip_bits(&s->gb, s->nb_channels);
01355         nb_granules = 1;
01356     } else {
01357         main_data_begin = get_bits(&s->gb, 9);
01358         if (s->nb_channels == 2)
01359             skip_bits(&s->gb, 3);
01360         else
01361             skip_bits(&s->gb, 5);
01362         nb_granules = 2;
01363         for (ch = 0; ch < s->nb_channels; ch++) {
01364             s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
01365             s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
01366         }
01367     }
01368 
01369     for (gr = 0; gr < nb_granules; gr++) {
01370         for (ch = 0; ch < s->nb_channels; ch++) {
01371             av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
01372             g = &s->granules[ch][gr];
01373             g->part2_3_length = get_bits(&s->gb, 12);
01374             g->big_values     = get_bits(&s->gb,  9);
01375             if (g->big_values > 288) {
01376                 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
01377                 return AVERROR_INVALIDDATA;
01378             }
01379 
01380             g->global_gain = get_bits(&s->gb, 8);
01381             /* if MS stereo only is selected, we precompute the
01382                1/sqrt(2) renormalization factor */
01383             if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
01384                 MODE_EXT_MS_STEREO)
01385                 g->global_gain -= 2;
01386             if (s->lsf)
01387                 g->scalefac_compress = get_bits(&s->gb, 9);
01388             else
01389                 g->scalefac_compress = get_bits(&s->gb, 4);
01390             blocksplit_flag = get_bits1(&s->gb);
01391             if (blocksplit_flag) {
01392                 g->block_type = get_bits(&s->gb, 2);
01393                 if (g->block_type == 0) {
01394                     av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
01395                     return AVERROR_INVALIDDATA;
01396                 }
01397                 g->switch_point = get_bits1(&s->gb);
01398                 for (i = 0; i < 2; i++)
01399                     g->table_select[i] = get_bits(&s->gb, 5);
01400                 for (i = 0; i < 3; i++)
01401                     g->subblock_gain[i] = get_bits(&s->gb, 3);
01402                 ff_init_short_region(s, g);
01403             } else {
01404                 int region_address1, region_address2;
01405                 g->block_type = 0;
01406                 g->switch_point = 0;
01407                 for (i = 0; i < 3; i++)
01408                     g->table_select[i] = get_bits(&s->gb, 5);
01409                 /* compute huffman coded region sizes */
01410                 region_address1 = get_bits(&s->gb, 4);
01411                 region_address2 = get_bits(&s->gb, 3);
01412                 av_dlog(s->avctx, "region1=%d region2=%d\n",
01413                         region_address1, region_address2);
01414                 ff_init_long_region(s, g, region_address1, region_address2);
01415             }
01416             ff_region_offset2size(g);
01417             ff_compute_band_indexes(s, g);
01418 
01419             g->preflag = 0;
01420             if (!s->lsf)
01421                 g->preflag = get_bits1(&s->gb);
01422             g->scalefac_scale     = get_bits1(&s->gb);
01423             g->count1table_select = get_bits1(&s->gb);
01424             av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
01425                     g->block_type, g->switch_point);
01426         }
01427     }
01428 
01429     if (!s->adu_mode) {
01430         const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
01431         assert((get_bits_count(&s->gb) & 7) == 0);
01432         /* now we get bits from the main_data_begin offset */
01433         av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
01434     //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
01435 
01436         memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
01437         s->in_gb = s->gb;
01438         init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
01439         skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
01440     }
01441 
01442     for (gr = 0; gr < nb_granules; gr++) {
01443         for (ch = 0; ch < s->nb_channels; ch++) {
01444             g = &s->granules[ch][gr];
01445             if (get_bits_count(&s->gb) < 0) {
01446                 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",
01447                        main_data_begin, s->last_buf_size, gr);
01448                 skip_bits_long(&s->gb, g->part2_3_length);
01449                 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
01450                 if (get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer) {
01451                     skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
01452                     s->gb           = s->in_gb;
01453                     s->in_gb.buffer = NULL;
01454                 }
01455                 continue;
01456             }
01457 
01458             bits_pos = get_bits_count(&s->gb);
01459 
01460             if (!s->lsf) {
01461                 uint8_t *sc;
01462                 int slen, slen1, slen2;
01463 
01464                 /* MPEG1 scale factors */
01465                 slen1 = slen_table[0][g->scalefac_compress];
01466                 slen2 = slen_table[1][g->scalefac_compress];
01467                 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
01468                 if (g->block_type == 2) {
01469                     n = g->switch_point ? 17 : 18;
01470                     j = 0;
01471                     if (slen1) {
01472                         for (i = 0; i < n; i++)
01473                             g->scale_factors[j++] = get_bits(&s->gb, slen1);
01474                     } else {
01475                         for (i = 0; i < n; i++)
01476                             g->scale_factors[j++] = 0;
01477                     }
01478                     if (slen2) {
01479                         for (i = 0; i < 18; i++)
01480                             g->scale_factors[j++] = get_bits(&s->gb, slen2);
01481                         for (i = 0; i < 3; i++)
01482                             g->scale_factors[j++] = 0;
01483                     } else {
01484                         for (i = 0; i < 21; i++)
01485                             g->scale_factors[j++] = 0;
01486                     }
01487                 } else {
01488                     sc = s->granules[ch][0].scale_factors;
01489                     j = 0;
01490                     for (k = 0; k < 4; k++) {
01491                         n = k == 0 ? 6 : 5;
01492                         if ((g->scfsi & (0x8 >> k)) == 0) {
01493                             slen = (k < 2) ? slen1 : slen2;
01494                             if (slen) {
01495                                 for (i = 0; i < n; i++)
01496                                     g->scale_factors[j++] = get_bits(&s->gb, slen);
01497                             } else {
01498                                 for (i = 0; i < n; i++)
01499                                     g->scale_factors[j++] = 0;
01500                             }
01501                         } else {
01502                             /* simply copy from last granule */
01503                             for (i = 0; i < n; i++) {
01504                                 g->scale_factors[j] = sc[j];
01505                                 j++;
01506                             }
01507                         }
01508                     }
01509                     g->scale_factors[j++] = 0;
01510                 }
01511             } else {
01512                 int tindex, tindex2, slen[4], sl, sf;
01513 
01514                 /* LSF scale factors */
01515                 if (g->block_type == 2)
01516                     tindex = g->switch_point ? 2 : 1;
01517                 else
01518                     tindex = 0;
01519 
01520                 sf = g->scalefac_compress;
01521                 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
01522                     /* intensity stereo case */
01523                     sf >>= 1;
01524                     if (sf < 180) {
01525                         lsf_sf_expand(slen, sf, 6, 6, 0);
01526                         tindex2 = 3;
01527                     } else if (sf < 244) {
01528                         lsf_sf_expand(slen, sf - 180, 4, 4, 0);
01529                         tindex2 = 4;
01530                     } else {
01531                         lsf_sf_expand(slen, sf - 244, 3, 0, 0);
01532                         tindex2 = 5;
01533                     }
01534                 } else {
01535                     /* normal case */
01536                     if (sf < 400) {
01537                         lsf_sf_expand(slen, sf, 5, 4, 4);
01538                         tindex2 = 0;
01539                     } else if (sf < 500) {
01540                         lsf_sf_expand(slen, sf - 400, 5, 4, 0);
01541                         tindex2 = 1;
01542                     } else {
01543                         lsf_sf_expand(slen, sf - 500, 3, 0, 0);
01544                         tindex2 = 2;
01545                         g->preflag = 1;
01546                     }
01547                 }
01548 
01549                 j = 0;
01550                 for (k = 0; k < 4; k++) {
01551                     n  = lsf_nsf_table[tindex2][tindex][k];
01552                     sl = slen[k];
01553                     if (sl) {
01554                         for (i = 0; i < n; i++)
01555                             g->scale_factors[j++] = get_bits(&s->gb, sl);
01556                     } else {
01557                         for (i = 0; i < n; i++)
01558                             g->scale_factors[j++] = 0;
01559                     }
01560                 }
01561                 /* XXX: should compute exact size */
01562                 for (; j < 40; j++)
01563                     g->scale_factors[j] = 0;
01564             }
01565 
01566             exponents_from_scale_factors(s, g, exponents);
01567 
01568             /* read Huffman coded residue */
01569             huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
01570         } /* ch */
01571 
01572         if (s->nb_channels == 2)
01573             compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
01574 
01575         for (ch = 0; ch < s->nb_channels; ch++) {
01576             g = &s->granules[ch][gr];
01577 
01578             reorder_block(s, g);
01579             compute_antialias(s, g);
01580             compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
01581         }
01582     } /* gr */
01583     if (get_bits_count(&s->gb) < 0)
01584         skip_bits_long(&s->gb, -get_bits_count(&s->gb));
01585     return nb_granules * 18;
01586 }
01587 
01588 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
01589                            const uint8_t *buf, int buf_size)
01590 {
01591     int i, nb_frames, ch, ret;
01592     OUT_INT *samples_ptr;
01593 
01594     init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
01595 
01596     /* skip error protection field */
01597     if (s->error_protection)
01598         skip_bits(&s->gb, 16);
01599 
01600     switch(s->layer) {
01601     case 1:
01602         s->avctx->frame_size = 384;
01603         nb_frames = mp_decode_layer1(s);
01604         break;
01605     case 2:
01606         s->avctx->frame_size = 1152;
01607         nb_frames = mp_decode_layer2(s);
01608         break;
01609     case 3:
01610         s->avctx->frame_size = s->lsf ? 576 : 1152;
01611     default:
01612         nb_frames = mp_decode_layer3(s);
01613 
01614         s->last_buf_size=0;
01615         if (s->in_gb.buffer) {
01616             align_get_bits(&s->gb);
01617             i = get_bits_left(&s->gb)>>3;
01618             if (i >= 0 && i <= BACKSTEP_SIZE) {
01619                 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
01620                 s->last_buf_size=i;
01621             } else
01622                 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
01623             s->gb           = s->in_gb;
01624             s->in_gb.buffer = NULL;
01625         }
01626 
01627         align_get_bits(&s->gb);
01628         assert((get_bits_count(&s->gb) & 7) == 0);
01629         i = get_bits_left(&s->gb) >> 3;
01630 
01631         if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
01632             if (i < 0)
01633                 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
01634             i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
01635         }
01636         assert(i <= buf_size - HEADER_SIZE && i >= 0);
01637         memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
01638         s->last_buf_size += i;
01639     }
01640 
01641     /* get output buffer */
01642     if (!samples) {
01643         s->frame.nb_samples = s->avctx->frame_size;
01644         if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
01645             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01646             return ret;
01647         }
01648         samples = (OUT_INT *)s->frame.data[0];
01649     }
01650 
01651     /* apply the synthesis filter */
01652     for (ch = 0; ch < s->nb_channels; ch++) {
01653         samples_ptr = samples + ch;
01654         for (i = 0; i < nb_frames; i++) {
01655             RENAME(ff_mpa_synth_filter)(
01656                          &s->mpadsp,
01657                          s->synth_buf[ch], &(s->synth_buf_offset[ch]),
01658                          RENAME(ff_mpa_synth_window), &s->dither_state,
01659                          samples_ptr, s->nb_channels,
01660                          s->sb_samples[ch][i]);
01661             samples_ptr += 32 * s->nb_channels;
01662         }
01663     }
01664 
01665     return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
01666 }
01667 
01668 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
01669                         AVPacket *avpkt)
01670 {
01671     const uint8_t *buf  = avpkt->data;
01672     int buf_size        = avpkt->size;
01673     MPADecodeContext *s = avctx->priv_data;
01674     uint32_t header;
01675     int out_size;
01676 
01677     if (buf_size < HEADER_SIZE)
01678         return AVERROR_INVALIDDATA;
01679 
01680     header = AV_RB32(buf);
01681     if (ff_mpa_check_header(header) < 0) {
01682         av_log(avctx, AV_LOG_ERROR, "Header missing\n");
01683         return AVERROR_INVALIDDATA;
01684     }
01685 
01686     if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
01687         /* free format: prepare to compute frame size */
01688         s->frame_size = -1;
01689         return AVERROR_INVALIDDATA;
01690     }
01691     /* update codec info */
01692     avctx->channels       = s->nb_channels;
01693     avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
01694     if (!avctx->bit_rate)
01695         avctx->bit_rate = s->bit_rate;
01696     avctx->sub_id = s->layer;
01697 
01698     if (s->frame_size <= 0 || s->frame_size > buf_size) {
01699         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
01700         return AVERROR_INVALIDDATA;
01701     }else if(s->frame_size < buf_size){
01702         av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
01703         buf_size= s->frame_size;
01704     }
01705 
01706     out_size = mp_decode_frame(s, NULL, buf, buf_size);
01707     if (out_size >= 0) {
01708         *got_frame_ptr   = 1;
01709         *(AVFrame *)data = s->frame;
01710         avctx->sample_rate = s->sample_rate;
01711         //FIXME maybe move the other codec info stuff from above here too
01712     } else {
01713         av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
01714         /* Only return an error if the bad frame makes up the whole packet.
01715            If there is more data in the packet, just consume the bad frame
01716            instead of returning an error, which would discard the whole
01717            packet. */
01718         *got_frame_ptr = 0;
01719         if (buf_size == avpkt->size)
01720             return out_size;
01721     }
01722     s->frame_size = 0;
01723     return buf_size;
01724 }
01725 
01726 static void flush(AVCodecContext *avctx)
01727 {
01728     MPADecodeContext *s = avctx->priv_data;
01729     memset(s->synth_buf, 0, sizeof(s->synth_buf));
01730     s->last_buf_size = 0;
01731 }
01732 
01733 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
01734 static int decode_frame_adu(AVCodecContext *avctx, void *data,
01735                             int *got_frame_ptr, AVPacket *avpkt)
01736 {
01737     const uint8_t *buf  = avpkt->data;
01738     int buf_size        = avpkt->size;
01739     MPADecodeContext *s = avctx->priv_data;
01740     uint32_t header;
01741     int len, out_size;
01742 
01743     len = buf_size;
01744 
01745     // Discard too short frames
01746     if (buf_size < HEADER_SIZE) {
01747         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
01748         return AVERROR_INVALIDDATA;
01749     }
01750 
01751 
01752     if (len > MPA_MAX_CODED_FRAME_SIZE)
01753         len = MPA_MAX_CODED_FRAME_SIZE;
01754 
01755     // Get header and restore sync word
01756     header = AV_RB32(buf) | 0xffe00000;
01757 
01758     if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
01759         av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
01760         return AVERROR_INVALIDDATA;
01761     }
01762 
01763     avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
01764     /* update codec info */
01765     avctx->sample_rate = s->sample_rate;
01766     avctx->channels    = s->nb_channels;
01767     if (!avctx->bit_rate)
01768         avctx->bit_rate = s->bit_rate;
01769     avctx->sub_id = s->layer;
01770 
01771     s->frame_size = len;
01772 
01773 #if FF_API_PARSE_FRAME
01774     if (avctx->parse_only)
01775         out_size = buf_size;
01776     else
01777 #endif
01778     out_size = mp_decode_frame(s, NULL, buf, buf_size);
01779 
01780     *got_frame_ptr   = 1;
01781     *(AVFrame *)data = s->frame;
01782 
01783     return buf_size;
01784 }
01785 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
01786 
01787 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
01788 
01792 typedef struct MP3On4DecodeContext {
01793     AVFrame *frame;
01794     int frames;                     
01795     int syncword;                   
01796     const uint8_t *coff;            
01797     MPADecodeContext *mp3decctx[5]; 
01798     OUT_INT *decoded_buf;           
01799 } MP3On4DecodeContext;
01800 
01801 #include "mpeg4audio.h"
01802 
01803 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
01804 
01805 /* number of mp3 decoder instances */
01806 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
01807 
01808 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
01809 static const uint8_t chan_offset[8][5] = {
01810     { 0             },
01811     { 0             },  // C
01812     { 0             },  // FLR
01813     { 2, 0          },  // C FLR
01814     { 2, 0, 3       },  // C FLR BS
01815     { 2, 0, 3       },  // C FLR BLRS
01816     { 2, 0, 4, 3    },  // C FLR BLRS LFE
01817     { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE
01818 };
01819 
01820 /* mp3on4 channel layouts */
01821 static const int16_t chan_layout[8] = {
01822     0,
01823     AV_CH_LAYOUT_MONO,
01824     AV_CH_LAYOUT_STEREO,
01825     AV_CH_LAYOUT_SURROUND,
01826     AV_CH_LAYOUT_4POINT0,
01827     AV_CH_LAYOUT_5POINT0,
01828     AV_CH_LAYOUT_5POINT1,
01829     AV_CH_LAYOUT_7POINT1
01830 };
01831 
01832 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
01833 {
01834     MP3On4DecodeContext *s = avctx->priv_data;
01835     int i;
01836 
01837     for (i = 0; i < s->frames; i++)
01838         av_free(s->mp3decctx[i]);
01839 
01840     av_freep(&s->decoded_buf);
01841 
01842     return 0;
01843 }
01844 
01845 
01846 static int decode_init_mp3on4(AVCodecContext * avctx)
01847 {
01848     MP3On4DecodeContext *s = avctx->priv_data;
01849     MPEG4AudioConfig cfg;
01850     int i;
01851 
01852     if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
01853         av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
01854         return AVERROR_INVALIDDATA;
01855     }
01856 
01857     avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
01858                                  avctx->extradata_size * 8, 1);
01859     if (!cfg.chan_config || cfg.chan_config > 7) {
01860         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
01861         return AVERROR_INVALIDDATA;
01862     }
01863     s->frames             = mp3Frames[cfg.chan_config];
01864     s->coff               = chan_offset[cfg.chan_config];
01865     avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
01866     avctx->channel_layout = chan_layout[cfg.chan_config];
01867 
01868     if (cfg.sample_rate < 16000)
01869         s->syncword = 0xffe00000;
01870     else
01871         s->syncword = 0xfff00000;
01872 
01873     /* Init the first mp3 decoder in standard way, so that all tables get builded
01874      * We replace avctx->priv_data with the context of the first decoder so that
01875      * decode_init() does not have to be changed.
01876      * Other decoders will be initialized here copying data from the first context
01877      */
01878     // Allocate zeroed memory for the first decoder context
01879     s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
01880     if (!s->mp3decctx[0])
01881         goto alloc_fail;
01882     // Put decoder context in place to make init_decode() happy
01883     avctx->priv_data = s->mp3decctx[0];
01884     decode_init(avctx);
01885     s->frame = avctx->coded_frame;
01886     // Restore mp3on4 context pointer
01887     avctx->priv_data = s;
01888     s->mp3decctx[0]->adu_mode = 1; // Set adu mode
01889 
01890     /* Create a separate codec/context for each frame (first is already ok).
01891      * Each frame is 1 or 2 channels - up to 5 frames allowed
01892      */
01893     for (i = 1; i < s->frames; i++) {
01894         s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
01895         if (!s->mp3decctx[i])
01896             goto alloc_fail;
01897         s->mp3decctx[i]->adu_mode = 1;
01898         s->mp3decctx[i]->avctx = avctx;
01899         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
01900     }
01901 
01902     /* Allocate buffer for multi-channel output if needed */
01903     if (s->frames > 1) {
01904         s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
01905                                    sizeof(*s->decoded_buf));
01906         if (!s->decoded_buf)
01907             goto alloc_fail;
01908     }
01909 
01910     return 0;
01911 alloc_fail:
01912     decode_close_mp3on4(avctx);
01913     return AVERROR(ENOMEM);
01914 }
01915 
01916 
01917 static void flush_mp3on4(AVCodecContext *avctx)
01918 {
01919     int i;
01920     MP3On4DecodeContext *s = avctx->priv_data;
01921 
01922     for (i = 0; i < s->frames; i++) {
01923         MPADecodeContext *m = s->mp3decctx[i];
01924         memset(m->synth_buf, 0, sizeof(m->synth_buf));
01925         m->last_buf_size = 0;
01926     }
01927 }
01928 
01929 
01930 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
01931                                int *got_frame_ptr, AVPacket *avpkt)
01932 {
01933     const uint8_t *buf     = avpkt->data;
01934     int buf_size           = avpkt->size;
01935     MP3On4DecodeContext *s = avctx->priv_data;
01936     MPADecodeContext *m;
01937     int fsize, len = buf_size, out_size = 0;
01938     uint32_t header;
01939     OUT_INT *out_samples;
01940     OUT_INT *outptr, *bp;
01941     int fr, j, n, ch, ret;
01942 
01943     /* get output buffer */
01944     s->frame->nb_samples = MPA_FRAME_SIZE;
01945     if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
01946         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01947         return ret;
01948     }
01949     out_samples = (OUT_INT *)s->frame->data[0];
01950 
01951     // Discard too short frames
01952     if (buf_size < HEADER_SIZE)
01953         return AVERROR_INVALIDDATA;
01954 
01955     // If only one decoder interleave is not needed
01956     outptr = s->frames == 1 ? out_samples : s->decoded_buf;
01957 
01958     avctx->bit_rate = 0;
01959 
01960     ch = 0;
01961     for (fr = 0; fr < s->frames; fr++) {
01962         fsize = AV_RB16(buf) >> 4;
01963         fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
01964         m     = s->mp3decctx[fr];
01965         assert(m != NULL);
01966 
01967         header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
01968 
01969         if (ff_mpa_check_header(header) < 0) // Bad header, discard block
01970             break;
01971 
01972         avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
01973 
01974         if (ch + m->nb_channels > avctx->channels) {
01975             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
01976                                         "channel count\n");
01977             return AVERROR_INVALIDDATA;
01978         }
01979         ch += m->nb_channels;
01980 
01981         out_size += mp_decode_frame(m, outptr, buf, fsize);
01982         buf      += fsize;
01983         len      -= fsize;
01984 
01985         if (s->frames > 1) {
01986             n = m->avctx->frame_size*m->nb_channels;
01987             /* interleave output data */
01988             bp = out_samples + s->coff[fr];
01989             if (m->nb_channels == 1) {
01990                 for (j = 0; j < n; j++) {
01991                     *bp = s->decoded_buf[j];
01992                     bp += avctx->channels;
01993                 }
01994             } else {
01995                 for (j = 0; j < n; j++) {
01996                     bp[0] = s->decoded_buf[j++];
01997                     bp[1] = s->decoded_buf[j];
01998                     bp   += avctx->channels;
01999                 }
02000             }
02001         }
02002         avctx->bit_rate += m->bit_rate;
02003     }
02004 
02005     /* update codec info */
02006     avctx->sample_rate = s->mp3decctx[0]->sample_rate;
02007 
02008     s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
02009     *got_frame_ptr   = 1;
02010     *(AVFrame *)data = *s->frame;
02011 
02012     return buf_size;
02013 }
02014 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
02015 
02016 #if !CONFIG_FLOAT
02017 #if CONFIG_MP1_DECODER
02018 AVCodec ff_mp1_decoder = {
02019     .name           = "mp1",
02020     .type           = AVMEDIA_TYPE_AUDIO,
02021     .id             = CODEC_ID_MP1,
02022     .priv_data_size = sizeof(MPADecodeContext),
02023     .init           = decode_init,
02024     .decode         = decode_frame,
02025 #if FF_API_PARSE_FRAME
02026     .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
02027 #else
02028     .capabilities   = CODEC_CAP_DR1,
02029 #endif
02030     .flush          = flush,
02031     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
02032 };
02033 #endif
02034 #if CONFIG_MP2_DECODER
02035 AVCodec ff_mp2_decoder = {
02036     .name           = "mp2",
02037     .type           = AVMEDIA_TYPE_AUDIO,
02038     .id             = CODEC_ID_MP2,
02039     .priv_data_size = sizeof(MPADecodeContext),
02040     .init           = decode_init,
02041     .decode         = decode_frame,
02042 #if FF_API_PARSE_FRAME
02043     .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
02044 #else
02045     .capabilities   = CODEC_CAP_DR1,
02046 #endif
02047     .flush          = flush,
02048     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
02049 };
02050 #endif
02051 #if CONFIG_MP3_DECODER
02052 AVCodec ff_mp3_decoder = {
02053     .name           = "mp3",
02054     .type           = AVMEDIA_TYPE_AUDIO,
02055     .id             = CODEC_ID_MP3,
02056     .priv_data_size = sizeof(MPADecodeContext),
02057     .init           = decode_init,
02058     .decode         = decode_frame,
02059 #if FF_API_PARSE_FRAME
02060     .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
02061 #else
02062     .capabilities   = CODEC_CAP_DR1,
02063 #endif
02064     .flush          = flush,
02065     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
02066 };
02067 #endif
02068 #if CONFIG_MP3ADU_DECODER
02069 AVCodec ff_mp3adu_decoder = {
02070     .name           = "mp3adu",
02071     .type           = AVMEDIA_TYPE_AUDIO,
02072     .id             = CODEC_ID_MP3ADU,
02073     .priv_data_size = sizeof(MPADecodeContext),
02074     .init           = decode_init,
02075     .decode         = decode_frame_adu,
02076 #if FF_API_PARSE_FRAME
02077     .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
02078 #else
02079     .capabilities   = CODEC_CAP_DR1,
02080 #endif
02081     .flush          = flush,
02082     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
02083 };
02084 #endif
02085 #if CONFIG_MP3ON4_DECODER
02086 AVCodec ff_mp3on4_decoder = {
02087     .name           = "mp3on4",
02088     .type           = AVMEDIA_TYPE_AUDIO,
02089     .id             = CODEC_ID_MP3ON4,
02090     .priv_data_size = sizeof(MP3On4DecodeContext),
02091     .init           = decode_init_mp3on4,
02092     .close          = decode_close_mp3on4,
02093     .decode         = decode_frame_mp3on4,
02094     .capabilities   = CODEC_CAP_DR1,
02095     .flush          = flush_mp3on4,
02096     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
02097 };
02098 #endif
02099 #endif