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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

257 258 259
    return m;
}

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

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

Justin Ruggles's avatar
Justin Ruggles committed
288
    RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
289

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

Justin Ruggles's avatar
Justin Ruggles committed
298
        xsize = h->xsize;
299

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

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

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

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

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


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

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

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

    return 0;
}
#endif

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

424 425 426 427 428
    if (!initialized_tables) {
        decode_init_static();
        initialized_tables = 1;
    }

429 430
    s->avctx = avctx;

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

437 438
    ff_mpadsp_init(&s->mpadsp);

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
449 450 451
    return 0;
}

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

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

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

472 473 474 475
    in2  = MULH3(in2, C3, 2);
    in3  = MULH3(in3, C3, 4);

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

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

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

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

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

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

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

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

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

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

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

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

    /* sanity check */
590 591
    if (bound > sblimit)
        bound = sblimit;
592

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

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

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

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

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

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

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

    exp_ptr = exponents;
790 791
    gain    = g->global_gain - 210;
    shift   = g->scalefac_scale + 1;
792

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

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

/* handle n = 0 too */
static inline int get_bitsz(GetBitContext *s, int n)
{
822
    return n ? get_bits(s, n) : 0;
823 824
}

825

826 827 828 829 830 831
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;
832
        av_assert2((get_bits_count(&s->gb) & 7) == 0);
833
        skip_bits_long(&s->gb, *pos - *end_pos);
834 835 836
        *end_pos2 =
        *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
        *pos      = get_bits_count(&s->gb);
837 838 839
    }
}

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

856
static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
857
                          int16_t *exponents, int end_pos2)
858 859
{
    int s_index;
860
    int i;
861
    int last_pos, bits_left;
862
    VLC *vlc;
863
    int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
864 865 866

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

878 879 880
        if (!l) {
            memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
            s_index += 2 * j;
881 882 883
            continue;
        }

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

            if (pos >= end_pos){
891
                switch_buffer(s, &pos, &end_pos, &end_pos2);
892
                if (pos >= end_pos)
893 894
                    break;
            }
895
            y = get_vlc2(&s->gb, vlc->table, 7, 3);
896

897
            if (!y) {
898 899 900 901 902 903
                g->sb_hybrid[s_index  ] =
                g->sb_hybrid[s_index+1] = 0;
                s_index += 2;
                continue;
            }

904
            exponent= exponents[s_index];
905

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

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

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

998
    i = get_bits_count(&s->gb);
999
    switch_buffer(s, &i, &end_pos, &end_pos2);
1000

Fabrice Bellard's avatar
Fabrice Bellard committed
1001 1002 1003
    return 0;
}

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

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

    if (g->switch_point) {
1017
        if (s->sample_rate_index != 8)
1018
            ptr = g->sb_hybrid + 36;
1019
        else
1020
            ptr = g->sb_hybrid + 72;
1021 1022 1023
    } else {
        ptr = g->sb_hybrid;
    }
1024

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

#define ISQRT2 FIXR(0.70710678118654752440)

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

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

1109
        non_zero_found = non_zero_found_short[0] |
1110 1111
                         non_zero_found_short[1] |
                         non_zero_found_short[2];
1112

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

1170
#if USE_FLOATS
1171 1172 1173 1174 1175 1176 1177
#if HAVE_MIPSFPU
#   include "mips/compute_antialias_float.h"
#endif /* HAVE_MIPSFPU */
#else
#if HAVE_MIPSDSPR1
#   include "mips/compute_antialias_fixed.h"
#endif /* HAVE_MIPSDSPR1 */
1178
#endif /* USE_FLOATS */
1179 1180

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

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

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

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

        ptr += 18;
1225 1226
    }
}
1227
#endif /* compute_antialias */
1228

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

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

1258 1259 1260 1261 1262 1263 1264
    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;

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

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

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

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

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

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

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

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

1403
        memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1404
        s->in_gb = s->gb;
1405
        init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1406
#if !UNCHECKED_BITSTREAM_READER
1407
        s->gb.size_in_bits_plus8 += FFMAX(extrasize, LAST_BUF_SIZE - s->last_buf_size) * 8;
1408
#endif
1409 1410 1411 1412 1413 1414
        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));
1415
                compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
            }
        }
        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);
            s->gb           = s->in_gb;
            s->in_gb.buffer = NULL;
        } else {
            skip_bits_long(&s->gb, skip);
        }
    } else {
        gr = 0;
1428
    }
1429

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

1435
            if (!s->lsf) {
1436
                uint8_t *sc;
1437 1438 1439 1440 1441
                int slen, slen1, slen2;

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

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

            exponents_from_scale_factors(s, g, exponents);

            /* read Huffman coded residue */
1544
            huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1545 1546
        } /* ch */

1547
        if (s->mode == MPA_JSTEREO)
1548
            compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1549

1550
        for (ch = 0; ch < s->nb_channels; ch++) {
1551
            g = &s->granules[ch][gr];
1552 1553

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

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

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

1571 1572
    /* skip error protection field */
    if (s->error_protection)
1573
        skip_bits(&s->gb, 16);
1574 1575 1576

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

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

1602
        align_get_bits(&s->gb);
1603
        av_assert1((get_bits_count(&s->gb) & 7) == 0);
1604
        i = get_bits_left(&s->gb) >> 3;
1605

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

1616 1617 1618
    if(nb_frames < 0)
        return nb_frames;

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

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

1648
    return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1649 1650
}

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

1660
    while(buf_size && !*buf){
1661
        buf++;
1662 1663
        buf_size--;
    }
1664

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

1668
    header = AV_RB32(buf);
1669 1670 1671 1672
    if (header>>8 == AV_RB32("TAG")>>8) {
        av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
        return buf_size;
    }
1673
    if (ff_mpa_check_header(header) < 0) {
1674
        av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1675
        return AVERROR_INVALIDDATA;
1676 1677
    }

1678
    if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
1679 1680
        /* free format: prepare to compute frame size */
        s->frame_size = -1;
1681
        return AVERROR_INVALIDDATA;
1682 1683
    }
    /* update codec info */
1684
    avctx->channels       = s->nb_channels;
1685
    avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1686 1687
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
1688

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

1697 1698
    s->frame = data;

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

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

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

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

    len = buf_size;

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


    if (len > MPA_MAX_CODED_FRAME_SIZE)
        len = MPA_MAX_CODED_FRAME_SIZE;

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

1759
    if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
1760 1761
        av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
        return AVERROR_INVALIDDATA;
Roberto Togni's avatar
Roberto Togni committed
1762 1763
    }

1764
    avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
Roberto Togni's avatar
Roberto Togni committed
1765 1766
    /* update codec info */
    avctx->sample_rate = s->sample_rate;
1767
    avctx->channels    = s->nb_channels;
1768
    avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1769 1770
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
Roberto Togni's avatar
Roberto Togni committed
1771

1772
    s->frame_size = len;
Roberto Togni's avatar
Roberto Togni committed
1773

1774 1775
    s->frame = data;

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

1782
    *got_frame_ptr = 1;
Roberto Togni's avatar
Roberto Togni committed
1783 1784 1785

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

1788
#if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1789

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

1800 1801
#include "mpeg4audio.h"

1802
/* Next 3 arrays are indexed by channel config number (passed via codecdata) */
1803 1804 1805 1806

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

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

1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
/* 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
};
1830

1831 1832 1833 1834 1835 1836
static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
{
    MP3On4DecodeContext *s = avctx->priv_data;
    int i;

    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_config(&cfg, avctx->extradata,
                                 avctx->extradata_size * 8, 1);
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 1897 1898
    }

    return 0;
1899 1900 1901
alloc_fail:
    decode_close_mp3on4(avctx);
    return AVERROR(ENOMEM);
1902 1903 1904
}


1905
static void flush_mp3on4(AVCodecContext *avctx)
1906 1907
{
    int i;
1908
    MP3On4DecodeContext *s = avctx->priv_data;
1909

1910 1911
    for (i = 0; i < s->frames; i++)
        mp_flush(s->mp3decctx[i]);
1912 1913 1914
}


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

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

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

1939 1940
    avctx->bit_rate = 0;

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

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

1954 1955 1956 1957
        if (ff_mpa_check_header(header) < 0) {
            av_log(avctx, AV_LOG_ERROR, "Bad header, discard block\n");
            return AVERROR_INVALIDDATA;
        }
1958

1959
        avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
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 */