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