Statistics
| Branch: | Revision:

ffmpeg / libavcodec / aac.c @ 848a5815

History | View | Annotate | Download (38.8 KB)

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

    
23
/**
24
 * @file 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
 * N                    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 "bitstream.h"
81
#include "dsputil.h"
82

    
83
#include "aac.h"
84
#include "aactab.h"
85
#include "aacdectab.h"
86
#include "mpeg4audio.h"
87

    
88
#include <assert.h>
89
#include <errno.h>
90
#include <math.h>
91
#include <string.h>
92

    
93
#ifndef CONFIG_HARDCODED_TABLES
94
    static float ff_aac_pow2sf_tab[316];
95
#endif /* CONFIG_HARDCODED_TABLES */
96

    
97
static VLC vlc_scalefactors;
98
static VLC vlc_spectral[11];
99

    
100

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

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

    
117
    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
118

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

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

    
144
    avctx->channels = channels;
145
    return 0;
146
}
147

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

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

    
174
    skip_bits(gb, 2);  // object_type
175

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

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

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

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

    
202
    skip_bits_long(gb, 4 * num_assoc_data);
203

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

    
206
    align_get_bits(gb);
207

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

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

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

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

    
255
    return 0;
256
}
257

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

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

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

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

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

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

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

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

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

    
334
    skip_bits_long(&gb, i);
335

    
336
    switch (ac->m4ac.object_type) {
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 av_cold int aac_decode_init(AVCodecContext * avccontext) {
361
    AACContext * ac = avccontext->priv_data;
362
    int i;
363

    
364
    ac->avccontext = avccontext;
365

    
366
    if (avccontext->extradata_size <= 0 ||
367
        decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size))
368
        return -1;
369

    
370
    avccontext->sample_fmt  = SAMPLE_FMT_S16;
371
    avccontext->sample_rate = ac->m4ac.sample_rate;
372
    avccontext->frame_size  = 1024;
373

    
374
    AAC_INIT_VLC_STATIC( 0, 144);
375
    AAC_INIT_VLC_STATIC( 1, 114);
376
    AAC_INIT_VLC_STATIC( 2, 188);
377
    AAC_INIT_VLC_STATIC( 3, 180);
378
    AAC_INIT_VLC_STATIC( 4, 172);
379
    AAC_INIT_VLC_STATIC( 5, 140);
380
    AAC_INIT_VLC_STATIC( 6, 168);
381
    AAC_INIT_VLC_STATIC( 7, 114);
382
    AAC_INIT_VLC_STATIC( 8, 262);
383
    AAC_INIT_VLC_STATIC( 9, 248);
384
    AAC_INIT_VLC_STATIC(10, 384);
385

    
386
    dsputil_init(&ac->dsp, avccontext);
387

    
388
    ac->random_state = 0x1f2e3d4c;
389

    
390
    // -1024 - Compensate wrong IMDCT method.
391
    // 32768 - Required to scale values to the correct range for the bias method
392
    //         for float to int16 conversion.
393

    
394
    if(ac->dsp.float_to_int16 == ff_float_to_int16_c) {
395
        ac->add_bias = 385.0f;
396
        ac->sf_scale = 1. / (-1024. * 32768.);
397
        ac->sf_offset = 0;
398
    } else {
399
        ac->add_bias = 0.0f;
400
        ac->sf_scale = 1. / -1024.;
401
        ac->sf_offset = 60;
402
    }
403

    
404
#ifndef CONFIG_HARDCODED_TABLES
405
    for (i = 0; i < 316; i++)
406
        ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.);
407
#endif /* CONFIG_HARDCODED_TABLES */
408

    
409
    INIT_VLC_STATIC(&vlc_scalefactors, 7, sizeof(ff_aac_scalefactor_code)/sizeof(ff_aac_scalefactor_code[0]),
410
        ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
411
        ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
412
        352);
413

    
414
    ff_mdct_init(&ac->mdct, 11, 1);
415
    ff_mdct_init(&ac->mdct_small, 8, 1);
416
    return 0;
417
}
418

    
419
/**
420
 * Skip data_stream_element; reference: table 4.10.
421
 */
422
static void skip_data_stream_element(GetBitContext * gb) {
423
    int byte_align = get_bits1(gb);
424
    int count = get_bits(gb, 8);
425
    if (count == 255)
426
        count += get_bits(gb, 8);
427
    if (byte_align)
428
        align_get_bits(gb);
429
    skip_bits_long(gb, 8 * count);
430
}
431

    
432
/**
433
 * Decode Individual Channel Stream info; reference: table 4.6.
434
 *
435
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
436
 */
437
static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb, int common_window) {
438
    if (get_bits1(gb)) {
439
        av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n");
440
        memset(ics, 0, sizeof(IndividualChannelStream));
441
        return -1;
442
    }
443
    ics->window_sequence[1] = ics->window_sequence[0];
444
    ics->window_sequence[0] = get_bits(gb, 2);
445
    ics->use_kb_window[1] = ics->use_kb_window[0];
446
    ics->use_kb_window[0] = get_bits1(gb);
447
    ics->num_window_groups = 1;
448
    ics->group_len[0] = 1;
449

    
450
        if (get_bits1(gb)) {
451
            av_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1);
452
            memset(ics, 0, sizeof(IndividualChannelStream));
453
            return -1;
454
        }
455
    }
456

    
457
    if(ics->max_sfb > ics->num_swb) {
458
        av_log(ac->avccontext, AV_LOG_ERROR,
459
            "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
460
            ics->max_sfb, ics->num_swb);
461
        memset(ics, 0, sizeof(IndividualChannelStream));
462
        return -1;
463
    }
464

    
465
    return 0;
466
}
467

    
468
/**
469
 * Decode band types (section_data payload); reference: table 4.46.
470
 *
471
 * @param   band_type           array of the used band type
472
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
473
 *
474
 * @return  Returns error status. 0 - OK, !0 - error
475
 */
476
static int decode_band_types(AACContext * ac, enum BandType band_type[120],
477
        int band_type_run_end[120], GetBitContext * gb, IndividualChannelStream * ics) {
478
    int g, idx = 0;
479
    const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
480
    for (g = 0; g < ics->num_window_groups; g++) {
481
        int k = 0;
482
        while (k < ics->max_sfb) {
483
            uint8_t sect_len = k;
484
            int sect_len_incr;
485
            int sect_band_type = get_bits(gb, 4);
486
            if (sect_band_type == 12) {
487
                av_log(ac->avccontext, AV_LOG_ERROR, "invalid band type\n");
488
                return -1;
489
            }
490
            while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits)-1)
491
                sect_len += sect_len_incr;
492
            sect_len += sect_len_incr;
493
            if (sect_len > ics->max_sfb) {
494
                av_log(ac->avccontext, AV_LOG_ERROR,
495
                    "Number of bands (%d) exceeds limit (%d).\n",
496
                    sect_len, ics->max_sfb);
497
                return -1;
498
            }
499
        }
500
    }
501
    return 0;
502
}
503

    
504
/**
505
 * Decode scalefactors; reference: table 4.47.
506
 *
507
 * @param   global_gain         first scalefactor value as scalefactors are differentially coded
508
 * @param   band_type           array of the used band type
509
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
510
 * @param   sf                  array of scalefactors or intensity stereo positions
511
 *
512
 * @return  Returns error status. 0 - OK, !0 - error
513
 */
514
static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * gb,
515
        unsigned int global_gain, IndividualChannelStream * ics,
516
        enum BandType band_type[120], int band_type_run_end[120]) {
517
    const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0);
518
    int g, i, idx = 0;
519
    int offset[3] = { global_gain, global_gain - 90, 100 };
520
    int noise_flag = 1;
521
    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
522
    for (g = 0; g < ics->num_window_groups; g++) {
523
        for (i = 0; i < ics->max_sfb;) {
524
            int run_end = band_type_run_end[idx];
525
            if (band_type[idx] == ZERO_BT) {
526
                for(; i < run_end; i++, idx++)
527
                    sf[idx] = 0.;
528
            }else if((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
529
                for(; i < run_end; i++, idx++) {
530
                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
531
                    if(offset[2] > 255U) {
532
                        av_log(ac->avccontext, AV_LOG_ERROR,
533
                            "%s (%d) out of range.\n", sf_str[2], offset[2]);
534
                        return -1;
535
                    }
536
                    sf[idx]  = ff_aac_pow2sf_tab[-offset[2] + 300];
537
                }
538
            }else if(band_type[idx] == NOISE_BT) {
539
                for(; i < run_end; i++, idx++) {
540
                    if(noise_flag-- > 0)
541
                        offset[1] += get_bits(gb, 9) - 256;
542
                    else
543
                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
544
                    if(offset[1] > 255U) {
545
                        av_log(ac->avccontext, AV_LOG_ERROR,
546
                            "%s (%d) out of range.\n", sf_str[1], offset[1]);
547
                        return -1;
548
                    }
549
                    sf[idx]  = -ff_aac_pow2sf_tab[ offset[1] + sf_offset];
550
                }
551
            }else {
552
                for(; i < run_end; i++, idx++) {
553
                    offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
554
                    if(offset[0] > 255U) {
555
                        av_log(ac->avccontext, AV_LOG_ERROR,
556
                            "%s (%d) out of range.\n", sf_str[0], offset[0]);
557
                        return -1;
558
                    }
559
                    sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset];
560
                }
561
            }
562
        }
563
    }
564
    return 0;
565
}
566

    
567
/**
568
 * Decode pulse data; reference: table 4.7.
569
 */
570
static void decode_pulses(Pulse * pulse, GetBitContext * gb, const uint16_t * swb_offset) {
571
    int i;
572
    pulse->num_pulse = get_bits(gb, 2) + 1;
573
    pulse->pos[0]    = get_bits(gb, 5) + swb_offset[get_bits(gb, 6)];
574
    pulse->amp[0]    = get_bits(gb, 4);
575
    for (i = 1; i < pulse->num_pulse; i++) {
576
        pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i-1];
577
        pulse->amp[i] = get_bits(gb, 4);
578
    }
579
}
580

    
581
/**
582
 * Decode Mid/Side data; reference: table 4.54.
583
 *
584
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
585
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
586
 *                      [3] reserved for scalable AAC
587
 */
588
static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb,
589
        int ms_present) {
590
    int idx;
591
    if (ms_present == 1) {
592
        for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
593
            cpe->ms_mask[idx] = get_bits1(gb);
594
    } else if (ms_present == 2) {
595
        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
596
    }
597
}
598

    
599
/**
600
 * Decode an individual_channel_stream payload; reference: table 4.44.
601
 *
602
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
603
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
604
 *
605
 * @return  Returns error status. 0 - OK, !0 - error
606
 */
607
static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext * gb, int common_window, int scale_flag) {
608
    Pulse pulse;
609
    TemporalNoiseShaping * tns = &sce->tns;
610
    IndividualChannelStream * ics = &sce->ics;
611
    float * out = sce->coeffs;
612
    int global_gain, pulse_present = 0;
613

    
614
    /* This assignment is to silence a GCC warning about the variable being used
615
     * uninitialized when in fact it always is.
616
     */
617
    pulse.num_pulse = 0;
618

    
619
    global_gain = get_bits(gb, 8);
620

    
621
    if (!common_window && !scale_flag) {
622
        if (decode_ics_info(ac, ics, gb, 0) < 0)
623
            return -1;
624
    }
625

    
626
    if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
627
        return -1;
628
    if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
629
        return -1;
630

    
631
    pulse_present = 0;
632
    if (!scale_flag) {
633
        if ((pulse_present = get_bits1(gb))) {
634
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
635
                av_log(ac->avccontext, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
636
                return -1;
637
            }
638
            decode_pulses(&pulse, gb, ics->swb_offset);
639
        }
640
        if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
641
            return -1;
642
        if (get_bits1(gb)) {
643
            av_log_missing_feature(ac->avccontext, "SSR", 1);
644
            return -1;
645
        }
646
    }
647

    
648
    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
649
        return -1;
650
    return 0;
651
}
652

    
653
/**
654
 * Decode a channel_pair_element; reference: table 4.4.
655
 *
656
 * @param   elem_id Identifies the instance of a syntax element.
657
 *
658
 * @return  Returns error status. 0 - OK, !0 - error
659
 */
660
static int decode_cpe(AACContext * ac, GetBitContext * gb, int elem_id) {
661
    int i, ret, common_window, ms_present = 0;
662
    ChannelElement * cpe;
663

    
664
    cpe = ac->che[TYPE_CPE][elem_id];
665
    common_window = get_bits1(gb);
666
    if (common_window) {
667
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
668
            return -1;
669
        i = cpe->ch[1].ics.use_kb_window[0];
670
        cpe->ch[1].ics = cpe->ch[0].ics;
671
        cpe->ch[1].ics.use_kb_window[1] = i;
672
        ms_present = get_bits(gb, 2);
673
        if(ms_present == 3) {
674
            av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
675
            return -1;
676
        } else if(ms_present)
677
            decode_mid_side_stereo(cpe, gb, ms_present);
678
    }
679
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
680
        return ret;
681
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
682
        return ret;
683

    
684
    if (common_window && ms_present)
685
        apply_mid_side_stereo(cpe);
686

    
687
    apply_intensity_stereo(cpe, ms_present);
688
    return 0;
689
}
690

    
691
    coup->coupling_point = 2*get_bits1(gb);
692
    coup->num_coupled = get_bits(gb, 3);
693
    for (c = 0; c <= coup->num_coupled; c++) {
694
        num_gain++;
695
        coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
696
        coup->id_select[c] = get_bits(gb, 4);
697
        if (coup->type[c] == TYPE_CPE) {
698
            coup->ch_select[c] = get_bits(gb, 2);
699
            if (coup->ch_select[c] == 3)
700
                num_gain++;
701
        } else
702
            coup->ch_select[c] = 1;
703
    }
704
    coup->coupling_point += get_bits1(gb);
705

    
706
    if (coup->coupling_point == 2) {
707
        av_log(ac->avccontext, AV_LOG_ERROR,
708
            "Independently switched CCE with 'invalid' domain signalled.\n");
709
        memset(coup, 0, sizeof(ChannelCoupling));
710
        return -1;
711
    }
712

    
713
    sign = get_bits(gb, 1);
714
    scale = pow(2., pow(2., get_bits(gb, 2) - 3));
715

    
716
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
717
        return ret;
718

    
719
    for (c = 0; c < num_gain; c++) {
720
        int cge = 1;
721
        int gain = 0;
722
        float gain_cache = 1.;
723
        if (c) {
724
            cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
725
            gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
726
            gain_cache = pow(scale, gain);
727
        }
728
        for (g = 0; g < sce->ics.num_window_groups; g++)
729
            for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++)
730
                if (sce->band_type[idx] != ZERO_BT) {
731
                    if (!cge) {
732
                        int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
733
                        if (t) {
734
                            int s = 1;
735
                            if (sign) {
736
                                s  -= 2 * (t & 0x1);
737
                                t >>= 1;
738
                            }
739
                            gain += t;
740
                            gain_cache = pow(scale, gain) * s;
741
                        }
742
                    }
743
                    coup->gain[c][idx] = gain_cache;
744
                }
745
    }
746
    return 0;
747
}
748

    
749
/**
750
 * Decode Spectral Band Replication extension data; reference: table 4.55.
751
 *
752
 * @param   crc flag indicating the presence of CRC checksum
753
 * @param   cnt length of TYPE_FIL syntactic element in bytes
754
 *
755
 * @return  Returns number of bytes consumed from the TYPE_FIL element.
756
 */
757
static int decode_sbr_extension(AACContext * ac, GetBitContext * gb, int crc, int cnt) {
758
    // TODO : sbr_extension implementation
759
    av_log_missing_feature(ac->avccontext, "SBR", 0);
760
    skip_bits_long(gb, 8*cnt - 4); // -4 due to reading extension type
761
    return cnt;
762
}
763

    
764
/**
765
 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
766
 *
767
 * @return  Returns number of bytes consumed.
768
 */
769
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitContext * gb) {
770
    int i;
771
    int num_excl_chan = 0;
772

    
773
    do {
774
        for (i = 0; i < 7; i++)
775
            che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
776
    } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
777

    
778
    return num_excl_chan / 7;
779
}
780

    
781
/**
782
 * Decode dynamic range information; reference: table 4.52.
783
 *
784
 * @param   cnt length of TYPE_FIL syntactic element in bytes
785
 *
786
 * @return  Returns number of bytes consumed.
787
 */
788
static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext * gb, int cnt) {
789
    int n = 1;
790
    int drc_num_bands = 1;
791
    int i;
792

    
793
    /* pce_tag_present? */
794
    if(get_bits1(gb)) {
795
        che_drc->pce_instance_tag  = get_bits(gb, 4);
796
        skip_bits(gb, 4); // tag_reserved_bits
797
        n++;
798
    }
799

    
800
    /* excluded_chns_present? */
801
    if(get_bits1(gb)) {
802
        n += decode_drc_channel_exclusions(che_drc, gb);
803
    }
804

    
805
    /* drc_bands_present? */
806
    if (get_bits1(gb)) {
807
        che_drc->band_incr            = get_bits(gb, 4);
808
        che_drc->interpolation_scheme = get_bits(gb, 4);
809
        n++;
810
        drc_num_bands += che_drc->band_incr;
811
        for (i = 0; i < drc_num_bands; i++) {
812
            che_drc->band_top[i] = get_bits(gb, 8);
813
            n++;
814
        }
815
    }
816

    
817
    /* prog_ref_level_present? */
818
    if (get_bits1(gb)) {
819
        che_drc->prog_ref_level = get_bits(gb, 7);
820
        skip_bits1(gb); // prog_ref_level_reserved_bits
821
        n++;
822
    }
823

    
824
    for (i = 0; i < drc_num_bands; i++) {
825
        che_drc->dyn_rng_sgn[i] = get_bits1(gb);
826
        che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
827
        n++;
828
    }
829

    
830
    return n;
831
}
832

    
833
/**
834
 * Decode extension data (incomplete); reference: table 4.51.
835
 *
836
 * @param   cnt length of TYPE_FIL syntactic element in bytes
837
 *
838
 * @return Returns number of bytes consumed
839
 */
840
static int decode_extension_payload(AACContext * ac, GetBitContext * gb, int cnt) {
841
    int crc_flag = 0;
842
    int res = cnt;
843
    switch (get_bits(gb, 4)) { // extension type
844
        case EXT_SBR_DATA_CRC:
845
            crc_flag++;
846
        case EXT_SBR_DATA:
847
            res = decode_sbr_extension(ac, gb, crc_flag, cnt);
848
            break;
849
        case EXT_DYNAMIC_RANGE:
850
            res = decode_dynamic_range(&ac->che_drc, gb, cnt);
851
            break;
852
        case EXT_FILL:
853
        case EXT_FILL_DATA:
854
        case EXT_DATA_ELEMENT:
855
        default:
856
            skip_bits_long(gb, 8*cnt - 4);
857
            break;
858
    };
859
    return res;
860
}
861

    
862
/**
863
 * Conduct IMDCT and windowing.
864
 */
865
static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) {
866
    IndividualChannelStream * ics = &sce->ics;
867
    float * in = sce->coeffs;
868
    float * out = sce->ret;
869
    float * saved = sce->saved;
870
    const float * lwindow      = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
871
    const float * swindow      = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
872
    const float * lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
873
    const float * swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
874
    float * buf = ac->buf_mdct;
875
    int i;
876

    
877
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
878
        if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE)
879
            av_log(ac->avccontext, AV_LOG_WARNING,
880
                   "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
881
                   "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
882
        for (i = 0; i < 2048; i += 256) {
883
            ff_imdct_calc(&ac->mdct_small, buf + i, in + i/2);
884
            ac->dsp.vector_fmul_reverse(ac->revers + i/2, buf + i + 128, swindow, 128);
885
        }
886
        for (i = 0; i < 448; i++)   out[i] = saved[i] + ac->add_bias;
887

    
888
        ac->dsp.vector_fmul_add_add(out + 448 + 0*128, buf + 0*128, swindow_prev, saved + 448 ,       ac->add_bias, 128, 1);
889
        ac->dsp.vector_fmul_add_add(out + 448 + 1*128, buf + 2*128, swindow,      ac->revers + 0*128, ac->add_bias, 128, 1);
890
        ac->dsp.vector_fmul_add_add(out + 448 + 2*128, buf + 4*128, swindow,      ac->revers + 1*128, ac->add_bias, 128, 1);
891
        ac->dsp.vector_fmul_add_add(out + 448 + 3*128, buf + 6*128, swindow,      ac->revers + 2*128, ac->add_bias, 128, 1);
892
        ac->dsp.vector_fmul_add_add(out + 448 + 4*128, buf + 8*128, swindow,      ac->revers + 3*128, ac->add_bias,  64, 1);
893

    
894
#if 0
895
        vector_fmul_add_add_add(&ac->dsp, out + 448 + 1*128, buf + 2*128, swindow,      saved + 448 + 1*128, ac->revers + 0*128, ac->add_bias, 128);
896
        vector_fmul_add_add_add(&ac->dsp, out + 448 + 2*128, buf + 4*128, swindow,      saved + 448 + 2*128, ac->revers + 1*128, ac->add_bias, 128);
897
        vector_fmul_add_add_add(&ac->dsp, out + 448 + 3*128, buf + 6*128, swindow,      saved + 448 + 3*128, ac->revers + 2*128, ac->add_bias, 128);
898
        vector_fmul_add_add_add(&ac->dsp, out + 448 + 4*128, buf + 8*128, swindow,      saved + 448 + 4*128, ac->revers + 3*128, ac->add_bias, 64);
899
#endif
900

    
901
        ac->dsp.vector_fmul_add_add(saved,       buf + 1024 + 64,    swindow + 64, ac->revers + 3*128+64,  0, 64, 1);
902
        ac->dsp.vector_fmul_add_add(saved + 64,  buf + 1024 + 2*128, swindow,      ac->revers + 4*128,     0, 128, 1);
903
        ac->dsp.vector_fmul_add_add(saved + 192, buf + 1024 + 4*128, swindow,      ac->revers + 5*128,     0, 128, 1);
904
        ac->dsp.vector_fmul_add_add(saved + 320, buf + 1024 + 6*128, swindow,      ac->revers + 6*128,     0, 128, 1);
905
        memcpy(                     saved + 448, ac->revers + 7*128, 128 * sizeof(float));
906
        memset(                     saved + 576, 0,                  448 * sizeof(float));
907
    } else {
908
        ff_imdct_calc(&ac->mdct, buf, in);
909
        if (ics->window_sequence[0] == LONG_STOP_SEQUENCE) {
910
            for (i = 0;   i < 448;  i++)   out[i] =          saved[i] + ac->add_bias;
911
            ac->dsp.vector_fmul_add_add(out + 448, buf + 448, swindow_prev, saved + 448, ac->add_bias, 128, 1);
912
            for (i = 576; i < 1024; i++)   out[i] = buf[i] + saved[i] + ac->add_bias;
913
        } else {
914
            ac->dsp.vector_fmul_add_add(out, buf, lwindow_prev, saved, ac->add_bias, 1024, 1);
915
        }
916
        if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
917
            memcpy(saved, buf + 1024, 448 * sizeof(float));
918
            ac->dsp.vector_fmul_reverse(saved + 448, buf + 1024 + 448, swindow, 128);
919
            memset(saved + 576, 0, 448 * sizeof(float));
920
        } else {
921
            ac->dsp.vector_fmul_reverse(saved, buf + 1024, lwindow, 1024);
922
        }
923
    }
924
}
925

    
926
/**
927
 * Apply dependent channel coupling (applied before IMDCT).
928
 *
929
 * @param   index   index into coupling gain array
930
 */
931
static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * sce, ChannelElement * cc, int index) {
932
    IndividualChannelStream * ics = &cc->ch[0].ics;
933
    const uint16_t * offsets = ics->swb_offset;
934
    float * dest = sce->coeffs;
935
    const float * src = cc->ch[0].coeffs;
936
    int g, i, group, k, idx = 0;
937
    if(ac->m4ac.object_type == AOT_AAC_LTP) {
938
        av_log(ac->avccontext, AV_LOG_ERROR,
939
               "Dependent coupling is not supported together with LTP\n");
940
        return;
941
    }
942
    for (g = 0; g < ics->num_window_groups; g++) {
943
        for (i = 0; i < ics->max_sfb; i++, idx++) {
944
            if (cc->ch[0].band_type[idx] != ZERO_BT) {
945
                for (group = 0; group < ics->group_len[g]; group++) {
946
                    for (k = offsets[i]; k < offsets[i+1]; k++) {
947
                        // XXX dsputil-ize
948
                        dest[group*128+k] += cc->coup.gain[index][idx] * src[group*128+k];
949
                    }
950
                }
951
            }
952
        }
953
        dest += ics->group_len[g]*128;
954
        src  += ics->group_len[g]*128;
955
    }
956
}
957

    
958
/**
959
 * Apply independent channel coupling (applied after IMDCT).
960
 *
961
 * @param   index   index into coupling gain array
962
 */
963
static void apply_independent_coupling(AACContext * ac, SingleChannelElement * sce, ChannelElement * cc, int index) {
964
    int i;
965
    for (i = 0; i < 1024; i++)
966
        sce->ret[i] += cc->coup.gain[index][0] * (cc->ch[0].ret[i] - ac->add_bias);
967
}
968

    
969
            }
970
        }
971
    }
972
}
973

    
974
static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data_size, const uint8_t * buf, int buf_size) {
975
    AACContext * ac = avccontext->priv_data;
976
    GetBitContext gb;
977
    enum RawDataBlockType elem_type;
978
    int err, elem_id, data_size_tmp;
979

    
980
    init_get_bits(&gb, buf, buf_size*8);
981

    
982
    // parse
983
    while ((elem_type = get_bits(&gb, 3)) != TYPE_END) {
984
        elem_id = get_bits(&gb, 4);
985
        err = -1;
986

    
987
        if(elem_type == TYPE_SCE && elem_id == 1 &&
988
                !ac->che[TYPE_SCE][elem_id] && ac->che[TYPE_LFE][0]) {
989
            /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
990
               instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have
991
               encountered such a stream, transfer the LFE[0] element to SCE[1] */
992
            ac->che[TYPE_SCE][elem_id] = ac->che[TYPE_LFE][0];
993
            ac->che[TYPE_LFE][0] = NULL;
994
        }
995
        if(elem_type && elem_type < TYPE_DSE) {
996
            if(!ac->che[elem_type][elem_id])
997
                return -1;
998
            if(elem_type != TYPE_CCE)
999
                ac->che[elem_type][elem_id]->coup.coupling_point = 4;
1000
        }
1001

    
1002
        switch (elem_type) {
1003

    
1004
        case TYPE_SCE:
1005
            err = decode_ics(ac, &ac->che[TYPE_SCE][elem_id]->ch[0], &gb, 0, 0);
1006
            break;
1007

    
1008
        case TYPE_CPE:
1009
            err = decode_cpe(ac, &gb, elem_id);
1010
            break;
1011

    
1012
        case TYPE_CCE:
1013
            err = decode_cce(ac, &gb, ac->che[TYPE_SCE][elem_id]);
1014
            break;
1015

    
1016
        case TYPE_LFE:
1017
            err = decode_ics(ac, &ac->che[TYPE_LFE][elem_id]->ch[0], &gb, 0, 0);
1018
            break;
1019

    
1020
        case TYPE_DSE:
1021
            skip_data_stream_element(&gb);
1022
            err = 0;
1023
            break;
1024

    
1025
        case TYPE_PCE:
1026
        {
1027
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
1028
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
1029
            if((err = decode_pce(ac, new_che_pos, &gb)))
1030
                break;
1031
            err = output_configure(ac, ac->che_pos, new_che_pos);
1032
            break;
1033
        }
1034

    
1035
        case TYPE_FIL:
1036
            if (elem_id == 15)
1037
                elem_id += get_bits(&gb, 8) - 1;
1038
            while (elem_id > 0)
1039
                elem_id -= decode_extension_payload(ac, &gb, elem_id);
1040
            err = 0; /* FIXME */
1041
            break;
1042

    
1043
        default:
1044
            err = -1; /* should not happen, but keeps compiler happy */
1045
            break;
1046
        }
1047

    
1048
        if(err)
1049
            return err;
1050
    }
1051

    
1052
    spectral_to_sample(ac);
1053

    
1054
    if (!ac->is_saved) {
1055
        ac->is_saved = 1;
1056
        *data_size = 0;
1057
        return buf_size;
1058
    }
1059

    
1060
    data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t);
1061
    if(*data_size < data_size_tmp) {
1062
        av_log(avccontext, AV_LOG_ERROR,
1063
               "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
1064
               *data_size, data_size_tmp);
1065
        return -1;
1066
    }
1067
    *data_size = data_size_tmp;
1068

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

    
1071
    return buf_size;
1072
}
1073

    
1074
static av_cold int aac_decode_close(AVCodecContext * avccontext) {
1075
    AACContext * ac = avccontext->priv_data;
1076
    int i, type;
1077

    
1078
    for (i = 0; i < MAX_ELEM_ID; i++) {
1079
        for(type = 0; type < 4; type++)
1080
            av_freep(&ac->che[type][i]);
1081
    }
1082

    
1083
    ff_mdct_end(&ac->mdct);
1084
    ff_mdct_end(&ac->mdct_small);
1085
    return 0 ;
1086
}
1087

    
1088
AVCodec aac_decoder = {
1089
    "aac",
1090
    CODEC_TYPE_AUDIO,
1091
    CODEC_ID_AAC,
1092
    sizeof(AACContext),
1093
    aac_decode_init,
1094
    NULL,
1095
    aac_decode_close,
1096
    aac_decode_frame,
1097
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
1098
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1099
};