GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aacdec_template.c Lines: 1466 1825 80.3 %
Date: 2019-11-18 18:00:01 Branches: 922 1271 72.5 %

Line Branch Exec Source
1
/*
2
 * AAC decoder
3
 * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
4
 * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
5
 * Copyright (c) 2008-2013 Alex Converse <alex.converse@gmail.com>
6
 *
7
 * AAC LATM decoder
8
 * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
9
 * Copyright (c) 2010      Janne Grunau <janne-libav@jannau.net>
10
 *
11
 * AAC decoder fixed-point implementation
12
 * Copyright (c) 2013
13
 *      MIPS Technologies, Inc., California.
14
 *
15
 * This file is part of FFmpeg.
16
 *
17
 * FFmpeg is free software; you can redistribute it and/or
18
 * modify it under the terms of the GNU Lesser General Public
19
 * License as published by the Free Software Foundation; either
20
 * version 2.1 of the License, or (at your option) any later version.
21
 *
22
 * FFmpeg is distributed in the hope that it will be useful,
23
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
 * Lesser General Public License for more details.
26
 *
27
 * You should have received a copy of the GNU Lesser General Public
28
 * License along with FFmpeg; if not, write to the Free Software
29
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30
 */
31
32
/**
33
 * @file
34
 * AAC decoder
35
 * @author Oded Shimon  ( ods15 ods15 dyndns org )
36
 * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
37
 *
38
 * AAC decoder fixed-point implementation
39
 * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
40
 * @author Nedeljko Babic ( nedeljko.babic imgtec com )
41
 */
42
43
/*
44
 * supported tools
45
 *
46
 * Support?                     Name
47
 * N (code in SoC repo)         gain control
48
 * Y                            block switching
49
 * Y                            window shapes - standard
50
 * N                            window shapes - Low Delay
51
 * Y                            filterbank - standard
52
 * N (code in SoC repo)         filterbank - Scalable Sample Rate
53
 * Y                            Temporal Noise Shaping
54
 * Y                            Long Term Prediction
55
 * Y                            intensity stereo
56
 * Y                            channel coupling
57
 * Y                            frequency domain prediction
58
 * Y                            Perceptual Noise Substitution
59
 * Y                            Mid/Side stereo
60
 * N                            Scalable Inverse AAC Quantization
61
 * N                            Frequency Selective Switch
62
 * N                            upsampling filter
63
 * Y                            quantization & coding - AAC
64
 * N                            quantization & coding - TwinVQ
65
 * N                            quantization & coding - BSAC
66
 * N                            AAC Error Resilience tools
67
 * N                            Error Resilience payload syntax
68
 * N                            Error Protection tool
69
 * N                            CELP
70
 * N                            Silence Compression
71
 * N                            HVXC
72
 * N                            HVXC 4kbits/s VR
73
 * N                            Structured Audio tools
74
 * N                            Structured Audio Sample Bank Format
75
 * N                            MIDI
76
 * N                            Harmonic and Individual Lines plus Noise
77
 * N                            Text-To-Speech Interface
78
 * Y                            Spectral Band Replication
79
 * Y (not in this code)         Layer-1
80
 * Y (not in this code)         Layer-2
81
 * Y (not in this code)         Layer-3
82
 * N                            SinuSoidal Coding (Transient, Sinusoid, Noise)
83
 * Y                            Parametric Stereo
84
 * N                            Direct Stream Transfer
85
 * Y  (not in fixed point code) Enhanced AAC Low Delay (ER AAC ELD)
86
 *
87
 * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
88
 *       - HE AAC v2 comprises LC AAC with Spectral Band Replication and
89
           Parametric Stereo.
90
 */
91
92
#include "libavutil/thread.h"
93
94
static VLC vlc_scalefactors;
95
static VLC vlc_spectral[11];
96
97
static int output_configure(AACContext *ac,
98
                            uint8_t layout_map[MAX_ELEM_ID*4][3], int tags,
99
                            enum OCStatus oc_type, int get_new_frame);
100
101
#define overread_err "Input buffer exhausted before END element found\n"
102
103
528
static int count_channels(uint8_t (*layout)[3], int tags)
104
{
105
528
    int i, sum = 0;
106
1618
    for (i = 0; i < tags; i++) {
107
1090
        int syn_ele = layout[i][0];
108
1090
        int pos     = layout[i][2];
109
2180
        sum += (1 + (syn_ele == TYPE_CPE)) *
110

1090
               (pos != AAC_CHANNEL_OFF && pos != AAC_CHANNEL_CC);
111
    }
112
528
    return sum;
113
}
114
115
/**
116
 * Check for the channel element in the current channel position configuration.
117
 * If it exists, make sure the appropriate element is allocated and map the
118
 * channel order to match the internal FFmpeg channel layout.
119
 *
120
 * @param   che_pos current channel position configuration
121
 * @param   type channel element type
122
 * @param   id channel element id
123
 * @param   channels count of the number of channels in the configuration
124
 *
125
 * @return  Returns error status. 0 - OK, !0 - error
126
 */
127
4582
static av_cold int che_configure(AACContext *ac,
128
                                 enum ChannelPosition che_pos,
129
                                 int type, int id, int *channels)
130
{
131
4582
    if (*channels >= MAX_CHANNELS)
132
        return AVERROR_INVALIDDATA;
133
4582
    if (che_pos) {
134
4582
        if (!ac->che[type][id]) {
135
347
            if (!(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
136
                return AVERROR(ENOMEM);
137
347
            AAC_RENAME(ff_aac_sbr_ctx_init)(ac, &ac->che[type][id]->sbr, type);
138
        }
139
4582
        if (type != TYPE_CCE) {
140


4574
            if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
141
                av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
142
                return AVERROR_INVALIDDATA;
143
            }
144
4574
            ac->output_element[(*channels)++] = &ac->che[type][id]->ch[0];
145

4574
            if (type == TYPE_CPE ||
146
773
                (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
147
4100
                ac->output_element[(*channels)++] = &ac->che[type][id]->ch[1];
148
            }
149
        }
150
    } else {
151
        if (ac->che[type][id])
152
            AAC_RENAME(ff_aac_sbr_ctx_close)(&ac->che[type][id]->sbr);
153
        av_freep(&ac->che[type][id]);
154
    }
155
4582
    return 0;
156
}
157
158
49857
static int frame_configure_elements(AVCodecContext *avctx)
159
{
160
49857
    AACContext *ac = avctx->priv_data;
161
    int type, id, ch, ret;
162
163
    /* set channel pointers to internal buffers by default */
164
249285
    for (type = 0; type < 4; type++) {
165
3390276
        for (id = 0; id < MAX_ELEM_ID; id++) {
166
3190848
            ChannelElement *che = ac->che[type][id];
167
3190848
            if (che) {
168
63237
                che->ch[0].ret = che->ch[0].ret_buf;
169
63237
                che->ch[1].ret = che->ch[1].ret_buf;
170
            }
171
        }
172
    }
173
174
    /* get output buffer */
175
49857
    av_frame_unref(ac->frame);
176
49857
    if (!avctx->channels)
177
        return 1;
178
179
49857
    ac->frame->nb_samples = 2048;
180
49857
    if ((ret = ff_get_buffer(avctx, ac->frame, 0)) < 0)
181
        return ret;
182
183
    /* map output channel pointers to AVFrame data */
184
144264
    for (ch = 0; ch < avctx->channels; ch++) {
185
94407
        if (ac->output_element[ch])
186
94407
            ac->output_element[ch]->ret = (INTFLOAT *)ac->frame->extended_data[ch];
187
    }
188
189
49857
    return 0;
190
}
191
192
struct elem_to_channel {
193
    uint64_t av_position;
194
    uint8_t syn_ele;
195
    uint8_t elem_id;
196
    uint8_t aac_position;
197
};
198
199
3738
static int assign_pair(struct elem_to_channel e2c_vec[MAX_ELEM_ID],
200
                       uint8_t (*layout_map)[3], int offset, uint64_t left,
201
                       uint64_t right, int pos)
202
{
203
3738
    if (layout_map[offset][0] == TYPE_CPE) {
204
3734
        e2c_vec[offset] = (struct elem_to_channel) {
205
3734
            .av_position  = left | right,
206
            .syn_ele      = TYPE_CPE,
207
3734
            .elem_id      = layout_map[offset][1],
208
            .aac_position = pos
209
        };
210
3734
        return 1;
211
    } else {
212
4
        e2c_vec[offset] = (struct elem_to_channel) {
213
            .av_position  = left,
214
            .syn_ele      = TYPE_SCE,
215
4
            .elem_id      = layout_map[offset][1],
216
            .aac_position = pos
217
        };
218
4
        e2c_vec[offset + 1] = (struct elem_to_channel) {
219
            .av_position  = right,
220
            .syn_ele      = TYPE_SCE,
221
4
            .elem_id      = layout_map[offset + 1][1],
222
            .aac_position = pos
223
        };
224
4
        return 2;
225
    }
226
}
227
228
13095
static int count_paired_channels(uint8_t (*layout_map)[3], int tags, int pos,
229
                                 int *current)
230
{
231
13095
    int num_pos_channels = 0;
232
13095
    int first_cpe        = 0;
233
13095
    int sce_parity       = 0;
234
    int i;
235
17602
    for (i = *current; i < tags; i++) {
236
4708
        if (layout_map[i][2] != pos)
237
201
            break;
238
4507
        if (layout_map[i][0] == TYPE_CPE) {
239
3734
            if (sce_parity) {
240

71
                if (pos == AAC_CHANNEL_FRONT && !first_cpe) {
241
71
                    sce_parity = 0;
242
                } else {
243
                    return -1;
244
                }
245
            }
246
3734
            num_pos_channels += 2;
247
3734
            first_cpe         = 1;
248
        } else {
249
773
            num_pos_channels++;
250
773
            sce_parity ^= 1;
251
        }
252
    }
253

13095
    if (sce_parity &&
254

694
        ((pos == AAC_CHANNEL_FRONT && first_cpe) || pos == AAC_CHANNEL_SIDE))
255
        return -1;
256
13095
    *current = i;
257
13095
    return num_pos_channels;
258
}
259
260
4365
static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
261
{
262
    int i, n, total_non_cc_elements;
263
4365
    struct elem_to_channel e2c_vec[4 * MAX_ELEM_ID] = { { 0 } };
264
    int num_front_channels, num_side_channels, num_back_channels;
265
    uint64_t layout;
266
267
4365
    if (FF_ARRAY_ELEMS(e2c_vec) < tags)
268
        return 0;
269
270
4365
    i = 0;
271
    num_front_channels =
272
4365
        count_paired_channels(layout_map, tags, AAC_CHANNEL_FRONT, &i);
273
4365
    if (num_front_channels < 0)
274
        return 0;
275
    num_side_channels =
276
4365
        count_paired_channels(layout_map, tags, AAC_CHANNEL_SIDE, &i);
277
4365
    if (num_side_channels < 0)
278
        return 0;
279
    num_back_channels =
280
4365
        count_paired_channels(layout_map, tags, AAC_CHANNEL_BACK, &i);
281
4365
    if (num_back_channels < 0)
282
        return 0;
283
284

4365
    if (num_side_channels == 0 && num_back_channels >= 4) {
285
        num_side_channels = 2;
286
        num_back_channels -= 2;
287
    }
288
289
4365
    i = 0;
290
4365
    if (num_front_channels & 1) {
291
765
        e2c_vec[i] = (struct elem_to_channel) {
292
            .av_position  = AV_CH_FRONT_CENTER,
293
            .syn_ele      = TYPE_SCE,
294
765
            .elem_id      = layout_map[i][1],
295
            .aac_position = AAC_CHANNEL_FRONT
296
        };
297
765
        i++;
298
765
        num_front_channels--;
299
    }
300
4365
    if (num_front_channels >= 4) {
301
8
        i += assign_pair(e2c_vec, layout_map, i,
302
                         AV_CH_FRONT_LEFT_OF_CENTER,
303
                         AV_CH_FRONT_RIGHT_OF_CENTER,
304
                         AAC_CHANNEL_FRONT);
305
8
        num_front_channels -= 2;
306
    }
307
4365
    if (num_front_channels >= 2) {
308
3671
        i += assign_pair(e2c_vec, layout_map, i,
309
                         AV_CH_FRONT_LEFT,
310
                         AV_CH_FRONT_RIGHT,
311
                         AAC_CHANNEL_FRONT);
312
3671
        num_front_channels -= 2;
313
    }
314
4365
    while (num_front_channels >= 2) {
315
        i += assign_pair(e2c_vec, layout_map, i,
316
                         UINT64_MAX,
317
                         UINT64_MAX,
318
                         AAC_CHANNEL_FRONT);
319
        num_front_channels -= 2;
320
    }
321
322
4365
    if (num_side_channels >= 2) {
323
        i += assign_pair(e2c_vec, layout_map, i,
324
                         AV_CH_SIDE_LEFT,
325
                         AV_CH_SIDE_RIGHT,
326
                         AAC_CHANNEL_FRONT);
327
        num_side_channels -= 2;
328
    }
329
4365
    while (num_side_channels >= 2) {
330
        i += assign_pair(e2c_vec, layout_map, i,
331
                         UINT64_MAX,
332
                         UINT64_MAX,
333
                         AAC_CHANNEL_SIDE);
334
        num_side_channels -= 2;
335
    }
336
337
4365
    while (num_back_channels >= 4) {
338
        i += assign_pair(e2c_vec, layout_map, i,
339
                         UINT64_MAX,
340
                         UINT64_MAX,
341
                         AAC_CHANNEL_BACK);
342
        num_back_channels -= 2;
343
    }
344
4365
    if (num_back_channels >= 2) {
345
59
        i += assign_pair(e2c_vec, layout_map, i,
346
                         AV_CH_BACK_LEFT,
347
                         AV_CH_BACK_RIGHT,
348
                         AAC_CHANNEL_BACK);
349
59
        num_back_channels -= 2;
350
    }
351
4365
    if (num_back_channels) {
352
        e2c_vec[i] = (struct elem_to_channel) {
353
            .av_position  = AV_CH_BACK_CENTER,
354
            .syn_ele      = TYPE_SCE,
355
            .elem_id      = layout_map[i][1],
356
            .aac_position = AAC_CHANNEL_BACK
357
        };
358
        i++;
359
        num_back_channels--;
360
    }
361
362

4365
    if (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
363
67
        e2c_vec[i] = (struct elem_to_channel) {
364
            .av_position  = AV_CH_LOW_FREQUENCY,
365
            .syn_ele      = TYPE_LFE,
366
67
            .elem_id      = layout_map[i][1],
367
            .aac_position = AAC_CHANNEL_LFE
368
        };
369
67
        i++;
370
    }
371

4365
    while (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
372
        e2c_vec[i] = (struct elem_to_channel) {
373
            .av_position  = UINT64_MAX,
374
            .syn_ele      = TYPE_LFE,
375
            .elem_id      = layout_map[i][1],
376
            .aac_position = AAC_CHANNEL_LFE
377
        };
378
        i++;
379
    }
380
381
    // Must choose a stable sort
382
4365
    total_non_cc_elements = n = i;
383
    do {
384
4444
        int next_n = 0;
385
4787
        for (i = 1; i < n; i++)
386
343
            if (e2c_vec[i - 1].av_position > e2c_vec[i].av_position) {
387
146
                FFSWAP(struct elem_to_channel, e2c_vec[i - 1], e2c_vec[i]);
388
146
                next_n = i;
389
            }
390
4444
        n = next_n;
391
4444
    } while (n > 0);
392
393
4365
    layout = 0;
394
8939
    for (i = 0; i < total_non_cc_elements; i++) {
395
4574
        layout_map[i][0] = e2c_vec[i].syn_ele;
396
4574
        layout_map[i][1] = e2c_vec[i].elem_id;
397
4574
        layout_map[i][2] = e2c_vec[i].aac_position;
398
4574
        if (e2c_vec[i].av_position != UINT64_MAX) {
399
4574
            layout |= e2c_vec[i].av_position;
400
        }
401
    }
402
403
4365
    return layout;
404
}
405
406
/**
407
 * Save current output configuration if and only if it has been locked.
408
 */
409
4118
static int push_output_configuration(AACContext *ac) {
410
4118
    int pushed = 0;
411
412

4118
    if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
413
4118
        ac->oc[0] = ac->oc[1];
414
4118
        pushed = 1;
415
    }
416
4118
    ac->oc[1].status = OC_NONE;
417
4118
    return pushed;
418
}
419
420
/**
421
 * Restore the previous output configuration if and only if the current
422
 * configuration is unlocked.
423
 */
424
static void pop_output_configuration(AACContext *ac) {
425
    if (ac->oc[1].status != OC_LOCKED && ac->oc[0].status != OC_NONE) {
426
        ac->oc[1] = ac->oc[0];
427
        ac->avctx->channels = ac->oc[1].channels;
428
        ac->avctx->channel_layout = ac->oc[1].channel_layout;
429
        output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
430
                         ac->oc[1].status, 0);
431
    }
432
}
433
434
/**
435
 * Configure output channel order based on the current program
436
 * configuration element.
437
 *
438
 * @return  Returns error status. 0 - OK, !0 - error
439
 */
440
4365
static int output_configure(AACContext *ac,
441
                            uint8_t layout_map[MAX_ELEM_ID * 4][3], int tags,
442
                            enum OCStatus oc_type, int get_new_frame)
443
{
444
4365
    AVCodecContext *avctx = ac->avctx;
445
4365
    int i, channels = 0, ret;
446
4365
    uint64_t layout = 0;
447
4365
    uint8_t id_map[TYPE_END][MAX_ELEM_ID] = {{ 0 }};
448
4365
    uint8_t type_counts[TYPE_END] = { 0 };
449
450
4365
    if (ac->oc[1].layout_map != layout_map) {
451
4353
        memcpy(ac->oc[1].layout_map, layout_map, tags * sizeof(layout_map[0]));
452
4353
        ac->oc[1].layout_map_tags = tags;
453
    }
454
8947
    for (i = 0; i < tags; i++) {
455
4582
        int type =         layout_map[i][0];
456
4582
        int id =           layout_map[i][1];
457
4582
        id_map[type][id] = type_counts[type]++;
458
4582
        if (id_map[type][id] >= MAX_ELEM_ID) {
459
            avpriv_request_sample(ac->avctx, "Too large remapped id");
460
            return AVERROR_PATCHWELCOME;
461
        }
462
    }
463
    // Try to sniff a reasonable channel order, otherwise output the
464
    // channels in the order the PCE declared them.
465
4365
    if (avctx->request_channel_layout != AV_CH_LAYOUT_NATIVE)
466
4365
        layout = sniff_channel_order(layout_map, tags);
467
8947
    for (i = 0; i < tags; i++) {
468
4582
        int type =     layout_map[i][0];
469
4582
        int id =       layout_map[i][1];
470
4582
        int iid =      id_map[type][id];
471
4582
        int position = layout_map[i][2];
472
        // Allocate or free elements depending on if they are in the
473
        // current program configuration.
474
4582
        ret = che_configure(ac, position, type, iid, &channels);
475
4582
        if (ret < 0)
476
            return ret;
477
4582
        ac->tag_che_map[type][id] = ac->che[type][iid];
478
    }
479

4365
    if (ac->oc[1].m4ac.ps == 1 && channels == 2) {
480
366
        if (layout == AV_CH_FRONT_CENTER) {
481
366
            layout = AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT;
482
        } else {
483
            layout = 0;
484
        }
485
    }
486
487
4365
    if (layout) avctx->channel_layout = layout;
488
4365
                            ac->oc[1].channel_layout = layout;
489
4365
    avctx->channels       = ac->oc[1].channels       = channels;
490
4365
    ac->oc[1].status = oc_type;
491
492
4365
    if (get_new_frame) {
493
12
        if ((ret = frame_configure_elements(ac->avctx)) < 0)
494
            return ret;
495
    }
496
497
4365
    return 0;
498
}
499
500
static void flush(AVCodecContext *avctx)
501
{
502
    AACContext *ac= avctx->priv_data;
503
    int type, i, j;
504
505
    for (type = 3; type >= 0; type--) {
506
        for (i = 0; i < MAX_ELEM_ID; i++) {
507
            ChannelElement *che = ac->che[type][i];
508
            if (che) {
509
                for (j = 0; j <= 1; j++) {
510
                    memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
511
                }
512
            }
513
        }
514
    }
515
}
516
517
/**
518
 * Set up channel positions based on a default channel configuration
519
 * as specified in table 1.17.
520
 *
521
 * @return  Returns error status. 0 - OK, !0 - error
522
 */
523
4631
static int set_default_channel_config(AVCodecContext *avctx,
524
                                      uint8_t (*layout_map)[3],
525
                                      int *tags,
526
                                      int channel_config)
527
{
528


4631
    if (channel_config < 1 || (channel_config > 7 && channel_config < 11) ||
529
        channel_config > 12) {
530
        av_log(avctx, AV_LOG_ERROR,
531
               "invalid default channel configuration (%d)\n",
532
               channel_config);
533
        return AVERROR_INVALIDDATA;
534
    }
535
4631
    *tags = tags_per_config[channel_config];
536
4631
    memcpy(layout_map, aac_channel_layout_map[channel_config - 1],
537
4631
           *tags * sizeof(*layout_map));
538
539
    /*
540
     * AAC specification has 7.1(wide) as a default layout for 8-channel streams.
541
     * However, at least Nero AAC encoder encodes 7.1 streams using the default
542
     * channel config 7, mapping the side channels of the original audio stream
543
     * to the second AAC_CHANNEL_FRONT pair in the AAC stream. Similarly, e.g. FAAD
544
     * decodes the second AAC_CHANNEL_FRONT pair as side channels, therefore decoding
545
     * the incorrect streams as if they were correct (and as the encoder intended).
546
     *
547
     * As actual intended 7.1(wide) streams are very rare, default to assuming a
548
     * 7.1 layout was intended.
549
     */
550

4631
    if (channel_config == 7 && avctx->strict_std_compliance < FF_COMPLIANCE_STRICT) {
551
        av_log(avctx, AV_LOG_INFO, "Assuming an incorrectly encoded 7.1 channel layout"
552
               " instead of a spec-compliant 7.1(wide) layout, use -strict %d to decode"
553
               " according to the specification instead.\n", FF_COMPLIANCE_STRICT);
554
        layout_map[2][2] = AAC_CHANNEL_SIDE;
555
    }
556
557
4631
    return 0;
558
}
559
560
62891
static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
561
{
562
    /* For PCE based channel configurations map the channels solely based
563
     * on tags. */
564
62891
    if (!ac->oc[1].m4ac.chan_config) {
565
24124
        return ac->tag_che_map[type][elem_id];
566
    }
567
    // Allow single CPE stereo files to be signalled with mono configuration.
568

38767
    if (!ac->tags_mapped && type == TYPE_CPE &&
569
20533
        ac->oc[1].m4ac.chan_config == 1) {
570
        uint8_t layout_map[MAX_ELEM_ID*4][3];
571
        int layout_map_tags;
572
        push_output_configuration(ac);
573
574
        av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
575
576
        if (set_default_channel_config(ac->avctx, layout_map,
577
                                       &layout_map_tags, 2) < 0)
578
            return NULL;
579
        if (output_configure(ac, layout_map, layout_map_tags,
580
                             OC_TRIAL_FRAME, 1) < 0)
581
            return NULL;
582
583
        ac->oc[1].m4ac.chan_config = 2;
584
        ac->oc[1].m4ac.ps = 0;
585
    }
586
    // And vice-versa
587

38767
    if (!ac->tags_mapped && type == TYPE_SCE &&
588
15774
        ac->oc[1].m4ac.chan_config == 2) {
589
        uint8_t layout_map[MAX_ELEM_ID * 4][3];
590
        int layout_map_tags;
591
        push_output_configuration(ac);
592
593
        av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
594
595
        if (set_default_channel_config(ac->avctx, layout_map,
596
                                       &layout_map_tags, 1) < 0)
597
            return NULL;
598
        if (output_configure(ac, layout_map, layout_map_tags,
599
                             OC_TRIAL_FRAME, 1) < 0)
600
            return NULL;
601
602
        ac->oc[1].m4ac.chan_config = 1;
603
        if (ac->oc[1].m4ac.sbr)
604
            ac->oc[1].m4ac.ps = -1;
605
    }
606
    /* For indexed channel configurations map the channels solely based
607
     * on position. */
608


38767
    switch (ac->oc[1].m4ac.chan_config) {
609
    case 12:
610
    case 7:
611
        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
612
            ac->tags_mapped++;
613
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
614
        }
615
    case 11:
616
        if (ac->tags_mapped == 2 &&
617
            ac->oc[1].m4ac.chan_config == 11 &&
618
            type == TYPE_SCE) {
619
            ac->tags_mapped++;
620
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
621
        }
622
    case 6:
623
        /* Some streams incorrectly code 5.1 audio as
624
         * SCE[0] CPE[0] CPE[1] SCE[1]
625
         * instead of
626
         * SCE[0] CPE[0] CPE[1] LFE[0].
627
         * If we seem to have encountered such a stream, transfer
628
         * the LFE[0] element to the SCE[1]'s mapping */
629

3280
        if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
630

820
            if (!ac->warned_remapping_once && (type != TYPE_LFE || elem_id != 0)) {
631
                av_log(ac->avctx, AV_LOG_WARNING,
632
                   "This stream seems to incorrectly report its last channel as %s[%d], mapping to LFE[0]\n",
633
                   type == TYPE_SCE ? "SCE" : "LFE", elem_id);
634
                ac->warned_remapping_once++;
635
            }
636
820
            ac->tags_mapped++;
637
820
            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
638
        }
639
    case 5:
640

2460
        if (ac->tags_mapped == 2 && type == TYPE_CPE) {
641
820
            ac->tags_mapped++;
642
820
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
643
        }
644
    case 4:
645
        /* Some streams incorrectly code 4.0 audio as
646
         * SCE[0] CPE[0] LFE[0]
647
         * instead of
648
         * SCE[0] CPE[0] SCE[1].
649
         * If we seem to have encountered such a stream, transfer
650
         * the SCE[1] element to the LFE[0]'s mapping */
651

1640
        if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
652
            if (!ac->warned_remapping_once && (type != TYPE_SCE || elem_id != 1)) {
653
                av_log(ac->avctx, AV_LOG_WARNING,
654
                   "This stream seems to incorrectly report its last channel as %s[%d], mapping to SCE[1]\n",
655
                   type == TYPE_SCE ? "SCE" : "LFE", elem_id);
656
                ac->warned_remapping_once++;
657
            }
658
            ac->tags_mapped++;
659
            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_SCE][1];
660
        }
661
1640
        if (ac->tags_mapped == 2 &&
662
            ac->oc[1].m4ac.chan_config == 4 &&
663
            type == TYPE_SCE) {
664
            ac->tags_mapped++;
665
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
666
        }
667
    case 3:
668
    case 2:
669

22173
        if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) &&
670
            type == TYPE_CPE) {
671
21353
            ac->tags_mapped++;
672
21353
            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
673
820
        } else if (ac->oc[1].m4ac.chan_config == 2) {
674
            return NULL;
675
        }
676
    case 1:
677

15774
        if (!ac->tags_mapped && type == TYPE_SCE) {
678
15774
            ac->tags_mapped++;
679
15774
            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
680
        }
681
    default:
682
        return NULL;
683
    }
684
}
685
686
/**
687
 * Decode an array of 4 bit element IDs, optionally interleaved with a
688
 * stereo/mono switching bit.
689
 *
690
 * @param type speaker type/position for these channels
691
 */
692
215
static void decode_channel_map(uint8_t layout_map[][3],
693
                               enum ChannelPosition type,
694
                               GetBitContext *gb, int n)
695
{
696
310
    while (n--) {
697
        enum RawDataBlockType syn_ele;
698

95
        switch (type) {
699
75
        case AAC_CHANNEL_FRONT:
700
        case AAC_CHANNEL_BACK:
701
        case AAC_CHANNEL_SIDE:
702
75
            syn_ele = get_bits1(gb);
703
75
            break;
704
8
        case AAC_CHANNEL_CC:
705
8
            skip_bits1(gb);
706
8
            syn_ele = TYPE_CCE;
707
8
            break;
708
12
        case AAC_CHANNEL_LFE:
709
12
            syn_ele = TYPE_LFE;
710
12
            break;
711
        default:
712
            // AAC_CHANNEL_OFF has no channel map
713
            av_assert0(0);
714
        }
715
95
        layout_map[0][0] = syn_ele;
716
95
        layout_map[0][1] = get_bits(gb, 4);
717
95
        layout_map[0][2] = type;
718
95
        layout_map++;
719
    }
720
215
}
721
722
43
static inline void relative_align_get_bits(GetBitContext *gb,
723
                                           int reference_position) {
724
43
    int n = (reference_position - get_bits_count(gb) & 7);
725
43
    if (n)
726
39
        skip_bits(gb, n);
727
43
}
728
729
/**
730
 * Decode program configuration element; reference: table 4.2.
731
 *
732
 * @return  Returns error status. 0 - OK, !0 - error
733
 */
734
43
static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
735
                      uint8_t (*layout_map)[3],
736
                      GetBitContext *gb, int byte_align_ref)
737
{
738
    int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
739
    int sampling_index;
740
    int comment_len;
741
    int tags;
742
743
43
    skip_bits(gb, 2);  // object_type
744
745
43
    sampling_index = get_bits(gb, 4);
746
43
    if (m4ac->sampling_index != sampling_index)
747
        av_log(avctx, AV_LOG_WARNING,
748
               "Sample rate index in program config element does not "
749
               "match the sample rate index configured by the container.\n");
750
751
43
    num_front       = get_bits(gb, 4);
752
43
    num_side        = get_bits(gb, 4);
753
43
    num_back        = get_bits(gb, 4);
754
43
    num_lfe         = get_bits(gb, 2);
755
43
    num_assoc_data  = get_bits(gb, 3);
756
43
    num_cc          = get_bits(gb, 4);
757
758
43
    if (get_bits1(gb))
759
        skip_bits(gb, 4); // mono_mixdown_tag
760
43
    if (get_bits1(gb))
761
        skip_bits(gb, 4); // stereo_mixdown_tag
762
763
43
    if (get_bits1(gb))
764
        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
765
766
43
    if (get_bits_left(gb) < 5 * (num_front + num_side + num_back + num_cc) + 4 *(num_lfe + num_assoc_data + num_cc)) {
767
        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
768
        return -1;
769
    }
770
43
    decode_channel_map(layout_map       , AAC_CHANNEL_FRONT, gb, num_front);
771
43
    tags = num_front;
772
43
    decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE,  gb, num_side);
773
43
    tags += num_side;
774
43
    decode_channel_map(layout_map + tags, AAC_CHANNEL_BACK,  gb, num_back);
775
43
    tags += num_back;
776
43
    decode_channel_map(layout_map + tags, AAC_CHANNEL_LFE,   gb, num_lfe);
777
43
    tags += num_lfe;
778
779
43
    skip_bits_long(gb, 4 * num_assoc_data);
780
781
43
    decode_channel_map(layout_map + tags, AAC_CHANNEL_CC,    gb, num_cc);
782
43
    tags += num_cc;
783
784
43
    relative_align_get_bits(gb, byte_align_ref);
785
786
    /* comment field, first byte is length */
787
43
    comment_len = get_bits(gb, 8) * 8;
788
43
    if (get_bits_left(gb) < comment_len) {
789
        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
790
        return AVERROR_INVALIDDATA;
791
    }
792
43
    skip_bits_long(gb, comment_len);
793
43
    return tags;
794
}
795
796
/**
797
 * Decode GA "General Audio" specific configuration; reference: table 4.1.
798
 *
799
 * @param   ac          pointer to AACContext, may be null
800
 * @param   avctx       pointer to AVCCodecContext, used for logging
801
 *
802
 * @return  Returns error status. 0 - OK, !0 - error
803
 */
804
528
static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
805
                                     GetBitContext *gb,
806
                                     int get_bit_alignment,
807
                                     MPEG4AudioConfig *m4ac,
808
                                     int channel_config)
809
{
810
    int extension_flag, ret, ep_config, res_flags;
811
    uint8_t layout_map[MAX_ELEM_ID*4][3];
812
528
    int tags = 0;
813
814
#if USE_FIXED
815
17
    if (get_bits1(gb)) { // frameLengthFlag
816
        avpriv_report_missing_feature(avctx, "Fixed point 960/120 MDCT window");
817
        return AVERROR_PATCHWELCOME;
818
    }
819
17
    m4ac->frame_length_short = 0;
820
#else
821
511
    m4ac->frame_length_short = get_bits1(gb);
822

511
    if (m4ac->frame_length_short && m4ac->sbr == 1) {
823
      avpriv_report_missing_feature(avctx, "SBR with 960 frame length");
824
      if (ac) ac->warned_960_sbr = 1;
825
      m4ac->sbr = 0;
826
      m4ac->ps = 0;
827
    }
828
#endif
829
830
528
    if (get_bits1(gb))       // dependsOnCoreCoder
831
        skip_bits(gb, 14);   // coreCoderDelay
832
528
    extension_flag = get_bits1(gb);
833
834
528
    if (m4ac->object_type == AOT_AAC_SCALABLE ||
835
528
        m4ac->object_type == AOT_ER_AAC_SCALABLE)
836
        skip_bits(gb, 3);     // layerNr
837
838
528
    if (channel_config == 0) {
839
43
        skip_bits(gb, 4);  // element_instance_tag
840
43
        tags = decode_pce(avctx, m4ac, layout_map, gb, get_bit_alignment);
841
43
        if (tags < 0)
842
            return tags;
843
    } else {
844
485
        if ((ret = set_default_channel_config(avctx, layout_map,
845
                                              &tags, channel_config)))
846
            return ret;
847
    }
848
849
528
    if (count_channels(layout_map, tags) > 1) {
850
438
        m4ac->ps = 0;
851

90
    } else if (m4ac->sbr == 1 && m4ac->ps == -1)
852
18
        m4ac->ps = 1;
853
854

528
    if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
855
        return ret;
856
857
528
    if (extension_flag) {
858
4
        switch (m4ac->object_type) {
859
        case AOT_ER_BSAC:
860
            skip_bits(gb, 5);    // numOfSubFrame
861
            skip_bits(gb, 11);   // layer_length
862
            break;
863
4
        case AOT_ER_AAC_LC:
864
        case AOT_ER_AAC_LTP:
865
        case AOT_ER_AAC_SCALABLE:
866
        case AOT_ER_AAC_LD:
867
4
            res_flags = get_bits(gb, 3);
868
4
            if (res_flags) {
869
                avpriv_report_missing_feature(avctx,
870
                                              "AAC data resilience (flags %x)",
871
                                              res_flags);
872
                return AVERROR_PATCHWELCOME;
873
            }
874
4
            break;
875
        }
876
4
        skip_bits1(gb);    // extensionFlag3 (TBD in version 3)
877
    }
878
528
    switch (m4ac->object_type) {
879
4
    case AOT_ER_AAC_LC:
880
    case AOT_ER_AAC_LTP:
881
    case AOT_ER_AAC_SCALABLE:
882
    case AOT_ER_AAC_LD:
883
4
        ep_config = get_bits(gb, 2);
884
4
        if (ep_config) {
885
            avpriv_report_missing_feature(avctx,
886
                                          "epConfig %d", ep_config);
887
            return AVERROR_PATCHWELCOME;
888
        }
889
    }
890
528
    return 0;
891
}
892
893
10
static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx,
894
                                     GetBitContext *gb,
895
                                     MPEG4AudioConfig *m4ac,
896
                                     int channel_config)
897
{
898
    int ret, ep_config, res_flags;
899
    uint8_t layout_map[MAX_ELEM_ID*4][3];
900
10
    int tags = 0;
901
10
    const int ELDEXT_TERM = 0;
902
903
10
    m4ac->ps  = 0;
904
10
    m4ac->sbr = 0;
905
#if USE_FIXED
906
2
    if (get_bits1(gb)) { // frameLengthFlag
907
        avpriv_request_sample(avctx, "960/120 MDCT window");
908
        return AVERROR_PATCHWELCOME;
909
    }
910
#else
911
8
    m4ac->frame_length_short = get_bits1(gb);
912
#endif
913
10
    res_flags = get_bits(gb, 3);
914
10
    if (res_flags) {
915
        avpriv_report_missing_feature(avctx,
916
                                      "AAC data resilience (flags %x)",
917
                                      res_flags);
918
        return AVERROR_PATCHWELCOME;
919
    }
920
921
10
    if (get_bits1(gb)) { // ldSbrPresentFlag
922
        avpriv_report_missing_feature(avctx,
923
                                      "Low Delay SBR");
924
        return AVERROR_PATCHWELCOME;
925
    }
926
927
10
    while (get_bits(gb, 4) != ELDEXT_TERM) {
928
        int len = get_bits(gb, 4);
929
        if (len == 15)
930
            len += get_bits(gb, 8);
931
        if (len == 15 + 255)
932
            len += get_bits(gb, 16);
933
        if (get_bits_left(gb) < len * 8 + 4) {
934
            av_log(avctx, AV_LOG_ERROR, overread_err);
935
            return AVERROR_INVALIDDATA;
936
        }
937
        skip_bits_long(gb, 8 * len);
938
    }
939
940
10
    if ((ret = set_default_channel_config(avctx, layout_map,
941
                                          &tags, channel_config)))
942
        return ret;
943
944

10
    if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
945
        return ret;
946
947
10
    ep_config = get_bits(gb, 2);
948
10
    if (ep_config) {
949
        avpriv_report_missing_feature(avctx,
950
                                      "epConfig %d", ep_config);
951
        return AVERROR_PATCHWELCOME;
952
    }
953
10
    return 0;
954
}
955
956
/**
957
 * Decode audio specific configuration; reference: table 1.13.
958
 *
959
 * @param   ac          pointer to AACContext, may be null
960
 * @param   avctx       pointer to AVCCodecContext, used for logging
961
 * @param   m4ac        pointer to MPEG4AudioConfig, used for parsing
962
 * @param   gb          buffer holding an audio specific config
963
 * @param   get_bit_alignment relative alignment for byte align operations
964
 * @param   sync_extension look for an appended sync extension
965
 *
966
 * @return  Returns error status or number of consumed bits. <0 - error
967
 */
968
538
static int decode_audio_specific_config_gb(AACContext *ac,
969
                                           AVCodecContext *avctx,
970
                                           MPEG4AudioConfig *m4ac,
971
                                           GetBitContext *gb,
972
                                           int get_bit_alignment,
973
                                           int sync_extension)
974
{
975
    int i, ret;
976
538
    GetBitContext gbc = *gb;
977
978
538
    if ((i = ff_mpeg4audio_get_config_gb(m4ac, &gbc, sync_extension, avctx)) < 0)
979
        return AVERROR_INVALIDDATA;
980
981
538
    if (m4ac->sampling_index > 12) {
982
        av_log(avctx, AV_LOG_ERROR,
983
               "invalid sampling rate index %d\n",
984
               m4ac->sampling_index);
985
        return AVERROR_INVALIDDATA;
986
    }
987
538
    if (m4ac->object_type == AOT_ER_AAC_LD &&
988

4
        (m4ac->sampling_index < 3 || m4ac->sampling_index > 7)) {
989
        av_log(avctx, AV_LOG_ERROR,
990
               "invalid low delay sampling rate index %d\n",
991
               m4ac->sampling_index);
992
        return AVERROR_INVALIDDATA;
993
    }
994
995
538
    skip_bits_long(gb, i);
996
997
538
    switch (m4ac->object_type) {
998
528
    case AOT_AAC_MAIN:
999
    case AOT_AAC_LC:
1000
    case AOT_AAC_SSR:
1001
    case AOT_AAC_LTP:
1002
    case AOT_ER_AAC_LC:
1003
    case AOT_ER_AAC_LD:
1004
528
        if ((ret = decode_ga_specific_config(ac, avctx, gb, get_bit_alignment,
1005
                                            m4ac, m4ac->chan_config)) < 0)
1006
            return ret;
1007
528
        break;
1008
10
    case AOT_ER_AAC_ELD:
1009
10
        if ((ret = decode_eld_specific_config(ac, avctx, gb,
1010
                                              m4ac, m4ac->chan_config)) < 0)
1011
            return ret;
1012
10
        break;
1013
    default:
1014
        avpriv_report_missing_feature(avctx,
1015
                                      "Audio object type %s%d",
1016
                                      m4ac->sbr == 1 ? "SBR+" : "",
1017
                                      m4ac->object_type);
1018
        return AVERROR(ENOSYS);
1019
    }
1020
1021
    ff_dlog(avctx,
1022
            "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
1023
            m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
1024
            m4ac->sample_rate, m4ac->sbr,
1025
            m4ac->ps);
1026
1027
538
    return get_bits_count(gb);
1028
}
1029
1030
217
static int decode_audio_specific_config(AACContext *ac,
1031
                                        AVCodecContext *avctx,
1032
                                        MPEG4AudioConfig *m4ac,
1033
                                        const uint8_t *data, int64_t bit_size,
1034
                                        int sync_extension)
1035
{
1036
    int i, ret;
1037
    GetBitContext gb;
1038
1039

217
    if (bit_size < 0 || bit_size > INT_MAX) {
1040
        av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
1041
        return AVERROR_INVALIDDATA;
1042
    }
1043
1044
    ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
1045
1556
    for (i = 0; i < bit_size >> 3; i++)
1046
        ff_dlog(avctx, "%02x ", data[i]);
1047
    ff_dlog(avctx, "\n");
1048
1049
217
    if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
1050
        return ret;
1051
1052
217
    return decode_audio_specific_config_gb(ac, avctx, m4ac, &gb, 0,
1053
                                           sync_extension);
1054
}
1055
1056
/**
1057
 * linear congruential pseudorandom number generator
1058
 *
1059
 * @param   previous_val    pointer to the current state of the generator
1060
 *
1061
 * @return  Returns a 32-bit pseudorandom integer
1062
 */
1063
5948804
static av_always_inline int lcg_random(unsigned previous_val)
1064
{
1065
5948804
    union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
1066
5948804
    return v.s;
1067
}
1068
1069
40
static void reset_all_predictors(PredictorState *ps)
1070
{
1071
    int i;
1072
26920
    for (i = 0; i < MAX_PREDICTORS; i++)
1073
26880
        reset_predict_state(&ps[i]);
1074
40
}
1075
1076
59
static int sample_rate_idx (int rate)
1077
{
1078
59
         if (92017 <= rate) return 0;
1079
59
    else if (75132 <= rate) return 1;
1080
59
    else if (55426 <= rate) return 2;
1081
59
    else if (46009 <= rate) return 3;
1082
58
    else if (37566 <= rate) return 4;
1083
42
    else if (27713 <= rate) return 5;
1084
39
    else if (23004 <= rate) return 6;
1085
39
    else if (18783 <= rate) return 7;
1086
39
    else if (13856 <= rate) return 8;
1087
35
    else if (11502 <= rate) return 9;
1088
35
    else if (9391  <= rate) return 10;
1089
35
    else                    return 11;
1090
}
1091
1092
516
static void reset_predictor_group(PredictorState *ps, int group_num)
1093
{
1094
    int i;
1095
12141
    for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
1096
11625
        reset_predict_state(&ps[i]);
1097
516
}
1098
1099
#define AAC_INIT_VLC_STATIC(num, size)                                     \
1100
    INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num],     \
1101
         ff_aac_spectral_bits[num], sizeof(ff_aac_spectral_bits[num][0]),  \
1102
                                    sizeof(ff_aac_spectral_bits[num][0]),  \
1103
        ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), \
1104
                                    sizeof(ff_aac_spectral_codes[num][0]), \
1105
        size);
1106
1107
static void aacdec_init(AACContext *ac);
1108
1109
164
static av_cold void aac_static_table_init(void)
1110
{
1111
164
    AAC_INIT_VLC_STATIC( 0, 304);
1112
164
    AAC_INIT_VLC_STATIC( 1, 270);
1113
164
    AAC_INIT_VLC_STATIC( 2, 550);
1114
164
    AAC_INIT_VLC_STATIC( 3, 300);
1115
164
    AAC_INIT_VLC_STATIC( 4, 328);
1116
164
    AAC_INIT_VLC_STATIC( 5, 294);
1117
164
    AAC_INIT_VLC_STATIC( 6, 306);
1118
164
    AAC_INIT_VLC_STATIC( 7, 268);
1119
164
    AAC_INIT_VLC_STATIC( 8, 510);
1120
164
    AAC_INIT_VLC_STATIC( 9, 366);
1121
164
    AAC_INIT_VLC_STATIC(10, 462);
1122
1123
164
    AAC_RENAME(ff_aac_sbr_init)();
1124
1125
164
    ff_aac_tableinit();
1126
1127
164
    INIT_VLC_STATIC(&vlc_scalefactors, 7,
1128
                    FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
1129
                    ff_aac_scalefactor_bits,
1130
                    sizeof(ff_aac_scalefactor_bits[0]),
1131
                    sizeof(ff_aac_scalefactor_bits[0]),
1132
                    ff_aac_scalefactor_code,
1133
                    sizeof(ff_aac_scalefactor_code[0]),
1134
                    sizeof(ff_aac_scalefactor_code[0]),
1135
                    352);
1136
1137
    // window initialization
1138
164
    AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_long_1024), 4.0, 1024);
1139
164
    AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_short_128), 6.0, 128);
1140
#if !USE_FIXED
1141
148
    AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_long_960), 4.0, 960);
1142
148
    AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_short_120), 6.0, 120);
1143
148
    AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_960), 960);
1144
148
    AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_120), 120);
1145
#endif
1146
164
    AAC_RENAME(ff_init_ff_sine_windows)(10);
1147
164
    AAC_RENAME(ff_init_ff_sine_windows)( 9);
1148
164
    AAC_RENAME(ff_init_ff_sine_windows)( 7);
1149
1150
164
    AAC_RENAME(ff_cbrt_tableinit)();
1151
164
}
1152
1153
static AVOnce aac_table_init = AV_ONCE_INIT;
1154
1155
269
static av_cold int aac_decode_init(AVCodecContext *avctx)
1156
{
1157
269
    AACContext *ac = avctx->priv_data;
1158
    int ret;
1159
1160
269
    if (avctx->sample_rate > 96000)
1161
        return AVERROR_INVALIDDATA;
1162
1163
269
    ret = ff_thread_once(&aac_table_init, &aac_static_table_init);
1164
269
    if (ret != 0)
1165
        return AVERROR_UNKNOWN;
1166
1167
269
    ac->avctx = avctx;
1168
269
    ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
1169
1170
269
    aacdec_init(ac);
1171
#if USE_FIXED
1172
19
    avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1173
#else
1174
250
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1175
#endif /* USE_FIXED */
1176
1177
269
    if (avctx->extradata_size > 0) {
1178
210
        if ((ret = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
1179
210
                                                avctx->extradata,
1180
210
                                                avctx->extradata_size * 8LL,
1181
                                                1)) < 0)
1182
            return ret;
1183
    } else {
1184
        int sr, i;
1185
        uint8_t layout_map[MAX_ELEM_ID*4][3];
1186
        int layout_map_tags;
1187
1188
59
        sr = sample_rate_idx(avctx->sample_rate);
1189
59
        ac->oc[1].m4ac.sampling_index = sr;
1190
59
        ac->oc[1].m4ac.channels = avctx->channels;
1191
59
        ac->oc[1].m4ac.sbr = -1;
1192
59
        ac->oc[1].m4ac.ps = -1;
1193
1194
107
        for (i = 0; i < FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++)
1195
107
            if (ff_mpeg4audio_channels[i] == avctx->channels)
1196
59
                break;
1197
59
        if (i == FF_ARRAY_ELEMS(ff_mpeg4audio_channels)) {
1198
            i = 0;
1199
        }
1200
59
        ac->oc[1].m4ac.chan_config = i;
1201
1202
59
        if (ac->oc[1].m4ac.chan_config) {
1203
24
            int ret = set_default_channel_config(avctx, layout_map,
1204
                &layout_map_tags, ac->oc[1].m4ac.chan_config);
1205
24
            if (!ret)
1206
24
                output_configure(ac, layout_map, layout_map_tags,
1207
                                 OC_GLOBAL_HDR, 0);
1208
            else if (avctx->err_recognition & AV_EF_EXPLODE)
1209
                return AVERROR_INVALIDDATA;
1210
        }
1211
    }
1212
1213
269
    if (avctx->channels > MAX_CHANNELS) {
1214
        av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
1215
        return AVERROR_INVALIDDATA;
1216
    }
1217
1218
#if USE_FIXED
1219
19
    ac->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1220
#else
1221
250
    ac->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1222
#endif /* USE_FIXED */
1223
269
    if (!ac->fdsp) {
1224
        return AVERROR(ENOMEM);
1225
    }
1226
1227
269
    ac->random_state = 0x1f2e3d4c;
1228
1229
269
    AAC_RENAME_32(ff_mdct_init)(&ac->mdct,       11, 1, 1.0 / RANGE15(1024.0));
1230
269
    AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ld,    10, 1, 1.0 / RANGE15(512.0));
1231
269
    AAC_RENAME_32(ff_mdct_init)(&ac->mdct_small,  8, 1, 1.0 / RANGE15(128.0));
1232
269
    AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ltp,   11, 0, RANGE15(-2.0));
1233
#if !USE_FIXED
1234
250
    ret = ff_mdct15_init(&ac->mdct120, 1, 3, 1.0f/(16*1024*120*2));
1235
250
    if (ret < 0)
1236
        return ret;
1237
250
    ret = ff_mdct15_init(&ac->mdct480, 1, 5, 1.0f/(16*1024*960));
1238
250
    if (ret < 0)
1239
        return ret;
1240
250
    ret = ff_mdct15_init(&ac->mdct960, 1, 6, 1.0f/(16*1024*960*2));
1241
250
    if (ret < 0)
1242
        return ret;
1243
#endif
1244
1245
269
    return 0;
1246
}
1247
1248
/**
1249
 * Skip data_stream_element; reference: table 4.10.
1250
 */
1251
2821
static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
1252
{
1253
2821
    int byte_align = get_bits1(gb);
1254
2821
    int count = get_bits(gb, 8);
1255
2821
    if (count == 255)
1256
        count += get_bits(gb, 8);
1257
2821
    if (byte_align)
1258
2454
        align_get_bits(gb);
1259
1260
2821
    if (get_bits_left(gb) < 8 * count) {
1261
        av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
1262
        return AVERROR_INVALIDDATA;
1263
    }
1264
2821
    skip_bits_long(gb, 8 * count);
1265
2821
    return 0;
1266
}
1267
1268
1425
static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
1269
                             GetBitContext *gb)
1270
{
1271
    int sfb;
1272
1425
    if (get_bits1(gb)) {
1273
357
        ics->predictor_reset_group = get_bits(gb, 5);
1274
357
        if (ics->predictor_reset_group == 0 ||
1275
357
            ics->predictor_reset_group > 30) {
1276
            av_log(ac->avctx, AV_LOG_ERROR,
1277
                   "Invalid Predictor Reset Group.\n");
1278
            return AVERROR_INVALIDDATA;
1279
        }
1280
    }
1281
47760
    for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index]); sfb++) {
1282
46335
        ics->prediction_used[sfb] = get_bits1(gb);
1283
    }
1284
1425
    return 0;
1285
}
1286
1287
/**
1288
 * Decode Long Term Prediction data; reference: table 4.xx.
1289
 */
1290
786
static void decode_ltp(LongTermPrediction *ltp,
1291
                       GetBitContext *gb, uint8_t max_sfb)
1292
{
1293
    int sfb;
1294
1295
786
    ltp->lag  = get_bits(gb, 11);
1296
786
    ltp->coef = ltp_coef[get_bits(gb, 3)];
1297
32226
    for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
1298
31440
        ltp->used[sfb] = get_bits1(gb);
1299
786
}
1300
1301
/**
1302
 * Decode Individual Channel Stream info; reference: table 4.6.
1303
 */
1304
63113
static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
1305
                           GetBitContext *gb)
1306
{
1307
63113
    const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
1308
63113
    const int aot = m4ac->object_type;
1309
63113
    const int sampling_index = m4ac->sampling_index;
1310
63113
    int ret_fail = AVERROR_INVALIDDATA;
1311
1312
63113
    if (aot != AOT_ER_AAC_ELD) {
1313
46748
        if (get_bits1(gb)) {
1314
            av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
1315
            if (ac->avctx->err_recognition & AV_EF_BITSTREAM)
1316
                return AVERROR_INVALIDDATA;
1317
        }
1318
46748
        ics->window_sequence[1] = ics->window_sequence[0];
1319
46748
        ics->window_sequence[0] = get_bits(gb, 2);
1320
46748
        if (aot == AOT_ER_AAC_LD &&
1321
2424
            ics->window_sequence[0] != ONLY_LONG_SEQUENCE) {
1322
            av_log(ac->avctx, AV_LOG_ERROR,
1323
                   "AAC LD is only defined for ONLY_LONG_SEQUENCE but "
1324
                   "window sequence %d found.\n", ics->window_sequence[0]);
1325
            ics->window_sequence[0] = ONLY_LONG_SEQUENCE;
1326
            return AVERROR_INVALIDDATA;
1327
        }
1328
46748
        ics->use_kb_window[1]   = ics->use_kb_window[0];
1329
46748
        ics->use_kb_window[0]   = get_bits1(gb);
1330
    }
1331
63113
    ics->num_window_groups  = 1;
1332
63113
    ics->group_len[0]       = 1;
1333
63113
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1334
        int i;
1335
1328
        ics->max_sfb = get_bits(gb, 4);
1336
10624
        for (i = 0; i < 7; i++) {
1337
9296
            if (get_bits1(gb)) {
1338
5868
                ics->group_len[ics->num_window_groups - 1]++;
1339
            } else {
1340
3428
                ics->num_window_groups++;
1341
3428
                ics->group_len[ics->num_window_groups - 1] = 1;
1342
            }
1343
        }
1344
1328
        ics->num_windows       = 8;
1345
1328
        if (m4ac->frame_length_short) {
1346
1
            ics->swb_offset    =  ff_swb_offset_120[sampling_index];
1347
1
            ics->num_swb       = ff_aac_num_swb_120[sampling_index];
1348
        } else {
1349
1327
            ics->swb_offset    =  ff_swb_offset_128[sampling_index];
1350
1327
            ics->num_swb       = ff_aac_num_swb_128[sampling_index];
1351
        }
1352
1328
        ics->tns_max_bands     = ff_tns_max_bands_128[sampling_index];
1353
1328
        ics->predictor_present = 0;
1354
    } else {
1355
61785
        ics->max_sfb           = get_bits(gb, 6);
1356
61785
        ics->num_windows       = 1;
1357

61785
        if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD) {
1358
18789
            if (m4ac->frame_length_short) {
1359
3559
                ics->swb_offset    =     ff_swb_offset_480[sampling_index];
1360
3559
                ics->num_swb       =    ff_aac_num_swb_480[sampling_index];
1361
3559
                ics->tns_max_bands =  ff_tns_max_bands_480[sampling_index];
1362
            } else {
1363
15230
                ics->swb_offset    =     ff_swb_offset_512[sampling_index];
1364
15230
                ics->num_swb       =    ff_aac_num_swb_512[sampling_index];
1365
15230
                ics->tns_max_bands =  ff_tns_max_bands_512[sampling_index];
1366
            }
1367

18789
            if (!ics->num_swb || !ics->swb_offset) {
1368
                ret_fail = AVERROR_BUG;
1369
                goto fail;
1370
            }
1371
        } else {
1372
42996
            if (m4ac->frame_length_short) {
1373
386
                ics->num_swb    = ff_aac_num_swb_960[sampling_index];
1374
386
                ics->swb_offset = ff_swb_offset_960[sampling_index];
1375
            } else {
1376
42610
                ics->num_swb    = ff_aac_num_swb_1024[sampling_index];
1377
42610
                ics->swb_offset = ff_swb_offset_1024[sampling_index];
1378
            }
1379
42996
            ics->tns_max_bands = ff_tns_max_bands_1024[sampling_index];
1380
        }
1381
61785
        if (aot != AOT_ER_AAC_ELD) {
1382
45420
            ics->predictor_present     = get_bits1(gb);
1383
45420
            ics->predictor_reset_group = 0;
1384
        }
1385
61785
        if (ics->predictor_present) {
1386
1963
            if (aot == AOT_AAC_MAIN) {
1387
1425
                if (decode_prediction(ac, ics, gb)) {
1388
                    goto fail;
1389
                }
1390

538
            } else if (aot == AOT_AAC_LC ||
1391
                       aot == AOT_ER_AAC_LC) {
1392
                av_log(ac->avctx, AV_LOG_ERROR,
1393
                       "Prediction is not allowed in AAC-LC.\n");
1394
                goto fail;
1395
            } else {
1396
538
                if (aot == AOT_ER_AAC_LD) {
1397
                    av_log(ac->avctx, AV_LOG_ERROR,
1398
                           "LTP in ER AAC LD not yet implemented.\n");
1399
                    ret_fail = AVERROR_PATCHWELCOME;
1400
                    goto fail;
1401
                }
1402
538
                if ((ics->ltp.present = get_bits(gb, 1)))
1403
382
                    decode_ltp(&ics->ltp, gb, ics->max_sfb);
1404
            }
1405
        }
1406
    }
1407
1408
63113
    if (ics->max_sfb > ics->num_swb) {
1409
        av_log(ac->avctx, AV_LOG_ERROR,
1410
               "Number of scalefactor bands in group (%d) "
1411
               "exceeds limit (%d).\n",
1412
               ics->max_sfb, ics->num_swb);
1413
        goto fail;
1414
    }
1415
1416
63113
    return 0;
1417
fail:
1418
    ics->max_sfb = 0;
1419
    return ret_fail;
1420
}
1421
1422
/**
1423
 * Decode band types (section_data payload); reference: table 4.46.
1424
 *
1425
 * @param   band_type           array of the used band type
1426
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
1427
 *
1428
 * @return  Returns error status. 0 - OK, !0 - error
1429
 */
1430
93570
static int decode_band_types(AACContext *ac, enum BandType band_type[120],
1431
                             int band_type_run_end[120], GetBitContext *gb,
1432
                             IndividualChannelStream *ics)
1433
{
1434
93570
    int g, idx = 0;
1435
93570
    const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
1436
192378
    for (g = 0; g < ics->num_window_groups; g++) {
1437
98808
        int k = 0;
1438
560719
        while (k < ics->max_sfb) {
1439
461911
            uint8_t sect_end = k;
1440
            int sect_len_incr;
1441
461911
            int sect_band_type = get_bits(gb, 4);
1442
461911
            if (sect_band_type == 12) {
1443
                av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
1444
                return AVERROR_INVALIDDATA;
1445
            }
1446
            do {
1447
480641
                sect_len_incr = get_bits(gb, bits);
1448
480641
                sect_end += sect_len_incr;
1449
480641
                if (get_bits_left(gb) < 0) {
1450
                    av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
1451
                    return AVERROR_INVALIDDATA;
1452
                }
1453
480641
                if (sect_end > ics->max_sfb) {
1454
                    av_log(ac->avctx, AV_LOG_ERROR,
1455
                           "Number of bands (%d) exceeds limit (%d).\n",
1456
                           sect_end, ics->max_sfb);
1457
                    return AVERROR_INVALIDDATA;
1458
                }
1459
480641
            } while (sect_len_incr == (1 << bits) - 1);
1460
3925553
            for (; k < sect_end; k++) {
1461
3463642
                band_type        [idx]   = sect_band_type;
1462
3463642
                band_type_run_end[idx++] = sect_end;
1463
            }
1464
        }
1465
    }
1466
93570
    return 0;
1467
}
1468
1469
/**
1470
 * Decode scalefactors; reference: table 4.47.
1471
 *
1472
 * @param   global_gain         first scalefactor value as scalefactors are differentially coded
1473
 * @param   band_type           array of the used band type
1474
 * @param   band_type_run_end   array of the last scalefactor band of a band type run
1475
 * @param   sf                  array of scalefactors or intensity stereo positions
1476
 *
1477
 * @return  Returns error status. 0 - OK, !0 - error
1478
 */
1479
93570
static int decode_scalefactors(AACContext *ac, INTFLOAT sf[120], GetBitContext *gb,
1480
                               unsigned int global_gain,
1481
                               IndividualChannelStream *ics,
1482
                               enum BandType band_type[120],
1483
                               int band_type_run_end[120])
1484
{
1485
93570
    int g, i, idx = 0;
1486
93570
    int offset[3] = { global_gain, global_gain - NOISE_OFFSET, 0 };
1487
    int clipped_offset;
1488
93570
    int noise_flag = 1;
1489
192378
    for (g = 0; g < ics->num_window_groups; g++) {
1490
560719
        for (i = 0; i < ics->max_sfb;) {
1491
461911
            int run_end = band_type_run_end[idx];
1492
461911
            if (band_type[idx] == ZERO_BT) {
1493
597603
                for (; i < run_end; i++, idx++)
1494
534619
                    sf[idx] = FIXR(0.);
1495
398927
            } else if ((band_type[idx] == INTENSITY_BT) ||
1496
389553
                       (band_type[idx] == INTENSITY_BT2)) {
1497
75268
                for (; i < run_end; i++, idx++) {
1498
65778
                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1499
65778
                    clipped_offset = av_clip(offset[2], -155, 100);
1500
65778
                    if (offset[2] != clipped_offset) {
1501
                        avpriv_request_sample(ac->avctx,
1502
                                              "If you heard an audible artifact, there may be a bug in the decoder. "
1503
                                              "Clipped intensity stereo position (%d -> %d)",
1504
                                              offset[2], clipped_offset);
1505
                    }
1506
#if USE_FIXED
1507
17856
                    sf[idx] = 100 - clipped_offset;
1508
#else
1509
47922
                    sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];
1510
#endif /* USE_FIXED */
1511
                }
1512
389437
            } else if (band_type[idx] == NOISE_BT) {
1513
289566
                for (; i < run_end; i++, idx++) {
1514
281905
                    if (noise_flag-- > 0)
1515
6716
                        offset[1] += get_bits(gb, NOISE_PRE_BITS) - NOISE_PRE;
1516
                    else
1517
275189
                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1518
281905
                    clipped_offset = av_clip(offset[1], -100, 155);
1519
281905
                    if (offset[1] != clipped_offset) {
1520
                        avpriv_request_sample(ac->avctx,
1521
                                              "If you heard an audible artifact, there may be a bug in the decoder. "
1522
                                              "Clipped noise gain (%d -> %d)",
1523
                                              offset[1], clipped_offset);
1524
                    }
1525
#if USE_FIXED
1526
137931
                    sf[idx] = -(100 + clipped_offset);
1527
#else
1528
143974
                    sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];
1529
#endif /* USE_FIXED */
1530
                }
1531
            } else {
1532
2963116
                for (; i < run_end; i++, idx++) {
1533
2581340
                    offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1534
2581340
                    if (offset[0] > 255U) {
1535
                        av_log(ac->avctx, AV_LOG_ERROR,
1536
                               "Scalefactor (%d) out of range.\n", offset[0]);
1537
                        return AVERROR_INVALIDDATA;
1538
                    }
1539
#if USE_FIXED
1540
772587
                    sf[idx] = -offset[0];
1541
#else
1542
1808753
                    sf[idx] = -ff_aac_pow2sf_tab[offset[0] - 100 + POW_SF2_ZERO];
1543
#endif /* USE_FIXED */
1544
                }
1545
            }
1546
        }
1547
    }
1548
93570
    return 0;
1549
}
1550
1551
/**
1552
 * Decode pulse data; reference: table 4.7.
1553
 */
1554
1098
static int decode_pulses(Pulse *pulse, GetBitContext *gb,
1555
                         const uint16_t *swb_offset, int num_swb)
1556
{
1557
    int i, pulse_swb;
1558
1098
    pulse->num_pulse = get_bits(gb, 2) + 1;
1559
1098
    pulse_swb        = get_bits(gb, 6);
1560
1098
    if (pulse_swb >= num_swb)
1561
        return -1;
1562
1098
    pulse->pos[0]    = swb_offset[pulse_swb];
1563
1098
    pulse->pos[0]   += get_bits(gb, 5);
1564
1098
    if (pulse->pos[0] >= swb_offset[num_swb])
1565
        return -1;
1566
1098
    pulse->amp[0]    = get_bits(gb, 4);
1567
2744
    for (i = 1; i < pulse->num_pulse; i++) {
1568
1646
        pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
1569
1646
        if (pulse->pos[i] >= swb_offset[num_swb])
1570
            return -1;
1571
1646
        pulse->amp[i] = get_bits(gb, 4);
1572
    }
1573
1098
    return 0;
1574
}
1575
1576
/**
1577
 * Decode Temporal Noise Shaping data; reference: table 4.48.
1578
 *
1579
 * @return  Returns error status. 0 - OK, !0 - error
1580
 */
1581
6927
static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
1582
                      GetBitContext *gb, const IndividualChannelStream *ics)
1583
{
1584
    int w, filt, i, coef_len, coef_res, coef_compress;
1585
6927
    const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
1586

6927
    const int tns_max_order = is8 ? 7 : ac->oc[1].m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
1587
18467
    for (w = 0; w < ics->num_windows; w++) {
1588
11540
        if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
1589
7918
            coef_res = get_bits1(gb);
1590
1591
17297
            for (filt = 0; filt < tns->n_filt[w]; filt++) {
1592
                int tmp2_idx;
1593
9379
                tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
1594
1595
9379
                if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
1596
                    av_log(ac->avctx, AV_LOG_ERROR,
1597
                           "TNS filter order %d is greater than maximum %d.\n",
1598
                           tns->order[w][filt], tns_max_order);
1599
                    tns->order[w][filt] = 0;
1600
                    return AVERROR_INVALIDDATA;
1601
                }
1602
9379
                if (tns->order[w][filt]) {
1603
8859
                    tns->direction[w][filt] = get_bits1(gb);
1604
8859
                    coef_compress = get_bits1(gb);
1605
8859
                    coef_len = coef_res + 3 - coef_compress;
1606
8859
                    tmp2_idx = 2 * coef_compress + coef_res;
1607
1608
67167
                    for (i = 0; i < tns->order[w][filt]; i++)
1609
58308
                        tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
1610
                }
1611
            }
1612
        }
1613
    }
1614
6927
    return 0;
1615
}
1616
1617
/**
1618
 * Decode Mid/Side data; reference: table 4.54.
1619
 *
1620
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
1621
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
1622
 *                      [3] reserved for scalable AAC
1623
 */
1624
26980
static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
1625
                                   int ms_present)
1626
{
1627
    int idx;
1628
26980
    int max_idx = cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb;
1629
26980
    if (ms_present == 1) {
1630
510726
        for (idx = 0; idx < max_idx; idx++)
1631
498034
            cpe->ms_mask[idx] = get_bits1(gb);
1632
14288
    } else if (ms_present == 2) {
1633
14288
        memset(cpe->ms_mask, 1, max_idx * sizeof(cpe->ms_mask[0]));
1634
    }
1635
26980
}
1636
1637
/**
1638
 * Decode spectral data; reference: table 4.50.
1639
 * Dequantize and scale spectral data; reference: 4.6.3.3.
1640
 *
1641
 * @param   coef            array of dequantized, scaled spectral data
1642
 * @param   sf              array of scalefactors or intensity stereo positions
1643
 * @param   pulse_present   set if pulses are present
1644
 * @param   pulse           pointer to pulse data struct
1645
 * @param   band_type       array of the used band type
1646
 *
1647
 * @return  Returns error status. 0 - OK, !0 - error
1648
 */
1649
93570
static int decode_spectrum_and_dequant(AACContext *ac, INTFLOAT coef[1024],
1650
                                       GetBitContext *gb, const INTFLOAT sf[120],
1651
                                       int pulse_present, const Pulse *pulse,
1652
                                       const IndividualChannelStream *ics,
1653
                                       enum BandType band_type[120])
1654
{
1655
93570
    int i, k, g, idx = 0;
1656
93570
    const int c = 1024 / ics->num_windows;
1657
93570
    const uint16_t *offsets = ics->swb_offset;
1658
93570
    INTFLOAT *coef_base = coef;
1659
1660
201742
    for (g = 0; g < ics->num_windows; g++)
1661
108172
        memset(coef + g * 128 + offsets[ics->max_sfb], 0,
1662
108172
               sizeof(INTFLOAT) * (c - offsets[ics->max_sfb]));
1663
1664
192378
    for (g = 0; g < ics->num_window_groups; g++) {
1665
98808
        unsigned g_len = ics->group_len[g];
1666
1667
3562450
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1668
3463642
            const unsigned cbt_m1 = band_type[idx] - 1;
1669
3463642
            INTFLOAT *cfo = coef + offsets[i];
1670
3463642
            int off_len = offsets[i + 1] - offsets[i];
1671
            int group;
1672
1673
3463642
            if (cbt_m1 >= INTENSITY_BT2 - 1) {
1674
1238838
                for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1675
638441
                    memset(cfo, 0, off_len * sizeof(*cfo));
1676
                }
1677
2863245
            } else if (cbt_m1 == NOISE_BT - 1) {
1678
563829
                for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1679
                    INTFLOAT band_energy;
1680
#if USE_FIXED
1681
3021407
                    for (k = 0; k < off_len; k++) {
1682
2883476
                        ac->random_state  = lcg_random(ac->random_state);
1683
2883476
                        cfo[k] = ac->random_state >> 3;
1684
                    }
1685
1686
137931
                    band_energy = ac->fdsp->scalarproduct_fixed(cfo, cfo, off_len);
1687
137931
                    band_energy = fixed_sqrt(band_energy, 31);
1688
137931
                    noise_scale(cfo, sf[idx], band_energy, off_len);
1689
#else
1690
                    float scale;
1691
1692
3209321
                    for (k = 0; k < off_len; k++) {
1693
3065328
                        ac->random_state  = lcg_random(ac->random_state);
1694
3065328
                        cfo[k] = ac->random_state;
1695
                    }
1696
1697
143993
                    band_energy = ac->fdsp->scalarproduct_float(cfo, cfo, off_len);
1698
143993
                    scale = sf[idx] / sqrtf(band_energy);
1699
143993
                    ac->fdsp->vector_fmul_scalar(cfo, cfo, scale, off_len);
1700
#endif /* USE_FIXED */
1701
                }
1702
            } else {
1703
#if !USE_FIXED
1704
1808753
                const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1705
#endif /* !USE_FIXED */
1706
2581340
                const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
1707
2581340
                VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1708
2581340
                OPEN_READER(re, gb);
1709
1710

2581340
                switch (cbt_m1 >> 1) {
1711
622847
                case 0:
1712
1273031
                    for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1713
650184
                        INTFLOAT *cf = cfo;
1714
650184
                        int len = off_len;
1715
1716
                        do {
1717
                            int code;
1718
                            unsigned cb_idx;
1719
1720
3234892
                            UPDATE_CACHE(re, gb);
1721
3234892
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1722
3234892
                            cb_idx = cb_vector_idx[code];
1723
#if USE_FIXED
1724
978157
                            cf = DEC_SQUAD(cf, cb_idx);
1725
#else
1726
2256735
                            cf = VMUL4(cf, vq, cb_idx, sf + idx);
1727
#endif /* USE_FIXED */
1728
3234892
                        } while (len -= 4);
1729
                    }
1730
622847
                    break;
1731
1732
577957
                case 1:
1733
1168422
                    for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1734
590465
                        INTFLOAT *cf = cfo;
1735
590465
                        int len = off_len;
1736
1737
                        do {
1738
                            int code;
1739
                            unsigned nnz;
1740
                            unsigned cb_idx;
1741
                            uint32_t bits;
1742
1743
2638266
                            UPDATE_CACHE(re, gb);
1744
2638266
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1745
2638266
                            cb_idx = cb_vector_idx[code];
1746
2638266
                            nnz = cb_idx >> 8 & 15;
1747
2638266
                            bits = nnz ? GET_CACHE(re, gb) : 0;
1748
2638266
                            LAST_SKIP_BITS(re, gb, nnz);
1749
#if USE_FIXED
1750
816691
                            cf = DEC_UQUAD(cf, cb_idx, bits);
1751
#else
1752
1821575
                            cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1753
#endif /* USE_FIXED */
1754
2638266
                        } while (len -= 4);
1755
                    }
1756
577957
                    break;
1757
1758
401051
                case 2:
1759
814793
                    for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1760
413742
                        INTFLOAT *cf = cfo;
1761
413742
                        int len = off_len;
1762
1763
                        do {
1764
                            int code;
1765
                            unsigned cb_idx;
1766
1767
2508696
                            UPDATE_CACHE(re, gb);
1768
2508696
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1769
2508696
                            cb_idx = cb_vector_idx[code];
1770
#if USE_FIXED
1771
672272
                            cf = DEC_SPAIR(cf, cb_idx);
1772
#else
1773
1836424
                            cf = VMUL2(cf, vq, cb_idx, sf + idx);
1774
#endif /* USE_FIXED */
1775
2508696
                        } while (len -= 2);
1776
                    }
1777
401051
                    break;
1778
1779
542878
                case 3:
1780
                case 4:
1781
1104196
                    for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1782
561318
                        INTFLOAT *cf = cfo;
1783
561318
                        int len = off_len;
1784
1785
                        do {
1786
                            int code;
1787
                            unsigned nnz;
1788
                            unsigned cb_idx;
1789
                            unsigned sign;
1790
1791
2966498
                            UPDATE_CACHE(re, gb);
1792
2966498
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1793
2966498
                            cb_idx = cb_vector_idx[code];
1794
2966498
                            nnz = cb_idx >> 8 & 15;
1795
2966498
                            sign = nnz ? SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12) : 0;
1796
2966498
                            LAST_SKIP_BITS(re, gb, nnz);
1797
#if USE_FIXED
1798
703742
                            cf = DEC_UPAIR(cf, cb_idx, sign);
1799
#else
1800
2262756
                            cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1801
#endif /* USE_FIXED */
1802
2966498
                        } while (len -= 2);
1803
                    }
1804
542878
                    break;
1805
1806
436607
                default:
1807
883063
                    for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1808
#if USE_FIXED
1809
119275
                        int *icf = cfo;
1810
                        int v;
1811
#else
1812
327181
                        float *cf = cfo;
1813
327181
                        uint32_t *icf = (uint32_t *) cf;
1814
#endif /* USE_FIXED */
1815
446456
                        int len = off_len;
1816
1817
                        do {
1818
                            int code;
1819
                            unsigned nzt, nnz;
1820
                            unsigned cb_idx;
1821
                            uint32_t bits;
1822
                            int j;
1823
1824
1473268
                            UPDATE_CACHE(re, gb);
1825
1473268
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1826
1827
1473268
                            if (!code) {
1828
68905
                                *icf++ = 0;
1829
68905
                                *icf++ = 0;
1830
68905
                                continue;
1831
                            }
1832
1833
1404363
                            cb_idx = cb_vector_idx[code];
1834
1404363
                            nnz = cb_idx >> 12;
1835
1404363
                            nzt = cb_idx >> 8;
1836
1404363
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1837
1404363
                            LAST_SKIP_BITS(re, gb, nnz);
1838
1839
4213089
                            for (j = 0; j < 2; j++) {
1840
2808726
                                if (nzt & 1<<j) {
1841
                                    uint32_t b;
1842
                                    int n;
1843
                                    /* The total length of escape_sequence must be < 22 bits according
1844
                                       to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1845
366465
                                    UPDATE_CACHE(re, gb);
1846
366465
                                    b = GET_CACHE(re, gb);
1847
366465
                                    b = 31 - av_log2(~b);
1848
1849
366465
                                    if (b > 8) {
1850
                                        av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1851
                                        return AVERROR_INVALIDDATA;
1852
                                    }
1853
1854
366465
                                    SKIP_BITS(re, gb, b + 1);
1855
366465
                                    b += 4;
1856
366465
                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
1857
366465
                                    LAST_SKIP_BITS(re, gb, b);
1858
#if USE_FIXED
1859
64951
                                    v = n;
1860
64951
                                    if (bits & 1U<<31)
1861
32336
                                        v = -v;
1862
64951
                                    *icf++ = v;
1863
#else
1864
301514
                                    *icf++ = ff_cbrt_tab[n] | (bits & 1U<<31);
1865
#endif /* USE_FIXED */
1866
366465
                                    bits <<= 1;
1867
                                } else {
1868
#if USE_FIXED
1869
539259
                                    v = cb_idx & 15;
1870
539259
                                    if (bits & 1U<<31)
1871
256298
                                        v = -v;
1872
539259
                                    *icf++ = v;
1873
#else
1874
1903002
                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1875
1903002
                                    *icf++ = (bits & 1U<<31) | v;
1876
#endif /* USE_FIXED */
1877
2442261
                                    bits <<= !!v;
1878
                                }
1879
2808726
                                cb_idx >>= 4;
1880
                            }
1881
1473268
                        } while (len -= 2);
1882
#if !USE_FIXED
1883
327181
                        ac->fdsp->vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1884
#endif /* !USE_FIXED */
1885
                    }
1886
                }
1887
1888
2581340
                CLOSE_READER(re, gb);
1889
            }
1890
        }
1891
98808
        coef += g_len << 7;
1892
    }
1893
1894
93570
    if (pulse_present) {
1895
1098
        idx = 0;
1896
3842
        for (i = 0; i < pulse->num_pulse; i++) {
1897
2744
            INTFLOAT co = coef_base[ pulse->pos[i] ];
1898
6840
            while (offsets[idx + 1] <= pulse->pos[i])
1899
4096
                idx++;
1900

2744
            if (band_type[idx] != NOISE_BT && sf[idx]) {
1901
2668
                INTFLOAT ico = -pulse->amp[i];
1902
#if USE_FIXED
1903
864
                if (co) {
1904
730
                    ico = co + (co > 0 ? -ico : ico);
1905
                }
1906
864
                coef_base[ pulse->pos[i] ] = ico;
1907
#else
1908
1804
                if (co) {
1909
1564
                    co /= sf[idx];
1910
1564
                    ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
1911
                }
1912
1804
                coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
1913
#endif /* USE_FIXED */
1914
            }
1915
        }
1916
    }
1917
#if USE_FIXED
1918
28710
    coef = coef_base;
1919
28710
    idx = 0;
1920
59752
    for (g = 0; g < ics->num_window_groups; g++) {
1921
31042
        unsigned g_len = ics->group_len[g];
1922
1923
1071091
        for (i = 0; i < ics->max_sfb; i++, idx++) {
1924
1040049
            const unsigned cbt_m1 = band_type[idx] - 1;
1925
1040049
            int *cfo = coef + offsets[i];
1926
1040049
            int off_len = offsets[i + 1] - offsets[i];
1927
            int group;
1928
1929
1040049
            if (cbt_m1 < NOISE_BT - 1) {
1930
1560445
                for (group = 0; group < (int)g_len; group++, cfo+=128) {
1931
787858
                    ac->vector_pow43(cfo, off_len);
1932
787858
                    ac->subband_scale(cfo, cfo, sf[idx], 34, off_len, ac->avctx);
1933
                }
1934
            }
1935
        }
1936
31042
        coef += g_len << 7;
1937
    }
1938
#endif /* USE_FIXED */
1939
93570
    return 0;
1940
}
1941
1942
/**
1943
 * Apply AAC-Main style frequency domain prediction.
1944
 */
1945
7388
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
1946
{
1947
    int sfb, k;
1948
1949
7388
    if (!sce->ics.predictor_initialized) {
1950
20
        reset_all_predictors(sce->predictor_state);
1951
20
        sce->ics.predictor_initialized = 1;
1952
    }
1953
1954
7388
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
1955
7368
        for (sfb = 0;
1956
262566
             sfb < ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index];
1957
255198
             sfb++) {
1958
255198
            for (k = sce->ics.swb_offset[sfb];
1959
4303134
                 k < sce->ics.swb_offset[sfb + 1];
1960
4047936
                 k++) {
1961
4047936
                predict(&sce->predictor_state[k], &sce->coeffs[k],
1962
4047936
                        sce->ics.predictor_present &&
1963
892992
                        sce->ics.prediction_used[sfb]);
1964
            }
1965
        }
1966
7368
        if (sce->ics.predictor_reset_group)
1967
516
            reset_predictor_group(sce->predictor_state,
1968
                                  sce->ics.predictor_reset_group);
1969
    } else
1970
20
        reset_all_predictors(sce->predictor_state);
1971
7388
}
1972
1973
static void decode_gain_control(SingleChannelElement * sce, GetBitContext * gb)
1974
{
1975
    // wd_num, wd_test, aloc_size
1976
    static const uint8_t gain_mode[4][3] = {
1977
        {1, 0, 5},  // ONLY_LONG_SEQUENCE = 0,
1978
        {2, 1, 2},  // LONG_START_SEQUENCE,
1979
        {8, 0, 2},  // EIGHT_SHORT_SEQUENCE,
1980
        {2, 1, 5},  // LONG_STOP_SEQUENCE
1981
    };
1982
1983
    const int mode = sce->ics.window_sequence[0];
1984
    uint8_t bd, wd, ad;
1985
1986
    // FIXME: Store the gain control data on |sce| and do something with it.
1987
    uint8_t max_band = get_bits(gb, 2);
1988
    for (bd = 0; bd < max_band; bd++) {
1989
        for (wd = 0; wd < gain_mode[mode][0]; wd++) {
1990
            uint8_t adjust_num = get_bits(gb, 3);
1991
            for (ad = 0; ad < adjust_num; ad++) {
1992
                skip_bits(gb, 4 + ((wd == 0 && gain_mode[mode][1])
1993
                                     ? 4
1994
                                     : gain_mode[mode][2]));
1995
            }
1996
        }
1997
    }
1998
}
1999
2000
/**
2001
 * Decode an individual_channel_stream payload; reference: table 4.44.
2002
 *
2003
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
2004
 * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
2005
 *
2006
 * @return  Returns error status. 0 - OK, !0 - error
2007
 */
2008
93570
static int decode_ics(AACContext *ac, SingleChannelElement *sce,
2009
                      GetBitContext *gb, int common_window, int scale_flag)
2010
{
2011
    Pulse pulse;
2012
93570
    TemporalNoiseShaping    *tns = &sce->tns;
2013
93570
    IndividualChannelStream *ics = &sce->ics;
2014
93570
    INTFLOAT *out = sce->coeffs;
2015
93570
    int global_gain, eld_syntax, er_syntax, pulse_present = 0;
2016
    int ret;
2017
2018
93570
    eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2019
280710
    er_syntax  = ac->oc[1].m4ac.object_type == AOT_ER_AAC_LC ||
2020
93570
                 ac->oc[1].m4ac.object_type == AOT_ER_AAC_LTP ||
2021

277074
                 ac->oc[1].m4ac.object_type == AOT_ER_AAC_LD ||
2022
89934
                 ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2023
2024
    /* This assignment is to silence a GCC warning about the variable being used
2025
     * uninitialized when in fact it always is.
2026
     */
2027
93570
    pulse.num_pulse = 0;
2028
2029
93570
    global_gain = get_bits(gb, 8);
2030
2031

93570
    if (!common_window && !scale_flag) {
2032
32656
        ret = decode_ics_info(ac, ics, gb);
2033
32656
        if (ret < 0)
2034
            goto fail;
2035
    }
2036
2037
93570
    if ((ret = decode_band_types(ac, sce->band_type,
2038
93570
                                 sce->band_type_run_end, gb, ics)) < 0)
2039
        goto fail;
2040
93570
    if ((ret = decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
2041
93570
                                  sce->band_type, sce->band_type_run_end)) < 0)
2042
        goto fail;
2043
2044
93570
    pulse_present = 0;
2045
93570
    if (!scale_flag) {
2046

93570
        if (!eld_syntax && (pulse_present = get_bits1(gb))) {
2047
1098
            if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2048
                av_log(ac->avctx, AV_LOG_ERROR,
2049
                       "Pulse tool not allowed in eight short sequence.\n");
2050
                ret = AVERROR_INVALIDDATA;
2051
                goto fail;
2052
            }
2053
1098
            if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
2054
                av_log(ac->avctx, AV_LOG_ERROR,
2055
                       "Pulse data corrupt or invalid.\n");
2056
                ret = AVERROR_INVALIDDATA;
2057
                goto fail;
2058
            }
2059
        }
2060
93570
        tns->present = get_bits1(gb);
2061

93570
        if (tns->present && !er_syntax) {
2062
5663
            ret = decode_tns(ac, tns, gb, ics);
2063
5663
            if (ret < 0)
2064
                goto fail;
2065
        }
2066

93570
        if (!eld_syntax && get_bits1(gb)) {
2067
            decode_gain_control(sce, gb);
2068
            if (!ac->warned_gain_control) {
2069
                avpriv_report_missing_feature(ac->avctx, "Gain control");
2070
                ac->warned_gain_control = 1;
2071
            }
2072
        }
2073
        // I see no textual basis in the spec for this occurring after SSR gain
2074
        // control, but this is what both reference and real implmentations do
2075

93570
        if (tns->present && er_syntax) {
2076
1264
            ret = decode_tns(ac, tns, gb, ics);
2077
1264
            if (ret < 0)
2078
                goto fail;
2079
        }
2080
    }
2081
2082
93570
    ret = decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
2083
93570
                                    &pulse, ics, sce->band_type);
2084
93570
    if (ret < 0)
2085
        goto fail;
2086
2087

93570
    if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
2088
6094
        apply_prediction(ac, sce);
2089
2090
93570
    return 0;
2091
fail:
2092
    tns->present = 0;
2093
    return ret;
2094
}
2095
2096
/**
2097
 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
2098
 */
2099
26980
static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
2100
{
2101
26980
    const IndividualChannelStream *ics = &cpe->ch[0].ics;
2102
26980
    INTFLOAT *ch0 = cpe->ch[0].coeffs;
2103
26980
    INTFLOAT *ch1 = cpe->ch[1].coeffs;
2104
26980
    int g, i, group, idx = 0;
2105
26980
    const uint16_t *offsets = ics->swb_offset;
2106
55663
    for (g = 0; g < ics->num_window_groups; g++) {
2107
1041956
        for (i = 0; i < ics->max_sfb; i++, idx++) {
2108
1013273
            if (cpe->ms_mask[idx] &&
2109
794243
                cpe->ch[0].band_type[idx] < NOISE_BT &&
2110
794243
                cpe->ch[1].band_type[idx] < NOISE_BT) {
2111
#if USE_FIXED
2112
500617
                for (group = 0; group < ics->group_len[g]; group++) {
2113
253158
                    ac->fdsp->butterflies_fixed(ch0 + group * 128 + offsets[i],
2114
253158
                                                ch1 + group * 128 + offsets[i],
2115
253158
                                                offsets[i+1] - offsets[i]);
2116
#else
2117
1113172
                for (group = 0; group < ics->group_len[g]; group++) {
2118
568830
                    ac->fdsp->butterflies_float(ch0 + group * 128 + offsets[i],
2119
568830
                                               ch1 + group * 128 + offsets[i],
2120
568830
                                               offsets[i+1] - offsets[i]);
2121
#endif /* USE_FIXED */
2122
                }
2123
            }
2124
        }
2125
28683
        ch0 += ics->group_len[g] * 128;
2126
28683
        ch1 += ics->group_len[g] * 128;
2127
    }
2128
26980
}
2129
2130
/**
2131
 * intensity stereo decoding; reference: 4.6.8.2.3
2132
 *
2133
 * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
2134
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
2135
 *                      [3] reserved for scalable AAC
2136
 */
2137
30679
static void apply_intensity_stereo(AACContext *ac,
2138
                                   ChannelElement *cpe, int ms_present)
2139
{
2140
30679
    const IndividualChannelStream *ics = &cpe->ch[1].ics;
2141
30679
    SingleChannelElement         *sce1 = &cpe->ch[1];
2142
30679
    INTFLOAT *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
2143
30679
    const uint16_t *offsets = ics->swb_offset;
2144
30679
    int g, group, i, idx = 0;
2145
    int c;
2146
    INTFLOAT scale;
2147
63286
    for (g = 0; g < ics->num_window_groups; g++) {
2148
193117
        for (i = 0; i < ics->max_sfb;) {
2149
160510
            if (sce1->band_type[idx] == INTENSITY_BT ||
2150
160626
                sce1->band_type[idx] == INTENSITY_BT2) {
2151
9490
                const int bt_run_end = sce1->band_type_run_end[idx];
2152
75268
                for (; i < bt_run_end; i++, idx++) {
2153
65778
                    c = -1 + 2 * (sce1->band_type[idx] - 14);
2154
65778
                    if (ms_present)
2155
61107
                        c *= 1 - 2 * cpe->ms_mask[idx];
2156
65778
                    scale = c * sce1->sf[idx];
2157
131873
                    for (group = 0; group < ics->group_len[g]; group++)
2158
#if USE_FIXED
2159
17955
                        ac->subband_scale(coef1 + group * 128 + offsets[i],
2160
17955
                                      coef0 + group * 128 + offsets[i],
2161
                                      scale,
2162
                                      23,
2163
17955
                                      offsets[i + 1] - offsets[i] ,ac->avctx);
2164
#else
2165
48140
                        ac->fdsp->vector_fmul_scalar(coef1 + group * 128 + offsets[i],
2166
48140
                                                    coef0 + group * 128 + offsets[i],
2167
                                                    scale,
2168
48140
                                                    offsets[i + 1] - offsets[i]);
2169
#endif /* USE_FIXED */
2170
                }
2171
            } else {
2172
151020
                int bt_run_end = sce1->band_type_run_end[idx];
2173
151020
                idx += bt_run_end - i;
2174
151020
                i    = bt_run_end;
2175
            }
2176
        }
2177
32607
        coef0 += ics->group_len[g] * 128;
2178
32607
        coef1 += ics->group_len[g] * 128;
2179
    }
2180
30679
}
2181
2182
/**
2183
 * Decode a channel_pair_element; reference: table 4.4.
2184
 *
2185
 * @return  Returns error status. 0 - OK, !0 - error
2186
 */
2187
30679
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
2188
{
2189
30679
    int i, ret, common_window, ms_present = 0;
2190
30679
    int eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2191
2192

30679
    common_window = eld_syntax || get_bits1(gb);
2193
30679
    if (common_window) {
2194
30457
        if (decode_ics_info(ac, &cpe->ch[0].ics, gb))
2195
            return AVERROR_INVALIDDATA;
2196
30457
        i = cpe->ch[1].ics.use_kb_window[0];
2197
30457
        cpe->ch[1].ics = cpe->ch[0].ics;
2198
30457
        cpe->ch[1].ics.use_kb_window[1] = i;
2199
30457
        if (cpe->ch[1].ics.predictor_present &&
2200
724
            (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
2201
538
            if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
2202
404
                decode_ltp(&cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
2203
30457
        ms_present = get_bits(gb, 2);
2204
30457
        if (ms_present == 3) {
2205
            av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
2206
            return AVERROR_INVALIDDATA;
2207
30457
        } else if (ms_present)
2208
26980
            decode_mid_side_stereo(cpe, gb, ms_present);
2209
    }
2210
30679
    if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
2211
        return ret;
2212
30679
    if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
2213
        return ret;
2214
2215
30679
    if (common_window) {
2216
30457
        if (ms_present)
2217
26980
            apply_mid_side_stereo(ac, cpe);
2218
30457
        if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
2219
647
            apply_prediction(ac, &cpe->ch[0]);
2220
647
            apply_prediction(ac, &cpe->ch[1]);
2221
        }
2222
    }
2223
2224
30679
    apply_intensity_stereo(ac, cpe, ms_present);
2225
30679
    return 0;
2226
}
2227
2228
static const float cce_scale[] = {
2229
    1.09050773266525765921, //2^(1/8)
2230
    1.18920711500272106672, //2^(1/4)
2231
    M_SQRT2,
2232
    2,
2233
};
2234
2235
/**
2236
 * Decode coupling_channel_element; reference: table 4.8.
2237
 *
2238
 * @return  Returns error status. 0 - OK, !0 - error
2239
 */
2240
1174
static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
2241
{
2242
1174
    int num_gain = 0;
2243
    int c, g, sfb, ret;
2244
    int sign;
2245
    INTFLOAT scale;
2246
1174
    SingleChannelElement *sce = &che->ch[0];
2247
1174
    ChannelCoupling     *coup = &che->coup;
2248
2249
1174
    coup->coupling_point = 2 * get_bits1(gb);
2250
1174
    coup->num_coupled = get_bits(gb, 3);
2251
3915
    for (c = 0; c <= coup->num_coupled; c++) {
2252
2741
        num_gain++;
2253
2741
        coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
2254
2741
        coup->id_select[c] = get_bits(gb, 4);
2255
2741
        if (coup->type[c] == TYPE_CPE) {
2256
2348
            coup->ch_select[c] = get_bits(gb, 2);
2257
2348
            if (coup->ch_select[c] == 3)
2258
1967
                num_gain++;
2259
        } else
2260
393
            coup->ch_select[c] = 2;
2261
    }
2262

1174
    coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
2263
2264
1174
    sign  = get_bits(gb, 1);
2265
#if USE_FIXED
2266
130
    scale = get_bits(gb, 2);
2267
#else
2268
1044
    scale = cce_scale[get_bits(gb, 2)];
2269
#endif
2270
2271
1174
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
2272
        return ret;
2273
2274
5882
    for (c = 0; c < num_gain; c++) {
2275
4708
        int idx  = 0;
2276
4708
        int cge  = 1;
2277
4708
        int gain = 0;
2278
4708
        INTFLOAT gain_cache = FIXR10(1.);
2279
4708
        if (c) {
2280
3534
            cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
2281
3534
            gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
2282
3534
            gain_cache = GET_GAIN(scale, gain);
2283
#if USE_FIXED
2284
520
            if ((abs(gain_cache)-1024) >> 3 > 30)
2285
                return AVERROR(ERANGE);
2286
#endif
2287
        }
2288
4708
        if (coup->coupling_point == AFTER_IMDCT) {
2289
1965
            coup->gain[c][0] = gain_cache;
2290
        } else {
2291
5486
            for (g = 0; g < sce->ics.num_window_groups; g++) {
2292
112463
                for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
2293
109720
                    if (sce->band_type[idx] != ZERO_BT) {
2294
5196
                        if (!cge) {
2295
2879
                            int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
2296
2879
                            if (t) {
2297
2724
                                int s = 1;
2298
2724
                                t = gain += t;
2299
2724
                                if (sign) {
2300
1666
                                    s  -= 2 * (t & 0x1);
2301
1666
                                    t >>= 1;
2302
                                }
2303
2724
                                gain_cache = GET_GAIN(scale, t) * s;
2304
#if USE_FIXED
2305
                                if ((abs(gain_cache)-1024) >> 3 > 30)
2306
                                    return AVERROR(ERANGE);
2307
#endif
2308
                            }
2309
                        }
2310
5196
                        coup->gain[c][idx] = gain_cache;
2311
                    }
2312
                }
2313
            }
2314
        }
2315
    }
2316
1174
    return 0;
2317
}
2318
2319
/**
2320
 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
2321
 *
2322
 * @return  Returns number of bytes consumed.
2323
 */
2324
4
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
2325
                                         GetBitContext *gb)
2326
{
2327
    int i;
2328
4
    int num_excl_chan = 0;
2329
2330
    do {
2331
32
        for (i = 0; i < 7; i++)
2332
28
            che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
2333

4
    } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
2334
2335
4
    return num_excl_chan / 7;
2336
}
2337
2338
/**
2339
 * Decode dynamic range information; reference: table 4.52.
2340
 *
2341
 * @return  Returns number of bytes consumed.
2342
 */
2343
880
static int decode_dynamic_range(DynamicRangeControl *che_drc,
2344
                                GetBitContext *gb)
2345
{
2346
880
    int n             = 1;
2347
880
    int drc_num_bands = 1;
2348
    int i;
2349
2350
    /* pce_tag_present? */
2351
880
    if (get_bits1(gb)) {
2352
        che_drc->pce_instance_tag  = get_bits(gb, 4);
2353
        skip_bits(gb, 4); // tag_reserved_bits
2354
        n++;
2355
    }
2356
2357
    /* excluded_chns_present? */
2358
880
    if (get_bits1(gb)) {
2359
4
        n += decode_drc_channel_exclusions(che_drc, gb);
2360
    }
2361
2362
    /* drc_bands_present? */
2363
880
    if (get_bits1(gb)) {
2364
35
        che_drc->band_incr            = get_bits(gb, 4);
2365
35
        che_drc->interpolation_scheme = get_bits(gb, 4);
2366
35
        n++;
2367
35
        drc_num_bands += che_drc->band_incr;
2368
140
        for (i = 0; i < drc_num_bands; i++) {
2369
105
            che_drc->band_top[i] = get_bits(gb, 8);
2370
105
            n++;
2371
        }
2372
    }
2373
2374
    /* prog_ref_level_present? */
2375
880
    if (get_bits1(gb)) {
2376
878
        che_drc->prog_ref_level = get_bits(gb, 7);
2377
878
        skip_bits1(gb); // prog_ref_level_reserved_bits
2378
878
        n++;
2379
    }
2380
2381
1830
    for (i = 0; i < drc_num_bands; i++) {
2382
950
        che_drc->dyn_rng_sgn[i] = get_bits1(gb);
2383
950
        che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
2384
950
        n++;
2385
    }
2386
2387
880
    return n;
2388
}
2389
2390
8967
static int decode_fill(AACContext *ac, GetBitContext *gb, int len) {
2391
    uint8_t buf[256];
2392
    int i, major, minor;
2393
2394
8967
    if (len < 13+7*8)
2395
380
        goto unknown;
2396
2397
8587
    get_bits(gb, 13); len -= 13;
2398
2399

1136948
    for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
2400
1128361
        buf[i] = get_bits(gb, 8);
2401
2402
8587
    buf[i] = 0;
2403
8587
    if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
2404
        av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
2405
2406
8587
    if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
2407
19
        ac->avctx->internal->skip_samples = 1024;
2408
    }
2409
2410
8568
unknown:
2411
8967
    skip_bits_long(gb, len);
2412
2413
8967
    return 0;
2414
}
2415
2416
/**
2417
 * Decode extension data (incomplete); reference: table 4.51.
2418
 *
2419
 * @param   cnt length of TYPE_FIL syntactic element in bytes
2420
 *
2421
 * @return Returns number of bytes consumed
2422
 */
2423
23698
static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
2424
                                    ChannelElement *che, enum RawDataBlockType elem_type)
2425
{
2426
23698
    int crc_flag = 0;
2427
23698
    int res = cnt;
2428
23698
    int type = get_bits(gb, 4);
2429
2430
23698
    if (ac->avctx->debug & FF_DEBUG_STARTCODE)
2431
        av_log(ac->avctx, AV_LOG_DEBUG, "extension type: %d len:%d\n", type, cnt);
2432
2433

23698
    switch (type) { // extension type
2434
    case EXT_SBR_DATA_CRC:
2435
        crc_flag++;
2436
10901
    case EXT_SBR_DATA:
2437
10901
        if (!che) {
2438
            av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
2439
            return res;
2440
10901
        } else if (ac->oc[1].m4ac.frame_length_short) {
2441
            if (!ac->warned_960_sbr)
2442
              avpriv_report_missing_feature(ac->avctx,
2443
                                            "SBR with 960 frame length");
2444
            ac->warned_960_sbr = 1;
2445
            skip_bits_long(gb, 8 * cnt - 4);
2446
            return res;
2447
10901
        } else if (!ac->oc[1].m4ac.sbr) {
2448
            av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
2449
            skip_bits_long(gb, 8 * cnt - 4);
2450
            return res;
2451

10901
        } else if (ac->oc[1].m4ac.sbr == -1 && ac->oc[1].status == OC_LOCKED) {
2452
            av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
2453
            skip_bits_long(gb, 8 * cnt - 4);
2454
            return res;
2455

10901
        } else if (ac->oc[1].m4ac.ps == -1 && ac->oc[1].status < OC_LOCKED && ac->avctx->channels == 1) {
2456
12
            ac->oc[1].m4ac.sbr = 1;
2457
12
            ac->oc[1].m4ac.ps = 1;
2458
12
            ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
2459
12
            output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
2460
                             ac->oc[1].status, 1);
2461
        } else {
2462
10889
            ac->oc[1].m4ac.sbr = 1;
2463
10889
            ac->avctx->profile = FF_PROFILE_AAC_HE;
2464
        }
2465
10901
        res = AAC_RENAME(ff_decode_sbr_extension)(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
2466
10901
        break;
2467
880
    case EXT_DYNAMIC_RANGE:
2468
880
        res = decode_dynamic_range(&ac->che_drc, gb);
2469
880
        break;
2470
8967
    case EXT_FILL:
2471
8967
        decode_fill(ac, gb, 8 * cnt - 4);
2472
8967
        break;
2473
2950
    case EXT_FILL_DATA:
2474
    case EXT_DATA_ELEMENT:
2475
    default:
2476
2950
        skip_bits_long(gb, 8 * cnt - 4);
2477
2950
        break;
2478
    };
2479
23698
    return res;
2480
}
2481
2482
/**
2483
 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
2484
 *
2485
 * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
2486
 * @param   coef    spectral coefficients
2487
 */
2488
6933
static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
2489
                      IndividualChannelStream *ics, int decode)
2490
{
2491
6933
    const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
2492
    int w, filt, m, i;
2493
    int bottom, top, order, start, end, size, inc;
2494
    INTFLOAT lpc[TNS_MAX_ORDER];
2495
    INTFLOAT tmp[TNS_MAX_ORDER+1];
2496
6933
    UINTFLOAT *coef = coef_param;
2497
2498
6933
    if(!mmm)
2499
6
        return;
2500
2501
18467
    for (w = 0; w < ics->num_windows; w++) {
2502
11540
        bottom = ics->num_swb;
2503
20919
        for (filt = 0; filt < tns->n_filt[w]; filt++) {
2504
9379
            top    = bottom;
2505
9379
            bottom = FFMAX(0, top - tns->length[w][filt]);
2506
9379
            order  = tns->order[w][filt];
2507
9379
            if (order == 0)
2508
520
                continue;
2509
2510
            // tns_decode_coef
2511
8859
            AAC_RENAME(compute_lpc_coefs)(tns->coef[w][filt], order, lpc, 0, 0, 0);
2512
2513
8859
            start = ics->swb_offset[FFMIN(bottom, mmm)];
2514
8859
            end   = ics->swb_offset[FFMIN(   top, mmm)];
2515
8859
            if ((size = end - start) <= 0)
2516
8
                continue;
2517
8851
            if (tns->direction[w][filt]) {
2518
3586
                inc = -1;
2519
3586
                start = end - 1;
2520
            } else {
2521
5265
                inc = 1;
2522
            }
2523
8851
            start += w * 128;
2524
2525
8851
            if (decode) {
2526
                // ar filter
2527
2738921
                for (m = 0; m < size; m++, start += inc)
2528
23883725
                    for (i = 1; i <= FFMIN(m, order); i++)
2529
21153649
                        coef[start] -= AAC_MUL26((INTFLOAT)coef[start - i * inc], lpc[i - 1]);
2530
            } else {
2531
                // ma filter
2532
3702
                for (m = 0; m < size; m++, start += inc) {
2533
3696
                    tmp[0] = coef[start];
2534
39112
                    for (i = 1; i <= FFMIN(m, order); i++)
2535
35416
                        coef[start] += AAC_MUL26(tmp[i], lpc[i - 1]);
2536
39424
                    for (i = order; i > 0; i--)
2537
35728
                        tmp[i] = tmp[i - 1];
2538
                }
2539
            }
2540
        }
2541
    }
2542
}
2543
2544
/**
2545
 *  Apply windowing and MDCT to obtain the spectral
2546
 *  coefficient from the predicted sample by LTP.
2547
 */
2548
786
static void windowing_and_mdct_ltp(AACContext *ac, INTFLOAT *out,
2549
                                   INTFLOAT *in, IndividualChannelStream *ics)
2550
{
2551
786
    const INTFLOAT *lwindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2552
786
    const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
2553
786
    const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2554
786
    const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
2555
2556
786
    if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
2557
784
        ac->fdsp->vector_fmul(in, in, lwindow_prev, 1024);
2558
    } else {
2559
2
        memset(in, 0, 448 * sizeof(*in));
2560
2
        ac->fdsp->vector_fmul(in + 448, in + 448, swindow_prev, 128);
2561
    }
2562
786
    if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
2563
786
        ac->fdsp->vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
2564
    } else {
2565
        ac->fdsp->vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
2566
        memset(in + 1024 + 576, 0, 448 * sizeof(*in));
2567
    }
2568
786
    ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
2569
786
}
2570
2571
/**
2572
 * Apply the long term prediction
2573
 */
2574
786
static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
2575
{
2576
786
    const LongTermPrediction *ltp = &sce->ics.ltp;
2577
786
    const uint16_t *offsets = sce->ics.swb_offset;
2578
    int i, sfb;
2579
2580
786
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
2581
786
        INTFLOAT *predTime = sce->ret;
2582
786
        INTFLOAT *predFreq = ac->buf_mdct;
2583
786
        int16_t num_samples = 2048;
2584
2585
786
        if (ltp->lag < 1024)
2586
            num_samples = ltp->lag + 1024;
2587
1610514
        for (i = 0; i < num_samples; i++)
2588
1609728
            predTime[i] = AAC_MUL30(sce->ltp_state[i + 2048 - ltp->lag], ltp->coef);
2589
786
        memset(&predTime[i], 0, (2048 - i) * sizeof(*predTime));
2590
2591
786
        ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
2592
2593
786
        if (sce->tns.present)
2594
6
            ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
2595
2596
32226
        for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
2597
31440
            if (ltp->used[sfb])
2598
370412
                for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
2599
347544
                    sce->coeffs[i] += (UINTFLOAT)predFreq[i];
2600
    }
2601
786
}
2602
2603
/**
2604
 * Update the LTP buffer for next frame
2605
 */
2606
3568
static void update_ltp(AACContext *ac, SingleChannelElement *sce)
2607
{
2608
3568
    IndividualChannelStream *ics = &sce->ics;
2609
3568
    INTFLOAT *saved     = sce->saved;
2610
3568
    INTFLOAT *saved_ltp = sce->coeffs;
2611
3568
    const INTFLOAT *lwindow = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2612
3568
    const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
2613
    int i;
2614
2615
3568
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2616
4
        memcpy(saved_ltp,       saved, 512 * sizeof(*saved_ltp));
2617
4
        memset(saved_ltp + 576, 0,     448 * sizeof(*saved_ltp));
2618
4
        ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
2619
2620
260
        for (i = 0; i < 64; i++)
2621
256
            saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
2622
3564
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2623
4
        memcpy(saved_ltp,       ac->buf_mdct + 512, 448 * sizeof(*saved_ltp));
2624
4
        memset(saved_ltp + 576, 0,                  448 * sizeof(*saved_ltp));
2625
4
        ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
2626
2627
260
        for (i = 0; i < 64; i++)
2628
256
            saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
2629
    } else { // LONG_STOP or ONLY_LONG
2630
3560
        ac->fdsp->vector_fmul_reverse(saved_ltp,       ac->buf_mdct + 512,     &lwindow[512],     512);
2631
2632
1826280
        for (i = 0; i < 512; i++)
2633
1822720
            saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], lwindow[511 - i]);
2634
    }
2635
2636
3568
    memcpy(sce->ltp_state,      sce->ltp_state+1024, 1024 * sizeof(*sce->ltp_state));
2637
3568
    memcpy(sce->ltp_state+1024, sce->ret,            1024 * sizeof(*sce->ltp_state));
2638
3568
    memcpy(sce->ltp_state+2048, saved_ltp,           1024 * sizeof(*sce->ltp_state));
2639
3568
}
2640
2641
/**
2642
 * Conduct IMDCT and windowing.
2643
 */
2644
62168
static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
2645
{
2646
62168
    IndividualChannelStream *ics = &sce->ics;
2647
62168
    INTFLOAT *in    = sce->coeffs;
2648
62168
    INTFLOAT *out   = sce->ret;
2649
62168
    INTFLOAT *saved = sce->saved;
2650
62168
    const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
2651
62168
    const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2652
62168
    const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
2653
62168
    INTFLOAT *buf  = ac->buf_mdct;
2654
62168
    INTFLOAT *temp = ac->temp;
2655
    int i;
2656
2657
    // imdct
2658
62168
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2659
18765
        for (i = 0; i < 1024; i += 128)
2660
16680
            ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
2661
    } else {
2662
60083
        ac->mdct.imdct_half(&ac->mdct, buf, in);
2663
#if USE_FIXED
2664
16815125
        for (i=0; i<1024; i++)
2665
16798720
          buf[i] = (buf[i] + 4LL) >> 3;
2666
#endif /* USE_FIXED */
2667
    }
2668
2669
    /* window overlapping
2670
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
2671
     * and long to short transitions are considered to be short to short
2672
     * transitions. This leaves just two cases (long to long and short to short)
2673
     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
2674
     */
2675

62168
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
2676

59004
            (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
2677
59002
        ac->fdsp->vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 512);
2678
    } else {
2679
3166
        memcpy(                         out,               saved,            448 * sizeof(*out));
2680
2681
3166
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2682
2085
            ac->fdsp->vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, 64);
2683
2085
            ac->fdsp->vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      64);
2684
2085
            ac->fdsp->vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      64);
2685
2085
            ac->fdsp->vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      64);
2686
2085
            ac->fdsp->vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      64);
2687
2085
            memcpy(                     out + 448 + 4*128, temp, 64 * sizeof(*out));
2688
        } else {
2689
1081
            ac->fdsp->vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, 64);
2690
1081
            memcpy(                     out + 576,         buf + 64,         448 * sizeof(*out));
2691
        }
2692
    }
2693
2694
    // buffer update
2695
62168
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2696
2085
        memcpy(                     saved,       temp + 64,         64 * sizeof(*saved));
2697
2085
        ac->fdsp->vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 64);
2698
2085
        ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
2699
2085
        ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
2700
2085
        memcpy(                     saved + 448, buf + 7*128 + 64,  64 * sizeof(*saved));
2701
60083
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2702
1204
        memcpy(                     saved,       buf + 512,        448 * sizeof(*saved));
2703
1204
        memcpy(                     saved + 448, buf + 7*128 + 64,  64 * sizeof(*saved));
2704
    } else { // LONG_STOP or ONLY_LONG
2705
58879
        memcpy(                     saved,       buf + 512,        512 * sizeof(*saved));
2706
    }
2707
62168
}
2708
2709
/**
2710
 * Conduct IMDCT and windowing.
2711
 */
2712
387
static void imdct_and_windowing_960(AACContext *ac, SingleChannelElement *sce)
2713
{
2714
#if !USE_FIXED
2715
387
    IndividualChannelStream *ics = &sce->ics;
2716
387
    INTFLOAT *in    = sce->coeffs;
2717
387
    INTFLOAT *out   = sce->ret;
2718
387
    INTFLOAT *saved = sce->saved;
2719
387
    const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_120) : AAC_RENAME(ff_sine_120);
2720
387
    const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_960) : AAC_RENAME(ff_sine_960);
2721
387
    const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_120) : AAC_RENAME(ff_sine_120);
2722
387
    INTFLOAT *buf  = ac->buf_mdct;
2723
387
    INTFLOAT *temp = ac->temp;
2724
    int i;
2725
2726
    // imdct
2727
387
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2728
9
        for (i = 0; i < 8; i++)
2729
8
            ac->mdct120->imdct_half(ac->mdct120, buf + i * 120, in + i * 128, 1);
2730
    } else {
2731
386
        ac->mdct960->imdct_half(ac->mdct960, buf, in, 1);
2732
    }
2733
2734
    /* window overlapping
2735
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
2736
     * and long to short transitions are considered to be short to short
2737
     * transitions. This leaves just two cases (long to long and short to short)
2738
     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
2739
     */
2740
2741

387
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
2742

385
        (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
2743
385
        ac->fdsp->vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 480);
2744
    } else {
2745
2
        memcpy(                          out,               saved,            420 * sizeof(*out));
2746
2747
2
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2748
1
            ac->fdsp->vector_fmul_window(out + 420 + 0*120, saved + 420,      buf + 0*120, swindow_prev, 60);
2749
1
            ac->fdsp->vector_fmul_window(out + 420 + 1*120, buf + 0*120 + 60, buf + 1*120, swindow,      60);
2750
1
            ac->fdsp->vector_fmul_window(out + 420 + 2*120, buf + 1*120 + 60, buf + 2*120, swindow,      60);
2751
1
            ac->fdsp->vector_fmul_window(out + 420 + 3*120, buf + 2*120 + 60, buf + 3*120, swindow,      60);
2752
1
            ac->fdsp->vector_fmul_window(temp,              buf + 3*120 + 60, buf + 4*120, swindow,      60);
2753
1
            memcpy(                      out + 420 + 4*120, temp, 60 * sizeof(*out));
2754
        } else {
2755
1
            ac->fdsp->vector_fmul_window(out + 420,         saved + 420,      buf,         swindow_prev, 60);
2756
1
            memcpy(                      out + 540,         buf + 60,         420 * sizeof(*out));
2757
        }
2758
    }
2759
2760
    // buffer update
2761
387
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2762
1
        memcpy(                      saved,       temp + 60,         60 * sizeof(*saved));
2763
1
        ac->fdsp->vector_fmul_window(saved + 60,  buf + 4*120 + 60, buf + 5*120, swindow, 60);
2764
1
        ac->fdsp->vector_fmul_window(saved + 180, buf + 5*120 + 60, buf + 6*120, swindow, 60);
2765
1
        ac->fdsp->vector_fmul_window(saved + 300, buf + 6*120 + 60, buf + 7*120, swindow, 60);
2766
1
        memcpy(                      saved + 420, buf + 7*120 + 60,  60 * sizeof(*saved));
2767
386
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2768
2
        memcpy(                      saved,       buf + 480,        420 * sizeof(*saved));
2769
2
        memcpy(                      saved + 420, buf + 7*120 + 60,  60 * sizeof(*saved));
2770
    } else { // LONG_STOP or ONLY_LONG
2771
384
        memcpy(                      saved,       buf + 480,        480 * sizeof(*saved));
2772
    }
2773
#endif
2774
387
}
2775
3636
static void imdct_and_windowing_ld(AACContext *ac, SingleChannelElement *sce)
2776
{
2777
3636
    IndividualChannelStream *ics = &sce->ics;
2778
3636
    INTFLOAT *in    = sce->coeffs;
2779
3636
    INTFLOAT *out   = sce->ret;
2780
3636
    INTFLOAT *saved = sce->saved;
2781
3636
    INTFLOAT *buf  = ac->buf_mdct;
2782
#if USE_FIXED
2783
    int i;
2784
#endif /* USE_FIXED */
2785
2786
    // imdct
2787
3636
    ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
2788
2789
#if USE_FIXED
2790
1857300
    for (i = 0; i < 1024; i++)
2791
1855488
        buf[i] = (buf[i] + 2) >> 2;
2792
#endif /* USE_FIXED */
2793
2794
    // window overlapping
2795
3636
    if (ics->use_kb_window[1]) {
2796
        // AAC LD uses a low overlap sine window instead of a KBD window
2797
62
        memcpy(out, saved, 192 * sizeof(*out));
2798
62
        ac->fdsp->vector_fmul_window(out + 192, saved + 192, buf, AAC_RENAME(ff_sine_128), 64);
2799
62
        memcpy(                     out + 320, buf + 64, 192 * sizeof(*out));
2800
    } else {
2801
3574
        ac->fdsp->vector_fmul_window(out, saved, buf, AAC_RENAME(ff_sine_512), 256);
2802
    }
2803
2804
    // buffer update
2805
3636
    memcpy(saved, buf + 256, 256 * sizeof(*saved));
2806
3636
}
2807
2808
26598
static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
2809
{
2810
26598
    INTFLOAT *in    = sce->coeffs;
2811
26598
    INTFLOAT *out   = sce->ret;
2812
26598
    INTFLOAT *saved = sce->saved;
2813
26598
    INTFLOAT *buf  = ac->buf_mdct;
2814
    int i;
2815
26598
    const int n  = ac->oc[1].m4ac.frame_length_short ? 480 : 512;
2816
26598
    const int n2 = n >> 1;
2817
26598
    const int n4 = n >> 2;
2818
26598
    const INTFLOAT *const window = n == 480 ? AAC_RENAME(ff_aac_eld_window_480) :
2819
                                           AAC_RENAME(ff_aac_eld_window_512);
2820
2821
    // Inverse transform, mapped to the conventional IMDCT by
2822
    // Chivukula, R.K.; Reznik, Y.A.; Devarajan, V.,
2823
    // "Efficient algorithms for MPEG-4 AAC-ELD, AAC-LD and AAC-LC filterbanks,"
2824
    // International Conference on Audio, Language and Image Processing, ICALIP 2008.
2825
    // URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4590245&isnumber=4589950
2826
3374198
    for (i = 0; i < n2; i+=2) {
2827
        INTFLOAT temp;
2828
3347600
        temp =  in[i    ]; in[i    ] = -in[n - 1 - i]; in[n - 1 - i] = temp;
2829
3347600
        temp = -in[i + 1]; in[i + 1] =  in[n - 2 - i]; in[n - 2 - i] = temp;
2830
    }
2831
#if !USE_FIXED
2832
16861
    if (n == 480)
2833
7118
        ac->mdct480->imdct_half(ac->mdct480, buf, in, 1);
2834
    else
2835
#endif
2836
19480
        ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
2837
2838
#if USE_FIXED
2839
9980425
    for (i = 0; i < 1024; i++)
2840
9970688
      buf[i] = (buf[i] + 1) >> 1;
2841
#endif /* USE_FIXED */
2842
2843
6721798
    for (i = 0; i < n; i+=2) {
2844
6695200
        buf[i] = -buf[i];
2845
    }
2846
    // Like with the regular IMDCT at this point we still have the middle half
2847
    // of a transform but with even symmetry on the left and odd symmetry on
2848
    // the right
2849
2850
    // window overlapping
2851
    // The spec says to use samples [0..511] but the reference decoder uses
2852
    // samples [128..639].
2853
3374198
    for (i = n4; i < n2; i ++) {
2854
3347600
        out[i - n4] = AAC_MUL31(   buf[    n2 - 1 - i] , window[i       - n4]) +
2855
3347600
                      AAC_MUL31( saved[        i + n2] , window[i +   n - n4]) +
2856
3347600
                      AAC_MUL31(-saved[n + n2 - 1 - i] , window[i + 2*n - n4]) +
2857
3347600
                      AAC_MUL31(-saved[  2*n + n2 + i] , window[i + 3*n - n4]);
2858
    }
2859
6721798
    for (i = 0; i < n2; i ++) {
2860
6695200
        out[n4 + i] = AAC_MUL31(   buf[              i] , window[i + n2       - n4]) +
2861
6695200
                      AAC_MUL31(-saved[      n - 1 - i] , window[i + n2 +   n - n4]) +
2862
6695200
                      AAC_MUL31(-saved[          n + i] , window[i + n2 + 2*n - n4]) +
2863
6695200
                      AAC_MUL31( saved[2*n + n - 1 - i] , window[i + n2 + 3*n - n4]);
2864
    }
2865
3374198
    for (i = 0; i < n4; i ++) {
2866
3347600
        out[n2 + n4 + i] = AAC_MUL31(   buf[    i + n2] , window[i +   n - n4]) +
2867
3347600
                           AAC_MUL31(-saved[n2 - 1 - i] , window[i + 2*n - n4]) +
2868
3347600
                           AAC_MUL31(-saved[n + n2 + i] , window[i + 3*n - n4]);
2869
    }
2870
2871
    // buffer update
2872
26598
    memmove(saved + n, saved, 2 * n * sizeof(*saved));
2873
26598
    memcpy( saved,       buf,     n * sizeof(*saved));
2874
26598
}
2875
2876
/**
2877
 * channel coupling transformation interface
2878
 *
2879
 * @param   apply_coupling_method   pointer to (in)dependent coupling function
2880
 */
2881
175813
static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
2882
                                   enum RawDataBlockType type, int elem_id,
2883
                                   enum CouplingPoint coupling_point,
2884
                                   void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
2885
{
2886
    int i, c;
2887
2888
2988821
    for (i = 0; i < MAX_ELEM_ID; i++) {
2889
2813008
        ChannelElement *cce = ac->che[TYPE_CCE][i];
2890
2813008
        int index = 0;
2891
2892

2813008
        if (cce && cce->coup.coupling_point == coupling_point) {
2893
3915
            ChannelCoupling *coup = &cce->coup;
2894
2895
13317
            for (c = 0; c <= coup->num_coupled; c++) {
2896

9402
                if (coup->type[c] == type && coup->id_select[c] == elem_id) {
2897
2741
                    if (coup->ch_select[c] != 1) {
2898
2561
                        apply_coupling_method(ac, &cc->ch[0], cce, index);
2899
2561
                        if (coup->ch_select[c] != 0)
2900
2561
                            index++;
2901
                    }
2902
2741
                    if (coup->ch_select[c] != 2)
2903
2147
                        apply_coupling_method(ac, &cc->ch[1], cce, index++);
2904
                } else
2905
6661
                    index += 1 + (coup->ch_select[c] == 3);
2906
            }
2907
        }
2908
    }
2909
175813
}
2910
2911
/**
2912
 * Convert spectral data to samples, applying all supported tools as appropriate.
2913
 */
2914
49845
static void spectral_to_sample(AACContext *ac, int samples)
2915
{
2916
    int i, type;
2917
    void (*imdct_and_window)(AACContext *ac, SingleChannelElement *sce);
2918
49845
    switch (ac->oc[1].m4ac.object_type) {
2919
606
    case AOT_ER_AAC_LD:
2920
606
        imdct_and_window = imdct_and_windowing_ld;
2921
606
        break;
2922
16365
    case AOT_ER_AAC_ELD:
2923
16365
        imdct_and_window = imdct_and_windowing_eld;
2924
16365
        break;
2925
32874
    default:
2926
32874
        if (ac->oc[1].m4ac.frame_length_short)
2927
387
            imdct_and_window = imdct_and_windowing_960;
2928
        else
2929
32487
            imdct_and_window = ac->imdct_and_windowing;
2930
    }
2931
249225
    for (type = 3; type >= 0; type--) {
2932
3389460
        for (i = 0; i < MAX_ELEM_ID; i++) {
2933
3190080
            ChannelElement *che = ac->che[type][i];
2934

3190080
            if (che && che->present) {
2935
62891
                if (type <= TYPE_CPE)
2936
58213
                    apply_channel_coupling(ac, che, type, i, BEFORE_TNS, AAC_RENAME(apply_dependent_coupling));
2937
62891
                if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
2938
1784
                    if (che->ch[0].ics.predictor_present) {
2939
538
                        if (che->ch[0].ics.ltp.present)
2940
382
                            ac->apply_ltp(ac, &che->ch[0]);
2941

538
                        if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
2942
404
                            ac->apply_ltp(ac, &che->ch[1]);
2943
                    }
2944
                }
2945
62891
                if (che->ch[0].tns.present)
2946
4633
                    ac->apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
2947
62891
                if (che->ch[1].tns.present)
2948
2294
                    ac->apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
2949
62891
                if (type <= TYPE_CPE)
2950
58213
                    apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, AAC_RENAME(apply_dependent_coupling));
2951

62891
                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
2952
62110
                    imdct_and_window(ac, &che->ch[0]);
2953
62110
                    if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
2954
1784
                        ac->update_ltp(ac, &che->ch[0]);
2955
62110
                    if (type == TYPE_CPE) {
2956
30679
                        imdct_and_window(ac, &che->ch[1]);
2957
30679
                        if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
2958
1784
                            ac->update_ltp(ac, &che->ch[1]);
2959
                    }
2960
62110
                    if (ac->oc[1].m4ac.sbr > 0) {
2961
12411
                        AAC_RENAME(ff_sbr_apply)(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
2962
                    }
2963
                }
2964
62891
                if (type <= TYPE_CCE)
2965
59387
                    apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, AAC_RENAME(apply_independent_coupling));
2966
2967
#if USE_FIXED
2968
                {
2969
                    int j;
2970
                    /* preparation for resampler */
2971
19746147
                    for(j = 0; j<samples; j++){
2972
19726848
                        che->ch[0].ret[j] = (int32_t)av_clip64((int64_t)che->ch[0].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
2973
19726848
                        if(type == TYPE_CPE)
2974
9935872
                            che->ch[1].ret[j] = (int32_t)av_clip64((int64_t)che->ch[1].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
2975
                    }
2976
                }
2977
#endif /* USE_FIXED */
2978
62891
                che->present = 0;
2979
3127189
            } else if (che) {
2980
329
                av_log(ac->avctx, AV_LOG_VERBOSE, "ChannelElement %d.%d missing \n", type, i);
2981
            }
2982
        }
2983
    }
2984
49845
}
2985
2986
4112
static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
2987
{
2988
    int size;
2989
    AACADTSHeaderInfo hdr_info;
2990
    uint8_t layout_map[MAX_ELEM_ID*4][3];
2991
    int layout_map_tags, ret;
2992
2993
4112
    size = ff_adts_header_parse(gb, &hdr_info);
2994
4112
    if (size > 0) {
2995

4112
        if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
2996
            // This is 2 for "VLB " audio in NSV files.
2997
            // See samples/nsv/vlb_audio.
2998
            avpriv_report_missing_feature(ac->avctx,
2999
                                          "More than one AAC RDB per ADTS frame");
3000
            ac->warned_num_aac_frames = 1;
3001
        }
3002
4112
        push_output_configuration(ac);
3003
4112
        if (hdr_info.chan_config) {
3004
4112
            ac->oc[1].m4ac.chan_config = hdr_info.chan_config;
3005
4112
            if ((ret = set_default_channel_config(ac->avctx,
3006
                                                  layout_map,
3007
                                                  &layout_map_tags,
3008
4112
                                                  hdr_info.chan_config)) < 0)
3009
                return ret;
3010
4112
            if ((ret = output_configure(ac, layout_map, layout_map_tags,
3011
4112
                                        FFMAX(ac->oc[1].status,
3012
                                              OC_TRIAL_FRAME), 0)) < 0)
3013
                return ret;
3014
        } else {
3015
            ac->oc[1].m4ac.chan_config = 0;
3016
            /**
3017
             * dual mono frames in Japanese DTV can have chan_config 0
3018
             * WITHOUT specifying PCE.
3019
             *  thus, set dual mono as default.
3020
             */
3021
            if (ac->dmono_mode && ac->oc[0].status == OC_NONE) {
3022
                layout_map_tags = 2;
3023
                layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
3024
                layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
3025
                layout_map[0][1] = 0;
3026
                layout_map[1][1] = 1;
3027
                if (output_configure(ac, layout_map, layout_map_tags,
3028
                                     OC_TRIAL_FRAME, 0))
3029
                    return -7;
3030
            }
3031
        }
3032
4112
        ac->oc[1].m4ac.sample_rate     = hdr_info.sample_rate;
3033
4112
        ac->oc[1].m4ac.sampling_index  = hdr_info.sampling_index;
3034
4112
        ac->oc[1].m4ac.object_type     = hdr_info.object_type;
3035
4112
        ac->oc[1].m4ac.frame_length_short = 0;
3036
4112
        if (ac->oc[0].status != OC_LOCKED ||
3037
4058
            ac->oc[0].m4ac.chan_config != hdr_info.chan_config ||
3038
4058
            ac->oc[0].m4ac.sample_rate != hdr_info.sample_rate) {
3039
54
            ac->oc[1].m4ac.sbr = -1;
3040
54
            ac->oc[1].m4ac.ps  = -1;
3041
        }
3042
4112
        if (!hdr_info.crc_absent)
3043
1
            skip_bits(gb, 16);
3044
    }
3045
4112
    return size;
3046
}
3047
3048
16971
static int aac_decode_er_frame(AVCodecContext *avctx, void *data,
3049
                               int *got_frame_ptr, GetBitContext *gb)
3050
{
3051
16971
    AACContext *ac = avctx->priv_data;
3052
16971
    const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
3053
    ChannelElement *che;
3054
    int err, i;
3055
16971
    int samples = m4ac->frame_length_short ? 960 : 1024;
3056
16971
    int chan_config = m4ac->chan_config;
3057
16971
    int aot = m4ac->object_type;
3058
3059

16971
    if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD)
3060
16971
        samples >>= 1;
3061
3062
16971
    ac->frame = data;
3063
3064
16971
    if ((err = frame_configure_elements(avctx)) < 0)
3065
        return err;
3066
3067
    // The FF_PROFILE_AAC_* defines are all object_type - 1
3068
    // This may lead to an undefined profile being signaled
3069
16971
    ac->avctx->profile = aot - 1;
3070
3071
16971
    ac->tags_mapped = 0;
3072
3073


16971
    if (chan_config < 0 || (chan_config >= 8 && chan_config < 11) || chan_config >= 13) {
3074
        avpriv_request_sample(avctx, "Unknown ER channel configuration %d",
3075
                              chan_config);
3076
        return AVERROR_INVALIDDATA;
3077
    }
3078
35760
    for (i = 0; i < tags_per_config[chan_config]; i++) {
3079
18789
        const int elem_type = aac_channel_layout_map[chan_config-1][i][0];
3080
18789
        const int elem_id   = aac_channel_layout_map[chan_config-1][i][1];
3081
18789
        if (!(che=get_che(ac, elem_type, elem_id))) {
3082
            av_log(ac->avctx, AV_LOG_ERROR,
3083
                   "channel element %d.%d is not allocated\n",
3084
                   elem_type, elem_id);
3085
            return AVERROR_INVALIDDATA;
3086
        }
3087
18789
        che->present = 1;
3088
18789
        if (aot != AOT_ER_AAC_ELD)
3089
2424
            skip_bits(gb, 4);
3090

18789
        switch (elem_type) {
3091
6738
        case TYPE_SCE:
3092
6738
            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3093
6738
            break;
3094
11445
        case TYPE_CPE:
3095
11445
            err = decode_cpe(ac, gb, che);
3096
11445
            break;
3097
606
        case TYPE_LFE:
3098
606
            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3099
606
            break;
3100
        }
3101
18789
        if (err < 0)
3102
            return err;
3103
    }
3104
3105
16971
    spectral_to_sample(ac, samples);
3106
3107

16971
    if (!ac->frame->data[0] && samples) {
3108
        av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
3109
        return AVERROR_INVALIDDATA;
3110
    }
3111
3112
16971
    ac->frame->nb_samples = samples;
3113
16971
    ac->frame->sample_rate = avctx->sample_rate;
3114
16971
    *got_frame_ptr = 1;
3115
3116
16971
    skip_bits_long(gb, get_bits_left(gb));
3117
16971
    return 0;
3118
}
3119
3120
32874
static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
3121
                                int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
3122
{
3123
32874
    AACContext *ac = avctx->priv_data;
3124
32874
    ChannelElement *che = NULL, *che_prev = NULL;
3125
32874
    enum RawDataBlockType elem_type, che_prev_type = TYPE_END;
3126
    int err, elem_id;
3127
32874
    int samples = 0, multiplier, audio_found = 0, pce_found = 0;
3128
32874
    int is_dmono, sce_count = 0;
3129
    int payload_alignment;
3130
32874
    uint8_t che_presence[4][MAX_ELEM_ID] = {{0}};
3131
3132
32874
    ac->frame = data;
3133
3134
32874
    if (show_bits(gb, 12) == 0xfff) {
3135
4112
        if ((err = parse_adts_frame_header(ac, gb)) < 0) {
3136
            av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
3137
            goto fail;
3138
        }
3139
4112
        if (ac->oc[1].m4ac.sampling_index > 12) {
3140
            av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->oc[1].m4ac.sampling_index);
3141
            err = AVERROR_INVALIDDATA;
3142
            goto fail;
3143
        }
3144
    }
3145
3146
32874
    if ((err = frame_configure_elements(avctx)) < 0)
3147
        goto fail;
3148
3149
    // The FF_PROFILE_AAC_* defines are all object_type - 1
3150
    // This may lead to an undefined profile being signaled
3151
32874
    ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
3152
3153
32874
    payload_alignment = get_bits_count(gb);
3154
32874
    ac->tags_mapped = 0;
3155
    // parse
3156
105016
    while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
3157
72142
        elem_id = get_bits(gb, 4);
3158
3159
72142
        if (avctx->debug & FF_DEBUG_STARTCODE)
3160
            av_log(avctx, AV_LOG_DEBUG, "Elem type:%x id:%x\n", elem_type, elem_id);
3161
3162

72142
        if (!avctx->channels && elem_type != TYPE_PCE) {
3163
            err = AVERROR_INVALIDDATA;
3164
            goto fail;
3165
        }
3166
3167
72142
        if (elem_type < TYPE_DSE) {
3168
44102
            if (che_presence[elem_type][elem_id]) {
3169
                int error = che_presence[elem_type][elem_id] > 1;
3170
                av_log(ac->avctx, error ? AV_LOG_ERROR : AV_LOG_DEBUG, "channel element %d.%d duplicate\n",
3171
                       elem_type, elem_id);
3172
                if (error) {
3173
                    err = AVERROR_INVALIDDATA;
3174
                    goto fail;
3175
                }
3176
            }
3177
44102
            che_presence[elem_type][elem_id]++;
3178
3179
44102
            if (!(che=get_che(ac, elem_type, elem_id))) {
3180
                av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
3181
                       elem_type, elem_id);
3182
                err = AVERROR_INVALIDDATA;
3183
                goto fail;
3184
            }
3185
44102
            samples = ac->oc[1].m4ac.frame_length_short ? 960 : 1024;
3186
44102
            che->present = 1;
3187
        }
3188
3189


72142
        switch (elem_type) {
3190
3191
20796
        case TYPE_SCE:
3192
20796
            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3193
20796
            audio_found = 1;
3194
20796
            sce_count++;
3195
20796
            break;
3196
3197
19234
        case TYPE_CPE:
3198
19234
            err = decode_cpe(ac, gb, che);
3199
19234
            audio_found = 1;
3200
19234
            break;
3201
3202
1174
        case TYPE_CCE:
3203
1174
            err = decode_cce(ac, gb, che);
3204
1174
            break;
3205
3206
2898
        case TYPE_LFE:
3207
2898
            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3208
2898
            audio_found = 1;
3209
2898
            break;
3210
3211
2821
        case TYPE_DSE:
3212
2821
            err = skip_data_stream_element(ac, gb);
3213
2821
            break;
3214
3215
        case TYPE_PCE: {
3216
            uint8_t layout_map[MAX_ELEM_ID*4][3];
3217
            int tags;
3218
3219
            int pushed = push_output_configuration(ac);
3220
            if (pce_found && !pushed) {
3221
                err = AVERROR_INVALIDDATA;
3222
                goto fail;
3223
            }
3224
3225
            tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb,
3226
                              payload_alignment);
3227
            if (tags < 0) {
3228
                err = tags;
3229
                break;
3230
            }
3231
            if (pce_found) {
3232
                av_log(avctx, AV_LOG_ERROR,
3233
                       "Not evaluating a further program_config_element as this construct is dubious at best.\n");
3234
                pop_output_configuration(ac);
3235
            } else {
3236
                err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
3237
                if (!err)
3238
                    ac->oc[1].m4ac.chan_config = 0;
3239
                pce_found = 1;
3240
            }
3241
            break;
3242
        }
3243
3244
25219
        case TYPE_FIL:
3245
25219
            if (elem_id == 15)
3246
16455
                elem_id += get_bits(gb, 8) - 1;
3247
25219
            if (get_bits_left(gb) < 8 * elem_id) {
3248
                    av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
3249
                    err = AVERROR_INVALIDDATA;
3250
                    goto fail;
3251
            }
3252
25219
            err = 0;
3253
48917
            while (elem_id > 0) {
3254
23698
                int ret = decode_extension_payload(ac, gb, elem_id, che_prev, che_prev_type);
3255
23698
                if (ret < 0) {
3256
                    err = ret;
3257
                    break;
3258
                }
3259
23698
                elem_id -= ret;
3260
            }
3261
25219
            break;
3262
3263
        default:
3264
            err = AVERROR_BUG; /* should not happen, but keeps compiler happy */
3265
            break;
3266
        }
3267
3268
72142
        if (elem_type < TYPE_DSE) {
3269
44102
            che_prev      = che;
3270
44102
            che_prev_type = elem_type;
3271
        }
3272
3273
72142
        if (err)
3274
            goto fail;
3275
3276
72142
        if (get_bits_left(gb) < 3) {
3277
            av_log(avctx, AV_LOG_ERROR, overread_err);
3278
            err = AVERROR_INVALIDDATA;
3279
            goto fail;
3280
        }
3281
    }
3282
3283
32874
    if (!avctx->channels) {
3284
        *got_frame_ptr = 0;
3285
        return 0;
3286
    }
3287
3288

32874
    multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
3289
32874
    samples <<= multiplier;
3290
3291
32874
    spectral_to_sample(ac, samples);
3292
3293

32874
    if (ac->oc[1].status && audio_found) {
3294
32874
        avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
3295
32874
        avctx->frame_size = samples;
3296
32874
        ac->oc[1].status = OC_LOCKED;
3297
    }
3298
3299
32874
    if (multiplier)
3300
5583
        avctx->internal->skip_samples_multiplier = 2;
3301
3302

32874
    if (!ac->frame->data[0] && samples) {
3303
        av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
3304
        err = AVERROR_INVALIDDATA;
3305
        goto fail;
3306
    }
3307
3308
32874
    if (samples) {
3309
32874
        ac->frame->nb_samples = samples;
3310
32874
        ac->frame->sample_rate = avctx->sample_rate;
3311
    } else
3312
        av_frame_unref(ac->frame);
3313
32874
    *got_frame_ptr = !!samples;
3314
3315
    /* for dual-mono audio (SCE + SCE) */
3316

32874
    is_dmono = ac->dmono_mode && sce_count == 2 &&
3317
               ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
3318
32874
    if (is_dmono) {
3319
        if (ac->dmono_mode == 1)
3320
            ((AVFrame *)data)->data[1] =((AVFrame *)data)->data[0];
3321
        else if (ac->dmono_mode == 2)
3322
            ((AVFrame *)data)->data[0] =((AVFrame *)data)->data[1];
3323
    }
3324
3325
32874
    return 0;
3326
fail:
3327
    pop_output_configuration(ac);
3328
    return err;
3329
}
3330
3331
49331
static int aac_decode_frame(AVCodecContext *avctx, void *data,
3332
                            int *got_frame_ptr, AVPacket *avpkt)
3333
{
3334
49331
    AACContext *ac = avctx->priv_data;
3335
49331
    const uint8_t *buf = avpkt->data;
3336
49331
    int buf_size = avpkt->size;
3337
    GetBitContext gb;
3338
    int buf_consumed;
3339
    int buf_offset;
3340
    int err;
3341
    int new_extradata_size;
3342
49331
    const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
3343
                                       AV_PKT_DATA_NEW_EXTRADATA,
3344
                                       &new_extradata_size);
3345
    int jp_dualmono_size;
3346
49331
    const uint8_t *jp_dualmono   = av_packet_get_side_data(avpkt,
3347
                                       AV_PKT_DATA_JP_DUALMONO,
3348
                                       &jp_dualmono_size);
3349
3350
49331
    if (new_extradata) {
3351
        /* discard previous configuration */
3352
1
        ac->oc[1].status = OC_NONE;
3353
1
        err = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
3354
                                           new_extradata,
3355
1
                                           new_extradata_size * 8LL, 1);
3356
1
        if (err < 0) {
3357
            return err;
3358
        }
3359
    }
3360
3361
49331
    ac->dmono_mode = 0;
3362

49331
    if (jp_dualmono && jp_dualmono_size > 0)
3363
        ac->dmono_mode =  1 + *jp_dualmono;
3364
49331
    if (ac->force_dmono_mode >= 0)
3365
14933
        ac->dmono_mode = ac->force_dmono_mode;
3366
3367
49331
    if (INT_MAX / 8 <= buf_size)
3368
        return AVERROR_INVALIDDATA;
3369
3370
49331
    if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
3371
        return err;
3372
3373
49331