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