Revision 77b8320a

View differences:

libavcodec/Makefile
42 42
OBJS-$(CONFIG_VDPAU)                   += vdpau.o
43 43

  
44 44
# decoders/encoders/hardware accelerators
45
OBJS-$(CONFIG_AAC_DECODER)             += aac.o aactab.o aacsbr.o
45
OBJS-$(CONFIG_AAC_DECODER)             += aacdec.o aactab.o aacsbr.o
46 46
OBJS-$(CONFIG_AAC_ENCODER)             += aacenc.o aaccoder.o    \
47 47
                                          aacpsy.o aactab.o      \
48 48
                                          psymodel.o iirfilter.o \
libavcodec/aac.c
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
 * 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 "cbrt_tablegen.h"
90
#include "sbr.h"
91
#include "aacsbr.h"
92
#include "mpeg4audio.h"
93
#include "aac_parser.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
                ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;
205
            }
206
        }
207
    } else {
208
        if (ac->che[type][id])
209
            ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr);
210
        av_freep(&ac->che[type][id]);
211
    }
212
    return 0;
213
}
214

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

  
231
    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
232

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

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

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

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

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

  
266
        avctx->channel_layout = 0;
267
    }
268

  
269
    avctx->channels = channels;
270

  
271
    ac->output_configured = oc_type;
272

  
273
    return 0;
274
}
275

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

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

  
307
    skip_bits(gb, 2);  // object_type
308

  
309
    sampling_index = get_bits(gb, 4);
310
    if (ac->m4ac.sampling_index != sampling_index)
311
        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");
312

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

  
320
    if (get_bits1(gb))
321
        skip_bits(gb, 4); // mono_mixdown_tag
322
    if (get_bits1(gb))
323
        skip_bits(gb, 4); // stereo_mixdown_tag
324

  
325
    if (get_bits1(gb))
326
        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
327

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

  
333
    skip_bits_long(gb, 4 * num_assoc_data);
334

  
335
    decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC,    gb, num_cc   );
336

  
337
    align_get_bits(gb);
338

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

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

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

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

  
392
    return 0;
393
}
394

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

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

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

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

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

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

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

  
466
    init_get_bits(&gb, data, data_size * 8);
467

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

  
475
    skip_bits_long(&gb, i);
476

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

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

  
503
static av_always_inline void reset_predict_state(PredictorState *ps)
504
{
505
    ps->r0   = 0.0f;
506
    ps->r1   = 0.0f;
507
    ps->cor0 = 0.0f;
508
    ps->cor1 = 0.0f;
509
    ps->var0 = 1.0f;
510
    ps->var1 = 1.0f;
511
}
512

  
513
static void reset_all_predictors(PredictorState *ps)
514
{
515
    int i;
516
    for (i = 0; i < MAX_PREDICTORS; i++)
517
        reset_predict_state(&ps[i]);
518
}
519

  
520
static void reset_predictor_group(PredictorState *ps, int group_num)
521
{
522
    int i;
523
    for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
524
        reset_predict_state(&ps[i]);
525
}
526

  
527
static av_cold int aac_decode_init(AVCodecContext *avctx)
528
{
529
    AACContext *ac = avctx->priv_data;
530
    int i;
531

  
532
    ac->avctx = avctx;
533
    ac->m4ac.sample_rate = avctx->sample_rate;
534

  
535
    if (avctx->extradata_size > 0) {
536
        if (decode_audio_specific_config(ac, avctx->extradata, avctx->extradata_size))
537
            return -1;
538
    }
539

  
540
    avctx->sample_fmt = SAMPLE_FMT_S16;
541

  
542
    AAC_INIT_VLC_STATIC( 0, 304);
543
    AAC_INIT_VLC_STATIC( 1, 270);
544
    AAC_INIT_VLC_STATIC( 2, 550);
545
    AAC_INIT_VLC_STATIC( 3, 300);
546
    AAC_INIT_VLC_STATIC( 4, 328);
547
    AAC_INIT_VLC_STATIC( 5, 294);
548
    AAC_INIT_VLC_STATIC( 6, 306);
549
    AAC_INIT_VLC_STATIC( 7, 268);
550
    AAC_INIT_VLC_STATIC( 8, 510);
551
    AAC_INIT_VLC_STATIC( 9, 366);
552
    AAC_INIT_VLC_STATIC(10, 462);
553

  
554
    ff_aac_sbr_init();
555

  
556
    dsputil_init(&ac->dsp, avctx);
557

  
558
    ac->random_state = 0x1f2e3d4c;
559

  
560
    // -1024 - Compensate wrong IMDCT method.
561
    // 32768 - Required to scale values to the correct range for the bias method
562
    //         for float to int16 conversion.
563

  
564
    if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
565
        ac->add_bias  = 385.0f;
566
        ac->sf_scale  = 1. / (-1024. * 32768.);
567
        ac->sf_offset = 0;
568
    } else {
569
        ac->add_bias  = 0.0f;
570
        ac->sf_scale  = 1. / -1024.;
571
        ac->sf_offset = 60;
572
    }
573

  
574
#if !CONFIG_HARDCODED_TABLES
575
    for (i = 0; i < 428; i++)
576
        ff_aac_pow2sf_tab[i] = pow(2, (i - 200) / 4.);
577
#endif /* CONFIG_HARDCODED_TABLES */
578

  
579
    INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
580
                    ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
581
                    ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
582
                    352);
583

  
584
    ff_mdct_init(&ac->mdct, 11, 1, 1.0);
585
    ff_mdct_init(&ac->mdct_small, 8, 1, 1.0);
586
    // window initialization
587
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
588
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
589
    ff_init_ff_sine_windows(10);
590
    ff_init_ff_sine_windows( 7);
591

  
592
    cbrt_tableinit();
593

  
594
    return 0;
595
}
596

  
597
/**
598
 * Skip data_stream_element; reference: table 4.10.
599
 */
600
static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
601
{
602
    int byte_align = get_bits1(gb);
603
    int count = get_bits(gb, 8);
604
    if (count == 255)
605
        count += get_bits(gb, 8);
606
    if (byte_align)
607
        align_get_bits(gb);
608

  
609
    if (get_bits_left(gb) < 8 * count) {
610
        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
611
        return -1;
612
    }
613
    skip_bits_long(gb, 8 * count);
614
    return 0;
615
}
616

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

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

  
695
    if (ics->max_sfb > ics->num_swb) {
696
        av_log(ac->avctx, AV_LOG_ERROR,
697
               "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
698
               ics->max_sfb, ics->num_swb);
699
        memset(ics, 0, sizeof(IndividualChannelStream));
700
        return -1;
701
    }
702

  
703
    return 0;
704
}
705

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

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

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

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

  
858
            for (filt = 0; filt < tns->n_filt[w]; filt++) {
859
                int tmp2_idx;
860
                tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
861

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

  
874
                    for (i = 0; i < tns->order[w][filt]; i++)
875
                        tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
876
                }
877
            }
878
        }
879
    }
880
    return 0;
881
}
882

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

  
902
#ifndef VMUL2
903
static inline float *VMUL2(float *dst, const float *v, unsigned idx,
904
                           const float *scale)
905
{
906
    float s = *scale;
907
    *dst++ = v[idx    & 15] * s;
908
    *dst++ = v[idx>>4 & 15] * s;
909
    return dst;
910
}
911
#endif
912

  
913
#ifndef VMUL4
914
static inline float *VMUL4(float *dst, const float *v, unsigned idx,
915
                           const float *scale)
916
{
917
    float s = *scale;
918
    *dst++ = v[idx    & 3] * s;
919
    *dst++ = v[idx>>2 & 3] * s;
920
    *dst++ = v[idx>>4 & 3] * s;
921
    *dst++ = v[idx>>6 & 3] * s;
922
    return dst;
923
}
924
#endif
925

  
926
#ifndef VMUL2S
927
static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
928
                            unsigned sign, const float *scale)
929
{
930
    union float754 s0, s1;
931

  
932
    s0.f = s1.f = *scale;
933
    s0.i ^= sign >> 1 << 31;
934
    s1.i ^= sign      << 31;
935

  
936
    *dst++ = v[idx    & 15] * s0.f;
937
    *dst++ = v[idx>>4 & 15] * s1.f;
938

  
939
    return dst;
940
}
941
#endif
942

  
943
#ifndef VMUL4S
944
static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
945
                            unsigned sign, const float *scale)
946
{
947
    unsigned nz = idx >> 12;
948
    union float754 s = { .f = *scale };
949
    union float754 t;
950

  
951
    t.i = s.i ^ (sign & 1<<31);
952
    *dst++ = v[idx    & 3] * t.f;
953

  
954
    sign <<= nz & 1; nz >>= 1;
955
    t.i = s.i ^ (sign & 1<<31);
956
    *dst++ = v[idx>>2 & 3] * t.f;
957

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

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

  
966
    return dst;
967
}
968
#endif
969

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

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

  
997
    for (g = 0; g < ics->num_window_groups; g++) {
998
        unsigned g_len = ics->group_len[g];
999

  
1000
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1001
            const unsigned cbt_m1 = band_type[idx] - 1;
1002
            float *cfo = coef + offsets[i];
1003
            int off_len = offsets[i + 1] - offsets[i];
1004
            int group;
1005

  
1006
            if (cbt_m1 >= INTENSITY_BT2 - 1) {
1007
                for (group = 0; group < g_len; group++, cfo+=128) {
1008
                    memset(cfo, 0, off_len * sizeof(float));
1009
                }
1010
            } else if (cbt_m1 == NOISE_BT - 1) {
1011
                for (group = 0; group < g_len; group++, cfo+=128) {
1012
                    float scale;
1013
                    float band_energy;
1014

  
1015
                    for (k = 0; k < off_len; k++) {
1016
                        ac->random_state  = lcg_random(ac->random_state);
1017
                        cfo[k] = ac->random_state;
1018
                    }
1019

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

  
1031
                switch (cbt_m1 >> 1) {
1032
                case 0:
1033
                    for (group = 0; group < g_len; group++, cfo+=128) {
1034
                        float *cf = cfo;
1035
                        int len = off_len;
1036

  
1037
                        do {
1038
                            int code;
1039
                            unsigned cb_idx;
1040

  
1041
                            UPDATE_CACHE(re, gb);
1042
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1043

  
1044
                            if (code >= cb_size) {
1045
                                err_idx = code;
1046
                                goto err_cb_overflow;
1047
                            }
1048

  
1049
                            cb_idx = cb_vector_idx[code];
1050
                            cf = VMUL4(cf, vq, cb_idx, sf + idx);
1051
                        } while (len -= 4);
1052
                    }
1053
                    break;
1054

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

  
1060
                        do {
1061
                            int code;
1062
                            unsigned nnz;
1063
                            unsigned cb_idx;
1064
                            uint32_t bits;
1065

  
1066
                            UPDATE_CACHE(re, gb);
1067
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1068

  
1069
                            if (code >= cb_size) {
1070
                                err_idx = code;
1071
                                goto err_cb_overflow;
1072
                            }
1073

  
1074
#if MIN_CACHE_BITS < 20
1075
                            UPDATE_CACHE(re, gb);
1076
#endif
1077
                            cb_idx = cb_vector_idx[code];
1078
                            nnz = cb_idx >> 8 & 15;
1079
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1080
                            LAST_SKIP_BITS(re, gb, nnz);
1081
                            cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1082
                        } while (len -= 4);
1083
                    }
1084
                    break;
1085

  
1086
                case 2:
1087
                    for (group = 0; group < g_len; group++, cfo+=128) {
1088
                        float *cf = cfo;
1089
                        int len = off_len;
1090

  
1091
                        do {
1092
                            int code;
1093
                            unsigned cb_idx;
1094

  
1095
                            UPDATE_CACHE(re, gb);
1096
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1097

  
1098
                            if (code >= cb_size) {
1099
                                err_idx = code;
1100
                                goto err_cb_overflow;
1101
                            }
1102

  
1103
                            cb_idx = cb_vector_idx[code];
1104
                            cf = VMUL2(cf, vq, cb_idx, sf + idx);
1105
                        } while (len -= 2);
1106
                    }
1107
                    break;
1108

  
1109
                case 3:
1110
                case 4:
1111
                    for (group = 0; group < g_len; group++, cfo+=128) {
1112
                        float *cf = cfo;
1113
                        int len = off_len;
1114

  
1115
                        do {
1116
                            int code;
1117
                            unsigned nnz;
1118
                            unsigned cb_idx;
1119
                            unsigned sign;
1120

  
1121
                            UPDATE_CACHE(re, gb);
1122
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1123

  
1124
                            if (code >= cb_size) {
1125
                                err_idx = code;
1126
                                goto err_cb_overflow;
1127
                            }
1128

  
1129
                            cb_idx = cb_vector_idx[code];
1130
                            nnz = cb_idx >> 8 & 15;
1131
                            sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12);
1132
                            LAST_SKIP_BITS(re, gb, nnz);
1133
                            cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1134
                        } while (len -= 2);
1135
                    }
1136
                    break;
1137

  
1138
                default:
1139
                    for (group = 0; group < g_len; group++, cfo+=128) {
1140
                        float *cf = cfo;
1141
                        uint32_t *icf = (uint32_t *) cf;
1142
                        int len = off_len;
1143

  
1144
                        do {
1145
                            int code;
1146
                            unsigned nzt, nnz;
1147
                            unsigned cb_idx;
1148
                            uint32_t bits;
1149
                            int j;
1150

  
1151
                            UPDATE_CACHE(re, gb);
1152
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1153

  
1154
                            if (!code) {
1155
                                *icf++ = 0;
1156
                                *icf++ = 0;
1157
                                continue;
1158
                            }
1159

  
1160
                            if (code >= cb_size) {
1161
                                err_idx = code;
1162
                                goto err_cb_overflow;
1163
                            }
1164

  
1165
                            cb_idx = cb_vector_idx[code];
1166
                            nnz = cb_idx >> 12;
1167
                            nzt = cb_idx >> 8;
1168
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1169
                            LAST_SKIP_BITS(re, gb, nnz);
1170

  
1171
                            for (j = 0; j < 2; j++) {
1172
                                if (nzt & 1<<j) {
1173
                                    uint32_t b;
1174
                                    int n;
1175
                                    /* The total length of escape_sequence must be < 22 bits according
1176
                                       to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1177
                                    UPDATE_CACHE(re, gb);
1178
                                    b = GET_CACHE(re, gb);
1179
                                    b = 31 - av_log2(~b);
1180

  
1181
                                    if (b > 8) {
1182
                                        av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1183
                                        return -1;
1184
                                    }
1185

  
1186
#if MIN_CACHE_BITS < 21
1187
                                    LAST_SKIP_BITS(re, gb, b + 1);
1188
                                    UPDATE_CACHE(re, gb);
1189
#else
1190
                                    SKIP_BITS(re, gb, b + 1);
1191
#endif
1192
                                    b += 4;
1193
                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
1194
                                    LAST_SKIP_BITS(re, gb, b);
1195
                                    *icf++ = cbrt_tab[n] | (bits & 1<<31);
1196
                                    bits <<= 1;
1197
                                } else {
1198
                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1199
                                    *icf++ = (bits & 1<<31) | v;
1200
                                    bits <<= !!v;
1201
                                }
1202
                                cb_idx >>= 4;
1203
                            }
1204
                        } while (len -= 2);
1205

  
1206
                        ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1207
                    }
1208
                }
1209

  
1210
                CLOSE_READER(re, gb);
1211
            }
1212
        }
1213
        coef += g_len << 7;
1214
    }
1215

  
1216
    if (pulse_present) {
1217
        idx = 0;
1218
        for (i = 0; i < pulse->num_pulse; i++) {
1219
            float co = coef_base[ pulse->pos[i] ];
1220
            while (offsets[idx + 1] <= pulse->pos[i])
1221
                idx++;
1222
            if (band_type[idx] != NOISE_BT && sf[idx]) {
1223
                float ico = -pulse->amp[i];
1224
                if (co) {
1225
                    co /= sf[idx];
1226
                    ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
1227
                }
1228
                coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
1229
            }
1230
        }
1231
    }
1232
    return 0;
1233

  
1234
err_cb_overflow:
1235
    av_log(ac->avctx, AV_LOG_ERROR,
1236
           "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
1237
           band_type[idx], err_idx, ff_aac_spectral_sizes[band_type[idx]]);
1238
    return -1;
1239
}
1240

  
1241
static av_always_inline float flt16_round(float pf)
1242
{
1243
    union float754 tmp;
1244
    tmp.f = pf;
1245
    tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
1246
    return tmp.f;
1247
}
1248

  
1249
static av_always_inline float flt16_even(float pf)
1250
{
1251
    union float754 tmp;
1252
    tmp.f = pf;
1253
    tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
1254
    return tmp.f;
1255
}
1256

  
1257
static av_always_inline float flt16_trunc(float pf)
1258
{
1259
    union float754 pun;
1260
    pun.f = pf;
1261
    pun.i &= 0xFFFF0000U;
1262
    return pun.f;
1263
}
1264

  
1265
static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef,
1266
                    int output_enable)
1267
{
1268
    const float a     = 0.953125; // 61.0 / 64
1269
    const float alpha = 0.90625;  // 29.0 / 32
1270
    float e0, e1;
1271
    float pv;
1272
    float k1, k2;
1273

  
1274
    k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
1275
    k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
1276

  
1277
    pv = flt16_round(k1 * ps->r0 + k2 * ps->r1);
1278
    if (output_enable)
1279
        *coef += pv * ac->sf_scale;
1280

  
1281
    e0 = *coef / ac->sf_scale;
1282
    e1 = e0 - k1 * ps->r0;
1283

  
1284
    ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1);
1285
    ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5 * (ps->r1 * ps->r1 + e1 * e1));
1286
    ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0);
1287
    ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5 * (ps->r0 * ps->r0 + e0 * e0));
1288

  
1289
    ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0));
1290
    ps->r0 = flt16_trunc(a * e0);
1291
}
1292

  
1293
/**
1294
 * Apply AAC-Main style frequency domain prediction.
1295
 */
1296
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
1297
{
1298
    int sfb, k;
1299

  
1300
    if (!sce->ics.predictor_initialized) {
1301
        reset_all_predictors(sce->predictor_state);
1302
        sce->ics.predictor_initialized = 1;
1303
    }
1304

  
1305
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
1306
        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
1307
            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
1308
                predict(ac, &sce->predictor_state[k], &sce->coeffs[k],
1309
                        sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
1310
            }
1311
        }
1312
        if (sce->ics.predictor_reset_group)
1313
            reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
1314
    } else
1315
        reset_all_predictors(sce->predictor_state);
1316
}
1317

  
1318
/**
1319
 * Decode an individual_channel_stream payload; reference: table 4.44.
1320
 *
1321
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
1322
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
1323
 *
1324
 * @return  Returns error status. 0 - OK, !0 - error
1325
 */
1326
static int decode_ics(AACContext *ac, SingleChannelElement *sce,
1327
                      GetBitContext *gb, int common_window, int scale_flag)
1328
{
1329
    Pulse pulse;
1330
    TemporalNoiseShaping    *tns = &sce->tns;
1331
    IndividualChannelStream *ics = &sce->ics;
1332
    float *out = sce->coeffs;
1333
    int global_gain, pulse_present = 0;
1334

  
1335
    /* This assignment is to silence a GCC warning about the variable being used
1336
     * uninitialized when in fact it always is.
1337
     */
1338
    pulse.num_pulse = 0;
1339

  
1340
    global_gain = get_bits(gb, 8);
1341

  
1342
    if (!common_window && !scale_flag) {
1343
        if (decode_ics_info(ac, ics, gb, 0) < 0)
1344
            return -1;
1345
    }
1346

  
1347
    if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
1348
        return -1;
1349
    if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
1350
        return -1;
1351

  
1352
    pulse_present = 0;
1353
    if (!scale_flag) {
1354
        if ((pulse_present = get_bits1(gb))) {
1355
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1356
                av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
1357
                return -1;
1358
            }
1359
            if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
1360
                av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
1361
                return -1;
1362
            }
1363
        }
1364
        if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
1365
            return -1;
1366
        if (get_bits1(gb)) {
1367
            av_log_missing_feature(ac->avctx, "SSR", 1);
1368
            return -1;
1369
        }
1370
    }
1371

  
1372
    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
1373
        return -1;
1374

  
1375
    if (ac->m4ac.object_type == AOT_AAC_MAIN && !common_window)
1376
        apply_prediction(ac, sce);
1377

  
1378
    return 0;
1379
}
1380

  
1381
/**
1382
 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
1383
 */
1384
static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
1385
{
1386
    const IndividualChannelStream *ics = &cpe->ch[0].ics;
1387
    float *ch0 = cpe->ch[0].coeffs;
1388
    float *ch1 = cpe->ch[1].coeffs;
1389
    int g, i, group, idx = 0;
1390
    const uint16_t *offsets = ics->swb_offset;
1391
    for (g = 0; g < ics->num_window_groups; g++) {
1392
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1393
            if (cpe->ms_mask[idx] &&
1394
                    cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
1395
                for (group = 0; group < ics->group_len[g]; group++) {
1396
                    ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i],
1397
                                              ch1 + group * 128 + offsets[i],
1398
                                              offsets[i+1] - offsets[i]);
1399
                }
1400
            }
1401
        }
1402
        ch0 += ics->group_len[g] * 128;
1403
        ch1 += ics->group_len[g] * 128;
1404
    }
1405
}
1406

  
1407
/**
1408
 * intensity stereo decoding; reference: 4.6.8.2.3
1409
 *
1410
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
1411
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
1412
 *                      [3] reserved for scalable AAC
1413
 */
1414
static void apply_intensity_stereo(ChannelElement *cpe, int ms_present)
1415
{
1416
    const IndividualChannelStream *ics = &cpe->ch[1].ics;
1417
    SingleChannelElement         *sce1 = &cpe->ch[1];
1418
    float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
1419
    const uint16_t *offsets = ics->swb_offset;
1420
    int g, group, i, k, idx = 0;
1421
    int c;
1422
    float scale;
1423
    for (g = 0; g < ics->num_window_groups; g++) {
1424
        for (i = 0; i < ics->max_sfb;) {
1425
            if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) {
1426
                const int bt_run_end = sce1->band_type_run_end[idx];
1427
                for (; i < bt_run_end; i++, idx++) {
1428
                    c = -1 + 2 * (sce1->band_type[idx] - 14);
1429
                    if (ms_present)
1430
                        c *= 1 - 2 * cpe->ms_mask[idx];
1431
                    scale = c * sce1->sf[idx];
1432
                    for (group = 0; group < ics->group_len[g]; group++)
1433
                        for (k = offsets[i]; k < offsets[i + 1]; k++)
1434
                            coef1[group * 128 + k] = scale * coef0[group * 128 + k];
1435
                }
1436
            } else {
1437
                int bt_run_end = sce1->band_type_run_end[idx];
1438
                idx += bt_run_end - i;
1439
                i    = bt_run_end;
1440
            }
1441
        }
1442
        coef0 += ics->group_len[g] * 128;
1443
        coef1 += ics->group_len[g] * 128;
1444
    }
1445
}
1446

  
1447
/**
1448
 * Decode a channel_pair_element; reference: table 4.4.
1449
 *
1450
 * @param   elem_id Identifies the instance of a syntax element.
1451
 *
1452
 * @return  Returns error status. 0 - OK, !0 - error
1453
 */
1454
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
1455
{
1456
    int i, ret, common_window, ms_present = 0;
1457

  
1458
    common_window = get_bits1(gb);
1459
    if (common_window) {
1460
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
1461
            return -1;
1462
        i = cpe->ch[1].ics.use_kb_window[0];
1463
        cpe->ch[1].ics = cpe->ch[0].ics;
1464
        cpe->ch[1].ics.use_kb_window[1] = i;
1465
        ms_present = get_bits(gb, 2);
1466
        if (ms_present == 3) {
1467
            av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1468
            return -1;
1469
        } else if (ms_present)
1470
            decode_mid_side_stereo(cpe, gb, ms_present);
1471
    }
1472
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
1473
        return ret;
1474
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff