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