git.sesse.net Git - ffmpeg/blob - libavcodec/mpegaudiodec.c

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