← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty

« back to all changes in this revision

Viewing changes to libavcodec/aacdec.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-04-19 15:04:55 UTC
  • mfrom: (1.2.1 upstream)
  • mto: (1.3.4 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20110419150455-c1nac6gjm3t2aa4n
Tags: 4:0.7~b1-1
* New upstream version
* bump SONAME and SHLIBS
* configure flags --disable-stripping was removed upstream
* the MAINTAINERS file was removed upstream
* remove patch disable-configuration-warning.patch
* drop avfilter confflags, it is enable by default in 0.7
* libfaad wrapper has been removed upstream
* also update the *contents* of the lintian overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/aacdec.c
3
3
 * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
4
4
 * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
5
5
 *
6
 
 * This file is part of FFmpeg.
7
 
 *
8
 
 * FFmpeg is free software; you can redistribute it and/or
 
6
 * AAC LATM decoder
 
7
 * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
 
8
 * Copyright (c) 2010      Janne Grunau <janne-ffmpeg@jannau.net>
 
9
 *
 
10
 * This file is part of Libav.
 
11
 *
 
12
 * Libav is free software; you can redistribute it and/or
9
13
 * modify it under the terms of the GNU Lesser General Public
10
14
 * License as published by the Free Software Foundation; either
11
15
 * version 2.1 of the License, or (at your option) any later version.
12
16
 *
13
 
 * FFmpeg is distributed in the hope that it will be useful,
 
17
 * Libav is distributed in the hope that it will be useful,
14
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
20
 * Lesser General Public License for more details.
17
21
 *
18
22
 * You should have received a copy of the GNU Lesser General Public
19
 
 * License along with FFmpeg; if not, write to the Free Software
 
23
 * License along with Libav; if not, write to the Free Software
20
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
25
 */
22
26
 
38
42
 * Y                    filterbank - standard
39
43
 * N (code in SoC repo) filterbank - Scalable Sample Rate
40
44
 * Y                    Temporal Noise Shaping
41
 
 * N (code in SoC repo) Long Term Prediction
 
45
 * Y                    Long Term Prediction
42
46
 * Y                    intensity stereo
43
47
 * Y                    channel coupling
44
48
 * Y                    frequency domain prediction
81
85
#include "get_bits.h"
82
86
#include "dsputil.h"
83
87
#include "fft.h"
 
88
#include "fmtconvert.h"
84
89
#include "lpc.h"
 
90
#include "kbdwin.h"
 
91
#include "sinewin.h"
85
92
 
86
93
#include "aac.h"
87
94
#include "aactab.h"
90
97
#include "sbr.h"
91
98
#include "aacsbr.h"
92
99
#include "mpeg4audio.h"
93
 
#include "aac_parser.h"
 
100
#include "aacadtsdec.h"
94
101
 
95
102
#include <assert.h>
96
103
#include <errno.h>
113
120
 
114
121
static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
115
122
{
116
 
    /* Some buggy encoders appear to set all elem_ids to zero and rely on
117
 
    channels always occurring in the same order. This is expressly forbidden
118
 
    by the spec but we will try to work around it.
119
 
    */
120
 
    int err_printed = 0;
121
 
    while (ac->tags_seen_this_frame[type][elem_id] && elem_id < MAX_ELEM_ID) {
122
 
        if (ac->output_configured < OC_LOCKED && !err_printed) {
123
 
            av_log(ac->avctx, AV_LOG_WARNING, "Duplicate channel tag found, attempting to remap.\n");
124
 
            err_printed = 1;
125
 
        }
126
 
        elem_id++;
127
 
    }
128
 
    if (elem_id == MAX_ELEM_ID)
129
 
        return NULL;
130
 
    ac->tags_seen_this_frame[type][elem_id] = 1;
131
 
 
132
 
    if (ac->tag_che_map[type][elem_id]) {
 
123
    // For PCE based channel configurations map the channels solely based on tags.
 
124
    if (!ac->m4ac.chan_config) {
133
125
        return ac->tag_che_map[type][elem_id];
134
126
    }
135
 
    if (ac->tags_mapped >= tags_per_config[ac->m4ac.chan_config]) {
136
 
        return NULL;
137
 
    }
 
127
    // For indexed channel configurations map the channels solely based on position.
138
128
    switch (ac->m4ac.chan_config) {
139
129
    case 7:
140
130
        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
180
170
/**
181
171
 * Check for the channel element in the current channel position configuration.
182
172
 * If it exists, make sure the appropriate element is allocated and map the
183
 
 * channel order to match the internal FFmpeg channel layout.
 
173
 * channel order to match the internal Libav channel layout.
184
174
 *
185
175
 * @param   che_pos current channel position configuration
186
176
 * @param   type channel element type
242
232
        }
243
233
 
244
234
        memset(ac->tag_che_map, 0,       4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
245
 
        ac->tags_mapped = 0;
246
235
 
247
236
        avctx->channel_layout = aac_channel_layout[channel_config - 1];
248
237
    } else {
263
252
        }
264
253
 
265
254
        memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
266
 
        ac->tags_mapped = 4 * MAX_ELEM_ID;
267
255
 
268
256
        avctx->channel_layout = 0;
269
257
    }
300
288
 *
301
289
 * @return  Returns error status. 0 - OK, !0 - error
302
290
 */
303
 
static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
 
291
static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
 
292
                      enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
304
293
                      GetBitContext *gb)
305
294
{
306
295
    int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
309
298
    skip_bits(gb, 2);  // object_type
310
299
 
311
300
    sampling_index = get_bits(gb, 4);
312
 
    if (ac->m4ac.sampling_index != sampling_index)
313
 
        av_log(ac->avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
 
301
    if (m4ac->sampling_index != sampling_index)
 
302
        av_log(avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
314
303
 
315
304
    num_front       = get_bits(gb, 4);
316
305
    num_side        = get_bits(gb, 4);
341
330
    /* comment field, first byte is length */
342
331
    comment_len = get_bits(gb, 8) * 8;
343
332
    if (get_bits_left(gb) < comment_len) {
344
 
        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 
333
        av_log(avctx, AV_LOG_ERROR, overread_err);
345
334
        return -1;
346
335
    }
347
336
    skip_bits_long(gb, comment_len);
356
345
 *
357
346
 * @return  Returns error status. 0 - OK, !0 - error
358
347
 */
359
 
static av_cold int set_default_channel_config(AACContext *ac,
 
348
static av_cold int set_default_channel_config(AVCodecContext *avctx,
360
349
                                      enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
361
350
                                      int channel_config)
362
351
{
363
352
    if (channel_config < 1 || channel_config > 7) {
364
 
        av_log(ac->avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
 
353
        av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
365
354
               channel_config);
366
355
        return -1;
367
356
    }
397
386
/**
398
387
 * Decode GA "General Audio" specific configuration; reference: table 4.1.
399
388
 *
 
389
 * @param   ac          pointer to AACContext, may be null
 
390
 * @param   avctx       pointer to AVCCodecContext, used for logging
 
391
 *
400
392
 * @return  Returns error status. 0 - OK, !0 - error
401
393
 */
402
 
static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb,
 
394
static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
 
395
                                     GetBitContext *gb,
 
396
                                     MPEG4AudioConfig *m4ac,
403
397
                                     int channel_config)
404
398
{
405
399
    enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
406
400
    int extension_flag, ret;
407
401
 
408
402
    if (get_bits1(gb)) { // frameLengthFlag
409
 
        av_log_missing_feature(ac->avctx, "960/120 MDCT window is", 1);
 
403
        av_log_missing_feature(avctx, "960/120 MDCT window is", 1);
410
404
        return -1;
411
405
    }
412
406
 
414
408
        skip_bits(gb, 14);   // coreCoderDelay
415
409
    extension_flag = get_bits1(gb);
416
410
 
417
 
    if (ac->m4ac.object_type == AOT_AAC_SCALABLE ||
418
 
        ac->m4ac.object_type == AOT_ER_AAC_SCALABLE)
 
411
    if (m4ac->object_type == AOT_AAC_SCALABLE ||
 
412
        m4ac->object_type == AOT_ER_AAC_SCALABLE)
419
413
        skip_bits(gb, 3);     // layerNr
420
414
 
421
415
    memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
422
416
    if (channel_config == 0) {
423
417
        skip_bits(gb, 4);  // element_instance_tag
424
 
        if ((ret = decode_pce(ac, new_che_pos, gb)))
 
418
        if ((ret = decode_pce(avctx, m4ac, new_che_pos, gb)))
425
419
            return ret;
426
420
    } else {
427
 
        if ((ret = set_default_channel_config(ac, new_che_pos, channel_config)))
 
421
        if ((ret = set_default_channel_config(avctx, new_che_pos, channel_config)))
428
422
            return ret;
429
423
    }
430
 
    if ((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
 
424
    if (ac && (ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
431
425
        return ret;
432
426
 
433
427
    if (extension_flag) {
434
 
        switch (ac->m4ac.object_type) {
 
428
        switch (m4ac->object_type) {
435
429
        case AOT_ER_BSAC:
436
430
            skip_bits(gb, 5);    // numOfSubFrame
437
431
            skip_bits(gb, 11);   // layer_length
454
448
/**
455
449
 * Decode audio specific configuration; reference: table 1.13.
456
450
 *
 
451
 * @param   ac          pointer to AACContext, may be null
 
452
 * @param   avctx       pointer to AVCCodecContext, used for logging
 
453
 * @param   m4ac        pointer to MPEG4AudioConfig, used for parsing
457
454
 * @param   data        pointer to AVCodecContext extradata
458
455
 * @param   data_size   size of AVCCodecContext extradata
459
456
 *
460
 
 * @return  Returns error status. 0 - OK, !0 - error
 
457
 * @return  Returns error status or number of consumed bits. <0 - error
461
458
 */
462
 
static int decode_audio_specific_config(AACContext *ac, void *data,
463
 
                                        int data_size)
 
459
static int decode_audio_specific_config(AACContext *ac,
 
460
                                        AVCodecContext *avctx,
 
461
                                        MPEG4AudioConfig *m4ac,
 
462
                                        const uint8_t *data, int data_size)
464
463
{
465
464
    GetBitContext gb;
466
465
    int i;
467
466
 
468
467
    init_get_bits(&gb, data, data_size * 8);
469
468
 
470
 
    if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0)
 
469
    if ((i = ff_mpeg4audio_get_config(m4ac, data, data_size)) < 0)
471
470
        return -1;
472
 
    if (ac->m4ac.sampling_index > 12) {
473
 
        av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
 
471
    if (m4ac->sampling_index > 12) {
 
472
        av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);
474
473
        return -1;
475
474
    }
476
 
    if (ac->m4ac.sbr == 1 && ac->m4ac.ps == -1)
477
 
        ac->m4ac.ps = 1;
 
475
    if (m4ac->sbr == 1 && m4ac->ps == -1)
 
476
        m4ac->ps = 1;
478
477
 
479
478
    skip_bits_long(&gb, i);
480
479
 
481
 
    switch (ac->m4ac.object_type) {
 
480
    switch (m4ac->object_type) {
482
481
    case AOT_AAC_MAIN:
483
482
    case AOT_AAC_LC:
484
 
        if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config))
 
483
    case AOT_AAC_LTP:
 
484
        if (decode_ga_specific_config(ac, avctx, &gb, m4ac, m4ac->chan_config))
485
485
            return -1;
486
486
        break;
487
487
    default:
488
 
        av_log(ac->avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
489
 
               ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type);
 
488
        av_log(avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
 
489
               m4ac->sbr == 1? "SBR+" : "", m4ac->object_type);
490
490
        return -1;
491
491
    }
492
 
    return 0;
 
492
 
 
493
    return get_bits_count(&gb);
493
494
}
494
495
 
495
496
/**
542
543
    ac->m4ac.sample_rate = avctx->sample_rate;
543
544
 
544
545
    if (avctx->extradata_size > 0) {
545
 
        if (decode_audio_specific_config(ac, avctx->extradata, avctx->extradata_size))
 
546
        if (decode_audio_specific_config(ac, ac->avctx, &ac->m4ac,
 
547
                                         avctx->extradata,
 
548
                                         avctx->extradata_size) < 0)
546
549
            return -1;
547
550
    }
548
551
 
549
 
    avctx->sample_fmt = SAMPLE_FMT_S16;
 
552
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
550
553
 
551
554
    AAC_INIT_VLC_STATIC( 0, 304);
552
555
    AAC_INIT_VLC_STATIC( 1, 270);
563
566
    ff_aac_sbr_init();
564
567
 
565
568
    dsputil_init(&ac->dsp, avctx);
 
569
    ff_fmt_convert_init(&ac->fmt_conv, avctx);
566
570
 
567
571
    ac->random_state = 0x1f2e3d4c;
568
572
 
569
573
    // -1024 - Compensate wrong IMDCT method.
570
 
    // 32768 - Required to scale values to the correct range for the bias method
571
 
    //         for float to int16 conversion.
572
 
 
573
 
    if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
574
 
        ac->add_bias  = 385.0f;
575
 
        ac->sf_scale  = 1. / (-1024. * 32768.);
576
 
        ac->sf_offset = 0;
577
 
    } else {
578
 
        ac->add_bias  = 0.0f;
579
 
        ac->sf_scale  = 1. / -1024.;
580
 
        ac->sf_offset = 60;
581
 
    }
 
574
    // 60    - Required to scale values to the correct range [-32768,32767]
 
575
    //         for float to int16 conversion. (1 << (60 / 4)) == 32768
 
576
    ac->sf_scale  = 1. / -1024.;
 
577
    ac->sf_offset = 60;
582
578
 
583
579
    ff_aac_tableinit();
584
580
 
587
583
                    ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
588
584
                    352);
589
585
 
590
 
    ff_mdct_init(&ac->mdct, 11, 1, 1.0);
591
 
    ff_mdct_init(&ac->mdct_small, 8, 1, 1.0);
 
586
    ff_mdct_init(&ac->mdct,       11, 1, 1.0);
 
587
    ff_mdct_init(&ac->mdct_small,  8, 1, 1.0);
 
588
    ff_mdct_init(&ac->mdct_ltp,   11, 0, 1.0);
592
589
    // window initialization
593
590
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
594
591
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
638
635
}
639
636
 
640
637
/**
 
638
 * Decode Long Term Prediction data; reference: table 4.xx.
 
639
 */
 
640
static void decode_ltp(AACContext *ac, LongTermPrediction *ltp,
 
641
                       GetBitContext *gb, uint8_t max_sfb)
 
642
{
 
643
    int sfb;
 
644
 
 
645
    ltp->lag  = get_bits(gb, 11);
 
646
    ltp->coef = ltp_coef[get_bits(gb, 3)] * ac->sf_scale;
 
647
    for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
 
648
        ltp->used[sfb] = get_bits1(gb);
 
649
}
 
650
 
 
651
/**
641
652
 * Decode Individual Channel Stream info; reference: table 4.6.
642
653
 *
643
654
 * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
691
702
                memset(ics, 0, sizeof(IndividualChannelStream));
692
703
                return -1;
693
704
            } else {
694
 
                av_log_missing_feature(ac->avctx, "Predictor bit set but LTP is", 1);
695
 
                memset(ics, 0, sizeof(IndividualChannelStream));
696
 
                return -1;
 
705
                if ((ics->ltp.present = get_bits(gb, 1)))
 
706
                    decode_ltp(ac, &ics->ltp, gb, ics->max_sfb);
697
707
            }
698
708
        }
699
709
    }
954
964
    union float754 s = { .f = *scale };
955
965
    union float754 t;
956
966
 
957
 
    t.i = s.i ^ (sign & 1<<31);
 
967
    t.i = s.i ^ (sign & 1U<<31);
958
968
    *dst++ = v[idx    & 3] * t.f;
959
969
 
960
970
    sign <<= nz & 1; nz >>= 1;
961
 
    t.i = s.i ^ (sign & 1<<31);
 
971
    t.i = s.i ^ (sign & 1U<<31);
962
972
    *dst++ = v[idx>>2 & 3] * t.f;
963
973
 
964
974
    sign <<= nz & 1; nz >>= 1;
965
 
    t.i = s.i ^ (sign & 1<<31);
 
975
    t.i = s.i ^ (sign & 1U<<31);
966
976
    *dst++ = v[idx>>4 & 3] * t.f;
967
977
 
968
978
    sign <<= nz & 1; nz >>= 1;
969
 
    t.i = s.i ^ (sign & 1<<31);
 
979
    t.i = s.i ^ (sign & 1U<<31);
970
980
    *dst++ = v[idx>>6 & 3] * t.f;
971
981
 
972
982
    return dst;
995
1005
    const int c = 1024 / ics->num_windows;
996
1006
    const uint16_t *offsets = ics->swb_offset;
997
1007
    float *coef_base = coef;
998
 
    int err_idx;
999
1008
 
1000
1009
    for (g = 0; g < ics->num_windows; g++)
1001
1010
        memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb]));
1031
1040
                const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1032
1041
                const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
1033
1042
                VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1034
 
                const int cb_size = ff_aac_spectral_sizes[cbt_m1];
1035
1043
                OPEN_READER(re, gb);
1036
1044
 
1037
1045
                switch (cbt_m1 >> 1) {
1046
1054
 
1047
1055
                            UPDATE_CACHE(re, gb);
1048
1056
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1049
 
 
1050
 
                            if (code >= cb_size) {
1051
 
                                err_idx = code;
1052
 
                                goto err_cb_overflow;
1053
 
                            }
1054
 
 
1055
1057
                            cb_idx = cb_vector_idx[code];
1056
1058
                            cf = VMUL4(cf, vq, cb_idx, sf + idx);
1057
1059
                        } while (len -= 4);
1071
1073
 
1072
1074
                            UPDATE_CACHE(re, gb);
1073
1075
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1074
 
 
1075
 
                            if (code >= cb_size) {
1076
 
                                err_idx = code;
1077
 
                                goto err_cb_overflow;
1078
 
                            }
1079
 
 
1080
 
#if MIN_CACHE_BITS < 20
1081
 
                            UPDATE_CACHE(re, gb);
1082
 
#endif
1083
1076
                            cb_idx = cb_vector_idx[code];
1084
1077
                            nnz = cb_idx >> 8 & 15;
1085
1078
                            bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1100
1093
 
1101
1094
                            UPDATE_CACHE(re, gb);
1102
1095
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1103
 
 
1104
 
                            if (code >= cb_size) {
1105
 
                                err_idx = code;
1106
 
                                goto err_cb_overflow;
1107
 
                            }
1108
 
 
1109
1096
                            cb_idx = cb_vector_idx[code];
1110
1097
                            cf = VMUL2(cf, vq, cb_idx, sf + idx);
1111
1098
                        } while (len -= 2);
1126
1113
 
1127
1114
                            UPDATE_CACHE(re, gb);
1128
1115
                            GET_VLC(code, re, gb, vlc_tab, 8, 2);
1129
 
 
1130
 
                            if (code >= cb_size) {
1131
 
                                err_idx = code;
1132
 
                                goto err_cb_overflow;
1133
 
                            }
1134
 
 
1135
1116
                            cb_idx = cb_vector_idx[code];
1136
1117
                            nnz = cb_idx >> 8 & 15;
1137
1118
                            sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12);
1163
1144
                                continue;
1164
1145
                            }
1165
1146
 
1166
 
                            if (code >= cb_size) {
1167
 
                                err_idx = code;
1168
 
                                goto err_cb_overflow;
1169
 
                            }
1170
 
 
1171
1147
                            cb_idx = cb_vector_idx[code];
1172
1148
                            nnz = cb_idx >> 12;
1173
1149
                            nzt = cb_idx >> 8;
1189
1165
                                        return -1;
1190
1166
                                    }
1191
1167
 
1192
 
#if MIN_CACHE_BITS < 21
1193
 
                                    LAST_SKIP_BITS(re, gb, b + 1);
1194
 
                                    UPDATE_CACHE(re, gb);
1195
 
#else
1196
1168
                                    SKIP_BITS(re, gb, b + 1);
1197
 
#endif
1198
1169
                                    b += 4;
1199
1170
                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
1200
1171
                                    LAST_SKIP_BITS(re, gb, b);
1201
 
                                    *icf++ = cbrt_tab[n] | (bits & 1<<31);
 
1172
                                    *icf++ = cbrt_tab[n] | (bits & 1U<<31);
1202
1173
                                    bits <<= 1;
1203
1174
                                } else {
1204
1175
                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1205
 
                                    *icf++ = (bits & 1<<31) | v;
 
1176
                                    *icf++ = (bits & 1U<<31) | v;
1206
1177
                                    bits <<= !!v;
1207
1178
                                }
1208
1179
                                cb_idx >>= 4;
1236
1207
        }
1237
1208
    }
1238
1209
    return 0;
1239
 
 
1240
 
err_cb_overflow:
1241
 
    av_log(ac->avctx, AV_LOG_ERROR,
1242
 
           "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
1243
 
           band_type[idx], err_idx, ff_aac_spectral_sizes[band_type[idx]]);
1244
 
    return -1;
1245
1210
}
1246
1211
 
1247
1212
static av_always_inline float flt16_round(float pf)
1268
1233
    return pun.f;
1269
1234
}
1270
1235
 
1271
 
static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef,
 
1236
static av_always_inline void predict(PredictorState *ps, float *coef,
 
1237
                                     float sf_scale, float inv_sf_scale,
1272
1238
                    int output_enable)
1273
1239
{
1274
1240
    const float a     = 0.953125; // 61.0 / 64
1276
1242
    float e0, e1;
1277
1243
    float pv;
1278
1244
    float k1, k2;
1279
 
 
1280
 
    k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
1281
 
    k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
1282
 
 
1283
 
    pv = flt16_round(k1 * ps->r0 + k2 * ps->r1);
 
1245
    float   r0 = ps->r0,     r1 = ps->r1;
 
1246
    float cor0 = ps->cor0, cor1 = ps->cor1;
 
1247
    float var0 = ps->var0, var1 = ps->var1;
 
1248
 
 
1249
    k1 = var0 > 1 ? cor0 * flt16_even(a / var0) : 0;
 
1250
    k2 = var1 > 1 ? cor1 * flt16_even(a / var1) : 0;
 
1251
 
 
1252
    pv = flt16_round(k1 * r0 + k2 * r1);
1284
1253
    if (output_enable)
1285
 
        *coef += pv * ac->sf_scale;
1286
 
 
1287
 
    e0 = *coef / ac->sf_scale;
1288
 
    e1 = e0 - k1 * ps->r0;
1289
 
 
1290
 
    ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1);
1291
 
    ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5 * (ps->r1 * ps->r1 + e1 * e1));
1292
 
    ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0);
1293
 
    ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5 * (ps->r0 * ps->r0 + e0 * e0));
1294
 
 
1295
 
    ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0));
 
1254
        *coef += pv * sf_scale;
 
1255
 
 
1256
    e0 = *coef * inv_sf_scale;
 
1257
    e1 = e0 - k1 * r0;
 
1258
 
 
1259
    ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1);
 
1260
    ps->var1 = flt16_trunc(alpha * var1 + 0.5f * (r1 * r1 + e1 * e1));
 
1261
    ps->cor0 = flt16_trunc(alpha * cor0 + r0 * e0);
 
1262
    ps->var0 = flt16_trunc(alpha * var0 + 0.5f * (r0 * r0 + e0 * e0));
 
1263
 
 
1264
    ps->r1 = flt16_trunc(a * (r0 - k1 * e0));
1296
1265
    ps->r0 = flt16_trunc(a * e0);
1297
1266
}
1298
1267
 
1302
1271
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
1303
1272
{
1304
1273
    int sfb, k;
 
1274
    float sf_scale = ac->sf_scale, inv_sf_scale = 1 / ac->sf_scale;
1305
1275
 
1306
1276
    if (!sce->ics.predictor_initialized) {
1307
1277
        reset_all_predictors(sce->predictor_state);
1311
1281
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
1312
1282
        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
1313
1283
            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
1314
 
                predict(ac, &sce->predictor_state[k], &sce->coeffs[k],
 
1284
                predict(&sce->predictor_state[k], &sce->coeffs[k],
 
1285
                        sf_scale, inv_sf_scale,
1315
1286
                        sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
1316
1287
            }
1317
1288
        }
1417
1388
 *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
1418
1389
 *                      [3] reserved for scalable AAC
1419
1390
 */
1420
 
static void apply_intensity_stereo(ChannelElement *cpe, int ms_present)
 
1391
static void apply_intensity_stereo(AACContext *ac, ChannelElement *cpe, int ms_present)
1421
1392
{
1422
1393
    const IndividualChannelStream *ics = &cpe->ch[1].ics;
1423
1394
    SingleChannelElement         *sce1 = &cpe->ch[1];
1424
1395
    float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
1425
1396
    const uint16_t *offsets = ics->swb_offset;
1426
 
    int g, group, i, k, idx = 0;
 
1397
    int g, group, i, idx = 0;
1427
1398
    int c;
1428
1399
    float scale;
1429
1400
    for (g = 0; g < ics->num_window_groups; g++) {
1436
1407
                        c *= 1 - 2 * cpe->ms_mask[idx];
1437
1408
                    scale = c * sce1->sf[idx];
1438
1409
                    for (group = 0; group < ics->group_len[g]; group++)
1439
 
                        for (k = offsets[i]; k < offsets[i + 1]; k++)
1440
 
                            coef1[group * 128 + k] = scale * coef0[group * 128 + k];
 
1410
                        ac->dsp.vector_fmul_scalar(coef1 + group * 128 + offsets[i],
 
1411
                                                   coef0 + group * 128 + offsets[i],
 
1412
                                                   scale,
 
1413
                                                   offsets[i + 1] - offsets[i]);
1441
1414
                }
1442
1415
            } else {
1443
1416
                int bt_run_end = sce1->band_type_run_end[idx];
1453
1426
/**
1454
1427
 * Decode a channel_pair_element; reference: table 4.4.
1455
1428
 *
1456
 
 * @param   elem_id Identifies the instance of a syntax element.
1457
 
 *
1458
1429
 * @return  Returns error status. 0 - OK, !0 - error
1459
1430
 */
1460
1431
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
1468
1439
        i = cpe->ch[1].ics.use_kb_window[0];
1469
1440
        cpe->ch[1].ics = cpe->ch[0].ics;
1470
1441
        cpe->ch[1].ics.use_kb_window[1] = i;
 
1442
        if (cpe->ch[1].ics.predictor_present && (ac->m4ac.object_type != AOT_AAC_MAIN))
 
1443
            if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
 
1444
                decode_ltp(ac, &cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
1471
1445
        ms_present = get_bits(gb, 2);
1472
1446
        if (ms_present == 3) {
1473
1447
            av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1489
1463
        }
1490
1464
    }
1491
1465
 
1492
 
    apply_intensity_stereo(cpe, ms_present);
 
1466
    apply_intensity_stereo(ac, cpe, ms_present);
1493
1467
    return 0;
1494
1468
}
1495
1469
 
 
1470
static const float cce_scale[] = {
 
1471
    1.09050773266525765921, //2^(1/8)
 
1472
    1.18920711500272106672, //2^(1/4)
 
1473
    M_SQRT2,
 
1474
    2,
 
1475
};
 
1476
 
1496
1477
/**
1497
1478
 * Decode coupling_channel_element; reference: table 4.8.
1498
1479
 *
1499
 
 * @param   elem_id Identifies the instance of a syntax element.
1500
 
 *
1501
1480
 * @return  Returns error status. 0 - OK, !0 - error
1502
1481
 */
1503
1482
static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
1525
1504
    coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
1526
1505
 
1527
1506
    sign  = get_bits(gb, 1);
1528
 
    scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3));
 
1507
    scale = cce_scale[get_bits(gb, 2)];
1529
1508
 
1530
1509
    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
1531
1510
        return ret;
1538
1517
        if (c) {
1539
1518
            cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
1540
1519
            gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
1541
 
            gain_cache = pow(scale, -gain);
 
1520
            gain_cache = powf(scale, -gain);
1542
1521
        }
1543
1522
        if (coup->coupling_point == AFTER_IMDCT) {
1544
1523
            coup->gain[c][0] = gain_cache;
1555
1534
                                    s  -= 2 * (t & 0x1);
1556
1535
                                    t >>= 1;
1557
1536
                                }
1558
 
                                gain_cache = pow(scale, -t) * s;
 
1537
                                gain_cache = powf(scale, -t) * s;
1559
1538
                            }
1560
1539
                        }
1561
1540
                        coup->gain[c][idx] = gain_cache;
1702
1681
    int w, filt, m, i;
1703
1682
    int bottom, top, order, start, end, size, inc;
1704
1683
    float lpc[TNS_MAX_ORDER];
 
1684
    float tmp[TNS_MAX_ORDER];
1705
1685
 
1706
1686
    for (w = 0; w < ics->num_windows; w++) {
1707
1687
        bottom = ics->num_swb;
1727
1707
            }
1728
1708
            start += w * 128;
1729
1709
 
1730
 
            // ar filter
1731
 
            for (m = 0; m < size; m++, start += inc)
1732
 
                for (i = 1; i <= FFMIN(m, order); i++)
1733
 
                    coef[start] -= coef[start - i * inc] * lpc[i - 1];
 
1710
            if (decode) {
 
1711
                // ar filter
 
1712
                for (m = 0; m < size; m++, start += inc)
 
1713
                    for (i = 1; i <= FFMIN(m, order); i++)
 
1714
                        coef[start] -= coef[start - i * inc] * lpc[i - 1];
 
1715
            } else {
 
1716
                // ma filter
 
1717
                for (m = 0; m < size; m++, start += inc) {
 
1718
                    tmp[0] = coef[start];
 
1719
                    for (i = 1; i <= FFMIN(m, order); i++)
 
1720
                        coef[start] += tmp[i] * lpc[i - 1];
 
1721
                    for (i = order; i > 0; i--)
 
1722
                        tmp[i] = tmp[i - 1];
 
1723
                }
 
1724
            }
1734
1725
        }
1735
1726
    }
1736
1727
}
1737
1728
 
1738
1729
/**
 
1730
 *  Apply windowing and MDCT to obtain the spectral
 
1731
 *  coefficient from the predicted sample by LTP.
 
1732
 */
 
1733
static void windowing_and_mdct_ltp(AACContext *ac, float *out,
 
1734
                                   float *in, IndividualChannelStream *ics)
 
1735
{
 
1736
    const float *lwindow      = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
 
1737
    const float *swindow      = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
 
1738
    const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
 
1739
    const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
 
1740
 
 
1741
    if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
 
1742
        ac->dsp.vector_fmul(in, in, lwindow_prev, 1024);
 
1743
    } else {
 
1744
        memset(in, 0, 448 * sizeof(float));
 
1745
        ac->dsp.vector_fmul(in + 448, in + 448, swindow_prev, 128);
 
1746
        memcpy(in + 576, in + 576, 448 * sizeof(float));
 
1747
    }
 
1748
    if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
 
1749
        ac->dsp.vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
 
1750
    } else {
 
1751
        memcpy(in + 1024, in + 1024, 448 * sizeof(float));
 
1752
        ac->dsp.vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
 
1753
        memset(in + 1024 + 576, 0, 448 * sizeof(float));
 
1754
    }
 
1755
    ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
 
1756
}
 
1757
 
 
1758
/**
 
1759
 * Apply the long term prediction
 
1760
 */
 
1761
static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
 
1762
{
 
1763
    const LongTermPrediction *ltp = &sce->ics.ltp;
 
1764
    const uint16_t *offsets = sce->ics.swb_offset;
 
1765
    int i, sfb;
 
1766
 
 
1767
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
 
1768
        float *predTime = sce->ret;
 
1769
        float *predFreq = ac->buf_mdct;
 
1770
        int16_t num_samples = 2048;
 
1771
 
 
1772
        if (ltp->lag < 1024)
 
1773
            num_samples = ltp->lag + 1024;
 
1774
        for (i = 0; i < num_samples; i++)
 
1775
            predTime[i] = sce->ltp_state[i + 2048 - ltp->lag] * ltp->coef;
 
1776
        memset(&predTime[i], 0, (2048 - i) * sizeof(float));
 
1777
 
 
1778
        windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
 
1779
 
 
1780
        if (sce->tns.present)
 
1781
            apply_tns(predFreq, &sce->tns, &sce->ics, 0);
 
1782
 
 
1783
        for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
 
1784
            if (ltp->used[sfb])
 
1785
                for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
 
1786
                    sce->coeffs[i] += predFreq[i];
 
1787
    }
 
1788
}
 
1789
 
 
1790
/**
 
1791
 * Update the LTP buffer for next frame
 
1792
 */
 
1793
static void update_ltp(AACContext *ac, SingleChannelElement *sce)
 
1794
{
 
1795
    IndividualChannelStream *ics = &sce->ics;
 
1796
    float *saved     = sce->saved;
 
1797
    float *saved_ltp = sce->coeffs;
 
1798
    const float *lwindow = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
 
1799
    const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
 
1800
    int i;
 
1801
 
 
1802
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 
1803
        memcpy(saved_ltp,       saved, 512 * sizeof(float));
 
1804
        memset(saved_ltp + 576, 0,     448 * sizeof(float));
 
1805
        ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
 
1806
        for (i = 0; i < 64; i++)
 
1807
            saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * swindow[63 - i];
 
1808
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
 
1809
        memcpy(saved_ltp,       ac->buf_mdct + 512, 448 * sizeof(float));
 
1810
        memset(saved_ltp + 576, 0,                  448 * sizeof(float));
 
1811
        ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
 
1812
        for (i = 0; i < 64; i++)
 
1813
            saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * swindow[63 - i];
 
1814
    } else { // LONG_STOP or ONLY_LONG
 
1815
        ac->dsp.vector_fmul_reverse(saved_ltp,       ac->buf_mdct + 512,     &lwindow[512],     512);
 
1816
        for (i = 0; i < 512; i++)
 
1817
            saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * lwindow[511 - i];
 
1818
    }
 
1819
 
 
1820
    memcpy(sce->ltp_state, &sce->ltp_state[1024], 1024 * sizeof(int16_t));
 
1821
    ac->fmt_conv.float_to_int16(&(sce->ltp_state[1024]), sce->ret,  1024);
 
1822
    ac->fmt_conv.float_to_int16(&(sce->ltp_state[2048]), saved_ltp, 1024);
 
1823
}
 
1824
 
 
1825
/**
1739
1826
 * Conduct IMDCT and windowing.
1740
1827
 */
1741
 
static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float bias)
 
1828
static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
1742
1829
{
1743
1830
    IndividualChannelStream *ics = &sce->ics;
1744
1831
    float *in    = sce->coeffs;
1753
1840
 
1754
1841
    // imdct
1755
1842
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1756
 
        if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE)
1757
 
            av_log(ac->avctx, AV_LOG_WARNING,
1758
 
                   "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
1759
 
                   "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
1760
1843
        for (i = 0; i < 1024; i += 128)
1761
 
            ff_imdct_half(&ac->mdct_small, buf + i, in + i);
 
1844
            ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
1762
1845
    } else
1763
 
        ff_imdct_half(&ac->mdct, buf, in);
 
1846
        ac->mdct.imdct_half(&ac->mdct, buf, in);
1764
1847
 
1765
1848
    /* window overlapping
1766
1849
     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1770
1853
     */
1771
1854
    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
1772
1855
            (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
1773
 
        ac->dsp.vector_fmul_window(    out,               saved,            buf,         lwindow_prev, bias, 512);
 
1856
        ac->dsp.vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 512);
1774
1857
    } else {
1775
 
        for (i = 0; i < 448; i++)
1776
 
            out[i] = saved[i] + bias;
 
1858
        memcpy(                        out,               saved,            448 * sizeof(float));
1777
1859
 
1778
1860
        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1779
 
            ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, bias, 64);
1780
 
            ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      bias, 64);
1781
 
            ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      bias, 64);
1782
 
            ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      bias, 64);
1783
 
            ac->dsp.vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      bias, 64);
 
1861
            ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, 64);
 
1862
            ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      64);
 
1863
            ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      64);
 
1864
            ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      64);
 
1865
            ac->dsp.vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      64);
1784
1866
            memcpy(                    out + 448 + 4*128, temp, 64 * sizeof(float));
1785
1867
        } else {
1786
 
            ac->dsp.vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, bias, 64);
1787
 
            for (i = 576; i < 1024; i++)
1788
 
                out[i] = buf[i-512] + bias;
 
1868
            ac->dsp.vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, 64);
 
1869
            memcpy(                    out + 576,         buf + 64,         448 * sizeof(float));
1789
1870
        }
1790
1871
    }
1791
1872
 
1792
1873
    // buffer update
1793
1874
    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1794
 
        for (i = 0; i < 64; i++)
1795
 
            saved[i] = temp[64 + i] - bias;
1796
 
        ac->dsp.vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 0, 64);
1797
 
        ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64);
1798
 
        ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64);
 
1875
        memcpy(                    saved,       temp + 64,         64 * sizeof(float));
 
1876
        ac->dsp.vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 64);
 
1877
        ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
 
1878
        ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
1799
1879
        memcpy(                    saved + 448, buf + 7*128 + 64,  64 * sizeof(float));
1800
1880
    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
1801
1881
        memcpy(                    saved,       buf + 512,        448 * sizeof(float));
1852
1932
{
1853
1933
    int i;
1854
1934
    const float gain = cce->coup.gain[index][0];
1855
 
    const float bias = ac->add_bias;
1856
1935
    const float *src = cce->ch[0].ret;
1857
1936
    float *dest = target->ret;
1858
1937
    const int len = 1024 << (ac->m4ac.sbr == 1);
1859
1938
 
1860
1939
    for (i = 0; i < len; i++)
1861
 
        dest[i] += gain * (src[i] - bias);
 
1940
        dest[i] += gain * src[i];
1862
1941
}
1863
1942
 
1864
1943
/**
1865
1944
 * channel coupling transformation interface
1866
1945
 *
1867
 
 * @param   index   index into coupling gain array
1868
1946
 * @param   apply_coupling_method   pointer to (in)dependent coupling function
1869
1947
 */
1870
1948
static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
1903
1981
static void spectral_to_sample(AACContext *ac)
1904
1982
{
1905
1983
    int i, type;
1906
 
    float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f;
1907
1984
    for (type = 3; type >= 0; type--) {
1908
1985
        for (i = 0; i < MAX_ELEM_ID; i++) {
1909
1986
            ChannelElement *che = ac->che[type][i];
1910
1987
            if (che) {
1911
1988
                if (type <= TYPE_CPE)
1912
1989
                    apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling);
 
1990
                if (ac->m4ac.object_type == AOT_AAC_LTP) {
 
1991
                    if (che->ch[0].ics.predictor_present) {
 
1992
                        if (che->ch[0].ics.ltp.present)
 
1993
                            apply_ltp(ac, &che->ch[0]);
 
1994
                        if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
 
1995
                            apply_ltp(ac, &che->ch[1]);
 
1996
                    }
 
1997
                }
1913
1998
                if (che->ch[0].tns.present)
1914
1999
                    apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
1915
2000
                if (che->ch[1].tns.present)
1917
2002
                if (type <= TYPE_CPE)
1918
2003
                    apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
1919
2004
                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
1920
 
                    imdct_and_windowing(ac, &che->ch[0], imdct_bias);
 
2005
                    imdct_and_windowing(ac, &che->ch[0]);
 
2006
                    if (ac->m4ac.object_type == AOT_AAC_LTP)
 
2007
                        update_ltp(ac, &che->ch[0]);
1921
2008
                    if (type == TYPE_CPE) {
1922
 
                        imdct_and_windowing(ac, &che->ch[1], imdct_bias);
 
2009
                        imdct_and_windowing(ac, &che->ch[1]);
 
2010
                        if (ac->m4ac.object_type == AOT_AAC_LTP)
 
2011
                            update_ltp(ac, &che->ch[1]);
1923
2012
                    }
1924
2013
                    if (ac->m4ac.sbr > 0) {
1925
2014
                        ff_sbr_apply(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
1943
2032
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
1944
2033
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
1945
2034
            ac->m4ac.chan_config = hdr_info.chan_config;
1946
 
            if (set_default_channel_config(ac, new_che_pos, hdr_info.chan_config))
 
2035
            if (set_default_channel_config(ac->avctx, new_che_pos, hdr_info.chan_config))
1947
2036
                return -7;
1948
2037
            if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME))
1949
2038
                return -7;
1970
2059
    return size;
1971
2060
}
1972
2061
 
1973
 
static int aac_decode_frame(AVCodecContext *avctx, void *data,
1974
 
                            int *data_size, AVPacket *avpkt)
 
2062
static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
 
2063
                                int *data_size, GetBitContext *gb)
1975
2064
{
1976
 
    const uint8_t *buf = avpkt->data;
1977
 
    int buf_size = avpkt->size;
1978
2065
    AACContext *ac = avctx->priv_data;
1979
2066
    ChannelElement *che = NULL, *che_prev = NULL;
1980
 
    GetBitContext gb;
1981
2067
    enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
1982
2068
    int err, elem_id, data_size_tmp;
1983
 
    int buf_consumed;
1984
2069
    int samples = 0, multiplier;
1985
 
    int buf_offset;
1986
 
 
1987
 
    init_get_bits(&gb, buf, buf_size * 8);
1988
 
 
1989
 
    if (show_bits(&gb, 12) == 0xfff) {
1990
 
        if (parse_adts_frame_header(ac, &gb) < 0) {
 
2070
 
 
2071
    if (show_bits(gb, 12) == 0xfff) {
 
2072
        if (parse_adts_frame_header(ac, gb) < 0) {
1991
2073
            av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
1992
2074
            return -1;
1993
2075
        }
1997
2079
        }
1998
2080
    }
1999
2081
 
2000
 
    memset(ac->tags_seen_this_frame, 0, sizeof(ac->tags_seen_this_frame));
 
2082
    ac->tags_mapped = 0;
2001
2083
    // parse
2002
 
    while ((elem_type = get_bits(&gb, 3)) != TYPE_END) {
2003
 
        elem_id = get_bits(&gb, 4);
 
2084
    while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
 
2085
        elem_id = get_bits(gb, 4);
2004
2086
 
2005
2087
        if (elem_type < TYPE_DSE) {
2006
2088
            if (!(che=get_che(ac, elem_type, elem_id))) {
2014
2096
        switch (elem_type) {
2015
2097
 
2016
2098
        case TYPE_SCE:
2017
 
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
 
2099
            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
2018
2100
            break;
2019
2101
 
2020
2102
        case TYPE_CPE:
2021
 
            err = decode_cpe(ac, &gb, che);
 
2103
            err = decode_cpe(ac, gb, che);
2022
2104
            break;
2023
2105
 
2024
2106
        case TYPE_CCE:
2025
 
            err = decode_cce(ac, &gb, che);
 
2107
            err = decode_cce(ac, gb, che);
2026
2108
            break;
2027
2109
 
2028
2110
        case TYPE_LFE:
2029
 
            err = decode_ics(ac, &che->ch[0], &gb, 0, 0);
 
2111
            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
2030
2112
            break;
2031
2113
 
2032
2114
        case TYPE_DSE:
2033
 
            err = skip_data_stream_element(ac, &gb);
 
2115
            err = skip_data_stream_element(ac, gb);
2034
2116
            break;
2035
2117
 
2036
2118
        case TYPE_PCE: {
2037
2119
            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
2038
2120
            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
2039
 
            if ((err = decode_pce(ac, new_che_pos, &gb)))
 
2121
            if ((err = decode_pce(avctx, &ac->m4ac, new_che_pos, gb)))
2040
2122
                break;
2041
2123
            if (ac->output_configured > OC_TRIAL_PCE)
2042
2124
                av_log(avctx, AV_LOG_ERROR,
2048
2130
 
2049
2131
        case TYPE_FIL:
2050
2132
            if (elem_id == 15)
2051
 
                elem_id += get_bits(&gb, 8) - 1;
2052
 
            if (get_bits_left(&gb) < 8 * elem_id) {
 
2133
                elem_id += get_bits(gb, 8) - 1;
 
2134
            if (get_bits_left(gb) < 8 * elem_id) {
2053
2135
                    av_log(avctx, AV_LOG_ERROR, overread_err);
2054
2136
                    return -1;
2055
2137
            }
2056
2138
            while (elem_id > 0)
2057
 
                elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev);
 
2139
                elem_id -= decode_extension_payload(ac, gb, elem_id, che_prev, elem_type_prev);
2058
2140
            err = 0; /* FIXME */
2059
2141
            break;
2060
2142
 
2069
2151
        if (err)
2070
2152
            return err;
2071
2153
 
2072
 
        if (get_bits_left(&gb) < 3) {
 
2154
        if (get_bits_left(gb) < 3) {
2073
2155
            av_log(avctx, AV_LOG_ERROR, overread_err);
2074
2156
            return -1;
2075
2157
        }
2094
2176
    *data_size = data_size_tmp;
2095
2177
 
2096
2178
    if (samples)
2097
 
        ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels);
 
2179
        ac->fmt_conv.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels);
2098
2180
 
2099
2181
    if (ac->output_configured)
2100
2182
        ac->output_configured = OC_LOCKED;
2101
2183
 
 
2184
    return 0;
 
2185
}
 
2186
 
 
2187
static int aac_decode_frame(AVCodecContext *avctx, void *data,
 
2188
                            int *data_size, AVPacket *avpkt)
 
2189
{
 
2190
    const uint8_t *buf = avpkt->data;
 
2191
    int buf_size = avpkt->size;
 
2192
    GetBitContext gb;
 
2193
    int buf_consumed;
 
2194
    int buf_offset;
 
2195
    int err;
 
2196
 
 
2197
    init_get_bits(&gb, buf, buf_size * 8);
 
2198
 
 
2199
    if ((err = aac_decode_frame_int(avctx, data, data_size, &gb)) < 0)
 
2200
        return err;
 
2201
 
2102
2202
    buf_consumed = (get_bits_count(&gb) + 7) >> 3;
2103
2203
    for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
2104
2204
        if (buf[buf_offset])
2122
2222
 
2123
2223
    ff_mdct_end(&ac->mdct);
2124
2224
    ff_mdct_end(&ac->mdct_small);
2125
 
    return 0;
2126
 
}
2127
 
 
2128
 
AVCodec aac_decoder = {
 
2225
    ff_mdct_end(&ac->mdct_ltp);
 
2226
    return 0;
 
2227
}
 
2228
 
 
2229
 
 
2230
#define LOAS_SYNC_WORD   0x2b7       ///< 11 bits LOAS sync word
 
2231
 
 
2232
struct LATMContext {
 
2233
    AACContext      aac_ctx;             ///< containing AACContext
 
2234
    int             initialized;         ///< initilized after a valid extradata was seen
 
2235
 
 
2236
    // parser data
 
2237
    int             audio_mux_version_A; ///< LATM syntax version
 
2238
    int             frame_length_type;   ///< 0/1 variable/fixed frame length
 
2239
    int             frame_length;        ///< frame length for fixed frame length
 
2240
};
 
2241
 
 
2242
static inline uint32_t latm_get_value(GetBitContext *b)
 
2243
{
 
2244
    int length = get_bits(b, 2);
 
2245
 
 
2246
    return get_bits_long(b, (length+1)*8);
 
2247
}
 
2248
 
 
2249
static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
 
2250
                                             GetBitContext *gb)
 
2251
{
 
2252
    AVCodecContext *avctx = latmctx->aac_ctx.avctx;
 
2253
    MPEG4AudioConfig m4ac;
 
2254
    int  config_start_bit = get_bits_count(gb);
 
2255
    int     bits_consumed, esize;
 
2256
 
 
2257
    if (config_start_bit % 8) {
 
2258
        av_log_missing_feature(latmctx->aac_ctx.avctx, "audio specific "
 
2259
                               "config not byte aligned.\n", 1);
 
2260
        return AVERROR_INVALIDDATA;
 
2261
    } else {
 
2262
        bits_consumed =
 
2263
            decode_audio_specific_config(NULL, avctx, &m4ac,
 
2264
                                         gb->buffer + (config_start_bit / 8),
 
2265
                                         get_bits_left(gb) / 8);
 
2266
 
 
2267
        if (bits_consumed < 0)
 
2268
            return AVERROR_INVALIDDATA;
 
2269
 
 
2270
        esize = (bits_consumed+7) / 8;
 
2271
 
 
2272
        if (avctx->extradata_size <= esize) {
 
2273
            av_free(avctx->extradata);
 
2274
            avctx->extradata = av_malloc(esize + FF_INPUT_BUFFER_PADDING_SIZE);
 
2275
            if (!avctx->extradata)
 
2276
                return AVERROR(ENOMEM);
 
2277
        }
 
2278
 
 
2279
        avctx->extradata_size = esize;
 
2280
        memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);
 
2281
        memset(avctx->extradata+esize, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 
2282
 
 
2283
        skip_bits_long(gb, bits_consumed);
 
2284
    }
 
2285
 
 
2286
    return bits_consumed;
 
2287
}
 
2288
 
 
2289
static int read_stream_mux_config(struct LATMContext *latmctx,
 
2290
                                  GetBitContext *gb)
 
2291
{
 
2292
    int ret, audio_mux_version = get_bits(gb, 1);
 
2293
 
 
2294
    latmctx->audio_mux_version_A = 0;
 
2295
    if (audio_mux_version)
 
2296
        latmctx->audio_mux_version_A = get_bits(gb, 1);
 
2297
 
 
2298
    if (!latmctx->audio_mux_version_A) {
 
2299
 
 
2300
        if (audio_mux_version)
 
2301
            latm_get_value(gb);                 // taraFullness
 
2302
 
 
2303
        skip_bits(gb, 1);                       // allStreamSameTimeFraming
 
2304
        skip_bits(gb, 6);                       // numSubFrames
 
2305
        // numPrograms
 
2306
        if (get_bits(gb, 4)) {                  // numPrograms
 
2307
            av_log_missing_feature(latmctx->aac_ctx.avctx,
 
2308
                                   "multiple programs are not supported\n", 1);
 
2309
            return AVERROR_PATCHWELCOME;
 
2310
        }
 
2311
 
 
2312
        // for each program (which there is only on in DVB)
 
2313
 
 
2314
        // for each layer (which there is only on in DVB)
 
2315
        if (get_bits(gb, 3)) {                   // numLayer
 
2316
            av_log_missing_feature(latmctx->aac_ctx.avctx,
 
2317
                                   "multiple layers are not supported\n", 1);
 
2318
            return AVERROR_PATCHWELCOME;
 
2319
        }
 
2320
 
 
2321
        // for all but first stream: use_same_config = get_bits(gb, 1);
 
2322
        if (!audio_mux_version) {
 
2323
            if ((ret = latm_decode_audio_specific_config(latmctx, gb)) < 0)
 
2324
                return ret;
 
2325
        } else {
 
2326
            int ascLen = latm_get_value(gb);
 
2327
            if ((ret = latm_decode_audio_specific_config(latmctx, gb)) < 0)
 
2328
                return ret;
 
2329
            ascLen -= ret;
 
2330
            skip_bits_long(gb, ascLen);
 
2331
        }
 
2332
 
 
2333
        latmctx->frame_length_type = get_bits(gb, 3);
 
2334
        switch (latmctx->frame_length_type) {
 
2335
        case 0:
 
2336
            skip_bits(gb, 8);       // latmBufferFullness
 
2337
            break;
 
2338
        case 1:
 
2339
            latmctx->frame_length = get_bits(gb, 9);
 
2340
            break;
 
2341
        case 3:
 
2342
        case 4:
 
2343
        case 5:
 
2344
            skip_bits(gb, 6);       // CELP frame length table index
 
2345
            break;
 
2346
        case 6:
 
2347
        case 7:
 
2348
            skip_bits(gb, 1);       // HVXC frame length table index
 
2349
            break;
 
2350
        }
 
2351
 
 
2352
        if (get_bits(gb, 1)) {                  // other data
 
2353
            if (audio_mux_version) {
 
2354
                latm_get_value(gb);             // other_data_bits
 
2355
            } else {
 
2356
                int esc;
 
2357
                do {
 
2358
                    esc = get_bits(gb, 1);
 
2359
                    skip_bits(gb, 8);
 
2360
                } while (esc);
 
2361
            }
 
2362
        }
 
2363
 
 
2364
        if (get_bits(gb, 1))                     // crc present
 
2365
            skip_bits(gb, 8);                    // config_crc
 
2366
    }
 
2367
 
 
2368
    return 0;
 
2369
}
 
2370
 
 
2371
static int read_payload_length_info(struct LATMContext *ctx, GetBitContext *gb)
 
2372
{
 
2373
    uint8_t tmp;
 
2374
 
 
2375
    if (ctx->frame_length_type == 0) {
 
2376
        int mux_slot_length = 0;
 
2377
        do {
 
2378
            tmp = get_bits(gb, 8);
 
2379
            mux_slot_length += tmp;
 
2380
        } while (tmp == 255);
 
2381
        return mux_slot_length;
 
2382
    } else if (ctx->frame_length_type == 1) {
 
2383
        return ctx->frame_length;
 
2384
    } else if (ctx->frame_length_type == 3 ||
 
2385
               ctx->frame_length_type == 5 ||
 
2386
               ctx->frame_length_type == 7) {
 
2387
        skip_bits(gb, 2);          // mux_slot_length_coded
 
2388
    }
 
2389
    return 0;
 
2390
}
 
2391
 
 
2392
static int read_audio_mux_element(struct LATMContext *latmctx,
 
2393
                                  GetBitContext *gb)
 
2394
{
 
2395
    int err;
 
2396
    uint8_t use_same_mux = get_bits(gb, 1);
 
2397
    if (!use_same_mux) {
 
2398
        if ((err = read_stream_mux_config(latmctx, gb)) < 0)
 
2399
            return err;
 
2400
    } else if (!latmctx->aac_ctx.avctx->extradata) {
 
2401
        av_log(latmctx->aac_ctx.avctx, AV_LOG_DEBUG,
 
2402
               "no decoder config found\n");
 
2403
        return AVERROR(EAGAIN);
 
2404
    }
 
2405
    if (latmctx->audio_mux_version_A == 0) {
 
2406
        int mux_slot_length_bytes = read_payload_length_info(latmctx, gb);
 
2407
        if (mux_slot_length_bytes * 8 > get_bits_left(gb)) {
 
2408
            av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n");
 
2409
            return AVERROR_INVALIDDATA;
 
2410
        } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) {
 
2411
            av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
 
2412
                   "frame length mismatch %d << %d\n",
 
2413
                   mux_slot_length_bytes * 8, get_bits_left(gb));
 
2414
            return AVERROR_INVALIDDATA;
 
2415
        }
 
2416
    }
 
2417
    return 0;
 
2418
}
 
2419
 
 
2420
 
 
2421
static int latm_decode_frame(AVCodecContext *avctx, void *out, int *out_size,
 
2422
                             AVPacket *avpkt)
 
2423
{
 
2424
    struct LATMContext *latmctx = avctx->priv_data;
 
2425
    int                 muxlength, err;
 
2426
    GetBitContext       gb;
 
2427
 
 
2428
    if (avpkt->size == 0)
 
2429
        return 0;
 
2430
 
 
2431
    init_get_bits(&gb, avpkt->data, avpkt->size * 8);
 
2432
 
 
2433
    // check for LOAS sync word
 
2434
    if (get_bits(&gb, 11) != LOAS_SYNC_WORD)
 
2435
        return AVERROR_INVALIDDATA;
 
2436
 
 
2437
    muxlength = get_bits(&gb, 13) + 3;
 
2438
    // not enough data, the parser should have sorted this
 
2439
    if (muxlength > avpkt->size)
 
2440
        return AVERROR_INVALIDDATA;
 
2441
 
 
2442
    if ((err = read_audio_mux_element(latmctx, &gb)) < 0)
 
2443
        return err;
 
2444
 
 
2445
    if (!latmctx->initialized) {
 
2446
        if (!avctx->extradata) {
 
2447
            *out_size = 0;
 
2448
            return avpkt->size;
 
2449
        } else {
 
2450
            if ((err = aac_decode_init(avctx)) < 0)
 
2451
                return err;
 
2452
            latmctx->initialized = 1;
 
2453
        }
 
2454
    }
 
2455
 
 
2456
    if (show_bits(&gb, 12) == 0xfff) {
 
2457
        av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
 
2458
               "ADTS header detected, probably as result of configuration "
 
2459
               "misparsing\n");
 
2460
        return AVERROR_INVALIDDATA;
 
2461
    }
 
2462
 
 
2463
    if ((err = aac_decode_frame_int(avctx, out, out_size, &gb)) < 0)
 
2464
        return err;
 
2465
 
 
2466
    return muxlength;
 
2467
}
 
2468
 
 
2469
av_cold static int latm_decode_init(AVCodecContext *avctx)
 
2470
{
 
2471
    struct LATMContext *latmctx = avctx->priv_data;
 
2472
    int ret;
 
2473
 
 
2474
    ret = aac_decode_init(avctx);
 
2475
 
 
2476
    if (avctx->extradata_size > 0) {
 
2477
        latmctx->initialized = !ret;
 
2478
    } else {
 
2479
        latmctx->initialized = 0;
 
2480
    }
 
2481
 
 
2482
    return ret;
 
2483
}
 
2484
 
 
2485
 
 
2486
AVCodec ff_aac_decoder = {
2129
2487
    "aac",
2130
2488
    AVMEDIA_TYPE_AUDIO,
2131
2489
    CODEC_ID_AAC,
2135
2493
    aac_decode_close,
2136
2494
    aac_decode_frame,
2137
2495
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
2138
 
    .sample_fmts = (const enum SampleFormat[]) {
2139
 
        SAMPLE_FMT_S16,SAMPLE_FMT_NONE
 
2496
    .sample_fmts = (const enum AVSampleFormat[]) {
 
2497
        AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE
 
2498
    },
 
2499
    .channel_layouts = aac_channel_layout,
 
2500
};
 
2501
 
 
2502
/*
 
2503
    Note: This decoder filter is intended to decode LATM streams transferred
 
2504
    in MPEG transport streams which only contain one program.
 
2505
    To do a more complex LATM demuxing a separate LATM demuxer should be used.
 
2506
*/
 
2507
AVCodec ff_aac_latm_decoder = {
 
2508
    .name = "aac_latm",
 
2509
    .type = AVMEDIA_TYPE_AUDIO,
 
2510
    .id   = CODEC_ID_AAC_LATM,
 
2511
    .priv_data_size = sizeof(struct LATMContext),
 
2512
    .init   = latm_decode_init,
 
2513
    .close  = aac_decode_close,
 
2514
    .decode = latm_decode_frame,
 
2515
    .long_name = NULL_IF_CONFIG_SMALL("AAC LATM (Advanced Audio Codec LATM syntax)"),
 
2516
    .sample_fmts = (const enum AVSampleFormat[]) {
 
2517
        AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE
2140
2518
    },
2141
2519
    .channel_layouts = aac_channel_layout,
2142
2520
};