git.sesse.net Git - ffmpeg/blob - libavcodec/aac.c

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