mpegaudiodec.c 67.2 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * MPEG Audio decoder
3
 * Copyright (c) 2001, 2002 Fabrice Bellard
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
12
 * Libav is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
21 22

/**
23
 * @file
24
 * MPEG Audio decoder
25
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
26

27
#include "libavutil/attributes.h"
28
#include "libavutil/avassert.h"
29
#include "libavutil/channel_layout.h"
30
#include "libavutil/float_dsp.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
31
#include "avcodec.h"
32
#include "get_bits.h"
33
#include "internal.h"
34
#include "mathops.h"
35
#include "mpegaudiodsp.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
36 37

/*
38 39
 * TODO:
 *  - test lsf / mpeg25 extensively.
Fabrice Bellard's avatar
Fabrice Bellard committed
40 41
 */

Roberto Togni's avatar
Roberto Togni committed
42
#include "mpegaudio.h"
43
#include "mpegaudiodecheader.h"
44

45 46
#define BACKSTEP_SIZE 512
#define EXTRABYTES 24
47
#define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

/* layer 3 "granule" */
typedef struct GranuleDef {
    uint8_t scfsi;
    int part2_3_length;
    int big_values;
    int global_gain;
    int scalefac_compress;
    uint8_t block_type;
    uint8_t switch_point;
    int table_select[3];
    int subblock_gain[3];
    uint8_t scalefac_scale;
    uint8_t count1table_select;
    int region_size[3]; /* number of huffman codes in each region */
    int preflag;
    int short_start, long_end; /* long/short band indexes */
    uint8_t scale_factors[40];
66
    DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
67 68 69 70
} GranuleDef;

typedef struct MPADecodeContext {
    MPA_DECODE_HEADER
71
    uint8_t last_buf[LAST_BUF_SIZE];
72 73 74 75 76
    int last_buf_size;
    /* next header (used in free format parsing) */
    uint32_t free_format_next_header;
    GetBitContext gb;
    GetBitContext in_gb;
77
    DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
78
    int synth_buf_offset[MPA_MAX_CHANNELS];
79
    DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
80 81 82 83
    INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
    GranuleDef granules[2][2]; /* Used in Layer 3 */
    int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
    int dither_state;
84
    int err_recognition;
85 86
    AVCodecContext* avctx;
    MPADSPContext mpadsp;
87
    AVFloatDSPContext fdsp;
88
    AVFrame *frame;
89 90
} MPADecodeContext;

91
#if CONFIG_FLOAT
92
#   define SHR(a,b)       ((a)*(1.0f/(1<<(b))))
93
#   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
94 95
#   define FIXR(x)        ((float)(x))
#   define FIXHR(x)       ((float)(x))
96 97 98
#   define MULH3(x, y, s) ((s)*(y)*(x))
#   define MULLx(x, y, s) ((y)*(x))
#   define RENAME(a) a ## _float
99 100
#   define OUT_FMT   AV_SAMPLE_FMT_FLT
#   define OUT_FMT_P AV_SAMPLE_FMT_FLTP
101 102
#else
#   define SHR(a,b)       ((a)>>(b))
103
/* WARNING: only correct for positive numbers */
104 105 106 107 108
#   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
#   define FIXR(a)        ((int)((a) * FRAC_ONE + 0.5))
#   define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))
#   define MULH3(x, y, s) MULH((s)*(x), y)
#   define MULLx(x, y, s) MULL(x,y,s)
109
#   define RENAME(a)      a ## _fixed
110 111
#   define OUT_FMT   AV_SAMPLE_FMT_S16
#   define OUT_FMT_P AV_SAMPLE_FMT_S16P
112
#endif
113

114 115
/****************/

Fabrice Bellard's avatar
Fabrice Bellard committed
116 117
#define HEADER_SIZE 4

118
#include "mpegaudiodata.h"
119 120 121
#include "mpegaudiodectab.h"

/* vlc structure for decoding layer 3 huffman tables */
122
static VLC huff_vlc[16];
123
static VLC_TYPE huff_vlc_tables[
124 125
    0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
  142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
126 127
  ][2];
static const int huff_vlc_tables_sizes[16] = {
128 129
    0,  128,  128,  128,  130,  128,  154,  166,
  142,  204,  190,  170,  542,  460,  662,  414
130
};
131
static VLC huff_quad_vlc[2];
132 133
static VLC_TYPE  huff_quad_vlc_tables[128+16][2];
static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
134
/* computed from band_size_long */
135
static uint16_t band_index_long[9][23];
136
#include "mpegaudio_tablegen.h"
137
/* intensity stereo coef table */
138 139
static INTFLOAT is_table[2][16];
static INTFLOAT is_table_lsf[2][2][16];
140
static INTFLOAT csa_table[8][4];
141

142 143 144 145 146 147 148 149
static int16_t division_tab3[1<<6 ];
static int16_t division_tab5[1<<8 ];
static int16_t division_tab9[1<<11];

static int16_t * const division_tabs[4] = {
    division_tab3, division_tab5, NULL, division_tab9
};

150
/* lower 2 bits: modulo 3, higher bits: shift */
151
static uint16_t scale_factor_modshift[64];
152
/* [i][j]:  2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
153
static int32_t scale_factor_mult[15][3];
154 155 156
/* mult table for layer 2 group quantization */

#define SCALE_GEN(v) \
157
{ FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
158

Michael Niedermayer's avatar
Michael Niedermayer committed
159
static const int32_t scale_factor_mult2[3][3] = {
160 161 162
    SCALE_GEN(4.0 / 3.0), /* 3 steps */
    SCALE_GEN(4.0 / 5.0), /* 5 steps */
    SCALE_GEN(4.0 / 9.0), /* 9 steps */
163 164
};

165 166 167 168
/**
 * Convert region offsets to region sizes and truncate
 * size to big_values.
 */
169
static void region_offset2size(GranuleDef *g)
170 171 172 173
{
    int i, k, j = 0;
    g->region_size[2] = 576 / 2;
    for (i = 0; i < 3; i++) {
174 175 176 177 178 179
        k = FFMIN(g->region_size[i], g->big_values);
        g->region_size[i] = k - j;
        j = k;
    }
}

180
static void init_short_region(MPADecodeContext *s, GranuleDef *g)
181
{
182 183 184 185 186 187
    if (g->block_type == 2) {
        if (s->sample_rate_index != 8)
            g->region_size[0] = (36 / 2);
        else
            g->region_size[0] = (72 / 2);
    } else {
188 189 190 191 192 193 194 195 196 197
        if (s->sample_rate_index <= 2)
            g->region_size[0] = (36 / 2);
        else if (s->sample_rate_index != 8)
            g->region_size[0] = (54 / 2);
        else
            g->region_size[0] = (108 / 2);
    }
    g->region_size[1] = (576 / 2);
}

198 199
static void init_long_region(MPADecodeContext *s, GranuleDef *g,
                             int ra1, int ra2)
200
{
201
    int l;
202
    g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
203 204
    /* should not overflow */
    l = FFMIN(ra1 + ra2 + 2, 22);
205
    g->region_size[1] = band_index_long[s->sample_rate_index][      l] >> 1;
206 207
}

208
static void compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
209
{
210 211 212
    if (g->block_type == 2) {
        if (g->switch_point) {
            /* if switched mode, we handle the 36 first samples as
213 214
                long blocks.  For 8000Hz, we handle the 72 first
                exponents as long blocks */
215 216 217
            if (s->sample_rate_index <= 2)
                g->long_end = 8;
            else
218
                g->long_end = 6;
219

220
            g->short_start = 3;
221
        } else {
222
            g->long_end    = 0;
223 224 225 226
            g->short_start = 0;
        }
    } else {
        g->short_start = 13;
227
        g->long_end    = 22;
228 229 230
    }
}

231 232 233 234 235
/* layer 1 unscaling */
/* n = number of bits of the mantissa minus 1 */
static inline int l1_unscale(int n, int mant, int scale_factor)
{
    int shift, mod;
236
    int64_t val;
237

238 239
    shift   = scale_factor_modshift[scale_factor];
    mod     = shift & 3;
240
    shift >>= 2;
241 242
    val     = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
    shift  += n;
243 244
    /* NOTE: at this point, 1 <= shift >= 21 + 15 */
    return (int)((val + (1LL << (shift - 1))) >> shift);
245 246 247 248 249 250
}

static inline int l2_unscale_group(int steps, int mant, int scale_factor)
{
    int shift, mod, val;

251 252
    shift   = scale_factor_modshift[scale_factor];
    mod     = shift & 3;
253
    shift >>= 2;
254 255 256 257 258 259

    val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
    /* NOTE: at this point, 0 <= shift <= 21 */
    if (shift > 0)
        val = (val + (1 << (shift - 1))) >> shift;
    return val;
260 261 262 263 264 265 266 267
}

/* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
static inline int l3_unscale(int value, int exponent)
{
    unsigned int m;
    int e;

268 269 270 271
    e  = table_4_3_exp  [4 * value + (exponent & 3)];
    m  = table_4_3_value[4 * value + (exponent & 3)];
    e -= exponent >> 2;
    assert(e >= 1);
272
    if (e > 31)
273
        return 0;
274
    m = (m + (1 << (e - 1))) >> e;
275

276 277 278
    return m;
}

279
static av_cold void decode_init_static(void)
Fabrice Bellard's avatar
Fabrice Bellard committed
280
{
281
    int i, j, k;
Justin Ruggles's avatar
Justin Ruggles committed
282 283 284 285 286 287 288 289 290 291
    int offset;

    /* scale factors table for layer 1/2 */
    for (i = 0; i < 64; i++) {
        int shift, mod;
        /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
        shift = i / 3;
        mod   = i % 3;
        scale_factor_modshift[i] = mod | (shift << 2);
    }
292

Justin Ruggles's avatar
Justin Ruggles committed
293 294 295 296 297 298 299 300
    /* scale factor multiply for layer 1 */
    for (i = 0; i < 15; i++) {
        int n, norm;
        n = i + 2;
        norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
        scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0          * 2.0), FRAC_BITS);
        scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
        scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
301
        av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
Justin Ruggles's avatar
Justin Ruggles committed
302 303 304 305
                scale_factor_mult[i][0],
                scale_factor_mult[i][1],
                scale_factor_mult[i][2]);
    }
306

Justin Ruggles's avatar
Justin Ruggles committed
307
    RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
308

Justin Ruggles's avatar
Justin Ruggles committed
309 310 311 312 313
    /* huffman decode tables */
    offset = 0;
    for (i = 1; i < 16; i++) {
        const HuffTable *h = &mpa_huff_tables[i];
        int xsize, x, y;
314 315
        uint8_t  tmp_bits [512] = { 0 };
        uint16_t tmp_codes[512] = { 0 };
316

Justin Ruggles's avatar
Justin Ruggles committed
317
        xsize = h->xsize;
318

Justin Ruggles's avatar
Justin Ruggles committed
319 320 321 322 323
        j = 0;
        for (x = 0; x < xsize; x++) {
            for (y = 0; y < xsize; y++) {
                tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j  ];
                tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
324 325 326
            }
        }

Justin Ruggles's avatar
Justin Ruggles committed
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
        /* XXX: fail test */
        huff_vlc[i].table = huff_vlc_tables+offset;
        huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
        init_vlc(&huff_vlc[i], 7, 512,
                 tmp_bits, 1, 1, tmp_codes, 2, 2,
                 INIT_VLC_USE_NEW_STATIC);
        offset += huff_vlc_tables_sizes[i];
    }
    assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));

    offset = 0;
    for (i = 0; i < 2; i++) {
        huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
        huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
        init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
                 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
                 INIT_VLC_USE_NEW_STATIC);
        offset += huff_quad_vlc_tables_sizes[i];
    }
    assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));

    for (i = 0; i < 9; i++) {
        k = 0;
        for (j = 0; j < 22; j++) {
            band_index_long[i][j] = k;
            k += band_size_long[i][j];
353
        }
Justin Ruggles's avatar
Justin Ruggles committed
354 355
        band_index_long[i][22] = k;
    }
356

Justin Ruggles's avatar
Justin Ruggles committed
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
    /* compute n ^ (4/3) and store it in mantissa/exp format */

    mpegaudio_tableinit();

    for (i = 0; i < 4; i++) {
        if (ff_mpa_quant_bits[i] < 0) {
            for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
                int val1, val2, val3, steps;
                int val = j;
                steps   = ff_mpa_quant_steps[i];
                val1    = val % steps;
                val    /= steps;
                val2    = val % steps;
                val3    = val / steps;
                division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
372 373
            }
        }
Justin Ruggles's avatar
Justin Ruggles committed
374
    }
375 376


Justin Ruggles's avatar
Justin Ruggles committed
377 378 379 380 381 382 383 384
    for (i = 0; i < 7; i++) {
        float f;
        INTFLOAT v;
        if (i != 6) {
            f = tan((double)i * M_PI / 12.0);
            v = FIXR(f / (1.0 + f));
        } else {
            v = FIXR(1.0);
385
        }
Justin Ruggles's avatar
Justin Ruggles committed
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
        is_table[0][    i] = v;
        is_table[1][6 - i] = v;
    }
    /* invalid values */
    for (i = 7; i < 16; i++)
        is_table[0][i] = is_table[1][i] = 0.0;

    for (i = 0; i < 16; i++) {
        double f;
        int e, k;

        for (j = 0; j < 2; j++) {
            e = -(j + 1) * ((i + 1) >> 1);
            f = pow(2.0, e / 4.0);
            k = i & 1;
            is_table_lsf[j][k ^ 1][i] = FIXR(f);
            is_table_lsf[j][k    ][i] = FIXR(1.0);
403
            av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
Justin Ruggles's avatar
Justin Ruggles committed
404 405
                    i, j, (float) is_table_lsf[j][0][i],
                    (float) is_table_lsf[j][1][i]);
406
        }
Justin Ruggles's avatar
Justin Ruggles committed
407
    }
408

Justin Ruggles's avatar
Justin Ruggles committed
409 410 411 412 413
    for (i = 0; i < 8; i++) {
        float ci, cs, ca;
        ci = ci_table[i];
        cs = 1.0 / sqrt(1.0 + ci * ci);
        ca = cs * ci;
414
#if !CONFIG_FLOAT
Justin Ruggles's avatar
Justin Ruggles committed
415 416 417 418
        csa_table[i][0] = FIXHR(cs/4);
        csa_table[i][1] = FIXHR(ca/4);
        csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
        csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
419
#else
Justin Ruggles's avatar
Justin Ruggles committed
420 421 422 423
        csa_table[i][0] = cs;
        csa_table[i][1] = ca;
        csa_table[i][2] = ca + cs;
        csa_table[i][3] = ca - cs;
424
#endif
Justin Ruggles's avatar
Justin Ruggles committed
425
    }
426
}
427

428 429
static av_cold int decode_init(AVCodecContext * avctx)
{
430
    static int initialized_tables = 0;
431 432
    MPADecodeContext *s = avctx->priv_data;

433 434 435 436 437
    if (!initialized_tables) {
        decode_init_static();
        initialized_tables = 1;
    }

438 439
    s->avctx = avctx;

440
    avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
441 442
    ff_mpadsp_init(&s->mpadsp);

443 444 445 446 447
    if (avctx->request_sample_fmt == OUT_FMT &&
        avctx->codec_id != AV_CODEC_ID_MP3ON4)
        avctx->sample_fmt = OUT_FMT;
    else
        avctx->sample_fmt = OUT_FMT_P;
448
    s->err_recognition = avctx->err_recognition;
Fabrice Bellard's avatar
Fabrice Bellard committed
449

450
    if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
Roberto Togni's avatar
Roberto Togni committed
451
        s->adu_mode = 1;
452

Fabrice Bellard's avatar
Fabrice Bellard committed
453 454 455
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
456
#define C3 FIXHR(0.86602540378443864676/2)
457 458 459
#define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
#define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
#define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
460

461 462
/* 12 points IMDCT. We compute it "by hand" by factorizing obvious
   cases. */
463
static void imdct12(INTFLOAT *out, INTFLOAT *in)
464
{
465
    INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
466

467 468 469 470 471 472
    in0  = in[0*3];
    in1  = in[1*3] + in[0*3];
    in2  = in[2*3] + in[1*3];
    in3  = in[3*3] + in[2*3];
    in4  = in[4*3] + in[3*3];
    in5  = in[5*3] + in[4*3];
Michael Niedermayer's avatar
Michael Niedermayer committed
473 474 475
    in5 += in3;
    in3 += in1;

476 477 478 479
    in2  = MULH3(in2, C3, 2);
    in3  = MULH3(in3, C3, 4);

    t1   = in0 - in4;
480
    t2   = MULH3(in1 - in5, C4, 2);
481 482 483 484 485 486 487 488 489

    out[ 7] =
    out[10] = t1 + t2;
    out[ 1] =
    out[ 4] = t1 - t2;

    in0    += SHR(in4, 1);
    in4     = in0 + in2;
    in5    += 2*in1;
490
    in1     = MULH3(in5 + in3, C5, 1);
491 492 493 494 495 496
    out[ 8] =
    out[ 9] = in4 + in1;
    out[ 2] =
    out[ 3] = in4 - in1;

    in0    -= in2;
497
    in5     = MULH3(in5 - in3, C6, 2);
498 499 500 501
    out[ 0] =
    out[ 5] = in0 - in5;
    out[ 6] =
    out[11] = in0 + in5;
502 503 504 505
}

/* return the number of decoded frames */
static int mp_decode_layer1(MPADecodeContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
506
{
507
    int bound, i, v, n, ch, j, mant;
508 509
    uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
    uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
510

511
    if (s->mode == MPA_JSTEREO)
512 513 514 515 516
        bound = (s->mode_ext + 1) * 4;
    else
        bound = SBLIMIT;

    /* allocation bits */
517 518
    for (i = 0; i < bound; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
519 520 521
            allocation[ch][i] = get_bits(&s->gb, 4);
        }
    }
522
    for (i = bound; i < SBLIMIT; i++)
523 524 525
        allocation[0][i] = get_bits(&s->gb, 4);

    /* scale factors */
526 527
    for (i = 0; i < bound; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
528 529 530 531
            if (allocation[ch][i])
                scale_factors[ch][i] = get_bits(&s->gb, 6);
        }
    }
532
    for (i = bound; i < SBLIMIT; i++) {
533 534 535 536 537
        if (allocation[0][i]) {
            scale_factors[0][i] = get_bits(&s->gb, 6);
            scale_factors[1][i] = get_bits(&s->gb, 6);
        }
    }
538

539
    /* compute samples */
540 541 542
    for (j = 0; j < 12; j++) {
        for (i = 0; i < bound; i++) {
            for (ch = 0; ch < s->nb_channels; ch++) {
543 544 545 546 547 548 549 550 551 552
                n = allocation[ch][i];
                if (n) {
                    mant = get_bits(&s->gb, n + 1);
                    v = l1_unscale(n, mant, scale_factors[ch][i]);
                } else {
                    v = 0;
                }
                s->sb_samples[ch][j][i] = v;
            }
        }
553
        for (i = bound; i < SBLIMIT; i++) {
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
            n = allocation[0][i];
            if (n) {
                mant = get_bits(&s->gb, n + 1);
                v = l1_unscale(n, mant, scale_factors[0][i]);
                s->sb_samples[0][j][i] = v;
                v = l1_unscale(n, mant, scale_factors[1][i]);
                s->sb_samples[1][j][i] = v;
            } else {
                s->sb_samples[0][j][i] = 0;
                s->sb_samples[1][j][i] = 0;
            }
        }
    }
    return 12;
}

static int mp_decode_layer2(MPADecodeContext *s)
{
    int sblimit; /* number of used subbands */
    const unsigned char *alloc_table;
    int table, bit_alloc_bits, i, j, ch, bound, v;
    unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
    unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
    unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
    int scale, qindex, bits, steps, k, l, m, b;
Fabrice Bellard's avatar
Fabrice Bellard committed
579

580
    /* select decoding table */
581
    table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
582 583
                                   s->sample_rate, s->lsf);
    sblimit     = ff_mpa_sblimit_table[table];
584
    alloc_table = ff_mpa_alloc_tables[table];
585

586
    if (s->mode == MPA_JSTEREO)
587 588 589 590
        bound = (s->mode_ext + 1) * 4;
    else
        bound = sblimit;

591
    av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
592 593

    /* sanity check */
594 595
    if (bound > sblimit)
        bound = sblimit;
596

597 598
    /* parse bit allocation */
    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 603 604
            bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
        j += 1 << bit_alloc_bits;
    }
605
    for (i = bound; i < sblimit; i++) {
606 607 608 609 610
        bit_alloc_bits = alloc_table[j];
        v = get_bits(&s->gb, bit_alloc_bits);
        bit_alloc[0][i] = v;
        bit_alloc[1][i] = v;
        j += 1 << bit_alloc_bits;
Fabrice Bellard's avatar
Fabrice Bellard committed
611
    }
612 613

    /* scale codes */
614 615
    for (i = 0; i < sblimit; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
616
            if (bit_alloc[ch][i])
617 618 619
                scale_code[ch][i] = get_bits(&s->gb, 2);
        }
    }
620

621
    /* scale factors */
622 623
    for (i = 0; i < sblimit; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
624 625
            if (bit_alloc[ch][i]) {
                sf = scale_factors[ch][i];
626
                switch (scale_code[ch][i]) {
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
                default:
                case 0:
                    sf[0] = get_bits(&s->gb, 6);
                    sf[1] = get_bits(&s->gb, 6);
                    sf[2] = get_bits(&s->gb, 6);
                    break;
                case 2:
                    sf[0] = get_bits(&s->gb, 6);
                    sf[1] = sf[0];
                    sf[2] = sf[0];
                    break;
                case 1:
                    sf[0] = get_bits(&s->gb, 6);
                    sf[2] = get_bits(&s->gb, 6);
                    sf[1] = sf[0];
                    break;
                case 3:
                    sf[0] = get_bits(&s->gb, 6);
                    sf[2] = get_bits(&s->gb, 6);
                    sf[1] = sf[2];
                    break;
                }
            }
        }
    }

    /* samples */
654 655
    for (k = 0; k < 3; k++) {
        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 661 662 663
                    b = bit_alloc[ch][i];
                    if (b) {
                        scale = scale_factors[ch][i][k];
                        qindex = alloc_table[j+b];
664
                        bits = ff_mpa_quant_bits[qindex];
665
                        if (bits < 0) {
666
                            int v2;
667 668
                            /* 3 values at the same time */
                            v = get_bits(&s->gb, -bits);
669 670 671
                            v2 = division_tabs[qindex][v];
                            steps  = ff_mpa_quant_steps[qindex];

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 681 682 683 684 685 686 687 688 689 690 691
                                v = get_bits(&s->gb, bits);
                                v = l1_unscale(bits - 1, v, scale);
                                s->sb_samples[ch][k * 12 + l + m][i] = v;
                            }
                        }
                    } else {
                        s->sb_samples[ch][k * 12 + l + 0][i] = 0;
                        s->sb_samples[ch][k * 12 + l + 1][i] = 0;
                        s->sb_samples[ch][k * 12 + l + 2][i] = 0;
                    }
                }
                /* 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 697 698 699 700 701 702
                bit_alloc_bits = alloc_table[j];
                b = bit_alloc[0][i];
                if (b) {
                    int mant, scale0, scale1;
                    scale0 = scale_factors[0][i][k];
                    scale1 = scale_factors[1][i][k];
                    qindex = alloc_table[j+b];
703
                    bits = ff_mpa_quant_bits[qindex];
704 705 706
                    if (bits < 0) {
                        /* 3 values at the same time */
                        v = get_bits(&s->gb, -bits);
707
                        steps = ff_mpa_quant_steps[qindex];
708 709
                        mant = v % steps;
                        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 714 715
                            l2_unscale_group(steps, mant, scale1);
                        mant = v % steps;
                        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 724
                            l2_unscale_group(steps, v, scale1);
                    } 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 731 732 733 734 735 736 737 738 739 740 741
                                l1_unscale(bits - 1, mant, scale1);
                        }
                    }
                } else {
                    s->sb_samples[0][k * 12 + l + 0][i] = 0;
                    s->sb_samples[0][k * 12 + l + 1][i] = 0;
                    s->sb_samples[0][k * 12 + l + 2][i] = 0;
                    s->sb_samples[1][k * 12 + l + 0][i] = 0;
                    s->sb_samples[1][k * 12 + l + 1][i] = 0;
                    s->sb_samples[1][k * 12 + l + 2][i] = 0;
                }
                /* next subband in alloc table */
742
                j += 1 << bit_alloc_bits;
743 744
            }
            /* fill remaining samples to zero */
745 746
            for (i = sblimit; i < SBLIMIT; i++) {
                for (ch = 0; ch < s->nb_channels; ch++) {
747 748 749 750 751 752 753 754
                    s->sb_samples[ch][k * 12 + l + 0][i] = 0;
                    s->sb_samples[ch][k * 12 + l + 1][i] = 0;
                    s->sb_samples[ch][k * 12 + l + 2][i] = 0;
                }
            }
        }
    }
    return 3 * 12;
Fabrice Bellard's avatar
Fabrice Bellard committed
755 756
}

757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
#define SPLIT(dst,sf,n)             \
    if (n == 3) {                   \
        int m = (sf * 171) >> 9;    \
        dst   = sf - 3 * m;         \
        sf    = m;                  \
    } else if (n == 4) {            \
        dst  = sf & 3;              \
        sf >>= 2;                   \
    } else if (n == 5) {            \
        int m = (sf * 205) >> 10;   \
        dst   = sf - 5 * m;         \
        sf    = m;                  \
    } else if (n == 6) {            \
        int m = (sf * 171) >> 10;   \
        dst   = sf - 6 * m;         \
        sf    = m;                  \
    } else {                        \
        dst = 0;                    \
775 776
    }

777 778
static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
                                           int n3)
779
{
780 781 782
    SPLIT(slen[3], sf, n3)
    SPLIT(slen[2], sf, n2)
    SPLIT(slen[1], sf, n1)
783 784 785
    slen[0] = sf;
}

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 795
    gain    = g->global_gain - 210;
    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 804 805 806
            *exp_ptr++ = v0;
    }

    if (g->short_start < 13) {
807
        bstab    = band_size_short[s->sample_rate_index];
808 809 810
        gains[0] = gain - (g->subblock_gain[0] << 3);
        gains[1] = gain - (g->subblock_gain[1] << 3);
        gains[2] = gain - (g->subblock_gain[2] << 3);
811 812
        k        = g->long_end;
        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 817
                for (j = len; j > 0; j--)
                    *exp_ptr++ = v0;
818 819 820 821 822 823 824 825
            }
        }
    }
}

/* handle n = 0 too */
static inline int get_bitsz(GetBitContext *s, int n)
{
826
    return n ? get_bits(s, n) : 0;
827 828
}

829

830 831 832 833 834 835
static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
                          int *end_pos2)
{
    if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
        s->gb           = s->in_gb;
        s->in_gb.buffer = NULL;
836 837
        assert((get_bits_count(&s->gb) & 7) == 0);
        skip_bits_long(&s->gb, *pos - *end_pos);
838 839 840
        *end_pos2 =
        *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
        *pos      = get_bits_count(&s->gb);
841 842 843
    }
}

844 845 846 847 848 849 850
/* Following is a optimized code for
            INTFLOAT v = *src
            if(get_bits1(&s->gb))
                v = -v;
            *dst = v;
*/
#if CONFIG_FLOAT
851 852 853
#define READ_FLIP_SIGN(dst,src)                     \
    v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \
    AV_WN32A(dst, v);
854
#else
855 856 857
#define READ_FLIP_SIGN(dst,src)     \
    v      = -get_bits1(&s->gb);    \
    *(dst) = (*(src) ^ v) - v;
858 859
#endif

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 870

    /* low frequencies (called big values) */
    s_index = 0;
871
    for (i = 0; i < 3; i++) {
872
        int j, k, l, linbits;
873 874 875 876
        j = g->region_size[i];
        if (j == 0)
            continue;
        /* select vlc table */
877 878
        k       = g->table_select[i];
        l       = mpa_huff_data[k][0];
879
        linbits = mpa_huff_data[k][1];
880
        vlc     = &huff_vlc[l];
881

882 883 884
        if (!l) {
            memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
            s_index += 2 * j;
885 886 887
            continue;
        }

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 898
                    break;
            }
899
            y = get_vlc2(&s->gb, vlc->table, 7, 3);
900

901
            if (!y) {
902 903 904 905 906 907
                g->sb_hybrid[s_index  ] =
                g->sb_hybrid[s_index+1] = 0;
                s_index += 2;
                continue;
            }

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) {
Michael Niedermayer's avatar
Michael Niedermayer committed
913 914
                x = y >> 5;
                y = y & 0x0f;
915 916 917
                if (x < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
                } else {
918
                    x += get_bitsz(&s->gb, linbits);
919
                    v  = l3_unscale(x, exponent);
920 921 922
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index] = v;
923
                }
924 925 926
                if (y < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
                } else {
927
                    y += get_bitsz(&s->gb, linbits);
928
                    v  = l3_unscale(y, exponent);
929 930 931
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index+1] = v;
932
                }
933
            } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
934 935 936
                x = y >> 5;
                y = y & 0x0f;
                x += y;
937 938 939
                if (x < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
                } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
940
                    x += get_bitsz(&s->gb, linbits);
941
                    v  = l3_unscale(x, exponent);
942 943 944
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index+!!y] = v;
Michael Niedermayer's avatar
Michael Niedermayer committed
945
                }
946
                g->sb_hybrid[s_index + !y] = 0;
947
            }
948
            s_index += 2;
949 950
        }
    }
951

952 953
    /* high frequencies */
    vlc = &huff_quad_vlc[g->count1table_select];
954
    last_pos = 0;
955
    while (s_index <= 572) {
956
        int pos, code;
957 958
        pos = get_bits_count(&s->gb);
        if (pos >= end_pos) {
959
            if (pos > end_pos2 && last_pos) {
960 961 962 963
                /* some encoders generate an incorrect size for this
                   part. We must go back into the data */
                s_index -= 4;
                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)
966
                    s_index=0;
967 968
                break;
            }
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 978 979 980 981 982
        g->sb_hybrid[s_index+0] =
        g->sb_hybrid[s_index+1] =
        g->sb_hybrid[s_index+2] =
        g->sb_hybrid[s_index+3] = 0;
        while (code) {
            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 985 986
            int pos = s_index + idxtab[code];
            code   ^= 8 >> idxtab[code];
            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)) {
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)) {
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 1001
    skip_bits_long(&s->gb, bits_left);

1002
    i = get_bits_count(&s->gb);
1003
    switch_buffer(s, &i, &end_pos, &end_pos2);
1004

Fabrice Bellard's avatar
Fabrice Bellard committed
1005 1006 1007
    return 0;
}

1008 1009 1010 1011 1012
/* Reorder short blocks from bitstream order to interleaved order. It
   would be faster to do it in parsing, but the code would be far more
   complicated */
static void reorder_block(MPADecodeContext *s, GranuleDef *g)
{
1013
    int i, j, len;
1014 1015
    INTFLOAT *ptr, *dst, *ptr1;
    INTFLOAT tmp[576];
1016 1017 1018 1019 1020

    if (g->block_type != 2)
        return;

    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 1026 1027
    } else {
        ptr = g->sb_hybrid;
    }
1028

1029 1030
    for (i = g->short_start; i < 13; i++) {
        len  = band_size_short[s->sample_rate_index][i];
1031
        ptr1 = ptr;
1032 1033
        dst  = tmp;
        for (j = len; j > 0; j--) {
1034 1035 1036 1037
            *dst++ = ptr[0*len];
            *dst++ = ptr[1*len];
            *dst++ = ptr[2*len];
            ptr++;
1038
        }
1039
        ptr += 2 * len;
1040
        memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1041 1042 1043 1044 1045
    }
}

#define ISQRT2 FIXR(0.70710678118654752440)

1046
static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1047 1048
{
    int i, j, k, l;
1049 1050
    int sf_max, sf, len, non_zero_found;
    INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
    int non_zero_found_short[3];

    /* intensity stereo */
    if (s->mode_ext & MODE_EXT_I_STEREO) {
        if (!s->lsf) {
            is_tab = is_table;
            sf_max = 7;
        } else {
            is_tab = is_table_lsf[g1->scalefac_compress & 1];
            sf_max = 16;
        }
1062

1063 1064 1065 1066 1067 1068 1069
        tab0 = g0->sb_hybrid + 576;
        tab1 = g1->sb_hybrid + 576;

        non_zero_found_short[0] = 0;
        non_zero_found_short[1] = 0;
        non_zero_found_short[2] = 0;
        k = (13 - g1->short_start) * 3 + g1->long_end - 3;
1070
        for (i = 12; i >= g1->short_start; i--) {
1071 1072 1073 1074
            /* for last band, use previous scale factor */
            if (i != 11)
                k -= 3;
            len = band_size_short[s->sample_rate_index][i];
1075
            for (l = 2; l >= 0; l--) {
1076 1077 1078 1079
                tab0 -= len;
                tab1 -= len;
                if (!non_zero_found_short[l]) {
                    /* test if non zero band. if so, stop doing i-stereo */
1080
                    for (j = 0; j < len; j++) {
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
                        if (tab1[j] != 0) {
                            non_zero_found_short[l] = 1;
                            goto found1;
                        }
                    }
                    sf = g1->scale_factors[k + l];
                    if (sf >= sf_max)
                        goto found1;

                    v1 = is_tab[0][sf];
                    v2 = is_tab[1][sf];
1092 1093
                    for (j = 0; j < len; j++) {
                        tmp0    = tab0[j];
1094 1095
                        tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
                        tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1096 1097
                    }
                } else {
1098
found1:
1099 1100 1101
                    if (s->mode_ext & MODE_EXT_MS_STEREO) {
                        /* lower part of the spectrum : do ms stereo
                           if enabled */
1102 1103 1104
                        for (j = 0; j < len; j++) {
                            tmp0    = tab0[j];
                            tmp1    = tab1[j];
1105 1106
                            tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
                            tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1107 1108 1109 1110 1111 1112
                        }
                    }
                }
            }
        }

1113
        non_zero_found = non_zero_found_short[0] |
1114 1115
                         non_zero_found_short[1] |
                         non_zero_found_short[2];
1116

1117 1118
        for (i = g1->long_end - 1;i >= 0;i--) {
            len   = band_size_long[s->sample_rate_index][i];
1119 1120 1121 1122
            tab0 -= len;
            tab1 -= len;
            /* test if non zero band. if so, stop doing i-stereo */
            if (!non_zero_found) {
1123
                for (j = 0; j < len; j++) {
1124 1125 1126 1127 1128 1129
                    if (tab1[j] != 0) {
                        non_zero_found = 1;
                        goto found2;
                    }
                }
                /* for last band, use previous scale factor */
1130
                k  = (i == 21) ? 20 : i;
1131 1132 1133 1134 1135
                sf = g1->scale_factors[k];
                if (sf >= sf_max)
                    goto found2;
                v1 = is_tab[0][sf];
                v2 = is_tab[1][sf];
1136 1137
                for (j = 0; j < len; j++) {
                    tmp0    = tab0[j];
1138 1139
                    tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
                    tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1140 1141
                }
            } else {
1142
found2:
1143 1144 1145
                if (s->mode_ext & MODE_EXT_MS_STEREO) {
                    /* lower part of the spectrum : do ms stereo
                       if enabled */
1146 1147 1148
                    for (j = 0; j < len; j++) {
                        tmp0    = tab0[j];
                        tmp1    = tab1[j];
1149 1150
                        tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
                        tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1151 1152 1153 1154 1155 1156 1157 1158
                    }
                }
            }
        }
    } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
        /* ms stereo ONLY */
        /* NOTE: the 1/sqrt(2) normalization factor is included in the
           global gain */
1159
#if CONFIG_FLOAT
1160
       s->fdsp.butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
1161
#else
1162 1163
        tab0 = g0->sb_hybrid;
        tab1 = g1->sb_hybrid;
1164 1165 1166
        for (i = 0; i < 576; i++) {
            tmp0    = tab0[i];
            tmp1    = tab1[i];
1167 1168 1169
            tab0[i] = tmp0 + tmp1;
            tab1[i] = tmp0 - tmp1;
        }
1170
#endif
1171 1172 1173
    }
}

1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
#if CONFIG_FLOAT
#define AA(j) do {                                                      \
        float tmp0 = ptr[-1-j];                                         \
        float tmp1 = ptr[   j];                                         \
        ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1];    \
        ptr[   j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0];    \
    } while (0)
#else
#define AA(j) do {                                              \
        int tmp0 = ptr[-1-j];                                   \
        int tmp1 = ptr[   j];                                   \
        int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
1186 1187
        ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
        ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
1188 1189 1190 1191
    } while (0)
#endif

static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1192
{
1193
    INTFLOAT *ptr;
Michael Niedermayer's avatar
Michael Niedermayer committed
1194
    int n, i;
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204

    /* we antialias only "long" bands */
    if (g->block_type == 2) {
        if (!g->switch_point)
            return;
        /* XXX: check this for 8000Hz case */
        n = 1;
    } else {
        n = SBLIMIT - 1;
    }
1205

1206
    ptr = g->sb_hybrid + 18;
1207
    for (i = n; i > 0; i--) {
1208 1209 1210 1211 1212 1213 1214 1215
        AA(0);
        AA(1);
        AA(2);
        AA(3);
        AA(4);
        AA(5);
        AA(6);
        AA(7);
1216 1217

        ptr += 18;
1218 1219
    }
}
1220

1221 1222
static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
                          INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1223
{
1224
    INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1225 1226
    INTFLOAT out2[12];
    int i, j, mdct_long_end, sblimit;
1227 1228

    /* find last non zero block */
1229
    ptr  = g->sb_hybrid + 576;
1230 1231
    ptr1 = g->sb_hybrid + 2 * 18;
    while (ptr >= ptr1) {
1232
        int32_t *p;
1233
        ptr -= 6;
1234 1235
        p    = (int32_t*)ptr;
        if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
            break;
    }
    sblimit = ((ptr - g->sb_hybrid) / 18) + 1;

    if (g->block_type == 2) {
        /* XXX: check for 8000 Hz */
        if (g->switch_point)
            mdct_long_end = 2;
        else
            mdct_long_end = 0;
    } else {
        mdct_long_end = sblimit;
    }

1250 1251 1252 1253 1254 1255 1256
    s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
                                     mdct_long_end, g->switch_point,
                                     g->block_type);

    buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
    ptr = g->sb_hybrid + 18 * mdct_long_end;

1257
    for (j = mdct_long_end; j < sblimit; j++) {
1258
        /* select frequency inversion */
1259
        win     = RENAME(ff_mdct_win)[2 + (4  & -(j & 1))];
1260
        out_ptr = sb_samples + j;
1261

1262
        for (i = 0; i < 6; i++) {
1263
            *out_ptr = buf[4*i];
Michael Niedermayer's avatar
Michael Niedermayer committed
1264 1265 1266
            out_ptr += SBLIMIT;
        }
        imdct12(out2, ptr + 0);
1267
        for (i = 0; i < 6; i++) {
1268 1269
            *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*1)];
            buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
1270 1271
            out_ptr += SBLIMIT;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1272
        imdct12(out2, ptr + 1);
1273
        for (i = 0; i < 6; i++) {
1274 1275
            *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*2)];
            buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
Michael Niedermayer's avatar
Michael Niedermayer committed
1276 1277 1278
            out_ptr += SBLIMIT;
        }
        imdct12(out2, ptr + 2);
1279
        for (i = 0; i < 6; i++) {
1280 1281 1282
            buf[4*(i + 6*0)] = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*0)];
            buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
            buf[4*(i + 6*2)] = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1283
        }
1284
        ptr += 18;
1285
        buf += (j&3) != 3 ? 1 : (4*18-3);
1286 1287
    }
    /* zero bands */
1288
    for (j = sblimit; j < SBLIMIT; j++) {
1289 1290
        /* overlap */
        out_ptr = sb_samples + j;
1291
        for (i = 0; i < 18; i++) {
1292 1293
            *out_ptr = buf[4*i];
            buf[4*i]   = 0;
1294 1295
            out_ptr += SBLIMIT;
        }
1296
        buf += (j&3) != 3 ? 1 : (4*18-3);
1297 1298 1299 1300 1301 1302
    }
}

/* main layer3 decoding function */
static int mp_decode_layer3(MPADecodeContext *s)
{
1303
    int nb_granules, main_data_begin;
1304
    int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1305
    GranuleDef *g;
1306
    int16_t exponents[576]; //FIXME try INTFLOAT
1307 1308 1309 1310

    /* read side info */
    if (s->lsf) {
        main_data_begin = get_bits(&s->gb, 8);
1311
        skip_bits(&s->gb, s->nb_channels);
1312 1313 1314 1315
        nb_granules = 1;
    } else {
        main_data_begin = get_bits(&s->gb, 9);
        if (s->nb_channels == 2)
1316
            skip_bits(&s->gb, 3);
1317
        else
1318
            skip_bits(&s->gb, 5);
1319
        nb_granules = 2;
1320
        for (ch = 0; ch < s->nb_channels; ch++) {
1321 1322
            s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
            s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1323 1324
        }
    }
1325

1326 1327
    for (gr = 0; gr < nb_granules; gr++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
1328
            av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1329
            g = &s->granules[ch][gr];
1330
            g->part2_3_length = get_bits(&s->gb, 12);
1331 1332
            g->big_values     = get_bits(&s->gb,  9);
            if (g->big_values > 288) {
1333
                av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1334
                return AVERROR_INVALIDDATA;
1335 1336
            }

1337 1338 1339
            g->global_gain = get_bits(&s->gb, 8);
            /* if MS stereo only is selected, we precompute the
               1/sqrt(2) renormalization factor */
1340
            if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
1341 1342 1343 1344 1345 1346
                MODE_EXT_MS_STEREO)
                g->global_gain -= 2;
            if (s->lsf)
                g->scalefac_compress = get_bits(&s->gb, 9);
            else
                g->scalefac_compress = get_bits(&s->gb, 4);
1347
            blocksplit_flag = get_bits1(&s->gb);
1348 1349
            if (blocksplit_flag) {
                g->block_type = get_bits(&s->gb, 2);
1350
                if (g->block_type == 0) {
1351
                    av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
1352
                    return AVERROR_INVALIDDATA;
1353
                }
1354
                g->switch_point = get_bits1(&s->gb);
1355
                for (i = 0; i < 2; i++)
1356
                    g->table_select[i] = get_bits(&s->gb, 5);
1357
                for (i = 0; i < 3; i++)
1358
                    g->subblock_gain[i] = get_bits(&s->gb, 3);
1359
                init_short_region(s, g);
1360
            } else {
1361
                int region_address1, region_address2;
1362 1363
                g->block_type = 0;
                g->switch_point = 0;
1364
                for (i = 0; i < 3; i++)
1365 1366 1367 1368
                    g->table_select[i] = get_bits(&s->gb, 5);
                /* compute huffman coded region sizes */
                region_address1 = get_bits(&s->gb, 4);
                region_address2 = get_bits(&s->gb, 3);
1369
                av_dlog(s->avctx, "region1=%d region2=%d\n",
1370
                        region_address1, region_address2);
1371
                init_long_region(s, g, region_address1, region_address2);
1372
            }
1373 1374
            region_offset2size(g);
            compute_band_indexes(s, g);
1375

1376 1377
            g->preflag = 0;
            if (!s->lsf)
1378
                g->preflag = get_bits1(&s->gb);
1379
            g->scalefac_scale     = get_bits1(&s->gb);
1380
            g->count1table_select = get_bits1(&s->gb);
1381
            av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1382 1383 1384 1385
                    g->block_type, g->switch_point);
        }
    }

1386
    if (!s->adu_mode) {
1387
        int skip;
1388
        const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1389 1390
        int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0,
                                FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
1391 1392
        assert((get_bits_count(&s->gb) & 7) == 0);
        /* now we get bits from the main_data_begin offset */
1393 1394
        av_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
                main_data_begin, s->last_buf_size);
1395

1396
        memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1397
        s->in_gb = s->gb;
1398
        init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1399
#if !UNCHECKED_BITSTREAM_READER
1400
        s->gb.size_in_bits_plus8 += extrasize * 8;
1401
#endif
1402
        s->last_buf_size <<= 3;
1403 1404
        for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
            for (ch = 0; ch < s->nb_channels; ch++) {
1405 1406
                g = &s->granules[ch][gr];
                s->last_buf_size += g->part2_3_length;
1407
                memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
1408
                compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1409
            }
1410
        }
1411 1412 1413
        skip = s->last_buf_size - 8 * main_data_begin;
        if (skip >= s->gb.size_in_bits && s->in_gb.buffer) {
            skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits);
1414 1415
            s->gb           = s->in_gb;
            s->in_gb.buffer = NULL;
1416 1417
        } else {
            skip_bits_long(&s->gb, skip);
1418 1419
        }
    } else {
1420
        gr = 0;
1421
    }
1422

1423 1424
    for (; gr < nb_granules; gr++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
1425
            g = &s->granules[ch][gr];
1426
            bits_pos = get_bits_count(&s->gb);
1427

1428
            if (!s->lsf) {
1429
                uint8_t *sc;
1430 1431 1432 1433 1434
                int slen, slen1, slen2;

                /* MPEG1 scale factors */
                slen1 = slen_table[0][g->scalefac_compress];
                slen2 = slen_table[1][g->scalefac_compress];
1435
                av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1436 1437 1438
                if (g->block_type == 2) {
                    n = g->switch_point ? 17 : 18;
                    j = 0;
1439 1440
                    if (slen1) {
                        for (i = 0; i < n; i++)
1441
                            g->scale_factors[j++] = get_bits(&s->gb, slen1);
1442 1443
                    } else {
                        for (i = 0; i < n; i++)
1444 1445
                            g->scale_factors[j++] = 0;
                    }
1446 1447
                    if (slen2) {
                        for (i = 0; i < 18; i++)
1448
                            g->scale_factors[j++] = get_bits(&s->gb, slen2);
1449
                        for (i = 0; i < 3; i++)
1450
                            g->scale_factors[j++] = 0;
1451 1452
                    } else {
                        for (i = 0; i < 21; i++)
1453 1454
                            g->scale_factors[j++] = 0;
                    }
1455
                } else {
1456
                    sc = s->granules[ch][0].scale_factors;
1457
                    j = 0;
1458 1459
                    for (k = 0; k < 4; k++) {
                        n = k == 0 ? 6 : 5;
1460 1461
                        if ((g->scfsi & (0x8 >> k)) == 0) {
                            slen = (k < 2) ? slen1 : slen2;
1462 1463
                            if (slen) {
                                for (i = 0; i < n; i++)
1464
                                    g->scale_factors[j++] = get_bits(&s->gb, slen);
1465 1466
                            } else {
                                for (i = 0; i < n; i++)
1467 1468
                                    g->scale_factors[j++] = 0;
                            }
1469 1470
                        } else {
                            /* simply copy from last granule */
1471
                            for (i = 0; i < n; i++) {
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
                                g->scale_factors[j] = sc[j];
                                j++;
                            }
                        }
                    }
                    g->scale_factors[j++] = 0;
                }
            } else {
                int tindex, tindex2, slen[4], sl, sf;

                /* LSF scale factors */
1483
                if (g->block_type == 2)
1484
                    tindex = g->switch_point ? 2 : 1;
1485
                else
1486
                    tindex = 0;
1487

1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
                sf = g->scalefac_compress;
                if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
                    /* intensity stereo case */
                    sf >>= 1;
                    if (sf < 180) {
                        lsf_sf_expand(slen, sf, 6, 6, 0);
                        tindex2 = 3;
                    } else if (sf < 244) {
                        lsf_sf_expand(slen, sf - 180, 4, 4, 0);
                        tindex2 = 4;
                    } else {
                        lsf_sf_expand(slen, sf - 244, 3, 0, 0);
                        tindex2 = 5;
                    }
                } else {
                    /* normal case */
                    if (sf < 400) {
                        lsf_sf_expand(slen, sf, 5, 4, 4);
                        tindex2 = 0;
                    } else if (sf < 500) {
                        lsf_sf_expand(slen, sf - 400, 5, 4, 0);
                        tindex2 = 1;
                    } else {
                        lsf_sf_expand(slen, sf - 500, 3, 0, 0);
                        tindex2 = 2;
                        g->preflag = 1;
                    }
                }

                j = 0;
1518 1519
                for (k = 0; k < 4; k++) {
                    n  = lsf_nsf_table[tindex2][tindex][k];
1520
                    sl = slen[k];
1521 1522
                    if (sl) {
                        for (i = 0; i < n; i++)
1523
                            g->scale_factors[j++] = get_bits(&s->gb, sl);
1524 1525
                    } else {
                        for (i = 0; i < n; i++)
1526 1527
                            g->scale_factors[j++] = 0;
                    }
1528 1529
                }
                /* XXX: should compute exact size */
1530
                for (; j < 40; j++)
1531 1532 1533 1534 1535 1536
                    g->scale_factors[j] = 0;
            }

            exponents_from_scale_factors(s, g, exponents);

            /* read Huffman coded residue */
1537
            huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1538 1539
        } /* ch */

1540
        if (s->mode == MPA_JSTEREO)
1541
            compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1542

1543
        for (ch = 0; ch < s->nb_channels; ch++) {
1544
            g = &s->granules[ch][gr];
1545 1546

            reorder_block(s, g);
1547
            compute_antialias(s, g);
1548
            compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1549 1550
        }
    } /* gr */
1551
    if (get_bits_count(&s->gb) < 0)
1552
        skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1553 1554 1555
    return nb_granules * 18;
}

1556
static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
1557
                           const uint8_t *buf, int buf_size)
1558
{
1559
    int i, nb_frames, ch, ret;
1560
    OUT_INT *samples_ptr;
1561

1562
    init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
1563

1564 1565
    /* skip error protection field */
    if (s->error_protection)
1566
        skip_bits(&s->gb, 16);
1567 1568 1569

    switch(s->layer) {
    case 1:
1570
        s->avctx->frame_size = 384;
1571 1572 1573
        nb_frames = mp_decode_layer1(s);
        break;
    case 2:
1574
        s->avctx->frame_size = 1152;
1575 1576 1577
        nb_frames = mp_decode_layer2(s);
        break;
    case 3:
1578
        s->avctx->frame_size = s->lsf ? 576 : 1152;
1579 1580
    default:
        nb_frames = mp_decode_layer3(s);
1581

1582 1583 1584
        if (nb_frames < 0)
            return nb_frames;

1585
        s->last_buf_size=0;
1586
        if (s->in_gb.buffer) {
1587
            align_get_bits(&s->gb);
1588 1589
            i = get_bits_left(&s->gb)>>3;
            if (i >= 0 && i <= BACKSTEP_SIZE) {
1590 1591
                memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
                s->last_buf_size=i;
1592
            } else
1593
                av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1594 1595
            s->gb           = s->in_gb;
            s->in_gb.buffer = NULL;
1596 1597
        }

1598 1599
        align_get_bits(&s->gb);
        assert((get_bits_count(&s->gb) & 7) == 0);
1600
        i = get_bits_left(&s->gb) >> 3;
1601

1602 1603
        if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
            if (i < 0)
1604
                av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1605
            i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1606
        }
1607
        assert(i <= buf_size - HEADER_SIZE && i >= 0);
1608
        memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1609
        s->last_buf_size += i;
1610
    }
1611

1612 1613
    /* get output buffer */
    if (!samples) {
1614 1615
        av_assert0(s->frame != NULL);
        s->frame->nb_samples = s->avctx->frame_size;
1616
        if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1617 1618 1619
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
            return ret;
        }
1620
        samples = (OUT_INT **)s->frame->extended_data;
1621
    }
1622

1623
    /* apply the synthesis filter */
1624
    for (ch = 0; ch < s->nb_channels; ch++) {
1625 1626 1627 1628 1629 1630 1631 1632
        int sample_stride;
        if (s->avctx->sample_fmt == OUT_FMT_P) {
            samples_ptr   = samples[ch];
            sample_stride = 1;
        } else {
            samples_ptr   = samples[0] + ch;
            sample_stride = s->nb_channels;
        }
1633
        for (i = 0; i < nb_frames; i++) {
1634 1635 1636 1637 1638 1639
            RENAME(ff_mpa_synth_filter)(&s->mpadsp, s->synth_buf[ch],
                                        &(s->synth_buf_offset[ch]),
                                        RENAME(ff_mpa_synth_window),
                                        &s->dither_state, samples_ptr,
                                        sample_stride, s->sb_samples[ch][i]);
            samples_ptr += 32 * sample_stride;
1640 1641
        }
    }
1642

1643
    return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1644 1645
}

1646
static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1647
                        AVPacket *avpkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
1648
{
1649 1650
    const uint8_t *buf  = avpkt->data;
    int buf_size        = avpkt->size;
Fabrice Bellard's avatar
Fabrice Bellard committed
1651
    MPADecodeContext *s = avctx->priv_data;
1652
    uint32_t header;
1653
    int ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
1654

1655
    if (buf_size < HEADER_SIZE)
1656
        return AVERROR_INVALIDDATA;
1657

1658
    header = AV_RB32(buf);
1659
    if (ff_mpa_check_header(header) < 0) {
1660
        av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1661
        return AVERROR_INVALIDDATA;
1662 1663
    }

1664
    if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1665 1666
        /* free format: prepare to compute frame size */
        s->frame_size = -1;
1667
        return AVERROR_INVALIDDATA;
1668 1669
    }
    /* update codec info */
1670
    avctx->channels       = s->nb_channels;
1671
    avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1672 1673
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
1674

1675
    if (s->frame_size <= 0 || s->frame_size > buf_size) {
1676
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1677
        return AVERROR_INVALIDDATA;
1678
    } else if (s->frame_size < buf_size) {
1679
        buf_size= s->frame_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
1680
    }
1681

1682 1683
    s->frame = data;

1684 1685
    ret = mp_decode_frame(s, NULL, buf, buf_size);
    if (ret >= 0) {
1686 1687 1688
        s->frame->nb_samples = avctx->frame_size;
        *got_frame_ptr       = 1;
        avctx->sample_rate   = s->sample_rate;
1689
        //FIXME maybe move the other codec info stuff from above here too
1690 1691
    } else {
        av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1692 1693 1694 1695 1696
        /* Only return an error if the bad frame makes up the whole packet or
         * the error is related to buffer management.
         * If there is more data in the packet, just consume the bad frame
         * instead of returning an error, which would discard the whole
         * packet. */
1697
        *got_frame_ptr = 0;
1698 1699
        if (buf_size == avpkt->size || ret != AVERROR_INVALIDDATA)
            return ret;
1700
    }
1701
    s->frame_size = 0;
1702
    return buf_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
1703 1704
}

1705 1706 1707 1708 1709 1710
static void mp_flush(MPADecodeContext *ctx)
{
    memset(ctx->synth_buf, 0, sizeof(ctx->synth_buf));
    ctx->last_buf_size = 0;
}

1711 1712
static void flush(AVCodecContext *avctx)
{
1713
    mp_flush(avctx->priv_data);
1714 1715
}

1716
#if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1717 1718
static int decode_frame_adu(AVCodecContext *avctx, void *data,
                            int *got_frame_ptr, AVPacket *avpkt)
Roberto Togni's avatar
Roberto Togni committed
1719
{
1720 1721
    const uint8_t *buf  = avpkt->data;
    int buf_size        = avpkt->size;
Roberto Togni's avatar
Roberto Togni committed
1722 1723
    MPADecodeContext *s = avctx->priv_data;
    uint32_t header;
1724
    int len, ret;
Roberto Togni's avatar
Roberto Togni committed
1725 1726 1727 1728 1729

    len = buf_size;

    // Discard too short frames
    if (buf_size < HEADER_SIZE) {
1730 1731
        av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
        return AVERROR_INVALIDDATA;
Roberto Togni's avatar
Roberto Togni committed
1732 1733 1734 1735 1736 1737 1738
    }


    if (len > MPA_MAX_CODED_FRAME_SIZE)
        len = MPA_MAX_CODED_FRAME_SIZE;

    // Get header and restore sync word
1739
    header = AV_RB32(buf) | 0xffe00000;
Roberto Togni's avatar
Roberto Togni committed
1740

1741
    if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1742 1743
        av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
        return AVERROR_INVALIDDATA;
Roberto Togni's avatar
Roberto Togni committed
1744 1745
    }

1746
    avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
Roberto Togni's avatar
Roberto Togni committed
1747 1748
    /* update codec info */
    avctx->sample_rate = s->sample_rate;
1749
    avctx->channels    = s->nb_channels;
1750 1751
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
Roberto Togni's avatar
Roberto Togni committed
1752

1753
    s->frame_size = len;
Roberto Togni's avatar
Roberto Togni committed
1754

1755 1756
    s->frame = data;

1757 1758
    ret = mp_decode_frame(s, NULL, buf, buf_size);
    if (ret < 0) {
1759
        av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1760
        return ret;
1761
    }
1762

1763
    *got_frame_ptr = 1;
Roberto Togni's avatar
Roberto Togni committed
1764 1765 1766

    return buf_size;
}
1767
#endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
Roberto Togni's avatar
Roberto Togni committed
1768

1769
#if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1770

1771 1772 1773 1774
/**
 * Context for MP3On4 decoder
 */
typedef struct MP3On4DecodeContext {
1775 1776 1777
    int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)
    int syncword;                   ///< syncword patch
    const uint8_t *coff;            ///< channel offsets in output buffer
1778 1779 1780
    MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
} MP3On4DecodeContext;

1781 1782
#include "mpeg4audio.h"

1783
/* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1784 1785 1786 1787

/* number of mp3 decoder instances */
static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };

1788
/* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1789
static const uint8_t chan_offset[8][5] = {
1790 1791 1792 1793 1794 1795 1796 1797
    { 0             },
    { 0             },  // C
    { 0             },  // FLR
    { 2, 0          },  // C FLR
    { 2, 0, 3       },  // C FLR BS
    { 2, 0, 3       },  // C FLR BLRS
    { 2, 0, 4, 3    },  // C FLR BLRS LFE
    { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE
1798 1799
};

1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810
/* mp3on4 channel layouts */
static const int16_t chan_layout[8] = {
    0,
    AV_CH_LAYOUT_MONO,
    AV_CH_LAYOUT_STEREO,
    AV_CH_LAYOUT_SURROUND,
    AV_CH_LAYOUT_4POINT0,
    AV_CH_LAYOUT_5POINT0,
    AV_CH_LAYOUT_5POINT1,
    AV_CH_LAYOUT_7POINT1
};
1811

1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
{
    MP3On4DecodeContext *s = avctx->priv_data;
    int i;

    for (i = 0; i < s->frames; i++)
        av_free(s->mp3decctx[i]);

    return 0;
}


1824
static av_cold int decode_init_mp3on4(AVCodecContext * avctx)
1825 1826
{
    MP3On4DecodeContext *s = avctx->priv_data;
1827
    MPEG4AudioConfig cfg;
1828 1829 1830 1831
    int i;

    if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
        av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1832
        return AVERROR_INVALIDDATA;
1833 1834
    }

1835 1836
    avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
                                 avctx->extradata_size * 8, 1);
1837
    if (!cfg.chan_config || cfg.chan_config > 7) {
1838
        av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1839
        return AVERROR_INVALIDDATA;
1840
    }
1841 1842 1843
    s->frames             = mp3Frames[cfg.chan_config];
    s->coff               = chan_offset[cfg.chan_config];
    avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
1844
    avctx->channel_layout = chan_layout[cfg.chan_config];
1845

1846 1847 1848 1849 1850
    if (cfg.sample_rate < 16000)
        s->syncword = 0xffe00000;
    else
        s->syncword = 0xfff00000;

1851 1852 1853
    /* Init the first mp3 decoder in standard way, so that all tables get builded
     * We replace avctx->priv_data with the context of the first decoder so that
     * decode_init() does not have to be changed.
1854
     * Other decoders will be initialized here copying data from the first context
1855 1856 1857
     */
    // Allocate zeroed memory for the first decoder context
    s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1858 1859
    if (!s->mp3decctx[0])
        goto alloc_fail;
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
    // Put decoder context in place to make init_decode() happy
    avctx->priv_data = s->mp3decctx[0];
    decode_init(avctx);
    // Restore mp3on4 context pointer
    avctx->priv_data = s;
    s->mp3decctx[0]->adu_mode = 1; // Set adu mode

    /* Create a separate codec/context for each frame (first is already ok).
     * Each frame is 1 or 2 channels - up to 5 frames allowed
     */
    for (i = 1; i < s->frames; i++) {
        s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
1872 1873
        if (!s->mp3decctx[i])
            goto alloc_fail;
1874
        s->mp3decctx[i]->adu_mode = 1;
1875
        s->mp3decctx[i]->avctx = avctx;
1876
        s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1877 1878 1879
    }

    return 0;
1880 1881 1882
alloc_fail:
    decode_close_mp3on4(avctx);
    return AVERROR(ENOMEM);
1883 1884 1885
}


1886 1887 1888 1889 1890
static void flush_mp3on4(AVCodecContext *avctx)
{
    int i;
    MP3On4DecodeContext *s = avctx->priv_data;

1891 1892
    for (i = 0; i < s->frames; i++)
        mp_flush(s->mp3decctx[i]);
1893 1894 1895
}


1896 1897
static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
                               int *got_frame_ptr, AVPacket *avpkt)
1898
{
1899
    AVFrame *frame         = data;
1900 1901
    const uint8_t *buf     = avpkt->data;
    int buf_size           = avpkt->size;
1902 1903
    MP3On4DecodeContext *s = avctx->priv_data;
    MPADecodeContext *m;
1904
    int fsize, len = buf_size, out_size = 0;
1905
    uint32_t header;
1906 1907 1908
    OUT_INT **out_samples;
    OUT_INT *outptr[2];
    int fr, ch, ret;
1909

1910
    /* get output buffer */
1911
    frame->nb_samples = MPA_FRAME_SIZE;
1912
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1913 1914
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return ret;
1915
    }
1916
    out_samples = (OUT_INT **)frame->extended_data;
1917

1918
    // Discard too short frames
1919
    if (buf_size < HEADER_SIZE)
1920
        return AVERROR_INVALIDDATA;
1921

1922 1923
    avctx->bit_rate = 0;

1924
    ch = 0;
1925
    for (fr = 0; fr < s->frames; fr++) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1926
        fsize = AV_RB16(buf) >> 4;
1927
        fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1928 1929
        m     = s->mp3decctx[fr];
        assert(m != NULL);
1930

1931 1932 1933 1934
        if (fsize < HEADER_SIZE) {
            av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
            return AVERROR_INVALIDDATA;
        }
1935
        header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1936

1937 1938
        if (ff_mpa_check_header(header) < 0) // Bad header, discard block
            break;
1939

1940
        avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1941 1942 1943 1944 1945 1946 1947 1948

        if (ch + m->nb_channels > avctx->channels) {
            av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
                                        "channel count\n");
            return AVERROR_INVALIDDATA;
        }
        ch += m->nb_channels;

1949 1950 1951 1952
        outptr[0] = out_samples[s->coff[fr]];
        if (m->nb_channels > 1)
            outptr[1] = out_samples[s->coff[fr] + 1];

1953 1954 1955 1956
        if ((ret = mp_decode_frame(m, outptr, buf, fsize)) < 0)
            return ret;

        out_size += ret;
1957 1958
        buf      += fsize;
        len      -= fsize;
1959

1960
        avctx->bit_rate += m->bit_rate;
1961 1962 1963 1964 1965
    }

    /* update codec info */
    avctx->sample_rate = s->mp3decctx[0]->sample_rate;

1966 1967
    frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
    *got_frame_ptr    = 1;
1968

1969 1970
    return buf_size;
}
1971
#endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
1972

1973
#if !CONFIG_FLOAT
1974
#if CONFIG_MP1_DECODER
1975 1976 1977
AVCodec ff_mp1_decoder = {
    .name           = "mp1",
    .type           = AVMEDIA_TYPE_AUDIO,
1978
    .id             = AV_CODEC_ID_MP1,
1979 1980 1981
    .priv_data_size = sizeof(MPADecodeContext),
    .init           = decode_init,
    .decode         = decode_frame,
1982
    .capabilities   = CODEC_CAP_DR1,
1983 1984
    .flush          = flush,
    .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
1985 1986 1987
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_NONE },
1988 1989
};
#endif
1990
#if CONFIG_MP2_DECODER
1991 1992 1993
AVCodec ff_mp2_decoder = {
    .name           = "mp2",
    .type           = AVMEDIA_TYPE_AUDIO,
1994
    .id             = AV_CODEC_ID_MP2,
1995 1996 1997
    .priv_data_size = sizeof(MPADecodeContext),
    .init           = decode_init,
    .decode         = decode_frame,
1998
    .capabilities   = CODEC_CAP_DR1,
1999 2000
    .flush          = flush,
    .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
2001 2002 2003
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_NONE },
Fabrice Bellard's avatar
Fabrice Bellard committed
2004
};
2005
#endif
2006
#if CONFIG_MP3_DECODER
2007 2008 2009
AVCodec ff_mp3_decoder = {
    .name           = "mp3",
    .type           = AVMEDIA_TYPE_AUDIO,
2010
    .id             = AV_CODEC_ID_MP3,
2011 2012 2013
    .priv_data_size = sizeof(MPADecodeContext),
    .init           = decode_init,
    .decode         = decode_frame,
2014
    .capabilities   = CODEC_CAP_DR1,
2015 2016
    .flush          = flush,
    .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
2017 2018 2019
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_NONE },
2020
};
2021
#endif
2022
#if CONFIG_MP3ADU_DECODER
2023 2024 2025
AVCodec ff_mp3adu_decoder = {
    .name           = "mp3adu",
    .type           = AVMEDIA_TYPE_AUDIO,
2026
    .id             = AV_CODEC_ID_MP3ADU,
2027 2028 2029
    .priv_data_size = sizeof(MPADecodeContext),
    .init           = decode_init,
    .decode         = decode_frame_adu,
2030
    .capabilities   = CODEC_CAP_DR1,
2031 2032
    .flush          = flush,
    .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2033 2034 2035
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_NONE },
Roberto Togni's avatar
Roberto Togni committed
2036
};
2037
#endif
2038
#if CONFIG_MP3ON4_DECODER
2039 2040 2041
AVCodec ff_mp3on4_decoder = {
    .name           = "mp3on4",
    .type           = AVMEDIA_TYPE_AUDIO,
2042
    .id             = AV_CODEC_ID_MP3ON4,
2043 2044 2045 2046
    .priv_data_size = sizeof(MP3On4DecodeContext),
    .init           = decode_init_mp3on4,
    .close          = decode_close_mp3on4,
    .decode         = decode_frame_mp3on4,
2047
    .capabilities   = CODEC_CAP_DR1,
2048
    .flush          = flush_mp3on4,
2049
    .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
2050 2051
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_NONE },
2052
};
2053
#endif
2054
#endif