Statistics
| Branch: | Revision:

ffmpeg / libavcodec / aacdec.c @ 70c99adb

History | View | Annotate | Download (73.5 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
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
 * Y                    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
 * Y                    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 "cbrt_tablegen.h"
90
#include "sbr.h"
91
#include "aacsbr.h"
92
#include "mpeg4audio.h"
93
#include "aacadtsdec.h"
94

    
95
#include <assert.h>
96
#include <errno.h>
97
#include <math.h>
98
#include <string.h>
99

    
100
#if ARCH_ARM
101
#   include "arm/aac.h"
102
#endif
103

    
104
union float754 {
105
    float f;
106
    uint32_t i;
107
};
108

    
109
static VLC vlc_scalefactors;
110
static VLC vlc_spectral[11];
111

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

    
114
static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
115
{
116
    /* Some buggy encoders appear to set all elem_ids to zero and rely on
117
    channels always occurring in the same order. This is expressly forbidden
118
    by the spec but we will try to work around it.
119
    */
120
    int err_printed = 0;
121
    while (ac->tags_seen_this_frame[type][elem_id] && elem_id < MAX_ELEM_ID) {
122
        if (ac->output_configured < OC_LOCKED && !err_printed) {
123
            av_log(ac->avctx, AV_LOG_WARNING, "Duplicate channel tag found, attempting to remap.\n");
124
            err_printed = 1;
125
        }
126
        elem_id++;
127
    }
128
    if (elem_id == MAX_ELEM_ID)
129
        return NULL;
130
    ac->tags_seen_this_frame[type][elem_id] = 1;
131

    
132
    if (ac->tag_che_map[type][elem_id]) {
133
        return ac->tag_che_map[type][elem_id];
134
    }
135
    if (ac->tags_mapped >= tags_per_config[ac->m4ac.chan_config]) {
136
        return NULL;
137
    }
138
    switch (ac->m4ac.chan_config) {
139
    case 7:
140
        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
141
            ac->tags_mapped++;
142
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
143
        }
144
    case 6:
145
        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
146
           instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have
147
           encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */
148
        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
149
            ac->tags_mapped++;
150
            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
151
        }
152
    case 5:
153
        if (ac->tags_mapped == 2 && type == TYPE_CPE) {
154
            ac->tags_mapped++;
155
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
156
        }
157
    case 4:
158
        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {
159
            ac->tags_mapped++;
160
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
161
        }
162
    case 3:
163
    case 2:
164
        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {
165
            ac->tags_mapped++;
166
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
167
        } else if (ac->m4ac.chan_config == 2) {
168
            return NULL;
169
        }
170
    case 1:
171
        if (!ac->tags_mapped && type == TYPE_SCE) {
172
            ac->tags_mapped++;
173
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
174
        }
175
    default:
176
        return NULL;
177
    }
178
}
179

    
180
/**
181
 * Check for the channel element in the current channel position configuration.
182
 * If it exists, make sure the appropriate element is allocated and map the
183
 * channel order to match the internal FFmpeg channel layout.
184
 *
185
 * @param   che_pos current channel position configuration
186
 * @param   type channel element type
187
 * @param   id channel element id
188
 * @param   channels count of the number of channels in the configuration
189
 *
190
 * @return  Returns error status. 0 - OK, !0 - error
191
 */
192
static av_cold int che_configure(AACContext *ac,
193
                         enum ChannelPosition che_pos[4][MAX_ELEM_ID],
194
                         int type, int id,
195
                         int *channels)
196
{
197
    if (che_pos[type][id]) {
198
        if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
199
            return AVERROR(ENOMEM);
200
        ff_aac_sbr_ctx_init(&ac->che[type][id]->sbr);
201
        if (type != TYPE_CCE) {
202
            ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;
203
            if (type == TYPE_CPE ||
204
                (type == TYPE_SCE && ac->m4ac.ps == 1)) {
205
                ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;
206
            }
207
        }
208
    } else {
209
        if (ac->che[type][id])
210
            ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr);
211
        av_freep(&ac->che[type][id]);
212
    }
213
    return 0;
214
}
215

    
216
/**
217
 * Configure output channel order based on the current program configuration element.
218
 *
219
 * @param   che_pos current channel position configuration
220
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
221
 *
222
 * @return  Returns error status. 0 - OK, !0 - error
223
 */
224
static av_cold int output_configure(AACContext *ac,
225
                            enum ChannelPosition che_pos[4][MAX_ELEM_ID],
226
                            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
227
                            int channel_config, enum OCStatus oc_type)
228
{
229
    AVCodecContext *avctx = ac->avctx;
230
    int i, type, channels = 0, ret;
231

    
232
    if (new_che_pos != che_pos)
233
    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
234

    
235
    if (channel_config) {
236
        for (i = 0; i < tags_per_config[channel_config]; i++) {
237
            if ((ret = che_configure(ac, che_pos,
238
                                     aac_channel_layout_map[channel_config - 1][i][0],
239
                                     aac_channel_layout_map[channel_config - 1][i][1],
240
                                     &channels)))
241
                return ret;
242
        }
243

    
244
        memset(ac->tag_che_map, 0,       4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
245
        ac->tags_mapped = 0;
246

    
247
        avctx->channel_layout = aac_channel_layout[channel_config - 1];
248
    } else {
249
        /* Allocate or free elements depending on if they are in the
250
         * current program configuration.
251
         *
252
         * Set up default 1:1 output mapping.
253
         *
254
         * For a 5.1 stream the output order will be:
255
         *    [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
256
         */
257

    
258
        for (i = 0; i < MAX_ELEM_ID; i++) {
259
            for (type = 0; type < 4; type++) {
260
                if ((ret = che_configure(ac, che_pos, type, i, &channels)))
261
                    return ret;
262
            }
263
        }
264

    
265
        memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
266
        ac->tags_mapped = 4 * MAX_ELEM_ID;
267

    
268
        avctx->channel_layout = 0;
269
    }
270

    
271
    avctx->channels = channels;
272

    
273
    ac->output_configured = oc_type;
274

    
275
    return 0;
276
}
277

    
278
/**
279
 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
280
 *
281
 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
282
 * @param sce_map mono (Single Channel Element) map
283
 * @param type speaker type/position for these channels
284
 */
285
static void decode_channel_map(enum ChannelPosition *cpe_map,
286
                               enum ChannelPosition *sce_map,
287
                               enum ChannelPosition type,
288
                               GetBitContext *gb, int n)
289
{
290
    while (n--) {
291
        enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map
292
        map[get_bits(gb, 4)] = type;
293
    }
294
}
295

    
296
/**
297
 * Decode program configuration element; reference: table 4.2.
298
 *
299
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
300
 *
301
 * @return  Returns error status. 0 - OK, !0 - error
302
 */
303
static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
304
                      GetBitContext *gb)
305
{
306
    int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
307
    int comment_len;
308

    
309
    skip_bits(gb, 2);  // object_type
310

    
311
    sampling_index = get_bits(gb, 4);
312
    if (ac->m4ac.sampling_index != sampling_index)
313
        av_log(ac->avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
314

    
315
    num_front       = get_bits(gb, 4);
316
    num_side        = get_bits(gb, 4);
317
    num_back        = get_bits(gb, 4);
318
    num_lfe         = get_bits(gb, 2);
319
    num_assoc_data  = get_bits(gb, 3);
320
    num_cc          = get_bits(gb, 4);
321

    
322
    if (get_bits1(gb))
323
        skip_bits(gb, 4); // mono_mixdown_tag
324
    if (get_bits1(gb))
325
        skip_bits(gb, 4); // stereo_mixdown_tag
326

    
327
    if (get_bits1(gb))
328
        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
329

    
330
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
331
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE,  gb, num_side );
332
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK,  gb, num_back );
333
    decode_channel_map(NULL,                  new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE,   gb, num_lfe  );
334

    
335
    skip_bits_long(gb, 4 * num_assoc_data);
336

    
337
    decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC,    gb, num_cc   );
338

    
339
    align_get_bits(gb);
340

    
341
    /* comment field, first byte is length */
342
    comment_len = get_bits(gb, 8) * 8;
343
    if (get_bits_left(gb) < comment_len) {
344
        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
345
        return -1;
346
    }
347
    skip_bits_long(gb, comment_len);
348
    return 0;
349
}
350

    
351
/**
352
 * Set up channel positions based on a default channel configuration
353
 * as specified in table 1.17.
354
 *
355
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
356
 *
357
 * @return  Returns error status. 0 - OK, !0 - error
358
 */
359
static av_cold int set_default_channel_config(AACContext *ac,
360
                                      enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
361
                                      int channel_config)
362
{
363
    if (channel_config < 1 || channel_config > 7) {
364
        av_log(ac->avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
365
               channel_config);
366
        return -1;
367
    }
368

    
369
    /* default channel configurations:
370
     *
371
     * 1ch : front center (mono)
372
     * 2ch : L + R (stereo)
373
     * 3ch : front center + L + R
374
     * 4ch : front center + L + R + back center
375
     * 5ch : front center + L + R + back stereo
376
     * 6ch : front center + L + R + back stereo + LFE
377
     * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
378
     */
379

    
380
    if (channel_config != 2)
381
        new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono)
382
    if (channel_config > 1)
383
        new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo)
384
    if (channel_config == 4)
385
        new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK;  // back center
386
    if (channel_config > 4)
387
        new_che_pos[TYPE_CPE][(channel_config == 7) + 1]
388
        = AAC_CHANNEL_BACK;  // back stereo
389
    if (channel_config > 5)
390
        new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE;   // LFE
391
    if (channel_config == 7)
392
        new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right
393

    
394
    return 0;
395
}
396

    
397
/**
398
 * Decode GA "General Audio" specific configuration; reference: table 4.1.
399
 *
400
 * @return  Returns error status. 0 - OK, !0 - error
401
 */
402
static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb,
403
                                     int channel_config)
404
{
405
    enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
406
    int extension_flag, ret;
407

    
408
    if (get_bits1(gb)) { // frameLengthFlag
409
        av_log_missing_feature(ac->avctx, "960/120 MDCT window is", 1);
410
        return -1;
411
    }
412

    
413
    if (get_bits1(gb))       // dependsOnCoreCoder
414
        skip_bits(gb, 14);   // coreCoderDelay
415
    extension_flag = get_bits1(gb);
416

    
417
    if (ac->m4ac.object_type == AOT_AAC_SCALABLE ||
418
        ac->m4ac.object_type == AOT_ER_AAC_SCALABLE)
419
        skip_bits(gb, 3);     // layerNr
420

    
421
    memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
422
    if (channel_config == 0) {
423
        skip_bits(gb, 4);  // element_instance_tag
424
        if ((ret = decode_pce(ac, new_che_pos, gb)))
425
            return ret;
426
    } else {
427
        if ((ret = set_default_channel_config(ac, new_che_pos, channel_config)))
428
            return ret;
429
    }
430
    if ((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
431
        return ret;
432

    
433
    if (extension_flag) {
434
        switch (ac->m4ac.object_type) {
435
        case AOT_ER_BSAC:
436
            skip_bits(gb, 5);    // numOfSubFrame
437
            skip_bits(gb, 11);   // layer_length
438
            break;
439
        case AOT_ER_AAC_LC:
440
        case AOT_ER_AAC_LTP:
441
        case AOT_ER_AAC_SCALABLE:
442
        case AOT_ER_AAC_LD:
443
            skip_bits(gb, 3);  /* aacSectionDataResilienceFlag
444
                                    * aacScalefactorDataResilienceFlag
445
                                    * aacSpectralDataResilienceFlag
446
                                    */
447
            break;
448
        }
449
        skip_bits1(gb);    // extensionFlag3 (TBD in version 3)
450
    }
451
    return 0;
452
}
453

    
454
/**
455
 * Decode audio specific configuration; reference: table 1.13.
456
 *
457
 * @param   data        pointer to AVCodecContext extradata
458
 * @param   data_size   size of AVCCodecContext extradata
459
 *
460
 * @return  Returns error status. 0 - OK, !0 - error
461
 */
462
static int decode_audio_specific_config(AACContext *ac, void *data,
463
                                        int data_size)
464
{
465
    GetBitContext gb;
466
    int i;
467

    
468
    init_get_bits(&gb, data, data_size * 8);
469

    
470
    if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0)
471
        return -1;
472
    if (ac->m4ac.sampling_index > 12) {
473
        av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
474
        return -1;
475
    }
476
    if (ac->m4ac.sbr == 1 && ac->m4ac.ps == -1)
477
        ac->m4ac.ps = 1;
478

    
479
    skip_bits_long(&gb, i);
480

    
481
    switch (ac->m4ac.object_type) {
482
    case AOT_AAC_MAIN:
483
    case AOT_AAC_LC:
484
        if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config))
485
            return -1;
486
        break;
487
    default:
488
        av_log(ac->avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
489
               ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type);
490
        return -1;
491
    }
492
    return 0;
493
}
494

    
495
/**
496
 * linear congruential pseudorandom number generator
497
 *
498
 * @param   previous_val    pointer to the current state of the generator
499
 *
500
 * @return  Returns a 32-bit pseudorandom integer
501
 */
502
static av_always_inline int lcg_random(int previous_val)
503
{
504
    return previous_val * 1664525 + 1013904223;
505
}
506

    
507
static av_always_inline void reset_predict_state(PredictorState *ps)
508
{
509
    ps->r0   = 0.0f;
510
    ps->r1   = 0.0f;
511
    ps->cor0 = 0.0f;
512
    ps->cor1 = 0.0f;
513
    ps->var0 = 1.0f;
514
    ps->var1 = 1.0f;
515
}
516

    
517
static void reset_all_predictors(PredictorState *ps)
518
{
519
    int i;
520
    for (i = 0; i < MAX_PREDICTORS; i++)
521
        reset_predict_state(&ps[i]);
522
}
523

    
524
static void reset_predictor_group(PredictorState *ps, int group_num)
525
{
526
    int i;
527
    for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
528
        reset_predict_state(&ps[i]);
529
}
530

    
531
#define AAC_INIT_VLC_STATIC(num, size) \
532
    INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num], \
533
         ff_aac_spectral_bits[num], sizeof( ff_aac_spectral_bits[num][0]), sizeof( ff_aac_spectral_bits[num][0]), \
534
        ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), sizeof(ff_aac_spectral_codes[num][0]), \
535
        size);
536

    
537
static av_cold int aac_decode_init(AVCodecContext *avctx)
538
{
539
    AACContext *ac = avctx->priv_data;
540

    
541
    ac->avctx = avctx;
542
    ac->m4ac.sample_rate = avctx->sample_rate;
543

    
544
    if (avctx->extradata_size > 0) {
545
        if (decode_audio_specific_config(ac, avctx->extradata, avctx->extradata_size))
546
            return -1;
547
    }
548

    
549
    avctx->sample_fmt = SAMPLE_FMT_S16;
550

    
551
    AAC_INIT_VLC_STATIC( 0, 304);
552
    AAC_INIT_VLC_STATIC( 1, 270);
553
    AAC_INIT_VLC_STATIC( 2, 550);
554
    AAC_INIT_VLC_STATIC( 3, 300);
555
    AAC_INIT_VLC_STATIC( 4, 328);
556
    AAC_INIT_VLC_STATIC( 5, 294);
557
    AAC_INIT_VLC_STATIC( 6, 306);
558
    AAC_INIT_VLC_STATIC( 7, 268);
559
    AAC_INIT_VLC_STATIC( 8, 510);
560
    AAC_INIT_VLC_STATIC( 9, 366);
561
    AAC_INIT_VLC_STATIC(10, 462);
562

    
563
    ff_aac_sbr_init();
564

    
565
    dsputil_init(&ac->dsp, avctx);
566

    
567
    ac->random_state = 0x1f2e3d4c;
568

    
569
    // -1024 - Compensate wrong IMDCT method.
570
    // 32768 - Required to scale values to the correct range for the bias method
571
    //         for float to int16 conversion.
572

    
573
    if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
574
        ac->add_bias  = 385.0f;
575
        ac->sf_scale  = 1. / (-1024. * 32768.);
576
        ac->sf_offset = 0;
577
    } else {
578
        ac->add_bias  = 0.0f;
579
        ac->sf_scale  = 1. / -1024.;
580
        ac->sf_offset = 60;
581
    }
582

    
583
    ff_aac_tableinit();
584

    
585
    INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
586
                    ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
587
                    ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
588
                    352);
589

    
590
    ff_mdct_init(&ac->mdct, 11, 1, 1.0);
591
    ff_mdct_init(&ac->mdct_small, 8, 1, 1.0);
592
    // window initialization
593
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
594
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
595
    ff_init_ff_sine_windows(10);
596
    ff_init_ff_sine_windows( 7);
597

    
598
    cbrt_tableinit();
599

    
600
    return 0;
601
}
602

    
603
/**
604
 * Skip data_stream_element; reference: table 4.10.
605
 */
606
static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
607
{
608
    int byte_align = get_bits1(gb);
609
    int count = get_bits(gb, 8);
610
    if (count == 255)
611
        count += get_bits(gb, 8);
612
    if (byte_align)
613
        align_get_bits(gb);
614

    
615
    if (get_bits_left(gb) < 8 * count) {
616
        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
617
        return -1;
618
    }
619
    skip_bits_long(gb, 8 * count);
620
    return 0;
621
}
622

    
623
static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
624
                             GetBitContext *gb)
625
{
626
    int sfb;
627
    if (get_bits1(gb)) {
628
        ics->predictor_reset_group = get_bits(gb, 5);
629
        if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
630
            av_log(ac->avctx, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
631
            return -1;
632
        }
633
    }
634
    for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->m4ac.sampling_index]); sfb++) {
635
        ics->prediction_used[sfb] = get_bits1(gb);
636
    }
637
    return 0;
638
}
639

    
640
/**
641
 * Decode Individual Channel Stream info; reference: table 4.6.
642
 *
643
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
644
 */
645
static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
646
                           GetBitContext *gb, int common_window)
647
{
648
    if (get_bits1(gb)) {
649
        av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
650
        memset(ics, 0, sizeof(IndividualChannelStream));
651
        return -1;
652
    }
653
    ics->window_sequence[1] = ics->window_sequence[0];
654
    ics->window_sequence[0] = get_bits(gb, 2);
655
    ics->use_kb_window[1]   = ics->use_kb_window[0];
656
    ics->use_kb_window[0]   = get_bits1(gb);
657
    ics->num_window_groups  = 1;
658
    ics->group_len[0]       = 1;
659
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
660
        int i;
661
        ics->max_sfb = get_bits(gb, 4);
662
        for (i = 0; i < 7; i++) {
663
            if (get_bits1(gb)) {
664
                ics->group_len[ics->num_window_groups - 1]++;
665
            } else {
666
                ics->num_window_groups++;
667
                ics->group_len[ics->num_window_groups - 1] = 1;
668
            }
669
        }
670
        ics->num_windows       = 8;
671
        ics->swb_offset        =    ff_swb_offset_128[ac->m4ac.sampling_index];
672
        ics->num_swb           =   ff_aac_num_swb_128[ac->m4ac.sampling_index];
673
        ics->tns_max_bands     = ff_tns_max_bands_128[ac->m4ac.sampling_index];
674
        ics->predictor_present = 0;
675
    } else {
676
        ics->max_sfb               = get_bits(gb, 6);
677
        ics->num_windows           = 1;
678
        ics->swb_offset            =    ff_swb_offset_1024[ac->m4ac.sampling_index];
679
        ics->num_swb               =   ff_aac_num_swb_1024[ac->m4ac.sampling_index];
680
        ics->tns_max_bands         = ff_tns_max_bands_1024[ac->m4ac.sampling_index];
681
        ics->predictor_present     = get_bits1(gb);
682
        ics->predictor_reset_group = 0;
683
        if (ics->predictor_present) {
684
            if (ac->m4ac.object_type == AOT_AAC_MAIN) {
685
                if (decode_prediction(ac, ics, gb)) {
686
                    memset(ics, 0, sizeof(IndividualChannelStream));
687
                    return -1;
688
                }
689
            } else if (ac->m4ac.object_type == AOT_AAC_LC) {
690
                av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
691
                memset(ics, 0, sizeof(IndividualChannelStream));
692
                return -1;
693
            } else {
694
                av_log_missing_feature(ac->avctx, "Predictor bit set but LTP is", 1);
695
                memset(ics, 0, sizeof(IndividualChannelStream));
696
                return -1;
697
            }
698
        }
699
    }
700

    
701
    if (ics->max_sfb > ics->num_swb) {
702
        av_log(ac->avctx, AV_LOG_ERROR,
703
               "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
704
               ics->max_sfb, ics->num_swb);
705
        memset(ics, 0, sizeof(IndividualChannelStream));
706
        return -1;
707
    }
708

    
709
    return 0;
710
}
711

    
712
/**
713
 * Decode band types (section_data payload); reference: table 4.46.
714
 *
715
 * @param   band_type           array of the used band type
716
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
717
 *
718
 * @return  Returns error status. 0 - OK, !0 - error
719
 */
720
static int decode_band_types(AACContext *ac, enum BandType band_type[120],
721
                             int band_type_run_end[120], GetBitContext *gb,
722
                             IndividualChannelStream *ics)
723
{
724
    int g, idx = 0;
725
    const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
726
    for (g = 0; g < ics->num_window_groups; g++) {
727
        int k = 0;
728
        while (k < ics->max_sfb) {
729
            uint8_t sect_end = k;
730
            int sect_len_incr;
731
            int sect_band_type = get_bits(gb, 4);
732
            if (sect_band_type == 12) {
733
                av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
734
                return -1;
735
            }
736
            while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1)
737
                sect_end += sect_len_incr;
738
            sect_end += sect_len_incr;
739
            if (get_bits_left(gb) < 0) {
740
                av_log(ac->avctx, AV_LOG_ERROR, overread_err);
741
                return -1;
742
            }
743
            if (sect_end > ics->max_sfb) {
744
                av_log(ac->avctx, AV_LOG_ERROR,
745
                       "Number of bands (%d) exceeds limit (%d).\n",
746
                       sect_end, ics->max_sfb);
747
                return -1;
748
            }
749
            for (; k < sect_end; k++) {
750
                band_type        [idx]   = sect_band_type;
751
                band_type_run_end[idx++] = sect_end;
752
            }
753
        }
754
    }
755
    return 0;
756
}
757

    
758
/**
759
 * Decode scalefactors; reference: table 4.47.
760
 *
761
 * @param   global_gain         first scalefactor value as scalefactors are differentially coded
762
 * @param   band_type           array of the used band type
763
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
764
 * @param   sf                  array of scalefactors or intensity stereo positions
765
 *
766
 * @return  Returns error status. 0 - OK, !0 - error
767
 */
768
static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
769
                               unsigned int global_gain,
770
                               IndividualChannelStream *ics,
771
                               enum BandType band_type[120],
772
                               int band_type_run_end[120])
773
{
774
    const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0);
775
    int g, i, idx = 0;
776
    int offset[3] = { global_gain, global_gain - 90, 100 };
777
    int noise_flag = 1;
778
    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
779
    for (g = 0; g < ics->num_window_groups; g++) {
780
        for (i = 0; i < ics->max_sfb;) {
781
            int run_end = band_type_run_end[idx];
782
            if (band_type[idx] == ZERO_BT) {
783
                for (; i < run_end; i++, idx++)
784
                    sf[idx] = 0.;
785
            } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
786
                for (; i < run_end; i++, idx++) {
787
                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
788
                    if (offset[2] > 255U) {
789
                        av_log(ac->avctx, AV_LOG_ERROR,
790
                               "%s (%d) out of range.\n", sf_str[2], offset[2]);
791
                        return -1;
792
                    }
793
                    sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300];
794
                }
795
            } else if (band_type[idx] == NOISE_BT) {
796
                for (; i < run_end; i++, idx++) {
797
                    if (noise_flag-- > 0)
798
                        offset[1] += get_bits(gb, 9) - 256;
799
                    else
800
                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
801
                    if (offset[1] > 255U) {
802
                        av_log(ac->avctx, AV_LOG_ERROR,
803
                               "%s (%d) out of range.\n", sf_str[1], offset[1]);
804
                        return -1;
805
                    }
806
                    sf[idx] = -ff_aac_pow2sf_tab[offset[1] + sf_offset + 100];
807
                }
808
            } else {
809
                for (; i < run_end; i++, idx++) {
810
                    offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
811
                    if (offset[0] > 255U) {
812
                        av_log(ac->avctx, AV_LOG_ERROR,
813
                               "%s (%d) out of range.\n", sf_str[0], offset[0]);
814
                        return -1;
815
                    }
816
                    sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset];
817
                }
818
            }
819
        }
820
    }
821
    return 0;
822
}
823

    
824
/**
825
 * Decode pulse data; reference: table 4.7.
826
 */
827
static int decode_pulses(Pulse *pulse, GetBitContext *gb,
828
                         const uint16_t *swb_offset, int num_swb)
829
{
830
    int i, pulse_swb;
831
    pulse->num_pulse = get_bits(gb, 2) + 1;
832
    pulse_swb        = get_bits(gb, 6);
833
    if (pulse_swb >= num_swb)
834
        return -1;
835
    pulse->pos[0]    = swb_offset[pulse_swb];
836
    pulse->pos[0]   += get_bits(gb, 5);
837
    if (pulse->pos[0] > 1023)
838
        return -1;
839
    pulse->amp[0]    = get_bits(gb, 4);
840
    for (i = 1; i < pulse->num_pulse; i++) {
841
        pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
842
        if (pulse->pos[i] > 1023)
843
            return -1;
844
        pulse->amp[i] = get_bits(gb, 4);
845
    }
846
    return 0;
847
}
848

    
849
/**
850
 * Decode Temporal Noise Shaping data; reference: table 4.48.
851
 *
852
 * @return  Returns error status. 0 - OK, !0 - error
853
 */
854
static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
855
                      GetBitContext *gb, const IndividualChannelStream *ics)
856
{
857
    int w, filt, i, coef_len, coef_res, coef_compress;
858
    const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
859
    const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
860
    for (w = 0; w < ics->num_windows; w++) {
861
        if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
862
            coef_res = get_bits1(gb);
863

    
864
            for (filt = 0; filt < tns->n_filt[w]; filt++) {
865
                int tmp2_idx;
866
                tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
867

    
868
                if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
869
                    av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
870
                           tns->order[w][filt], tns_max_order);
871
                    tns->order[w][filt] = 0;
872
                    return -1;
873
                }
874
                if (tns->order[w][filt]) {
875
                    tns->direction[w][filt] = get_bits1(gb);
876
                    coef_compress = get_bits1(gb);
877
                    coef_len = coef_res + 3 - coef_compress;
878
                    tmp2_idx = 2 * coef_compress + coef_res;
879

    
880
                    for (i = 0; i < tns->order[w][filt]; i++)
881
                        tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
882
                }
883
            }
884
        }
885
    }
886
    return 0;
887
}
888

    
889
/**
890
 * Decode Mid/Side data; reference: table 4.54.
891
 *
892
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
893
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
894
 *                      [3] reserved for scalable AAC
895
 */
896
static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
897
                                   int ms_present)
898
{
899
    int idx;
900
    if (ms_present == 1) {
901
        for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
902
            cpe->ms_mask[idx] = get_bits1(gb);
903
    } else if (ms_present == 2) {
904
        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
905
    }
906
}
907

    
908
#ifndef VMUL2
909
static inline float *VMUL2(float *dst, const float *v, unsigned idx,
910
                           const float *scale)
911
{
912
    float s = *scale;
913
    *dst++ = v[idx    & 15] * s;
914
    *dst++ = v[idx>>4 & 15] * s;
915
    return dst;
916
}
917
#endif
918

    
919
#ifndef VMUL4
920
static inline float *VMUL4(float *dst, const float *v, unsigned idx,
921
                           const float *scale)
922
{
923
    float s = *scale;
924
    *dst++ = v[idx    & 3] * s;
925
    *dst++ = v[idx>>2 & 3] * s;
926
    *dst++ = v[idx>>4 & 3] * s;
927
    *dst++ = v[idx>>6 & 3] * s;
928
    return dst;
929
}
930
#endif
931

    
932
#ifndef VMUL2S
933
static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
934
                            unsigned sign, const float *scale)
935
{
936
    union float754 s0, s1;
937

    
938
    s0.f = s1.f = *scale;
939
    s0.i ^= sign >> 1 << 31;
940
    s1.i ^= sign      << 31;
941

    
942
    *dst++ = v[idx    & 15] * s0.f;
943
    *dst++ = v[idx>>4 & 15] * s1.f;
944

    
945
    return dst;
946
}
947
#endif
948

    
949
#ifndef VMUL4S
950
static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
951
                            unsigned sign, const float *scale)
952
{
953
    unsigned nz = idx >> 12;
954
    union float754 s = { .f = *scale };
955
    union float754 t;
956

    
957
    t.i = s.i ^ (sign & 1<<31);
958
    *dst++ = v[idx    & 3] * t.f;
959

    
960
    sign <<= nz & 1; nz >>= 1;
961
    t.i = s.i ^ (sign & 1<<31);
962
    *dst++ = v[idx>>2 & 3] * t.f;
963

    
964
    sign <<= nz & 1; nz >>= 1;
965
    t.i = s.i ^ (sign & 1<<31);
966
    *dst++ = v[idx>>4 & 3] * t.f;
967

    
968
    sign <<= nz & 1; nz >>= 1;
969
    t.i = s.i ^ (sign & 1<<31);
970
    *dst++ = v[idx>>6 & 3] * t.f;
971

    
972
    return dst;
973
}
974
#endif
975

    
976
/**
977
 * Decode spectral data; reference: table 4.50.
978
 * Dequantize and scale spectral data; reference: 4.6.3.3.
979
 *
980
 * @param   coef            array of dequantized, scaled spectral data
981
 * @param   sf              array of scalefactors or intensity stereo positions
982
 * @param   pulse_present   set if pulses are present
983
 * @param   pulse           pointer to pulse data struct
984
 * @param   band_type       array of the used band type
985
 *
986
 * @return  Returns error status. 0 - OK, !0 - error
987
 */
988
static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024],
989
                                       GetBitContext *gb, const float sf[120],
990
                                       int pulse_present, const Pulse *pulse,
991
                                       const IndividualChannelStream *ics,
992
                                       enum BandType band_type[120])
993
{
994
    int i, k, g, idx = 0;
995
    const int c = 1024 / ics->num_windows;
996
    const uint16_t *offsets = ics->swb_offset;
997
    float *coef_base = coef;
998

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

    
1002
    for (g = 0; g < ics->num_window_groups; g++) {
1003
        unsigned g_len = ics->group_len[g];
1004

    
1005
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1006
            const unsigned cbt_m1 = band_type[idx] - 1;
1007
            float *cfo = coef + offsets[i];
1008
            int off_len = offsets[i + 1] - offsets[i];
1009
            int group;
1010

    
1011
            if (cbt_m1 >= INTENSITY_BT2 - 1) {
1012
                for (group = 0; group < g_len; group++, cfo+=128) {
1013
                    memset(cfo, 0, off_len * sizeof(float));
1014
                }
1015
            } else if (cbt_m1 == NOISE_BT - 1) {
1016
                for (group = 0; group < g_len; group++, cfo+=128) {
1017
                    float scale;
1018
                    float band_energy;
1019

    
1020
                    for (k = 0; k < off_len; k++) {
1021
                        ac->random_state  = lcg_random(ac->random_state);
1022
                        cfo[k] = ac->random_state;
1023
                    }
1024

    
1025
                    band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len);
1026
                    scale = sf[idx] / sqrtf(band_energy);
1027
                    ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len);
1028
                }
1029
            } else {
1030
                const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1031
                const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
1032
                VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1033
                OPEN_READER(re, gb);
1034

    
1035
                switch (cbt_m1 >> 1) {
1036
                case 0:
1037
                    for (group = 0; group < g_len; group++, cfo+=128) {
1038
                        float *cf = cfo;
1039
                        int len = off_len;
1040

    
1041
                        do {
1042
                            int code;
1043
                            unsigned cb_idx;
1044

    
1045
                            UPDATE_CACHE(re, gb);
1046
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1047
                            cb_idx = cb_vector_idx[code];
1048
                            cf = VMUL4(cf, vq, cb_idx, sf + idx);
1049
                        } while (len -= 4);
1050
                    }
1051
                    break;
1052

    
1053
                case 1:
1054
                    for (group = 0; group < g_len; group++, cfo+=128) {
1055
                        float *cf = cfo;
1056
                        int len = off_len;
1057

    
1058
                        do {
1059
                            int code;
1060
                            unsigned nnz;
1061
                            unsigned cb_idx;
1062
                            uint32_t bits;
1063

    
1064
                            UPDATE_CACHE(re, gb);
1065
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1066
#if MIN_CACHE_BITS < 20
1067
                            UPDATE_CACHE(re, gb);
1068
#endif
1069
                            cb_idx = cb_vector_idx[code];
1070
                            nnz = cb_idx >> 8 & 15;
1071
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1072
                            LAST_SKIP_BITS(re, gb, nnz);
1073
                            cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1074
                        } while (len -= 4);
1075
                    }
1076
                    break;
1077

    
1078
                case 2:
1079
                    for (group = 0; group < g_len; group++, cfo+=128) {
1080
                        float *cf = cfo;
1081
                        int len = off_len;
1082

    
1083
                        do {
1084
                            int code;
1085
                            unsigned cb_idx;
1086

    
1087
                            UPDATE_CACHE(re, gb);
1088
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1089
                            cb_idx = cb_vector_idx[code];
1090
                            cf = VMUL2(cf, vq, cb_idx, sf + idx);
1091
                        } while (len -= 2);
1092
                    }
1093
                    break;
1094

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

    
1101
                        do {
1102
                            int code;
1103
                            unsigned nnz;
1104
                            unsigned cb_idx;
1105
                            unsigned sign;
1106

    
1107
                            UPDATE_CACHE(re, gb);
1108
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1109
                            cb_idx = cb_vector_idx[code];
1110
                            nnz = cb_idx >> 8 & 15;
1111
                            sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12);
1112
                            LAST_SKIP_BITS(re, gb, nnz);
1113
                            cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1114
                        } while (len -= 2);
1115
                    }
1116
                    break;
1117

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

    
1124
                        do {
1125
                            int code;
1126
                            unsigned nzt, nnz;
1127
                            unsigned cb_idx;
1128
                            uint32_t bits;
1129
                            int j;
1130

    
1131
                            UPDATE_CACHE(re, gb);
1132
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1133

    
1134
                            if (!code) {
1135
                                *icf++ = 0;
1136
                                *icf++ = 0;
1137
                                continue;
1138
                            }
1139

    
1140
                            cb_idx = cb_vector_idx[code];
1141
                            nnz = cb_idx >> 12;
1142
                            nzt = cb_idx >> 8;
1143
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1144
                            LAST_SKIP_BITS(re, gb, nnz);
1145

    
1146
                            for (j = 0; j < 2; j++) {
1147
                                if (nzt & 1<<j) {
1148
                                    uint32_t b;
1149
                                    int n;
1150
                                    /* The total length of escape_sequence must be < 22 bits according
1151
                                       to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1152
                                    UPDATE_CACHE(re, gb);
1153
                                    b = GET_CACHE(re, gb);
1154
                                    b = 31 - av_log2(~b);
1155

    
1156
                                    if (b > 8) {
1157
                                        av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1158
                                        return -1;
1159
                                    }
1160

    
1161
#if MIN_CACHE_BITS < 21
1162
                                    LAST_SKIP_BITS(re, gb, b + 1);
1163
                                    UPDATE_CACHE(re, gb);
1164
#else
1165
                                    SKIP_BITS(re, gb, b + 1);
1166
#endif
1167
                                    b += 4;
1168
                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
1169
                                    LAST_SKIP_BITS(re, gb, b);
1170
                                    *icf++ = cbrt_tab[n] | (bits & 1<<31);
1171
                                    bits <<= 1;
1172
                                } else {
1173
                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1174
                                    *icf++ = (bits & 1<<31) | v;
1175
                                    bits <<= !!v;
1176
                                }
1177
                                cb_idx >>= 4;
1178
                            }
1179
                        } while (len -= 2);
1180

    
1181
                        ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1182
                    }
1183
                }
1184

    
1185
                CLOSE_READER(re, gb);
1186
            }
1187
        }
1188
        coef += g_len << 7;
1189
    }
1190

    
1191
    if (pulse_present) {
1192
        idx = 0;
1193
        for (i = 0; i < pulse->num_pulse; i++) {
1194
            float co = coef_base[ pulse->pos[i] ];
1195
            while (offsets[idx + 1] <= pulse->pos[i])
1196
                idx++;
1197
            if (band_type[idx] != NOISE_BT && sf[idx]) {
1198
                float ico = -pulse->amp[i];
1199
                if (co) {
1200
                    co /= sf[idx];
1201
                    ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
1202
                }
1203
                coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
1204
            }
1205
        }
1206
    }
1207
    return 0;
1208
}
1209

    
1210
static av_always_inline float flt16_round(float pf)
1211
{
1212
    union float754 tmp;
1213
    tmp.f = pf;
1214
    tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
1215
    return tmp.f;
1216
}
1217

    
1218
static av_always_inline float flt16_even(float pf)
1219
{
1220
    union float754 tmp;
1221
    tmp.f = pf;
1222
    tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
1223
    return tmp.f;
1224
}
1225

    
1226
static av_always_inline float flt16_trunc(float pf)
1227
{
1228
    union float754 pun;
1229
    pun.f = pf;
1230
    pun.i &= 0xFFFF0000U;
1231
    return pun.f;
1232
}
1233

    
1234
static av_always_inline void predict(PredictorState *ps, float *coef,
1235
                                     float sf_scale, float inv_sf_scale,
1236
                    int output_enable)
1237
{
1238
    const float a     = 0.953125; // 61.0 / 64
1239
    const float alpha = 0.90625;  // 29.0 / 32
1240
    float e0, e1;
1241
    float pv;
1242
    float k1, k2;
1243

    
1244
    k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
1245
    k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
1246

    
1247
    pv = flt16_round(k1 * ps->r0 + k2 * ps->r1);
1248
    if (output_enable)
1249
        *coef += pv * sf_scale;
1250

    
1251
    e0 = *coef * inv_sf_scale;
1252
    e1 = e0 - k1 * ps->r0;
1253

    
1254
    ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1);
1255
    ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5f * (ps->r1 * ps->r1 + e1 * e1));
1256
    ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0);
1257
    ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5f * (ps->r0 * ps->r0 + e0 * e0));
1258

    
1259
    ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0));
1260
    ps->r0 = flt16_trunc(a * e0);
1261
}
1262

    
1263
/**
1264
 * Apply AAC-Main style frequency domain prediction.
1265
 */
1266
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
1267
{
1268
    int sfb, k;
1269
    float sf_scale = ac->sf_scale, inv_sf_scale = 1 / ac->sf_scale;
1270

    
1271
    if (!sce->ics.predictor_initialized) {
1272
        reset_all_predictors(sce->predictor_state);
1273
        sce->ics.predictor_initialized = 1;
1274
    }
1275

    
1276
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
1277
        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
1278
            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
1279
                predict(&sce->predictor_state[k], &sce->coeffs[k],
1280
                        sf_scale, inv_sf_scale,
1281
                        sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
1282
            }
1283
        }
1284
        if (sce->ics.predictor_reset_group)
1285
            reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
1286
    } else
1287
        reset_all_predictors(sce->predictor_state);
1288
}
1289

    
1290
/**
1291
 * Decode an individual_channel_stream payload; reference: table 4.44.
1292
 *
1293
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
1294
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
1295
 *
1296
 * @return  Returns error status. 0 - OK, !0 - error
1297
 */
1298
static int decode_ics(AACContext *ac, SingleChannelElement *sce,
1299
                      GetBitContext *gb, int common_window, int scale_flag)
1300
{
1301
    Pulse pulse;
1302
    TemporalNoiseShaping    *tns = &sce->tns;
1303
    IndividualChannelStream *ics = &sce->ics;
1304
    float *out = sce->coeffs;
1305
    int global_gain, pulse_present = 0;
1306

    
1307
    /* This assignment is to silence a GCC warning about the variable being used
1308
     * uninitialized when in fact it always is.
1309
     */
1310
    pulse.num_pulse = 0;
1311

    
1312
    global_gain = get_bits(gb, 8);
1313

    
1314
    if (!common_window && !scale_flag) {
1315
        if (decode_ics_info(ac, ics, gb, 0) < 0)
1316
            return -1;
1317
    }
1318

    
1319
    if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
1320
        return -1;
1321
    if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
1322
        return -1;
1323

    
1324
    pulse_present = 0;
1325
    if (!scale_flag) {
1326
        if ((pulse_present = get_bits1(gb))) {
1327
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1328
                av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
1329
                return -1;
1330
            }
1331
            if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
1332
                av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
1333
                return -1;
1334
            }
1335
        }
1336
        if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
1337
            return -1;
1338
        if (get_bits1(gb)) {
1339
            av_log_missing_feature(ac->avctx, "SSR", 1);
1340
            return -1;
1341
        }
1342
    }
1343

    
1344
    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
1345
        return -1;
1346

    
1347
    if (ac->m4ac.object_type == AOT_AAC_MAIN && !common_window)
1348
        apply_prediction(ac, sce);
1349

    
1350
    return 0;
1351
}
1352

    
1353
/**
1354
 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
1355
 */
1356
static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
1357
{
1358
    const IndividualChannelStream *ics = &cpe->ch[0].ics;
1359
    float *ch0 = cpe->ch[0].coeffs;
1360
    float *ch1 = cpe->ch[1].coeffs;
1361
    int g, i, group, idx = 0;
1362
    const uint16_t *offsets = ics->swb_offset;
1363
    for (g = 0; g < ics->num_window_groups; g++) {
1364
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1365
            if (cpe->ms_mask[idx] &&
1366
                    cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
1367
                for (group = 0; group < ics->group_len[g]; group++) {
1368
                    ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i],
1369
                                              ch1 + group * 128 + offsets[i],
1370
                                              offsets[i+1] - offsets[i]);
1371
                }
1372
            }
1373
        }
1374
        ch0 += ics->group_len[g] * 128;
1375
        ch1 += ics->group_len[g] * 128;
1376
    }
1377
}
1378

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

    
1419
/**
1420
 * Decode a channel_pair_element; reference: table 4.4.
1421
 *
1422
 * @return  Returns error status. 0 - OK, !0 - error
1423
 */
1424
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
1425
{
1426
    int i, ret, common_window, ms_present = 0;
1427

    
1428
    common_window = get_bits1(gb);
1429
    if (common_window) {
1430
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
1431
            return -1;
1432
        i = cpe->ch[1].ics.use_kb_window[0];
1433
        cpe->ch[1].ics = cpe->ch[0].ics;
1434
        cpe->ch[1].ics.use_kb_window[1] = i;
1435
        ms_present = get_bits(gb, 2);
1436
        if (ms_present == 3) {
1437
            av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1438
            return -1;
1439
        } else if (ms_present)
1440
            decode_mid_side_stereo(cpe, gb, ms_present);
1441
    }
1442
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
1443
        return ret;
1444
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
1445
        return ret;
1446

    
1447
    if (common_window) {
1448
        if (ms_present)
1449
            apply_mid_side_stereo(ac, cpe);
1450
        if (ac->m4ac.object_type == AOT_AAC_MAIN) {
1451
            apply_prediction(ac, &cpe->ch[0]);
1452
            apply_prediction(ac, &cpe->ch[1]);
1453
        }
1454
    }
1455

    
1456
    apply_intensity_stereo(cpe, ms_present);
1457
    return 0;
1458
}
1459

    
1460
static const float cce_scale[] = {
1461
    1.09050773266525765921, //2^(1/8)
1462
    1.18920711500272106672, //2^(1/4)
1463
    M_SQRT2,
1464
    2,
1465
};
1466

    
1467
/**
1468
 * Decode coupling_channel_element; reference: table 4.8.
1469
 *
1470
 * @return  Returns error status. 0 - OK, !0 - error
1471
 */
1472
static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
1473
{
1474
    int num_gain = 0;
1475
    int c, g, sfb, ret;
1476
    int sign;
1477
    float scale;
1478
    SingleChannelElement *sce = &che->ch[0];
1479
    ChannelCoupling     *coup = &che->coup;
1480

    
1481
    coup->coupling_point = 2 * get_bits1(gb);
1482
    coup->num_coupled = get_bits(gb, 3);
1483
    for (c = 0; c <= coup->num_coupled; c++) {
1484
        num_gain++;
1485
        coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
1486
        coup->id_select[c] = get_bits(gb, 4);
1487
        if (coup->type[c] == TYPE_CPE) {
1488
            coup->ch_select[c] = get_bits(gb, 2);
1489
            if (coup->ch_select[c] == 3)
1490
                num_gain++;
1491
        } else
1492
            coup->ch_select[c] = 2;
1493
    }
1494
    coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
1495

    
1496
    sign  = get_bits(gb, 1);
1497
    scale = cce_scale[get_bits(gb, 2)];
1498

    
1499
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
1500
        return ret;
1501

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

    
1539
/**
1540
 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1541
 *
1542
 * @return  Returns number of bytes consumed.
1543
 */
1544
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
1545
                                         GetBitContext *gb)
1546
{
1547
    int i;
1548
    int num_excl_chan = 0;
1549

    
1550
    do {
1551
        for (i = 0; i < 7; i++)
1552
            che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
1553
    } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
1554

    
1555
    return num_excl_chan / 7;
1556
}
1557

    
1558
/**
1559
 * Decode dynamic range information; reference: table 4.52.
1560
 *
1561
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1562
 *
1563
 * @return  Returns number of bytes consumed.
1564
 */
1565
static int decode_dynamic_range(DynamicRangeControl *che_drc,
1566
                                GetBitContext *gb, int cnt)
1567
{
1568
    int n             = 1;
1569
    int drc_num_bands = 1;
1570
    int i;
1571

    
1572
    /* pce_tag_present? */
1573
    if (get_bits1(gb)) {
1574
        che_drc->pce_instance_tag  = get_bits(gb, 4);
1575
        skip_bits(gb, 4); // tag_reserved_bits
1576
        n++;
1577
    }
1578

    
1579
    /* excluded_chns_present? */
1580
    if (get_bits1(gb)) {
1581
        n += decode_drc_channel_exclusions(che_drc, gb);
1582
    }
1583

    
1584
    /* drc_bands_present? */
1585
    if (get_bits1(gb)) {
1586
        che_drc->band_incr            = get_bits(gb, 4);
1587
        che_drc->interpolation_scheme = get_bits(gb, 4);
1588
        n++;
1589
        drc_num_bands += che_drc->band_incr;
1590
        for (i = 0; i < drc_num_bands; i++) {
1591
            che_drc->band_top[i] = get_bits(gb, 8);
1592
            n++;
1593
        }
1594
    }
1595

    
1596
    /* prog_ref_level_present? */
1597
    if (get_bits1(gb)) {
1598
        che_drc->prog_ref_level = get_bits(gb, 7);
1599
        skip_bits1(gb); // prog_ref_level_reserved_bits
1600
        n++;
1601
    }
1602

    
1603
    for (i = 0; i < drc_num_bands; i++) {
1604
        che_drc->dyn_rng_sgn[i] = get_bits1(gb);
1605
        che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
1606
        n++;
1607
    }
1608

    
1609
    return n;
1610
}
1611

    
1612
/**
1613
 * Decode extension data (incomplete); reference: table 4.51.
1614
 *
1615
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1616
 *
1617
 * @return Returns number of bytes consumed
1618
 */
1619
static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
1620
                                    ChannelElement *che, enum RawDataBlockType elem_type)
1621
{
1622
    int crc_flag = 0;
1623
    int res = cnt;
1624
    switch (get_bits(gb, 4)) { // extension type
1625
    case EXT_SBR_DATA_CRC:
1626
        crc_flag++;
1627
    case EXT_SBR_DATA:
1628
        if (!che) {
1629
            av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
1630
            return res;
1631
        } else if (!ac->m4ac.sbr) {
1632
            av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
1633
            skip_bits_long(gb, 8 * cnt - 4);
1634
            return res;
1635
        } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) {
1636
            av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
1637
            skip_bits_long(gb, 8 * cnt - 4);
1638
            return res;
1639
        } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) {
1640
            ac->m4ac.sbr = 1;
1641
            ac->m4ac.ps = 1;
1642
            output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured);
1643
        } else {
1644
            ac->m4ac.sbr = 1;
1645
        }
1646
        res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
1647
        break;
1648
    case EXT_DYNAMIC_RANGE:
1649
        res = decode_dynamic_range(&ac->che_drc, gb, cnt);
1650
        break;
1651
    case EXT_FILL:
1652
    case EXT_FILL_DATA:
1653
    case EXT_DATA_ELEMENT:
1654
    default:
1655
        skip_bits_long(gb, 8 * cnt - 4);
1656
        break;
1657
    };
1658
    return res;
1659
}
1660

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

    
1675
    for (w = 0; w < ics->num_windows; w++) {
1676
        bottom = ics->num_swb;
1677
        for (filt = 0; filt < tns->n_filt[w]; filt++) {
1678
            top    = bottom;
1679
            bottom = FFMAX(0, top - tns->length[w][filt]);
1680
            order  = tns->order[w][filt];
1681
            if (order == 0)
1682
                continue;
1683

    
1684
            // tns_decode_coef
1685
            compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
1686

    
1687
            start = ics->swb_offset[FFMIN(bottom, mmm)];
1688
            end   = ics->swb_offset[FFMIN(   top, mmm)];
1689
            if ((size = end - start) <= 0)
1690
                continue;
1691
            if (tns->direction[w][filt]) {
1692
                inc = -1;
1693
                start = end - 1;
1694
            } else {
1695
                inc = 1;
1696
            }
1697
            start += w * 128;
1698

    
1699
            // ar filter
1700
            for (m = 0; m < size; m++, start += inc)
1701
                for (i = 1; i <= FFMIN(m, order); i++)
1702
                    coef[start] -= coef[start - i * inc] * lpc[i - 1];
1703
        }
1704
    }
1705
}
1706

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

    
1723
    // imdct
1724
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1725
        for (i = 0; i < 1024; i += 128)
1726
            ff_imdct_half(&ac->mdct_small, buf + i, in + i);
1727
    } else
1728
        ff_imdct_half(&ac->mdct, buf, in);
1729

    
1730
    /* window overlapping
1731
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1732
     * and long to short transitions are considered to be short to short
1733
     * transitions. This leaves just two cases (long to long and short to short)
1734
     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
1735
     */
1736
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
1737
            (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
1738
        ac->dsp.vector_fmul_window(    out,               saved,            buf,         lwindow_prev, bias, 512);
1739
    } else {
1740
        for (i = 0; i < 448; i++)
1741
            out[i] = saved[i] + bias;
1742

    
1743
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1744
            ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, bias, 64);
1745
            ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      bias, 64);
1746
            ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      bias, 64);
1747
            ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      bias, 64);
1748
            ac->dsp.vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      bias, 64);
1749
            memcpy(                    out + 448 + 4*128, temp, 64 * sizeof(float));
1750
        } else {
1751
            ac->dsp.vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, bias, 64);
1752
            for (i = 576; i < 1024; i++)
1753
                out[i] = buf[i-512] + bias;
1754
        }
1755
    }
1756

    
1757
    // buffer update
1758
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1759
        for (i = 0; i < 64; i++)
1760
            saved[i] = temp[64 + i] - bias;
1761
        ac->dsp.vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 0, 64);
1762
        ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64);
1763
        ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64);
1764
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1765
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
1766
        memcpy(                    saved,       buf + 512,        448 * sizeof(float));
1767
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1768
    } else { // LONG_STOP or ONLY_LONG
1769
        memcpy(                    saved,       buf + 512,        512 * sizeof(float));
1770
    }
1771
}
1772

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

    
1809
/**
1810
 * Apply independent channel coupling (applied after IMDCT).
1811
 *
1812
 * @param   index   index into coupling gain array
1813
 */
1814
static void apply_independent_coupling(AACContext *ac,
1815
                                       SingleChannelElement *target,
1816
                                       ChannelElement *cce, int index)
1817
{
1818
    int i;
1819
    const float gain = cce->coup.gain[index][0];
1820
    const float bias = ac->add_bias;
1821
    const float *src = cce->ch[0].ret;
1822
    float *dest = target->ret;
1823
    const int len = 1024 << (ac->m4ac.sbr == 1);
1824

    
1825
    for (i = 0; i < len; i++)
1826
        dest[i] += gain * (src[i] - bias);
1827
}
1828

    
1829
/**
1830
 * channel coupling transformation interface
1831
 *
1832
 * @param   apply_coupling_method   pointer to (in)dependent coupling function
1833
 */
1834
static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
1835
                                   enum RawDataBlockType type, int elem_id,
1836
                                   enum CouplingPoint coupling_point,
1837
                                   void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
1838
{
1839
    int i, c;
1840

    
1841
    for (i = 0; i < MAX_ELEM_ID; i++) {
1842
        ChannelElement *cce = ac->che[TYPE_CCE][i];
1843
        int index = 0;
1844

    
1845
        if (cce && cce->coup.coupling_point == coupling_point) {
1846
            ChannelCoupling *coup = &cce->coup;
1847

    
1848
            for (c = 0; c <= coup->num_coupled; c++) {
1849
                if (coup->type[c] == type && coup->id_select[c] == elem_id) {
1850
                    if (coup->ch_select[c] != 1) {
1851
                        apply_coupling_method(ac, &cc->ch[0], cce, index);
1852
                        if (coup->ch_select[c] != 0)
1853
                            index++;
1854
                    }
1855
                    if (coup->ch_select[c] != 2)
1856
                        apply_coupling_method(ac, &cc->ch[1], cce, index++);
1857
                } else
1858
                    index += 1 + (coup->ch_select[c] == 3);
1859
            }
1860
        }
1861
    }
1862
}
1863

    
1864
/**
1865
 * Convert spectral data to float samples, applying all supported tools as appropriate.
1866
 */
1867
static void spectral_to_sample(AACContext *ac)
1868
{
1869
    int i, type;
1870
    float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f;
1871
    for (type = 3; type >= 0; type--) {
1872
        for (i = 0; i < MAX_ELEM_ID; i++) {
1873
            ChannelElement *che = ac->che[type][i];
1874
            if (che) {
1875
                if (type <= TYPE_CPE)
1876
                    apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling);
1877
                if (che->ch[0].tns.present)
1878
                    apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
1879
                if (che->ch[1].tns.present)
1880
                    apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
1881
                if (type <= TYPE_CPE)
1882
                    apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
1883
                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
1884
                    imdct_and_windowing(ac, &che->ch[0], imdct_bias);
1885
                    if (type == TYPE_CPE) {
1886
                        imdct_and_windowing(ac, &che->ch[1], imdct_bias);
1887
                    }
1888
                    if (ac->m4ac.sbr > 0) {
1889
                        ff_sbr_apply(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
1890
                    }
1891
                }
1892
                if (type <= TYPE_CCE)
1893
                    apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling);
1894
            }
1895
        }
1896
    }
1897
}
1898

    
1899
static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
1900
{
1901
    int size;
1902
    AACADTSHeaderInfo hdr_info;
1903

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

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

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

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

    
1964
    memset(ac->tags_seen_this_frame, 0, sizeof(ac->tags_seen_this_frame));
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) {
1970
            if (!(che=get_che(ac, elem_type, elem_id))) {
1971
                av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
1972
                       elem_type, elem_id);
1973
                return -1;
1974
            }
1975
            samples = 1024;
1976
        }
1977

    
1978
        switch (elem_type) {
1979

    
1980
        case TYPE_SCE:
1981
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
1982
            break;
1983

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

    
1988
        case TYPE_CCE:
1989
            err = decode_cce(ac, &gb, che);
1990
            break;
1991

    
1992
        case TYPE_LFE:
1993
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
1994
            break;
1995

    
1996
        case TYPE_DSE:
1997
            err = skip_data_stream_element(ac, &gb);
1998
            break;
1999

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

    
2013
        case TYPE_FIL:
2014
            if (elem_id == 15)
2015
                elem_id += get_bits(&gb, 8) - 1;
2016
            if (get_bits_left(&gb) < 8 * elem_id) {
2017
                    av_log(avctx, AV_LOG_ERROR, overread_err);
2018
                    return -1;
2019
            }
2020
            while (elem_id > 0)
2021
                elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev);
2022
            err = 0; /* FIXME */
2023
            break;
2024

    
2025
        default:
2026
            err = -1; /* should not happen, but keeps compiler happy */
2027
            break;
2028
        }
2029

    
2030
        che_prev       = che;
2031
        elem_type_prev = elem_type;
2032

    
2033
        if (err)
2034
            return err;
2035

    
2036
        if (get_bits_left(&gb) < 3) {
2037
            av_log(avctx, AV_LOG_ERROR, overread_err);
2038
            return -1;
2039
        }
2040
    }
2041

    
2042
    spectral_to_sample(ac);
2043

    
2044
    multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0;
2045
    samples <<= multiplier;
2046
    if (ac->output_configured < OC_LOCKED) {
2047
        avctx->sample_rate = ac->m4ac.sample_rate << multiplier;
2048
        avctx->frame_size = samples;
2049
    }
2050

    
2051
    data_size_tmp = samples * avctx->channels * sizeof(int16_t);
2052
    if (*data_size < data_size_tmp) {
2053
        av_log(avctx, AV_LOG_ERROR,
2054
               "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
2055
               *data_size, data_size_tmp);
2056
        return -1;
2057
    }
2058
    *data_size = data_size_tmp;
2059

    
2060
    if (samples)
2061
        ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels);
2062

    
2063
    if (ac->output_configured)
2064
        ac->output_configured = OC_LOCKED;
2065

    
2066
    buf_consumed = (get_bits_count(&gb) + 7) >> 3;
2067
    for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
2068
        if (buf[buf_offset])
2069
            break;
2070

    
2071
    return buf_size > buf_offset ? buf_consumed : buf_size;
2072
}
2073

    
2074
static av_cold int aac_decode_close(AVCodecContext *avctx)
2075
{
2076
    AACContext *ac = avctx->priv_data;
2077
    int i, type;
2078

    
2079
    for (i = 0; i < MAX_ELEM_ID; i++) {
2080
        for (type = 0; type < 4; type++) {
2081
            if (ac->che[type][i])
2082
                ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr);
2083
            av_freep(&ac->che[type][i]);
2084
        }
2085
    }
2086

    
2087
    ff_mdct_end(&ac->mdct);
2088
    ff_mdct_end(&ac->mdct_small);
2089
    return 0;
2090
}
2091

    
2092
AVCodec aac_decoder = {
2093
    "aac",
2094
    AVMEDIA_TYPE_AUDIO,
2095
    CODEC_ID_AAC,
2096
    sizeof(AACContext),
2097
    aac_decode_init,
2098
    NULL,
2099
    aac_decode_close,
2100
    aac_decode_frame,
2101
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
2102
    .sample_fmts = (const enum SampleFormat[]) {
2103
        SAMPLE_FMT_S16,SAMPLE_FMT_NONE
2104
    },
2105
    .channel_layouts = aac_channel_layout,
2106
};