• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/mpegaudiodec.c

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