Statistics
| Branch: | Revision:

ffmpeg / libavcodec / aac.c @ 54f158bd

History | View | Annotate | Download (72.8 KB)

1
/*
2
 * AAC decoder
3
 * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
4
 * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file libavcodec/aac.c
25
 * AAC decoder
26
 * @author Oded Shimon  ( ods15 ods15 dyndns org )
27
 * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
28
 */
29

    
30
/*
31
 * supported tools
32
 *
33
 * Support?             Name
34
 * N (code in SoC repo) gain control
35
 * Y                    block switching
36
 * Y                    window shapes - standard
37
 * N                    window shapes - Low Delay
38
 * Y                    filterbank - standard
39
 * N (code in SoC repo) filterbank - Scalable Sample Rate
40
 * Y                    Temporal Noise Shaping
41
 * N (code in SoC repo) Long Term Prediction
42
 * Y                    intensity stereo
43
 * Y                    channel coupling
44
 * Y                    frequency domain prediction
45
 * Y                    Perceptual Noise Substitution
46
 * Y                    Mid/Side stereo
47
 * N                    Scalable Inverse AAC Quantization
48
 * N                    Frequency Selective Switch
49
 * N                    upsampling filter
50
 * Y                    quantization & coding - AAC
51
 * N                    quantization & coding - TwinVQ
52
 * N                    quantization & coding - BSAC
53
 * N                    AAC Error Resilience tools
54
 * N                    Error Resilience payload syntax
55
 * N                    Error Protection tool
56
 * N                    CELP
57
 * N                    Silence Compression
58
 * N                    HVXC
59
 * N                    HVXC 4kbits/s VR
60
 * N                    Structured Audio tools
61
 * N                    Structured Audio Sample Bank Format
62
 * N                    MIDI
63
 * N                    Harmonic and Individual Lines plus Noise
64
 * N                    Text-To-Speech Interface
65
 * N (in progress)      Spectral Band Replication
66
 * Y (not in this code) Layer-1
67
 * Y (not in this code) Layer-2
68
 * Y (not in this code) Layer-3
69
 * N                    SinuSoidal Coding (Transient, Sinusoid, Noise)
70
 * N (planned)          Parametric Stereo
71
 * N                    Direct Stream Transfer
72
 *
73
 * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
74
 *       - HE AAC v2 comprises LC AAC with Spectral Band Replication and
75
           Parametric Stereo.
76
 */
77

    
78

    
79
#include "avcodec.h"
80
#include "internal.h"
81
#include "get_bits.h"
82
#include "dsputil.h"
83
#include "fft.h"
84
#include "lpc.h"
85

    
86
#include "aac.h"
87
#include "aactab.h"
88
#include "aacdectab.h"
89
#include "mpeg4audio.h"
90
#include "aac_parser.h"
91

    
92
#include <assert.h>
93
#include <errno.h>
94
#include <math.h>
95
#include <string.h>
96

    
97
#if ARCH_ARM
98
#   include "arm/aac.h"
99
#endif
100

    
101
union float754 {
102
    float f;
103
    uint32_t i;
104
};
105

    
106
static VLC vlc_scalefactors;
107
static VLC vlc_spectral[11];
108

    
109
static uint32_t cbrt_tab[1<<13];
110

    
111
static const char overread_err[] = "Input buffer exhausted before END element found\n";
112

    
113
static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
114
{
115
    if (ac->tag_che_map[type][elem_id]) {
116
        return ac->tag_che_map[type][elem_id];
117
    }
118
    if (ac->tags_mapped >= tags_per_config[ac->m4ac.chan_config]) {
119
        return NULL;
120
    }
121
    switch (ac->m4ac.chan_config) {
122
    case 7:
123
        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
124
            ac->tags_mapped++;
125
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
126
        }
127
    case 6:
128
        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
129
           instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have
130
           encountered such a stream, transfer the LFE[0] element to SCE[1] */
131
        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
132
            ac->tags_mapped++;
133
            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
134
        }
135
    case 5:
136
        if (ac->tags_mapped == 2 && type == TYPE_CPE) {
137
            ac->tags_mapped++;
138
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
139
        }
140
    case 4:
141
        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {
142
            ac->tags_mapped++;
143
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
144
        }
145
    case 3:
146
    case 2:
147
        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {
148
            ac->tags_mapped++;
149
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
150
        } else if (ac->m4ac.chan_config == 2) {
151
            return NULL;
152
        }
153
    case 1:
154
        if (!ac->tags_mapped && type == TYPE_SCE) {
155
            ac->tags_mapped++;
156
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
157
        }
158
    default:
159
        return NULL;
160
    }
161
}
162

    
163
/**
164
 * Check for the channel element in the current channel position configuration.
165
 * If it exists, make sure the appropriate element is allocated and map the
166
 * channel order to match the internal FFmpeg channel layout.
167
 *
168
 * @param   che_pos current channel position configuration
169
 * @param   type channel element type
170
 * @param   id channel element id
171
 * @param   channels count of the number of channels in the configuration
172
 *
173
 * @return  Returns error status. 0 - OK, !0 - error
174
 */
175
static av_cold int che_configure(AACContext *ac,
176
                         enum ChannelPosition che_pos[4][MAX_ELEM_ID],
177
                         int type, int id,
178
                         int *channels)
179
{
180
    if (che_pos[type][id]) {
181
        if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
182
            return AVERROR(ENOMEM);
183
        if (type != TYPE_CCE) {
184
            ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;
185
            if (type == TYPE_CPE) {
186
                ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;
187
            }
188
        }
189
    } else
190
        av_freep(&ac->che[type][id]);
191
    return 0;
192
}
193

    
194
/**
195
 * Configure output channel order based on the current program configuration element.
196
 *
197
 * @param   che_pos current channel position configuration
198
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
199
 *
200
 * @return  Returns error status. 0 - OK, !0 - error
201
 */
202
static av_cold int output_configure(AACContext *ac,
203
                            enum ChannelPosition che_pos[4][MAX_ELEM_ID],
204
                            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
205
                            int channel_config, enum OCStatus oc_type)
206
{
207
    AVCodecContext *avctx = ac->avccontext;
208
    int i, type, channels = 0, ret;
209

    
210
    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
211

    
212
    if (channel_config) {
213
        for (i = 0; i < tags_per_config[channel_config]; i++) {
214
            if ((ret = che_configure(ac, che_pos,
215
                                     aac_channel_layout_map[channel_config - 1][i][0],
216
                                     aac_channel_layout_map[channel_config - 1][i][1],
217
                                     &channels)))
218
                return ret;
219
        }
220

    
221
        memset(ac->tag_che_map, 0,       4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
222
        ac->tags_mapped = 0;
223

    
224
        avctx->channel_layout = aac_channel_layout[channel_config - 1];
225
    } else {
226
        /* Allocate or free elements depending on if they are in the
227
         * current program configuration.
228
         *
229
         * Set up default 1:1 output mapping.
230
         *
231
         * For a 5.1 stream the output order will be:
232
         *    [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
233
         */
234

    
235
        for (i = 0; i < MAX_ELEM_ID; i++) {
236
            for (type = 0; type < 4; type++) {
237
                if ((ret = che_configure(ac, che_pos, type, i, &channels)))
238
                    return ret;
239
            }
240
        }
241

    
242
        memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
243
        ac->tags_mapped = 4 * MAX_ELEM_ID;
244

    
245
        avctx->channel_layout = 0;
246
    }
247

    
248
    avctx->channels = channels;
249

    
250
    ac->output_configured = oc_type;
251

    
252
    return 0;
253
}
254

    
255
/**
256
 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
257
 *
258
 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
259
 * @param sce_map mono (Single Channel Element) map
260
 * @param type speaker type/position for these channels
261
 */
262
static void decode_channel_map(enum ChannelPosition *cpe_map,
263
                               enum ChannelPosition *sce_map,
264
                               enum ChannelPosition type,
265
                               GetBitContext *gb, int n)
266
{
267
    while (n--) {
268
        enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map
269
        map[get_bits(gb, 4)] = type;
270
    }
271
}
272

    
273
/**
274
 * Decode program configuration element; reference: table 4.2.
275
 *
276
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
277
 *
278
 * @return  Returns error status. 0 - OK, !0 - error
279
 */
280
static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
281
                      GetBitContext *gb)
282
{
283
    int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
284
    int comment_len;
285

    
286
    skip_bits(gb, 2);  // object_type
287

    
288
    sampling_index = get_bits(gb, 4);
289
    if (ac->m4ac.sampling_index != sampling_index)
290
        av_log(ac->avccontext, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
291

    
292
    num_front       = get_bits(gb, 4);
293
    num_side        = get_bits(gb, 4);
294
    num_back        = get_bits(gb, 4);
295
    num_lfe         = get_bits(gb, 2);
296
    num_assoc_data  = get_bits(gb, 3);
297
    num_cc          = get_bits(gb, 4);
298

    
299
    if (get_bits1(gb))
300
        skip_bits(gb, 4); // mono_mixdown_tag
301
    if (get_bits1(gb))
302
        skip_bits(gb, 4); // stereo_mixdown_tag
303

    
304
    if (get_bits1(gb))
305
        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
306

    
307
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
308
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE,  gb, num_side );
309
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK,  gb, num_back );
310
    decode_channel_map(NULL,                  new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE,   gb, num_lfe  );
311

    
312
    skip_bits_long(gb, 4 * num_assoc_data);
313

    
314
    decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC,    gb, num_cc   );
315

    
316
    align_get_bits(gb);
317

    
318
    /* comment field, first byte is length */
319
    comment_len = get_bits(gb, 8) * 8;
320
    if (get_bits_left(gb) < comment_len) {
321
        av_log(ac->avccontext, AV_LOG_ERROR, overread_err);
322
        return -1;
323
    }
324
    skip_bits_long(gb, comment_len);
325
    return 0;
326
}
327

    
328
/**
329
 * Set up channel positions based on a default channel configuration
330
 * as specified in table 1.17.
331
 *
332
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
333
 *
334
 * @return  Returns error status. 0 - OK, !0 - error
335
 */
336
static av_cold int set_default_channel_config(AACContext *ac,
337
                                      enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
338
                                      int channel_config)
339
{
340
    if (channel_config < 1 || channel_config > 7) {
341
        av_log(ac->avccontext, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
342
               channel_config);
343
        return -1;
344
    }
345

    
346
    /* default channel configurations:
347
     *
348
     * 1ch : front center (mono)
349
     * 2ch : L + R (stereo)
350
     * 3ch : front center + L + R
351
     * 4ch : front center + L + R + back center
352
     * 5ch : front center + L + R + back stereo
353
     * 6ch : front center + L + R + back stereo + LFE
354
     * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
355
     */
356

    
357
    if (channel_config != 2)
358
        new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono)
359
    if (channel_config > 1)
360
        new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo)
361
    if (channel_config == 4)
362
        new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK;  // back center
363
    if (channel_config > 4)
364
        new_che_pos[TYPE_CPE][(channel_config == 7) + 1]
365
        = AAC_CHANNEL_BACK;  // back stereo
366
    if (channel_config > 5)
367
        new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE;   // LFE
368
    if (channel_config == 7)
369
        new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right
370

    
371
    return 0;
372
}
373

    
374
/**
375
 * Decode GA "General Audio" specific configuration; reference: table 4.1.
376
 *
377
 * @return  Returns error status. 0 - OK, !0 - error
378
 */
379
static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb,
380
                                     int channel_config)
381
{
382
    enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
383
    int extension_flag, ret;
384

    
385
    if (get_bits1(gb)) { // frameLengthFlag
386
        av_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1);
387
        return -1;
388
    }
389

    
390
    if (get_bits1(gb))       // dependsOnCoreCoder
391
        skip_bits(gb, 14);   // coreCoderDelay
392
    extension_flag = get_bits1(gb);
393

    
394
    if (ac->m4ac.object_type == AOT_AAC_SCALABLE ||
395
        ac->m4ac.object_type == AOT_ER_AAC_SCALABLE)
396
        skip_bits(gb, 3);     // layerNr
397

    
398
    memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
399
    if (channel_config == 0) {
400
        skip_bits(gb, 4);  // element_instance_tag
401
        if ((ret = decode_pce(ac, new_che_pos, gb)))
402
            return ret;
403
    } else {
404
        if ((ret = set_default_channel_config(ac, new_che_pos, channel_config)))
405
            return ret;
406
    }
407
    if ((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
408
        return ret;
409

    
410
    if (extension_flag) {
411
        switch (ac->m4ac.object_type) {
412
        case AOT_ER_BSAC:
413
            skip_bits(gb, 5);    // numOfSubFrame
414
            skip_bits(gb, 11);   // layer_length
415
            break;
416
        case AOT_ER_AAC_LC:
417
        case AOT_ER_AAC_LTP:
418
        case AOT_ER_AAC_SCALABLE:
419
        case AOT_ER_AAC_LD:
420
            skip_bits(gb, 3);  /* aacSectionDataResilienceFlag
421
                                    * aacScalefactorDataResilienceFlag
422
                                    * aacSpectralDataResilienceFlag
423
                                    */
424
            break;
425
        }
426
        skip_bits1(gb);    // extensionFlag3 (TBD in version 3)
427
    }
428
    return 0;
429
}
430

    
431
/**
432
 * Decode audio specific configuration; reference: table 1.13.
433
 *
434
 * @param   data        pointer to AVCodecContext extradata
435
 * @param   data_size   size of AVCCodecContext extradata
436
 *
437
 * @return  Returns error status. 0 - OK, !0 - error
438
 */
439
static int decode_audio_specific_config(AACContext *ac, void *data,
440
                                        int data_size)
441
{
442
    GetBitContext gb;
443
    int i;
444

    
445
    init_get_bits(&gb, data, data_size * 8);
446

    
447
    if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0)
448
        return -1;
449
    if (ac->m4ac.sampling_index > 12) {
450
        av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
451
        return -1;
452
    }
453

    
454
    skip_bits_long(&gb, i);
455

    
456
    switch (ac->m4ac.object_type) {
457
    case AOT_AAC_MAIN:
458
    case AOT_AAC_LC:
459
        if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config))
460
            return -1;
461
        break;
462
    default:
463
        av_log(ac->avccontext, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
464
               ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type);
465
        return -1;
466
    }
467
    return 0;
468
}
469

    
470
/**
471
 * linear congruential pseudorandom number generator
472
 *
473
 * @param   previous_val    pointer to the current state of the generator
474
 *
475
 * @return  Returns a 32-bit pseudorandom integer
476
 */
477
static av_always_inline int lcg_random(int previous_val)
478
{
479
    return previous_val * 1664525 + 1013904223;
480
}
481

    
482
static av_always_inline void reset_predict_state(PredictorState *ps)
483
{
484
    ps->r0   = 0.0f;
485
    ps->r1   = 0.0f;
486
    ps->cor0 = 0.0f;
487
    ps->cor1 = 0.0f;
488
    ps->var0 = 1.0f;
489
    ps->var1 = 1.0f;
490
}
491

    
492
static void reset_all_predictors(PredictorState *ps)
493
{
494
    int i;
495
    for (i = 0; i < MAX_PREDICTORS; i++)
496
        reset_predict_state(&ps[i]);
497
}
498

    
499
static void reset_predictor_group(PredictorState *ps, int group_num)
500
{
501
    int i;
502
    for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
503
        reset_predict_state(&ps[i]);
504
}
505

    
506
static av_cold int aac_decode_init(AVCodecContext *avccontext)
507
{
508
    AACContext *ac = avccontext->priv_data;
509
    int i;
510

    
511
    ac->avccontext = avccontext;
512
    ac->m4ac.sample_rate = avccontext->sample_rate;
513

    
514
    if (avccontext->extradata_size > 0) {
515
        if (decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size))
516
            return -1;
517
    }
518

    
519
    avccontext->sample_fmt = SAMPLE_FMT_S16;
520

    
521
    AAC_INIT_VLC_STATIC( 0, 304);
522
    AAC_INIT_VLC_STATIC( 1, 270);
523
    AAC_INIT_VLC_STATIC( 2, 550);
524
    AAC_INIT_VLC_STATIC( 3, 300);
525
    AAC_INIT_VLC_STATIC( 4, 328);
526
    AAC_INIT_VLC_STATIC( 5, 294);
527
    AAC_INIT_VLC_STATIC( 6, 306);
528
    AAC_INIT_VLC_STATIC( 7, 268);
529
    AAC_INIT_VLC_STATIC( 8, 510);
530
    AAC_INIT_VLC_STATIC( 9, 366);
531
    AAC_INIT_VLC_STATIC(10, 462);
532

    
533
    dsputil_init(&ac->dsp, avccontext);
534

    
535
    ac->random_state = 0x1f2e3d4c;
536

    
537
    // -1024 - Compensate wrong IMDCT method.
538
    // 32768 - Required to scale values to the correct range for the bias method
539
    //         for float to int16 conversion.
540

    
541
    if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
542
        ac->add_bias  = 385.0f;
543
        ac->sf_scale  = 1. / (-1024. * 32768.);
544
        ac->sf_offset = 0;
545
    } else {
546
        ac->add_bias  = 0.0f;
547
        ac->sf_scale  = 1. / -1024.;
548
        ac->sf_offset = 60;
549
    }
550

    
551
#if !CONFIG_HARDCODED_TABLES
552
    for (i = 0; i < 428; i++)
553
        ff_aac_pow2sf_tab[i] = pow(2, (i - 200) / 4.);
554
#endif /* CONFIG_HARDCODED_TABLES */
555

    
556
    INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
557
                    ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
558
                    ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
559
                    352);
560

    
561
    ff_mdct_init(&ac->mdct, 11, 1, 1.0);
562
    ff_mdct_init(&ac->mdct_small, 8, 1, 1.0);
563
    // window initialization
564
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
565
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
566
    ff_init_ff_sine_windows(10);
567
    ff_init_ff_sine_windows( 7);
568

    
569
    if (!cbrt_tab[(1<<13) - 1]) {
570
        for (i = 0; i < 1<<13; i++) {
571
            union float754 f;
572
            f.f = cbrtf(i) * i;
573
            cbrt_tab[i] = f.i;
574
        }
575
    }
576

    
577
    return 0;
578
}
579

    
580
/**
581
 * Skip data_stream_element; reference: table 4.10.
582
 */
583
static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
584
{
585
    int byte_align = get_bits1(gb);
586
    int count = get_bits(gb, 8);
587
    if (count == 255)
588
        count += get_bits(gb, 8);
589
    if (byte_align)
590
        align_get_bits(gb);
591

    
592
    if (get_bits_left(gb) < 8 * count) {
593
        av_log(ac->avccontext, AV_LOG_ERROR, overread_err);
594
        return -1;
595
    }
596
    skip_bits_long(gb, 8 * count);
597
    return 0;
598
}
599

    
600
static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
601
                             GetBitContext *gb)
602
{
603
    int sfb;
604
    if (get_bits1(gb)) {
605
        ics->predictor_reset_group = get_bits(gb, 5);
606
        if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
607
            av_log(ac->avccontext, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
608
            return -1;
609
        }
610
    }
611
    for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->m4ac.sampling_index]); sfb++) {
612
        ics->prediction_used[sfb] = get_bits1(gb);
613
    }
614
    return 0;
615
}
616

    
617
/**
618
 * Decode Individual Channel Stream info; reference: table 4.6.
619
 *
620
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
621
 */
622
static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
623
                           GetBitContext *gb, int common_window)
624
{
625
    if (get_bits1(gb)) {
626
        av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n");
627
        memset(ics, 0, sizeof(IndividualChannelStream));
628
        return -1;
629
    }
630
    ics->window_sequence[1] = ics->window_sequence[0];
631
    ics->window_sequence[0] = get_bits(gb, 2);
632
    ics->use_kb_window[1]   = ics->use_kb_window[0];
633
    ics->use_kb_window[0]   = get_bits1(gb);
634
    ics->num_window_groups  = 1;
635
    ics->group_len[0]       = 1;
636
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
637
        int i;
638
        ics->max_sfb = get_bits(gb, 4);
639
        for (i = 0; i < 7; i++) {
640
            if (get_bits1(gb)) {
641
                ics->group_len[ics->num_window_groups - 1]++;
642
            } else {
643
                ics->num_window_groups++;
644
                ics->group_len[ics->num_window_groups - 1] = 1;
645
            }
646
        }
647
        ics->num_windows       = 8;
648
        ics->swb_offset        =    ff_swb_offset_128[ac->m4ac.sampling_index];
649
        ics->num_swb           =   ff_aac_num_swb_128[ac->m4ac.sampling_index];
650
        ics->tns_max_bands     = ff_tns_max_bands_128[ac->m4ac.sampling_index];
651
        ics->predictor_present = 0;
652
    } else {
653
        ics->max_sfb               = get_bits(gb, 6);
654
        ics->num_windows           = 1;
655
        ics->swb_offset            =    ff_swb_offset_1024[ac->m4ac.sampling_index];
656
        ics->num_swb               =   ff_aac_num_swb_1024[ac->m4ac.sampling_index];
657
        ics->tns_max_bands         = ff_tns_max_bands_1024[ac->m4ac.sampling_index];
658
        ics->predictor_present     = get_bits1(gb);
659
        ics->predictor_reset_group = 0;
660
        if (ics->predictor_present) {
661
            if (ac->m4ac.object_type == AOT_AAC_MAIN) {
662
                if (decode_prediction(ac, ics, gb)) {
663
                    memset(ics, 0, sizeof(IndividualChannelStream));
664
                    return -1;
665
                }
666
            } else if (ac->m4ac.object_type == AOT_AAC_LC) {
667
                av_log(ac->avccontext, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
668
                memset(ics, 0, sizeof(IndividualChannelStream));
669
                return -1;
670
            } else {
671
                av_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1);
672
                memset(ics, 0, sizeof(IndividualChannelStream));
673
                return -1;
674
            }
675
        }
676
    }
677

    
678
    if (ics->max_sfb > ics->num_swb) {
679
        av_log(ac->avccontext, AV_LOG_ERROR,
680
               "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
681
               ics->max_sfb, ics->num_swb);
682
        memset(ics, 0, sizeof(IndividualChannelStream));
683
        return -1;
684
    }
685

    
686
    return 0;
687
}
688

    
689
/**
690
 * Decode band types (section_data payload); reference: table 4.46.
691
 *
692
 * @param   band_type           array of the used band type
693
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
694
 *
695
 * @return  Returns error status. 0 - OK, !0 - error
696
 */
697
static int decode_band_types(AACContext *ac, enum BandType band_type[120],
698
                             int band_type_run_end[120], GetBitContext *gb,
699
                             IndividualChannelStream *ics)
700
{
701
    int g, idx = 0;
702
    const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
703
    for (g = 0; g < ics->num_window_groups; g++) {
704
        int k = 0;
705
        while (k < ics->max_sfb) {
706
            uint8_t sect_end = k;
707
            int sect_len_incr;
708
            int sect_band_type = get_bits(gb, 4);
709
            if (sect_band_type == 12) {
710
                av_log(ac->avccontext, AV_LOG_ERROR, "invalid band type\n");
711
                return -1;
712
            }
713
            while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1)
714
                sect_end += sect_len_incr;
715
            sect_end += sect_len_incr;
716
            if (get_bits_left(gb) < 0) {
717
                av_log(ac->avccontext, AV_LOG_ERROR, overread_err);
718
                return -1;
719
            }
720
            if (sect_end > ics->max_sfb) {
721
                av_log(ac->avccontext, AV_LOG_ERROR,
722
                       "Number of bands (%d) exceeds limit (%d).\n",
723
                       sect_end, ics->max_sfb);
724
                return -1;
725
            }
726
            for (; k < sect_end; k++) {
727
                band_type        [idx]   = sect_band_type;
728
                band_type_run_end[idx++] = sect_end;
729
            }
730
        }
731
    }
732
    return 0;
733
}
734

    
735
/**
736
 * Decode scalefactors; reference: table 4.47.
737
 *
738
 * @param   global_gain         first scalefactor value as scalefactors are differentially coded
739
 * @param   band_type           array of the used band type
740
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
741
 * @param   sf                  array of scalefactors or intensity stereo positions
742
 *
743
 * @return  Returns error status. 0 - OK, !0 - error
744
 */
745
static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
746
                               unsigned int global_gain,
747
                               IndividualChannelStream *ics,
748
                               enum BandType band_type[120],
749
                               int band_type_run_end[120])
750
{
751
    const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0);
752
    int g, i, idx = 0;
753
    int offset[3] = { global_gain, global_gain - 90, 100 };
754
    int noise_flag = 1;
755
    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
756
    for (g = 0; g < ics->num_window_groups; g++) {
757
        for (i = 0; i < ics->max_sfb;) {
758
            int run_end = band_type_run_end[idx];
759
            if (band_type[idx] == ZERO_BT) {
760
                for (; i < run_end; i++, idx++)
761
                    sf[idx] = 0.;
762
            } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
763
                for (; i < run_end; i++, idx++) {
764
                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
765
                    if (offset[2] > 255U) {
766
                        av_log(ac->avccontext, AV_LOG_ERROR,
767
                               "%s (%d) out of range.\n", sf_str[2], offset[2]);
768
                        return -1;
769
                    }
770
                    sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300];
771
                }
772
            } else if (band_type[idx] == NOISE_BT) {
773
                for (; i < run_end; i++, idx++) {
774
                    if (noise_flag-- > 0)
775
                        offset[1] += get_bits(gb, 9) - 256;
776
                    else
777
                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
778
                    if (offset[1] > 255U) {
779
                        av_log(ac->avccontext, AV_LOG_ERROR,
780
                               "%s (%d) out of range.\n", sf_str[1], offset[1]);
781
                        return -1;
782
                    }
783
                    sf[idx] = -ff_aac_pow2sf_tab[offset[1] + sf_offset + 100];
784
                }
785
            } else {
786
                for (; i < run_end; i++, idx++) {
787
                    offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
788
                    if (offset[0] > 255U) {
789
                        av_log(ac->avccontext, AV_LOG_ERROR,
790
                               "%s (%d) out of range.\n", sf_str[0], offset[0]);
791
                        return -1;
792
                    }
793
                    sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset];
794
                }
795
            }
796
        }
797
    }
798
    return 0;
799
}
800

    
801
/**
802
 * Decode pulse data; reference: table 4.7.
803
 */
804
static int decode_pulses(Pulse *pulse, GetBitContext *gb,
805
                         const uint16_t *swb_offset, int num_swb)
806
{
807
    int i, pulse_swb;
808
    pulse->num_pulse = get_bits(gb, 2) + 1;
809
    pulse_swb        = get_bits(gb, 6);
810
    if (pulse_swb >= num_swb)
811
        return -1;
812
    pulse->pos[0]    = swb_offset[pulse_swb];
813
    pulse->pos[0]   += get_bits(gb, 5);
814
    if (pulse->pos[0] > 1023)
815
        return -1;
816
    pulse->amp[0]    = get_bits(gb, 4);
817
    for (i = 1; i < pulse->num_pulse; i++) {
818
        pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
819
        if (pulse->pos[i] > 1023)
820
            return -1;
821
        pulse->amp[i] = get_bits(gb, 4);
822
    }
823
    return 0;
824
}
825

    
826
/**
827
 * Decode Temporal Noise Shaping data; reference: table 4.48.
828
 *
829
 * @return  Returns error status. 0 - OK, !0 - error
830
 */
831
static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
832
                      GetBitContext *gb, const IndividualChannelStream *ics)
833
{
834
    int w, filt, i, coef_len, coef_res, coef_compress;
835
    const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
836
    const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
837
    for (w = 0; w < ics->num_windows; w++) {
838
        if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
839
            coef_res = get_bits1(gb);
840

    
841
            for (filt = 0; filt < tns->n_filt[w]; filt++) {
842
                int tmp2_idx;
843
                tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
844

    
845
                if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
846
                    av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
847
                           tns->order[w][filt], tns_max_order);
848
                    tns->order[w][filt] = 0;
849
                    return -1;
850
                }
851
                if (tns->order[w][filt]) {
852
                    tns->direction[w][filt] = get_bits1(gb);
853
                    coef_compress = get_bits1(gb);
854
                    coef_len = coef_res + 3 - coef_compress;
855
                    tmp2_idx = 2 * coef_compress + coef_res;
856

    
857
                    for (i = 0; i < tns->order[w][filt]; i++)
858
                        tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
859
                }
860
            }
861
        }
862
    }
863
    return 0;
864
}
865

    
866
/**
867
 * Decode Mid/Side data; reference: table 4.54.
868
 *
869
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
870
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
871
 *                      [3] reserved for scalable AAC
872
 */
873
static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
874
                                   int ms_present)
875
{
876
    int idx;
877
    if (ms_present == 1) {
878
        for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
879
            cpe->ms_mask[idx] = get_bits1(gb);
880
    } else if (ms_present == 2) {
881
        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
882
    }
883
}
884

    
885
#ifndef VMUL2
886
static inline float *VMUL2(float *dst, const float *v, unsigned idx,
887
                           const float *scale)
888
{
889
    float s = *scale;
890
    *dst++ = v[idx    & 15] * s;
891
    *dst++ = v[idx>>4 & 15] * s;
892
    return dst;
893
}
894
#endif
895

    
896
#ifndef VMUL4
897
static inline float *VMUL4(float *dst, const float *v, unsigned idx,
898
                           const float *scale)
899
{
900
    float s = *scale;
901
    *dst++ = v[idx    & 3] * s;
902
    *dst++ = v[idx>>2 & 3] * s;
903
    *dst++ = v[idx>>4 & 3] * s;
904
    *dst++ = v[idx>>6 & 3] * s;
905
    return dst;
906
}
907
#endif
908

    
909
#ifndef VMUL2S
910
static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
911
                            unsigned sign, const float *scale)
912
{
913
    union float754 s0, s1;
914

    
915
    s0.f = s1.f = *scale;
916
    s0.i ^= sign >> 1 << 31;
917
    s1.i ^= sign      << 31;
918

    
919
    *dst++ = v[idx    & 15] * s0.f;
920
    *dst++ = v[idx>>4 & 15] * s1.f;
921

    
922
    return dst;
923
}
924
#endif
925

    
926
#ifndef VMUL4S
927
static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
928
                            unsigned sign, const float *scale)
929
{
930
    unsigned nz = idx >> 12;
931
    union float754 s = { .f = *scale };
932
    union float754 t;
933

    
934
    t.i = s.i ^ (sign & 1<<31);
935
    *dst++ = v[idx    & 3] * t.f;
936

    
937
    sign <<= nz & 1; nz >>= 1;
938
    t.i = s.i ^ (sign & 1<<31);
939
    *dst++ = v[idx>>2 & 3] * t.f;
940

    
941
    sign <<= nz & 1; nz >>= 1;
942
    t.i = s.i ^ (sign & 1<<31);
943
    *dst++ = v[idx>>4 & 3] * t.f;
944

    
945
    sign <<= nz & 1; nz >>= 1;
946
    t.i = s.i ^ (sign & 1<<31);
947
    *dst++ = v[idx>>6 & 3] * t.f;
948

    
949
    return dst;
950
}
951
#endif
952

    
953
/**
954
 * Decode spectral data; reference: table 4.50.
955
 * Dequantize and scale spectral data; reference: 4.6.3.3.
956
 *
957
 * @param   coef            array of dequantized, scaled spectral data
958
 * @param   sf              array of scalefactors or intensity stereo positions
959
 * @param   pulse_present   set if pulses are present
960
 * @param   pulse           pointer to pulse data struct
961
 * @param   band_type       array of the used band type
962
 *
963
 * @return  Returns error status. 0 - OK, !0 - error
964
 */
965
static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024],
966
                                       GetBitContext *gb, const float sf[120],
967
                                       int pulse_present, const Pulse *pulse,
968
                                       const IndividualChannelStream *ics,
969
                                       enum BandType band_type[120])
970
{
971
    int i, k, g, idx = 0;
972
    const int c = 1024 / ics->num_windows;
973
    const uint16_t *offsets = ics->swb_offset;
974
    float *coef_base = coef;
975
    int err_idx;
976

    
977
    for (g = 0; g < ics->num_windows; g++)
978
        memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb]));
979

    
980
    for (g = 0; g < ics->num_window_groups; g++) {
981
        unsigned g_len = ics->group_len[g];
982

    
983
        for (i = 0; i < ics->max_sfb; i++, idx++) {
984
            const unsigned cbt_m1 = band_type[idx] - 1;
985
            float *cfo = coef + offsets[i];
986
            int off_len = offsets[i + 1] - offsets[i];
987
            int group;
988

    
989
            if (cbt_m1 >= INTENSITY_BT2 - 1) {
990
                for (group = 0; group < g_len; group++, cfo+=128) {
991
                    memset(cfo, 0, off_len * sizeof(float));
992
                }
993
            } else if (cbt_m1 == NOISE_BT - 1) {
994
                for (group = 0; group < g_len; group++, cfo+=128) {
995
                    float scale;
996
                    float band_energy;
997

    
998
                    for (k = 0; k < off_len; k++) {
999
                        ac->random_state  = lcg_random(ac->random_state);
1000
                        cfo[k] = ac->random_state;
1001
                    }
1002

    
1003
                    band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len);
1004
                    scale = sf[idx] / sqrtf(band_energy);
1005
                    ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len);
1006
                }
1007
            } else {
1008
                const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1009
                const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
1010
                VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1011
                const int cb_size = ff_aac_spectral_sizes[cbt_m1];
1012
                OPEN_READER(re, gb);
1013

    
1014
                switch (cbt_m1 >> 1) {
1015
                case 0:
1016
                    for (group = 0; group < g_len; group++, cfo+=128) {
1017
                        float *cf = cfo;
1018
                        int len = off_len;
1019

    
1020
                        do {
1021
                            int code;
1022
                            unsigned cb_idx;
1023

    
1024
                            UPDATE_CACHE(re, gb);
1025
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1026

    
1027
                            if (code >= cb_size) {
1028
                                err_idx = code;
1029
                                goto err_cb_overflow;
1030
                            }
1031

    
1032
                            cb_idx = cb_vector_idx[code];
1033
                            cf = VMUL4(cf, vq, cb_idx, sf + idx);
1034
                        } while (len -= 4);
1035
                    }
1036
                    break;
1037

    
1038
                case 1:
1039
                    for (group = 0; group < g_len; group++, cfo+=128) {
1040
                        float *cf = cfo;
1041
                        int len = off_len;
1042

    
1043
                        do {
1044
                            int code;
1045
                            unsigned nnz;
1046
                            unsigned cb_idx;
1047
                            uint32_t bits;
1048

    
1049
                            UPDATE_CACHE(re, gb);
1050
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1051

    
1052
                            if (code >= cb_size) {
1053
                                err_idx = code;
1054
                                goto err_cb_overflow;
1055
                            }
1056

    
1057
#if MIN_CACHE_BITS < 20
1058
                            UPDATE_CACHE(re, gb);
1059
#endif
1060
                            cb_idx = cb_vector_idx[code];
1061
                            nnz = cb_idx >> 8 & 15;
1062
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1063
                            LAST_SKIP_BITS(re, gb, nnz);
1064
                            cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1065
                        } while (len -= 4);
1066
                    }
1067
                    break;
1068

    
1069
                case 2:
1070
                    for (group = 0; group < g_len; group++, cfo+=128) {
1071
                        float *cf = cfo;
1072
                        int len = off_len;
1073

    
1074
                        do {
1075
                            int code;
1076
                            unsigned cb_idx;
1077

    
1078
                            UPDATE_CACHE(re, gb);
1079
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1080

    
1081
                            if (code >= cb_size) {
1082
                                err_idx = code;
1083
                                goto err_cb_overflow;
1084
                            }
1085

    
1086
                            cb_idx = cb_vector_idx[code];
1087
                            cf = VMUL2(cf, vq, cb_idx, sf + idx);
1088
                        } while (len -= 2);
1089
                    }
1090
                    break;
1091

    
1092
                case 3:
1093
                case 4:
1094
                    for (group = 0; group < g_len; group++, cfo+=128) {
1095
                        float *cf = cfo;
1096
                        int len = off_len;
1097

    
1098
                        do {
1099
                            int code;
1100
                            unsigned nnz;
1101
                            unsigned cb_idx;
1102
                            unsigned sign;
1103

    
1104
                            UPDATE_CACHE(re, gb);
1105
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1106

    
1107
                            if (code >= cb_size) {
1108
                                err_idx = code;
1109
                                goto err_cb_overflow;
1110
                            }
1111

    
1112
                            cb_idx = cb_vector_idx[code];
1113
                            nnz = cb_idx >> 8 & 15;
1114
                            sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12);
1115
                            LAST_SKIP_BITS(re, gb, nnz);
1116
                            cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1117
                        } while (len -= 2);
1118
                    }
1119
                    break;
1120

    
1121
                default:
1122
                    for (group = 0; group < g_len; group++, cfo+=128) {
1123
                        float *cf = cfo;
1124
                        uint32_t *icf = (uint32_t *) cf;
1125
                        int len = off_len;
1126

    
1127
                        do {
1128
                            int code;
1129
                            unsigned nzt, nnz;
1130
                            unsigned cb_idx;
1131
                            uint32_t bits;
1132
                            int j;
1133

    
1134
                            UPDATE_CACHE(re, gb);
1135
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1136

    
1137
                            if (!code) {
1138
                                *icf++ = 0;
1139
                                *icf++ = 0;
1140
                                continue;
1141
                            }
1142

    
1143
                            if (code >= cb_size) {
1144
                                err_idx = code;
1145
                                goto err_cb_overflow;
1146
                            }
1147

    
1148
                            cb_idx = cb_vector_idx[code];
1149
                            nnz = cb_idx >> 12;
1150
                            nzt = cb_idx >> 8;
1151
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1152
                            LAST_SKIP_BITS(re, gb, nnz);
1153

    
1154
                            for (j = 0; j < 2; j++) {
1155
                                if (nzt & 1<<j) {
1156
                                    uint32_t b;
1157
                                    int n;
1158
                                    /* The total length of escape_sequence must be < 22 bits according
1159
                                       to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1160
                                    UPDATE_CACHE(re, gb);
1161
                                    b = GET_CACHE(re, gb);
1162
                                    b = 31 - av_log2(~b);
1163

    
1164
                                    if (b > 8) {
1165
                                        av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1166
                                        return -1;
1167
                                    }
1168

    
1169
#if MIN_CACHE_BITS < 21
1170
                                    LAST_SKIP_BITS(re, gb, b + 1);
1171
                                    UPDATE_CACHE(re, gb);
1172
#else
1173
                                    SKIP_BITS(re, gb, b + 1);
1174
#endif
1175
                                    b += 4;
1176
                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
1177
                                    LAST_SKIP_BITS(re, gb, b);
1178
                                    *icf++ = cbrt_tab[n] | (bits & 1<<31);
1179
                                    bits <<= 1;
1180
                                } else {
1181
                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1182
                                    *icf++ = (bits & 1<<31) | v;
1183
                                    bits <<= !!v;
1184
                                }
1185
                                cb_idx >>= 4;
1186
                            }
1187
                        } while (len -= 2);
1188

    
1189
                        ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1190
                    }
1191
                }
1192

    
1193
                CLOSE_READER(re, gb);
1194
            }
1195
        }
1196
        coef += g_len << 7;
1197
    }
1198

    
1199
    if (pulse_present) {
1200
        idx = 0;
1201
        for (i = 0; i < pulse->num_pulse; i++) {
1202
            float co = coef_base[ pulse->pos[i] ];
1203
            while (offsets[idx + 1] <= pulse->pos[i])
1204
                idx++;
1205
            if (band_type[idx] != NOISE_BT && sf[idx]) {
1206
                float ico = -pulse->amp[i];
1207
                if (co) {
1208
                    co /= sf[idx];
1209
                    ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
1210
                }
1211
                coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
1212
            }
1213
        }
1214
    }
1215
    return 0;
1216

    
1217
err_cb_overflow:
1218
    av_log(ac->avccontext, AV_LOG_ERROR,
1219
           "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
1220
           band_type[idx], err_idx, ff_aac_spectral_sizes[band_type[idx]]);
1221
    return -1;
1222
}
1223

    
1224
static av_always_inline float flt16_round(float pf)
1225
{
1226
    union float754 tmp;
1227
    tmp.f = pf;
1228
    tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
1229
    return tmp.f;
1230
}
1231

    
1232
static av_always_inline float flt16_even(float pf)
1233
{
1234
    union float754 tmp;
1235
    tmp.f = pf;
1236
    tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
1237
    return tmp.f;
1238
}
1239

    
1240
static av_always_inline float flt16_trunc(float pf)
1241
{
1242
    union float754 pun;
1243
    pun.f = pf;
1244
    pun.i &= 0xFFFF0000U;
1245
    return pun.f;
1246
}
1247

    
1248
static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef,
1249
                    int output_enable)
1250
{
1251
    const float a     = 0.953125; // 61.0 / 64
1252
    const float alpha = 0.90625;  // 29.0 / 32
1253
    float e0, e1;
1254
    float pv;
1255
    float k1, k2;
1256

    
1257
    k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
1258
    k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
1259

    
1260
    pv = flt16_round(k1 * ps->r0 + k2 * ps->r1);
1261
    if (output_enable)
1262
        *coef += pv * ac->sf_scale;
1263

    
1264
    e0 = *coef / ac->sf_scale;
1265
    e1 = e0 - k1 * ps->r0;
1266

    
1267
    ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1);
1268
    ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5 * (ps->r1 * ps->r1 + e1 * e1));
1269
    ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0);
1270
    ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5 * (ps->r0 * ps->r0 + e0 * e0));
1271

    
1272
    ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0));
1273
    ps->r0 = flt16_trunc(a * e0);
1274
}
1275

    
1276
/**
1277
 * Apply AAC-Main style frequency domain prediction.
1278
 */
1279
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
1280
{
1281
    int sfb, k;
1282

    
1283
    if (!sce->ics.predictor_initialized) {
1284
        reset_all_predictors(sce->predictor_state);
1285
        sce->ics.predictor_initialized = 1;
1286
    }
1287

    
1288
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
1289
        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
1290
            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
1291
                predict(ac, &sce->predictor_state[k], &sce->coeffs[k],
1292
                        sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
1293
            }
1294
        }
1295
        if (sce->ics.predictor_reset_group)
1296
            reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
1297
    } else
1298
        reset_all_predictors(sce->predictor_state);
1299
}
1300

    
1301
/**
1302
 * Decode an individual_channel_stream payload; reference: table 4.44.
1303
 *
1304
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
1305
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
1306
 *
1307
 * @return  Returns error status. 0 - OK, !0 - error
1308
 */
1309
static int decode_ics(AACContext *ac, SingleChannelElement *sce,
1310
                      GetBitContext *gb, int common_window, int scale_flag)
1311
{
1312
    Pulse pulse;
1313
    TemporalNoiseShaping    *tns = &sce->tns;
1314
    IndividualChannelStream *ics = &sce->ics;
1315
    float *out = sce->coeffs;
1316
    int global_gain, pulse_present = 0;
1317

    
1318
    /* This assignment is to silence a GCC warning about the variable being used
1319
     * uninitialized when in fact it always is.
1320
     */
1321
    pulse.num_pulse = 0;
1322

    
1323
    global_gain = get_bits(gb, 8);
1324

    
1325
    if (!common_window && !scale_flag) {
1326
        if (decode_ics_info(ac, ics, gb, 0) < 0)
1327
            return -1;
1328
    }
1329

    
1330
    if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
1331
        return -1;
1332
    if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
1333
        return -1;
1334

    
1335
    pulse_present = 0;
1336
    if (!scale_flag) {
1337
        if ((pulse_present = get_bits1(gb))) {
1338
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1339
                av_log(ac->avccontext, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
1340
                return -1;
1341
            }
1342
            if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
1343
                av_log(ac->avccontext, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
1344
                return -1;
1345
            }
1346
        }
1347
        if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
1348
            return -1;
1349
        if (get_bits1(gb)) {
1350
            av_log_missing_feature(ac->avccontext, "SSR", 1);
1351
            return -1;
1352
        }
1353
    }
1354

    
1355
    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
1356
        return -1;
1357

    
1358
    if (ac->m4ac.object_type == AOT_AAC_MAIN && !common_window)
1359
        apply_prediction(ac, sce);
1360

    
1361
    return 0;
1362
}
1363

    
1364
/**
1365
 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
1366
 */
1367
static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
1368
{
1369
    const IndividualChannelStream *ics = &cpe->ch[0].ics;
1370
    float *ch0 = cpe->ch[0].coeffs;
1371
    float *ch1 = cpe->ch[1].coeffs;
1372
    int g, i, group, idx = 0;
1373
    const uint16_t *offsets = ics->swb_offset;
1374
    for (g = 0; g < ics->num_window_groups; g++) {
1375
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1376
            if (cpe->ms_mask[idx] &&
1377
                    cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
1378
                for (group = 0; group < ics->group_len[g]; group++) {
1379
                    ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i],
1380
                                              ch1 + group * 128 + offsets[i],
1381
                                              offsets[i+1] - offsets[i]);
1382
                }
1383
            }
1384
        }
1385
        ch0 += ics->group_len[g] * 128;
1386
        ch1 += ics->group_len[g] * 128;
1387
    }
1388
}
1389

    
1390
/**
1391
 * intensity stereo decoding; reference: 4.6.8.2.3
1392
 *
1393
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
1394
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
1395
 *                      [3] reserved for scalable AAC
1396
 */
1397
static void apply_intensity_stereo(ChannelElement *cpe, int ms_present)
1398
{
1399
    const IndividualChannelStream *ics = &cpe->ch[1].ics;
1400
    SingleChannelElement         *sce1 = &cpe->ch[1];
1401
    float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
1402
    const uint16_t *offsets = ics->swb_offset;
1403
    int g, group, i, k, idx = 0;
1404
    int c;
1405
    float scale;
1406
    for (g = 0; g < ics->num_window_groups; g++) {
1407
        for (i = 0; i < ics->max_sfb;) {
1408
            if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) {
1409
                const int bt_run_end = sce1->band_type_run_end[idx];
1410
                for (; i < bt_run_end; i++, idx++) {
1411
                    c = -1 + 2 * (sce1->band_type[idx] - 14);
1412
                    if (ms_present)
1413
                        c *= 1 - 2 * cpe->ms_mask[idx];
1414
                    scale = c * sce1->sf[idx];
1415
                    for (group = 0; group < ics->group_len[g]; group++)
1416
                        for (k = offsets[i]; k < offsets[i + 1]; k++)
1417
                            coef1[group * 128 + k] = scale * coef0[group * 128 + k];
1418
                }
1419
            } else {
1420
                int bt_run_end = sce1->band_type_run_end[idx];
1421
                idx += bt_run_end - i;
1422
                i    = bt_run_end;
1423
            }
1424
        }
1425
        coef0 += ics->group_len[g] * 128;
1426
        coef1 += ics->group_len[g] * 128;
1427
    }
1428
}
1429

    
1430
/**
1431
 * Decode a channel_pair_element; reference: table 4.4.
1432
 *
1433
 * @param   elem_id Identifies the instance of a syntax element.
1434
 *
1435
 * @return  Returns error status. 0 - OK, !0 - error
1436
 */
1437
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
1438
{
1439
    int i, ret, common_window, ms_present = 0;
1440

    
1441
    common_window = get_bits1(gb);
1442
    if (common_window) {
1443
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
1444
            return -1;
1445
        i = cpe->ch[1].ics.use_kb_window[0];
1446
        cpe->ch[1].ics = cpe->ch[0].ics;
1447
        cpe->ch[1].ics.use_kb_window[1] = i;
1448
        ms_present = get_bits(gb, 2);
1449
        if (ms_present == 3) {
1450
            av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1451
            return -1;
1452
        } else if (ms_present)
1453
            decode_mid_side_stereo(cpe, gb, ms_present);
1454
    }
1455
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
1456
        return ret;
1457
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
1458
        return ret;
1459

    
1460
    if (common_window) {
1461
        if (ms_present)
1462
            apply_mid_side_stereo(ac, cpe);
1463
        if (ac->m4ac.object_type == AOT_AAC_MAIN) {
1464
            apply_prediction(ac, &cpe->ch[0]);
1465
            apply_prediction(ac, &cpe->ch[1]);
1466
        }
1467
    }
1468

    
1469
    apply_intensity_stereo(cpe, ms_present);
1470
    return 0;
1471
}
1472

    
1473
/**
1474
 * Decode coupling_channel_element; reference: table 4.8.
1475
 *
1476
 * @param   elem_id Identifies the instance of a syntax element.
1477
 *
1478
 * @return  Returns error status. 0 - OK, !0 - error
1479
 */
1480
static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
1481
{
1482
    int num_gain = 0;
1483
    int c, g, sfb, ret;
1484
    int sign;
1485
    float scale;
1486
    SingleChannelElement *sce = &che->ch[0];
1487
    ChannelCoupling     *coup = &che->coup;
1488

    
1489
    coup->coupling_point = 2 * get_bits1(gb);
1490
    coup->num_coupled = get_bits(gb, 3);
1491
    for (c = 0; c <= coup->num_coupled; c++) {
1492
        num_gain++;
1493
        coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
1494
        coup->id_select[c] = get_bits(gb, 4);
1495
        if (coup->type[c] == TYPE_CPE) {
1496
            coup->ch_select[c] = get_bits(gb, 2);
1497
            if (coup->ch_select[c] == 3)
1498
                num_gain++;
1499
        } else
1500
            coup->ch_select[c] = 2;
1501
    }
1502
    coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
1503

    
1504
    sign  = get_bits(gb, 1);
1505
    scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3));
1506

    
1507
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
1508
        return ret;
1509

    
1510
    for (c = 0; c < num_gain; c++) {
1511
        int idx  = 0;
1512
        int cge  = 1;
1513
        int gain = 0;
1514
        float gain_cache = 1.;
1515
        if (c) {
1516
            cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
1517
            gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
1518
            gain_cache = pow(scale, -gain);
1519
        }
1520
        if (coup->coupling_point == AFTER_IMDCT) {
1521
            coup->gain[c][0] = gain_cache;
1522
        } else {
1523
            for (g = 0; g < sce->ics.num_window_groups; g++) {
1524
                for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
1525
                    if (sce->band_type[idx] != ZERO_BT) {
1526
                        if (!cge) {
1527
                            int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
1528
                            if (t) {
1529
                                int s = 1;
1530
                                t = gain += t;
1531
                                if (sign) {
1532
                                    s  -= 2 * (t & 0x1);
1533
                                    t >>= 1;
1534
                                }
1535
                                gain_cache = pow(scale, -t) * s;
1536
                            }
1537
                        }
1538
                        coup->gain[c][idx] = gain_cache;
1539
                    }
1540
                }
1541
            }
1542
        }
1543
    }
1544
    return 0;
1545
}
1546

    
1547
/**
1548
 * Decode Spectral Band Replication extension data; reference: table 4.55.
1549
 *
1550
 * @param   crc flag indicating the presence of CRC checksum
1551
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1552
 *
1553
 * @return  Returns number of bytes consumed from the TYPE_FIL element.
1554
 */
1555
static int decode_sbr_extension(AACContext *ac, GetBitContext *gb,
1556
                                int crc, int cnt)
1557
{
1558
    // TODO : sbr_extension implementation
1559
    av_log_missing_feature(ac->avccontext, "SBR", 0);
1560
    skip_bits_long(gb, 8 * cnt - 4); // -4 due to reading extension type
1561
    return cnt;
1562
}
1563

    
1564
/**
1565
 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1566
 *
1567
 * @return  Returns number of bytes consumed.
1568
 */
1569
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
1570
                                         GetBitContext *gb)
1571
{
1572
    int i;
1573
    int num_excl_chan = 0;
1574

    
1575
    do {
1576
        for (i = 0; i < 7; i++)
1577
            che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
1578
    } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
1579

    
1580
    return num_excl_chan / 7;
1581
}
1582

    
1583
/**
1584
 * Decode dynamic range information; reference: table 4.52.
1585
 *
1586
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1587
 *
1588
 * @return  Returns number of bytes consumed.
1589
 */
1590
static int decode_dynamic_range(DynamicRangeControl *che_drc,
1591
                                GetBitContext *gb, int cnt)
1592
{
1593
    int n             = 1;
1594
    int drc_num_bands = 1;
1595
    int i;
1596

    
1597
    /* pce_tag_present? */
1598
    if (get_bits1(gb)) {
1599
        che_drc->pce_instance_tag  = get_bits(gb, 4);
1600
        skip_bits(gb, 4); // tag_reserved_bits
1601
        n++;
1602
    }
1603

    
1604
    /* excluded_chns_present? */
1605
    if (get_bits1(gb)) {
1606
        n += decode_drc_channel_exclusions(che_drc, gb);
1607
    }
1608

    
1609
    /* drc_bands_present? */
1610
    if (get_bits1(gb)) {
1611
        che_drc->band_incr            = get_bits(gb, 4);
1612
        che_drc->interpolation_scheme = get_bits(gb, 4);
1613
        n++;
1614
        drc_num_bands += che_drc->band_incr;
1615
        for (i = 0; i < drc_num_bands; i++) {
1616
            che_drc->band_top[i] = get_bits(gb, 8);
1617
            n++;
1618
        }
1619
    }
1620

    
1621
    /* prog_ref_level_present? */
1622
    if (get_bits1(gb)) {
1623
        che_drc->prog_ref_level = get_bits(gb, 7);
1624
        skip_bits1(gb); // prog_ref_level_reserved_bits
1625
        n++;
1626
    }
1627

    
1628
    for (i = 0; i < drc_num_bands; i++) {
1629
        che_drc->dyn_rng_sgn[i] = get_bits1(gb);
1630
        che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
1631
        n++;
1632
    }
1633

    
1634
    return n;
1635
}
1636

    
1637
/**
1638
 * Decode extension data (incomplete); reference: table 4.51.
1639
 *
1640
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1641
 *
1642
 * @return Returns number of bytes consumed
1643
 */
1644
static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt)
1645
{
1646
    int crc_flag = 0;
1647
    int res = cnt;
1648
    switch (get_bits(gb, 4)) { // extension type
1649
    case EXT_SBR_DATA_CRC:
1650
        crc_flag++;
1651
    case EXT_SBR_DATA:
1652
        res = decode_sbr_extension(ac, gb, crc_flag, cnt);
1653
        break;
1654
    case EXT_DYNAMIC_RANGE:
1655
        res = decode_dynamic_range(&ac->che_drc, gb, cnt);
1656
        break;
1657
    case EXT_FILL:
1658
    case EXT_FILL_DATA:
1659
    case EXT_DATA_ELEMENT:
1660
    default:
1661
        skip_bits_long(gb, 8 * cnt - 4);
1662
        break;
1663
    };
1664
    return res;
1665
}
1666

    
1667
/**
1668
 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
1669
 *
1670
 * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
1671
 * @param   coef    spectral coefficients
1672
 */
1673
static void apply_tns(float coef[1024], TemporalNoiseShaping *tns,
1674
                      IndividualChannelStream *ics, int decode)
1675
{
1676
    const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
1677
    int w, filt, m, i;
1678
    int bottom, top, order, start, end, size, inc;
1679
    float lpc[TNS_MAX_ORDER];
1680

    
1681
    for (w = 0; w < ics->num_windows; w++) {
1682
        bottom = ics->num_swb;
1683
        for (filt = 0; filt < tns->n_filt[w]; filt++) {
1684
            top    = bottom;
1685
            bottom = FFMAX(0, top - tns->length[w][filt]);
1686
            order  = tns->order[w][filt];
1687
            if (order == 0)
1688
                continue;
1689

    
1690
            // tns_decode_coef
1691
            compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
1692

    
1693
            start = ics->swb_offset[FFMIN(bottom, mmm)];
1694
            end   = ics->swb_offset[FFMIN(   top, mmm)];
1695
            if ((size = end - start) <= 0)
1696
                continue;
1697
            if (tns->direction[w][filt]) {
1698
                inc = -1;
1699
                start = end - 1;
1700
            } else {
1701
                inc = 1;
1702
            }
1703
            start += w * 128;
1704

    
1705
            // ar filter
1706
            for (m = 0; m < size; m++, start += inc)
1707
                for (i = 1; i <= FFMIN(m, order); i++)
1708
                    coef[start] -= coef[start - i * inc] * lpc[i - 1];
1709
        }
1710
    }
1711
}
1712

    
1713
/**
1714
 * Conduct IMDCT and windowing.
1715
 */
1716
static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
1717
{
1718
    IndividualChannelStream *ics = &sce->ics;
1719
    float *in    = sce->coeffs;
1720
    float *out   = sce->ret;
1721
    float *saved = sce->saved;
1722
    const float *swindow      = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
1723
    const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
1724
    const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
1725
    float *buf  = ac->buf_mdct;
1726
    float *temp = ac->temp;
1727
    int i;
1728

    
1729
    // imdct
1730
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1731
        if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE)
1732
            av_log(ac->avccontext, AV_LOG_WARNING,
1733
                   "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
1734
                   "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
1735
        for (i = 0; i < 1024; i += 128)
1736
            ff_imdct_half(&ac->mdct_small, buf + i, in + i);
1737
    } else
1738
        ff_imdct_half(&ac->mdct, buf, in);
1739

    
1740
    /* window overlapping
1741
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1742
     * and long to short transitions are considered to be short to short
1743
     * transitions. This leaves just two cases (long to long and short to short)
1744
     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
1745
     */
1746
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
1747
            (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
1748
        ac->dsp.vector_fmul_window(    out,               saved,            buf,         lwindow_prev, ac->add_bias, 512);
1749
    } else {
1750
        for (i = 0; i < 448; i++)
1751
            out[i] = saved[i] + ac->add_bias;
1752

    
1753
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1754
            ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, ac->add_bias, 64);
1755
            ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      ac->add_bias, 64);
1756
            ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      ac->add_bias, 64);
1757
            ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      ac->add_bias, 64);
1758
            ac->dsp.vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      ac->add_bias, 64);
1759
            memcpy(                    out + 448 + 4*128, temp, 64 * sizeof(float));
1760
        } else {
1761
            ac->dsp.vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, ac->add_bias, 64);
1762
            for (i = 576; i < 1024; i++)
1763
                out[i] = buf[i-512] + ac->add_bias;
1764
        }
1765
    }
1766

    
1767
    // buffer update
1768
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1769
        for (i = 0; i < 64; i++)
1770
            saved[i] = temp[64 + i] - ac->add_bias;
1771
        ac->dsp.vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 0, 64);
1772
        ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64);
1773
        ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64);
1774
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1775
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
1776
        memcpy(                    saved,       buf + 512,        448 * sizeof(float));
1777
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1778
    } else { // LONG_STOP or ONLY_LONG
1779
        memcpy(                    saved,       buf + 512,        512 * sizeof(float));
1780
    }
1781
}
1782

    
1783
/**
1784
 * Apply dependent channel coupling (applied before IMDCT).
1785
 *
1786
 * @param   index   index into coupling gain array
1787
 */
1788
static void apply_dependent_coupling(AACContext *ac,
1789
                                     SingleChannelElement *target,
1790
                                     ChannelElement *cce, int index)
1791
{
1792
    IndividualChannelStream *ics = &cce->ch[0].ics;
1793
    const uint16_t *offsets = ics->swb_offset;
1794
    float *dest = target->coeffs;
1795
    const float *src = cce->ch[0].coeffs;
1796
    int g, i, group, k, idx = 0;
1797
    if (ac->m4ac.object_type == AOT_AAC_LTP) {
1798
        av_log(ac->avccontext, AV_LOG_ERROR,
1799
               "Dependent coupling is not supported together with LTP\n");
1800
        return;
1801
    }
1802
    for (g = 0; g < ics->num_window_groups; g++) {
1803
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1804
            if (cce->ch[0].band_type[idx] != ZERO_BT) {
1805
                const float gain = cce->coup.gain[index][idx];
1806
                for (group = 0; group < ics->group_len[g]; group++) {
1807
                    for (k = offsets[i]; k < offsets[i + 1]; k++) {
1808
                        // XXX dsputil-ize
1809
                        dest[group * 128 + k] += gain * src[group * 128 + k];
1810
                    }
1811
                }
1812
            }
1813
        }
1814
        dest += ics->group_len[g] * 128;
1815
        src  += ics->group_len[g] * 128;
1816
    }
1817
}
1818

    
1819
/**
1820
 * Apply independent channel coupling (applied after IMDCT).
1821
 *
1822
 * @param   index   index into coupling gain array
1823
 */
1824
static void apply_independent_coupling(AACContext *ac,
1825
                                       SingleChannelElement *target,
1826
                                       ChannelElement *cce, int index)
1827
{
1828
    int i;
1829
    const float gain = cce->coup.gain[index][0];
1830
    const float bias = ac->add_bias;
1831
    const float *src = cce->ch[0].ret;
1832
    float *dest = target->ret;
1833

    
1834
    for (i = 0; i < 1024; i++)
1835
        dest[i] += gain * (src[i] - bias);
1836
}
1837

    
1838
/**
1839
 * channel coupling transformation interface
1840
 *
1841
 * @param   index   index into coupling gain array
1842
 * @param   apply_coupling_method   pointer to (in)dependent coupling function
1843
 */
1844
static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
1845
                                   enum RawDataBlockType type, int elem_id,
1846
                                   enum CouplingPoint coupling_point,
1847
                                   void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
1848
{
1849
    int i, c;
1850

    
1851
    for (i = 0; i < MAX_ELEM_ID; i++) {
1852
        ChannelElement *cce = ac->che[TYPE_CCE][i];
1853
        int index = 0;
1854

    
1855
        if (cce && cce->coup.coupling_point == coupling_point) {
1856
            ChannelCoupling *coup = &cce->coup;
1857

    
1858
            for (c = 0; c <= coup->num_coupled; c++) {
1859
                if (coup->type[c] == type && coup->id_select[c] == elem_id) {
1860
                    if (coup->ch_select[c] != 1) {
1861
                        apply_coupling_method(ac, &cc->ch[0], cce, index);
1862
                        if (coup->ch_select[c] != 0)
1863
                            index++;
1864
                    }
1865
                    if (coup->ch_select[c] != 2)
1866
                        apply_coupling_method(ac, &cc->ch[1], cce, index++);
1867
                } else
1868
                    index += 1 + (coup->ch_select[c] == 3);
1869
            }
1870
        }
1871
    }
1872
}
1873

    
1874
/**
1875
 * Convert spectral data to float samples, applying all supported tools as appropriate.
1876
 */
1877
static void spectral_to_sample(AACContext *ac)
1878
{
1879
    int i, type;
1880
    for (type = 3; type >= 0; type--) {
1881
        for (i = 0; i < MAX_ELEM_ID; i++) {
1882
            ChannelElement *che = ac->che[type][i];
1883
            if (che) {
1884
                if (type <= TYPE_CPE)
1885
                    apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling);
1886
                if (che->ch[0].tns.present)
1887
                    apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
1888
                if (che->ch[1].tns.present)
1889
                    apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
1890
                if (type <= TYPE_CPE)
1891
                    apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
1892
                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT)
1893
                    imdct_and_windowing(ac, &che->ch[0]);
1894
                if (type == TYPE_CPE)
1895
                    imdct_and_windowing(ac, &che->ch[1]);
1896
                if (type <= TYPE_CCE)
1897
                    apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling);
1898
            }
1899
        }
1900
    }
1901
}
1902

    
1903
static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
1904
{
1905
    int size;
1906
    AACADTSHeaderInfo hdr_info;
1907

    
1908
    size = ff_aac_parse_header(gb, &hdr_info);
1909
    if (size > 0) {
1910
        if (ac->output_configured != OC_LOCKED && hdr_info.chan_config) {
1911
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
1912
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
1913
            ac->m4ac.chan_config = hdr_info.chan_config;
1914
            if (set_default_channel_config(ac, new_che_pos, hdr_info.chan_config))
1915
                return -7;
1916
            if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME))
1917
                return -7;
1918
        } else if (ac->output_configured != OC_LOCKED) {
1919
            ac->output_configured = OC_NONE;
1920
        }
1921
        if (ac->output_configured != OC_LOCKED)
1922
            ac->m4ac.sbr = -1;
1923
        ac->m4ac.sample_rate     = hdr_info.sample_rate;
1924
        ac->m4ac.sampling_index  = hdr_info.sampling_index;
1925
        ac->m4ac.object_type     = hdr_info.object_type;
1926
        if (!ac->avccontext->sample_rate)
1927
            ac->avccontext->sample_rate = hdr_info.sample_rate;
1928
        if (hdr_info.num_aac_frames == 1) {
1929
            if (!hdr_info.crc_absent)
1930
                skip_bits(gb, 16);
1931
        } else {
1932
            av_log_missing_feature(ac->avccontext, "More than one AAC RDB per ADTS frame is", 0);
1933
            return -1;
1934
        }
1935
    }
1936
    return size;
1937
}
1938

    
1939
static int aac_decode_frame(AVCodecContext *avccontext, void *data,
1940
                            int *data_size, AVPacket *avpkt)
1941
{
1942
    const uint8_t *buf = avpkt->data;
1943
    int buf_size = avpkt->size;
1944
    AACContext *ac = avccontext->priv_data;
1945
    ChannelElement *che = NULL;
1946
    GetBitContext gb;
1947
    enum RawDataBlockType elem_type;
1948
    int err, elem_id, data_size_tmp;
1949
    int buf_consumed;
1950
    int samples = 1024, multiplier;
1951

    
1952
    init_get_bits(&gb, buf, buf_size * 8);
1953

    
1954
    if (show_bits(&gb, 12) == 0xfff) {
1955
        if (parse_adts_frame_header(ac, &gb) < 0) {
1956
            av_log(avccontext, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
1957
            return -1;
1958
        }
1959
        if (ac->m4ac.sampling_index > 12) {
1960
            av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
1961
            return -1;
1962
        }
1963
    }
1964

    
1965
    // parse
1966
    while ((elem_type = get_bits(&gb, 3)) != TYPE_END) {
1967
        elem_id = get_bits(&gb, 4);
1968

    
1969
        if (elem_type < TYPE_DSE && !(che=get_che(ac, elem_type, elem_id))) {
1970
            av_log(ac->avccontext, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", elem_type, elem_id);
1971
            return -1;
1972
        }
1973

    
1974
        switch (elem_type) {
1975

    
1976
        case TYPE_SCE:
1977
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
1978
            break;
1979

    
1980
        case TYPE_CPE:
1981
            err = decode_cpe(ac, &gb, che);
1982
            break;
1983

    
1984
        case TYPE_CCE:
1985
            err = decode_cce(ac, &gb, che);
1986
            break;
1987

    
1988
        case TYPE_LFE:
1989
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
1990
            break;
1991

    
1992
        case TYPE_DSE:
1993
            err = skip_data_stream_element(ac, &gb);
1994
            break;
1995

    
1996
        case TYPE_PCE: {
1997
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
1998
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
1999
            if ((err = decode_pce(ac, new_che_pos, &gb)))
2000
                break;
2001
            if (ac->output_configured > OC_TRIAL_PCE)
2002
                av_log(avccontext, AV_LOG_ERROR,
2003
                       "Not evaluating a further program_config_element as this construct is dubious at best.\n");
2004
            else
2005
                err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE);
2006
            break;
2007
        }
2008

    
2009
        case TYPE_FIL:
2010
            if (elem_id == 15)
2011
                elem_id += get_bits(&gb, 8) - 1;
2012
            if (get_bits_left(&gb) < 8 * elem_id) {
2013
                    av_log(avccontext, AV_LOG_ERROR, overread_err);
2014
                    return -1;
2015
            }
2016
            while (elem_id > 0)
2017
                elem_id -= decode_extension_payload(ac, &gb, elem_id);
2018
            err = 0; /* FIXME */
2019
            break;
2020

    
2021
        default:
2022
            err = -1; /* should not happen, but keeps compiler happy */
2023
            break;
2024
        }
2025

    
2026
        if (err)
2027
            return err;
2028

    
2029
        if (get_bits_left(&gb) < 3) {
2030
            av_log(avccontext, AV_LOG_ERROR, overread_err);
2031
            return -1;
2032
        }
2033
    }
2034

    
2035
    spectral_to_sample(ac);
2036

    
2037
    multiplier = 1;
2038
    samples <<= multiplier;
2039
    if (ac->output_configured < OC_LOCKED) {
2040
        avccontext->sample_rate = ac->m4ac.sample_rate << multiplier;
2041
        avccontext->frame_size = samples;
2042
    }
2043

    
2044
    data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t);
2045
    if (*data_size < data_size_tmp) {
2046
        av_log(avccontext, AV_LOG_ERROR,
2047
               "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
2048
               *data_size, data_size_tmp);
2049
        return -1;
2050
    }
2051
    *data_size = data_size_tmp;
2052

    
2053
    ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, 1024, avccontext->channels);
2054

    
2055
    if (ac->output_configured)
2056
        ac->output_configured = OC_LOCKED;
2057

    
2058
    buf_consumed = (get_bits_count(&gb) + 7) >> 3;
2059
    return buf_size > buf_consumed ? buf_consumed : buf_size;
2060
}
2061

    
2062
static av_cold int aac_decode_close(AVCodecContext *avccontext)
2063
{
2064
    AACContext *ac = avccontext->priv_data;
2065
    int i, type;
2066

    
2067
    for (i = 0; i < MAX_ELEM_ID; i++) {
2068
        for (type = 0; type < 4; type++)
2069
            av_freep(&ac->che[type][i]);
2070
    }
2071

    
2072
    ff_mdct_end(&ac->mdct);
2073
    ff_mdct_end(&ac->mdct_small);
2074
    return 0;
2075
}
2076

    
2077
AVCodec aac_decoder = {
2078
    "aac",
2079
    CODEC_TYPE_AUDIO,
2080
    CODEC_ID_AAC,
2081
    sizeof(AACContext),
2082
    aac_decode_init,
2083
    NULL,
2084
    aac_decode_close,
2085
    aac_decode_frame,
2086
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
2087
    .sample_fmts = (const enum SampleFormat[]) {
2088
        SAMPLE_FMT_S16,SAMPLE_FMT_NONE
2089
    },
2090
    .channel_layouts = aac_channel_layout,
2091
};