Statistics
| Branch: | Revision:

ffmpeg / libavcodec / aacdec.c @ 19ed4b86

History | View | Annotate | Download (75.1 KB)

1 71e9a1b8 Robert Swain
/*
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 ba87f080 Diego Biurrun
 * @file
25 71e9a1b8 Robert Swain
 * 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 7633a041 Alex Converse
 * Y                    frequency domain prediction
45 71e9a1b8 Robert Swain
 * 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 ed492b61 Alex Converse
 * Y                    Spectral Band Replication
66 71e9a1b8 Robert Swain
 * 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 a2063901 Alex Converse
 * Y                    Parametric Stereo
71 71e9a1b8 Robert Swain
 * 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 dbbec0c2 Stefano Sabatini
#include "internal.h"
81 9106a698 Stefano Sabatini
#include "get_bits.h"
82 71e9a1b8 Robert Swain
#include "dsputil.h"
83 1429224b Måns Rullgård
#include "fft.h"
84 1be0fc29 Vitor Sessak
#include "lpc.h"
85 71e9a1b8 Robert Swain
86
#include "aac.h"
87
#include "aactab.h"
88 cc0591da Robert Swain
#include "aacdectab.h"
89 c26bce10 Reimar Döffinger
#include "cbrt_tablegen.h"
90 ed492b61 Alex Converse
#include "sbr.h"
91
#include "aacsbr.h"
92 71e9a1b8 Robert Swain
#include "mpeg4audio.h"
93 158b3912 Robert Swain
#include "aac_parser.h"
94 71e9a1b8 Robert Swain
95
#include <assert.h>
96
#include <errno.h>
97
#include <math.h>
98
#include <string.h>
99
100 798339fb Måns Rullgård
#if ARCH_ARM
101
#   include "arm/aac.h"
102
#endif
103
104 577d383b Diego Biurrun
union float754 {
105
    float f;
106
    uint32_t i;
107
};
108 4a39ccb4 Alex Converse
109 71e9a1b8 Robert Swain
static VLC vlc_scalefactors;
110
static VLC vlc_spectral[11];
111
112 8d637124 Alex Converse
static const char overread_err[] = "Input buffer exhausted before END element found\n";
113
114 577d383b Diego Biurrun
static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
115
{
116 7caee063 Alex Converse
    /* Some buggy encoders appear to set all elem_ids to zero and rely on
117
    channels always occurring in the same order. This is expressly forbidden
118
    by the spec but we will try to work around it.
119
    */
120
    int err_printed = 0;
121
    while (ac->tags_seen_this_frame[type][elem_id] && elem_id < MAX_ELEM_ID) {
122
        if (ac->output_configured < OC_LOCKED && !err_printed) {
123 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_WARNING, "Duplicate channel tag found, attempting to remap.\n");
124 7caee063 Alex Converse
            err_printed = 1;
125
        }
126
        elem_id++;
127
    }
128
    if (elem_id == MAX_ELEM_ID)
129
        return NULL;
130
    ac->tags_seen_this_frame[type][elem_id] = 1;
131
132 bb5c0988 Alex Converse
    if (ac->tag_che_map[type][elem_id]) {
133
        return ac->tag_che_map[type][elem_id];
134
    }
135
    if (ac->tags_mapped >= tags_per_config[ac->m4ac.chan_config]) {
136
        return NULL;
137
    }
138
    switch (ac->m4ac.chan_config) {
139 577d383b Diego Biurrun
    case 7:
140
        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
141
            ac->tags_mapped++;
142
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
143
        }
144
    case 6:
145
        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
146 5d55bb9f Cyril Russo
           instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have
147
           encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */
148 577d383b Diego Biurrun
        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
149
            ac->tags_mapped++;
150
            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
151
        }
152
    case 5:
153
        if (ac->tags_mapped == 2 && type == TYPE_CPE) {
154
            ac->tags_mapped++;
155
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
156
        }
157
    case 4:
158
        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {
159
            ac->tags_mapped++;
160
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
161
        }
162
    case 3:
163
    case 2:
164
        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {
165
            ac->tags_mapped++;
166
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
167
        } else if (ac->m4ac.chan_config == 2) {
168 bb5c0988 Alex Converse
            return NULL;
169 577d383b Diego Biurrun
        }
170
    case 1:
171
        if (!ac->tags_mapped && type == TYPE_SCE) {
172
            ac->tags_mapped++;
173
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
174
        }
175
    default:
176
        return NULL;
177 bb5c0988 Alex Converse
    }
178
}
179
180 9cc04edf Robert Swain
/**
181 754ff9a7 Robert Swain
 * Check for the channel element in the current channel position configuration.
182
 * If it exists, make sure the appropriate element is allocated and map the
183
 * channel order to match the internal FFmpeg channel layout.
184
 *
185
 * @param   che_pos current channel position configuration
186
 * @param   type channel element type
187
 * @param   id channel element id
188
 * @param   channels count of the number of channels in the configuration
189
 *
190
 * @return  Returns error status. 0 - OK, !0 - error
191
 */
192 89584458 Alex Converse
static av_cold int che_configure(AACContext *ac,
193 754ff9a7 Robert Swain
                         enum ChannelPosition che_pos[4][MAX_ELEM_ID],
194
                         int type, int id,
195
                         int *channels)
196
{
197
    if (che_pos[type][id]) {
198
        if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
199
            return AVERROR(ENOMEM);
200 ed492b61 Alex Converse
        ff_aac_sbr_ctx_init(&ac->che[type][id]->sbr);
201 754ff9a7 Robert Swain
        if (type != TYPE_CCE) {
202
            ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;
203 a2063901 Alex Converse
            if (type == TYPE_CPE ||
204
                (type == TYPE_SCE && ac->m4ac.ps == 1)) {
205 754ff9a7 Robert Swain
                ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;
206
            }
207
        }
208 ed492b61 Alex Converse
    } else {
209
        if (ac->che[type][id])
210
            ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr);
211 754ff9a7 Robert Swain
        av_freep(&ac->che[type][id]);
212 ed492b61 Alex Converse
    }
213 754ff9a7 Robert Swain
    return 0;
214
}
215
216
/**
217 62a57fae Robert Swain
 * Configure output channel order based on the current program configuration element.
218
 *
219
 * @param   che_pos current channel position configuration
220
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
221
 *
222
 * @return  Returns error status. 0 - OK, !0 - error
223
 */
224 ff98c17c Alex Converse
static av_cold int output_configure(AACContext *ac,
225 577d383b Diego Biurrun
                            enum ChannelPosition che_pos[4][MAX_ELEM_ID],
226
                            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
227 981b8fd7 Alex Converse
                            int channel_config, enum OCStatus oc_type)
228 577d383b Diego Biurrun
{
229 dd8871a6 Alex Converse
    AVCodecContext *avctx = ac->avctx;
230 754ff9a7 Robert Swain
    int i, type, channels = 0, ret;
231 62a57fae Robert Swain
232 a2063901 Alex Converse
    if (new_che_pos != che_pos)
233 62a57fae Robert Swain
    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
234
235 e22da6b6 Robert Swain
    if (channel_config) {
236
        for (i = 0; i < tags_per_config[channel_config]; i++) {
237 754ff9a7 Robert Swain
            if ((ret = che_configure(ac, che_pos,
238
                                     aac_channel_layout_map[channel_config - 1][i][0],
239
                                     aac_channel_layout_map[channel_config - 1][i][1],
240
                                     &channels)))
241
                return ret;
242 e22da6b6 Robert Swain
        }
243
244
        memset(ac->tag_che_map, 0,       4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
245
        ac->tags_mapped = 0;
246
247
        avctx->channel_layout = aac_channel_layout[channel_config - 1];
248
    } else {
249 2309923c Robert Swain
        /* Allocate or free elements depending on if they are in the
250
         * current program configuration.
251
         *
252
         * Set up default 1:1 output mapping.
253
         *
254
         * For a 5.1 stream the output order will be:
255
         *    [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
256
         */
257
258
        for (i = 0; i < MAX_ELEM_ID; i++) {
259
            for (type = 0; type < 4; type++) {
260 754ff9a7 Robert Swain
                if ((ret = che_configure(ac, che_pos, type, i, &channels)))
261
                    return ret;
262 2309923c Robert Swain
            }
263 62a57fae Robert Swain
        }
264
265 bb5c0988 Alex Converse
        memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
266 577d383b Diego Biurrun
        ac->tags_mapped = 4 * MAX_ELEM_ID;
267 e22da6b6 Robert Swain
268
        avctx->channel_layout = 0;
269 bb5c0988 Alex Converse
    }
270
271 62a57fae Robert Swain
    avctx->channels = channels;
272 bb5c0988 Alex Converse
273 981b8fd7 Alex Converse
    ac->output_configured = oc_type;
274 6308765c Alex Converse
275 62a57fae Robert Swain
    return 0;
276
}
277
278
/**
279 9cc04edf Robert Swain
 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
280
 *
281
 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
282
 * @param sce_map mono (Single Channel Element) map
283
 * @param type speaker type/position for these channels
284
 */
285
static void decode_channel_map(enum ChannelPosition *cpe_map,
286 577d383b Diego Biurrun
                               enum ChannelPosition *sce_map,
287
                               enum ChannelPosition type,
288
                               GetBitContext *gb, int n)
289
{
290
    while (n--) {
291 9cc04edf Robert Swain
        enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map
292
        map[get_bits(gb, 4)] = type;
293
    }
294
}
295
296
/**
297
 * Decode program configuration element; reference: table 4.2.
298
 *
299
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
300
 *
301
 * @return  Returns error status. 0 - OK, !0 - error
302
 */
303 577d383b Diego Biurrun
static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
304
                      GetBitContext *gb)
305
{
306 99665a21 Alex Converse
    int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
307 8d637124 Alex Converse
    int comment_len;
308 9cc04edf Robert Swain
309
    skip_bits(gb, 2);  // object_type
310
311 99665a21 Alex Converse
    sampling_index = get_bits(gb, 4);
312 401a9950 Alex Converse
    if (ac->m4ac.sampling_index != sampling_index)
313 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
314 401a9950 Alex Converse
315 71e9a1b8 Robert Swain
    num_front       = get_bits(gb, 4);
316
    num_side        = get_bits(gb, 4);
317
    num_back        = get_bits(gb, 4);
318
    num_lfe         = get_bits(gb, 2);
319
    num_assoc_data  = get_bits(gb, 3);
320
    num_cc          = get_bits(gb, 4);
321
322 cc0591da Robert Swain
    if (get_bits1(gb))
323
        skip_bits(gb, 4); // mono_mixdown_tag
324
    if (get_bits1(gb))
325
        skip_bits(gb, 4); // stereo_mixdown_tag
326 71e9a1b8 Robert Swain
327 cc0591da Robert Swain
    if (get_bits1(gb))
328
        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
329 71e9a1b8 Robert Swain
330 cc0591da Robert Swain
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
331
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE,  gb, num_side );
332
    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK,  gb, num_back );
333
    decode_channel_map(NULL,                  new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE,   gb, num_lfe  );
334 71e9a1b8 Robert Swain
335
    skip_bits_long(gb, 4 * num_assoc_data);
336
337 cc0591da Robert Swain
    decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC,    gb, num_cc   );
338 71e9a1b8 Robert Swain
339
    align_get_bits(gb);
340
341
    /* comment field, first byte is length */
342 8d637124 Alex Converse
    comment_len = get_bits(gb, 8) * 8;
343
    if (get_bits_left(gb) < comment_len) {
344 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
345 8d637124 Alex Converse
        return -1;
346
    }
347
    skip_bits_long(gb, comment_len);
348 cc0591da Robert Swain
    return 0;
349
}
350 71e9a1b8 Robert Swain
351 9cc04edf Robert Swain
/**
352
 * Set up channel positions based on a default channel configuration
353
 * as specified in table 1.17.
354
 *
355
 * @param   new_che_pos New channel position configuration - we only do something if it differs from the current one.
356
 *
357
 * @return  Returns error status. 0 - OK, !0 - error
358
 */
359 ff98c17c Alex Converse
static av_cold int set_default_channel_config(AACContext *ac,
360 577d383b Diego Biurrun
                                      enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
361
                                      int channel_config)
362 9cc04edf Robert Swain
{
363 577d383b Diego Biurrun
    if (channel_config < 1 || channel_config > 7) {
364 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
365 9cc04edf Robert Swain
               channel_config);
366
        return -1;
367
    }
368
369
    /* default channel configurations:
370
     *
371
     * 1ch : front center (mono)
372
     * 2ch : L + R (stereo)
373
     * 3ch : front center + L + R
374
     * 4ch : front center + L + R + back center
375
     * 5ch : front center + L + R + back stereo
376
     * 6ch : front center + L + R + back stereo + LFE
377
     * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
378
     */
379
380 577d383b Diego Biurrun
    if (channel_config != 2)
381 9cc04edf Robert Swain
        new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono)
382 577d383b Diego Biurrun
    if (channel_config > 1)
383 9cc04edf Robert Swain
        new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo)
384 577d383b Diego Biurrun
    if (channel_config == 4)
385 9cc04edf Robert Swain
        new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK;  // back center
386 577d383b Diego Biurrun
    if (channel_config > 4)
387 9cc04edf Robert Swain
        new_che_pos[TYPE_CPE][(channel_config == 7) + 1]
388 577d383b Diego Biurrun
        = AAC_CHANNEL_BACK;  // back stereo
389
    if (channel_config > 5)
390 9cc04edf Robert Swain
        new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE;   // LFE
391 577d383b Diego Biurrun
    if (channel_config == 7)
392 9cc04edf Robert Swain
        new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right
393
394
    return 0;
395
}
396
397 62a57fae Robert Swain
/**
398
 * Decode GA "General Audio" specific configuration; reference: table 4.1.
399
 *
400
 * @return  Returns error status. 0 - OK, !0 - error
401
 */
402 577d383b Diego Biurrun
static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb,
403
                                     int channel_config)
404
{
405 62a57fae Robert Swain
    enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
406
    int extension_flag, ret;
407
408 577d383b Diego Biurrun
    if (get_bits1(gb)) { // frameLengthFlag
409 dd8871a6 Alex Converse
        av_log_missing_feature(ac->avctx, "960/120 MDCT window is", 1);
410 9cc04edf Robert Swain
        return -1;
411
    }
412
413
    if (get_bits1(gb))       // dependsOnCoreCoder
414
        skip_bits(gb, 14);   // coreCoderDelay
415
    extension_flag = get_bits1(gb);
416
417 577d383b Diego Biurrun
    if (ac->m4ac.object_type == AOT_AAC_SCALABLE ||
418
        ac->m4ac.object_type == AOT_ER_AAC_SCALABLE)
419 9cc04edf Robert Swain
        skip_bits(gb, 3);     // layerNr
420
421
    memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
422
    if (channel_config == 0) {
423
        skip_bits(gb, 4);  // element_instance_tag
424 577d383b Diego Biurrun
        if ((ret = decode_pce(ac, new_che_pos, gb)))
425 9cc04edf Robert Swain
            return ret;
426
    } else {
427 577d383b Diego Biurrun
        if ((ret = set_default_channel_config(ac, new_che_pos, channel_config)))
428 9cc04edf Robert Swain
            return ret;
429
    }
430 4fab6627 Alex Converse
    if ((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
431 9cc04edf Robert Swain
        return ret;
432
433
    if (extension_flag) {
434
        switch (ac->m4ac.object_type) {
435 577d383b Diego Biurrun
        case AOT_ER_BSAC:
436
            skip_bits(gb, 5);    // numOfSubFrame
437
            skip_bits(gb, 11);   // layer_length
438
            break;
439
        case AOT_ER_AAC_LC:
440
        case AOT_ER_AAC_LTP:
441
        case AOT_ER_AAC_SCALABLE:
442
        case AOT_ER_AAC_LD:
443
            skip_bits(gb, 3);  /* aacSectionDataResilienceFlag
444 9cc04edf Robert Swain
                                    * aacScalefactorDataResilienceFlag
445
                                    * aacSpectralDataResilienceFlag
446
                                    */
447 577d383b Diego Biurrun
            break;
448 9cc04edf Robert Swain
        }
449
        skip_bits1(gb);    // extensionFlag3 (TBD in version 3)
450
    }
451
    return 0;
452
}
453
454
/**
455
 * Decode audio specific configuration; reference: table 1.13.
456
 *
457
 * @param   data        pointer to AVCodecContext extradata
458
 * @param   data_size   size of AVCCodecContext extradata
459
 *
460
 * @return  Returns error status. 0 - OK, !0 - error
461
 */
462 577d383b Diego Biurrun
static int decode_audio_specific_config(AACContext *ac, void *data,
463
                                        int data_size)
464
{
465 9cc04edf Robert Swain
    GetBitContext gb;
466
    int i;
467
468
    init_get_bits(&gb, data, data_size * 8);
469
470 577d383b Diego Biurrun
    if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0)
471 9cc04edf Robert Swain
        return -1;
472 577d383b Diego Biurrun
    if (ac->m4ac.sampling_index > 12) {
473 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
474 9cc04edf Robert Swain
        return -1;
475
    }
476 a2063901 Alex Converse
    if (ac->m4ac.sbr == 1 && ac->m4ac.ps == -1)
477
        ac->m4ac.ps = 1;
478 9cc04edf Robert Swain
479
    skip_bits_long(&gb, i);
480
481
    switch (ac->m4ac.object_type) {
482 7633a041 Alex Converse
    case AOT_AAC_MAIN:
483 9cc04edf Robert Swain
    case AOT_AAC_LC:
484
        if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config))
485
            return -1;
486
        break;
487
    default:
488 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
489 9cc04edf Robert Swain
               ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type);
490
        return -1;
491
    }
492
    return 0;
493
}
494
495 62a57fae Robert Swain
/**
496
 * linear congruential pseudorandom number generator
497
 *
498
 * @param   previous_val    pointer to the current state of the generator
499
 *
500
 * @return  Returns a 32-bit pseudorandom integer
501
 */
502 577d383b Diego Biurrun
static av_always_inline int lcg_random(int previous_val)
503
{
504 62a57fae Robert Swain
    return previous_val * 1664525 + 1013904223;
505
}
506
507 ab2a3028 Alex Converse
static av_always_inline void reset_predict_state(PredictorState *ps)
508 577d383b Diego Biurrun
{
509
    ps->r0   = 0.0f;
510
    ps->r1   = 0.0f;
511 7633a041 Alex Converse
    ps->cor0 = 0.0f;
512
    ps->cor1 = 0.0f;
513
    ps->var0 = 1.0f;
514
    ps->var1 = 1.0f;
515
}
516
517 577d383b Diego Biurrun
static void reset_all_predictors(PredictorState *ps)
518
{
519 7633a041 Alex Converse
    int i;
520
    for (i = 0; i < MAX_PREDICTORS; i++)
521
        reset_predict_state(&ps[i]);
522
}
523
524 577d383b Diego Biurrun
static void reset_predictor_group(PredictorState *ps, int group_num)
525
{
526 7633a041 Alex Converse
    int i;
527 577d383b Diego Biurrun
    for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
528 7633a041 Alex Converse
        reset_predict_state(&ps[i]);
529
}
530
531 8e5998f0 Alex Converse
#define AAC_INIT_VLC_STATIC(num, size) \
532
    INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num], \
533
         ff_aac_spectral_bits[num], sizeof( ff_aac_spectral_bits[num][0]), sizeof( ff_aac_spectral_bits[num][0]), \
534
        ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), sizeof(ff_aac_spectral_codes[num][0]), \
535
        size);
536
537 dd8871a6 Alex Converse
static av_cold int aac_decode_init(AVCodecContext *avctx)
538 577d383b Diego Biurrun
{
539 dd8871a6 Alex Converse
    AACContext *ac = avctx->priv_data;
540 71e9a1b8 Robert Swain
    int i;
541
542 dd8871a6 Alex Converse
    ac->avctx = avctx;
543
    ac->m4ac.sample_rate = avctx->sample_rate;
544 71e9a1b8 Robert Swain
545 dd8871a6 Alex Converse
    if (avctx->extradata_size > 0) {
546
        if (decode_audio_specific_config(ac, avctx->extradata, avctx->extradata_size))
547 158b3912 Robert Swain
            return -1;
548
    }
549 cc0591da Robert Swain
550 dd8871a6 Alex Converse
    avctx->sample_fmt = SAMPLE_FMT_S16;
551 71e9a1b8 Robert Swain
552 2ef21b91 Måns Rullgård
    AAC_INIT_VLC_STATIC( 0, 304);
553
    AAC_INIT_VLC_STATIC( 1, 270);
554
    AAC_INIT_VLC_STATIC( 2, 550);
555
    AAC_INIT_VLC_STATIC( 3, 300);
556
    AAC_INIT_VLC_STATIC( 4, 328);
557
    AAC_INIT_VLC_STATIC( 5, 294);
558
    AAC_INIT_VLC_STATIC( 6, 306);
559
    AAC_INIT_VLC_STATIC( 7, 268);
560
    AAC_INIT_VLC_STATIC( 8, 510);
561
    AAC_INIT_VLC_STATIC( 9, 366);
562
    AAC_INIT_VLC_STATIC(10, 462);
563 71e9a1b8 Robert Swain
564 ed492b61 Alex Converse
    ff_aac_sbr_init();
565
566 dd8871a6 Alex Converse
    dsputil_init(&ac->dsp, avctx);
567 71e9a1b8 Robert Swain
568 9cc04edf Robert Swain
    ac->random_state = 0x1f2e3d4c;
569
570 71e9a1b8 Robert Swain
    // -1024 - Compensate wrong IMDCT method.
571
    // 32768 - Required to scale values to the correct range for the bias method
572
    //         for float to int16 conversion.
573
574 144fec83 David Conrad
    if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
575 577d383b Diego Biurrun
        ac->add_bias  = 385.0f;
576
        ac->sf_scale  = 1. / (-1024. * 32768.);
577 71e9a1b8 Robert Swain
        ac->sf_offset = 0;
578
    } else {
579 577d383b Diego Biurrun
        ac->add_bias  = 0.0f;
580
        ac->sf_scale  = 1. / -1024.;
581 71e9a1b8 Robert Swain
        ac->sf_offset = 60;
582
    }
583
584 b250f9c6 Aurelien Jacobs
#if !CONFIG_HARDCODED_TABLES
585 d0ee5021 Alex Converse
    for (i = 0; i < 428; i++)
586 577d383b Diego Biurrun
        ff_aac_pow2sf_tab[i] = pow(2, (i - 200) / 4.);
587 71e9a1b8 Robert Swain
#endif /* CONFIG_HARDCODED_TABLES */
588
589 37d3e066 Aurelien Jacobs
    INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
590 577d383b Diego Biurrun
                    ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
591
                    ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
592
                    352);
593 71e9a1b8 Robert Swain
594 7d485f16 Siarhei Siamashka
    ff_mdct_init(&ac->mdct, 11, 1, 1.0);
595
    ff_mdct_init(&ac->mdct_small, 8, 1, 1.0);
596 9ffd5c1c Robert Swain
    // window initialization
597
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
598
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
599 14b86070 Reimar Döffinger
    ff_init_ff_sine_windows(10);
600
    ff_init_ff_sine_windows( 7);
601 9ffd5c1c Robert Swain
602 c26bce10 Reimar Döffinger
    cbrt_tableinit();
603 dc0d86fa Måns Rullgård
604 71e9a1b8 Robert Swain
    return 0;
605
}
606
607 9cc04edf Robert Swain
/**
608
 * Skip data_stream_element; reference: table 4.10.
609
 */
610 8d637124 Alex Converse
static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
611 577d383b Diego Biurrun
{
612 71e9a1b8 Robert Swain
    int byte_align = get_bits1(gb);
613
    int count = get_bits(gb, 8);
614
    if (count == 255)
615
        count += get_bits(gb, 8);
616
    if (byte_align)
617
        align_get_bits(gb);
618 8d637124 Alex Converse
619
    if (get_bits_left(gb) < 8 * count) {
620 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
621 8d637124 Alex Converse
        return -1;
622
    }
623 71e9a1b8 Robert Swain
    skip_bits_long(gb, 8 * count);
624 8d637124 Alex Converse
    return 0;
625 71e9a1b8 Robert Swain
}
626
627 577d383b Diego Biurrun
static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
628
                             GetBitContext *gb)
629
{
630 7633a041 Alex Converse
    int sfb;
631
    if (get_bits1(gb)) {
632
        ics->predictor_reset_group = get_bits(gb, 5);
633
        if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
634 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
635 7633a041 Alex Converse
            return -1;
636
        }
637
    }
638
    for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->m4ac.sampling_index]); sfb++) {
639
        ics->prediction_used[sfb] = get_bits1(gb);
640
    }
641
    return 0;
642
}
643
644 71e9a1b8 Robert Swain
/**
645 9cc04edf Robert Swain
 * Decode Individual Channel Stream info; reference: table 4.6.
646
 *
647
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
648
 */
649 577d383b Diego Biurrun
static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
650
                           GetBitContext *gb, int common_window)
651
{
652 9cc04edf Robert Swain
    if (get_bits1(gb)) {
653 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
654 9cc04edf Robert Swain
        memset(ics, 0, sizeof(IndividualChannelStream));
655
        return -1;
656
    }
657
    ics->window_sequence[1] = ics->window_sequence[0];
658
    ics->window_sequence[0] = get_bits(gb, 2);
659 577d383b Diego Biurrun
    ics->use_kb_window[1]   = ics->use_kb_window[0];
660
    ics->use_kb_window[0]   = get_bits1(gb);
661
    ics->num_window_groups  = 1;
662
    ics->group_len[0]       = 1;
663 9ffd5c1c Robert Swain
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
664
        int i;
665
        ics->max_sfb = get_bits(gb, 4);
666
        for (i = 0; i < 7; i++) {
667
            if (get_bits1(gb)) {
668 577d383b Diego Biurrun
                ics->group_len[ics->num_window_groups - 1]++;
669 9ffd5c1c Robert Swain
            } else {
670
                ics->num_window_groups++;
671 577d383b Diego Biurrun
                ics->group_len[ics->num_window_groups - 1] = 1;
672 9ffd5c1c Robert Swain
            }
673
        }
674 577d383b Diego Biurrun
        ics->num_windows       = 8;
675
        ics->swb_offset        =    ff_swb_offset_128[ac->m4ac.sampling_index];
676
        ics->num_swb           =   ff_aac_num_swb_128[ac->m4ac.sampling_index];
677
        ics->tns_max_bands     = ff_tns_max_bands_128[ac->m4ac.sampling_index];
678 7633a041 Alex Converse
        ics->predictor_present = 0;
679 9ffd5c1c Robert Swain
    } else {
680 577d383b Diego Biurrun
        ics->max_sfb               = get_bits(gb, 6);
681
        ics->num_windows           = 1;
682
        ics->swb_offset            =    ff_swb_offset_1024[ac->m4ac.sampling_index];
683
        ics->num_swb               =   ff_aac_num_swb_1024[ac->m4ac.sampling_index];
684
        ics->tns_max_bands         = ff_tns_max_bands_1024[ac->m4ac.sampling_index];
685
        ics->predictor_present     = get_bits1(gb);
686 7633a041 Alex Converse
        ics->predictor_reset_group = 0;
687
        if (ics->predictor_present) {
688
            if (ac->m4ac.object_type == AOT_AAC_MAIN) {
689
                if (decode_prediction(ac, ics, gb)) {
690
                    memset(ics, 0, sizeof(IndividualChannelStream));
691
                    return -1;
692
                }
693
            } else if (ac->m4ac.object_type == AOT_AAC_LC) {
694 dd8871a6 Alex Converse
                av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
695 7633a041 Alex Converse
                memset(ics, 0, sizeof(IndividualChannelStream));
696
                return -1;
697
            } else {
698 dd8871a6 Alex Converse
                av_log_missing_feature(ac->avctx, "Predictor bit set but LTP is", 1);
699 8f5aaa6d Robert Swain
                memset(ics, 0, sizeof(IndividualChannelStream));
700
                return -1;
701 7633a041 Alex Converse
            }
702 62a57fae Robert Swain
        }
703
    }
704
705 577d383b Diego Biurrun
    if (ics->max_sfb > ics->num_swb) {
706 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR,
707 577d383b Diego Biurrun
               "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
708
               ics->max_sfb, ics->num_swb);
709 62a57fae Robert Swain
        memset(ics, 0, sizeof(IndividualChannelStream));
710
        return -1;
711
    }
712
713 9cc04edf Robert Swain
    return 0;
714
}
715
716
/**
717
 * Decode band types (section_data payload); reference: table 4.46.
718
 *
719
 * @param   band_type           array of the used band type
720
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
721
 *
722
 * @return  Returns error status. 0 - OK, !0 - error
723
 */
724 577d383b Diego Biurrun
static int decode_band_types(AACContext *ac, enum BandType band_type[120],
725
                             int band_type_run_end[120], GetBitContext *gb,
726
                             IndividualChannelStream *ics)
727
{
728 cc0591da Robert Swain
    int g, idx = 0;
729
    const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
730
    for (g = 0; g < ics->num_window_groups; g++) {
731
        int k = 0;
732
        while (k < ics->max_sfb) {
733 01d19fbc Alex Converse
            uint8_t sect_end = k;
734 cc0591da Robert Swain
            int sect_len_incr;
735
            int sect_band_type = get_bits(gb, 4);
736
            if (sect_band_type == 12) {
737 dd8871a6 Alex Converse
                av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
738 cc0591da Robert Swain
                return -1;
739
            }
740 577d383b Diego Biurrun
            while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1)
741 01d19fbc Alex Converse
                sect_end += sect_len_incr;
742
            sect_end += sect_len_incr;
743 c4a90caa Alex Converse
            if (get_bits_left(gb) < 0) {
744 dd8871a6 Alex Converse
                av_log(ac->avctx, AV_LOG_ERROR, overread_err);
745 c4a90caa Alex Converse
                return -1;
746
            }
747 01d19fbc Alex Converse
            if (sect_end > ics->max_sfb) {
748 dd8871a6 Alex Converse
                av_log(ac->avctx, AV_LOG_ERROR,
749 577d383b Diego Biurrun
                       "Number of bands (%d) exceeds limit (%d).\n",
750 01d19fbc Alex Converse
                       sect_end, ics->max_sfb);
751 cc0591da Robert Swain
                return -1;
752
            }
753 01d19fbc Alex Converse
            for (; k < sect_end; k++) {
754 9ffd5c1c Robert Swain
                band_type        [idx]   = sect_band_type;
755 01d19fbc Alex Converse
                band_type_run_end[idx++] = sect_end;
756 9ffd5c1c Robert Swain
            }
757 9cc04edf Robert Swain
        }
758
    }
759
    return 0;
760
}
761 cc0591da Robert Swain
762 9cc04edf Robert Swain
/**
763
 * Decode scalefactors; reference: table 4.47.
764 cc0591da Robert Swain
 *
765
 * @param   global_gain         first scalefactor value as scalefactors are differentially coded
766
 * @param   band_type           array of the used band type
767
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
768
 * @param   sf                  array of scalefactors or intensity stereo positions
769
 *
770
 * @return  Returns error status. 0 - OK, !0 - error
771
 */
772 577d383b Diego Biurrun
static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
773
                               unsigned int global_gain,
774
                               IndividualChannelStream *ics,
775
                               enum BandType band_type[120],
776
                               int band_type_run_end[120])
777
{
778 cc0591da Robert Swain
    const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0);
779
    int g, i, idx = 0;
780
    int offset[3] = { global_gain, global_gain - 90, 100 };
781
    int noise_flag = 1;
782
    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
783
    for (g = 0; g < ics->num_window_groups; g++) {
784
        for (i = 0; i < ics->max_sfb;) {
785
            int run_end = band_type_run_end[idx];
786
            if (band_type[idx] == ZERO_BT) {
787 577d383b Diego Biurrun
                for (; i < run_end; i++, idx++)
788 cc0591da Robert Swain
                    sf[idx] = 0.;
789 577d383b Diego Biurrun
            } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
790
                for (; i < run_end; i++, idx++) {
791 cc0591da Robert Swain
                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
792 577d383b Diego Biurrun
                    if (offset[2] > 255U) {
793 dd8871a6 Alex Converse
                        av_log(ac->avctx, AV_LOG_ERROR,
794 577d383b Diego Biurrun
                               "%s (%d) out of range.\n", sf_str[2], offset[2]);
795 cc0591da Robert Swain
                        return -1;
796
                    }
797 577d383b Diego Biurrun
                    sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300];
798 cc0591da Robert Swain
                }
799 577d383b Diego Biurrun
            } else if (band_type[idx] == NOISE_BT) {
800
                for (; i < run_end; i++, idx++) {
801
                    if (noise_flag-- > 0)
802 cc0591da Robert Swain
                        offset[1] += get_bits(gb, 9) - 256;
803
                    else
804
                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
805 577d383b Diego Biurrun
                    if (offset[1] > 255U) {
806 dd8871a6 Alex Converse
                        av_log(ac->avctx, AV_LOG_ERROR,
807 577d383b Diego Biurrun
                               "%s (%d) out of range.\n", sf_str[1], offset[1]);
808 cc0591da Robert Swain
                        return -1;
809
                    }
810 577d383b Diego Biurrun
                    sf[idx] = -ff_aac_pow2sf_tab[offset[1] + sf_offset + 100];
811 cc0591da Robert Swain
                }
812 577d383b Diego Biurrun
            } else {
813
                for (; i < run_end; i++, idx++) {
814 cc0591da Robert Swain
                    offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
815 577d383b Diego Biurrun
                    if (offset[0] > 255U) {
816 dd8871a6 Alex Converse
                        av_log(ac->avctx, AV_LOG_ERROR,
817 577d383b Diego Biurrun
                               "%s (%d) out of range.\n", sf_str[0], offset[0]);
818 cc0591da Robert Swain
                        return -1;
819
                    }
820
                    sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset];
821
                }
822
            }
823
        }
824
    }
825
    return 0;
826
}
827
828
/**
829
 * Decode pulse data; reference: table 4.7.
830
 */
831 577d383b Diego Biurrun
static int decode_pulses(Pulse *pulse, GetBitContext *gb,
832
                         const uint16_t *swb_offset, int num_swb)
833
{
834 aac0eda4 Alex Converse
    int i, pulse_swb;
835 cc0591da Robert Swain
    pulse->num_pulse = get_bits(gb, 2) + 1;
836 aac0eda4 Alex Converse
    pulse_swb        = get_bits(gb, 6);
837
    if (pulse_swb >= num_swb)
838
        return -1;
839
    pulse->pos[0]    = swb_offset[pulse_swb];
840 408992ba Robert Swain
    pulse->pos[0]   += get_bits(gb, 5);
841 aac0eda4 Alex Converse
    if (pulse->pos[0] > 1023)
842
        return -1;
843 848a5815 Robert Swain
    pulse->amp[0]    = get_bits(gb, 4);
844
    for (i = 1; i < pulse->num_pulse; i++) {
845 577d383b Diego Biurrun
        pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
846 aac0eda4 Alex Converse
        if (pulse->pos[i] > 1023)
847
            return -1;
848 848a5815 Robert Swain
        pulse->amp[i] = get_bits(gb, 4);
849 cc0591da Robert Swain
    }
850 aac0eda4 Alex Converse
    return 0;
851 cc0591da Robert Swain
}
852
853
/**
854 1dece0d2 Robert Swain
 * Decode Temporal Noise Shaping data; reference: table 4.48.
855
 *
856
 * @return  Returns error status. 0 - OK, !0 - error
857
 */
858 577d383b Diego Biurrun
static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
859
                      GetBitContext *gb, const IndividualChannelStream *ics)
860
{
861 1dece0d2 Robert Swain
    int w, filt, i, coef_len, coef_res, coef_compress;
862
    const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
863
    const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
864
    for (w = 0; w < ics->num_windows; w++) {
865 fbd91d7c Robert Swain
        if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
866 1dece0d2 Robert Swain
            coef_res = get_bits1(gb);
867
868 65b20b24 Robert Swain
            for (filt = 0; filt < tns->n_filt[w]; filt++) {
869
                int tmp2_idx;
870 577d383b Diego Biurrun
                tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
871 65b20b24 Robert Swain
872 577d383b Diego Biurrun
                if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
873 dd8871a6 Alex Converse
                    av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
874 65b20b24 Robert Swain
                           tns->order[w][filt], tns_max_order);
875
                    tns->order[w][filt] = 0;
876
                    return -1;
877
                }
878 51673647 Alex Converse
                if (tns->order[w][filt]) {
879 35445d29 Robert Swain
                    tns->direction[w][filt] = get_bits1(gb);
880
                    coef_compress = get_bits1(gb);
881
                    coef_len = coef_res + 3 - coef_compress;
882 577d383b Diego Biurrun
                    tmp2_idx = 2 * coef_compress + coef_res;
883 1dece0d2 Robert Swain
884 35445d29 Robert Swain
                    for (i = 0; i < tns->order[w][filt]; i++)
885
                        tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
886 51673647 Alex Converse
                }
887 65b20b24 Robert Swain
            }
888 fbd91d7c Robert Swain
        }
889 1dece0d2 Robert Swain
    }
890
    return 0;
891
}
892
893
/**
894 9cc04edf Robert Swain
 * Decode Mid/Side data; reference: table 4.54.
895
 *
896
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
897
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
898
 *                      [3] reserved for scalable AAC
899
 */
900 577d383b Diego Biurrun
static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
901
                                   int ms_present)
902
{
903 62a57fae Robert Swain
    int idx;
904
    if (ms_present == 1) {
905
        for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
906
            cpe->ms_mask[idx] = get_bits1(gb);
907
    } else if (ms_present == 2) {
908
        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
909
    }
910
}
911 9cc04edf Robert Swain
912 798339fb Måns Rullgård
#ifndef VMUL2
913 c816d3d0 Måns Rullgård
static inline float *VMUL2(float *dst, const float *v, unsigned idx,
914
                           const float *scale)
915
{
916
    float s = *scale;
917
    *dst++ = v[idx    & 15] * s;
918
    *dst++ = v[idx>>4 & 15] * s;
919
    return dst;
920
}
921 798339fb Måns Rullgård
#endif
922 c816d3d0 Måns Rullgård
923 798339fb Måns Rullgård
#ifndef VMUL4
924 c816d3d0 Måns Rullgård
static inline float *VMUL4(float *dst, const float *v, unsigned idx,
925
                           const float *scale)
926
{
927
    float s = *scale;
928
    *dst++ = v[idx    & 3] * s;
929
    *dst++ = v[idx>>2 & 3] * s;
930
    *dst++ = v[idx>>4 & 3] * s;
931
    *dst++ = v[idx>>6 & 3] * s;
932
    return dst;
933
}
934 798339fb Måns Rullgård
#endif
935 c816d3d0 Måns Rullgård
936 798339fb Måns Rullgård
#ifndef VMUL2S
937 c816d3d0 Måns Rullgård
static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
938
                            unsigned sign, const float *scale)
939
{
940
    union float754 s0, s1;
941
942
    s0.f = s1.f = *scale;
943
    s0.i ^= sign >> 1 << 31;
944
    s1.i ^= sign      << 31;
945
946
    *dst++ = v[idx    & 15] * s0.f;
947
    *dst++ = v[idx>>4 & 15] * s1.f;
948
949
    return dst;
950
}
951 798339fb Måns Rullgård
#endif
952 c816d3d0 Måns Rullgård
953 798339fb Måns Rullgård
#ifndef VMUL4S
954 c816d3d0 Måns Rullgård
static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
955
                            unsigned sign, const float *scale)
956
{
957
    unsigned nz = idx >> 12;
958
    union float754 s = { .f = *scale };
959
    union float754 t;
960
961
    t.i = s.i ^ (sign & 1<<31);
962
    *dst++ = v[idx    & 3] * t.f;
963
964
    sign <<= nz & 1; nz >>= 1;
965
    t.i = s.i ^ (sign & 1<<31);
966
    *dst++ = v[idx>>2 & 3] * t.f;
967
968
    sign <<= nz & 1; nz >>= 1;
969
    t.i = s.i ^ (sign & 1<<31);
970
    *dst++ = v[idx>>4 & 3] * t.f;
971
972
    sign <<= nz & 1; nz >>= 1;
973
    t.i = s.i ^ (sign & 1<<31);
974
    *dst++ = v[idx>>6 & 3] * t.f;
975
976
    return dst;
977
}
978 798339fb Måns Rullgård
#endif
979 c816d3d0 Måns Rullgård
980 9cc04edf Robert Swain
/**
981 9ffd5c1c Robert Swain
 * Decode spectral data; reference: table 4.50.
982
 * Dequantize and scale spectral data; reference: 4.6.3.3.
983
 *
984
 * @param   coef            array of dequantized, scaled spectral data
985
 * @param   sf              array of scalefactors or intensity stereo positions
986
 * @param   pulse_present   set if pulses are present
987
 * @param   pulse           pointer to pulse data struct
988
 * @param   band_type       array of the used band type
989
 *
990
 * @return  Returns error status. 0 - OK, !0 - error
991
 */
992 577d383b Diego Biurrun
static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024],
993 3963a17d Måns Rullgård
                                       GetBitContext *gb, const float sf[120],
994 577d383b Diego Biurrun
                                       int pulse_present, const Pulse *pulse,
995
                                       const IndividualChannelStream *ics,
996
                                       enum BandType band_type[120])
997
{
998 9ffd5c1c Robert Swain
    int i, k, g, idx = 0;
999 577d383b Diego Biurrun
    const int c = 1024 / ics->num_windows;
1000
    const uint16_t *offsets = ics->swb_offset;
1001 9ffd5c1c Robert Swain
    float *coef_base = coef;
1002 c816d3d0 Måns Rullgård
    int err_idx;
1003 9ffd5c1c Robert Swain
1004
    for (g = 0; g < ics->num_windows; g++)
1005 577d383b Diego Biurrun
        memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb]));
1006 9ffd5c1c Robert Swain
1007
    for (g = 0; g < ics->num_window_groups; g++) {
1008 05f9d8fc Måns Rullgård
        unsigned g_len = ics->group_len[g];
1009
1010 9ffd5c1c Robert Swain
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1011 05f9d8fc Måns Rullgård
            const unsigned cbt_m1 = band_type[idx] - 1;
1012
            float *cfo = coef + offsets[i];
1013
            int off_len = offsets[i + 1] - offsets[i];
1014 9ffd5c1c Robert Swain
            int group;
1015 05f9d8fc Måns Rullgård
1016
            if (cbt_m1 >= INTENSITY_BT2 - 1) {
1017
                for (group = 0; group < g_len; group++, cfo+=128) {
1018
                    memset(cfo, 0, off_len * sizeof(float));
1019 9ffd5c1c Robert Swain
                }
1020 05f9d8fc Måns Rullgård
            } else if (cbt_m1 == NOISE_BT - 1) {
1021
                for (group = 0; group < g_len; group++, cfo+=128) {
1022 d0ee5021 Alex Converse
                    float scale;
1023 b418a6ca Måns Rullgård
                    float band_energy;
1024 42d3fbb3 Måns Rullgård
1025 05f9d8fc Måns Rullgård
                    for (k = 0; k < off_len; k++) {
1026 9ffd5c1c Robert Swain
                        ac->random_state  = lcg_random(ac->random_state);
1027 05f9d8fc Måns Rullgård
                        cfo[k] = ac->random_state;
1028 d0ee5021 Alex Converse
                    }
1029 42d3fbb3 Måns Rullgård
1030 05f9d8fc Måns Rullgård
                    band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len);
1031 d0ee5021 Alex Converse
                    scale = sf[idx] / sqrtf(band_energy);
1032 05f9d8fc Måns Rullgård
                    ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len);
1033 9ffd5c1c Robert Swain
                }
1034 577d383b Diego Biurrun
            } else {
1035 05f9d8fc Måns Rullgård
                const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1036
                const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
1037
                VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1038
                const int cb_size = ff_aac_spectral_sizes[cbt_m1];
1039 d356a53f Måns Rullgård
                OPEN_READER(re, gb);
1040 c816d3d0 Måns Rullgård
1041 95dff4ac Måns Rullgård
                switch (cbt_m1 >> 1) {
1042
                case 0:
1043
                    for (group = 0; group < g_len; group++, cfo+=128) {
1044
                        float *cf = cfo;
1045
                        int len = off_len;
1046 42d3fbb3 Måns Rullgård
1047 c816d3d0 Måns Rullgård
                        do {
1048 d356a53f Måns Rullgård
                            int code;
1049 c816d3d0 Måns Rullgård
                            unsigned cb_idx;
1050
1051 d356a53f Måns Rullgård
                            UPDATE_CACHE(re, gb);
1052
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1053
1054
                            if (code >= cb_size) {
1055
                                err_idx = code;
1056 c816d3d0 Måns Rullgård
                                goto err_cb_overflow;
1057
                            }
1058
1059 d356a53f Måns Rullgård
                            cb_idx = cb_vector_idx[code];
1060 c816d3d0 Måns Rullgård
                            cf = VMUL4(cf, vq, cb_idx, sf + idx);
1061
                        } while (len -= 4);
1062 95dff4ac Måns Rullgård
                    }
1063
                    break;
1064
1065
                case 1:
1066
                    for (group = 0; group < g_len; group++, cfo+=128) {
1067
                        float *cf = cfo;
1068
                        int len = off_len;
1069
1070 c816d3d0 Måns Rullgård
                        do {
1071 d356a53f Måns Rullgård
                            int code;
1072 c816d3d0 Måns Rullgård
                            unsigned nnz;
1073
                            unsigned cb_idx;
1074
                            uint32_t bits;
1075
1076 d356a53f Måns Rullgård
                            UPDATE_CACHE(re, gb);
1077
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1078
1079
                            if (code >= cb_size) {
1080
                                err_idx = code;
1081 c816d3d0 Måns Rullgård
                                goto err_cb_overflow;
1082
                            }
1083
1084 d356a53f Måns Rullgård
#if MIN_CACHE_BITS < 20
1085
                            UPDATE_CACHE(re, gb);
1086
#endif
1087
                            cb_idx = cb_vector_idx[code];
1088 c816d3d0 Måns Rullgård
                            nnz = cb_idx >> 8 & 15;
1089 d356a53f Måns Rullgård
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1090
                            LAST_SKIP_BITS(re, gb, nnz);
1091 c816d3d0 Måns Rullgård
                            cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1092
                        } while (len -= 4);
1093 95dff4ac Måns Rullgård
                    }
1094
                    break;
1095
1096
                case 2:
1097
                    for (group = 0; group < g_len; group++, cfo+=128) {
1098
                        float *cf = cfo;
1099
                        int len = off_len;
1100
1101 c816d3d0 Måns Rullgård
                        do {
1102 d356a53f Måns Rullgård
                            int code;
1103 c816d3d0 Måns Rullgård
                            unsigned cb_idx;
1104
1105 d356a53f Måns Rullgård
                            UPDATE_CACHE(re, gb);
1106
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1107
1108
                            if (code >= cb_size) {
1109
                                err_idx = code;
1110 c816d3d0 Måns Rullgård
                                goto err_cb_overflow;
1111 c0893c3a Alex Converse
                            }
1112 c816d3d0 Måns Rullgård
1113 d356a53f Måns Rullgård
                            cb_idx = cb_vector_idx[code];
1114 c816d3d0 Måns Rullgård
                            cf = VMUL2(cf, vq, cb_idx, sf + idx);
1115
                        } while (len -= 2);
1116 95dff4ac Måns Rullgård
                    }
1117
                    break;
1118
1119
                case 3:
1120
                case 4:
1121
                    for (group = 0; group < g_len; group++, cfo+=128) {
1122
                        float *cf = cfo;
1123
                        int len = off_len;
1124
1125 c816d3d0 Måns Rullgård
                        do {
1126 d356a53f Måns Rullgård
                            int code;
1127 c816d3d0 Måns Rullgård
                            unsigned nnz;
1128
                            unsigned cb_idx;
1129
                            unsigned sign;
1130
1131 d356a53f Måns Rullgård
                            UPDATE_CACHE(re, gb);
1132
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1133
1134
                            if (code >= cb_size) {
1135
                                err_idx = code;
1136 c816d3d0 Måns Rullgård
                                goto err_cb_overflow;
1137
                            }
1138
1139 d356a53f Måns Rullgård
                            cb_idx = cb_vector_idx[code];
1140 c816d3d0 Måns Rullgård
                            nnz = cb_idx >> 8 & 15;
1141 d356a53f Måns Rullgård
                            sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12);
1142
                            LAST_SKIP_BITS(re, gb, nnz);
1143 c816d3d0 Måns Rullgård
                            cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1144
                        } while (len -= 2);
1145 95dff4ac Måns Rullgård
                    }
1146
                    break;
1147
1148
                default:
1149
                    for (group = 0; group < g_len; group++, cfo+=128) {
1150
                        float *cf = cfo;
1151
                        uint32_t *icf = (uint32_t *) cf;
1152
                        int len = off_len;
1153
1154 05f9d8fc Måns Rullgård
                        do {
1155 d356a53f Måns Rullgård
                            int code;
1156 c816d3d0 Måns Rullgård
                            unsigned nzt, nnz;
1157
                            unsigned cb_idx;
1158
                            uint32_t bits;
1159
                            int j;
1160
1161 d356a53f Måns Rullgård
                            UPDATE_CACHE(re, gb);
1162
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1163
1164
                            if (!code) {
1165 05f9d8fc Måns Rullgård
                                *icf++ = 0;
1166
                                *icf++ = 0;
1167 c816d3d0 Måns Rullgård
                                continue;
1168
                            }
1169
1170 d356a53f Måns Rullgård
                            if (code >= cb_size) {
1171
                                err_idx = code;
1172 c816d3d0 Måns Rullgård
                                goto err_cb_overflow;
1173
                            }
1174
1175 d356a53f Måns Rullgård
                            cb_idx = cb_vector_idx[code];
1176 c816d3d0 Måns Rullgård
                            nnz = cb_idx >> 12;
1177
                            nzt = cb_idx >> 8;
1178 d356a53f Måns Rullgård
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1179
                            LAST_SKIP_BITS(re, gb, nnz);
1180 c816d3d0 Måns Rullgård
1181
                            for (j = 0; j < 2; j++) {
1182
                                if (nzt & 1<<j) {
1183 d356a53f Måns Rullgård
                                    uint32_t b;
1184
                                    int n;
1185 c816d3d0 Måns Rullgård
                                    /* The total length of escape_sequence must be < 22 bits according
1186
                                       to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1187 d356a53f Måns Rullgård
                                    UPDATE_CACHE(re, gb);
1188
                                    b = GET_CACHE(re, gb);
1189
                                    b = 31 - av_log2(~b);
1190
1191
                                    if (b > 8) {
1192 dd8871a6 Alex Converse
                                        av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1193 c816d3d0 Måns Rullgård
                                        return -1;
1194
                                    }
1195 d356a53f Måns Rullgård
1196
#if MIN_CACHE_BITS < 21
1197
                                    LAST_SKIP_BITS(re, gb, b + 1);
1198
                                    UPDATE_CACHE(re, gb);
1199
#else
1200
                                    SKIP_BITS(re, gb, b + 1);
1201
#endif
1202
                                    b += 4;
1203
                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
1204
                                    LAST_SKIP_BITS(re, gb, b);
1205 05f9d8fc Måns Rullgård
                                    *icf++ = cbrt_tab[n] | (bits & 1<<31);
1206 c816d3d0 Måns Rullgård
                                    bits <<= 1;
1207
                                } else {
1208
                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1209 05f9d8fc Måns Rullgård
                                    *icf++ = (bits & 1<<31) | v;
1210 c816d3d0 Måns Rullgård
                                    bits <<= !!v;
1211 e8d5c07b Alex Converse
                                }
1212 c816d3d0 Måns Rullgård
                                cb_idx >>= 4;
1213 9ffd5c1c Robert Swain
                            }
1214 05f9d8fc Måns Rullgård
                        } while (len -= 2);
1215 42d3fbb3 Måns Rullgård
1216 05f9d8fc Måns Rullgård
                        ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1217 42d3fbb3 Måns Rullgård
                    }
1218 9ffd5c1c Robert Swain
                }
1219 d356a53f Måns Rullgård
1220
                CLOSE_READER(re, gb);
1221 9ffd5c1c Robert Swain
            }
1222
        }
1223 05f9d8fc Måns Rullgård
        coef += g_len << 7;
1224 9ffd5c1c Robert Swain
    }
1225
1226
    if (pulse_present) {
1227 51436848 Alex Converse
        idx = 0;
1228 577d383b Diego Biurrun
        for (i = 0; i < pulse->num_pulse; i++) {
1229
            float co = coef_base[ pulse->pos[i] ];
1230
            while (offsets[idx + 1] <= pulse->pos[i])
1231 51436848 Alex Converse
                idx++;
1232
            if (band_type[idx] != NOISE_BT && sf[idx]) {
1233 70735a3f Robert Swain
                float ico = -pulse->amp[i];
1234
                if (co) {
1235
                    co /= sf[idx];
1236
                    ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
1237
                }
1238
                coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
1239 51436848 Alex Converse
            }
1240 9ffd5c1c Robert Swain
        }
1241
    }
1242
    return 0;
1243 c816d3d0 Måns Rullgård
1244
err_cb_overflow:
1245 dd8871a6 Alex Converse
    av_log(ac->avctx, AV_LOG_ERROR,
1246 c816d3d0 Måns Rullgård
           "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
1247
           band_type[idx], err_idx, ff_aac_spectral_sizes[band_type[idx]]);
1248
    return -1;
1249 9ffd5c1c Robert Swain
}
1250
1251 577d383b Diego Biurrun
static av_always_inline float flt16_round(float pf)
1252
{
1253 4a39ccb4 Alex Converse
    union float754 tmp;
1254
    tmp.f = pf;
1255
    tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
1256
    return tmp.f;
1257 7633a041 Alex Converse
}
1258
1259 577d383b Diego Biurrun
static av_always_inline float flt16_even(float pf)
1260
{
1261 4a39ccb4 Alex Converse
    union float754 tmp;
1262
    tmp.f = pf;
1263 577d383b Diego Biurrun
    tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
1264 4a39ccb4 Alex Converse
    return tmp.f;
1265 7633a041 Alex Converse
}
1266
1267 577d383b Diego Biurrun
static av_always_inline float flt16_trunc(float pf)
1268
{
1269 4a39ccb4 Alex Converse
    union float754 pun;
1270
    pun.f = pf;
1271
    pun.i &= 0xFFFF0000U;
1272
    return pun.f;
1273 7633a041 Alex Converse
}
1274
1275 ab2a3028 Alex Converse
static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef,
1276 577d383b Diego Biurrun
                    int output_enable)
1277
{
1278
    const float a     = 0.953125; // 61.0 / 64
1279
    const float alpha = 0.90625;  // 29.0 / 32
1280 7633a041 Alex Converse
    float e0, e1;
1281
    float pv;
1282
    float k1, k2;
1283
1284
    k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
1285
    k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
1286
1287
    pv = flt16_round(k1 * ps->r0 + k2 * ps->r1);
1288
    if (output_enable)
1289
        *coef += pv * ac->sf_scale;
1290
1291
    e0 = *coef / ac->sf_scale;
1292
    e1 = e0 - k1 * ps->r0;
1293
1294
    ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1);
1295
    ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5 * (ps->r1 * ps->r1 + e1 * e1));
1296
    ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0);
1297
    ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5 * (ps->r0 * ps->r0 + e0 * e0));
1298
1299
    ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0));
1300
    ps->r0 = flt16_trunc(a * e0);
1301
}
1302
1303
/**
1304
 * Apply AAC-Main style frequency domain prediction.
1305
 */
1306 577d383b Diego Biurrun
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
1307
{
1308 7633a041 Alex Converse
    int sfb, k;
1309
1310
    if (!sce->ics.predictor_initialized) {
1311 aab54133 Alex Converse
        reset_all_predictors(sce->predictor_state);
1312 7633a041 Alex Converse
        sce->ics.predictor_initialized = 1;
1313
    }
1314
1315
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
1316
        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
1317
            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
1318 aab54133 Alex Converse
                predict(ac, &sce->predictor_state[k], &sce->coeffs[k],
1319 577d383b Diego Biurrun
                        sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
1320 7633a041 Alex Converse
            }
1321
        }
1322
        if (sce->ics.predictor_reset_group)
1323 aab54133 Alex Converse
            reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
1324 7633a041 Alex Converse
    } else
1325 aab54133 Alex Converse
        reset_all_predictors(sce->predictor_state);
1326 7633a041 Alex Converse
}
1327
1328 9ffd5c1c Robert Swain
/**
1329 9cc04edf Robert Swain
 * Decode an individual_channel_stream payload; reference: table 4.44.
1330
 *
1331
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
1332
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
1333
 *
1334
 * @return  Returns error status. 0 - OK, !0 - error
1335
 */
1336 577d383b Diego Biurrun
static int decode_ics(AACContext *ac, SingleChannelElement *sce,
1337
                      GetBitContext *gb, int common_window, int scale_flag)
1338
{
1339 9cc04edf Robert Swain
    Pulse pulse;
1340 577d383b Diego Biurrun
    TemporalNoiseShaping    *tns = &sce->tns;
1341
    IndividualChannelStream *ics = &sce->ics;
1342
    float *out = sce->coeffs;
1343 9cc04edf Robert Swain
    int global_gain, pulse_present = 0;
1344
1345 848a5815 Robert Swain
    /* This assignment is to silence a GCC warning about the variable being used
1346
     * uninitialized when in fact it always is.
1347 9cc04edf Robert Swain
     */
1348
    pulse.num_pulse = 0;
1349
1350
    global_gain = get_bits(gb, 8);
1351
1352
    if (!common_window && !scale_flag) {
1353
        if (decode_ics_info(ac, ics, gb, 0) < 0)
1354
            return -1;
1355
    }
1356
1357
    if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
1358
        return -1;
1359
    if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
1360
        return -1;
1361
1362
    pulse_present = 0;
1363
    if (!scale_flag) {
1364
        if ((pulse_present = get_bits1(gb))) {
1365
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1366 dd8871a6 Alex Converse
                av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
1367 9cc04edf Robert Swain
                return -1;
1368
            }
1369 aac0eda4 Alex Converse
            if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
1370 dd8871a6 Alex Converse
                av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
1371 aac0eda4 Alex Converse
                return -1;
1372
            }
1373 9cc04edf Robert Swain
        }
1374
        if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
1375
            return -1;
1376
        if (get_bits1(gb)) {
1377 dd8871a6 Alex Converse
            av_log_missing_feature(ac->avctx, "SSR", 1);
1378 9cc04edf Robert Swain
            return -1;
1379
        }
1380
    }
1381
1382 848a5815 Robert Swain
    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
1383 9cc04edf Robert Swain
        return -1;
1384 7633a041 Alex Converse
1385 577d383b Diego Biurrun
    if (ac->m4ac.object_type == AOT_AAC_MAIN && !common_window)
1386 7633a041 Alex Converse
        apply_prediction(ac, sce);
1387
1388 9cc04edf Robert Swain
    return 0;
1389
}
1390
1391
/**
1392 9ffd5c1c Robert Swain
 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
1393
 */
1394 42d3fbb3 Måns Rullgård
static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
1395 577d383b Diego Biurrun
{
1396
    const IndividualChannelStream *ics = &cpe->ch[0].ics;
1397 9ffd5c1c Robert Swain
    float *ch0 = cpe->ch[0].coeffs;
1398
    float *ch1 = cpe->ch[1].coeffs;
1399 42d3fbb3 Måns Rullgård
    int g, i, group, idx = 0;
1400 577d383b Diego Biurrun
    const uint16_t *offsets = ics->swb_offset;
1401 9ffd5c1c Robert Swain
    for (g = 0; g < ics->num_window_groups; g++) {
1402
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1403
            if (cpe->ms_mask[idx] &&
1404 577d383b Diego Biurrun
                    cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
1405 9ffd5c1c Robert Swain
                for (group = 0; group < ics->group_len[g]; group++) {
1406 42d3fbb3 Måns Rullgård
                    ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i],
1407
                                              ch1 + group * 128 + offsets[i],
1408
                                              offsets[i+1] - offsets[i]);
1409 9ffd5c1c Robert Swain
                }
1410
            }
1411
        }
1412 577d383b Diego Biurrun
        ch0 += ics->group_len[g] * 128;
1413
        ch1 += ics->group_len[g] * 128;
1414 9ffd5c1c Robert Swain
    }
1415
}
1416
1417
/**
1418
 * intensity stereo decoding; reference: 4.6.8.2.3
1419
 *
1420
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
1421
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
1422
 *                      [3] reserved for scalable AAC
1423
 */
1424 577d383b Diego Biurrun
static void apply_intensity_stereo(ChannelElement *cpe, int ms_present)
1425
{
1426
    const IndividualChannelStream *ics = &cpe->ch[1].ics;
1427
    SingleChannelElement         *sce1 = &cpe->ch[1];
1428 9ffd5c1c Robert Swain
    float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
1429 577d383b Diego Biurrun
    const uint16_t *offsets = ics->swb_offset;
1430 9ffd5c1c Robert Swain
    int g, group, i, k, idx = 0;
1431
    int c;
1432
    float scale;
1433
    for (g = 0; g < ics->num_window_groups; g++) {
1434
        for (i = 0; i < ics->max_sfb;) {
1435
            if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) {
1436
                const int bt_run_end = sce1->band_type_run_end[idx];
1437
                for (; i < bt_run_end; i++, idx++) {
1438
                    c = -1 + 2 * (sce1->band_type[idx] - 14);
1439
                    if (ms_present)
1440
                        c *= 1 - 2 * cpe->ms_mask[idx];
1441
                    scale = c * sce1->sf[idx];
1442
                    for (group = 0; group < ics->group_len[g]; group++)
1443 577d383b Diego Biurrun
                        for (k = offsets[i]; k < offsets[i + 1]; k++)
1444
                            coef1[group * 128 + k] = scale * coef0[group * 128 + k];
1445 9ffd5c1c Robert Swain
                }
1446
            } else {
1447
                int bt_run_end = sce1->band_type_run_end[idx];
1448
                idx += bt_run_end - i;
1449
                i    = bt_run_end;
1450
            }
1451
        }
1452 577d383b Diego Biurrun
        coef0 += ics->group_len[g] * 128;
1453
        coef1 += ics->group_len[g] * 128;
1454 9ffd5c1c Robert Swain
    }
1455
}
1456
1457
/**
1458 9cc04edf Robert Swain
 * Decode a channel_pair_element; reference: table 4.4.
1459
 *
1460
 * @param   elem_id Identifies the instance of a syntax element.
1461
 *
1462
 * @return  Returns error status. 0 - OK, !0 - error
1463
 */
1464 577d383b Diego Biurrun
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
1465
{
1466 9cc04edf Robert Swain
    int i, ret, common_window, ms_present = 0;
1467
1468
    common_window = get_bits1(gb);
1469
    if (common_window) {
1470
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
1471
            return -1;
1472
        i = cpe->ch[1].ics.use_kb_window[0];
1473
        cpe->ch[1].ics = cpe->ch[0].ics;
1474
        cpe->ch[1].ics.use_kb_window[1] = i;
1475
        ms_present = get_bits(gb, 2);
1476 577d383b Diego Biurrun
        if (ms_present == 3) {
1477 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1478 9cc04edf Robert Swain
            return -1;
1479 577d383b Diego Biurrun
        } else if (ms_present)
1480 9cc04edf Robert Swain
            decode_mid_side_stereo(cpe, gb, ms_present);
1481
    }
1482
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
1483
        return ret;
1484
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
1485
        return ret;
1486
1487 aab54133 Alex Converse
    if (common_window) {
1488
        if (ms_present)
1489 42d3fbb3 Måns Rullgård
            apply_mid_side_stereo(ac, cpe);
1490 aab54133 Alex Converse
        if (ac->m4ac.object_type == AOT_AAC_MAIN) {
1491
            apply_prediction(ac, &cpe->ch[0]);
1492
            apply_prediction(ac, &cpe->ch[1]);
1493
        }
1494
    }
1495 9cc04edf Robert Swain
1496 848a5815 Robert Swain
    apply_intensity_stereo(cpe, ms_present);
1497 9cc04edf Robert Swain
    return 0;
1498
}
1499
1500 9ffd5c1c Robert Swain
/**
1501
 * Decode coupling_channel_element; reference: table 4.8.
1502
 *
1503
 * @param   elem_id Identifies the instance of a syntax element.
1504
 *
1505
 * @return  Returns error status. 0 - OK, !0 - error
1506
 */
1507 577d383b Diego Biurrun
static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
1508
{
1509 9ffd5c1c Robert Swain
    int num_gain = 0;
1510 341b28c0 Robert Swain
    int c, g, sfb, ret;
1511 9ffd5c1c Robert Swain
    int sign;
1512
    float scale;
1513 577d383b Diego Biurrun
    SingleChannelElement *sce = &che->ch[0];
1514
    ChannelCoupling     *coup = &che->coup;
1515 9ffd5c1c Robert Swain
1516 577d383b Diego Biurrun
    coup->coupling_point = 2 * get_bits1(gb);
1517 62a57fae Robert Swain
    coup->num_coupled = get_bits(gb, 3);
1518
    for (c = 0; c <= coup->num_coupled; c++) {
1519
        num_gain++;
1520
        coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
1521
        coup->id_select[c] = get_bits(gb, 4);
1522
        if (coup->type[c] == TYPE_CPE) {
1523
            coup->ch_select[c] = get_bits(gb, 2);
1524
            if (coup->ch_select[c] == 3)
1525
                num_gain++;
1526
        } else
1527 88de95c2 Alex Converse
            coup->ch_select[c] = 2;
1528 62a57fae Robert Swain
    }
1529 577d383b Diego Biurrun
    coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
1530 62a57fae Robert Swain
1531 577d383b Diego Biurrun
    sign  = get_bits(gb, 1);
1532 c8947a56 Alex Converse
    scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3));
1533 62a57fae Robert Swain
1534
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
1535
        return ret;
1536
1537
    for (c = 0; c < num_gain; c++) {
1538 577d383b Diego Biurrun
        int idx  = 0;
1539
        int cge  = 1;
1540 62a57fae Robert Swain
        int gain = 0;
1541
        float gain_cache = 1.;
1542
        if (c) {
1543
            cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
1544
            gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
1545 88de95c2 Alex Converse
            gain_cache = pow(scale, -gain);
1546 62a57fae Robert Swain
        }
1547 f1ade11e Alex Converse
        if (coup->coupling_point == AFTER_IMDCT) {
1548
            coup->gain[c][0] = gain_cache;
1549
        } else {
1550 03b12747 Alex Converse
            for (g = 0; g < sce->ics.num_window_groups; g++) {
1551
                for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
1552
                    if (sce->band_type[idx] != ZERO_BT) {
1553
                        if (!cge) {
1554
                            int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
1555 577d383b Diego Biurrun
                            if (t) {
1556 03b12747 Alex Converse
                                int s = 1;
1557
                                t = gain += t;
1558
                                if (sign) {
1559
                                    s  -= 2 * (t & 0x1);
1560
                                    t >>= 1;
1561
                                }
1562
                                gain_cache = pow(scale, -t) * s;
1563 62a57fae Robert Swain
                            }
1564
                        }
1565 03b12747 Alex Converse
                        coup->gain[c][idx] = gain_cache;
1566 62a57fae Robert Swain
                    }
1567
                }
1568 f80a8ca5 Robert Swain
            }
1569
        }
1570 62a57fae Robert Swain
    }
1571
    return 0;
1572
}
1573
1574 9cc04edf Robert Swain
/**
1575 62a57fae Robert Swain
 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1576
 *
1577
 * @return  Returns number of bytes consumed.
1578
 */
1579 577d383b Diego Biurrun
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
1580
                                         GetBitContext *gb)
1581
{
1582 62a57fae Robert Swain
    int i;
1583
    int num_excl_chan = 0;
1584
1585
    do {
1586
        for (i = 0; i < 7; i++)
1587
            che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
1588
    } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
1589
1590
    return num_excl_chan / 7;
1591
}
1592
1593
/**
1594 9cc04edf Robert Swain
 * Decode dynamic range information; reference: table 4.52.
1595
 *
1596
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1597
 *
1598
 * @return  Returns number of bytes consumed.
1599
 */
1600 577d383b Diego Biurrun
static int decode_dynamic_range(DynamicRangeControl *che_drc,
1601
                                GetBitContext *gb, int cnt)
1602
{
1603
    int n             = 1;
1604 9cc04edf Robert Swain
    int drc_num_bands = 1;
1605
    int i;
1606
1607
    /* pce_tag_present? */
1608 577d383b Diego Biurrun
    if (get_bits1(gb)) {
1609 9cc04edf Robert Swain
        che_drc->pce_instance_tag  = get_bits(gb, 4);
1610
        skip_bits(gb, 4); // tag_reserved_bits
1611
        n++;
1612
    }
1613
1614
    /* excluded_chns_present? */
1615 577d383b Diego Biurrun
    if (get_bits1(gb)) {
1616 9cc04edf Robert Swain
        n += decode_drc_channel_exclusions(che_drc, gb);
1617
    }
1618
1619
    /* drc_bands_present? */
1620
    if (get_bits1(gb)) {
1621
        che_drc->band_incr            = get_bits(gb, 4);
1622
        che_drc->interpolation_scheme = get_bits(gb, 4);
1623
        n++;
1624
        drc_num_bands += che_drc->band_incr;
1625
        for (i = 0; i < drc_num_bands; i++) {
1626
            che_drc->band_top[i] = get_bits(gb, 8);
1627
            n++;
1628
        }
1629
    }
1630
1631
    /* prog_ref_level_present? */
1632
    if (get_bits1(gb)) {
1633
        che_drc->prog_ref_level = get_bits(gb, 7);
1634
        skip_bits1(gb); // prog_ref_level_reserved_bits
1635
        n++;
1636
    }
1637
1638
    for (i = 0; i < drc_num_bands; i++) {
1639
        che_drc->dyn_rng_sgn[i] = get_bits1(gb);
1640
        che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
1641
        n++;
1642
    }
1643
1644
    return n;
1645
}
1646
1647
/**
1648
 * Decode extension data (incomplete); reference: table 4.51.
1649
 *
1650
 * @param   cnt length of TYPE_FIL syntactic element in bytes
1651
 *
1652
 * @return Returns number of bytes consumed
1653
 */
1654 ed492b61 Alex Converse
static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
1655
                                    ChannelElement *che, enum RawDataBlockType elem_type)
1656 577d383b Diego Biurrun
{
1657 cc0591da Robert Swain
    int crc_flag = 0;
1658
    int res = cnt;
1659
    switch (get_bits(gb, 4)) { // extension type
1660 577d383b Diego Biurrun
    case EXT_SBR_DATA_CRC:
1661
        crc_flag++;
1662
    case EXT_SBR_DATA:
1663 ed492b61 Alex Converse
        if (!che) {
1664 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
1665 ed492b61 Alex Converse
            return res;
1666
        } else if (!ac->m4ac.sbr) {
1667 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
1668 ed492b61 Alex Converse
            skip_bits_long(gb, 8 * cnt - 4);
1669
            return res;
1670
        } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) {
1671 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
1672 ed492b61 Alex Converse
            skip_bits_long(gb, 8 * cnt - 4);
1673
            return res;
1674 a2063901 Alex Converse
        } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) {
1675
            ac->m4ac.sbr = 1;
1676
            ac->m4ac.ps = 1;
1677
            output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured);
1678 ed492b61 Alex Converse
        } else {
1679
            ac->m4ac.sbr = 1;
1680
        }
1681
        res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
1682 577d383b Diego Biurrun
        break;
1683
    case EXT_DYNAMIC_RANGE:
1684
        res = decode_dynamic_range(&ac->che_drc, gb, cnt);
1685
        break;
1686
    case EXT_FILL:
1687
    case EXT_FILL_DATA:
1688
    case EXT_DATA_ELEMENT:
1689
    default:
1690
        skip_bits_long(gb, 8 * cnt - 4);
1691
        break;
1692 cc0591da Robert Swain
    };
1693
    return res;
1694
}
1695
1696 7d8f3de4 Robert Swain
/**
1697
 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
1698
 *
1699
 * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
1700
 * @param   coef    spectral coefficients
1701
 */
1702 577d383b Diego Biurrun
static void apply_tns(float coef[1024], TemporalNoiseShaping *tns,
1703
                      IndividualChannelStream *ics, int decode)
1704
{
1705
    const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
1706 1098e8d2 Robert Swain
    int w, filt, m, i;
1707 7d8f3de4 Robert Swain
    int bottom, top, order, start, end, size, inc;
1708
    float lpc[TNS_MAX_ORDER];
1709
1710
    for (w = 0; w < ics->num_windows; w++) {
1711
        bottom = ics->num_swb;
1712
        for (filt = 0; filt < tns->n_filt[w]; filt++) {
1713
            top    = bottom;
1714
            bottom = FFMAX(0, top - tns->length[w][filt]);
1715
            order  = tns->order[w][filt];
1716
            if (order == 0)
1717
                continue;
1718
1719 1be0fc29 Vitor Sessak
            // tns_decode_coef
1720
            compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
1721 7d8f3de4 Robert Swain
1722 1dece0d2 Robert Swain
            start = ics->swb_offset[FFMIN(bottom, mmm)];
1723
            end   = ics->swb_offset[FFMIN(   top, mmm)];
1724
            if ((size = end - start) <= 0)
1725
                continue;
1726
            if (tns->direction[w][filt]) {
1727 577d383b Diego Biurrun
                inc = -1;
1728
                start = end - 1;
1729 1dece0d2 Robert Swain
            } else {
1730
                inc = 1;
1731
            }
1732
            start += w * 128;
1733
1734
            // ar filter
1735
            for (m = 0; m < size; m++, start += inc)
1736
                for (i = 1; i <= FFMIN(m, order); i++)
1737 577d383b Diego Biurrun
                    coef[start] -= coef[start - i * inc] * lpc[i - 1];
1738 1dece0d2 Robert Swain
        }
1739
    }
1740
}
1741
1742 cc0591da Robert Swain
/**
1743 9cc04edf Robert Swain
 * Conduct IMDCT and windowing.
1744
 */
1745 f8a93a20 Alex Converse
static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float bias)
1746 577d383b Diego Biurrun
{
1747
    IndividualChannelStream *ics = &sce->ics;
1748
    float *in    = sce->coeffs;
1749
    float *out   = sce->ret;
1750
    float *saved = sce->saved;
1751
    const float *swindow      = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
1752
    const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
1753
    const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
1754
    float *buf  = ac->buf_mdct;
1755
    float *temp = ac->temp;
1756 9cc04edf Robert Swain
    int i;
1757
1758 f4990558 Robert Swain
    // imdct
1759 62a57fae Robert Swain
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1760
        if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE)
1761 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_WARNING,
1762 62a57fae Robert Swain
                   "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
1763
                   "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
1764 b0f5852a Robert Swain
        for (i = 0; i < 1024; i += 128)
1765
            ff_imdct_half(&ac->mdct_small, buf + i, in + i);
1766 f4990558 Robert Swain
    } else
1767 b0f5852a Robert Swain
        ff_imdct_half(&ac->mdct, buf, in);
1768 f4990558 Robert Swain
1769
    /* window overlapping
1770
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1771
     * and long to short transitions are considered to be short to short
1772
     * transitions. This leaves just two cases (long to long and short to short)
1773
     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
1774
     */
1775
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
1776 577d383b Diego Biurrun
            (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
1777 f8a93a20 Alex Converse
        ac->dsp.vector_fmul_window(    out,               saved,            buf,         lwindow_prev, bias, 512);
1778 f4990558 Robert Swain
    } else {
1779 db38c386 Robert Swain
        for (i = 0; i < 448; i++)
1780 f8a93a20 Alex Converse
            out[i] = saved[i] + bias;
1781 62a57fae Robert Swain
1782 f4990558 Robert Swain
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1783 f8a93a20 Alex Converse
            ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, bias, 64);
1784
            ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      bias, 64);
1785
            ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      bias, 64);
1786
            ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      bias, 64);
1787
            ac->dsp.vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      bias, 64);
1788 b0f5852a Robert Swain
            memcpy(                    out + 448 + 4*128, temp, 64 * sizeof(float));
1789 f4990558 Robert Swain
        } else {
1790 f8a93a20 Alex Converse
            ac->dsp.vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, bias, 64);
1791 db38c386 Robert Swain
            for (i = 576; i < 1024; i++)
1792 f8a93a20 Alex Converse
                out[i] = buf[i-512] + bias;
1793 f4990558 Robert Swain
        }
1794
    }
1795 62a57fae Robert Swain
1796 f4990558 Robert Swain
    // buffer update
1797
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1798 b0f5852a Robert Swain
        for (i = 0; i < 64; i++)
1799 f8a93a20 Alex Converse
            saved[i] = temp[64 + i] - bias;
1800 b0f5852a Robert Swain
        ac->dsp.vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 0, 64);
1801
        ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64);
1802
        ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64);
1803
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1804 f4990558 Robert Swain
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
1805 b0f5852a Robert Swain
        memcpy(                    saved,       buf + 512,        448 * sizeof(float));
1806
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1807 f4990558 Robert Swain
    } else { // LONG_STOP or ONLY_LONG
1808 b0f5852a Robert Swain
        memcpy(                    saved,       buf + 512,        512 * sizeof(float));
1809 62a57fae Robert Swain
    }
1810
}
1811
1812 9cc04edf Robert Swain
/**
1813 cc0591da Robert Swain
 * Apply dependent channel coupling (applied before IMDCT).
1814
 *
1815
 * @param   index   index into coupling gain array
1816
 */
1817 577d383b Diego Biurrun
static void apply_dependent_coupling(AACContext *ac,
1818
                                     SingleChannelElement *target,
1819
                                     ChannelElement *cce, int index)
1820
{
1821
    IndividualChannelStream *ics = &cce->ch[0].ics;
1822
    const uint16_t *offsets = ics->swb_offset;
1823
    float *dest = target->coeffs;
1824
    const float *src = cce->ch[0].coeffs;
1825 cc0591da Robert Swain
    int g, i, group, k, idx = 0;
1826 577d383b Diego Biurrun
    if (ac->m4ac.object_type == AOT_AAC_LTP) {
1827 dd8871a6 Alex Converse
        av_log(ac->avctx, AV_LOG_ERROR,
1828 cc0591da Robert Swain
               "Dependent coupling is not supported together with LTP\n");
1829
        return;
1830
    }
1831
    for (g = 0; g < ics->num_window_groups; g++) {
1832
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1833 fbdae895 Alex Converse
            if (cce->ch[0].band_type[idx] != ZERO_BT) {
1834 cfd937b0 Alex Converse
                const float gain = cce->coup.gain[index][idx];
1835 cc0591da Robert Swain
                for (group = 0; group < ics->group_len[g]; group++) {
1836 577d383b Diego Biurrun
                    for (k = offsets[i]; k < offsets[i + 1]; k++) {
1837 cc0591da Robert Swain
                        // XXX dsputil-ize
1838 577d383b Diego Biurrun
                        dest[group * 128 + k] += gain * src[group * 128 + k];
1839 cc0591da Robert Swain
                    }
1840
                }
1841
            }
1842
        }
1843 577d383b Diego Biurrun
        dest += ics->group_len[g] * 128;
1844
        src  += ics->group_len[g] * 128;
1845 cc0591da Robert Swain
    }
1846
}
1847
1848
/**
1849
 * Apply independent channel coupling (applied after IMDCT).
1850
 *
1851
 * @param   index   index into coupling gain array
1852
 */
1853 577d383b Diego Biurrun
static void apply_independent_coupling(AACContext *ac,
1854
                                       SingleChannelElement *target,
1855
                                       ChannelElement *cce, int index)
1856
{
1857 cc0591da Robert Swain
    int i;
1858 039821a8 Alex Converse
    const float gain = cce->coup.gain[index][0];
1859
    const float bias = ac->add_bias;
1860 577d383b Diego Biurrun
    const float *src = cce->ch[0].ret;
1861
    float *dest = target->ret;
1862 ed492b61 Alex Converse
    const int len = 1024 << (ac->m4ac.sbr == 1);
1863 039821a8 Alex Converse
1864 ed492b61 Alex Converse
    for (i = 0; i < len; i++)
1865 039821a8 Alex Converse
        dest[i] += gain * (src[i] - bias);
1866 cc0591da Robert Swain
}
1867
1868 9ffd5c1c Robert Swain
/**
1869
 * channel coupling transformation interface
1870
 *
1871
 * @param   index   index into coupling gain array
1872
 * @param   apply_coupling_method   pointer to (in)dependent coupling function
1873
 */
1874 577d383b Diego Biurrun
static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
1875
                                   enum RawDataBlockType type, int elem_id,
1876
                                   enum CouplingPoint coupling_point,
1877
                                   void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
1878 9ffd5c1c Robert Swain
{
1879 88de95c2 Alex Converse
    int i, c;
1880
1881
    for (i = 0; i < MAX_ELEM_ID; i++) {
1882
        ChannelElement *cce = ac->che[TYPE_CCE][i];
1883
        int index = 0;
1884
1885
        if (cce && cce->coup.coupling_point == coupling_point) {
1886 577d383b Diego Biurrun
            ChannelCoupling *coup = &cce->coup;
1887 88de95c2 Alex Converse
1888
            for (c = 0; c <= coup->num_coupled; c++) {
1889
                if (coup->type[c] == type && coup->id_select[c] == elem_id) {
1890
                    if (coup->ch_select[c] != 1) {
1891
                        apply_coupling_method(ac, &cc->ch[0], cce, index);
1892
                        if (coup->ch_select[c] != 0)
1893
                            index++;
1894
                    }
1895
                    if (coup->ch_select[c] != 2)
1896
                        apply_coupling_method(ac, &cc->ch[1], cce, index++);
1897
                } else
1898
                    index += 1 + (coup->ch_select[c] == 3);
1899 9ffd5c1c Robert Swain
            }
1900
        }
1901
    }
1902
}
1903
1904
/**
1905
 * Convert spectral data to float samples, applying all supported tools as appropriate.
1906
 */
1907 577d383b Diego Biurrun
static void spectral_to_sample(AACContext *ac)
1908
{
1909 b0bc928b Carl Eugen Hoyos
    int i, type;
1910 f8a93a20 Alex Converse
    float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f;
1911 b0bc928b Carl Eugen Hoyos
    for (type = 3; type >= 0; type--) {
1912 88de95c2 Alex Converse
        for (i = 0; i < MAX_ELEM_ID; i++) {
1913 9ffd5c1c Robert Swain
            ChannelElement *che = ac->che[type][i];
1914 577d383b Diego Biurrun
            if (che) {
1915
                if (type <= TYPE_CPE)
1916 88de95c2 Alex Converse
                    apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling);
1917 577d383b Diego Biurrun
                if (che->ch[0].tns.present)
1918 9ffd5c1c Robert Swain
                    apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
1919 577d383b Diego Biurrun
                if (che->ch[1].tns.present)
1920 9ffd5c1c Robert Swain
                    apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
1921 577d383b Diego Biurrun
                if (type <= TYPE_CPE)
1922 88de95c2 Alex Converse
                    apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
1923 ed492b61 Alex Converse
                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
1924 f8a93a20 Alex Converse
                    imdct_and_windowing(ac, &che->ch[0], imdct_bias);
1925 d0dedce7 Alex Converse
                    if (type == TYPE_CPE) {
1926
                        imdct_and_windowing(ac, &che->ch[1], imdct_bias);
1927
                    }
1928 ca6d3f23 Alex Converse
                    if (ac->m4ac.sbr > 0) {
1929
                        ff_sbr_apply(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
1930
                    }
1931 ed492b61 Alex Converse
                }
1932 577d383b Diego Biurrun
                if (type <= TYPE_CCE)
1933 88de95c2 Alex Converse
                    apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling);
1934 62a57fae Robert Swain
            }
1935
        }
1936
    }
1937
}
1938
1939 577d383b Diego Biurrun
static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
1940
{
1941 158b3912 Robert Swain
    int size;
1942
    AACADTSHeaderInfo hdr_info;
1943
1944
    size = ff_aac_parse_header(gb, &hdr_info);
1945
    if (size > 0) {
1946 981b8fd7 Alex Converse
        if (ac->output_configured != OC_LOCKED && hdr_info.chan_config) {
1947 6308765c Alex Converse
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
1948
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
1949 158b3912 Robert Swain
            ac->m4ac.chan_config = hdr_info.chan_config;
1950 6308765c Alex Converse
            if (set_default_channel_config(ac, new_che_pos, hdr_info.chan_config))
1951
                return -7;
1952 981b8fd7 Alex Converse
            if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME))
1953 6308765c Alex Converse
                return -7;
1954 981b8fd7 Alex Converse
        } else if (ac->output_configured != OC_LOCKED) {
1955
            ac->output_configured = OC_NONE;
1956 6308765c Alex Converse
        }
1957 a2063901 Alex Converse
        if (ac->output_configured != OC_LOCKED) {
1958 38610d92 Alex Converse
            ac->m4ac.sbr = -1;
1959 a2063901 Alex Converse
            ac->m4ac.ps  = -1;
1960
        }
1961 158b3912 Robert Swain
        ac->m4ac.sample_rate     = hdr_info.sample_rate;
1962
        ac->m4ac.sampling_index  = hdr_info.sampling_index;
1963
        ac->m4ac.object_type     = hdr_info.object_type;
1964 dd8871a6 Alex Converse
        if (!ac->avctx->sample_rate)
1965
            ac->avctx->sample_rate = hdr_info.sample_rate;
1966 7d87e2ce Alex Converse
        if (hdr_info.num_aac_frames == 1) {
1967
            if (!hdr_info.crc_absent)
1968
                skip_bits(gb, 16);
1969
        } else {
1970 dd8871a6 Alex Converse
            av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0);
1971 7d87e2ce Alex Converse
            return -1;
1972
        }
1973 51741a82 Alex Converse
    }
1974 158b3912 Robert Swain
    return size;
1975
}
1976
1977 dd8871a6 Alex Converse
static int aac_decode_frame(AVCodecContext *avctx, void *data,
1978 577d383b Diego Biurrun
                            int *data_size, AVPacket *avpkt)
1979
{
1980 7a00bbad Thilo Borgmann
    const uint8_t *buf = avpkt->data;
1981
    int buf_size = avpkt->size;
1982 dd8871a6 Alex Converse
    AACContext *ac = avctx->priv_data;
1983 ed492b61 Alex Converse
    ChannelElement *che = NULL, *che_prev = NULL;
1984 62a57fae Robert Swain
    GetBitContext gb;
1985 ed492b61 Alex Converse
    enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
1986 62a57fae Robert Swain
    int err, elem_id, data_size_tmp;
1987 b5e2bb8c Alex Converse
    int buf_consumed;
1988 fda36b59 Alex Converse
    int samples = 0, multiplier;
1989 c16d5a6f Alex Converse
    int buf_offset;
1990 62a57fae Robert Swain
1991 577d383b Diego Biurrun
    init_get_bits(&gb, buf, buf_size * 8);
1992 62a57fae Robert Swain
1993 158b3912 Robert Swain
    if (show_bits(&gb, 12) == 0xfff) {
1994 5967e141 Robert Swain
        if (parse_adts_frame_header(ac, &gb) < 0) {
1995 dd8871a6 Alex Converse
            av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
1996 158b3912 Robert Swain
            return -1;
1997
        }
1998 30272450 Alex Converse
        if (ac->m4ac.sampling_index > 12) {
1999 dd8871a6 Alex Converse
            av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
2000 f418b861 Jai Menon
            return -1;
2001
        }
2002 158b3912 Robert Swain
    }
2003
2004 7caee063 Alex Converse
    memset(ac->tags_seen_this_frame, 0, sizeof(ac->tags_seen_this_frame));
2005 62a57fae Robert Swain
    // parse
2006
    while ((elem_type = get_bits(&gb, 3)) != TYPE_END) {
2007
        elem_id = get_bits(&gb, 4);
2008
2009 ed99e54d Alex Converse
        if (elem_type < TYPE_DSE) {
2010 d4e355d5 Alex Converse
            if (!(che=get_che(ac, elem_type, elem_id))) {
2011
                av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
2012
                       elem_type, elem_id);
2013
                return -1;
2014
            }
2015 fda36b59 Alex Converse
            samples = 1024;
2016 ed99e54d Alex Converse
        }
2017 fda36b59 Alex Converse
2018 62a57fae Robert Swain
        switch (elem_type) {
2019
2020
        case TYPE_SCE:
2021 bb5c0988 Alex Converse
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
2022 62a57fae Robert Swain
            break;
2023
2024
        case TYPE_CPE:
2025 bb5c0988 Alex Converse
            err = decode_cpe(ac, &gb, che);
2026 62a57fae Robert Swain
            break;
2027
2028
        case TYPE_CCE:
2029 bb5c0988 Alex Converse
            err = decode_cce(ac, &gb, che);
2030 62a57fae Robert Swain
            break;
2031
2032
        case TYPE_LFE:
2033 bb5c0988 Alex Converse
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
2034 62a57fae Robert Swain
            break;
2035
2036
        case TYPE_DSE:
2037 8d637124 Alex Converse
            err = skip_data_stream_element(ac, &gb);
2038 62a57fae Robert Swain
            break;
2039
2040 577d383b Diego Biurrun
        case TYPE_PCE: {
2041 62a57fae Robert Swain
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
2042
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
2043 577d383b Diego Biurrun
            if ((err = decode_pce(ac, new_che_pos, &gb)))
2044 62a57fae Robert Swain
                break;
2045 4e878a18 Alex Converse
            if (ac->output_configured > OC_TRIAL_PCE)
2046 dd8871a6 Alex Converse
                av_log(avctx, AV_LOG_ERROR,
2047 6308765c Alex Converse
                       "Not evaluating a further program_config_element as this construct is dubious at best.\n");
2048
            else
2049 981b8fd7 Alex Converse
                err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE);
2050 62a57fae Robert Swain
            break;
2051
        }
2052
2053
        case TYPE_FIL:
2054
            if (elem_id == 15)
2055
                elem_id += get_bits(&gb, 8) - 1;
2056 8d637124 Alex Converse
            if (get_bits_left(&gb) < 8 * elem_id) {
2057 dd8871a6 Alex Converse
                    av_log(avctx, AV_LOG_ERROR, overread_err);
2058 8d637124 Alex Converse
                    return -1;
2059
            }
2060 62a57fae Robert Swain
            while (elem_id > 0)
2061 ed492b61 Alex Converse
                elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev);
2062 62a57fae Robert Swain
            err = 0; /* FIXME */
2063
            break;
2064
2065
        default:
2066
            err = -1; /* should not happen, but keeps compiler happy */
2067
            break;
2068
        }
2069
2070 ed492b61 Alex Converse
        che_prev       = che;
2071
        elem_type_prev = elem_type;
2072
2073 577d383b Diego Biurrun
        if (err)
2074 62a57fae Robert Swain
            return err;
2075 8d637124 Alex Converse
2076
        if (get_bits_left(&gb) < 3) {
2077 dd8871a6 Alex Converse
            av_log(avctx, AV_LOG_ERROR, overread_err);
2078 8d637124 Alex Converse
            return -1;
2079
        }
2080 62a57fae Robert Swain
    }
2081
2082
    spectral_to_sample(ac);
2083
2084 ed492b61 Alex Converse
    multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0;
2085 54f158bd Alex Converse
    samples <<= multiplier;
2086
    if (ac->output_configured < OC_LOCKED) {
2087 dd8871a6 Alex Converse
        avctx->sample_rate = ac->m4ac.sample_rate << multiplier;
2088
        avctx->frame_size = samples;
2089 54f158bd Alex Converse
    }
2090
2091 dd8871a6 Alex Converse
    data_size_tmp = samples * avctx->channels * sizeof(int16_t);
2092 577d383b Diego Biurrun
    if (*data_size < data_size_tmp) {
2093 dd8871a6 Alex Converse
        av_log(avctx, AV_LOG_ERROR,
2094 9cc04edf Robert Swain
               "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
2095
               *data_size, data_size_tmp);
2096
        return -1;
2097
    }
2098
    *data_size = data_size_tmp;
2099
2100 fda36b59 Alex Converse
    if (samples)
2101 19ed4b86 Alex Converse
        ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels);
2102 9cc04edf Robert Swain
2103 981b8fd7 Alex Converse
    if (ac->output_configured)
2104
        ac->output_configured = OC_LOCKED;
2105
2106 b5e2bb8c Alex Converse
    buf_consumed = (get_bits_count(&gb) + 7) >> 3;
2107 c16d5a6f Alex Converse
    for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
2108
        if (buf[buf_offset])
2109
            break;
2110
2111
    return buf_size > buf_offset ? buf_consumed : buf_size;
2112 9cc04edf Robert Swain
}
2113
2114 dd8871a6 Alex Converse
static av_cold int aac_decode_close(AVCodecContext *avctx)
2115 577d383b Diego Biurrun
{
2116 dd8871a6 Alex Converse
    AACContext *ac = avctx->priv_data;
2117 9edae4ad Robert Swain
    int i, type;
2118 71e9a1b8 Robert Swain
2119 cc0591da Robert Swain
    for (i = 0; i < MAX_ELEM_ID; i++) {
2120 ed492b61 Alex Converse
        for (type = 0; type < 4; type++) {
2121
            if (ac->che[type][i])
2122
                ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr);
2123 9edae4ad Robert Swain
            av_freep(&ac->che[type][i]);
2124 ed492b61 Alex Converse
        }
2125 71e9a1b8 Robert Swain
    }
2126
2127
    ff_mdct_end(&ac->mdct);
2128
    ff_mdct_end(&ac->mdct_small);
2129 577d383b Diego Biurrun
    return 0;
2130 71e9a1b8 Robert Swain
}
2131
2132
AVCodec aac_decoder = {
2133
    "aac",
2134 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_AUDIO,
2135 71e9a1b8 Robert Swain
    CODEC_ID_AAC,
2136
    sizeof(AACContext),
2137
    aac_decode_init,
2138
    NULL,
2139
    aac_decode_close,
2140
    aac_decode_frame,
2141
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
2142 b5f09d31 Reimar Döffinger
    .sample_fmts = (const enum SampleFormat[]) {
2143 577d383b Diego Biurrun
        SAMPLE_FMT_S16,SAMPLE_FMT_NONE
2144
    },
2145 e22da6b6 Robert Swain
    .channel_layouts = aac_channel_layout,
2146 71e9a1b8 Robert Swain
};