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