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