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

   1 /*
   2  * MPEG Audio decoder
   3  * Copyright (c) 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * MPEG Audio decoder
  25  */
  26
  27 #include "libavutil/audioconvert.h"
  28 #include "avcodec.h"
  29 #include "get_bits.h"
  30 #include "mathops.h"
  31 #include "mpegaudiodsp.h"
  32 #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|AV_EF_COMPLIANT))
 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|AV_EF_COMPLIANT))) {
 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|AV_EF_AGGRESSIVE))) {
 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, EXTRABYTES);
1387         assert((get_bits_count(&s->gb) & 7) == 0);
1388         /* now we get bits from the main_data_begin offset */
1389         av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1390     //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1391
1392         memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1393         s->in_gb = s->gb;
1394         init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1395 #if !UNCHECKED_BITSTREAM_READER
1396         s->gb.size_in_bits_plus8 += FFMAX(extrasize, LAST_BUF_SIZE - s->last_buf_size) * 8;
1397 #endif
1398         s->last_buf_size <<= 3;
1399         for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
1400             for (ch = 0; ch < s->nb_channels; ch++) {
1401                 g = &s->granules[ch][gr];
1402                 s->last_buf_size += g->part2_3_length;
1403                 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1404             }
1405         }
1406         skip = s->last_buf_size - 8 * main_data_begin;
1407         if (skip >= s->gb.size_in_bits && s->in_gb.buffer) {
1408             skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits);
1409             s->gb           = s->in_gb;
1410             s->in_gb.buffer = NULL;
1411         } else {
1412             skip_bits_long(&s->gb, skip);
1413         }
1414     } else {
1415         gr = 0;
1416     }
1417
1418     for (; gr < nb_granules; gr++) {
1419         for (ch = 0; ch < s->nb_channels; ch++) {
1420             g = &s->granules[ch][gr];
1421             bits_pos = get_bits_count(&s->gb);
1422
1423             if (!s->lsf) {
1424                 uint8_t *sc;
1425                 int slen, slen1, slen2;
1426
1427                 /* MPEG1 scale factors */
1428                 slen1 = slen_table[0][g->scalefac_compress];
1429                 slen2 = slen_table[1][g->scalefac_compress];
1430                 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1431                 if (g->block_type == 2) {
1432                     n = g->switch_point ? 17 : 18;
1433                     j = 0;
1434                     if (slen1) {
1435                         for (i = 0; i < n; i++)
1436                             g->scale_factors[j++] = get_bits(&s->gb, slen1);
1437                     } else {
1438                         for (i = 0; i < n; i++)
1439                             g->scale_factors[j++] = 0;
1440                     }
1441                     if (slen2) {
1442                         for (i = 0; i < 18; i++)
1443                             g->scale_factors[j++] = get_bits(&s->gb, slen2);
1444                         for (i = 0; i < 3; i++)
1445                             g->scale_factors[j++] = 0;
1446                     } else {
1447                         for (i = 0; i < 21; i++)
1448                             g->scale_factors[j++] = 0;
1449                     }
1450                 } else {
1451                     sc = s->granules[ch][0].scale_factors;
1452                     j = 0;
1453                     for (k = 0; k < 4; k++) {
1454                         n = k == 0 ? 6 : 5;
1455                         if ((g->scfsi & (0x8 >> k)) == 0) {
1456                             slen = (k < 2) ? slen1 : slen2;
1457                             if (slen) {
1458                                 for (i = 0; i < n; i++)
1459                                     g->scale_factors[j++] = get_bits(&s->gb, slen);
1460                             } else {
1461                                 for (i = 0; i < n; i++)
1462                                     g->scale_factors[j++] = 0;
1463                             }
1464                         } else {
1465                             /* simply copy from last granule */
1466                             for (i = 0; i < n; i++) {
1467                                 g->scale_factors[j] = sc[j];
1468                                 j++;
1469                             }
1470                         }
1471                     }
1472                     g->scale_factors[j++] = 0;
1473                 }
1474             } else {
1475                 int tindex, tindex2, slen[4], sl, sf;
1476
1477                 /* LSF scale factors */
1478                 if (g->block_type == 2)
1479                     tindex = g->switch_point ? 2 : 1;
1480                 else
1481                     tindex = 0;
1482
1483                 sf = g->scalefac_compress;
1484                 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
1485                     /* intensity stereo case */
1486                     sf >>= 1;
1487                     if (sf < 180) {
1488                         lsf_sf_expand(slen, sf, 6, 6, 0);
1489                         tindex2 = 3;
1490                     } else if (sf < 244) {
1491                         lsf_sf_expand(slen, sf - 180, 4, 4, 0);
1492                         tindex2 = 4;
1493                     } else {
1494                         lsf_sf_expand(slen, sf - 244, 3, 0, 0);
1495                         tindex2 = 5;
1496                     }
1497                 } else {
1498                     /* normal case */
1499                     if (sf < 400) {
1500                         lsf_sf_expand(slen, sf, 5, 4, 4);
1501                         tindex2 = 0;
1502                     } else if (sf < 500) {
1503                         lsf_sf_expand(slen, sf - 400, 5, 4, 0);
1504                         tindex2 = 1;
1505                     } else {
1506                         lsf_sf_expand(slen, sf - 500, 3, 0, 0);
1507                         tindex2 = 2;
1508                         g->preflag = 1;
1509                     }
1510                 }
1511
1512                 j = 0;
1513                 for (k = 0; k < 4; k++) {
1514                     n  = lsf_nsf_table[tindex2][tindex][k];
1515                     sl = slen[k];
1516                     if (sl) {
1517                         for (i = 0; i < n; i++)
1518                             g->scale_factors[j++] = get_bits(&s->gb, sl);
1519                     } else {
1520                         for (i = 0; i < n; i++)
1521                             g->scale_factors[j++] = 0;
1522                     }
1523                 }
1524                 /* XXX: should compute exact size */
1525                 for (; j < 40; j++)
1526                     g->scale_factors[j] = 0;
1527             }
1528
1529             exponents_from_scale_factors(s, g, exponents);
1530
1531             /* read Huffman coded residue */
1532             huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1533         } /* ch */
1534
1535         if (s->mode == MPA_JSTEREO)
1536             compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1537
1538         for (ch = 0; ch < s->nb_channels; ch++) {
1539             g = &s->granules[ch][gr];
1540
1541             reorder_block(s, g);
1542             compute_antialias(s, g);
1543             compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1544         }
1545     } /* gr */
1546     if (get_bits_count(&s->gb) < 0)
1547         skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1548     return nb_granules * 18;
1549 }
1550
1551 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
1552                            const uint8_t *buf, int buf_size)
1553 {
1554     int i, nb_frames, ch, ret;
1555     OUT_INT *samples_ptr;
1556
1557     init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1558
1559     /* skip error protection field */
1560     if (s->error_protection)
1561         skip_bits(&s->gb, 16);
1562
1563     switch(s->layer) {
1564     case 1:
1565         s->avctx->frame_size = 384;
1566         nb_frames = mp_decode_layer1(s);
1567         break;
1568     case 2:
1569         s->avctx->frame_size = 1152;
1570         nb_frames = mp_decode_layer2(s);
1571         break;
1572     case 3:
1573         s->avctx->frame_size = s->lsf ? 576 : 1152;
1574     default:
1575         nb_frames = mp_decode_layer3(s);
1576
1577         s->last_buf_size=0;
1578         if (s->in_gb.buffer) {
1579             align_get_bits(&s->gb);
1580             i = get_bits_left(&s->gb)>>3;
1581             if (i >= 0 && i <= BACKSTEP_SIZE) {
1582                 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
1583                 s->last_buf_size=i;
1584             } else
1585                 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1586             s->gb           = s->in_gb;
1587             s->in_gb.buffer = NULL;
1588         }
1589
1590         align_get_bits(&s->gb);
1591         assert((get_bits_count(&s->gb) & 7) == 0);
1592         i = get_bits_left(&s->gb) >> 3;
1593
1594         if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
1595             if (i < 0)
1596                 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1597             i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1598         }
1599         assert(i <= buf_size - HEADER_SIZE && i >= 0);
1600         memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1601         s->last_buf_size += i;
1602     }
1603
1604     /* get output buffer */
1605     if (!samples) {
1606         s->frame.nb_samples = s->avctx->frame_size;
1607         if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1608             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1609             return ret;
1610         }
1611         samples = (OUT_INT *)s->frame.data[0];
1612     }
1613
1614     /* apply the synthesis filter */
1615     for (ch = 0; ch < s->nb_channels; ch++) {
1616         samples_ptr = samples + ch;
1617         for (i = 0; i < nb_frames; i++) {
1618             RENAME(ff_mpa_synth_filter)(
1619                          &s->mpadsp,
1620                          s->synth_buf[ch], &(s->synth_buf_offset[ch]),
1621                          RENAME(ff_mpa_synth_window), &s->dither_state,
1622                          samples_ptr, s->nb_channels,
1623                          s->sb_samples[ch][i]);
1624             samples_ptr += 32 * s->nb_channels;
1625         }
1626     }
1627
1628     return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1629 }
1630
1631 static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1632                         AVPacket *avpkt)
1633 {
1634     const uint8_t *buf  = avpkt->data;
1635     int buf_size        = avpkt->size;
1636     MPADecodeContext *s = avctx->priv_data;
1637     uint32_t header;
1638     int out_size;
1639
1640     if (buf_size < HEADER_SIZE)
1641         return AVERROR_INVALIDDATA;
1642
1643     header = AV_RB32(buf);
1644     if (ff_mpa_check_header(header) < 0) {
1645         av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1646         return AVERROR_INVALIDDATA;
1647     }
1648
1649     if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1650         /* free format: prepare to compute frame size */
1651         s->frame_size = -1;
1652         return AVERROR_INVALIDDATA;
1653     }
1654     /* update codec info */
1655     avctx->channels       = s->nb_channels;
1656     avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1657     if (!avctx->bit_rate)
1658         avctx->bit_rate = s->bit_rate;
1659
1660     if (s->frame_size <= 0 || s->frame_size > buf_size) {
1661         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1662         return AVERROR_INVALIDDATA;
1663     }else if(s->frame_size < buf_size){
1664         av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
1665         buf_size= s->frame_size;
1666     }
1667
1668     out_size = mp_decode_frame(s, NULL, buf, buf_size);
1669     if (out_size >= 0) {
1670         *got_frame_ptr   = 1;
1671         *(AVFrame *)data = s->frame;
1672         avctx->sample_rate = s->sample_rate;
1673         //FIXME maybe move the other codec info stuff from above here too
1674     } else {
1675         av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1676         /* Only return an error if the bad frame makes up the whole packet.
1677            If there is more data in the packet, just consume the bad frame
1678            instead of returning an error, which would discard the whole
1679            packet. */
1680         *got_frame_ptr = 0;
1681         if (buf_size == avpkt->size)
1682             return out_size;
1683     }
1684     s->frame_size = 0;
1685     return buf_size;
1686 }
1687
1688 static void flush(AVCodecContext *avctx)
1689 {
1690     MPADecodeContext *s = avctx->priv_data;
1691     memset(s->synth_buf, 0, sizeof(s->synth_buf));
1692     s->last_buf_size = 0;
1693 }
1694
1695 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1696 static int decode_frame_adu(AVCodecContext *avctx, void *data,
1697                             int *got_frame_ptr, AVPacket *avpkt)
1698 {
1699     const uint8_t *buf  = avpkt->data;
1700     int buf_size        = avpkt->size;
1701     MPADecodeContext *s = avctx->priv_data;
1702     uint32_t header;
1703     int len;
1704     int av_unused 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
1737     *got_frame_ptr   = 1;
1738     *(AVFrame *)data = s->frame;
1739
1740     return buf_size;
1741 }
1742 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
1743
1744 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1745
1746 /**
1747  * Context for MP3On4 decoder
1748  */
1749 typedef struct MP3On4DecodeContext {
1750     AVFrame *frame;
1751     int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)
1752     int syncword;                   ///< syncword patch
1753     const uint8_t *coff;            ///< channel offsets in output buffer
1754     MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
1755     OUT_INT *decoded_buf;           ///< output buffer for decoded samples
1756 } MP3On4DecodeContext;
1757
1758 #include "mpeg4audio.h"
1759
1760 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1761
1762 /* number of mp3 decoder instances */
1763 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1764
1765 /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1766 static const uint8_t chan_offset[8][5] = {
1767     { 0             },
1768     { 0             },  // C
1769     { 0             },  // FLR
1770     { 2, 0          },  // C FLR
1771     { 2, 0, 3       },  // C FLR BS
1772     { 2, 0, 3       },  // C FLR BLRS
1773     { 2, 0, 4, 3    },  // C FLR BLRS LFE
1774     { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE
1775 };
1776
1777 /* mp3on4 channel layouts */
1778 static const int16_t chan_layout[8] = {
1779     0,
1780     AV_CH_LAYOUT_MONO,
1781     AV_CH_LAYOUT_STEREO,
1782     AV_CH_LAYOUT_SURROUND,
1783     AV_CH_LAYOUT_4POINT0,
1784     AV_CH_LAYOUT_5POINT0,
1785     AV_CH_LAYOUT_5POINT1,
1786     AV_CH_LAYOUT_7POINT1
1787 };
1788
1789 static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
1790 {
1791     MP3On4DecodeContext *s = avctx->priv_data;
1792     int i;
1793
1794     for (i = 0; i < s->frames; i++)
1795         av_free(s->mp3decctx[i]);
1796
1797     av_freep(&s->decoded_buf);
1798
1799     return 0;
1800 }
1801
1802
1803 static int decode_init_mp3on4(AVCodecContext * avctx)
1804 {
1805     MP3On4DecodeContext *s = avctx->priv_data;
1806     MPEG4AudioConfig cfg;
1807     int i;
1808
1809     if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
1810         av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1811         return AVERROR_INVALIDDATA;
1812     }
1813
1814     avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
1815                                  avctx->extradata_size * 8, 1);
1816     if (!cfg.chan_config || cfg.chan_config > 7) {
1817         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1818         return AVERROR_INVALIDDATA;
1819     }
1820     s->frames             = mp3Frames[cfg.chan_config];
1821     s->coff               = chan_offset[cfg.chan_config];
1822     avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
1823     avctx->channel_layout = chan_layout[cfg.chan_config];
1824
1825     if (cfg.sample_rate < 16000)
1826         s->syncword = 0xffe00000;
1827     else
1828         s->syncword = 0xfff00000;
1829
1830     /* Init the first mp3 decoder in standard way, so that all tables get builded
1831      * We replace avctx->priv_data with the context of the first decoder so that
1832      * decode_init() does not have to be changed.
1833      * Other decoders will be initialized here copying data from the first context
1834      */
1835     // Allocate zeroed memory for the first decoder context
1836     s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1837     if (!s->mp3decctx[0])
1838         goto alloc_fail;
1839     // Put decoder context in place to make init_decode() happy
1840     avctx->priv_data = s->mp3decctx[0];
1841     decode_init(avctx);
1842     s->frame = avctx->coded_frame;
1843     // Restore mp3on4 context pointer
1844     avctx->priv_data = s;
1845     s->mp3decctx[0]->adu_mode = 1; // Set adu mode
1846
1847     /* Create a separate codec/context for each frame (first is already ok).
1848      * Each frame is 1 or 2 channels - up to 5 frames allowed
1849      */
1850     for (i = 1; i < s->frames; i++) {
1851         s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1852         if (!s->mp3decctx[i])
1853             goto alloc_fail;
1854         s->mp3decctx[i]->adu_mode = 1;
1855         s->mp3decctx[i]->avctx = avctx;
1856         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1857     }
1858
1859     /* Allocate buffer for multi-channel output if needed */
1860     if (s->frames > 1) {
1861         s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
1862                                    sizeof(*s->decoded_buf));
1863         if (!s->decoded_buf)
1864             goto alloc_fail;
1865     }
1866
1867     return 0;
1868 alloc_fail:
1869     decode_close_mp3on4(avctx);
1870     return AVERROR(ENOMEM);
1871 }
1872
1873
1874 static void flush_mp3on4(AVCodecContext *avctx)
1875 {
1876     int i;
1877     MP3On4DecodeContext *s = avctx->priv_data;
1878
1879     for (i = 0; i < s->frames; i++) {
1880         MPADecodeContext *m = s->mp3decctx[i];
1881         memset(m->synth_buf, 0, sizeof(m->synth_buf));
1882         m->last_buf_size = 0;
1883     }
1884 }
1885
1886
1887 static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
1888                                int *got_frame_ptr, AVPacket *avpkt)
1889 {
1890     const uint8_t *buf     = avpkt->data;
1891     int buf_size           = avpkt->size;
1892     MP3On4DecodeContext *s = avctx->priv_data;
1893     MPADecodeContext *m;
1894     int fsize, len = buf_size, out_size = 0;
1895     uint32_t header;
1896     OUT_INT *out_samples;
1897     OUT_INT *outptr, *bp;
1898     int fr, j, n, ch, ret;
1899
1900     /* get output buffer */
1901     s->frame->nb_samples = MPA_FRAME_SIZE;
1902     if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
1903         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1904         return ret;
1905     }
1906     out_samples = (OUT_INT *)s->frame->data[0];
1907
1908     // Discard too short frames
1909     if (buf_size < HEADER_SIZE)
1910         return AVERROR_INVALIDDATA;
1911
1912     // If only one decoder interleave is not needed
1913     outptr = s->frames == 1 ? out_samples : s->decoded_buf;
1914
1915     avctx->bit_rate = 0;
1916
1917     ch = 0;
1918     for (fr = 0; fr < s->frames; fr++) {
1919         fsize = AV_RB16(buf) >> 4;
1920         fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1921         m     = s->mp3decctx[fr];
1922         assert(m != NULL);
1923
1924         if (fsize < HEADER_SIZE) {
1925             av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
1926             return AVERROR_INVALIDDATA;
1927         }
1928         header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1929
1930         if (ff_mpa_check_header(header) < 0) // Bad header, discard block
1931             break;
1932
1933         avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1934
1935         if (ch + m->nb_channels > avctx->channels) {
1936             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
1937                                         "channel count\n");
1938             return AVERROR_INVALIDDATA;
1939         }
1940         ch += m->nb_channels;
1941
1942         out_size += mp_decode_frame(m, outptr, buf, fsize);
1943         buf      += fsize;
1944         len      -= fsize;
1945
1946         if (s->frames > 1) {
1947             n = m->avctx->frame_size*m->nb_channels;
1948             /* interleave output data */
1949             bp = out_samples + s->coff[fr];
1950             if (m->nb_channels == 1) {
1951                 for (j = 0; j < n; j++) {
1952                     *bp = s->decoded_buf[j];
1953                     bp += avctx->channels;
1954                 }
1955             } else {
1956                 for (j = 0; j < n; j++) {
1957                     bp[0] = s->decoded_buf[j++];
1958                     bp[1] = s->decoded_buf[j];
1959                     bp   += avctx->channels;
1960                 }
1961             }
1962         }
1963         avctx->bit_rate += m->bit_rate;
1964     }
1965
1966     /* update codec info */
1967     avctx->sample_rate = s->mp3decctx[0]->sample_rate;
1968
1969     s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
1970     *got_frame_ptr   = 1;
1971     *(AVFrame *)data = *s->frame;
1972
1973     return buf_size;
1974 }
1975 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
1976
1977 #if !CONFIG_FLOAT
1978 #if CONFIG_MP1_DECODER
1979 AVCodec ff_mp1_decoder = {
1980     .name           = "mp1",
1981     .type           = AVMEDIA_TYPE_AUDIO,
1982     .id             = CODEC_ID_MP1,
1983     .priv_data_size = sizeof(MPADecodeContext),
1984     .init           = decode_init,
1985     .decode         = decode_frame,
1986     .capabilities   = CODEC_CAP_DR1,
1987     .flush          = flush,
1988     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
1989 };
1990 #endif
1991 #if CONFIG_MP2_DECODER
1992 AVCodec ff_mp2_decoder = {
1993     .name           = "mp2",
1994     .type           = AVMEDIA_TYPE_AUDIO,
1995     .id             = CODEC_ID_MP2,
1996     .priv_data_size = sizeof(MPADecodeContext),
1997     .init           = decode_init,
1998     .decode         = decode_frame,
1999     .capabilities   = CODEC_CAP_DR1,
2000     .flush          = flush,
2001     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2002 };
2003 #endif
2004 #if CONFIG_MP3_DECODER
2005 AVCodec ff_mp3_decoder = {
2006     .name           = "mp3",
2007     .type           = AVMEDIA_TYPE_AUDIO,
2008     .id             = CODEC_ID_MP3,
2009     .priv_data_size = sizeof(MPADecodeContext),
2010     .init           = decode_init,
2011     .decode         = decode_frame,
2012     .capabilities   = CODEC_CAP_DR1,
2013     .flush          = flush,
2014     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2015 };
2016 #endif
2017 #if CONFIG_MP3ADU_DECODER
2018 AVCodec ff_mp3adu_decoder = {
2019     .name           = "mp3adu",
2020     .type           = AVMEDIA_TYPE_AUDIO,
2021     .id             = CODEC_ID_MP3ADU,
2022     .priv_data_size = sizeof(MPADecodeContext),
2023     .init           = decode_init,
2024     .decode         = decode_frame_adu,
2025     .capabilities   = CODEC_CAP_DR1,
2026     .flush          = flush,
2027     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2028 };
2029 #endif
2030 #if CONFIG_MP3ON4_DECODER
2031 AVCodec ff_mp3on4_decoder = {
2032     .name           = "mp3on4",
2033     .type           = AVMEDIA_TYPE_AUDIO,
2034     .id             = CODEC_ID_MP3ON4,
2035     .priv_data_size = sizeof(MP3On4DecodeContext),
2036     .init           = decode_init_mp3on4,
2037     .close          = decode_close_mp3on4,
2038     .decode         = decode_frame_mp3on4,
2039     .capabilities   = CODEC_CAP_DR1,
2040     .flush          = flush_mp3on4,
2041     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
2042 };
2043 #endif
2044 #endif