Statistics
| Branch: | Revision:

ffmpeg / libavcodec / aac.c @ 897c1703

History | View | Annotate | Download (59.7 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 aac.c
25
 * AAC decoder
26
 * @author Oded Shimon  ( ods15 ods15 dyndns org )
27
 * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
28
 */
29

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

    
78

    
79
#include "avcodec.h"
80
#include "internal.h"
81
#include "bitstream.h"
82
#include "dsputil.h"
83
#include "lpc.h"
84

    
85
#include "aac.h"
86
#include "aactab.h"
87
#include "aacdectab.h"
88
#include "mpeg4audio.h"
89

    
90
#include <assert.h>
91
#include <errno.h>
92
#include <math.h>
93
#include <string.h>
94

    
95
static VLC vlc_scalefactors;
96
static VLC vlc_spectral[11];
97

    
98

    
99
/**
100
 * Configure output channel order based on the current program configuration element.
101
 *
102
 * @param   che_pos current channel position configuration
103
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
104
 *
105
 * @return  Returns error status. 0 - OK, !0 - error
106
 */
107
static int output_configure(AACContext *ac, enum ChannelPosition che_pos[4][MAX_ELEM_ID],
108
        enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]) {
109
    AVCodecContext *avctx = ac->avccontext;
110
    int i, type, channels = 0;
111

    
112
    if(!memcmp(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])))
113
        return 0; /* no change */
114

    
115
    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
116

    
117
    /* Allocate or free elements depending on if they are in the
118
     * current program configuration.
119
     *
120
     * Set up default 1:1 output mapping.
121
     *
122
     * For a 5.1 stream the output order will be:
123
     *    [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
124
     */
125

    
126
    for(i = 0; i < MAX_ELEM_ID; i++) {
127
        for(type = 0; type < 4; type++) {
128
            if(che_pos[type][i]) {
129
                if(!ac->che[type][i] && !(ac->che[type][i] = av_mallocz(sizeof(ChannelElement))))
130
                    return AVERROR(ENOMEM);
131
                if(type != TYPE_CCE) {
132
                    ac->output_data[channels++] = ac->che[type][i]->ch[0].ret;
133
                    if(type == TYPE_CPE) {
134
                        ac->output_data[channels++] = ac->che[type][i]->ch[1].ret;
135
                    }
136
                }
137
            } else
138
                av_freep(&ac->che[type][i]);
139
        }
140
    }
141

    
142
    avctx->channels = channels;
143
    return 0;
144
}
145

    
146
/**
147
 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
148
 *
149
 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
150
 * @param sce_map mono (Single Channel Element) map
151
 * @param type speaker type/position for these channels
152
 */
153
static void decode_channel_map(enum ChannelPosition *cpe_map,
154
        enum ChannelPosition *sce_map, enum ChannelPosition type, GetBitContext * gb, int n) {
155
    while(n--) {
156
        enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map
157
        map[get_bits(gb, 4)] = type;
158
    }
159
}
160

    
161
/**
162
 * Decode program configuration element; reference: table 4.2.
163
 *
164
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
165
 *
166
 * @return  Returns error status. 0 - OK, !0 - error
167
 */
168
static int decode_pce(AACContext * ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
169
        GetBitContext * gb) {
170
    int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
171

    
172
    skip_bits(gb, 2);  // object_type
173

    
174
    sampling_index = get_bits(gb, 4);
175
    if(sampling_index > 11) {
176
        av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
177
        return -1;
178
    }
179
    ac->m4ac.sampling_index = sampling_index;
180
    ac->m4ac.sample_rate = ff_mpeg4audio_sample_rates[ac->m4ac.sampling_index];
181
    num_front       = get_bits(gb, 4);
182
    num_side        = get_bits(gb, 4);
183
    num_back        = get_bits(gb, 4);
184
    num_lfe         = get_bits(gb, 2);
185
    num_assoc_data  = get_bits(gb, 3);
186
    num_cc          = get_bits(gb, 4);
187

    
188
    if (get_bits1(gb))
189
        skip_bits(gb, 4); // mono_mixdown_tag
190
    if (get_bits1(gb))
191
        skip_bits(gb, 4); // stereo_mixdown_tag
192

    
193
    if (get_bits1(gb))
194
        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
195

    
196
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
197
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE,  gb, num_side );
198
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK,  gb, num_back );
199
    decode_channel_map(NULL,                  new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE,   gb, num_lfe  );
200

    
201
    skip_bits_long(gb, 4 * num_assoc_data);
202

    
203
    decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC,    gb, num_cc   );
204

    
205
    align_get_bits(gb);
206

    
207
    /* comment field, first byte is length */
208
    skip_bits_long(gb, 8 * get_bits(gb, 8));
209
    return 0;
210
}
211

    
212
/**
213
 * Set up channel positions based on a default channel configuration
214
 * as specified in table 1.17.
215
 *
216
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
217
 *
218
 * @return  Returns error status. 0 - OK, !0 - error
219
 */
220
static int set_default_channel_config(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
221
        int channel_config)
222
{
223
    if(channel_config < 1 || channel_config > 7) {
224
        av_log(ac->avccontext, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
225
               channel_config);
226
        return -1;
227
    }
228

    
229
    /* default channel configurations:
230
     *
231
     * 1ch : front center (mono)
232
     * 2ch : L + R (stereo)
233
     * 3ch : front center + L + R
234
     * 4ch : front center + L + R + back center
235
     * 5ch : front center + L + R + back stereo
236
     * 6ch : front center + L + R + back stereo + LFE
237
     * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
238
     */
239

    
240
    if(channel_config != 2)
241
        new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono)
242
    if(channel_config > 1)
243
        new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo)
244
    if(channel_config == 4)
245
        new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK;  // back center
246
    if(channel_config > 4)
247
        new_che_pos[TYPE_CPE][(channel_config == 7) + 1]
248
                                 = AAC_CHANNEL_BACK;  // back stereo
249
    if(channel_config > 5)
250
        new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE;   // LFE
251
    if(channel_config == 7)
252
        new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right
253

    
254
    return 0;
255
}
256

    
257
/**
258
 * Decode GA "General Audio" specific configuration; reference: table 4.1.
259
 *
260
 * @return  Returns error status. 0 - OK, !0 - error
261
 */
262
static int decode_ga_specific_config(AACContext * ac, GetBitContext * gb, int channel_config) {
263
    enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
264
    int extension_flag, ret;
265

    
266
    if(get_bits1(gb)) {  // frameLengthFlag
267
        ff_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1);
268
        return -1;
269
    }
270

    
271
    if (get_bits1(gb))       // dependsOnCoreCoder
272
        skip_bits(gb, 14);   // coreCoderDelay
273
    extension_flag = get_bits1(gb);
274

    
275
    if(ac->m4ac.object_type == AOT_AAC_SCALABLE ||
276
       ac->m4ac.object_type == AOT_ER_AAC_SCALABLE)
277
        skip_bits(gb, 3);     // layerNr
278

    
279
    memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
280
    if (channel_config == 0) {
281
        skip_bits(gb, 4);  // element_instance_tag
282
        if((ret = decode_pce(ac, new_che_pos, gb)))
283
            return ret;
284
    } else {
285
        if((ret = set_default_channel_config(ac, new_che_pos, channel_config)))
286
            return ret;
287
    }
288
    if((ret = output_configure(ac, ac->che_pos, new_che_pos)))
289
        return ret;
290

    
291
    if (extension_flag) {
292
        switch (ac->m4ac.object_type) {
293
            case AOT_ER_BSAC:
294
                skip_bits(gb, 5);    // numOfSubFrame
295
                skip_bits(gb, 11);   // layer_length
296
                break;
297
            case AOT_ER_AAC_LC:
298
            case AOT_ER_AAC_LTP:
299
            case AOT_ER_AAC_SCALABLE:
300
            case AOT_ER_AAC_LD:
301
                skip_bits(gb, 3);  /* aacSectionDataResilienceFlag
302
                                    * aacScalefactorDataResilienceFlag
303
                                    * aacSpectralDataResilienceFlag
304
                                    */
305
                break;
306
        }
307
        skip_bits1(gb);    // extensionFlag3 (TBD in version 3)
308
    }
309
    return 0;
310
}
311

    
312
/**
313
 * Decode audio specific configuration; reference: table 1.13.
314
 *
315
 * @param   data        pointer to AVCodecContext extradata
316
 * @param   data_size   size of AVCCodecContext extradata
317
 *
318
 * @return  Returns error status. 0 - OK, !0 - error
319
 */
320
static int decode_audio_specific_config(AACContext * ac, void *data, int data_size) {
321
    GetBitContext gb;
322
    int i;
323

    
324
    init_get_bits(&gb, data, data_size * 8);
325

    
326
    if((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0)
327
        return -1;
328
    if(ac->m4ac.sampling_index > 11) {
329
        av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
330
        return -1;
331
    }
332

    
333
    skip_bits_long(&gb, i);
334

    
335
    switch (ac->m4ac.object_type) {
336
    case AOT_AAC_MAIN:
337
    case AOT_AAC_LC:
338
        if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config))
339
            return -1;
340
        break;
341
    default:
342
        av_log(ac->avccontext, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
343
               ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type);
344
        return -1;
345
    }
346
    return 0;
347
}
348

    
349
/**
350
 * linear congruential pseudorandom number generator
351
 *
352
 * @param   previous_val    pointer to the current state of the generator
353
 *
354
 * @return  Returns a 32-bit pseudorandom integer
355
 */
356
static av_always_inline int lcg_random(int previous_val) {
357
    return previous_val * 1664525 + 1013904223;
358
}
359

    
360
static void reset_predict_state(PredictorState * ps) {
361
    ps->r0 = 0.0f;
362
    ps->r1 = 0.0f;
363
    ps->cor0 = 0.0f;
364
    ps->cor1 = 0.0f;
365
    ps->var0 = 1.0f;
366
    ps->var1 = 1.0f;
367
}
368

    
369
static void reset_all_predictors(PredictorState * ps) {
370
    int i;
371
    for (i = 0; i < MAX_PREDICTORS; i++)
372
        reset_predict_state(&ps[i]);
373
}
374

    
375
static void reset_predictor_group(PredictorState * ps, int group_num) {
376
    int i;
377
    for (i = group_num-1; i < MAX_PREDICTORS; i+=30)
378
        reset_predict_state(&ps[i]);
379
}
380

    
381
static av_cold int aac_decode_init(AVCodecContext * avccontext) {
382
    AACContext * ac = avccontext->priv_data;
383
    int i;
384

    
385
    ac->avccontext = avccontext;
386

    
387
    if (avccontext->extradata_size <= 0 ||
388
        decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size))
389
        return -1;
390

    
391
    avccontext->sample_fmt  = SAMPLE_FMT_S16;
392
    avccontext->sample_rate = ac->m4ac.sample_rate;
393
    avccontext->frame_size  = 1024;
394

    
395
    AAC_INIT_VLC_STATIC( 0, 144);
396
    AAC_INIT_VLC_STATIC( 1, 114);
397
    AAC_INIT_VLC_STATIC( 2, 188);
398
    AAC_INIT_VLC_STATIC( 3, 180);
399
    AAC_INIT_VLC_STATIC( 4, 172);
400
    AAC_INIT_VLC_STATIC( 5, 140);
401
    AAC_INIT_VLC_STATIC( 6, 168);
402
    AAC_INIT_VLC_STATIC( 7, 114);
403
    AAC_INIT_VLC_STATIC( 8, 262);
404
    AAC_INIT_VLC_STATIC( 9, 248);
405
    AAC_INIT_VLC_STATIC(10, 384);
406

    
407
    dsputil_init(&ac->dsp, avccontext);
408

    
409
    ac->random_state = 0x1f2e3d4c;
410

    
411
    // -1024 - Compensate wrong IMDCT method.
412
    // 32768 - Required to scale values to the correct range for the bias method
413
    //         for float to int16 conversion.
414

    
415
    if(ac->dsp.float_to_int16 == ff_float_to_int16_c) {
416
        ac->add_bias = 385.0f;
417
        ac->sf_scale = 1. / (-1024. * 32768.);
418
        ac->sf_offset = 0;
419
    } else {
420
        ac->add_bias = 0.0f;
421
        ac->sf_scale = 1. / -1024.;
422
        ac->sf_offset = 60;
423
    }
424

    
425
#ifndef CONFIG_HARDCODED_TABLES
426
    for (i = 0; i < 428; i++)
427
        ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.);
428
#endif /* CONFIG_HARDCODED_TABLES */
429

    
430
    INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
431
        ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
432
        ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
433
        352);
434

    
435
    ff_mdct_init(&ac->mdct, 11, 1);
436
    ff_mdct_init(&ac->mdct_small, 8, 1);
437
    // window initialization
438
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
439
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
440
    ff_sine_window_init(ff_sine_1024, 1024);
441
    ff_sine_window_init(ff_sine_128, 128);
442

    
443
    return 0;
444
}
445

    
446
/**
447
 * Skip data_stream_element; reference: table 4.10.
448
 */
449
static void skip_data_stream_element(GetBitContext * gb) {
450
    int byte_align = get_bits1(gb);
451
    int count = get_bits(gb, 8);
452
    if (count == 255)
453
        count += get_bits(gb, 8);
454
    if (byte_align)
455
        align_get_bits(gb);
456
    skip_bits_long(gb, 8 * count);
457
}
458

    
459
static int decode_prediction(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb) {
460
    int sfb;
461
    if (get_bits1(gb)) {
462
        ics->predictor_reset_group = get_bits(gb, 5);
463
        if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
464
            av_log(ac->avccontext, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
465
            return -1;
466
        }
467
    }
468
    for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->m4ac.sampling_index]); sfb++) {
469
        ics->prediction_used[sfb] = get_bits1(gb);
470
    }
471
    return 0;
472
}
473

    
474
/**
475
 * Decode Individual Channel Stream info; reference: table 4.6.
476
 *
477
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
478
 */
479
static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb, int common_window) {
480
    if (get_bits1(gb)) {
481
        av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n");
482
        memset(ics, 0, sizeof(IndividualChannelStream));
483
        return -1;
484
    }
485
    ics->window_sequence[1] = ics->window_sequence[0];
486
    ics->window_sequence[0] = get_bits(gb, 2);
487
    ics->use_kb_window[1] = ics->use_kb_window[0];
488
    ics->use_kb_window[0] = get_bits1(gb);
489
    ics->num_window_groups = 1;
490
    ics->group_len[0] = 1;
491
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
492
        int i;
493
        ics->max_sfb = get_bits(gb, 4);
494
        for (i = 0; i < 7; i++) {
495
            if (get_bits1(gb)) {
496
                ics->group_len[ics->num_window_groups-1]++;
497
            } else {
498
                ics->num_window_groups++;
499
                ics->group_len[ics->num_window_groups-1] = 1;
500
            }
501
        }
502
        ics->num_windows   = 8;
503
        ics->swb_offset    =      swb_offset_128[ac->m4ac.sampling_index];
504
        ics->num_swb       =  ff_aac_num_swb_128[ac->m4ac.sampling_index];
505
        ics->tns_max_bands =   tns_max_bands_128[ac->m4ac.sampling_index];
506
        ics->predictor_present = 0;
507
    } else {
508
        ics->max_sfb       = get_bits(gb, 6);
509
        ics->num_windows   = 1;
510
        ics->swb_offset    =     swb_offset_1024[ac->m4ac.sampling_index];
511
        ics->num_swb       = ff_aac_num_swb_1024[ac->m4ac.sampling_index];
512
        ics->tns_max_bands =  tns_max_bands_1024[ac->m4ac.sampling_index];
513
        ics->predictor_present = get_bits1(gb);
514
        ics->predictor_reset_group = 0;
515
        if (ics->predictor_present) {
516
            if (ac->m4ac.object_type == AOT_AAC_MAIN) {
517
                if (decode_prediction(ac, ics, gb)) {
518
                    memset(ics, 0, sizeof(IndividualChannelStream));
519
                    return -1;
520
                }
521
            } else if (ac->m4ac.object_type == AOT_AAC_LC) {
522
                av_log(ac->avccontext, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
523
                memset(ics, 0, sizeof(IndividualChannelStream));
524
                return -1;
525
            } else {
526
                ff_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1);
527
                memset(ics, 0, sizeof(IndividualChannelStream));
528
                return -1;
529
            }
530
        }
531
    }
532

    
533
    if(ics->max_sfb > ics->num_swb) {
534
        av_log(ac->avccontext, AV_LOG_ERROR,
535
            "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
536
            ics->max_sfb, ics->num_swb);
537
        memset(ics, 0, sizeof(IndividualChannelStream));
538
        return -1;
539
    }
540

    
541
    return 0;
542
}
543

    
544
/**
545
 * Decode band types (section_data payload); reference: table 4.46.
546
 *
547
 * @param   band_type           array of the used band type
548
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
549
 *
550
 * @return  Returns error status. 0 - OK, !0 - error
551
 */
552
static int decode_band_types(AACContext * ac, enum BandType band_type[120],
553
        int band_type_run_end[120], GetBitContext * gb, IndividualChannelStream * ics) {
554
    int g, idx = 0;
555
    const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
556
    for (g = 0; g < ics->num_window_groups; g++) {
557
        int k = 0;
558
        while (k < ics->max_sfb) {
559
            uint8_t sect_len = k;
560
            int sect_len_incr;
561
            int sect_band_type = get_bits(gb, 4);
562
            if (sect_band_type == 12) {
563
                av_log(ac->avccontext, AV_LOG_ERROR, "invalid band type\n");
564
                return -1;
565
            }
566
            while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits)-1)
567
                sect_len += sect_len_incr;
568
            sect_len += sect_len_incr;
569
            if (sect_len > ics->max_sfb) {
570
                av_log(ac->avccontext, AV_LOG_ERROR,
571
                    "Number of bands (%d) exceeds limit (%d).\n",
572
                    sect_len, ics->max_sfb);
573
                return -1;
574
            }
575
            for (; k < sect_len; k++) {
576
                band_type        [idx]   = sect_band_type;
577
                band_type_run_end[idx++] = sect_len;
578
            }
579
        }
580
    }
581
    return 0;
582
}
583

    
584
/**
585
 * Decode scalefactors; reference: table 4.47.
586
 *
587
 * @param   global_gain         first scalefactor value as scalefactors are differentially coded
588
 * @param   band_type           array of the used band type
589
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
590
 * @param   sf                  array of scalefactors or intensity stereo positions
591
 *
592
 * @return  Returns error status. 0 - OK, !0 - error
593
 */
594
static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * gb,
595
        unsigned int global_gain, IndividualChannelStream * ics,
596
        enum BandType band_type[120], int band_type_run_end[120]) {
597
    const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0);
598
    int g, i, idx = 0;
599
    int offset[3] = { global_gain, global_gain - 90, 100 };
600
    int noise_flag = 1;
601
    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
602
    for (g = 0; g < ics->num_window_groups; g++) {
603
        for (i = 0; i < ics->max_sfb;) {
604
            int run_end = band_type_run_end[idx];
605
            if (band_type[idx] == ZERO_BT) {
606
                for(; i < run_end; i++, idx++)
607
                    sf[idx] = 0.;
608
            }else if((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
609
                for(; i < run_end; i++, idx++) {
610
                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
611
                    if(offset[2] > 255U) {
612
                        av_log(ac->avccontext, AV_LOG_ERROR,
613
                            "%s (%d) out of range.\n", sf_str[2], offset[2]);
614
                        return -1;
615
                    }
616
                    sf[idx]  = ff_aac_pow2sf_tab[-offset[2] + 300];
617
                }
618
            }else if(band_type[idx] == NOISE_BT) {
619
                for(; i < run_end; i++, idx++) {
620
                    if(noise_flag-- > 0)
621
                        offset[1] += get_bits(gb, 9) - 256;
622
                    else
623
                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
624
                    if(offset[1] > 255U) {
625
                        av_log(ac->avccontext, AV_LOG_ERROR,
626
                            "%s (%d) out of range.\n", sf_str[1], offset[1]);
627
                        return -1;
628
                    }
629
                    sf[idx]  = -ff_aac_pow2sf_tab[ offset[1] + sf_offset + 100];
630
                }
631
            }else {
632
                for(; i < run_end; i++, idx++) {
633
                    offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
634
                    if(offset[0] > 255U) {
635
                        av_log(ac->avccontext, AV_LOG_ERROR,
636
                            "%s (%d) out of range.\n", sf_str[0], offset[0]);
637
                        return -1;
638
                    }
639
                    sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset];
640
                }
641
            }
642
        }
643
    }
644
    return 0;
645
}
646

    
647
/**
648
 * Decode pulse data; reference: table 4.7.
649
 */
650
static int decode_pulses(Pulse * pulse, GetBitContext * gb, const uint16_t * swb_offset, int num_swb) {
651
    int i, pulse_swb;
652
    pulse->num_pulse = get_bits(gb, 2) + 1;
653
    pulse_swb        = get_bits(gb, 6);
654
    if (pulse_swb >= num_swb)
655
        return -1;
656
    pulse->pos[0]    = swb_offset[pulse_swb];
657
    pulse->pos[0]   += get_bits(gb, 5);
658
    if (pulse->pos[0] > 1023)
659
        return -1;
660
    pulse->amp[0]    = get_bits(gb, 4);
661
    for (i = 1; i < pulse->num_pulse; i++) {
662
        pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i-1];
663
        if (pulse->pos[i] > 1023)
664
            return -1;
665
        pulse->amp[i] = get_bits(gb, 4);
666
    }
667
    return 0;
668
}
669

    
670
/**
671
 * Decode Temporal Noise Shaping data; reference: table 4.48.
672
 *
673
 * @return  Returns error status. 0 - OK, !0 - error
674
 */
675
static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns,
676
        GetBitContext * gb, const IndividualChannelStream * ics) {
677
    int w, filt, i, coef_len, coef_res, coef_compress;
678
    const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
679
    const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
680
    for (w = 0; w < ics->num_windows; w++) {
681
        if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
682
            coef_res = get_bits1(gb);
683

    
684
            for (filt = 0; filt < tns->n_filt[w]; filt++) {
685
                int tmp2_idx;
686
                tns->length[w][filt] = get_bits(gb, 6 - 2*is8);
687

    
688
                if ((tns->order[w][filt] = get_bits(gb, 5 - 2*is8)) > tns_max_order) {
689
                    av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.",
690
                           tns->order[w][filt], tns_max_order);
691
                    tns->order[w][filt] = 0;
692
                    return -1;
693
                }
694
                if (tns->order[w][filt]) {
695
                    tns->direction[w][filt] = get_bits1(gb);
696
                    coef_compress = get_bits1(gb);
697
                    coef_len = coef_res + 3 - coef_compress;
698
                    tmp2_idx = 2*coef_compress + coef_res;
699

    
700
                    for (i = 0; i < tns->order[w][filt]; i++)
701
                        tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
702
                }
703
            }
704
        }
705
    }
706
    return 0;
707
}
708

    
709
/**
710
 * Decode Mid/Side data; reference: table 4.54.
711
 *
712
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
713
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
714
 *                      [3] reserved for scalable AAC
715
 */
716
static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb,
717
        int ms_present) {
718
    int idx;
719
    if (ms_present == 1) {
720
        for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
721
            cpe->ms_mask[idx] = get_bits1(gb);
722
    } else if (ms_present == 2) {
723
        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
724
    }
725
}
726

    
727
/**
728
 * Decode spectral data; reference: table 4.50.
729
 * Dequantize and scale spectral data; reference: 4.6.3.3.
730
 *
731
 * @param   coef            array of dequantized, scaled spectral data
732
 * @param   sf              array of scalefactors or intensity stereo positions
733
 * @param   pulse_present   set if pulses are present
734
 * @param   pulse           pointer to pulse data struct
735
 * @param   band_type       array of the used band type
736
 *
737
 * @return  Returns error status. 0 - OK, !0 - error
738
 */
739
static int decode_spectrum_and_dequant(AACContext * ac, float coef[1024], GetBitContext * gb, float sf[120],
740
        int pulse_present, const Pulse * pulse, const IndividualChannelStream * ics, enum BandType band_type[120]) {
741
    int i, k, g, idx = 0;
742
    const int c = 1024/ics->num_windows;
743
    const uint16_t * offsets = ics->swb_offset;
744
    float *coef_base = coef;
745
    static const float sign_lookup[] = { 1.0f, -1.0f };
746

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

    
750
    for (g = 0; g < ics->num_window_groups; g++) {
751
        for (i = 0; i < ics->max_sfb; i++, idx++) {
752
            const int cur_band_type = band_type[idx];
753
            const int dim = cur_band_type >= FIRST_PAIR_BT ? 2 : 4;
754
            const int is_cb_unsigned = IS_CODEBOOK_UNSIGNED(cur_band_type);
755
            int group;
756
            if (cur_band_type == ZERO_BT || cur_band_type == INTENSITY_BT2 || cur_band_type == INTENSITY_BT) {
757
                for (group = 0; group < ics->group_len[g]; group++) {
758
                    memset(coef + group * 128 + offsets[i], 0, (offsets[i+1] - offsets[i])*sizeof(float));
759
                }
760
            }else if (cur_band_type == NOISE_BT) {
761
                for (group = 0; group < ics->group_len[g]; group++) {
762
                    float scale;
763
                    float band_energy = 0;
764
                    for (k = offsets[i]; k < offsets[i+1]; k++) {
765
                        ac->random_state  = lcg_random(ac->random_state);
766
                        coef[group*128+k] = ac->random_state;
767
                        band_energy += coef[group*128+k]*coef[group*128+k];
768
                    }
769
                    scale = sf[idx] / sqrtf(band_energy);
770
                    for (k = offsets[i]; k < offsets[i+1]; k++) {
771
                        coef[group*128+k] *= scale;
772
                    }
773
                }
774
            }else {
775
                for (group = 0; group < ics->group_len[g]; group++) {
776
                    for (k = offsets[i]; k < offsets[i+1]; k += dim) {
777
                        const int index = get_vlc2(gb, vlc_spectral[cur_band_type - 1].table, 6, 3);
778
                        const int coef_tmp_idx = (group << 7) + k;
779
                        const float *vq_ptr;
780
                        int j;
781
                        if(index >= ff_aac_spectral_sizes[cur_band_type - 1]) {
782
                            av_log(ac->avccontext, AV_LOG_ERROR,
783
                                "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
784
                                cur_band_type - 1, index, ff_aac_spectral_sizes[cur_band_type - 1]);
785
                            return -1;
786
                        }
787
                        vq_ptr = &ff_aac_codebook_vectors[cur_band_type - 1][index * dim];
788
                        if (is_cb_unsigned) {
789
                            if (vq_ptr[0]) coef[coef_tmp_idx    ] = sign_lookup[get_bits1(gb)];
790
                            if (vq_ptr[1]) coef[coef_tmp_idx + 1] = sign_lookup[get_bits1(gb)];
791
                            if (dim == 4) {
792
                                if (vq_ptr[2]) coef[coef_tmp_idx + 2] = sign_lookup[get_bits1(gb)];
793
                                if (vq_ptr[3]) coef[coef_tmp_idx + 3] = sign_lookup[get_bits1(gb)];
794
                            }
795
                        }else {
796
                            coef[coef_tmp_idx    ] = 1.0f;
797
                            coef[coef_tmp_idx + 1] = 1.0f;
798
                            if (dim == 4) {
799
                                coef[coef_tmp_idx + 2] = 1.0f;
800
                                coef[coef_tmp_idx + 3] = 1.0f;
801
                            }
802
                        }
803
                        if (cur_band_type == ESC_BT) {
804
                            for (j = 0; j < 2; j++) {
805
                                if (vq_ptr[j] == 64.0f) {
806
                                    int n = 4;
807
                                    /* The total length of escape_sequence must be < 22 bits according
808
                                       to the specification (i.e. max is 11111111110xxxxxxxxxx). */
809
                                    while (get_bits1(gb) && n < 15) n++;
810
                                    if(n == 15) {
811
                                        av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
812
                                        return -1;
813
                                    }
814
                                    n = (1<<n) + get_bits(gb, n);
815
                                    coef[coef_tmp_idx + j] *= cbrtf(n) * n;
816
                                }else
817
                                    coef[coef_tmp_idx + j] *= vq_ptr[j];
818
                            }
819
                        }else
820
                        {
821
                            coef[coef_tmp_idx    ] *= vq_ptr[0];
822
                            coef[coef_tmp_idx + 1] *= vq_ptr[1];
823
                            if (dim == 4) {
824
                                coef[coef_tmp_idx + 2] *= vq_ptr[2];
825
                                coef[coef_tmp_idx + 3] *= vq_ptr[3];
826
                            }
827
                        }
828
                        coef[coef_tmp_idx    ] *= sf[idx];
829
                        coef[coef_tmp_idx + 1] *= sf[idx];
830
                        if (dim == 4) {
831
                            coef[coef_tmp_idx + 2] *= sf[idx];
832
                            coef[coef_tmp_idx + 3] *= sf[idx];
833
                        }
834
                    }
835
                }
836
            }
837
        }
838
        coef += ics->group_len[g]<<7;
839
    }
840

    
841
    if (pulse_present) {
842
        idx = 0;
843
        for(i = 0; i < pulse->num_pulse; i++){
844
            float co  = coef_base[ pulse->pos[i] ];
845
            while(offsets[idx + 1] <= pulse->pos[i])
846
                idx++;
847
            if (band_type[idx] != NOISE_BT && sf[idx]) {
848
                float ico = -pulse->amp[i];
849
                if (co) {
850
                    co /= sf[idx];
851
                    ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
852
                }
853
                coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
854
            }
855
        }
856
    }
857
    return 0;
858
}
859

    
860
static av_always_inline float flt16_round(float pf) {
861
    int exp;
862
    pf = frexpf(pf, &exp);
863
    pf = ldexpf(roundf(ldexpf(pf, 8)), exp-8);
864
    return pf;
865
}
866

    
867
static av_always_inline float flt16_even(float pf) {
868
    int exp;
869
    pf = frexpf(pf, &exp);
870
    pf = ldexpf(rintf(ldexpf(pf, 8)), exp-8);
871
    return pf;
872
}
873

    
874
static av_always_inline float flt16_trunc(float pf) {
875
    int exp;
876
    pf = frexpf(pf, &exp);
877
    pf = ldexpf(truncf(ldexpf(pf, 8)), exp-8);
878
    return pf;
879
}
880

    
881
static void predict(AACContext * ac, PredictorState * ps, float* coef, int output_enable) {
882
    const float a     = 0.953125; // 61.0/64
883
    const float alpha = 0.90625;  // 29.0/32
884
    float e0, e1;
885
    float pv;
886
    float k1, k2;
887

    
888
    k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
889
    k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
890

    
891
    pv = flt16_round(k1 * ps->r0 + k2 * ps->r1);
892
    if (output_enable)
893
        *coef += pv * ac->sf_scale;
894

    
895
    e0 = *coef / ac->sf_scale;
896
    e1 = e0 - k1 * ps->r0;
897

    
898
    ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1);
899
    ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5 * (ps->r1 * ps->r1 + e1 * e1));
900
    ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0);
901
    ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5 * (ps->r0 * ps->r0 + e0 * e0));
902

    
903
    ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0));
904
    ps->r0 = flt16_trunc(a * e0);
905
}
906

    
907
/**
908
 * Apply AAC-Main style frequency domain prediction.
909
 */
910
static void apply_prediction(AACContext * ac, SingleChannelElement * sce) {
911
    int sfb, k;
912

    
913
    if (!sce->ics.predictor_initialized) {
914
        reset_all_predictors(sce->predictor_state);
915
        sce->ics.predictor_initialized = 1;
916
    }
917

    
918
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
919
        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
920
            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
921
                predict(ac, &sce->predictor_state[k], &sce->coeffs[k],
922
                    sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
923
            }
924
        }
925
        if (sce->ics.predictor_reset_group)
926
            reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
927
    } else
928
        reset_all_predictors(sce->predictor_state);
929
}
930

    
931
/**
932
 * Decode an individual_channel_stream payload; reference: table 4.44.
933
 *
934
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
935
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
936
 *
937
 * @return  Returns error status. 0 - OK, !0 - error
938
 */
939
static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext * gb, int common_window, int scale_flag) {
940
    Pulse pulse;
941
    TemporalNoiseShaping * tns = &sce->tns;
942
    IndividualChannelStream * ics = &sce->ics;
943
    float * out = sce->coeffs;
944
    int global_gain, pulse_present = 0;
945

    
946
    /* This assignment is to silence a GCC warning about the variable being used
947
     * uninitialized when in fact it always is.
948
     */
949
    pulse.num_pulse = 0;
950

    
951
    global_gain = get_bits(gb, 8);
952

    
953
    if (!common_window && !scale_flag) {
954
        if (decode_ics_info(ac, ics, gb, 0) < 0)
955
            return -1;
956
    }
957

    
958
    if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
959
        return -1;
960
    if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
961
        return -1;
962

    
963
    pulse_present = 0;
964
    if (!scale_flag) {
965
        if ((pulse_present = get_bits1(gb))) {
966
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
967
                av_log(ac->avccontext, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
968
                return -1;
969
            }
970
            if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
971
                av_log(ac->avccontext, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
972
                return -1;
973
            }
974
        }
975
        if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
976
            return -1;
977
        if (get_bits1(gb)) {
978
            ff_log_missing_feature(ac->avccontext, "SSR", 1);
979
            return -1;
980
        }
981
    }
982

    
983
    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
984
        return -1;
985

    
986
    if(ac->m4ac.object_type == AOT_AAC_MAIN && !common_window)
987
        apply_prediction(ac, sce);
988

    
989
    return 0;
990
}
991

    
992
/**
993
 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
994
 */
995
static void apply_mid_side_stereo(ChannelElement * cpe) {
996
    const IndividualChannelStream * ics = &cpe->ch[0].ics;
997
    float *ch0 = cpe->ch[0].coeffs;
998
    float *ch1 = cpe->ch[1].coeffs;
999
    int g, i, k, group, idx = 0;
1000
    const uint16_t * offsets = ics->swb_offset;
1001
    for (g = 0; g < ics->num_window_groups; g++) {
1002
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1003
            if (cpe->ms_mask[idx] &&
1004
                cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
1005
                for (group = 0; group < ics->group_len[g]; group++) {
1006
                    for (k = offsets[i]; k < offsets[i+1]; k++) {
1007
                        float tmp = ch0[group*128 + k] - ch1[group*128 + k];
1008
                        ch0[group*128 + k] += ch1[group*128 + k];
1009
                        ch1[group*128 + k] = tmp;
1010
                    }
1011
                }
1012
            }
1013
        }
1014
        ch0 += ics->group_len[g]*128;
1015
        ch1 += ics->group_len[g]*128;
1016
    }
1017
}
1018

    
1019
/**
1020
 * intensity stereo decoding; reference: 4.6.8.2.3
1021
 *
1022
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
1023
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
1024
 *                      [3] reserved for scalable AAC
1025
 */
1026
static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) {
1027
    const IndividualChannelStream * ics = &cpe->ch[1].ics;
1028
    SingleChannelElement * sce1 = &cpe->ch[1];
1029
    float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
1030
    const uint16_t * offsets = ics->swb_offset;
1031
    int g, group, i, k, idx = 0;
1032
    int c;
1033
    float scale;
1034
    for (g = 0; g < ics->num_window_groups; g++) {
1035
        for (i = 0; i < ics->max_sfb;) {
1036
            if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) {
1037
                const int bt_run_end = sce1->band_type_run_end[idx];
1038
                for (; i < bt_run_end; i++, idx++) {
1039
                    c = -1 + 2 * (sce1->band_type[idx] - 14);
1040
                    if (ms_present)
1041
                        c *= 1 - 2 * cpe->ms_mask[idx];
1042
                    scale = c * sce1->sf[idx];
1043
                    for (group = 0; group < ics->group_len[g]; group++)
1044
                        for (k = offsets[i]; k < offsets[i+1]; k++)
1045
                            coef1[group*128 + k] = scale * coef0[group*128 + k];
1046
                }
1047
            } else {
1048
                int bt_run_end = sce1->band_type_run_end[idx];
1049
                idx += bt_run_end - i;
1050
                i    = bt_run_end;
1051
            }
1052
        }
1053
        coef0 += ics->group_len[g]*128;
1054
        coef1 += ics->group_len[g]*128;
1055
    }
1056
}
1057

    
1058
/**
1059
 * Decode a channel_pair_element; reference: table 4.4.
1060
 *
1061
 * @param   elem_id Identifies the instance of a syntax element.
1062
 *
1063
 * @return  Returns error status. 0 - OK, !0 - error
1064
 */
1065
static int decode_cpe(AACContext * ac, GetBitContext * gb, int elem_id) {
1066
    int i, ret, common_window, ms_present = 0;
1067
    ChannelElement * cpe;
1068

    
1069
    cpe = ac->che[TYPE_CPE][elem_id];
1070
    common_window = get_bits1(gb);
1071
    if (common_window) {
1072
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
1073
            return -1;
1074
        i = cpe->ch[1].ics.use_kb_window[0];
1075
        cpe->ch[1].ics = cpe->ch[0].ics;
1076
        cpe->ch[1].ics.use_kb_window[1] = i;
1077
        ms_present = get_bits(gb, 2);
1078
        if(ms_present == 3) {
1079
            av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1080
            return -1;
1081
        } else if(ms_present)
1082
            decode_mid_side_stereo(cpe, gb, ms_present);
1083
    }
1084
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
1085
        return ret;
1086
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
1087
        return ret;
1088

    
1089
    if (common_window) {
1090
        if (ms_present)
1091
            apply_mid_side_stereo(cpe);
1092
        if (ac->m4ac.object_type == AOT_AAC_MAIN) {
1093
            apply_prediction(ac, &cpe->ch[0]);
1094
            apply_prediction(ac, &cpe->ch[1]);
1095
        }
1096
    }
1097

    
1098
    apply_intensity_stereo(cpe, ms_present);
1099
    return 0;
1100
}
1101

    
1102
/**
1103
 * Decode coupling_channel_element; reference: table 4.8.
1104
 *
1105
 * @param   elem_id Identifies the instance of a syntax element.
1106
 *
1107
 * @return  Returns error status. 0 - OK, !0 - error
1108
 */
1109
static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) {
1110
    int num_gain = 0;
1111
    int c, g, sfb, ret;
1112
    int sign;
1113
    float scale;
1114
    SingleChannelElement * sce = &che->ch[0];
1115
    ChannelCoupling * coup     = &che->coup;
1116

    
1117
    coup->coupling_point = 2*get_bits1(gb);
1118
    coup->num_coupled = get_bits(gb, 3);
1119
    for (c = 0; c <= coup->num_coupled; c++) {
1120
        num_gain++;
1121
        coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
1122
        coup->id_select[c] = get_bits(gb, 4);
1123
        if (coup->type[c] == TYPE_CPE) {
1124
            coup->ch_select[c] = get_bits(gb, 2);
1125
            if (coup->ch_select[c] == 3)
1126
                num_gain++;
1127
        } else
1128
            coup->ch_select[c] = 2;
1129
    }
1130
    coup->coupling_point += get_bits1(gb);
1131

    
1132
    if (coup->coupling_point == 2) {
1133
        av_log(ac->avccontext, AV_LOG_ERROR,
1134
            "Independently switched CCE with 'invalid' domain signalled.\n");
1135
        memset(coup, 0, sizeof(ChannelCoupling));
1136
        return -1;
1137
    }
1138

    
1139
    sign = get_bits(gb, 1);
1140
    scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3));
1141

    
1142
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
1143
        return ret;
1144

    
1145
    for (c = 0; c < num_gain; c++) {
1146
        int idx = 0;
1147
        int cge = 1;
1148
        int gain = 0;
1149
        float gain_cache = 1.;
1150
        if (c) {
1151
            cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
1152
            gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
1153
            gain_cache = pow(scale, -gain);
1154
        }
1155
        for (g = 0; g < sce->ics.num_window_groups; g++) {
1156
            for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
1157
                if (sce->band_type[idx] != ZERO_BT) {
1158
                    if (!cge) {
1159
                        int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
1160
                        if (t) {
1161
                            int s = 1;
1162
                            t = gain += t;
1163
                            if (sign) {
1164
                                s  -= 2 * (t & 0x1);
1165
                                t >>= 1;
1166
                            }
1167
                            gain_cache = pow(scale, -t) * s;
1168
                        }
1169
                    }
1170
                    coup->gain[c][idx] = gain_cache;
1171
                }
1172
            }
1173
        }
1174
    }
1175
    return 0;
1176
}
1177

    
1178
/**
1179
 * Decode Spectral Band Replication extension data; reference: table 4.55.
1180
 *
1181
 * @param   crc flag indicating the presence of CRC checksum
1182
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1183
 *
1184
 * @return  Returns number of bytes consumed from the TYPE_FIL element.
1185
 */
1186
static int decode_sbr_extension(AACContext * ac, GetBitContext * gb, int crc, int cnt) {
1187
    // TODO : sbr_extension implementation
1188
    ff_log_missing_feature(ac->avccontext, "SBR", 0);
1189
    skip_bits_long(gb, 8*cnt - 4); // -4 due to reading extension type
1190
    return cnt;
1191
}
1192

    
1193
/**
1194
 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1195
 *
1196
 * @return  Returns number of bytes consumed.
1197
 */
1198
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitContext * gb) {
1199
    int i;
1200
    int num_excl_chan = 0;
1201

    
1202
    do {
1203
        for (i = 0; i < 7; i++)
1204
            che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
1205
    } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
1206

    
1207
    return num_excl_chan / 7;
1208
}
1209

    
1210
/**
1211
 * Decode dynamic range information; reference: table 4.52.
1212
 *
1213
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1214
 *
1215
 * @return  Returns number of bytes consumed.
1216
 */
1217
static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext * gb, int cnt) {
1218
    int n = 1;
1219
    int drc_num_bands = 1;
1220
    int i;
1221

    
1222
    /* pce_tag_present? */
1223
    if(get_bits1(gb)) {
1224
        che_drc->pce_instance_tag  = get_bits(gb, 4);
1225
        skip_bits(gb, 4); // tag_reserved_bits
1226
        n++;
1227
    }
1228

    
1229
    /* excluded_chns_present? */
1230
    if(get_bits1(gb)) {
1231
        n += decode_drc_channel_exclusions(che_drc, gb);
1232
    }
1233

    
1234
    /* drc_bands_present? */
1235
    if (get_bits1(gb)) {
1236
        che_drc->band_incr            = get_bits(gb, 4);
1237
        che_drc->interpolation_scheme = get_bits(gb, 4);
1238
        n++;
1239
        drc_num_bands += che_drc->band_incr;
1240
        for (i = 0; i < drc_num_bands; i++) {
1241
            che_drc->band_top[i] = get_bits(gb, 8);
1242
            n++;
1243
        }
1244
    }
1245

    
1246
    /* prog_ref_level_present? */
1247
    if (get_bits1(gb)) {
1248
        che_drc->prog_ref_level = get_bits(gb, 7);
1249
        skip_bits1(gb); // prog_ref_level_reserved_bits
1250
        n++;
1251
    }
1252

    
1253
    for (i = 0; i < drc_num_bands; i++) {
1254
        che_drc->dyn_rng_sgn[i] = get_bits1(gb);
1255
        che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
1256
        n++;
1257
    }
1258

    
1259
    return n;
1260
}
1261

    
1262
/**
1263
 * Decode extension data (incomplete); reference: table 4.51.
1264
 *
1265
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1266
 *
1267
 * @return Returns number of bytes consumed
1268
 */
1269
static int decode_extension_payload(AACContext * ac, GetBitContext * gb, int cnt) {
1270
    int crc_flag = 0;
1271
    int res = cnt;
1272
    switch (get_bits(gb, 4)) { // extension type
1273
        case EXT_SBR_DATA_CRC:
1274
            crc_flag++;
1275
        case EXT_SBR_DATA:
1276
            res = decode_sbr_extension(ac, gb, crc_flag, cnt);
1277
            break;
1278
        case EXT_DYNAMIC_RANGE:
1279
            res = decode_dynamic_range(&ac->che_drc, gb, cnt);
1280
            break;
1281
        case EXT_FILL:
1282
        case EXT_FILL_DATA:
1283
        case EXT_DATA_ELEMENT:
1284
        default:
1285
            skip_bits_long(gb, 8*cnt - 4);
1286
            break;
1287
    };
1288
    return res;
1289
}
1290

    
1291
/**
1292
 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
1293
 *
1294
 * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
1295
 * @param   coef    spectral coefficients
1296
 */
1297
static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualChannelStream * ics, int decode) {
1298
    const int mmm = FFMIN(ics->tns_max_bands,  ics->max_sfb);
1299
    int w, filt, m, i;
1300
    int bottom, top, order, start, end, size, inc;
1301
    float lpc[TNS_MAX_ORDER];
1302

    
1303
    for (w = 0; w < ics->num_windows; w++) {
1304
        bottom = ics->num_swb;
1305
        for (filt = 0; filt < tns->n_filt[w]; filt++) {
1306
            top    = bottom;
1307
            bottom = FFMAX(0, top - tns->length[w][filt]);
1308
            order  = tns->order[w][filt];
1309
            if (order == 0)
1310
                continue;
1311

    
1312
            // tns_decode_coef
1313
            compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
1314

    
1315
            start = ics->swb_offset[FFMIN(bottom, mmm)];
1316
            end   = ics->swb_offset[FFMIN(   top, mmm)];
1317
            if ((size = end - start) <= 0)
1318
                continue;
1319
            if (tns->direction[w][filt]) {
1320
                inc = -1; start = end - 1;
1321
            } else {
1322
                inc = 1;
1323
            }
1324
            start += w * 128;
1325

    
1326
            // ar filter
1327
            for (m = 0; m < size; m++, start += inc)
1328
                for (i = 1; i <= FFMIN(m, order); i++)
1329
                    coef[start] -= coef[start - i*inc] * lpc[i-1];
1330
        }
1331
    }
1332
}
1333

    
1334
/**
1335
 * Conduct IMDCT and windowing.
1336
 */
1337
static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) {
1338
    IndividualChannelStream * ics = &sce->ics;
1339
    float * in = sce->coeffs;
1340
    float * out = sce->ret;
1341
    float * saved = sce->saved;
1342
    const float * swindow      = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
1343
    const float * lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
1344
    const float * swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
1345
    float * buf = ac->buf_mdct;
1346
    float * temp = ac->temp;
1347
    int i;
1348

    
1349
    // imdct
1350
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1351
        if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE)
1352
            av_log(ac->avccontext, AV_LOG_WARNING,
1353
                   "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
1354
                   "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
1355
        for (i = 0; i < 1024; i += 128)
1356
            ff_imdct_half(&ac->mdct_small, buf + i, in + i);
1357
    } else
1358
        ff_imdct_half(&ac->mdct, buf, in);
1359

    
1360
    /* window overlapping
1361
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1362
     * and long to short transitions are considered to be short to short
1363
     * transitions. This leaves just two cases (long to long and short to short)
1364
     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
1365
     */
1366
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
1367
        (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
1368
        ac->dsp.vector_fmul_window(    out,               saved,            buf,         lwindow_prev, ac->add_bias, 512);
1369
    } else {
1370
        for (i = 0; i < 448; i++)
1371
            out[i] = saved[i] + ac->add_bias;
1372

    
1373
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1374
            ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, ac->add_bias, 64);
1375
            ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      ac->add_bias, 64);
1376
            ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      ac->add_bias, 64);
1377
            ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      ac->add_bias, 64);
1378
            ac->dsp.vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      ac->add_bias, 64);
1379
            memcpy(                    out + 448 + 4*128, temp, 64 * sizeof(float));
1380
        } else {
1381
            ac->dsp.vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, ac->add_bias, 64);
1382
            for (i = 576; i < 1024; i++)
1383
                out[i] = buf[i-512] + ac->add_bias;
1384
        }
1385
    }
1386

    
1387
    // buffer update
1388
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1389
        for (i = 0; i < 64; i++)
1390
            saved[i] = temp[64 + i] - ac->add_bias;
1391
        ac->dsp.vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 0, 64);
1392
        ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64);
1393
        ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64);
1394
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1395
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
1396
        memcpy(                    saved,       buf + 512,        448 * sizeof(float));
1397
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1398
    } else { // LONG_STOP or ONLY_LONG
1399
        memcpy(                    saved,       buf + 512,        512 * sizeof(float));
1400
    }
1401
}
1402

    
1403
/**
1404
 * Apply dependent channel coupling (applied before IMDCT).
1405
 *
1406
 * @param   index   index into coupling gain array
1407
 */
1408
static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) {
1409
    IndividualChannelStream * ics = &cce->ch[0].ics;
1410
    const uint16_t * offsets = ics->swb_offset;
1411
    float * dest = target->coeffs;
1412
    const float * src = cce->ch[0].coeffs;
1413
    int g, i, group, k, idx = 0;
1414
    if(ac->m4ac.object_type == AOT_AAC_LTP) {
1415
        av_log(ac->avccontext, AV_LOG_ERROR,
1416
               "Dependent coupling is not supported together with LTP\n");
1417
        return;
1418
    }
1419
    for (g = 0; g < ics->num_window_groups; g++) {
1420
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1421
            if (cce->ch[0].band_type[idx] != ZERO_BT) {
1422
                for (group = 0; group < ics->group_len[g]; group++) {
1423
                    for (k = offsets[i]; k < offsets[i+1]; k++) {
1424
                        // XXX dsputil-ize
1425
                        dest[group*128+k] += cce->coup.gain[index][idx] * src[group*128+k];
1426
                    }
1427
                }
1428
            }
1429
        }
1430
        dest += ics->group_len[g]*128;
1431
        src  += ics->group_len[g]*128;
1432
    }
1433
}
1434

    
1435
/**
1436
 * Apply independent channel coupling (applied after IMDCT).
1437
 *
1438
 * @param   index   index into coupling gain array
1439
 */
1440
static void apply_independent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) {
1441
    int i;
1442
    for (i = 0; i < 1024; i++)
1443
        target->ret[i] += cce->coup.gain[index][0] * (cce->ch[0].ret[i] - ac->add_bias);
1444
}
1445

    
1446
/**
1447
 * channel coupling transformation interface
1448
 *
1449
 * @param   index   index into coupling gain array
1450
 * @param   apply_coupling_method   pointer to (in)dependent coupling function
1451
 */
1452
static void apply_channel_coupling(AACContext * ac, ChannelElement * cc,
1453
        enum RawDataBlockType type, int elem_id, enum CouplingPoint coupling_point,
1454
        void (*apply_coupling_method)(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index))
1455
{
1456
    int i, c;
1457

    
1458
    for (i = 0; i < MAX_ELEM_ID; i++) {
1459
        ChannelElement *cce = ac->che[TYPE_CCE][i];
1460
        int index = 0;
1461

    
1462
        if (cce && cce->coup.coupling_point == coupling_point) {
1463
            ChannelCoupling * coup = &cce->coup;
1464

    
1465
            for (c = 0; c <= coup->num_coupled; c++) {
1466
                if (coup->type[c] == type && coup->id_select[c] == elem_id) {
1467
                    if (coup->ch_select[c] != 1) {
1468
                        apply_coupling_method(ac, &cc->ch[0], cce, index);
1469
                        if (coup->ch_select[c] != 0)
1470
                            index++;
1471
                    }
1472
                    if (coup->ch_select[c] != 2)
1473
                        apply_coupling_method(ac, &cc->ch[1], cce, index++);
1474
                } else
1475
                    index += 1 + (coup->ch_select[c] == 3);
1476
            }
1477
        }
1478
    }
1479
}
1480

    
1481
/**
1482
 * Convert spectral data to float samples, applying all supported tools as appropriate.
1483
 */
1484
static void spectral_to_sample(AACContext * ac) {
1485
    int i, type;
1486
    for(type = 3; type >= 0; type--) {
1487
        for (i = 0; i < MAX_ELEM_ID; i++) {
1488
            ChannelElement *che = ac->che[type][i];
1489
            if(che) {
1490
                if(type <= TYPE_CPE)
1491
                    apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling);
1492
                if(che->ch[0].tns.present)
1493
                    apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
1494
                if(che->ch[1].tns.present)
1495
                    apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
1496
                if(type <= TYPE_CPE)
1497
                    apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
1498
                if(type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT)
1499
                    imdct_and_windowing(ac, &che->ch[0]);
1500
                if(type == TYPE_CPE)
1501
                    imdct_and_windowing(ac, &che->ch[1]);
1502
                if(type <= TYPE_CCE)
1503
                    apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling);
1504
            }
1505
        }
1506
    }
1507
}
1508

    
1509
static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data_size, const uint8_t * buf, int buf_size) {
1510
    AACContext * ac = avccontext->priv_data;
1511
    GetBitContext gb;
1512
    enum RawDataBlockType elem_type;
1513
    int err, elem_id, data_size_tmp;
1514

    
1515
    init_get_bits(&gb, buf, buf_size*8);
1516

    
1517
    // parse
1518
    while ((elem_type = get_bits(&gb, 3)) != TYPE_END) {
1519
        elem_id = get_bits(&gb, 4);
1520
        err = -1;
1521

    
1522
        if(elem_type == TYPE_SCE && elem_id == 1 &&
1523
                !ac->che[TYPE_SCE][elem_id] && ac->che[TYPE_LFE][0]) {
1524
            /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
1525
               instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have
1526
               encountered such a stream, transfer the LFE[0] element to SCE[1] */
1527
            ac->che[TYPE_SCE][elem_id] = ac->che[TYPE_LFE][0];
1528
            ac->che[TYPE_LFE][0] = NULL;
1529
        }
1530
        if(elem_type < TYPE_DSE) {
1531
            if(!ac->che[elem_type][elem_id])
1532
                return -1;
1533
            if(elem_type != TYPE_CCE)
1534
                ac->che[elem_type][elem_id]->coup.coupling_point = 4;
1535
        }
1536

    
1537
        switch (elem_type) {
1538

    
1539
        case TYPE_SCE:
1540
            err = decode_ics(ac, &ac->che[TYPE_SCE][elem_id]->ch[0], &gb, 0, 0);
1541
            break;
1542

    
1543
        case TYPE_CPE:
1544
            err = decode_cpe(ac, &gb, elem_id);
1545
            break;
1546

    
1547
        case TYPE_CCE:
1548
            err = decode_cce(ac, &gb, ac->che[TYPE_CCE][elem_id]);
1549
            break;
1550

    
1551
        case TYPE_LFE:
1552
            err = decode_ics(ac, &ac->che[TYPE_LFE][elem_id]->ch[0], &gb, 0, 0);
1553
            break;
1554

    
1555
        case TYPE_DSE:
1556
            skip_data_stream_element(&gb);
1557
            err = 0;
1558
            break;
1559

    
1560
        case TYPE_PCE:
1561
        {
1562
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
1563
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
1564
            if((err = decode_pce(ac, new_che_pos, &gb)))
1565
                break;
1566
            err = output_configure(ac, ac->che_pos, new_che_pos);
1567
            break;
1568
        }
1569

    
1570
        case TYPE_FIL:
1571
            if (elem_id == 15)
1572
                elem_id += get_bits(&gb, 8) - 1;
1573
            while (elem_id > 0)
1574
                elem_id -= decode_extension_payload(ac, &gb, elem_id);
1575
            err = 0; /* FIXME */
1576
            break;
1577

    
1578
        default:
1579
            err = -1; /* should not happen, but keeps compiler happy */
1580
            break;
1581
        }
1582

    
1583
        if(err)
1584
            return err;
1585
    }
1586

    
1587
    spectral_to_sample(ac);
1588

    
1589
    if (!ac->is_saved) {
1590
        ac->is_saved = 1;
1591
        *data_size = 0;
1592
        return buf_size;
1593
    }
1594

    
1595
    data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t);
1596
    if(*data_size < data_size_tmp) {
1597
        av_log(avccontext, AV_LOG_ERROR,
1598
               "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
1599
               *data_size, data_size_tmp);
1600
        return -1;
1601
    }
1602
    *data_size = data_size_tmp;
1603

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

    
1606
    return buf_size;
1607
}
1608

    
1609
static av_cold int aac_decode_close(AVCodecContext * avccontext) {
1610
    AACContext * ac = avccontext->priv_data;
1611
    int i, type;
1612

    
1613
    for (i = 0; i < MAX_ELEM_ID; i++) {
1614
        for(type = 0; type < 4; type++)
1615
            av_freep(&ac->che[type][i]);
1616
    }
1617

    
1618
    ff_mdct_end(&ac->mdct);
1619
    ff_mdct_end(&ac->mdct_small);
1620
    return 0 ;
1621
}
1622

    
1623
AVCodec aac_decoder = {
1624
    "aac",
1625
    CODEC_TYPE_AUDIO,
1626
    CODEC_ID_AAC,
1627
    sizeof(AACContext),
1628
    aac_decode_init,
1629
    NULL,
1630
    aac_decode_close,
1631
    aac_decode_frame,
1632
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
1633
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1634
};