mpegaudiodec_template.c 64.5 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 220
    val     = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
    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
        av_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
            av_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 391 392 393 394
    for (i = 0; i < 8; i++) {
        float ci, cs, ca;
        ci = ci_table[i];
        cs = 1.0 / sqrt(1.0 + ci * ci);
        ca = cs * ci;
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
static av_cold int decode_init(AVCodecContext * avctx)
{
411
    static int initialized_tables = 0;
412 413
    MPADecodeContext *s = avctx->priv_data;

414 415 416 417 418
    if (!initialized_tables) {
        decode_init_static();
        initialized_tables = 1;
    }

419 420
    s->avctx = avctx;

421
    avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
422 423
    ff_mpadsp_init(&s->mpadsp);

424 425 426 427 428
    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;
429
    s->err_recognition = avctx->err_recognition;
Fabrice Bellard's avatar
Fabrice Bellard committed
430

431
    if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
Roberto Togni's avatar
Roberto Togni committed
432
        s->adu_mode = 1;
433

Fabrice Bellard's avatar
Fabrice Bellard committed
434 435 436
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
437
#define C3 FIXHR(0.86602540378443864676/2)
438 439 440
#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)
441

442 443
/* 12 points IMDCT. We compute it "by hand" by factorizing obvious
   cases. */
444
static void imdct12(INTFLOAT *out, INTFLOAT *in)
445
{
446
    INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
447

448 449 450 451 452 453
    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
454 455 456
    in5 += in3;
    in3 += in1;

457 458 459 460
    in2  = MULH3(in2, C3, 2);
    in3  = MULH3(in3, C3, 4);

    t1   = in0 - in4;
461
    t2   = MULH3(in1 - in5, C4, 2);
462 463 464 465 466 467 468 469 470

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

    in0    += SHR(in4, 1);
    in4     = in0 + in2;
    in5    += 2*in1;
471
    in1     = MULH3(in5 + in3, C5, 1);
472 473 474 475 476 477
    out[ 8] =
    out[ 9] = in4 + in1;
    out[ 2] =
    out[ 3] = in4 - in1;

    in0    -= in2;
478
    in5     = MULH3(in5 - in3, C6, 2);
479 480 481 482
    out[ 0] =
    out[ 5] = in0 - in5;
    out[ 6] =
    out[11] = in0 + in5;
483 484 485 486
}

/* return the number of decoded frames */
static int mp_decode_layer1(MPADecodeContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
487
{
488
    int bound, i, v, n, ch, j, mant;
489 490
    uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
    uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
491

492
    if (s->mode == MPA_JSTEREO)
493 494 495 496 497
        bound = (s->mode_ext + 1) * 4;
    else
        bound = SBLIMIT;

    /* allocation bits */
498 499
    for (i = 0; i < bound; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
500 501 502
            allocation[ch][i] = get_bits(&s->gb, 4);
        }
    }
503
    for (i = bound; i < SBLIMIT; i++)
504 505 506
        allocation[0][i] = get_bits(&s->gb, 4);

    /* scale factors */
507 508
    for (i = 0; i < bound; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
509 510 511 512
            if (allocation[ch][i])
                scale_factors[ch][i] = get_bits(&s->gb, 6);
        }
    }
513
    for (i = bound; i < SBLIMIT; i++) {
514 515 516 517 518
        if (allocation[0][i]) {
            scale_factors[0][i] = get_bits(&s->gb, 6);
            scale_factors[1][i] = get_bits(&s->gb, 6);
        }
    }
519

520
    /* compute samples */
521 522 523
    for (j = 0; j < 12; j++) {
        for (i = 0; i < bound; i++) {
            for (ch = 0; ch < s->nb_channels; ch++) {
524 525 526 527 528 529 530 531 532 533
                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;
            }
        }
534
        for (i = bound; i < SBLIMIT; i++) {
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
            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
560

561
    /* select decoding table */
562
    table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
563 564
                                   s->sample_rate, s->lsf);
    sblimit     = ff_mpa_sblimit_table[table];
565
    alloc_table = ff_mpa_alloc_tables[table];
566

567
    if (s->mode == MPA_JSTEREO)
568 569 570 571
        bound = (s->mode_ext + 1) * 4;
    else
        bound = sblimit;

572
    av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
573 574

    /* sanity check */
575 576
    if (bound > sblimit)
        bound = sblimit;
577

578 579
    /* parse bit allocation */
    j = 0;
580
    for (i = 0; i < bound; i++) {
581
        bit_alloc_bits = alloc_table[j];
582
        for (ch = 0; ch < s->nb_channels; ch++)
583 584 585
            bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
        j += 1 << bit_alloc_bits;
    }
586
    for (i = bound; i < sblimit; i++) {
587 588 589 590 591
        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
592
    }
593 594

    /* scale codes */
595 596
    for (i = 0; i < sblimit; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
597
            if (bit_alloc[ch][i])
598 599 600
                scale_code[ch][i] = get_bits(&s->gb, 2);
        }
    }
601

602
    /* scale factors */
603 604
    for (i = 0; i < sblimit; i++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
605 606
            if (bit_alloc[ch][i]) {
                sf = scale_factors[ch][i];
607
                switch (scale_code[ch][i]) {
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
                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 */
635 636
    for (k = 0; k < 3; k++) {
        for (l = 0; l < 12; l += 3) {
637
            j = 0;
638
            for (i = 0; i < bound; i++) {
639
                bit_alloc_bits = alloc_table[j];
640
                for (ch = 0; ch < s->nb_channels; ch++) {
641 642 643 644
                    b = bit_alloc[ch][i];
                    if (b) {
                        scale = scale_factors[ch][i][k];
                        qindex = alloc_table[j+b];
645
                        bits = ff_mpa_quant_bits[qindex];
646
                        if (bits < 0) {
647
                            int v2;
648 649
                            /* 3 values at the same time */
                            v = get_bits(&s->gb, -bits);
650 651 652
                            v2 = division_tabs[qindex][v];
                            steps  = ff_mpa_quant_steps[qindex];

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

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
#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;                    \
756 757
    }

758 759
static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
                                           int n3)
760
{
761 762 763
    SPLIT(slen[3], sf, n3)
    SPLIT(slen[2], sf, n2)
    SPLIT(slen[1], sf, n1)
764 765 766
    slen[0] = sf;
}

767
static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
768
                                         int16_t *exponents)
769
{
770
    const uint8_t *bstab, *pretab;
771
    int len, i, j, k, l, v0, shift, gain, gains[3];
772
    int16_t *exp_ptr;
773 774

    exp_ptr = exponents;
775 776
    gain    = g->global_gain - 210;
    shift   = g->scalefac_scale + 1;
777

778
    bstab  = band_size_long[s->sample_rate_index];
779
    pretab = mpa_pretab[g->preflag];
780
    for (i = 0; i < g->long_end; i++) {
781
        v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
782
        len = bstab[i];
783
        for (j = len; j > 0; j--)
784 785 786 787
            *exp_ptr++ = v0;
    }

    if (g->short_start < 13) {
788
        bstab    = band_size_short[s->sample_rate_index];
789 790 791
        gains[0] = gain - (g->subblock_gain[0] << 3);
        gains[1] = gain - (g->subblock_gain[1] << 3);
        gains[2] = gain - (g->subblock_gain[2] << 3);
792 793
        k        = g->long_end;
        for (i = g->short_start; i < 13; i++) {
794
            len = bstab[i];
795
            for (l = 0; l < 3; l++) {
796
                v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
797 798
                for (j = len; j > 0; j--)
                    *exp_ptr++ = v0;
799 800 801 802 803 804 805 806
            }
        }
    }
}

/* handle n = 0 too */
static inline int get_bitsz(GetBitContext *s, int n)
{
807
    return n ? get_bits(s, n) : 0;
808 809
}

810

811 812 813 814 815 816
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;
817
        av_assert2((get_bits_count(&s->gb) & 7) == 0);
818
        skip_bits_long(&s->gb, *pos - *end_pos);
819 820 821
        *end_pos2 =
        *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
        *pos      = get_bits_count(&s->gb);
822 823 824
    }
}

825 826 827 828 829 830
/* Following is a optimized code for
            INTFLOAT v = *src
            if(get_bits1(&s->gb))
                v = -v;
            *dst = v;
*/
831
#if USE_FLOATS
832 833 834
#define READ_FLIP_SIGN(dst,src)                     \
    v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \
    AV_WN32A(dst, v);
835
#else
836 837 838
#define READ_FLIP_SIGN(dst,src)     \
    v      = -get_bits1(&s->gb);    \
    *(dst) = (*(src) ^ v) - v;
839 840
#endif

841
static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
842
                          int16_t *exponents, int end_pos2)
843 844
{
    int s_index;
845
    int i;
846
    int last_pos, bits_left;
847
    VLC *vlc;
848
    int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
849 850 851

    /* low frequencies (called big values) */
    s_index = 0;
852
    for (i = 0; i < 3; i++) {
853
        int j, k, l, linbits;
854 855 856 857
        j = g->region_size[i];
        if (j == 0)
            continue;
        /* select vlc table */
858 859
        k       = g->table_select[i];
        l       = mpa_huff_data[k][0];
860
        linbits = mpa_huff_data[k][1];
861
        vlc     = &huff_vlc[l];
862

863 864 865
        if (!l) {
            memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
            s_index += 2 * j;
866 867 868
            continue;
        }

869
        /* read huffcode and compute each couple */
870
        for (; j > 0; j--) {
871
            int exponent, x, y;
872
            int v;
873
            int pos = get_bits_count(&s->gb);
874 875

            if (pos >= end_pos){
876
                switch_buffer(s, &pos, &end_pos, &end_pos2);
877
                if (pos >= end_pos)
878 879
                    break;
            }
880
            y = get_vlc2(&s->gb, vlc->table, 7, 3);
881

882
            if (!y) {
883 884 885 886 887 888
                g->sb_hybrid[s_index  ] =
                g->sb_hybrid[s_index+1] = 0;
                s_index += 2;
                continue;
            }

889
            exponent= exponents[s_index];
890

891
            av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
892
                    i, g->region_size[i] - j, x, y, exponent);
893
            if (y & 16) {
Michael Niedermayer's avatar
Michael Niedermayer committed
894 895
                x = y >> 5;
                y = y & 0x0f;
896 897 898
                if (x < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
                } else {
899
                    x += get_bitsz(&s->gb, linbits);
900
                    v  = l3_unscale(x, exponent);
901 902 903
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index] = v;
904
                }
905 906 907
                if (y < 15) {
                    READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
                } else {
908
                    y += get_bitsz(&s->gb, linbits);
909
                    v  = l3_unscale(y, exponent);
910 911 912
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index+1] = v;
913
                }
914
            } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
915 916 917
                x = y >> 5;
                y = y & 0x0f;
                x += y;
918 919 920
                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
921
                    x += get_bitsz(&s->gb, linbits);
922
                    v  = l3_unscale(x, exponent);
923 924 925
                    if (get_bits1(&s->gb))
                        v = -v;
                    g->sb_hybrid[s_index+!!y] = v;
Michael Niedermayer's avatar
Michael Niedermayer committed
926
                }
927
                g->sb_hybrid[s_index + !y] = 0;
928
            }
929
            s_index += 2;
930 931
        }
    }
932

933 934
    /* high frequencies */
    vlc = &huff_quad_vlc[g->count1table_select];
935
    last_pos = 0;
936
    while (s_index <= 572) {
937
        int pos, code;
938 939
        pos = get_bits_count(&s->gb);
        if (pos >= end_pos) {
940
            if (pos > end_pos2 && last_pos) {
941 942 943 944
                /* 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);
945
                av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
946
                if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
947
                    s_index=0;
948 949
                break;
            }
950
            switch_buffer(s, &pos, &end_pos, &end_pos2);
951
            if (pos >= end_pos)
952
                break;
953
        }
954
        last_pos = pos;
955

956
        code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
957
        av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
958 959 960 961 962 963
        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 };
964
            int v;
965 966 967
            int pos = s_index + idxtab[code];
            code   ^= 8 >> idxtab[code];
            READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
968
        }
969
        s_index += 4;
970
    }
971
    /* skip extension bits */
972
    bits_left = end_pos2 - get_bits_count(&s->gb);
973
    if (bits_left < 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_COMPLIANT))) {
974
        av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
975
        s_index=0;
976
    } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) {
977
        av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
978
        s_index = 0;
979
    }
980
    memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
981 982
    skip_bits_long(&s->gb, bits_left);

983
    i = get_bits_count(&s->gb);
984
    switch_buffer(s, &i, &end_pos, &end_pos2);
985

Fabrice Bellard's avatar
Fabrice Bellard committed
986 987 988
    return 0;
}

989 990 991 992 993
/* 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)
{
994
    int i, j, len;
995 996
    INTFLOAT *ptr, *dst, *ptr1;
    INTFLOAT tmp[576];
997 998 999 1000 1001

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

    if (g->switch_point) {
1002
        if (s->sample_rate_index != 8)
1003
            ptr = g->sb_hybrid + 36;
1004
        else
1005
            ptr = g->sb_hybrid + 72;
1006 1007 1008
    } else {
        ptr = g->sb_hybrid;
    }
1009

1010 1011
    for (i = g->short_start; i < 13; i++) {
        len  = band_size_short[s->sample_rate_index][i];
1012
        ptr1 = ptr;
1013 1014
        dst  = tmp;
        for (j = len; j > 0; j--) {
1015 1016 1017 1018
            *dst++ = ptr[0*len];
            *dst++ = ptr[1*len];
            *dst++ = ptr[2*len];
            ptr++;
1019
        }
1020
        ptr += 2 * len;
1021
        memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
1022 1023 1024 1025 1026
    }
}

#define ISQRT2 FIXR(0.70710678118654752440)

1027
static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
1028 1029
{
    int i, j, k, l;
1030 1031
    int sf_max, sf, len, non_zero_found;
    INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
    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;
        }
1043

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

1094
        non_zero_found = non_zero_found_short[0] |
1095 1096
                         non_zero_found_short[1] |
                         non_zero_found_short[2];
1097

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

1155
#if USE_FLOATS
1156 1157 1158 1159 1160 1161 1162
#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 */
1163
#endif /* USE_FLOATS */
1164 1165

#ifndef compute_antialias
1166
#if USE_FLOATS
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
#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]);          \
1178 1179
        ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
        ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
1180 1181 1182 1183
    } while (0)
#endif

static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
1184
{
1185
    INTFLOAT *ptr;
Michael Niedermayer's avatar
Michael Niedermayer committed
1186
    int n, i;
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196

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

1198
    ptr = g->sb_hybrid + 18;
1199
    for (i = n; i > 0; i--) {
1200 1201 1202 1203 1204 1205 1206 1207
        AA(0);
        AA(1);
        AA(2);
        AA(3);
        AA(4);
        AA(5);
        AA(6);
        AA(7);
1208 1209

        ptr += 18;
1210 1211
    }
}
1212
#endif /* compute_antialias */
1213

1214 1215
static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
                          INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
1216
{
1217
    INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
1218 1219
    INTFLOAT out2[12];
    int i, j, mdct_long_end, sblimit;
1220 1221

    /* find last non zero block */
1222
    ptr  = g->sb_hybrid + 576;
1223 1224
    ptr1 = g->sb_hybrid + 2 * 18;
    while (ptr >= ptr1) {
1225
        int32_t *p;
1226
        ptr -= 6;
1227 1228
        p    = (int32_t*)ptr;
        if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
            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;
    }

1243 1244 1245 1246 1247 1248 1249
    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;

1250
    for (j = mdct_long_end; j < sblimit; j++) {
1251
        /* select frequency inversion */
1252
        win     = RENAME(ff_mdct_win)[2 + (4  & -(j & 1))];
1253
        out_ptr = sb_samples + j;
1254

1255
        for (i = 0; i < 6; i++) {
1256
            *out_ptr = buf[4*i];
Michael Niedermayer's avatar
Michael Niedermayer committed
1257 1258 1259
            out_ptr += SBLIMIT;
        }
        imdct12(out2, ptr + 0);
1260
        for (i = 0; i < 6; i++) {
1261 1262
            *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);
1263 1264
            out_ptr += SBLIMIT;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1265
        imdct12(out2, ptr + 1);
1266
        for (i = 0; i < 6; i++) {
1267 1268
            *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
1269 1270 1271
            out_ptr += SBLIMIT;
        }
        imdct12(out2, ptr + 2);
1272
        for (i = 0; i < 6; i++) {
1273 1274 1275
            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
1276
        }
1277
        ptr += 18;
1278
        buf += (j&3) != 3 ? 1 : (4*18-3);
1279 1280
    }
    /* zero bands */
1281
    for (j = sblimit; j < SBLIMIT; j++) {
1282 1283
        /* overlap */
        out_ptr = sb_samples + j;
1284
        for (i = 0; i < 18; i++) {
1285 1286
            *out_ptr = buf[4*i];
            buf[4*i]   = 0;
1287 1288
            out_ptr += SBLIMIT;
        }
1289
        buf += (j&3) != 3 ? 1 : (4*18-3);
1290 1291 1292 1293 1294 1295
    }
}

/* main layer3 decoding function */
static int mp_decode_layer3(MPADecodeContext *s)
{
1296
    int nb_granules, main_data_begin;
1297
    int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
1298
    GranuleDef *g;
1299
    int16_t exponents[576]; //FIXME try INTFLOAT
1300 1301 1302 1303

    /* read side info */
    if (s->lsf) {
        main_data_begin = get_bits(&s->gb, 8);
1304
        skip_bits(&s->gb, s->nb_channels);
1305 1306 1307 1308
        nb_granules = 1;
    } else {
        main_data_begin = get_bits(&s->gb, 9);
        if (s->nb_channels == 2)
1309
            skip_bits(&s->gb, 3);
1310
        else
1311
            skip_bits(&s->gb, 5);
1312
        nb_granules = 2;
1313
        for (ch = 0; ch < s->nb_channels; ch++) {
1314 1315
            s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
            s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
1316 1317
        }
    }
1318

1319 1320
    for (gr = 0; gr < nb_granules; gr++) {
        for (ch = 0; ch < s->nb_channels; ch++) {
1321
            av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1322
            g = &s->granules[ch][gr];
1323
            g->part2_3_length = get_bits(&s->gb, 12);
1324 1325
            g->big_values     = get_bits(&s->gb,  9);
            if (g->big_values > 288) {
1326
                av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
1327
                return AVERROR_INVALIDDATA;
1328 1329
            }

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

1369 1370
            g->preflag = 0;
            if (!s->lsf)
1371
                g->preflag = get_bits1(&s->gb);
1372
            g->scalefac_scale     = get_bits1(&s->gb);
1373
            g->count1table_select = get_bits1(&s->gb);
1374
            av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1375 1376 1377 1378
                    g->block_type, g->switch_point);
        }
    }

1379
    if (!s->adu_mode) {
1380
        int skip;
1381
        const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1382
        int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0, EXTRABYTES);
1383
        av_assert1((get_bits_count(&s->gb) & 7) == 0);
1384
        /* now we get bits from the main_data_begin offset */
1385 1386
        av_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
                main_data_begin, s->last_buf_size);
1387

1388
        memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
1389
        s->in_gb = s->gb;
1390
        init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
1391
#if !UNCHECKED_BITSTREAM_READER
1392
        s->gb.size_in_bits_plus8 += FFMAX(extrasize, LAST_BUF_SIZE - s->last_buf_size) * 8;
1393
#endif
1394 1395 1396 1397 1398 1399
        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));
1400
                compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
            }
        }
        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;
1413
    }
1414

1415
    for (; gr < nb_granules; gr++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1416
        for (ch = 0; ch < s->nb_channels; ch++) {
1417
            g = &s->granules[ch][gr];
1418
            bits_pos = get_bits_count(&s->gb);
1419

1420
            if (!s->lsf) {
1421
                uint8_t *sc;
1422 1423 1424 1425 1426
                int slen, slen1, slen2;

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

                /* LSF scale factors */
1475
                if (g->block_type == 2)
1476
                    tindex = g->switch_point ? 2 : 1;
1477
                else
1478
                    tindex = 0;
1479

1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
                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;
1510 1511
                for (k = 0; k < 4; k++) {
                    n  = lsf_nsf_table[tindex2][tindex][k];
1512
                    sl = slen[k];
1513 1514
                    if (sl) {
                        for (i = 0; i < n; i++)
1515
                            g->scale_factors[j++] = get_bits(&s->gb, sl);
1516 1517
                    } else {
                        for (i = 0; i < n; i++)
1518 1519
                            g->scale_factors[j++] = 0;
                    }
1520 1521
                }
                /* XXX: should compute exact size */
1522
                for (; j < 40; j++)
1523 1524 1525 1526 1527 1528
                    g->scale_factors[j] = 0;
            }

            exponents_from_scale_factors(s, g, exponents);

            /* read Huffman coded residue */
1529
            huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
1530 1531
        } /* ch */

1532
        if (s->mode == MPA_JSTEREO)
1533
            compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
1534

1535
        for (ch = 0; ch < s->nb_channels; ch++) {
1536
            g = &s->granules[ch][gr];
1537 1538

            reorder_block(s, g);
1539
            compute_antialias(s, g);
1540
            compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
1541 1542
        }
    } /* gr */
1543
    if (get_bits_count(&s->gb) < 0)
1544
        skip_bits_long(&s->gb, -get_bits_count(&s->gb));
1545 1546 1547
    return nb_granules * 18;
}

1548
static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
1549
                           const uint8_t *buf, int buf_size)
1550
{
1551
    int i, nb_frames, ch, ret;
1552
    OUT_INT *samples_ptr;
1553

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

1556 1557
    /* skip error protection field */
    if (s->error_protection)
1558
        skip_bits(&s->gb, 16);
1559 1560 1561

    switch(s->layer) {
    case 1:
1562
        s->avctx->frame_size = 384;
1563 1564 1565
        nb_frames = mp_decode_layer1(s);
        break;
    case 2:
1566
        s->avctx->frame_size = 1152;
1567 1568 1569
        nb_frames = mp_decode_layer2(s);
        break;
    case 3:
1570
        s->avctx->frame_size = s->lsf ? 576 : 1152;
1571 1572
    default:
        nb_frames = mp_decode_layer3(s);
1573

1574
        s->last_buf_size=0;
1575
        if (s->in_gb.buffer) {
1576
            align_get_bits(&s->gb);
1577 1578
            i = get_bits_left(&s->gb)>>3;
            if (i >= 0 && i <= BACKSTEP_SIZE) {
1579 1580
                memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
                s->last_buf_size=i;
1581
            } else
1582
                av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
1583 1584
            s->gb           = s->in_gb;
            s->in_gb.buffer = NULL;
1585 1586
        }

1587
        align_get_bits(&s->gb);
1588
        av_assert1((get_bits_count(&s->gb) & 7) == 0);
1589
        i = get_bits_left(&s->gb) >> 3;
1590

1591 1592
        if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
            if (i < 0)
1593
                av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
1594
            i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
1595
        }
1596
        av_assert1(i <= buf_size - HEADER_SIZE && i >= 0);
1597
        memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
1598
        s->last_buf_size += i;
1599
    }
1600

1601 1602 1603
    if(nb_frames < 0)
        return nb_frames;

1604 1605
    /* get output buffer */
    if (!samples) {
1606 1607
        av_assert0(s->frame != NULL);
        s->frame->nb_samples = s->avctx->frame_size;
1608
        if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0)
1609
            return ret;
1610
        samples = (OUT_INT **)s->frame->extended_data;
1611
    }
1612

1613
    /* apply the synthesis filter */
1614
    for (ch = 0; ch < s->nb_channels; ch++) {
1615 1616 1617 1618 1619 1620 1621 1622
        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;
        }
1623
        for (i = 0; i < nb_frames; i++) {
1624 1625 1626 1627 1628 1629
            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;
1630 1631
        }
    }
1632

1633
    return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
1634 1635
}

1636
static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
1637
                        AVPacket *avpkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
1638
{
1639 1640
    const uint8_t *buf  = avpkt->data;
    int buf_size        = avpkt->size;
Fabrice Bellard's avatar
Fabrice Bellard committed
1641
    MPADecodeContext *s = avctx->priv_data;
1642
    uint32_t header;
1643
    int ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
1644

1645
    while(buf_size && !*buf){
1646
        buf++;
1647 1648
        buf_size--;
    }
1649

1650
    if (buf_size < HEADER_SIZE)
1651
        return AVERROR_INVALIDDATA;
1652

1653
    header = AV_RB32(buf);
1654 1655 1656 1657
    if (header>>8 == AV_RB32("TAG")>>8) {
        av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
        return buf_size;
    }
1658
    if (ff_mpa_check_header(header) < 0) {
1659
        av_log(avctx, AV_LOG_ERROR, "Header missing\n");
1660
        return AVERROR_INVALIDDATA;
1661 1662
    }

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

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

1682 1683
    s->frame = data;

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

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

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

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

    len = buf_size;

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


    if (len > MPA_MAX_CODED_FRAME_SIZE)
        len = MPA_MAX_CODED_FRAME_SIZE;

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

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

1747
    avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
Roberto Togni's avatar
Roberto Togni committed
1748 1749
    /* update codec info */
    avctx->sample_rate = s->sample_rate;
1750
    avctx->channels    = s->nb_channels;
1751
    avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
1752 1753
    if (!avctx->bit_rate)
        avctx->bit_rate = s->bit_rate;
Roberto Togni's avatar
Roberto Togni committed
1754

1755
    s->frame_size = len;
Roberto Togni's avatar
Roberto Togni committed
1756

1757 1758
    s->frame = data;

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

1765
    *got_frame_ptr = 1;
Roberto Togni's avatar
Roberto Togni committed
1766 1767 1768

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

1771
#if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1772

1773 1774 1775 1776
/**
 * Context for MP3On4 decoder
 */
typedef struct MP3On4DecodeContext {
1777 1778 1779
    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
1780 1781 1782
    MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
} MP3On4DecodeContext;

1783 1784
#include "mpeg4audio.h"

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

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

1790
/* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
1791
static const uint8_t chan_offset[8][5] = {
1792 1793 1794 1795 1796 1797 1798 1799
    { 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
1800 1801
};

1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
/* 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
};
1813

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

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

    return 0;
}

1825

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

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

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

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

1853 1854 1855
    /* 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.
1856
     * Other decoders will be initialized here copying data from the first context
1857 1858 1859
     */
    // Allocate zeroed memory for the first decoder context
    s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
1860 1861
    if (!s->mp3decctx[0])
        goto alloc_fail;
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
    // 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));
1874 1875
        if (!s->mp3decctx[i])
            goto alloc_fail;
1876
        s->mp3decctx[i]->adu_mode = 1;
1877
        s->mp3decctx[i]->avctx = avctx;
1878
        s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
1879 1880 1881
    }

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


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

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


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

1912
    /* get output buffer */
1913
    frame->nb_samples = MPA_FRAME_SIZE;
1914
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1915
        return ret;
1916
    out_samples = (OUT_INT **)frame->extended_data;
1917

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

1922 1923
    avctx->bit_rate = 0;

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

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

1937 1938 1939 1940
        if (ff_mpa_check_header(header) < 0) {
            av_log(avctx, AV_LOG_ERROR, "Bad header, discard block\n");
            return AVERROR_INVALIDDATA;
        }
1941

1942
        avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
1943

1944 1945
        if (ch + m->nb_channels > avctx->channels ||
            s->coff[fr] + m->nb_channels > avctx->channels) {
1946 1947 1948 1949 1950 1951
            av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
                                        "channel count\n");
            return AVERROR_INVALIDDATA;
        }
        ch += m->nb_channels;

1952 1953 1954 1955
        outptr[0] = out_samples[s->coff[fr]];
        if (m->nb_channels > 1)
            outptr[1] = out_samples[s->coff[fr] + 1];

1956 1957 1958 1959 1960 1961 1962
        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);
        }
1963 1964

        out_size += ret;
1965 1966
        buf      += fsize;
        len      -= fsize;
1967

1968
        avctx->bit_rate += m->bit_rate;
1969
    }
1970 1971 1972 1973
    if (ch != avctx->channels) {
        av_log(avctx, AV_LOG_ERROR, "failed to decode all channels\n");
        return AVERROR_INVALIDDATA;
    }
1974 1975 1976 1977

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

1978 1979
    frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
    *got_frame_ptr    = 1;
1980

1981 1982
    return buf_size;
}
1983
#endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */