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