mpegaudiodec_template.c 65 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 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; 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"
31
#include "libavutil/libm.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
32
#include "avcodec.h"
33
#include "get_bits.h"
34
#include "internal.h"
35
#include "mathops.h"
36
#include "mpegaudiodsp.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
37 38

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

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

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

/* 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];
67
    DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
68 69 70 71
} GranuleDef;

typedef struct MPADecodeContext {
    MPA_DECODE_HEADER
72
    uint8_t last_buf[LAST_BUF_SIZE];
73
    int last_buf_size;
74
    int extrasize;
75 76 77 78
    /* next header (used in free format parsing) */
    uint32_t free_format_next_header;
    GetBitContext gb;
    GetBitContext in_gb;
79
    DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
80
    int synth_buf_offset[MPA_MAX_CHANNELS];
81
    DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
82 83 84 85
    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;
86
    int err_recognition;
87 88
    AVCodecContext* avctx;
    MPADSPContext mpadsp;
89
    AVFloatDSPContext *fdsp;
90
    AVFrame *frame;
91 92
} MPADecodeContext;

Fabrice Bellard's avatar
Fabrice Bellard committed
93 94
#define HEADER_SIZE 4

95
#include "mpegaudiodata.h"
96 97 98
#include "mpegaudiodectab.h"

/* vlc structure for decoding layer 3 huffman tables */
99
static VLC huff_vlc[16];
100
static VLC_TYPE huff_vlc_tables[
101 102
    0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
  142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
103 104
  ][2];
static const int huff_vlc_tables_sizes[16] = {
105 106
    0,  128,  128,  128,  130,  128,  154,  166,
  142,  204,  190,  170,  542,  460,  662,  414
107
};
108
static VLC huff_quad_vlc[2];
109 110
static VLC_TYPE  huff_quad_vlc_tables[128+16][2];
static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
111
/* computed from band_size_long */
112
static uint16_t band_index_long[9][23];
113
#include "mpegaudio_tablegen.h"
114
/* intensity stereo coef table */
115 116
static INTFLOAT is_table[2][16];
static INTFLOAT is_table_lsf[2][2][16];
117
static INTFLOAT csa_table[8][4];
118

119 120 121 122 123 124 125 126
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
};

127
/* lower 2 bits: modulo 3, higher bits: shift */
128
static uint16_t scale_factor_modshift[64];
129
/* [i][j]:  2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
130
static int32_t scale_factor_mult[15][3];
131 132 133
/* mult table for layer 2 group quantization */

#define SCALE_GEN(v) \
134
{ FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
135

Michael Niedermayer's avatar
Michael Niedermayer committed
136
static const int32_t scale_factor_mult2[3][3] = {
137 138 139
    SCALE_GEN(4.0 / 3.0), /* 3 steps */
    SCALE_GEN(4.0 / 5.0), /* 5 steps */
    SCALE_GEN(4.0 / 9.0), /* 9 steps */
140 141
};

142 143 144 145
/**
 * Convert region offsets to region sizes and truncate
 * size to big_values.
 */
146
static void region_offset2size(GranuleDef *g)
147 148 149 150
{
    int i, k, j = 0;
    g->region_size[2] = 576 / 2;
    for (i = 0; i < 3; i++) {
151 152 153 154 155 156
        k = FFMIN(g->region_size[i], g->big_values);
        g->region_size[i] = k - j;
        j = k;
    }
}

157
static void init_short_region(MPADecodeContext *s, GranuleDef *g)
158
{
159 160 161 162 163 164
    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 {
165 166 167 168 169 170 171 172 173 174
        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);
}

175 176
static void init_long_region(MPADecodeContext *s, GranuleDef *g,
                             int ra1, int ra2)
177
{
178
    int l;
179
    g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
180 181
    /* should not overflow */
    l = FFMIN(ra1 + ra2 + 2, 22);
182
    g->region_size[1] = band_index_long[s->sample_rate_index][      l] >> 1;
183 184
}

185
static void compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
186
{
187 188
    if (g->block_type == 2) {
        if (g->switch_point) {
189
            if(s->sample_rate_index == 8)
190
                avpriv_request_sample(s->avctx, "switch point in 8khz");
191
            /* if switched mode, we handle the 36 first samples as
192 193
                long blocks.  For 8000Hz, we handle the 72 first
                exponents as long blocks */
194 195 196
            if (s->sample_rate_index <= 2)
                g->long_end = 8;
            else
197
                g->long_end = 6;
198

199
            g->short_start = 3;
200
        } else {
201
            g->long_end    = 0;
202 203 204 205
            g->short_start = 0;
        }
    } else {
        g->short_start = 13;
206
        g->long_end    = 22;
207 208 209
    }
}

210 211 212 213 214
/* 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;
215
    int64_t val;
216

217 218
    shift   = scale_factor_modshift[scale_factor];
    mod     = shift & 3;
219
    shift >>= 2;
220
    val     = MUL64((int)(mant + (-1U << n) + 1), scale_factor_mult[n-1][mod]);
221
    shift  += n;
222 223
    /* NOTE: at this point, 1 <= shift >= 21 + 15 */
    return (int)((val + (1LL << (shift - 1))) >> shift);
224 225 226 227 228 229
}

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

230 231
    shift   = scale_factor_modshift[scale_factor];
    mod     = shift & 3;
232
    shift >>= 2;
233 234 235 236 237 238

    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;
239 240 241 242 243 244 245 246
}

/* 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;

247 248 249
    e  = table_4_3_exp  [4 * value + (exponent & 3)];
    m  = table_4_3_value[4 * value + (exponent & 3)];
    e -= exponent >> 2;
250 251
#ifdef DEBUG
    if(e < 1)
252
        av_log(NULL, AV_LOG_WARNING, "l3_unscale: e is %d\n", e);
253
#endif
254
    if (e > (SUINT)31)
255
        return 0;
256
    m = (m + ((1U << e)>>1)) >> e;
257

258 259 260
    return m;
}

261
static av_cold void decode_init_static(void)
Fabrice Bellard's avatar
Fabrice Bellard committed
262
{
263
    int i, j, k;
Justin Ruggles's avatar
Justin Ruggles committed
264 265 266 267 268 269 270 271 272 273
    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);
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
274

Justin Ruggles's avatar
Justin Ruggles committed
275 276 277 278 279 280 281 282
    /* 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);
283 284
        ff_dlog(NULL, "%d: norm=%x s=%"PRIx32" %"PRIx32" %"PRIx32"\n", i,
                (unsigned)norm,
Justin Ruggles's avatar
Justin Ruggles committed
285 286 287 288
                scale_factor_mult[i][0],
                scale_factor_mult[i][1],
                scale_factor_mult[i][2]);
    }
289

Justin Ruggles's avatar
Justin Ruggles committed
290
    RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
291

Justin Ruggles's avatar
Justin Ruggles committed
292 293 294 295 296
    /* huffman decode tables */
    offset = 0;
    for (i = 1; i < 16; i++) {
        const HuffTable *h = &mpa_huff_tables[i];
        int xsize, x, y;
297 298
        uint8_t  tmp_bits [512] = { 0 };
        uint16_t tmp_codes[512] = { 0 };
299

Justin Ruggles's avatar
Justin Ruggles committed
300
        xsize = h->xsize;
301

Justin Ruggles's avatar
Justin Ruggles committed
302 303 304 305 306
        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++];
307 308 309
            }
        }

Justin Ruggles's avatar
Justin Ruggles committed
310 311 312 313 314 315 316 317
        /* 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];
    }
318
    av_assert0(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
Justin Ruggles's avatar
Justin Ruggles committed
319 320 321 322 323 324 325 326 327 328

    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];
    }
329
    av_assert0(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
Justin Ruggles's avatar
Justin Ruggles committed
330 331 332 333 334 335

    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];
336
        }
Justin Ruggles's avatar
Justin Ruggles committed
337 338
        band_index_long[i][22] = k;
    }
339

Justin Ruggles's avatar
Justin Ruggles committed
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
    /* 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);
355 356
            }
        }
Justin Ruggles's avatar
Justin Ruggles committed
357
    }
358 359


Justin Ruggles's avatar
Justin Ruggles committed
360 361 362 363 364 365 366 367
    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);
368
        }
Justin Ruggles's avatar
Justin Ruggles committed
369 370 371 372 373 374 375 376 377 378 379 380 381
        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);
382
            f = exp2(e / 4.0);
Justin Ruggles's avatar
Justin Ruggles committed
383 384 385
            k = i & 1;
            is_table_lsf[j][k ^ 1][i] = FIXR(f);
            is_table_lsf[j][k    ][i] = FIXR(1.0);
386
            ff_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
Justin Ruggles's avatar
Justin Ruggles committed
387 388
                    i, j, (float) is_table_lsf[j][0][i],
                    (float) is_table_lsf[j][1][i]);
389
        }
Justin Ruggles's avatar
Justin Ruggles committed
390
    }
391

Justin Ruggles's avatar
Justin Ruggles committed
392
    for (i = 0; i < 8; i++) {
393
        double ci, cs, ca;
Justin Ruggles's avatar
Justin Ruggles committed
394 395 396
        ci = ci_table[i];
        cs = 1.0 / sqrt(1.0 + ci * ci);
        ca = cs * ci;
397
#if !USE_FLOATS
Justin Ruggles's avatar
Justin Ruggles committed
398 399 400 401
        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);
402
#else
Justin Ruggles's avatar
Justin Ruggles committed
403 404 405 406
        csa_table[i][0] = cs;
        csa_table[i][1] = ca;
        csa_table[i][2] = ca + cs;
        csa_table[i][3] = ca - cs;
407
#endif
Justin Ruggles's avatar
Justin Ruggles committed
408
    }
409
}
410

411 412 413 414 415 416 417 418 419 420
#if USE_FLOATS
static av_cold int decode_close(AVCodecContext * avctx)
{
    MPADecodeContext *s = avctx->priv_data;
    av_freep(&s->fdsp);

    return 0;
}
#endif

421 422
static av_cold int decode_init(AVCodecContext * avctx)
{
423
    static int initialized_tables = 0;
424 425
    MPADecodeContext *s = avctx->priv_data;

426 427 428 429 430
    if (!initialized_tables) {
        decode_init_static();
        initialized_tables = 1;
    }

431 432
    s->avctx = avctx;

433
#if USE_FLOATS
434
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
435 436
    if (!s->fdsp)
        return AVERROR(ENOMEM);
437
#endif
438

439 440
    ff_mpadsp_init(&s->mpadsp);

441 442 443 444 445
    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;
446
    s->err_recognition = avctx->err_recognition;
Fabrice Bellard's avatar
Fabrice Bellard committed
447

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

Fabrice Bellard's avatar
Fabrice Bellard committed
451 452 453
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
454
#define C3 FIXHR(0.86602540378443864676/2)
455 456 457
#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)
458

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

465 466 467 468 469 470
    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
471 472 473
    in5 += in3;
    in3 += in1;

474 475 476 477
    in2  = MULH3(in2, C3, 2);
    in3  = MULH3(in3, C3, 4);

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

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

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

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

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

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

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

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

537
    /* compute samples */
538 539 540
    for (j = 0; j < 12; j++) {
        for (i = 0; i < bound; i++) {
            for (ch = 0; ch < s->nb_channels; ch++) {
541 542 543 544 545 546 547 548 549 550
                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;
            }
        }
551
        for (i = bound; i < SBLIMIT; i++) {
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
            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
577

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

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

589
    ff_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
590 591

    /* sanity check */
592 593
    if (bound > sblimit)
        bound = sblimit;
594

595 596
    /* parse bit allocation */
    j = 0;
597
    for (i = 0; i < bound; i++) {
598
        bit_alloc_bits = alloc_table[j];
599
        for (ch = 0; ch < s->nb_channels; ch++)
600 601 602
            bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
        j += 1 << bit_alloc_bits;
    }
603
    for (i = bound; i < sblimit; i++) {
604 605 606 607 608
        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
609
    }
610 611

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

619
    /* scale factors */
620 621
    for (i = 0; i < sblimit; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
622 623
            if (bit_alloc[ch][i]) {
                sf = scale_factors[ch][i];
624
                switch (scale_code[ch][i]) {
625 626 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
                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 */
652 653
    for (k = 0; k < 3; k++) {
        for (l = 0; l < 12; l += 3) {
654
            j = 0;
655
            for (i = 0; i < bound; i++) {
656
                bit_alloc_bits = alloc_table[j];
657
                for (ch = 0; ch < s->nb_channels; ch++) {
658 659 660 661
                    b = bit_alloc[ch][i];
                    if (b) {
                        scale = scale_factors[ch][i][k];
                        qindex = alloc_table[j+b];
662
                        bits = ff_mpa_quant_bits[qindex];
663
                        if (bits < 0) {
664
                            int v2;
665 666
                            /* 3 values at the same time */
                            v = get_bits(&s->gb, -bits);
667 668 669
                            v2 = division_tabs[qindex][v];
                            steps  = ff_mpa_quant_steps[qindex];

670
                            s->sb_samples[ch][k * 12 + l + 0][i] =
671
                                l2_unscale_group(steps,  v2       & 15, scale);
672
                            s->sb_samples[ch][k * 12 + l + 1][i] =
673
                                l2_unscale_group(steps, (v2 >> 4) & 15, scale);
674
                            s->sb_samples[ch][k * 12 + l + 2][i] =
675
                                l2_unscale_group(steps,  v2 >> 8      , scale);
676
                        } else {
677
                            for (m = 0; m < 3; m++) {
678 679 680 681 682 683 684 685 686 687 688 689
                                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 */
690
                j += 1 << bit_alloc_bits;
691 692
            }
            /* XXX: find a way to avoid this duplication of code */
693
            for (i = bound; i < sblimit; i++) {
694 695 696 697 698 699 700
                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];
701
                    bits = ff_mpa_quant_bits[qindex];
702 703 704
                    if (bits < 0) {
                        /* 3 values at the same time */
                        v = get_bits(&s->gb, -bits);
705
                        steps = ff_mpa_quant_steps[qindex];
706 707
                        mant = v % steps;
                        v = v / steps;
708
                        s->sb_samples[0][k * 12 + l + 0][i] =
709
                            l2_unscale_group(steps, mant, scale0);
710
                        s->sb_samples[1][k * 12 + l + 0][i] =
711 712 713
                            l2_unscale_group(steps, mant, scale1);
                        mant = v % steps;
                        v = v / steps;
714
                        s->sb_samples[0][k * 12 + l + 1][i] =
715
                            l2_unscale_group(steps, mant, scale0);
716
                        s->sb_samples[1][k * 12 + l + 1][i] =
717
                            l2_unscale_group(steps, mant, scale1);
718
                        s->sb_samples[0][k * 12 + l + 2][i] =
719
                            l2_unscale_group(steps, v, scale0);
720
                        s->sb_samples[1][k * 12 + l + 2][i] =
721 722
                            l2_unscale_group(steps, v, scale1);
                    } else {
723
                        for (m = 0; m < 3; m++) {
724
                            mant = get_bits(&s->gb, bits);
725
                            s->sb_samples[0][k * 12 + l + m][i] =
726
                                l1_unscale(bits - 1, mant, scale0);
727
                            s->sb_samples[1][k * 12 + l + m][i] =
728 729 730 731 732 733 734 735 736 737 738 739
                                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 */
740
                j += 1 << bit_alloc_bits;
741 742
            }
            /* fill remaining samples to zero */
743 744
            for (i = sblimit; i < SBLIMIT; i++) {
                for (ch = 0; ch < s->nb_channels; ch++) {
745 746 747 748 749 750 751 752
                    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
753 754
}

755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
#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;                    \
773 774
    }

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

784
static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
785
                                         int16_t *exponents)
786
{
787
    const uint8_t *bstab, *pretab;
788
    int len, i, j, k, l, v0, shift, gain, gains[3];
789
    int16_t *exp_ptr;
790 791

    exp_ptr = exponents;
792 793
    gain    = g->global_gain - 210;
    shift   = g->scalefac_scale + 1;
794

795
    bstab  = band_size_long[s->sample_rate_index];
796
    pretab = mpa_pretab[g->preflag];
797
    for (i = 0; i < g->long_end; i++) {
798
        v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
799
        len = bstab[i];
800
        for (j = len; j > 0; j--)
801 802 803 804
            *exp_ptr++ = v0;
    }

    if (g->short_start < 13) {
805
        bstab    = band_size_short[s->sample_rate_index];
806 807 808
        gains[0] = gain - (g->subblock_gain[0] << 3);
        gains[1] = gain - (g->subblock_gain[1] << 3);
        gains[2] = gain - (g->subblock_gain[2] << 3);
809 810
        k        = g->long_end;
        for (i = g->short_start; i < 13; i++) {
811
            len = bstab[i];
812
            for (l = 0; l < 3; l++) {
813
                v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
814 815
                for (j = len; j > 0; j--)
                    *exp_ptr++ = v0;
816 817 818 819 820
            }
        }
    }
}

821 822 823
static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
                          int *end_pos2)
{
824
    if (s->in_gb.buffer && *pos >= s->gb.size_in_bits - s->extrasize * 8) {
825 826
        s->gb           = s->in_gb;
        s->in_gb.buffer = NULL;
827
        s->extrasize    = 0;
828
        av_assert2((get_bits_count(&s->gb) & 7) == 0);
829
        skip_bits_long(&s->gb, *pos - *end_pos);
830 831 832
        *end_pos2 =
        *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
        *pos      = get_bits_count(&s->gb);
833 834 835
    }
}

Lou Logan's avatar
Lou Logan committed
836
/* Following is an optimized code for
837 838 839 840 841
            INTFLOAT v = *src
            if(get_bits1(&s->gb))
                v = -v;
            *dst = v;
*/
842
#if USE_FLOATS
843 844 845
#define READ_FLIP_SIGN(dst,src)                     \
    v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \
    AV_WN32A(dst, v);
846
#else
847 848 849
#define READ_FLIP_SIGN(dst,src)     \
    v      = -get_bits1(&s->gb);    \
    *(dst) = (*(src) ^ v) - v;
850 851
#endif

852
static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
853
                          int16_t *exponents, int end_pos2)
854 855
{
    int s_index;
856
    int i;
857
    int last_pos, bits_left;
858
    VLC *vlc;
859
    int end_pos = FFMIN(end_pos2, s->gb.size_in_bits - s->extrasize * 8);
860 861 862

    /* low frequencies (called big values) */
    s_index = 0;
863
    for (i = 0; i < 3; i++) {
864
        int j, k, l, linbits;
865 866 867 868
        j = g->region_size[i];
        if (j == 0)
            continue;
        /* select vlc table */
869 870
        k       = g->table_select[i];
        l       = mpa_huff_data[k][0];
871
        linbits = mpa_huff_data[k][1];
872
        vlc     = &huff_vlc[l];
873

874 875 876
        if (!l) {
            memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
            s_index += 2 * j;
877 878 879
            continue;
        }

880
        /* read huffcode and compute each couple */
881
        for (; j > 0; j--) {
882
            int exponent, x, y;
883
            int v;
884
            int pos = get_bits_count(&s->gb);
885 886

            if (pos >= end_pos){
887
                switch_buffer(s, &pos, &end_pos, &end_pos2);
888
                if (pos >= end_pos)
889 890
                    break;
            }
891
            y = get_vlc2(&s->gb, vlc->table, 7, 3);
892

893
            if (!y) {
894 895 896 897 898 899
                g->sb_hybrid[s_index  ] =
                g->sb_hybrid[s_index+1] = 0;
                s_index += 2;
                continue;
            }

900
            exponent= exponents[s_index];
901

902 903
            ff_dlog(s->avctx, "region=%d n=%d y=%d exp=%d\n",
                    i, g->region_size[i] - j, y, exponent);
904
            if (y & 16) {
Michael Niedermayer's avatar
Michael Niedermayer committed
905 906
                x = y >> 5;
                y = y & 0x0f;
907 908 909
                if (x < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
                } else {
910
                    x += get_bitsz(&s->gb, linbits);
911
                    v  = l3_unscale(x, exponent);
912 913 914
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index] = v;
915
                }
916 917 918
                if (y < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
                } else {
919
                    y += get_bitsz(&s->gb, linbits);
920
                    v  = l3_unscale(y, exponent);
921 922 923
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index+1] = v;
924
                }
925
            } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
926 927 928
                x = y >> 5;
                y = y & 0x0f;
                x += y;
929 930 931
                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
932
                    x += get_bitsz(&s->gb, linbits);
933
                    v  = l3_unscale(x, exponent);
934 935 936
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index+!!y] = v;
Michael Niedermayer's avatar
Michael Niedermayer committed
937
                }
938
                g->sb_hybrid[s_index + !y] = 0;
939
            }
940
            s_index += 2;
941 942
        }
    }
943

944 945
    /* high frequencies */
    vlc = &huff_quad_vlc[g->count1table_select];
946
    last_pos = 0;
947
    while (s_index <= 572) {
948
        int pos, code;
949 950
        pos = get_bits_count(&s->gb);
        if (pos >= end_pos) {
951
            if (pos > end_pos2 && last_pos) {
952 953 954 955
                /* 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);
956
                av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
957
                if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
958
                    s_index=0;
959 960
                break;
            }
961
            switch_buffer(s, &pos, &end_pos, &end_pos2);
962
            if (pos >= end_pos)
963
                break;
964
        }
965
        last_pos = pos;
966

967
        code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
968
        ff_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
969 970 971 972 973 974
        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 };
975
            int v;
976 977 978
            int pos = s_index + idxtab[code];
            code   ^= 8 >> idxtab[code];
            READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
979
        }
980
        s_index += 4;
981
    }
982
    /* skip extension bits */
983
    bits_left = end_pos2 - get_bits_count(&s->gb);
984
    if (bits_left < 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_COMPLIANT))) {
985
        av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
986
        s_index=0;
987
    } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) {
988
        av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
989
        s_index = 0;
990
    }
991
    memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
992 993
    skip_bits_long(&s->gb, bits_left);

994
    i = get_bits_count(&s->gb);
995
    switch_buffer(s, &i, &end_pos, &end_pos2);
996

Fabrice Bellard's avatar
Fabrice Bellard committed
997 998 999
    return 0;
}

1000 1001 1002 1003 1004
/* 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)
{
1005
    int i, j, len;
1006 1007
    INTFLOAT *ptr, *dst, *ptr1;
    INTFLOAT tmp[576];
1008 1009 1010 1011 1012

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

    if (g->switch_point) {
1013
        if (s->sample_rate_index != 8)
1014
            ptr = g->sb_hybrid + 36;
1015
        else
1016
            ptr = g->sb_hybrid + 72;
1017 1018 1019
    } else {
        ptr = g->sb_hybrid;
    }
1020

1021 1022
    for (i = g->short_start; i < 13; i++) {
        len  = band_size_short[s->sample_rate_index][i];
1023
        ptr1 = ptr;
1024 1025
        dst  = tmp;
        for (j = len; j > 0; j--) {
1026 1027 1028 1029
            *dst++ = ptr[0*len];
            *dst++ = ptr[1*len];
            *dst++ = ptr[2*len];
            ptr++;
1030
        }
1031
        ptr += 2 * len;
1032
        memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1033 1034 1035 1036 1037
    }
}

#define ISQRT2 FIXR(0.70710678118654752440)

1038
static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1039 1040
{
    int i, j, k, l;
1041
    int sf_max, sf, len, non_zero_found;
1042 1043
    INTFLOAT (*is_tab)[16], *tab0, *tab1, v1, v2;
    SUINTFLOAT tmp0, tmp1;
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
    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;
        }
1055

1056 1057 1058 1059 1060 1061 1062
        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;
1063
        for (i = 12; i >= g1->short_start; i--) {
1064 1065 1066 1067
            /* for last band, use previous scale factor */
            if (i != 11)
                k -= 3;
            len = band_size_short[s->sample_rate_index][i];
1068
            for (l = 2; l >= 0; l--) {
1069 1070 1071 1072
                tab0 -= len;
                tab1 -= len;
                if (!non_zero_found_short[l]) {
                    /* test if non zero band. if so, stop doing i-stereo */
1073
                    for (j = 0; j < len; j++) {
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
                        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];
1085 1086
                    for (j = 0; j < len; j++) {
                        tmp0    = tab0[j];
1087 1088
                        tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
                        tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
1089 1090
                    }
                } else {
1091
found1:
1092 1093 1094
                    if (s->mode_ext & MODE_EXT_MS_STEREO) {
                        /* lower part of the spectrum : do ms stereo
                           if enabled */
1095 1096 1097
                        for (j = 0; j < len; j++) {
                            tmp0    = tab0[j];
                            tmp1    = tab1[j];
1098 1099
                            tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
                            tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
1100 1101 1102 1103 1104 1105
                        }
                    }
                }
            }
        }

1106
        non_zero_found = non_zero_found_short[0] |
1107 1108
                         non_zero_found_short[1] |
                         non_zero_found_short[2];
1109

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

1167
#if USE_FLOATS
1168 1169 1170 1171
#if HAVE_MIPSFPU
#   include "mips/compute_antialias_float.h"
#endif /* HAVE_MIPSFPU */
#else
1172
#if HAVE_MIPSDSP
1173
#   include "mips/compute_antialias_fixed.h"
1174
#endif /* HAVE_MIPSDSP */
1175
#endif /* USE_FLOATS */
1176 1177

#ifndef compute_antialias
1178
#if USE_FLOATS
1179 1180 1181 1182 1183 1184 1185 1186
#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 {                                              \
1187 1188 1189
        SUINT tmp0 = ptr[-1-j];                                   \
        SUINT tmp1 = ptr[   j];                                   \
        SUINT tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
1190 1191
        ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
        ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
1192 1193 1194 1195
    } while (0)
#endif

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

    /* 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;
    }
1209

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

        ptr += 18;
1222 1223
    }
}
1224
#endif /* compute_antialias */
1225

1226 1227
static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
                          INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1228
{
1229
    INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1230 1231
    INTFLOAT out2[12];
    int i, j, mdct_long_end, sblimit;
1232 1233

    /* find last non zero block */
1234
    ptr  = g->sb_hybrid + 576;
1235 1236
    ptr1 = g->sb_hybrid + 2 * 18;
    while (ptr >= ptr1) {
1237
        int32_t *p;
1238
        ptr -= 6;
1239 1240
        p    = (int32_t*)ptr;
        if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
            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;
    }

1255 1256 1257 1258 1259 1260 1261
    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;

1262
    for (j = mdct_long_end; j < sblimit; j++) {
1263
        /* select frequency inversion */
1264
        win     = RENAME(ff_mdct_win)[2 + (4  & -(j & 1))];
1265
        out_ptr = sb_samples + j;
1266

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

/* main layer3 decoding function */
static int mp_decode_layer3(MPADecodeContext *s)
{
1308
    int nb_granules, main_data_begin;
1309
    int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1310
    GranuleDef *g;
1311
    int16_t exponents[576]; //FIXME try INTFLOAT
1312 1313 1314 1315

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

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

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

1381 1382
            g->preflag = 0;
            if (!s->lsf)
1383
                g->preflag = get_bits1(&s->gb);
1384
            g->scalefac_scale     = get_bits1(&s->gb);
1385
            g->count1table_select = get_bits1(&s->gb);
1386
            ff_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1387 1388 1389 1390
                    g->block_type, g->switch_point);
        }
    }

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

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

1427
    for (; gr < nb_granules; gr++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1428
        for (ch = 0; ch < s->nb_channels; ch++) {
1429
            g = &s->granules[ch][gr];
1430
            bits_pos = get_bits_count(&s->gb);
1431

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

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

                /* LSF scale factors */
1487
                if (g->block_type == 2)
1488
                    tindex = g->switch_point ? 2 : 1;
1489
                else
1490
                    tindex = 0;
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 1518 1519 1520 1521
                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;
1522 1523
                for (k = 0; k < 4; k++) {
                    n  = lsf_nsf_table[tindex2][tindex][k];
1524
                    sl = slen[k];
1525 1526
                    if (sl) {
                        for (i = 0; i < n; i++)
1527
                            g->scale_factors[j++] = get_bits(&s->gb, sl);
1528 1529
                    } else {
                        for (i = 0; i < n; i++)
1530 1531
                            g->scale_factors[j++] = 0;
                    }
1532 1533
                }
                /* XXX: should compute exact size */
1534
                for (; j < 40; j++)
1535 1536 1537 1538 1539 1540
                    g->scale_factors[j] = 0;
            }

            exponents_from_scale_factors(s, g, exponents);

            /* read Huffman coded residue */
1541
            huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1542 1543
        } /* ch */

1544
        if (s->mode == MPA_JSTEREO)
1545
            compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1546

1547
        for (ch = 0; ch < s->nb_channels; ch++) {
1548
            g = &s->granules[ch][gr];
1549 1550

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

1560
static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
1561
                           const uint8_t *buf, int buf_size)
1562
{
1563
    int i, nb_frames, ch, ret;
1564
    OUT_INT *samples_ptr;
1565

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

1568 1569
    /* skip error protection field */
    if (s->error_protection)
1570
        skip_bits(&s->gb, 16);
1571 1572 1573

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

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

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

1613 1614 1615
    if(nb_frames < 0)
        return nb_frames;

1616 1617
    /* get output buffer */
    if (!samples) {
1618
        av_assert0(s->frame);
1619
        s->frame->nb_samples = s->avctx->frame_size;
1620
        if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0)
1621
            return ret;
1622
        samples = (OUT_INT **)s->frame->extended_data;
1623
    }
1624

1625
    /* apply the synthesis filter */
1626
    for (ch = 0; ch < s->nb_channels; ch++) {
1627 1628 1629 1630 1631 1632 1633 1634
        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;
        }
1635
        for (i = 0; i < nb_frames; i++) {
1636 1637 1638 1639 1640 1641
            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;
1642 1643
        }
    }
1644

1645
    return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1646 1647
}

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

wm4's avatar
wm4 committed
1657
    int skipped = 0;
1658
    while(buf_size && !*buf){
1659
        buf++;
1660
        buf_size--;
wm4's avatar
wm4 committed
1661
        skipped++;
1662
    }
1663

1664
    if (buf_size < HEADER_SIZE)
1665
        return AVERROR_INVALIDDATA;
1666

1667
    header = AV_RB32(buf);
1668 1669
    if (header>>8 == AV_RB32("TAG")>>8) {
        av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
1670
        return buf_size + skipped;
1671
    }
1672 1673
    ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
    if (ret < 0) {
1674
        av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1675
        return AVERROR_INVALIDDATA;
1676
    } else if (ret == 1) {
1677 1678
        /* free format: prepare to compute frame size */
        s->frame_size = -1;
1679
        return AVERROR_INVALIDDATA;
1680 1681
    }
    /* update codec info */
1682
    avctx->channels       = s->nb_channels;
1683
    avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1684 1685
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
1686

1687
    if (s->frame_size <= 0) {
1688
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1689
        return AVERROR_INVALIDDATA;
1690
    } else if (s->frame_size < buf_size) {
1691
        av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
1692
        buf_size= s->frame_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
1693
    }
1694

1695 1696
    s->frame = data;

1697 1698
    ret = mp_decode_frame(s, NULL, buf, buf_size);
    if (ret >= 0) {
1699 1700 1701
        s->frame->nb_samples = avctx->frame_size;
        *got_frame_ptr       = 1;
        avctx->sample_rate   = s->sample_rate;
1702
        //FIXME maybe move the other codec info stuff from above here too
1703 1704
    } else {
        av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1705 1706 1707 1708 1709
        /* 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. */
1710
        *got_frame_ptr = 0;
1711 1712
        if (buf_size == avpkt->size || ret != AVERROR_INVALIDDATA)
            return ret;
1713
    }
1714
    s->frame_size = 0;
wm4's avatar
wm4 committed
1715
    return buf_size + skipped;
Fabrice Bellard's avatar
Fabrice Bellard committed
1716 1717
}

1718 1719 1720
static void mp_flush(MPADecodeContext *ctx)
{
    memset(ctx->synth_buf, 0, sizeof(ctx->synth_buf));
1721
    memset(ctx->mdct_buf, 0, sizeof(ctx->mdct_buf));
1722
    ctx->last_buf_size = 0;
1723
    ctx->dither_state = 0;
1724 1725
}

1726 1727
static void flush(AVCodecContext *avctx)
{
1728
    mp_flush(avctx->priv_data);
1729 1730
}

1731
#if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1732 1733
static int decode_frame_adu(AVCodecContext *avctx, void *data,
                            int *got_frame_ptr, AVPacket *avpkt)
Roberto Togni's avatar
Roberto Togni committed
1734
{
1735 1736
    const uint8_t *buf  = avpkt->data;
    int buf_size        = avpkt->size;
Roberto Togni's avatar
Roberto Togni committed
1737 1738
    MPADecodeContext *s = avctx->priv_data;
    uint32_t header;
1739
    int len, ret;
1740
    int av_unused out_size;
Roberto Togni's avatar
Roberto Togni committed
1741 1742 1743 1744 1745

    len = buf_size;

    // Discard too short frames
    if (buf_size < HEADER_SIZE) {
1746 1747
        av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
        return AVERROR_INVALIDDATA;
Roberto Togni's avatar
Roberto Togni committed
1748 1749 1750 1751 1752 1753 1754
    }


    if (len > MPA_MAX_CODED_FRAME_SIZE)
        len = MPA_MAX_CODED_FRAME_SIZE;

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

1757 1758
    ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
    if (ret < 0) {
1759
        av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
1760
        return ret;
Roberto Togni's avatar
Roberto Togni committed
1761 1762 1763
    }
    /* update codec info */
    avctx->sample_rate = s->sample_rate;
1764
    avctx->channels    = s->nb_channels;
1765
    avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1766 1767
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
Roberto Togni's avatar
Roberto Togni committed
1768

1769
    s->frame_size = len;
Roberto Togni's avatar
Roberto Togni committed
1770

1771 1772
    s->frame = data;

1773 1774
    ret = mp_decode_frame(s, NULL, buf, buf_size);
    if (ret < 0) {
1775
        av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
1776
        return ret;
1777
    }
1778

1779
    *got_frame_ptr = 1;
Roberto Togni's avatar
Roberto Togni committed
1780 1781 1782

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

1785
#if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1786

1787 1788 1789 1790
/**
 * Context for MP3On4 decoder
 */
typedef struct MP3On4DecodeContext {
1791 1792 1793
    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
1794 1795 1796
    MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
} MP3On4DecodeContext;

1797 1798
#include "mpeg4audio.h"

1799
/* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1800 1801 1802 1803

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

1804
/* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1805
static const uint8_t chan_offset[8][5] = {
1806 1807 1808 1809 1810 1811 1812 1813
    { 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
1814 1815
};

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
/* 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
};
1827

1828 1829 1830 1831 1832
static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
{
    MP3On4DecodeContext *s = avctx->priv_data;
    int i;

1833 1834 1835
    if (s->mp3decctx[0])
        av_freep(&s->mp3decctx[0]->fdsp);

1836
    for (i = 0; i < s->frames; i++)
1837
        av_freep(&s->mp3decctx[i]);
1838 1839 1840 1841

    return 0;
}

1842

1843
static av_cold int decode_init_mp3on4(AVCodecContext * avctx)
1844 1845
{
    MP3On4DecodeContext *s = avctx->priv_data;
1846
    MPEG4AudioConfig cfg;
1847 1848
    int i;

1849
    if ((avctx->extradata_size < 2) || !avctx->extradata) {
1850
        av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
1851
        return AVERROR_INVALIDDATA;
1852 1853
    }

1854 1855
    avpriv_mpeg4audio_get_config2(&cfg, avctx->extradata,
                                  avctx->extradata_size, 1, avctx);
1856
    if (!cfg.chan_config || cfg.chan_config > 7) {
1857
        av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
1858
        return AVERROR_INVALIDDATA;
1859
    }
1860 1861 1862
    s->frames             = mp3Frames[cfg.chan_config];
    s->coff               = chan_offset[cfg.chan_config];
    avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
1863
    avctx->channel_layout = chan_layout[cfg.chan_config];
1864

1865 1866 1867 1868 1869
    if (cfg.sample_rate < 16000)
        s->syncword = 0xffe00000;
    else
        s->syncword = 0xfff00000;

1870 1871 1872
    /* 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.
1873
     * Other decoders will be initialized here copying data from the first context
1874 1875 1876
     */
    // Allocate zeroed memory for the first decoder context
    s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1877 1878
    if (!s->mp3decctx[0])
        goto alloc_fail;
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
    // 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));
1891 1892
        if (!s->mp3decctx[i])
            goto alloc_fail;
1893
        s->mp3decctx[i]->adu_mode = 1;
1894
        s->mp3decctx[i]->avctx = avctx;
1895
        s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1896
        s->mp3decctx[i]->fdsp = s->mp3decctx[0]->fdsp;
1897 1898 1899
    }

    return 0;
1900 1901 1902
alloc_fail:
    decode_close_mp3on4(avctx);
    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 1912
    for (i = 0; i < s->frames; i++)
        mp_flush(s->mp3decctx[i]);
1913 1914 1915
}


1916 1917
static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
                               int *got_frame_ptr, AVPacket *avpkt)
1918
{
1919
    AVFrame *frame         = data;
1920 1921
    const uint8_t *buf     = avpkt->data;
    int buf_size           = avpkt->size;
1922 1923
    MP3On4DecodeContext *s = avctx->priv_data;
    MPADecodeContext *m;
1924
    int fsize, len = buf_size, out_size = 0;
1925
    uint32_t header;
1926 1927 1928
    OUT_INT **out_samples;
    OUT_INT *outptr[2];
    int fr, ch, ret;
1929

1930
    /* get output buffer */
1931
    frame->nb_samples = MPA_FRAME_SIZE;
1932
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1933
        return ret;
1934
    out_samples = (OUT_INT **)frame->extended_data;
1935

1936
    // Discard too short frames
1937
    if (buf_size < HEADER_SIZE)
1938
        return AVERROR_INVALIDDATA;
1939

1940 1941
    avctx->bit_rate = 0;

1942
    ch = 0;
1943
    for (fr = 0; fr < s->frames; fr++) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1944
        fsize = AV_RB16(buf) >> 4;
1945
        fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
1946
        m     = s->mp3decctx[fr];
1947
        av_assert1(m);
1948

1949 1950 1951 1952
        if (fsize < HEADER_SIZE) {
            av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
            return AVERROR_INVALIDDATA;
        }
1953
        header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
1954

1955
        ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1956
        if (ret < 0) {
1957 1958 1959
            av_log(avctx, AV_LOG_ERROR, "Bad header, discard block\n");
            return AVERROR_INVALIDDATA;
        }
1960

1961 1962
        if (ch + m->nb_channels > avctx->channels ||
            s->coff[fr] + m->nb_channels > avctx->channels) {
1963 1964 1965 1966 1967 1968
            av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
                                        "channel count\n");
            return AVERROR_INVALIDDATA;
        }
        ch += m->nb_channels;

1969 1970 1971 1972
        outptr[0] = out_samples[s->coff[fr]];
        if (m->nb_channels > 1)
            outptr[1] = out_samples[s->coff[fr] + 1];

1973 1974 1975 1976 1977 1978 1979
        if ((ret = mp_decode_frame(m, outptr, buf, fsize)) < 0) {
            av_log(avctx, AV_LOG_ERROR, "failed to decode channel %d\n", ch);
            memset(outptr[0], 0, MPA_FRAME_SIZE*sizeof(OUT_INT));
            if (m->nb_channels > 1)
                memset(outptr[1], 0, MPA_FRAME_SIZE*sizeof(OUT_INT));
            ret = m->nb_channels * MPA_FRAME_SIZE*sizeof(OUT_INT);
        }
1980 1981

        out_size += ret;
1982 1983
        buf      += fsize;
        len      -= fsize;
1984

1985
        avctx->bit_rate += m->bit_rate;
1986
    }
1987 1988 1989 1990
    if (ch != avctx->channels) {
        av_log(avctx, AV_LOG_ERROR, "failed to decode all channels\n");
        return AVERROR_INVALIDDATA;
    }
1991 1992 1993 1994

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

1995 1996
    frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
    *got_frame_ptr    = 1;
1997

1998 1999
    return buf_size;
}
2000
#endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */