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     DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
  62 } GranuleDef;
  63
  64 typedef struct MPADecodeContext {
  65     MPA_DECODE_HEADER
  66     uint8_t last_buf[2 * BACKSTEP_SIZE + EXTRABYTES];
  67     int last_buf_size;
  68     /* next header (used in free format parsing) */
  69     uint32_t free_format_next_header;
  70     GetBitContext gb;
  71     GetBitContext in_gb;
  72     DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
  73     int synth_buf_offset[MPA_MAX_CHANNELS];
  74     DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
  75     INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
  76     GranuleDef granules[2][2]; /* Used in Layer 3 */
  77     int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
  78     int dither_state;
  79     int err_recognition;
  80     AVCodecContext* avctx;
  81     MPADSPContext mpadsp;
  82     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_BUFFER)) {
 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     out_size = mp_decode_frame(s, NULL, buf, buf_size);
1731
1732     *got_frame_ptr   = 1;
1733     *(AVFrame *)data = s->frame;
1734
1735     return buf_size;
1736 }
1737 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1738
1739 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1740
1741 /**
1742  * Context for MP3On4 decoder
1743  */
1744 typedef struct MP3On4DecodeContext {
1745     AVFrame *frame;
1746     int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)
1747     int syncword;                   ///< syncword patch
1748     const uint8_t *coff;            ///< channel offsets in output buffer
1749     MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1750     OUT_INT *decoded_buf;           ///< output buffer for decoded samples
1751 } MP3On4DecodeContext;
1752
1753 #include "mpeg4audio.h"
1754
1755 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1756
1757 /* number of mp3 decoder instances */
1758 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1759
1760 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1761 static const uint8_t chan_offset[8][5] = {
1762     { 0             },
1763     { 0             },  // C
1764     { 0             },  // FLR
1765     { 2, 0          },  // C FLR
1766     { 2, 0, 3       },  // C FLR BS
1767     { 2, 0, 3       },  // C FLR BLRS
1768     { 2, 0, 4, 3    },  // C FLR BLRS LFE
1769     { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE
1770 };
1771
1772 /* mp3on4 channel layouts */
1773 static const int16_t chan_layout[8] = {
1774     0,
1775     AV_CH_LAYOUT_MONO,
1776     AV_CH_LAYOUT_STEREO,
1777     AV_CH_LAYOUT_SURROUND,
1778     AV_CH_LAYOUT_4POINT0,
1779     AV_CH_LAYOUT_5POINT0,
1780     AV_CH_LAYOUT_5POINT1,
1781     AV_CH_LAYOUT_7POINT1
1782 };
1783
1784 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1785 {
1786     MP3On4DecodeContext *s = avctx->priv_data;
1787     int i;
1788
1789     for (i = 0; i < s->frames; i++)
1790         av_free(s->mp3decctx[i]);
1791
1792     av_freep(&s->decoded_buf);
1793
1794     return 0;
1795 }
1796
1797
1798 static int decode_init_mp3on4(AVCodecContext * avctx)
1799 {
1800     MP3On4DecodeContext *s = avctx->priv_data;
1801     MPEG4AudioConfig cfg;
1802     int i;
1803
1804     if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1805         av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1806         return AVERROR_INVALIDDATA;
1807     }
1808
1809     avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1810                                  avctx->extradata_size * 8, 1);
1811     if (!cfg.chan_config || cfg.chan_config > 7) {
1812         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1813         return AVERROR_INVALIDDATA;
1814     }
1815     s->frames             = mp3Frames[cfg.chan_config];
1816     s->coff               = chan_offset[cfg.chan_config];
1817     avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
1818     avctx->channel_layout = chan_layout[cfg.chan_config];
1819
1820     if (cfg.sample_rate < 16000)
1821         s->syncword = 0xffe00000;
1822     else
1823         s->syncword = 0xfff00000;
1824
1825     /* Init the first mp3 decoder in standard way, so that all tables get builded
1826      * We replace avctx->priv_data with the context of the first decoder so that
1827      * decode_init() does not have to be changed.
1828      * Other decoders will be initialized here copying data from the first context
1829      */
1830     // Allocate zeroed memory for the first decoder context
1831     s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1832     if (!s->mp3decctx[0])
1833         goto alloc_fail;
1834     // Put decoder context in place to make init_decode() happy
1835     avctx->priv_data = s->mp3decctx[0];
1836     decode_init(avctx);
1837     s->frame = avctx->coded_frame;
1838     // Restore mp3on4 context pointer
1839     avctx->priv_data = s;
1840     s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1841
1842     /* Create a separate codec/context for each frame (first is already ok).
1843      * Each frame is 1 or 2 channels - up to 5 frames allowed
1844      */
1845     for (i = 1; i < s->frames; i++) {
1846         s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1847         if (!s->mp3decctx[i])
1848             goto alloc_fail;
1849         s->mp3decctx[i]->adu_mode = 1;
1850         s->mp3decctx[i]->avctx = avctx;
1851         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1852     }
1853
1854     /* Allocate buffer for multi-channel output if needed */
1855     if (s->frames > 1) {
1856         s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1857                                    sizeof(*s->decoded_buf));
1858         if (!s->decoded_buf)
1859             goto alloc_fail;
1860     }
1861
1862     return 0;
1863 alloc_fail:
1864     decode_close_mp3on4(avctx);
1865     return AVERROR(ENOMEM);
1866 }
1867
1868
1869 static void flush_mp3on4(AVCodecContext *avctx)
1870 {
1871     int i;
1872     MP3On4DecodeContext *s = avctx->priv_data;
1873
1874     for (i = 0; i < s->frames; i++) {
1875         MPADecodeContext *m = s->mp3decctx[i];
1876         memset(m->synth_buf, 0, sizeof(m->synth_buf));
1877         m->last_buf_size = 0;
1878     }
1879 }
1880
1881
1882 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
1883                                int *got_frame_ptr, AVPacket *avpkt)
1884 {
1885     const uint8_t *buf     = avpkt->data;
1886     int buf_size           = avpkt->size;
1887     MP3On4DecodeContext *s = avctx->priv_data;
1888     MPADecodeContext *m;
1889     int fsize, len = buf_size, out_size = 0;
1890     uint32_t header;
1891     OUT_INT *out_samples;
1892     OUT_INT *outptr, *bp;
1893     int fr, j, n, ch, ret;
1894
1895     /* get output buffer */
1896     s->frame->nb_samples = MPA_FRAME_SIZE;
1897     if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
1898         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1899         return ret;
1900     }
1901     out_samples = (OUT_INT *)s->frame->data[0];
1902
1903     // Discard too short frames
1904     if (buf_size < HEADER_SIZE)
1905         return AVERROR_INVALIDDATA;
1906
1907     // If only one decoder interleave is not needed
1908     outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1909
1910     avctx->bit_rate = 0;
1911
1912     ch = 0;
1913     for (fr = 0; fr < s->frames; fr++) {
1914         fsize = AV_RB16(buf) >> 4;
1915         fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1916         m     = s->mp3decctx[fr];
1917         assert(m != NULL);
1918
1919         header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1920
1921         if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1922             break;
1923
1924         avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1925
1926         if (ch + m->nb_channels > avctx->channels) {
1927             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1928                                         "channel count\n");
1929             return AVERROR_INVALIDDATA;
1930         }
1931         ch += m->nb_channels;
1932
1933         out_size += mp_decode_frame(m, outptr, buf, fsize);
1934         buf      += fsize;
1935         len      -= fsize;
1936
1937         if (s->frames > 1) {
1938             n = m->avctx->frame_size*m->nb_channels;
1939             /* interleave output data */
1940             bp = out_samples + s->coff[fr];
1941             if (m->nb_channels == 1) {
1942                 for (j = 0; j < n; j++) {
1943                     *bp = s->decoded_buf[j];
1944                     bp += avctx->channels;
1945                 }
1946             } else {
1947                 for (j = 0; j < n; j++) {
1948                     bp[0] = s->decoded_buf[j++];
1949                     bp[1] = s->decoded_buf[j];
1950                     bp   += avctx->channels;
1951                 }
1952             }
1953         }
1954         avctx->bit_rate += m->bit_rate;
1955     }
1956
1957     /* update codec info */
1958     avctx->sample_rate = s->mp3decctx[0]->sample_rate;
1959
1960     s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
1961     *got_frame_ptr   = 1;
1962     *(AVFrame *)data = *s->frame;
1963
1964     return buf_size;
1965 }
1966 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
1967
1968 #if !CONFIG_FLOAT
1969 #if CONFIG_MP1_DECODER
1970 AVCodec ff_mp1_decoder = {
1971     .name           = "mp1",
1972     .type           = AVMEDIA_TYPE_AUDIO,
1973     .id             = CODEC_ID_MP1,
1974     .priv_data_size = sizeof(MPADecodeContext),
1975     .init           = decode_init,
1976     .decode         = decode_frame,
1977     .capabilities   = CODEC_CAP_DR1,
1978     .flush          = flush,
1979     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
1980 };
1981 #endif
1982 #if CONFIG_MP2_DECODER
1983 AVCodec ff_mp2_decoder = {
1984     .name           = "mp2",
1985     .type           = AVMEDIA_TYPE_AUDIO,
1986     .id             = CODEC_ID_MP2,
1987     .priv_data_size = sizeof(MPADecodeContext),
1988     .init           = decode_init,
1989     .decode         = decode_frame,
1990     .capabilities   = CODEC_CAP_DR1,
1991     .flush          = flush,
1992     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
1993 };
1994 #endif
1995 #if CONFIG_MP3_DECODER
1996 AVCodec ff_mp3_decoder = {
1997     .name           = "mp3",
1998     .type           = AVMEDIA_TYPE_AUDIO,
1999     .id             = CODEC_ID_MP3,
2000     .priv_data_size = sizeof(MPADecodeContext),
2001     .init           = decode_init,
2002     .decode         = decode_frame,
2003     .capabilities   = CODEC_CAP_DR1,
2004     .flush          = flush,
2005     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2006 };
2007 #endif
2008 #if CONFIG_MP3ADU_DECODER
2009 AVCodec ff_mp3adu_decoder = {
2010     .name           = "mp3adu",
2011     .type           = AVMEDIA_TYPE_AUDIO,
2012     .id             = CODEC_ID_MP3ADU,
2013     .priv_data_size = sizeof(MPADecodeContext),
2014     .init           = decode_init,
2015     .decode         = decode_frame_adu,
2016     .capabilities   = CODEC_CAP_DR1,
2017     .flush          = flush,
2018     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2019 };
2020 #endif
2021 #if CONFIG_MP3ON4_DECODER
2022 AVCodec ff_mp3on4_decoder = {
2023     .name           = "mp3on4",
2024     .type           = AVMEDIA_TYPE_AUDIO,
2025     .id             = CODEC_ID_MP3ON4,
2026     .priv_data_size = sizeof(MP3On4DecodeContext),
2027     .init           = decode_init_mp3on4,
2028     .close          = decode_close_mp3on4,
2029     .decode         = decode_frame_mp3on4,
2030     .capabilities   = CODEC_CAP_DR1,
2031     .flush          = flush_mp3on4,
2032     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
2033 };
2034 #endif
2035 #endif