"Fossies" - the Fresh Open Source Software Archive

Member "ffmpeg-3.4.2/libavcodec/aacdec_template.c" (12 Feb 2018, 125577 Bytes) of package /linux/misc/ffmpeg-3.4.2.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "aacdec_template.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 3.3.4_vs_3.4.

    1 /*
    2  * AAC decoder
    3  * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
    4  * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
    5  * Copyright (c) 2008-2013 Alex Converse <alex.converse@gmail.com>
    6  *
    7  * AAC LATM decoder
    8  * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
    9  * Copyright (c) 2010      Janne Grunau <janne-libav@jannau.net>
   10  *
   11  * AAC decoder fixed-point implementation
   12  * Copyright (c) 2013
   13  *      MIPS Technologies, Inc., California.
   14  *
   15  * This file is part of FFmpeg.
   16  *
   17  * FFmpeg is free software; you can redistribute it and/or
   18  * modify it under the terms of the GNU Lesser General Public
   19  * License as published by the Free Software Foundation; either
   20  * version 2.1 of the License, or (at your option) any later version.
   21  *
   22  * FFmpeg is distributed in the hope that it will be useful,
   23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   25  * Lesser General Public License for more details.
   26  *
   27  * You should have received a copy of the GNU Lesser General Public
   28  * License along with FFmpeg; if not, write to the Free Software
   29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   30  */
   31 
   32 /**
   33  * @file
   34  * AAC decoder
   35  * @author Oded Shimon  ( ods15 ods15 dyndns org )
   36  * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
   37  *
   38  * AAC decoder fixed-point implementation
   39  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
   40  * @author Nedeljko Babic ( nedeljko.babic imgtec com )
   41  */
   42 
   43 /*
   44  * supported tools
   45  *
   46  * Support?                     Name
   47  * N (code in SoC repo)         gain control
   48  * Y                            block switching
   49  * Y                            window shapes - standard
   50  * N                            window shapes - Low Delay
   51  * Y                            filterbank - standard
   52  * N (code in SoC repo)         filterbank - Scalable Sample Rate
   53  * Y                            Temporal Noise Shaping
   54  * Y                            Long Term Prediction
   55  * Y                            intensity stereo
   56  * Y                            channel coupling
   57  * Y                            frequency domain prediction
   58  * Y                            Perceptual Noise Substitution
   59  * Y                            Mid/Side stereo
   60  * N                            Scalable Inverse AAC Quantization
   61  * N                            Frequency Selective Switch
   62  * N                            upsampling filter
   63  * Y                            quantization & coding - AAC
   64  * N                            quantization & coding - TwinVQ
   65  * N                            quantization & coding - BSAC
   66  * N                            AAC Error Resilience tools
   67  * N                            Error Resilience payload syntax
   68  * N                            Error Protection tool
   69  * N                            CELP
   70  * N                            Silence Compression
   71  * N                            HVXC
   72  * N                            HVXC 4kbits/s VR
   73  * N                            Structured Audio tools
   74  * N                            Structured Audio Sample Bank Format
   75  * N                            MIDI
   76  * N                            Harmonic and Individual Lines plus Noise
   77  * N                            Text-To-Speech Interface
   78  * Y                            Spectral Band Replication
   79  * Y (not in this code)         Layer-1
   80  * Y (not in this code)         Layer-2
   81  * Y (not in this code)         Layer-3
   82  * N                            SinuSoidal Coding (Transient, Sinusoid, Noise)
   83  * Y                            Parametric Stereo
   84  * N                            Direct Stream Transfer
   85  * Y  (not in fixed point code) Enhanced AAC Low Delay (ER AAC ELD)
   86  *
   87  * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
   88  *       - HE AAC v2 comprises LC AAC with Spectral Band Replication and
   89            Parametric Stereo.
   90  */
   91 
   92 #include "libavutil/thread.h"
   93 
   94 static VLC vlc_scalefactors;
   95 static VLC vlc_spectral[11];
   96 
   97 static int output_configure(AACContext *ac,
   98                             uint8_t layout_map[MAX_ELEM_ID*4][3], int tags,
   99                             enum OCStatus oc_type, int get_new_frame);
  100 
  101 #define overread_err "Input buffer exhausted before END element found\n"
  102 
  103 static int count_channels(uint8_t (*layout)[3], int tags)
  104 {
  105     int i, sum = 0;
  106     for (i = 0; i < tags; i++) {
  107         int syn_ele = layout[i][0];
  108         int pos     = layout[i][2];
  109         sum += (1 + (syn_ele == TYPE_CPE)) *
  110                (pos != AAC_CHANNEL_OFF && pos != AAC_CHANNEL_CC);
  111     }
  112     return sum;
  113 }
  114 
  115 /**
  116  * Check for the channel element in the current channel position configuration.
  117  * If it exists, make sure the appropriate element is allocated and map the
  118  * channel order to match the internal FFmpeg channel layout.
  119  *
  120  * @param   che_pos current channel position configuration
  121  * @param   type channel element type
  122  * @param   id channel element id
  123  * @param   channels count of the number of channels in the configuration
  124  *
  125  * @return  Returns error status. 0 - OK, !0 - error
  126  */
  127 static av_cold int che_configure(AACContext *ac,
  128                                  enum ChannelPosition che_pos,
  129                                  int type, int id, int *channels)
  130 {
  131     if (*channels >= MAX_CHANNELS)
  132         return AVERROR_INVALIDDATA;
  133     if (che_pos) {
  134         if (!ac->che[type][id]) {
  135             if (!(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
  136                 return AVERROR(ENOMEM);
  137             AAC_RENAME(ff_aac_sbr_ctx_init)(ac, &ac->che[type][id]->sbr, type);
  138         }
  139         if (type != TYPE_CCE) {
  140             if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
  141                 av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
  142                 return AVERROR_INVALIDDATA;
  143             }
  144             ac->output_element[(*channels)++] = &ac->che[type][id]->ch[0];
  145             if (type == TYPE_CPE ||
  146                 (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
  147                 ac->output_element[(*channels)++] = &ac->che[type][id]->ch[1];
  148             }
  149         }
  150     } else {
  151         if (ac->che[type][id])
  152             AAC_RENAME(ff_aac_sbr_ctx_close)(&ac->che[type][id]->sbr);
  153         av_freep(&ac->che[type][id]);
  154     }
  155     return 0;
  156 }
  157 
  158 static int frame_configure_elements(AVCodecContext *avctx)
  159 {
  160     AACContext *ac = avctx->priv_data;
  161     int type, id, ch, ret;
  162 
  163     /* set channel pointers to internal buffers by default */
  164     for (type = 0; type < 4; type++) {
  165         for (id = 0; id < MAX_ELEM_ID; id++) {
  166             ChannelElement *che = ac->che[type][id];
  167             if (che) {
  168                 che->ch[0].ret = che->ch[0].ret_buf;
  169                 che->ch[1].ret = che->ch[1].ret_buf;
  170             }
  171         }
  172     }
  173 
  174     /* get output buffer */
  175     av_frame_unref(ac->frame);
  176     if (!avctx->channels)
  177         return 1;
  178 
  179     ac->frame->nb_samples = 2048;
  180     if ((ret = ff_get_buffer(avctx, ac->frame, 0)) < 0)
  181         return ret;
  182 
  183     /* map output channel pointers to AVFrame data */
  184     for (ch = 0; ch < avctx->channels; ch++) {
  185         if (ac->output_element[ch])
  186             ac->output_element[ch]->ret = (INTFLOAT *)ac->frame->extended_data[ch];
  187     }
  188 
  189     return 0;
  190 }
  191 
  192 struct elem_to_channel {
  193     uint64_t av_position;
  194     uint8_t syn_ele;
  195     uint8_t elem_id;
  196     uint8_t aac_position;
  197 };
  198 
  199 static int assign_pair(struct elem_to_channel e2c_vec[MAX_ELEM_ID],
  200                        uint8_t (*layout_map)[3], int offset, uint64_t left,
  201                        uint64_t right, int pos)
  202 {
  203     if (layout_map[offset][0] == TYPE_CPE) {
  204         e2c_vec[offset] = (struct elem_to_channel) {
  205             .av_position  = left | right,
  206             .syn_ele      = TYPE_CPE,
  207             .elem_id      = layout_map[offset][1],
  208             .aac_position = pos
  209         };
  210         return 1;
  211     } else {
  212         e2c_vec[offset] = (struct elem_to_channel) {
  213             .av_position  = left,
  214             .syn_ele      = TYPE_SCE,
  215             .elem_id      = layout_map[offset][1],
  216             .aac_position = pos
  217         };
  218         e2c_vec[offset + 1] = (struct elem_to_channel) {
  219             .av_position  = right,
  220             .syn_ele      = TYPE_SCE,
  221             .elem_id      = layout_map[offset + 1][1],
  222             .aac_position = pos
  223         };
  224         return 2;
  225     }
  226 }
  227 
  228 static int count_paired_channels(uint8_t (*layout_map)[3], int tags, int pos,
  229                                  int *current)
  230 {
  231     int num_pos_channels = 0;
  232     int first_cpe        = 0;
  233     int sce_parity       = 0;
  234     int i;
  235     for (i = *current; i < tags; i++) {
  236         if (layout_map[i][2] != pos)
  237             break;
  238         if (layout_map[i][0] == TYPE_CPE) {
  239             if (sce_parity) {
  240                 if (pos == AAC_CHANNEL_FRONT && !first_cpe) {
  241                     sce_parity = 0;
  242                 } else {
  243                     return -1;
  244                 }
  245             }
  246             num_pos_channels += 2;
  247             first_cpe         = 1;
  248         } else {
  249             num_pos_channels++;
  250             sce_parity ^= 1;
  251         }
  252     }
  253     if (sce_parity &&
  254         ((pos == AAC_CHANNEL_FRONT && first_cpe) || pos == AAC_CHANNEL_SIDE))
  255         return -1;
  256     *current = i;
  257     return num_pos_channels;
  258 }
  259 
  260 static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
  261 {
  262     int i, n, total_non_cc_elements;
  263     struct elem_to_channel e2c_vec[4 * MAX_ELEM_ID] = { { 0 } };
  264     int num_front_channels, num_side_channels, num_back_channels;
  265     uint64_t layout;
  266 
  267     if (FF_ARRAY_ELEMS(e2c_vec) < tags)
  268         return 0;
  269 
  270     i = 0;
  271     num_front_channels =
  272         count_paired_channels(layout_map, tags, AAC_CHANNEL_FRONT, &i);
  273     if (num_front_channels < 0)
  274         return 0;
  275     num_side_channels =
  276         count_paired_channels(layout_map, tags, AAC_CHANNEL_SIDE, &i);
  277     if (num_side_channels < 0)
  278         return 0;
  279     num_back_channels =
  280         count_paired_channels(layout_map, tags, AAC_CHANNEL_BACK, &i);
  281     if (num_back_channels < 0)
  282         return 0;
  283 
  284     if (num_side_channels == 0 && num_back_channels >= 4) {
  285         num_side_channels = 2;
  286         num_back_channels -= 2;
  287     }
  288 
  289     i = 0;
  290     if (num_front_channels & 1) {
  291         e2c_vec[i] = (struct elem_to_channel) {
  292             .av_position  = AV_CH_FRONT_CENTER,
  293             .syn_ele      = TYPE_SCE,
  294             .elem_id      = layout_map[i][1],
  295             .aac_position = AAC_CHANNEL_FRONT
  296         };
  297         i++;
  298         num_front_channels--;
  299     }
  300     if (num_front_channels >= 4) {
  301         i += assign_pair(e2c_vec, layout_map, i,
  302                          AV_CH_FRONT_LEFT_OF_CENTER,
  303                          AV_CH_FRONT_RIGHT_OF_CENTER,
  304                          AAC_CHANNEL_FRONT);
  305         num_front_channels -= 2;
  306     }
  307     if (num_front_channels >= 2) {
  308         i += assign_pair(e2c_vec, layout_map, i,
  309                          AV_CH_FRONT_LEFT,
  310                          AV_CH_FRONT_RIGHT,
  311                          AAC_CHANNEL_FRONT);
  312         num_front_channels -= 2;
  313     }
  314     while (num_front_channels >= 2) {
  315         i += assign_pair(e2c_vec, layout_map, i,
  316                          UINT64_MAX,
  317                          UINT64_MAX,
  318                          AAC_CHANNEL_FRONT);
  319         num_front_channels -= 2;
  320     }
  321 
  322     if (num_side_channels >= 2) {
  323         i += assign_pair(e2c_vec, layout_map, i,
  324                          AV_CH_SIDE_LEFT,
  325                          AV_CH_SIDE_RIGHT,
  326                          AAC_CHANNEL_FRONT);
  327         num_side_channels -= 2;
  328     }
  329     while (num_side_channels >= 2) {
  330         i += assign_pair(e2c_vec, layout_map, i,
  331                          UINT64_MAX,
  332                          UINT64_MAX,
  333                          AAC_CHANNEL_SIDE);
  334         num_side_channels -= 2;
  335     }
  336 
  337     while (num_back_channels >= 4) {
  338         i += assign_pair(e2c_vec, layout_map, i,
  339                          UINT64_MAX,
  340                          UINT64_MAX,
  341                          AAC_CHANNEL_BACK);
  342         num_back_channels -= 2;
  343     }
  344     if (num_back_channels >= 2) {
  345         i += assign_pair(e2c_vec, layout_map, i,
  346                          AV_CH_BACK_LEFT,
  347                          AV_CH_BACK_RIGHT,
  348                          AAC_CHANNEL_BACK);
  349         num_back_channels -= 2;
  350     }
  351     if (num_back_channels) {
  352         e2c_vec[i] = (struct elem_to_channel) {
  353             .av_position  = AV_CH_BACK_CENTER,
  354             .syn_ele      = TYPE_SCE,
  355             .elem_id      = layout_map[i][1],
  356             .aac_position = AAC_CHANNEL_BACK
  357         };
  358         i++;
  359         num_back_channels--;
  360     }
  361 
  362     if (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
  363         e2c_vec[i] = (struct elem_to_channel) {
  364             .av_position  = AV_CH_LOW_FREQUENCY,
  365             .syn_ele      = TYPE_LFE,
  366             .elem_id      = layout_map[i][1],
  367             .aac_position = AAC_CHANNEL_LFE
  368         };
  369         i++;
  370     }
  371     while (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
  372         e2c_vec[i] = (struct elem_to_channel) {
  373             .av_position  = UINT64_MAX,
  374             .syn_ele      = TYPE_LFE,
  375             .elem_id      = layout_map[i][1],
  376             .aac_position = AAC_CHANNEL_LFE
  377         };
  378         i++;
  379     }
  380 
  381     // Must choose a stable sort
  382     total_non_cc_elements = n = i;
  383     do {
  384         int next_n = 0;
  385         for (i = 1; i < n; i++)
  386             if (e2c_vec[i - 1].av_position > e2c_vec[i].av_position) {
  387                 FFSWAP(struct elem_to_channel, e2c_vec[i - 1], e2c_vec[i]);
  388                 next_n = i;
  389             }
  390         n = next_n;
  391     } while (n > 0);
  392 
  393     layout = 0;
  394     for (i = 0; i < total_non_cc_elements; i++) {
  395         layout_map[i][0] = e2c_vec[i].syn_ele;
  396         layout_map[i][1] = e2c_vec[i].elem_id;
  397         layout_map[i][2] = e2c_vec[i].aac_position;
  398         if (e2c_vec[i].av_position != UINT64_MAX) {
  399             layout |= e2c_vec[i].av_position;
  400         }
  401     }
  402 
  403     return layout;
  404 }
  405 
  406 /**
  407  * Save current output configuration if and only if it has been locked.
  408  */
  409 static int push_output_configuration(AACContext *ac) {
  410     int pushed = 0;
  411 
  412     if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
  413         ac->oc[0] = ac->oc[1];
  414         pushed = 1;
  415     }
  416     ac->oc[1].status = OC_NONE;
  417     return pushed;
  418 }
  419 
  420 /**
  421  * Restore the previous output configuration if and only if the current
  422  * configuration is unlocked.
  423  */
  424 static void pop_output_configuration(AACContext *ac) {
  425     if (ac->oc[1].status != OC_LOCKED && ac->oc[0].status != OC_NONE) {
  426         ac->oc[1] = ac->oc[0];
  427         ac->avctx->channels = ac->oc[1].channels;
  428         ac->avctx->channel_layout = ac->oc[1].channel_layout;
  429         output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
  430                          ac->oc[1].status, 0);
  431     }
  432 }
  433 
  434 /**
  435  * Configure output channel order based on the current program
  436  * configuration element.
  437  *
  438  * @return  Returns error status. 0 - OK, !0 - error
  439  */
  440 static int output_configure(AACContext *ac,
  441                             uint8_t layout_map[MAX_ELEM_ID * 4][3], int tags,
  442                             enum OCStatus oc_type, int get_new_frame)
  443 {
  444     AVCodecContext *avctx = ac->avctx;
  445     int i, channels = 0, ret;
  446     uint64_t layout = 0;
  447     uint8_t id_map[TYPE_END][MAX_ELEM_ID] = {{ 0 }};
  448     uint8_t type_counts[TYPE_END] = { 0 };
  449 
  450     if (ac->oc[1].layout_map != layout_map) {
  451         memcpy(ac->oc[1].layout_map, layout_map, tags * sizeof(layout_map[0]));
  452         ac->oc[1].layout_map_tags = tags;
  453     }
  454     for (i = 0; i < tags; i++) {
  455         int type =         layout_map[i][0];
  456         int id =           layout_map[i][1];
  457         id_map[type][id] = type_counts[type]++;
  458         if (id_map[type][id] >= MAX_ELEM_ID) {
  459             avpriv_request_sample(ac->avctx, "Too large remapped id");
  460             return AVERROR_PATCHWELCOME;
  461         }
  462     }
  463     // Try to sniff a reasonable channel order, otherwise output the
  464     // channels in the order the PCE declared them.
  465     if (avctx->request_channel_layout != AV_CH_LAYOUT_NATIVE)
  466         layout = sniff_channel_order(layout_map, tags);
  467     for (i = 0; i < tags; i++) {
  468         int type =     layout_map[i][0];
  469         int id =       layout_map[i][1];
  470         int iid =      id_map[type][id];
  471         int position = layout_map[i][2];
  472         // Allocate or free elements depending on if they are in the
  473         // current program configuration.
  474         ret = che_configure(ac, position, type, iid, &channels);
  475         if (ret < 0)
  476             return ret;
  477         ac->tag_che_map[type][id] = ac->che[type][iid];
  478     }
  479     if (ac->oc[1].m4ac.ps == 1 && channels == 2) {
  480         if (layout == AV_CH_FRONT_CENTER) {
  481             layout = AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT;
  482         } else {
  483             layout = 0;
  484         }
  485     }
  486 
  487     if (layout) avctx->channel_layout = layout;
  488                             ac->oc[1].channel_layout = layout;
  489     avctx->channels       = ac->oc[1].channels       = channels;
  490     ac->oc[1].status = oc_type;
  491 
  492     if (get_new_frame) {
  493         if ((ret = frame_configure_elements(ac->avctx)) < 0)
  494             return ret;
  495     }
  496 
  497     return 0;
  498 }
  499 
  500 static void flush(AVCodecContext *avctx)
  501 {
  502     AACContext *ac= avctx->priv_data;
  503     int type, i, j;
  504 
  505     for (type = 3; type >= 0; type--) {
  506         for (i = 0; i < MAX_ELEM_ID; i++) {
  507             ChannelElement *che = ac->che[type][i];
  508             if (che) {
  509                 for (j = 0; j <= 1; j++) {
  510                     memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
  511                 }
  512             }
  513         }
  514     }
  515 }
  516 
  517 /**
  518  * Set up channel positions based on a default channel configuration
  519  * as specified in table 1.17.
  520  *
  521  * @return  Returns error status. 0 - OK, !0 - error
  522  */
  523 static int set_default_channel_config(AVCodecContext *avctx,
  524                                       uint8_t (*layout_map)[3],
  525                                       int *tags,
  526                                       int channel_config)
  527 {
  528     if (channel_config < 1 || (channel_config > 7 && channel_config < 11) ||
  529         channel_config > 12) {
  530         av_log(avctx, AV_LOG_ERROR,
  531                "invalid default channel configuration (%d)\n",
  532                channel_config);
  533         return AVERROR_INVALIDDATA;
  534     }
  535     *tags = tags_per_config[channel_config];
  536     memcpy(layout_map, aac_channel_layout_map[channel_config - 1],
  537            *tags * sizeof(*layout_map));
  538 
  539     /*
  540      * AAC specification has 7.1(wide) as a default layout for 8-channel streams.
  541      * However, at least Nero AAC encoder encodes 7.1 streams using the default
  542      * channel config 7, mapping the side channels of the original audio stream
  543      * to the second AAC_CHANNEL_FRONT pair in the AAC stream. Similarly, e.g. FAAD
  544      * decodes the second AAC_CHANNEL_FRONT pair as side channels, therefore decoding
  545      * the incorrect streams as if they were correct (and as the encoder intended).
  546      *
  547      * As actual intended 7.1(wide) streams are very rare, default to assuming a
  548      * 7.1 layout was intended.
  549      */
  550     if (channel_config == 7 && avctx->strict_std_compliance < FF_COMPLIANCE_STRICT) {
  551         av_log(avctx, AV_LOG_INFO, "Assuming an incorrectly encoded 7.1 channel layout"
  552                " instead of a spec-compliant 7.1(wide) layout, use -strict %d to decode"
  553                " according to the specification instead.\n", FF_COMPLIANCE_STRICT);
  554         layout_map[2][2] = AAC_CHANNEL_SIDE;
  555     }
  556 
  557     return 0;
  558 }
  559 
  560 static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
  561 {
  562     /* For PCE based channel configurations map the channels solely based
  563      * on tags. */
  564     if (!ac->oc[1].m4ac.chan_config) {
  565         return ac->tag_che_map[type][elem_id];
  566     }
  567     // Allow single CPE stereo files to be signalled with mono configuration.
  568     if (!ac->tags_mapped && type == TYPE_CPE &&
  569         ac->oc[1].m4ac.chan_config == 1) {
  570         uint8_t layout_map[MAX_ELEM_ID*4][3];
  571         int layout_map_tags;
  572         push_output_configuration(ac);
  573 
  574         av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
  575 
  576         if (set_default_channel_config(ac->avctx, layout_map,
  577                                        &layout_map_tags, 2) < 0)
  578             return NULL;
  579         if (output_configure(ac, layout_map, layout_map_tags,
  580                              OC_TRIAL_FRAME, 1) < 0)
  581             return NULL;
  582 
  583         ac->oc[1].m4ac.chan_config = 2;
  584         ac->oc[1].m4ac.ps = 0;
  585     }
  586     // And vice-versa
  587     if (!ac->tags_mapped && type == TYPE_SCE &&
  588         ac->oc[1].m4ac.chan_config == 2) {
  589         uint8_t layout_map[MAX_ELEM_ID * 4][3];
  590         int layout_map_tags;
  591         push_output_configuration(ac);
  592 
  593         av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
  594 
  595         if (set_default_channel_config(ac->avctx, layout_map,
  596                                        &layout_map_tags, 1) < 0)
  597             return NULL;
  598         if (output_configure(ac, layout_map, layout_map_tags,
  599                              OC_TRIAL_FRAME, 1) < 0)
  600             return NULL;
  601 
  602         ac->oc[1].m4ac.chan_config = 1;
  603         if (ac->oc[1].m4ac.sbr)
  604             ac->oc[1].m4ac.ps = -1;
  605     }
  606     /* For indexed channel configurations map the channels solely based
  607      * on position. */
  608     switch (ac->oc[1].m4ac.chan_config) {
  609     case 12:
  610     case 7:
  611         if (ac->tags_mapped == 3 && type == TYPE_CPE) {
  612             ac->tags_mapped++;
  613             return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
  614         }
  615     case 11:
  616         if (ac->tags_mapped == 2 &&
  617             ac->oc[1].m4ac.chan_config == 11 &&
  618             type == TYPE_SCE) {
  619             ac->tags_mapped++;
  620             return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
  621         }
  622     case 6:
  623         /* Some streams incorrectly code 5.1 audio as
  624          * SCE[0] CPE[0] CPE[1] SCE[1]
  625          * instead of
  626          * SCE[0] CPE[0] CPE[1] LFE[0].
  627          * If we seem to have encountered such a stream, transfer
  628          * the LFE[0] element to the SCE[1]'s mapping */
  629         if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
  630             if (!ac->warned_remapping_once && (type != TYPE_LFE || elem_id != 0)) {
  631                 av_log(ac->avctx, AV_LOG_WARNING,
  632                    "This stream seems to incorrectly report its last channel as %s[%d], mapping to LFE[0]\n",
  633                    type == TYPE_SCE ? "SCE" : "LFE", elem_id);
  634                 ac->warned_remapping_once++;
  635             }
  636             ac->tags_mapped++;
  637             return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
  638         }
  639     case 5:
  640         if (ac->tags_mapped == 2 && type == TYPE_CPE) {
  641             ac->tags_mapped++;
  642             return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
  643         }
  644     case 4:
  645         /* Some streams incorrectly code 4.0 audio as
  646          * SCE[0] CPE[0] LFE[0]
  647          * instead of
  648          * SCE[0] CPE[0] SCE[1].
  649          * If we seem to have encountered such a stream, transfer
  650          * the SCE[1] element to the LFE[0]'s mapping */
  651         if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
  652             if (!ac->warned_remapping_once && (type != TYPE_SCE || elem_id != 1)) {
  653                 av_log(ac->avctx, AV_LOG_WARNING,
  654                    "This stream seems to incorrectly report its last channel as %s[%d], mapping to SCE[1]\n",
  655                    type == TYPE_SCE ? "SCE" : "LFE", elem_id);
  656                 ac->warned_remapping_once++;
  657             }
  658             ac->tags_mapped++;
  659             return ac->tag_che_map[type][elem_id] = ac->che[TYPE_SCE][1];
  660         }
  661         if (ac->tags_mapped == 2 &&
  662             ac->oc[1].m4ac.chan_config == 4 &&
  663             type == TYPE_SCE) {
  664             ac->tags_mapped++;
  665             return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
  666         }
  667     case 3:
  668     case 2:
  669         if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) &&
  670             type == TYPE_CPE) {
  671             ac->tags_mapped++;
  672             return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
  673         } else if (ac->oc[1].m4ac.chan_config == 2) {
  674             return NULL;
  675         }
  676     case 1:
  677         if (!ac->tags_mapped && type == TYPE_SCE) {
  678             ac->tags_mapped++;
  679             return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
  680         }
  681     default:
  682         return NULL;
  683     }
  684 }
  685 
  686 /**
  687  * Decode an array of 4 bit element IDs, optionally interleaved with a
  688  * stereo/mono switching bit.
  689  *
  690  * @param type speaker type/position for these channels
  691  */
  692 static void decode_channel_map(uint8_t layout_map[][3],
  693                                enum ChannelPosition type,
  694                                GetBitContext *gb, int n)
  695 {
  696     while (n--) {
  697         enum RawDataBlockType syn_ele;
  698         switch (type) {
  699         case AAC_CHANNEL_FRONT:
  700         case AAC_CHANNEL_BACK:
  701         case AAC_CHANNEL_SIDE:
  702             syn_ele = get_bits1(gb);
  703             break;
  704         case AAC_CHANNEL_CC:
  705             skip_bits1(gb);
  706             syn_ele = TYPE_CCE;
  707             break;
  708         case AAC_CHANNEL_LFE:
  709             syn_ele = TYPE_LFE;
  710             break;
  711         default:
  712             // AAC_CHANNEL_OFF has no channel map
  713             av_assert0(0);
  714         }
  715         layout_map[0][0] = syn_ele;
  716         layout_map[0][1] = get_bits(gb, 4);
  717         layout_map[0][2] = type;
  718         layout_map++;
  719     }
  720 }
  721 
  722 static inline void relative_align_get_bits(GetBitContext *gb,
  723                                            int reference_position) {
  724     int n = (reference_position - get_bits_count(gb) & 7);
  725     if (n)
  726         skip_bits(gb, n);
  727 }
  728 
  729 /**
  730  * Decode program configuration element; reference: table 4.2.
  731  *
  732  * @return  Returns error status. 0 - OK, !0 - error
  733  */
  734 static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
  735                       uint8_t (*layout_map)[3],
  736                       GetBitContext *gb, int byte_align_ref)
  737 {
  738     int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
  739     int sampling_index;
  740     int comment_len;
  741     int tags;
  742 
  743     skip_bits(gb, 2);  // object_type
  744 
  745     sampling_index = get_bits(gb, 4);
  746     if (m4ac->sampling_index != sampling_index)
  747         av_log(avctx, AV_LOG_WARNING,
  748                "Sample rate index in program config element does not "
  749                "match the sample rate index configured by the container.\n");
  750 
  751     num_front       = get_bits(gb, 4);
  752     num_side        = get_bits(gb, 4);
  753     num_back        = get_bits(gb, 4);
  754     num_lfe         = get_bits(gb, 2);
  755     num_assoc_data  = get_bits(gb, 3);
  756     num_cc          = get_bits(gb, 4);
  757 
  758     if (get_bits1(gb))
  759         skip_bits(gb, 4); // mono_mixdown_tag
  760     if (get_bits1(gb))
  761         skip_bits(gb, 4); // stereo_mixdown_tag
  762 
  763     if (get_bits1(gb))
  764         skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
  765 
  766     if (get_bits_left(gb) < 5 * (num_front + num_side + num_back + num_cc) + 4 *(num_lfe + num_assoc_data + num_cc)) {
  767         av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
  768         return -1;
  769     }
  770     decode_channel_map(layout_map       , AAC_CHANNEL_FRONT, gb, num_front);
  771     tags = num_front;
  772     decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE,  gb, num_side);
  773     tags += num_side;
  774     decode_channel_map(layout_map + tags, AAC_CHANNEL_BACK,  gb, num_back);
  775     tags += num_back;
  776     decode_channel_map(layout_map + tags, AAC_CHANNEL_LFE,   gb, num_lfe);
  777     tags += num_lfe;
  778 
  779     skip_bits_long(gb, 4 * num_assoc_data);
  780 
  781     decode_channel_map(layout_map + tags, AAC_CHANNEL_CC,    gb, num_cc);
  782     tags += num_cc;
  783 
  784     relative_align_get_bits(gb, byte_align_ref);
  785 
  786     /* comment field, first byte is length */
  787     comment_len = get_bits(gb, 8) * 8;
  788     if (get_bits_left(gb) < comment_len) {
  789         av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
  790         return AVERROR_INVALIDDATA;
  791     }
  792     skip_bits_long(gb, comment_len);
  793     return tags;
  794 }
  795 
  796 /**
  797  * Decode GA "General Audio" specific configuration; reference: table 4.1.
  798  *
  799  * @param   ac          pointer to AACContext, may be null
  800  * @param   avctx       pointer to AVCCodecContext, used for logging
  801  *
  802  * @return  Returns error status. 0 - OK, !0 - error
  803  */
  804 static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
  805                                      GetBitContext *gb,
  806                                      int get_bit_alignment,
  807                                      MPEG4AudioConfig *m4ac,
  808                                      int channel_config)
  809 {
  810     int extension_flag, ret, ep_config, res_flags;
  811     uint8_t layout_map[MAX_ELEM_ID*4][3];
  812     int tags = 0;
  813 
  814 #if USE_FIXED
  815     if (get_bits1(gb)) { // frameLengthFlag
  816         avpriv_report_missing_feature(avctx, "Fixed point 960/120 MDCT window");
  817         return AVERROR_PATCHWELCOME;
  818     }
  819     m4ac->frame_length_short = 0;
  820 #else
  821     m4ac->frame_length_short = get_bits1(gb);
  822     if (m4ac->frame_length_short && m4ac->sbr == 1) {
  823       avpriv_report_missing_feature(avctx, "SBR with 960 frame length");
  824       if (ac) ac->warned_960_sbr = 1;
  825       m4ac->sbr = 0;
  826       m4ac->ps = 0;
  827     }
  828 #endif
  829 
  830     if (get_bits1(gb))       // dependsOnCoreCoder
  831         skip_bits(gb, 14);   // coreCoderDelay
  832     extension_flag = get_bits1(gb);
  833 
  834     if (m4ac->object_type == AOT_AAC_SCALABLE ||
  835         m4ac->object_type == AOT_ER_AAC_SCALABLE)
  836         skip_bits(gb, 3);     // layerNr
  837 
  838     if (channel_config == 0) {
  839         skip_bits(gb, 4);  // element_instance_tag
  840         tags = decode_pce(avctx, m4ac, layout_map, gb, get_bit_alignment);
  841         if (tags < 0)
  842             return tags;
  843     } else {
  844         if ((ret = set_default_channel_config(avctx, layout_map,
  845                                               &tags, channel_config)))
  846             return ret;
  847     }
  848 
  849     if (count_channels(layout_map, tags) > 1) {
  850         m4ac->ps = 0;
  851     } else if (m4ac->sbr == 1 && m4ac->ps == -1)
  852         m4ac->ps = 1;
  853 
  854     if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
  855         return ret;
  856 
  857     if (extension_flag) {
  858         switch (m4ac->object_type) {
  859         case AOT_ER_BSAC:
  860             skip_bits(gb, 5);    // numOfSubFrame
  861             skip_bits(gb, 11);   // layer_length
  862             break;
  863         case AOT_ER_AAC_LC:
  864         case AOT_ER_AAC_LTP:
  865         case AOT_ER_AAC_SCALABLE:
  866         case AOT_ER_AAC_LD:
  867             res_flags = get_bits(gb, 3);
  868             if (res_flags) {
  869                 avpriv_report_missing_feature(avctx,
  870                                               "AAC data resilience (flags %x)",
  871                                               res_flags);
  872                 return AVERROR_PATCHWELCOME;
  873             }
  874             break;
  875         }
  876         skip_bits1(gb);    // extensionFlag3 (TBD in version 3)
  877     }
  878     switch (m4ac->object_type) {
  879     case AOT_ER_AAC_LC:
  880     case AOT_ER_AAC_LTP:
  881     case AOT_ER_AAC_SCALABLE:
  882     case AOT_ER_AAC_LD:
  883         ep_config = get_bits(gb, 2);
  884         if (ep_config) {
  885             avpriv_report_missing_feature(avctx,
  886                                           "epConfig %d", ep_config);
  887             return AVERROR_PATCHWELCOME;
  888         }
  889     }
  890     return 0;
  891 }
  892 
  893 static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx,
  894                                      GetBitContext *gb,
  895                                      MPEG4AudioConfig *m4ac,
  896                                      int channel_config)
  897 {
  898     int ret, ep_config, res_flags;
  899     uint8_t layout_map[MAX_ELEM_ID*4][3];
  900     int tags = 0;
  901     const int ELDEXT_TERM = 0;
  902 
  903     m4ac->ps  = 0;
  904     m4ac->sbr = 0;
  905 #if USE_FIXED
  906     if (get_bits1(gb)) { // frameLengthFlag
  907         avpriv_request_sample(avctx, "960/120 MDCT window");
  908         return AVERROR_PATCHWELCOME;
  909     }
  910 #else
  911     m4ac->frame_length_short = get_bits1(gb);
  912 #endif
  913     res_flags = get_bits(gb, 3);
  914     if (res_flags) {
  915         avpriv_report_missing_feature(avctx,
  916                                       "AAC data resilience (flags %x)",
  917                                       res_flags);
  918         return AVERROR_PATCHWELCOME;
  919     }
  920 
  921     if (get_bits1(gb)) { // ldSbrPresentFlag
  922         avpriv_report_missing_feature(avctx,
  923                                       "Low Delay SBR");
  924         return AVERROR_PATCHWELCOME;
  925     }
  926 
  927     while (get_bits(gb, 4) != ELDEXT_TERM) {
  928         int len = get_bits(gb, 4);
  929         if (len == 15)
  930             len += get_bits(gb, 8);
  931         if (len == 15 + 255)
  932             len += get_bits(gb, 16);
  933         if (get_bits_left(gb) < len * 8 + 4) {
  934             av_log(avctx, AV_LOG_ERROR, overread_err);
  935             return AVERROR_INVALIDDATA;
  936         }
  937         skip_bits_long(gb, 8 * len);
  938     }
  939 
  940     if ((ret = set_default_channel_config(avctx, layout_map,
  941                                           &tags, channel_config)))
  942         return ret;
  943 
  944     if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
  945         return ret;
  946 
  947     ep_config = get_bits(gb, 2);
  948     if (ep_config) {
  949         avpriv_report_missing_feature(avctx,
  950                                       "epConfig %d", ep_config);
  951         return AVERROR_PATCHWELCOME;
  952     }
  953     return 0;
  954 }
  955 
  956 /**
  957  * Decode audio specific configuration; reference: table 1.13.
  958  *
  959  * @param   ac          pointer to AACContext, may be null
  960  * @param   avctx       pointer to AVCCodecContext, used for logging
  961  * @param   m4ac        pointer to MPEG4AudioConfig, used for parsing
  962  * @param   gb          buffer holding an audio specific config
  963  * @param   get_bit_alignment relative alignment for byte align operations
  964  * @param   sync_extension look for an appended sync extension
  965  *
  966  * @return  Returns error status or number of consumed bits. <0 - error
  967  */
  968 static int decode_audio_specific_config_gb(AACContext *ac,
  969                                            AVCodecContext *avctx,
  970                                            MPEG4AudioConfig *m4ac,
  971                                            GetBitContext *gb,
  972                                            int get_bit_alignment,
  973                                            int sync_extension)
  974 {
  975     int i, ret;
  976     GetBitContext gbc = *gb;
  977 
  978     if ((i = ff_mpeg4audio_get_config_gb(m4ac, &gbc, sync_extension)) < 0)
  979         return AVERROR_INVALIDDATA;
  980 
  981     if (m4ac->sampling_index > 12) {
  982         av_log(avctx, AV_LOG_ERROR,
  983                "invalid sampling rate index %d\n",
  984                m4ac->sampling_index);
  985         return AVERROR_INVALIDDATA;
  986     }
  987     if (m4ac->object_type == AOT_ER_AAC_LD &&
  988         (m4ac->sampling_index < 3 || m4ac->sampling_index > 7)) {
  989         av_log(avctx, AV_LOG_ERROR,
  990                "invalid low delay sampling rate index %d\n",
  991                m4ac->sampling_index);
  992         return AVERROR_INVALIDDATA;
  993     }
  994 
  995     skip_bits_long(gb, i);
  996 
  997     switch (m4ac->object_type) {
  998     case AOT_AAC_MAIN:
  999     case AOT_AAC_LC:
 1000     case AOT_AAC_LTP:
 1001     case AOT_ER_AAC_LC:
 1002     case AOT_ER_AAC_LD:
 1003         if ((ret = decode_ga_specific_config(ac, avctx, gb, get_bit_alignment,
 1004                                             m4ac, m4ac->chan_config)) < 0)
 1005             return ret;
 1006         break;
 1007     case AOT_ER_AAC_ELD:
 1008         if ((ret = decode_eld_specific_config(ac, avctx, gb,
 1009                                               m4ac, m4ac->chan_config)) < 0)
 1010             return ret;
 1011         break;
 1012     default:
 1013         avpriv_report_missing_feature(avctx,
 1014                                       "Audio object type %s%d",
 1015                                       m4ac->sbr == 1 ? "SBR+" : "",
 1016                                       m4ac->object_type);
 1017         return AVERROR(ENOSYS);
 1018     }
 1019 
 1020     ff_dlog(avctx,
 1021             "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
 1022             m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
 1023             m4ac->sample_rate, m4ac->sbr,
 1024             m4ac->ps);
 1025 
 1026     return get_bits_count(gb);
 1027 }
 1028 
 1029 static int decode_audio_specific_config(AACContext *ac,
 1030                                         AVCodecContext *avctx,
 1031                                         MPEG4AudioConfig *m4ac,
 1032                                         const uint8_t *data, int64_t bit_size,
 1033                                         int sync_extension)
 1034 {
 1035     int i, ret;
 1036     GetBitContext gb;
 1037 
 1038     if (bit_size < 0 || bit_size > INT_MAX) {
 1039         av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
 1040         return AVERROR_INVALIDDATA;
 1041     }
 1042 
 1043     ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
 1044     for (i = 0; i < bit_size >> 3; i++)
 1045         ff_dlog(avctx, "%02x ", data[i]);
 1046     ff_dlog(avctx, "\n");
 1047 
 1048     if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
 1049         return ret;
 1050 
 1051     return decode_audio_specific_config_gb(ac, avctx, m4ac, &gb, 0,
 1052                                            sync_extension);
 1053 }
 1054 
 1055 /**
 1056  * linear congruential pseudorandom number generator
 1057  *
 1058  * @param   previous_val    pointer to the current state of the generator
 1059  *
 1060  * @return  Returns a 32-bit pseudorandom integer
 1061  */
 1062 static av_always_inline int lcg_random(unsigned previous_val)
 1063 {
 1064     union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
 1065     return v.s;
 1066 }
 1067 
 1068 static void reset_all_predictors(PredictorState *ps)
 1069 {
 1070     int i;
 1071     for (i = 0; i < MAX_PREDICTORS; i++)
 1072         reset_predict_state(&ps[i]);
 1073 }
 1074 
 1075 static int sample_rate_idx (int rate)
 1076 {
 1077          if (92017 <= rate) return 0;
 1078     else if (75132 <= rate) return 1;
 1079     else if (55426 <= rate) return 2;
 1080     else if (46009 <= rate) return 3;
 1081     else if (37566 <= rate) return 4;
 1082     else if (27713 <= rate) return 5;
 1083     else if (23004 <= rate) return 6;
 1084     else if (18783 <= rate) return 7;
 1085     else if (13856 <= rate) return 8;
 1086     else if (11502 <= rate) return 9;
 1087     else if (9391  <= rate) return 10;
 1088     else                    return 11;
 1089 }
 1090 
 1091 static void reset_predictor_group(PredictorState *ps, int group_num)
 1092 {
 1093     int i;
 1094     for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
 1095         reset_predict_state(&ps[i]);
 1096 }
 1097 
 1098 #define AAC_INIT_VLC_STATIC(num, size)                                     \
 1099     INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num],     \
 1100          ff_aac_spectral_bits[num], sizeof(ff_aac_spectral_bits[num][0]),  \
 1101                                     sizeof(ff_aac_spectral_bits[num][0]),  \
 1102         ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), \
 1103                                     sizeof(ff_aac_spectral_codes[num][0]), \
 1104         size);
 1105 
 1106 static void aacdec_init(AACContext *ac);
 1107 
 1108 static av_cold void aac_static_table_init(void)
 1109 {
 1110     AAC_INIT_VLC_STATIC( 0, 304);
 1111     AAC_INIT_VLC_STATIC( 1, 270);
 1112     AAC_INIT_VLC_STATIC( 2, 550);
 1113     AAC_INIT_VLC_STATIC( 3, 300);
 1114     AAC_INIT_VLC_STATIC( 4, 328);
 1115     AAC_INIT_VLC_STATIC( 5, 294);
 1116     AAC_INIT_VLC_STATIC( 6, 306);
 1117     AAC_INIT_VLC_STATIC( 7, 268);
 1118     AAC_INIT_VLC_STATIC( 8, 510);
 1119     AAC_INIT_VLC_STATIC( 9, 366);
 1120     AAC_INIT_VLC_STATIC(10, 462);
 1121 
 1122     AAC_RENAME(ff_aac_sbr_init)();
 1123 
 1124     ff_aac_tableinit();
 1125 
 1126     INIT_VLC_STATIC(&vlc_scalefactors, 7,
 1127                     FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
 1128                     ff_aac_scalefactor_bits,
 1129                     sizeof(ff_aac_scalefactor_bits[0]),
 1130                     sizeof(ff_aac_scalefactor_bits[0]),
 1131                     ff_aac_scalefactor_code,
 1132                     sizeof(ff_aac_scalefactor_code[0]),
 1133                     sizeof(ff_aac_scalefactor_code[0]),
 1134                     352);
 1135 
 1136     // window initialization
 1137     AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_long_1024), 4.0, 1024);
 1138     AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_short_128), 6.0, 128);
 1139 #if !USE_FIXED
 1140     AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_long_960), 4.0, 960);
 1141     AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_short_120), 6.0, 120);
 1142     AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_960), 960);
 1143     AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_120), 120);
 1144 #endif
 1145     AAC_RENAME(ff_init_ff_sine_windows)(10);
 1146     AAC_RENAME(ff_init_ff_sine_windows)( 9);
 1147     AAC_RENAME(ff_init_ff_sine_windows)( 7);
 1148 
 1149     AAC_RENAME(ff_cbrt_tableinit)();
 1150 }
 1151 
 1152 static AVOnce aac_table_init = AV_ONCE_INIT;
 1153 
 1154 static av_cold int aac_decode_init(AVCodecContext *avctx)
 1155 {
 1156     AACContext *ac = avctx->priv_data;
 1157     int ret;
 1158 
 1159     ret = ff_thread_once(&aac_table_init, &aac_static_table_init);
 1160     if (ret != 0)
 1161         return AVERROR_UNKNOWN;
 1162 
 1163     ac->avctx = avctx;
 1164     ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
 1165 
 1166     aacdec_init(ac);
 1167 #if USE_FIXED
 1168     avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
 1169 #else
 1170     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
 1171 #endif /* USE_FIXED */
 1172 
 1173     if (avctx->extradata_size > 0) {
 1174         if ((ret = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
 1175                                                 avctx->extradata,
 1176                                                 avctx->extradata_size * 8LL,
 1177                                                 1)) < 0)
 1178             return ret;
 1179     } else {
 1180         int sr, i;
 1181         uint8_t layout_map[MAX_ELEM_ID*4][3];
 1182         int layout_map_tags;
 1183 
 1184         sr = sample_rate_idx(avctx->sample_rate);
 1185         ac->oc[1].m4ac.sampling_index = sr;
 1186         ac->oc[1].m4ac.channels = avctx->channels;
 1187         ac->oc[1].m4ac.sbr = -1;
 1188         ac->oc[1].m4ac.ps = -1;
 1189 
 1190         for (i = 0; i < FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++)
 1191             if (ff_mpeg4audio_channels[i] == avctx->channels)
 1192                 break;
 1193         if (i == FF_ARRAY_ELEMS(ff_mpeg4audio_channels)) {
 1194             i = 0;
 1195         }
 1196         ac->oc[1].m4ac.chan_config = i;
 1197 
 1198         if (ac->oc[1].m4ac.chan_config) {
 1199             int ret = set_default_channel_config(avctx, layout_map,
 1200                 &layout_map_tags, ac->oc[1].m4ac.chan_config);
 1201             if (!ret)
 1202                 output_configure(ac, layout_map, layout_map_tags,
 1203                                  OC_GLOBAL_HDR, 0);
 1204             else if (avctx->err_recognition & AV_EF_EXPLODE)
 1205                 return AVERROR_INVALIDDATA;
 1206         }
 1207     }
 1208 
 1209     if (avctx->channels > MAX_CHANNELS) {
 1210         av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
 1211         return AVERROR_INVALIDDATA;
 1212     }
 1213 
 1214 #if USE_FIXED
 1215     ac->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 1216 #else
 1217     ac->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 1218 #endif /* USE_FIXED */
 1219     if (!ac->fdsp) {
 1220         return AVERROR(ENOMEM);
 1221     }
 1222 
 1223     ac->random_state = 0x1f2e3d4c;
 1224 
 1225     AAC_RENAME_32(ff_mdct_init)(&ac->mdct,       11, 1, 1.0 / RANGE15(1024.0));
 1226     AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ld,    10, 1, 1.0 / RANGE15(512.0));
 1227     AAC_RENAME_32(ff_mdct_init)(&ac->mdct_small,  8, 1, 1.0 / RANGE15(128.0));
 1228     AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ltp,   11, 0, RANGE15(-2.0));
 1229 #if !USE_FIXED
 1230     ret = ff_mdct15_init(&ac->mdct120, 1, 3, 1.0f/(16*1024*120*2));
 1231     if (ret < 0)
 1232         return ret;
 1233     ret = ff_mdct15_init(&ac->mdct480, 1, 5, 1.0f/(16*1024*960));
 1234     if (ret < 0)
 1235         return ret;
 1236     ret = ff_mdct15_init(&ac->mdct960, 1, 6, 1.0f/(16*1024*960*2));
 1237     if (ret < 0)
 1238         return ret;
 1239 #endif
 1240 
 1241     return 0;
 1242 }
 1243 
 1244 /**
 1245  * Skip data_stream_element; reference: table 4.10.
 1246  */
 1247 static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
 1248 {
 1249     int byte_align = get_bits1(gb);
 1250     int count = get_bits(gb, 8);
 1251     if (count == 255)
 1252         count += get_bits(gb, 8);
 1253     if (byte_align)
 1254         align_get_bits(gb);
 1255 
 1256     if (get_bits_left(gb) < 8 * count) {
 1257         av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
 1258         return AVERROR_INVALIDDATA;
 1259     }
 1260     skip_bits_long(gb, 8 * count);
 1261     return 0;
 1262 }
 1263 
 1264 static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
 1265                              GetBitContext *gb)
 1266 {
 1267     int sfb;
 1268     if (get_bits1(gb)) {
 1269         ics->predictor_reset_group = get_bits(gb, 5);
 1270         if (ics->predictor_reset_group == 0 ||
 1271             ics->predictor_reset_group > 30) {
 1272             av_log(ac->avctx, AV_LOG_ERROR,
 1273                    "Invalid Predictor Reset Group.\n");
 1274             return AVERROR_INVALIDDATA;
 1275         }
 1276     }
 1277     for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index]); sfb++) {
 1278         ics->prediction_used[sfb] = get_bits1(gb);
 1279     }
 1280     return 0;
 1281 }
 1282 
 1283 /**
 1284  * Decode Long Term Prediction data; reference: table 4.xx.
 1285  */
 1286 static void decode_ltp(LongTermPrediction *ltp,
 1287                        GetBitContext *gb, uint8_t max_sfb)
 1288 {
 1289     int sfb;
 1290 
 1291     ltp->lag  = get_bits(gb, 11);
 1292     ltp->coef = ltp_coef[get_bits(gb, 3)];
 1293     for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
 1294         ltp->used[sfb] = get_bits1(gb);
 1295 }
 1296 
 1297 /**
 1298  * Decode Individual Channel Stream info; reference: table 4.6.
 1299  */
 1300 static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
 1301                            GetBitContext *gb)
 1302 {
 1303     const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
 1304     const int aot = m4ac->object_type;
 1305     const int sampling_index = m4ac->sampling_index;
 1306     int ret_fail = AVERROR_INVALIDDATA;
 1307 
 1308     if (aot != AOT_ER_AAC_ELD) {
 1309         if (get_bits1(gb)) {
 1310             av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
 1311             if (ac->avctx->err_recognition & AV_EF_BITSTREAM)
 1312                 return AVERROR_INVALIDDATA;
 1313         }
 1314         ics->window_sequence[1] = ics->window_sequence[0];
 1315         ics->window_sequence[0] = get_bits(gb, 2);
 1316         if (aot == AOT_ER_AAC_LD &&
 1317             ics->window_sequence[0] != ONLY_LONG_SEQUENCE) {
 1318             av_log(ac->avctx, AV_LOG_ERROR,
 1319                    "AAC LD is only defined for ONLY_LONG_SEQUENCE but "
 1320                    "window sequence %d found.\n", ics->window_sequence[0]);
 1321             ics->window_sequence[0] = ONLY_LONG_SEQUENCE;
 1322             return AVERROR_INVALIDDATA;
 1323         }
 1324         ics->use_kb_window[1]   = ics->use_kb_window[0];
 1325         ics->use_kb_window[0]   = get_bits1(gb);
 1326     }
 1327     ics->num_window_groups  = 1;
 1328     ics->group_len[0]       = 1;
 1329     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 1330         int i;
 1331         ics->max_sfb = get_bits(gb, 4);
 1332         for (i = 0; i < 7; i++) {
 1333             if (get_bits1(gb)) {
 1334                 ics->group_len[ics->num_window_groups - 1]++;
 1335             } else {
 1336                 ics->num_window_groups++;
 1337                 ics->group_len[ics->num_window_groups - 1] = 1;
 1338             }
 1339         }
 1340         ics->num_windows       = 8;
 1341         if (m4ac->frame_length_short) {
 1342             ics->swb_offset    =  ff_swb_offset_120[sampling_index];
 1343             ics->num_swb       = ff_aac_num_swb_120[sampling_index];
 1344         } else {
 1345             ics->swb_offset    =  ff_swb_offset_128[sampling_index];
 1346             ics->num_swb       = ff_aac_num_swb_128[sampling_index];
 1347         }
 1348         ics->tns_max_bands     = ff_tns_max_bands_128[sampling_index];
 1349         ics->predictor_present = 0;
 1350     } else {
 1351         ics->max_sfb           = get_bits(gb, 6);
 1352         ics->num_windows       = 1;
 1353         if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD) {
 1354             if (m4ac->frame_length_short) {
 1355                 ics->swb_offset    =     ff_swb_offset_480[sampling_index];
 1356                 ics->num_swb       =    ff_aac_num_swb_480[sampling_index];
 1357                 ics->tns_max_bands =  ff_tns_max_bands_480[sampling_index];
 1358             } else {
 1359                 ics->swb_offset    =     ff_swb_offset_512[sampling_index];
 1360                 ics->num_swb       =    ff_aac_num_swb_512[sampling_index];
 1361                 ics->tns_max_bands =  ff_tns_max_bands_512[sampling_index];
 1362             }
 1363             if (!ics->num_swb || !ics->swb_offset) {
 1364                 ret_fail = AVERROR_BUG;
 1365                 goto fail;
 1366             }
 1367         } else {
 1368             if (m4ac->frame_length_short) {
 1369                 ics->num_swb    = ff_aac_num_swb_960[sampling_index];
 1370                 ics->swb_offset = ff_swb_offset_960[sampling_index];
 1371             } else {
 1372                 ics->num_swb    = ff_aac_num_swb_1024[sampling_index];
 1373                 ics->swb_offset = ff_swb_offset_1024[sampling_index];
 1374             }
 1375             ics->tns_max_bands = ff_tns_max_bands_1024[sampling_index];
 1376         }
 1377         if (aot != AOT_ER_AAC_ELD) {
 1378             ics->predictor_present     = get_bits1(gb);
 1379             ics->predictor_reset_group = 0;
 1380         }
 1381         if (ics->predictor_present) {
 1382             if (aot == AOT_AAC_MAIN) {
 1383                 if (decode_prediction(ac, ics, gb)) {
 1384                     goto fail;
 1385                 }
 1386             } else if (aot == AOT_AAC_LC ||
 1387                        aot == AOT_ER_AAC_LC) {
 1388                 av_log(ac->avctx, AV_LOG_ERROR,
 1389                        "Prediction is not allowed in AAC-LC.\n");
 1390                 goto fail;
 1391             } else {
 1392                 if (aot == AOT_ER_AAC_LD) {
 1393                     av_log(ac->avctx, AV_LOG_ERROR,
 1394                            "LTP in ER AAC LD not yet implemented.\n");
 1395                     ret_fail = AVERROR_PATCHWELCOME;
 1396                     goto fail;
 1397                 }
 1398                 if ((ics->ltp.present = get_bits(gb, 1)))
 1399                     decode_ltp(&ics->ltp, gb, ics->max_sfb);
 1400             }
 1401         }
 1402     }
 1403 
 1404     if (ics->max_sfb > ics->num_swb) {
 1405         av_log(ac->avctx, AV_LOG_ERROR,
 1406                "Number of scalefactor bands in group (%d) "
 1407                "exceeds limit (%d).\n",
 1408                ics->max_sfb, ics->num_swb);
 1409         goto fail;
 1410     }
 1411 
 1412     return 0;
 1413 fail:
 1414     ics->max_sfb = 0;
 1415     return ret_fail;
 1416 }
 1417 
 1418 /**
 1419  * Decode band types (section_data payload); reference: table 4.46.
 1420  *
 1421  * @param   band_type           array of the used band type
 1422  * @param   band_type_run_end   array of the last scalefactor band of a band type run
 1423  *
 1424  * @return  Returns error status. 0 - OK, !0 - error
 1425  */
 1426 static int decode_band_types(AACContext *ac, enum BandType band_type[120],
 1427                              int band_type_run_end[120], GetBitContext *gb,
 1428                              IndividualChannelStream *ics)
 1429 {
 1430     int g, idx = 0;
 1431     const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
 1432     for (g = 0; g < ics->num_window_groups; g++) {
 1433         int k = 0;
 1434         while (k < ics->max_sfb) {
 1435             uint8_t sect_end = k;
 1436             int sect_len_incr;
 1437             int sect_band_type = get_bits(gb, 4);
 1438             if (sect_band_type == 12) {
 1439                 av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
 1440                 return AVERROR_INVALIDDATA;
 1441             }
 1442             do {
 1443                 sect_len_incr = get_bits(gb, bits);
 1444                 sect_end += sect_len_incr;
 1445                 if (get_bits_left(gb) < 0) {
 1446                     av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
 1447                     return AVERROR_INVALIDDATA;
 1448                 }
 1449                 if (sect_end > ics->max_sfb) {
 1450                     av_log(ac->avctx, AV_LOG_ERROR,
 1451                            "Number of bands (%d) exceeds limit (%d).\n",
 1452                            sect_end, ics->max_sfb);
 1453                     return AVERROR_INVALIDDATA;
 1454                 }
 1455             } while (sect_len_incr == (1 << bits) - 1);
 1456             for (; k < sect_end; k++) {
 1457                 band_type        [idx]   = sect_band_type;
 1458                 band_type_run_end[idx++] = sect_end;
 1459             }
 1460         }
 1461     }
 1462     return 0;
 1463 }
 1464 
 1465 /**
 1466  * Decode scalefactors; reference: table 4.47.
 1467  *
 1468  * @param   global_gain         first scalefactor value as scalefactors are differentially coded
 1469  * @param   band_type           array of the used band type
 1470  * @param   band_type_run_end   array of the last scalefactor band of a band type run
 1471  * @param   sf                  array of scalefactors or intensity stereo positions
 1472  *
 1473  * @return  Returns error status. 0 - OK, !0 - error
 1474  */
 1475 static int decode_scalefactors(AACContext *ac, INTFLOAT sf[120], GetBitContext *gb,
 1476                                unsigned int global_gain,
 1477                                IndividualChannelStream *ics,
 1478                                enum BandType band_type[120],
 1479                                int band_type_run_end[120])
 1480 {
 1481     int g, i, idx = 0;
 1482     int offset[3] = { global_gain, global_gain - NOISE_OFFSET, 0 };
 1483     int clipped_offset;
 1484     int noise_flag = 1;
 1485     for (g = 0; g < ics->num_window_groups; g++) {
 1486         for (i = 0; i < ics->max_sfb;) {
 1487             int run_end = band_type_run_end[idx];
 1488             if (band_type[idx] == ZERO_BT) {
 1489                 for (; i < run_end; i++, idx++)
 1490                     sf[idx] = FIXR(0.);
 1491             } else if ((band_type[idx] == INTENSITY_BT) ||
 1492                        (band_type[idx] == INTENSITY_BT2)) {
 1493                 for (; i < run_end; i++, idx++) {
 1494                     offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
 1495                     clipped_offset = av_clip(offset[2], -155, 100);
 1496                     if (offset[2] != clipped_offset) {
 1497                         avpriv_request_sample(ac->avctx,
 1498                                               "If you heard an audible artifact, there may be a bug in the decoder. "
 1499                                               "Clipped intensity stereo position (%d -> %d)",
 1500                                               offset[2], clipped_offset);
 1501                     }
 1502 #if USE_FIXED
 1503                     sf[idx] = 100 - clipped_offset;
 1504 #else
 1505                     sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];
 1506 #endif /* USE_FIXED */
 1507                 }
 1508             } else if (band_type[idx] == NOISE_BT) {
 1509                 for (; i < run_end; i++, idx++) {
 1510                     if (noise_flag-- > 0)
 1511                         offset[1] += get_bits(gb, NOISE_PRE_BITS) - NOISE_PRE;
 1512                     else
 1513                         offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
 1514                     clipped_offset = av_clip(offset[1], -100, 155);
 1515                     if (offset[1] != clipped_offset) {
 1516                         avpriv_request_sample(ac->avctx,
 1517                                               "If you heard an audible artifact, there may be a bug in the decoder. "
 1518                                               "Clipped noise gain (%d -> %d)",
 1519                                               offset[1], clipped_offset);
 1520                     }
 1521 #if USE_FIXED
 1522                     sf[idx] = -(100 + clipped_offset);
 1523 #else
 1524                     sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];
 1525 #endif /* USE_FIXED */
 1526                 }
 1527             } else {
 1528                 for (; i < run_end; i++, idx++) {
 1529                     offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
 1530                     if (offset[0] > 255U) {
 1531                         av_log(ac->avctx, AV_LOG_ERROR,
 1532                                "Scalefactor (%d) out of range.\n", offset[0]);
 1533                         return AVERROR_INVALIDDATA;
 1534                     }
 1535 #if USE_FIXED
 1536                     sf[idx] = -offset[0];
 1537 #else
 1538                     sf[idx] = -ff_aac_pow2sf_tab[offset[0] - 100 + POW_SF2_ZERO];
 1539 #endif /* USE_FIXED */
 1540                 }
 1541             }
 1542         }
 1543     }
 1544     return 0;
 1545 }
 1546 
 1547 /**
 1548  * Decode pulse data; reference: table 4.7.
 1549  */
 1550 static int decode_pulses(Pulse *pulse, GetBitContext *gb,
 1551                          const uint16_t *swb_offset, int num_swb)
 1552 {
 1553     int i, pulse_swb;
 1554     pulse->num_pulse = get_bits(gb, 2) + 1;
 1555     pulse_swb        = get_bits(gb, 6);
 1556     if (pulse_swb >= num_swb)
 1557         return -1;
 1558     pulse->pos[0]    = swb_offset[pulse_swb];
 1559     pulse->pos[0]   += get_bits(gb, 5);
 1560     if (pulse->pos[0] >= swb_offset[num_swb])
 1561         return -1;
 1562     pulse->amp[0]    = get_bits(gb, 4);
 1563     for (i = 1; i < pulse->num_pulse; i++) {
 1564         pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
 1565         if (pulse->pos[i] >= swb_offset[num_swb])
 1566             return -1;
 1567         pulse->amp[i] = get_bits(gb, 4);
 1568     }
 1569     return 0;
 1570 }
 1571 
 1572 /**
 1573  * Decode Temporal Noise Shaping data; reference: table 4.48.
 1574  *
 1575  * @return  Returns error status. 0 - OK, !0 - error
 1576  */
 1577 static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
 1578                       GetBitContext *gb, const IndividualChannelStream *ics)
 1579 {
 1580     int w, filt, i, coef_len, coef_res, coef_compress;
 1581     const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
 1582     const int tns_max_order = is8 ? 7 : ac->oc[1].m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
 1583     for (w = 0; w < ics->num_windows; w++) {
 1584         if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
 1585             coef_res = get_bits1(gb);
 1586 
 1587             for (filt = 0; filt < tns->n_filt[w]; filt++) {
 1588                 int tmp2_idx;
 1589                 tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
 1590 
 1591                 if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
 1592                     av_log(ac->avctx, AV_LOG_ERROR,
 1593                            "TNS filter order %d is greater than maximum %d.\n",
 1594                            tns->order[w][filt], tns_max_order);
 1595                     tns->order[w][filt] = 0;
 1596                     return AVERROR_INVALIDDATA;
 1597                 }
 1598                 if (tns->order[w][filt]) {
 1599                     tns->direction[w][filt] = get_bits1(gb);
 1600                     coef_compress = get_bits1(gb);
 1601                     coef_len = coef_res + 3 - coef_compress;
 1602                     tmp2_idx = 2 * coef_compress + coef_res;
 1603 
 1604                     for (i = 0; i < tns->order[w][filt]; i++)
 1605                         tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
 1606                 }
 1607             }
 1608         }
 1609     }
 1610     return 0;
 1611 }
 1612 
 1613 /**
 1614  * Decode Mid/Side data; reference: table 4.54.
 1615  *
 1616  * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
 1617  *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
 1618  *                      [3] reserved for scalable AAC
 1619  */
 1620 static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
 1621                                    int ms_present)
 1622 {
 1623     int idx;
 1624     int max_idx = cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb;
 1625     if (ms_present == 1) {
 1626         for (idx = 0; idx < max_idx; idx++)
 1627             cpe->ms_mask[idx] = get_bits1(gb);
 1628     } else if (ms_present == 2) {
 1629         memset(cpe->ms_mask, 1, max_idx * sizeof(cpe->ms_mask[0]));
 1630     }
 1631 }
 1632 
 1633 /**
 1634  * Decode spectral data; reference: table 4.50.
 1635  * Dequantize and scale spectral data; reference: 4.6.3.3.
 1636  *
 1637  * @param   coef            array of dequantized, scaled spectral data
 1638  * @param   sf              array of scalefactors or intensity stereo positions
 1639  * @param   pulse_present   set if pulses are present
 1640  * @param   pulse           pointer to pulse data struct
 1641  * @param   band_type       array of the used band type
 1642  *
 1643  * @return  Returns error status. 0 - OK, !0 - error
 1644  */
 1645 static int decode_spectrum_and_dequant(AACContext *ac, INTFLOAT coef[1024],
 1646                                        GetBitContext *gb, const INTFLOAT sf[120],
 1647                                        int pulse_present, const Pulse *pulse,
 1648                                        const IndividualChannelStream *ics,
 1649                                        enum BandType band_type[120])
 1650 {
 1651     int i, k, g, idx = 0;
 1652     const int c = 1024 / ics->num_windows;
 1653     const uint16_t *offsets = ics->swb_offset;
 1654     INTFLOAT *coef_base = coef;
 1655 
 1656     for (g = 0; g < ics->num_windows; g++)
 1657         memset(coef + g * 128 + offsets[ics->max_sfb], 0,
 1658                sizeof(INTFLOAT) * (c - offsets[ics->max_sfb]));
 1659 
 1660     for (g = 0; g < ics->num_window_groups; g++) {
 1661         unsigned g_len = ics->group_len[g];
 1662 
 1663         for (i = 0; i < ics->max_sfb; i++, idx++) {
 1664             const unsigned cbt_m1 = band_type[idx] - 1;
 1665             INTFLOAT *cfo = coef + offsets[i];
 1666             int off_len = offsets[i + 1] - offsets[i];
 1667             int group;
 1668 
 1669             if (cbt_m1 >= INTENSITY_BT2 - 1) {
 1670                 for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1671                     memset(cfo, 0, off_len * sizeof(*cfo));
 1672                 }
 1673             } else if (cbt_m1 == NOISE_BT - 1) {
 1674                 for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1675 #if !USE_FIXED
 1676                     float scale;
 1677 #endif /* !USE_FIXED */
 1678                     INTFLOAT band_energy;
 1679 
 1680                     for (k = 0; k < off_len; k++) {
 1681                         ac->random_state  = lcg_random(ac->random_state);
 1682 #if USE_FIXED
 1683                         cfo[k] = ac->random_state >> 3;
 1684 #else
 1685                         cfo[k] = ac->random_state;
 1686 #endif /* USE_FIXED */
 1687                     }
 1688 
 1689 #if USE_FIXED
 1690                     band_energy = ac->fdsp->scalarproduct_fixed(cfo, cfo, off_len);
 1691                     band_energy = fixed_sqrt(band_energy, 31);
 1692                     noise_scale(cfo, sf[idx], band_energy, off_len);
 1693 #else
 1694                     band_energy = ac->fdsp->scalarproduct_float(cfo, cfo, off_len);
 1695                     scale = sf[idx] / sqrtf(band_energy);
 1696                     ac->fdsp->vector_fmul_scalar(cfo, cfo, scale, off_len);
 1697 #endif /* USE_FIXED */
 1698                 }
 1699             } else {
 1700 #if !USE_FIXED
 1701                 const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
 1702 #endif /* !USE_FIXED */
 1703                 const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
 1704                 VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
 1705                 OPEN_READER(re, gb);
 1706 
 1707                 switch (cbt_m1 >> 1) {
 1708                 case 0:
 1709                     for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1710                         INTFLOAT *cf = cfo;
 1711                         int len = off_len;
 1712 
 1713                         do {
 1714                             int code;
 1715                             unsigned cb_idx;
 1716 
 1717                             UPDATE_CACHE(re, gb);
 1718                             GET_VLC(code, re, gb, vlc_tab, 8, 2);
 1719                             cb_idx = cb_vector_idx[code];
 1720 #if USE_FIXED
 1721                             cf = DEC_SQUAD(cf, cb_idx);
 1722 #else
 1723                             cf = VMUL4(cf, vq, cb_idx, sf + idx);
 1724 #endif /* USE_FIXED */
 1725                         } while (len -= 4);
 1726                     }
 1727                     break;
 1728 
 1729                 case 1:
 1730                     for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1731                         INTFLOAT *cf = cfo;
 1732                         int len = off_len;
 1733 
 1734                         do {
 1735                             int code;
 1736                             unsigned nnz;
 1737                             unsigned cb_idx;
 1738                             uint32_t bits;
 1739 
 1740                             UPDATE_CACHE(re, gb);
 1741                             GET_VLC(code, re, gb, vlc_tab, 8, 2);
 1742                             cb_idx = cb_vector_idx[code];
 1743                             nnz = cb_idx >> 8 & 15;
 1744                             bits = nnz ? GET_CACHE(re, gb) : 0;
 1745                             LAST_SKIP_BITS(re, gb, nnz);
 1746 #if USE_FIXED
 1747                             cf = DEC_UQUAD(cf, cb_idx, bits);
 1748 #else
 1749                             cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
 1750 #endif /* USE_FIXED */
 1751                         } while (len -= 4);
 1752                     }
 1753                     break;
 1754 
 1755                 case 2:
 1756                     for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1757                         INTFLOAT *cf = cfo;
 1758                         int len = off_len;
 1759 
 1760                         do {
 1761                             int code;
 1762                             unsigned cb_idx;
 1763 
 1764                             UPDATE_CACHE(re, gb);
 1765                             GET_VLC(code, re, gb, vlc_tab, 8, 2);
 1766                             cb_idx = cb_vector_idx[code];
 1767 #if USE_FIXED
 1768                             cf = DEC_SPAIR(cf, cb_idx);
 1769 #else
 1770                             cf = VMUL2(cf, vq, cb_idx, sf + idx);
 1771 #endif /* USE_FIXED */
 1772                         } while (len -= 2);
 1773                     }
 1774                     break;
 1775 
 1776                 case 3:
 1777                 case 4:
 1778                     for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1779                         INTFLOAT *cf = cfo;
 1780                         int len = off_len;
 1781 
 1782                         do {
 1783                             int code;
 1784                             unsigned nnz;
 1785                             unsigned cb_idx;
 1786                             unsigned sign;
 1787 
 1788                             UPDATE_CACHE(re, gb);
 1789                             GET_VLC(code, re, gb, vlc_tab, 8, 2);
 1790                             cb_idx = cb_vector_idx[code];
 1791                             nnz = cb_idx >> 8 & 15;
 1792                             sign = nnz ? SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12) : 0;
 1793                             LAST_SKIP_BITS(re, gb, nnz);
 1794 #if USE_FIXED
 1795                             cf = DEC_UPAIR(cf, cb_idx, sign);
 1796 #else
 1797                             cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
 1798 #endif /* USE_FIXED */
 1799                         } while (len -= 2);
 1800                     }
 1801                     break;
 1802 
 1803                 default:
 1804                     for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
 1805 #if USE_FIXED
 1806                         int *icf = cfo;
 1807                         int v;
 1808 #else
 1809                         float *cf = cfo;
 1810                         uint32_t *icf = (uint32_t *) cf;
 1811 #endif /* USE_FIXED */
 1812                         int len = off_len;
 1813 
 1814                         do {
 1815                             int code;
 1816                             unsigned nzt, nnz;
 1817                             unsigned cb_idx;
 1818                             uint32_t bits;
 1819                             int j;
 1820 
 1821                             UPDATE_CACHE(re, gb);
 1822                             GET_VLC(code, re, gb, vlc_tab, 8, 2);
 1823 
 1824                             if (!code) {
 1825                                 *icf++ = 0;
 1826                                 *icf++ = 0;
 1827                                 continue;
 1828                             }
 1829 
 1830                             cb_idx = cb_vector_idx[code];
 1831                             nnz = cb_idx >> 12;
 1832                             nzt = cb_idx >> 8;
 1833                             bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
 1834                             LAST_SKIP_BITS(re, gb, nnz);
 1835 
 1836                             for (j = 0; j < 2; j++) {
 1837                                 if (nzt & 1<<j) {
 1838                                     uint32_t b;
 1839                                     int n;
 1840                                     /* The total length of escape_sequence must be < 22 bits according
 1841                                        to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
 1842                                     UPDATE_CACHE(re, gb);
 1843                                     b = GET_CACHE(re, gb);
 1844                                     b = 31 - av_log2(~b);
 1845 
 1846                                     if (b > 8) {
 1847                                         av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
 1848                                         return AVERROR_INVALIDDATA;
 1849                                     }
 1850 
 1851                                     SKIP_BITS(re, gb, b + 1);
 1852                                     b += 4;
 1853                                     n = (1 << b) + SHOW_UBITS(re, gb, b);
 1854                                     LAST_SKIP_BITS(re, gb, b);
 1855 #if USE_FIXED
 1856                                     v = n;
 1857                                     if (bits & 1U<<31)
 1858                                         v = -v;
 1859                                     *icf++ = v;
 1860 #else
 1861                                     *icf++ = ff_cbrt_tab[n] | (bits & 1U<<31);
 1862 #endif /* USE_FIXED */
 1863                                     bits <<= 1;
 1864                                 } else {
 1865 #if USE_FIXED
 1866                                     v = cb_idx & 15;
 1867                                     if (bits & 1U<<31)
 1868                                         v = -v;
 1869                                     *icf++ = v;
 1870 #else
 1871                                     unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
 1872                                     *icf++ = (bits & 1U<<31) | v;
 1873 #endif /* USE_FIXED */
 1874                                     bits <<= !!v;
 1875                                 }
 1876                                 cb_idx >>= 4;
 1877                             }
 1878                         } while (len -= 2);
 1879 #if !USE_FIXED
 1880                         ac->fdsp->vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
 1881 #endif /* !USE_FIXED */
 1882                     }
 1883                 }
 1884 
 1885                 CLOSE_READER(re, gb);
 1886             }
 1887         }
 1888         coef += g_len << 7;
 1889     }
 1890 
 1891     if (pulse_present) {
 1892         idx = 0;
 1893         for (i = 0; i < pulse->num_pulse; i++) {
 1894             INTFLOAT co = coef_base[ pulse->pos[i] ];
 1895             while (offsets[idx + 1] <= pulse->pos[i])
 1896                 idx++;
 1897             if (band_type[idx] != NOISE_BT && sf[idx]) {
 1898                 INTFLOAT ico = -pulse->amp[i];
 1899 #if USE_FIXED
 1900                 if (co) {
 1901                     ico = co + (co > 0 ? -ico : ico);
 1902                 }
 1903                 coef_base[ pulse->pos[i] ] = ico;
 1904 #else
 1905                 if (co) {
 1906                     co /= sf[idx];
 1907                     ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
 1908                 }
 1909                 coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
 1910 #endif /* USE_FIXED */
 1911             }
 1912         }
 1913     }
 1914 #if USE_FIXED
 1915     coef = coef_base;
 1916     idx = 0;
 1917     for (g = 0; g < ics->num_window_groups; g++) {
 1918         unsigned g_len = ics->group_len[g];
 1919 
 1920         for (i = 0; i < ics->max_sfb; i++, idx++) {
 1921             const unsigned cbt_m1 = band_type[idx] - 1;
 1922             int *cfo = coef + offsets[i];
 1923             int off_len = offsets[i + 1] - offsets[i];
 1924             int group;
 1925 
 1926             if (cbt_m1 < NOISE_BT - 1) {
 1927                 for (group = 0; group < (int)g_len; group++, cfo+=128) {
 1928                     ac->vector_pow43(cfo, off_len);
 1929                     ac->subband_scale(cfo, cfo, sf[idx], 34, off_len);
 1930                 }
 1931             }
 1932         }
 1933         coef += g_len << 7;
 1934     }
 1935 #endif /* USE_FIXED */
 1936     return 0;
 1937 }
 1938 
 1939 /**
 1940  * Apply AAC-Main style frequency domain prediction.
 1941  */
 1942 static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
 1943 {
 1944     int sfb, k;
 1945 
 1946     if (!sce->ics.predictor_initialized) {
 1947         reset_all_predictors(sce->predictor_state);
 1948         sce->ics.predictor_initialized = 1;
 1949     }
 1950 
 1951     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
 1952         for (sfb = 0;
 1953              sfb < ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index];
 1954              sfb++) {
 1955             for (k = sce->ics.swb_offset[sfb];
 1956                  k < sce->ics.swb_offset[sfb + 1];
 1957                  k++) {
 1958                 predict(&sce->predictor_state[k], &sce->coeffs[k],
 1959                         sce->ics.predictor_present &&
 1960                         sce->ics.prediction_used[sfb]);
 1961             }
 1962         }
 1963         if (sce->ics.predictor_reset_group)
 1964             reset_predictor_group(sce->predictor_state,
 1965                                   sce->ics.predictor_reset_group);
 1966     } else
 1967         reset_all_predictors(sce->predictor_state);
 1968 }
 1969 
 1970 /**
 1971  * Decode an individual_channel_stream payload; reference: table 4.44.
 1972  *
 1973  * @param   common_window   Channels have independent [0], or shared [1], Individual Channel Stream information.
 1974  * @param   scale_flag      scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
 1975  *
 1976  * @return  Returns error status. 0 - OK, !0 - error
 1977  */
 1978 static int decode_ics(AACContext *ac, SingleChannelElement *sce,
 1979                       GetBitContext *gb, int common_window, int scale_flag)
 1980 {
 1981     Pulse pulse;
 1982     TemporalNoiseShaping    *tns = &sce->tns;
 1983     IndividualChannelStream *ics = &sce->ics;
 1984     INTFLOAT *out = sce->coeffs;
 1985     int global_gain, eld_syntax, er_syntax, pulse_present = 0;
 1986     int ret;
 1987 
 1988     eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
 1989     er_syntax  = ac->oc[1].m4ac.object_type == AOT_ER_AAC_LC ||
 1990                  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LTP ||
 1991                  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LD ||
 1992                  ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
 1993 
 1994     /* This assignment is to silence a GCC warning about the variable being used
 1995      * uninitialized when in fact it always is.
 1996      */
 1997     pulse.num_pulse = 0;
 1998 
 1999     global_gain = get_bits(gb, 8);
 2000 
 2001     if (!common_window && !scale_flag) {
 2002         ret = decode_ics_info(ac, ics, gb);
 2003         if (ret < 0)
 2004             goto fail;
 2005     }
 2006 
 2007     if ((ret = decode_band_types(ac, sce->band_type,
 2008                                  sce->band_type_run_end, gb, ics)) < 0)
 2009         goto fail;
 2010     if ((ret = decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
 2011                                   sce->band_type, sce->band_type_run_end)) < 0)
 2012         goto fail;
 2013 
 2014     pulse_present = 0;
 2015     if (!scale_flag) {
 2016         if (!eld_syntax && (pulse_present = get_bits1(gb))) {
 2017             if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2018                 av_log(ac->avctx, AV_LOG_ERROR,
 2019                        "Pulse tool not allowed in eight short sequence.\n");
 2020                 ret = AVERROR_INVALIDDATA;
 2021                 goto fail;
 2022             }
 2023             if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
 2024                 av_log(ac->avctx, AV_LOG_ERROR,
 2025                        "Pulse data corrupt or invalid.\n");
 2026                 ret = AVERROR_INVALIDDATA;
 2027                 goto fail;
 2028             }
 2029         }
 2030         tns->present = get_bits1(gb);
 2031         if (tns->present && !er_syntax) {
 2032             ret = decode_tns(ac, tns, gb, ics);
 2033             if (ret < 0)
 2034                 goto fail;
 2035         }
 2036         if (!eld_syntax && get_bits1(gb)) {
 2037             avpriv_request_sample(ac->avctx, "SSR");
 2038             ret = AVERROR_PATCHWELCOME;
 2039             goto fail;
 2040         }
 2041         // I see no textual basis in the spec for this occurring after SSR gain
 2042         // control, but this is what both reference and real implmentations do
 2043         if (tns->present && er_syntax) {
 2044             ret = decode_tns(ac, tns, gb, ics);
 2045             if (ret < 0)
 2046                 goto fail;
 2047         }
 2048     }
 2049 
 2050     ret = decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
 2051                                     &pulse, ics, sce->band_type);
 2052     if (ret < 0)
 2053         goto fail;
 2054 
 2055     if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
 2056         apply_prediction(ac, sce);
 2057 
 2058     return 0;
 2059 fail:
 2060     tns->present = 0;
 2061     return ret;
 2062 }
 2063 
 2064 /**
 2065  * Mid/Side stereo decoding; reference: 4.6.8.1.3.
 2066  */
 2067 static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
 2068 {
 2069     const IndividualChannelStream *ics = &cpe->ch[0].ics;
 2070     INTFLOAT *ch0 = cpe->ch[0].coeffs;
 2071     INTFLOAT *ch1 = cpe->ch[1].coeffs;
 2072     int g, i, group, idx = 0;
 2073     const uint16_t *offsets = ics->swb_offset;
 2074     for (g = 0; g < ics->num_window_groups; g++) {
 2075         for (i = 0; i < ics->max_sfb; i++, idx++) {
 2076             if (cpe->ms_mask[idx] &&
 2077                 cpe->ch[0].band_type[idx] < NOISE_BT &&
 2078                 cpe->ch[1].band_type[idx] < NOISE_BT) {
 2079 #if USE_FIXED
 2080                 for (group = 0; group < ics->group_len[g]; group++) {
 2081                     ac->fdsp->butterflies_fixed(ch0 + group * 128 + offsets[i],
 2082                                                 ch1 + group * 128 + offsets[i],
 2083                                                 offsets[i+1] - offsets[i]);
 2084 #else
 2085                 for (group = 0; group < ics->group_len[g]; group++) {
 2086                     ac->fdsp->butterflies_float(ch0 + group * 128 + offsets[i],
 2087                                                ch1 + group * 128 + offsets[i],
 2088                                                offsets[i+1] - offsets[i]);
 2089 #endif /* USE_FIXED */
 2090                 }
 2091             }
 2092         }
 2093         ch0 += ics->group_len[g] * 128;
 2094         ch1 += ics->group_len[g] * 128;
 2095     }
 2096 }
 2097 
 2098 /**
 2099  * intensity stereo decoding; reference: 4.6.8.2.3
 2100  *
 2101  * @param   ms_present  Indicates mid/side stereo presence. [0] mask is all 0s;
 2102  *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
 2103  *                      [3] reserved for scalable AAC
 2104  */
 2105 static void apply_intensity_stereo(AACContext *ac,
 2106                                    ChannelElement *cpe, int ms_present)
 2107 {
 2108     const IndividualChannelStream *ics = &cpe->ch[1].ics;
 2109     SingleChannelElement         *sce1 = &cpe->ch[1];
 2110     INTFLOAT *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
 2111     const uint16_t *offsets = ics->swb_offset;
 2112     int g, group, i, idx = 0;
 2113     int c;
 2114     INTFLOAT scale;
 2115     for (g = 0; g < ics->num_window_groups; g++) {
 2116         for (i = 0; i < ics->max_sfb;) {
 2117             if (sce1->band_type[idx] == INTENSITY_BT ||
 2118                 sce1->band_type[idx] == INTENSITY_BT2) {
 2119                 const int bt_run_end = sce1->band_type_run_end[idx];
 2120                 for (; i < bt_run_end; i++, idx++) {
 2121                     c = -1 + 2 * (sce1->band_type[idx] - 14);
 2122                     if (ms_present)
 2123                         c *= 1 - 2 * cpe->ms_mask[idx];
 2124                     scale = c * sce1->sf[idx];
 2125                     for (group = 0; group < ics->group_len[g]; group++)
 2126 #if USE_FIXED
 2127                         ac->subband_scale(coef1 + group * 128 + offsets[i],
 2128                                       coef0 + group * 128 + offsets[i],
 2129                                       scale,
 2130                                       23,
 2131                                       offsets[i + 1] - offsets[i]);
 2132 #else
 2133                         ac->fdsp->vector_fmul_scalar(coef1 + group * 128 + offsets[i],
 2134                                                     coef0 + group * 128 + offsets[i],
 2135                                                     scale,
 2136                                                     offsets[i + 1] - offsets[i]);
 2137 #endif /* USE_FIXED */
 2138                 }
 2139             } else {
 2140                 int bt_run_end = sce1->band_type_run_end[idx];
 2141                 idx += bt_run_end - i;
 2142                 i    = bt_run_end;
 2143             }
 2144         }
 2145         coef0 += ics->group_len[g] * 128;
 2146         coef1 += ics->group_len[g] * 128;
 2147     }
 2148 }
 2149 
 2150 /**
 2151  * Decode a channel_pair_element; reference: table 4.4.
 2152  *
 2153  * @return  Returns error status. 0 - OK, !0 - error
 2154  */
 2155 static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
 2156 {
 2157     int i, ret, common_window, ms_present = 0;
 2158     int eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
 2159 
 2160     common_window = eld_syntax || get_bits1(gb);
 2161     if (common_window) {
 2162         if (decode_ics_info(ac, &cpe->ch[0].ics, gb))
 2163             return AVERROR_INVALIDDATA;
 2164         i = cpe->ch[1].ics.use_kb_window[0];
 2165         cpe->ch[1].ics = cpe->ch[0].ics;
 2166         cpe->ch[1].ics.use_kb_window[1] = i;
 2167         if (cpe->ch[1].ics.predictor_present &&
 2168             (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
 2169             if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
 2170                 decode_ltp(&cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
 2171         ms_present = get_bits(gb, 2);
 2172         if (ms_present == 3) {
 2173             av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
 2174             return AVERROR_INVALIDDATA;
 2175         } else if (ms_present)
 2176             decode_mid_side_stereo(cpe, gb, ms_present);
 2177     }
 2178     if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
 2179         return ret;
 2180     if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
 2181         return ret;
 2182 
 2183     if (common_window) {
 2184         if (ms_present)
 2185             apply_mid_side_stereo(ac, cpe);
 2186         if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
 2187             apply_prediction(ac, &cpe->ch[0]);
 2188             apply_prediction(ac, &cpe->ch[1]);
 2189         }
 2190     }
 2191 
 2192     apply_intensity_stereo(ac, cpe, ms_present);
 2193     return 0;
 2194 }
 2195 
 2196 static const float cce_scale[] = {
 2197     1.09050773266525765921, //2^(1/8)
 2198     1.18920711500272106672, //2^(1/4)
 2199     M_SQRT2,
 2200     2,
 2201 };
 2202 
 2203 /**
 2204  * Decode coupling_channel_element; reference: table 4.8.
 2205  *
 2206  * @return  Returns error status. 0 - OK, !0 - error
 2207  */
 2208 static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
 2209 {
 2210     int num_gain = 0;
 2211     int c, g, sfb, ret;
 2212     int sign;
 2213     INTFLOAT scale;
 2214     SingleChannelElement *sce = &che->ch[0];
 2215     ChannelCoupling     *coup = &che->coup;
 2216 
 2217     coup->coupling_point = 2 * get_bits1(gb);
 2218     coup->num_coupled = get_bits(gb, 3);
 2219     for (c = 0; c <= coup->num_coupled; c++) {
 2220         num_gain++;
 2221         coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
 2222         coup->id_select[c] = get_bits(gb, 4);
 2223         if (coup->type[c] == TYPE_CPE) {
 2224             coup->ch_select[c] = get_bits(gb, 2);
 2225             if (coup->ch_select[c] == 3)
 2226                 num_gain++;
 2227         } else
 2228             coup->ch_select[c] = 2;
 2229     }
 2230     coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
 2231 
 2232     sign  = get_bits(gb, 1);
 2233 #if USE_FIXED
 2234     scale = get_bits(gb, 2);
 2235 #else
 2236     scale = cce_scale[get_bits(gb, 2)];
 2237 #endif
 2238 
 2239     if ((ret = decode_ics(ac, sce, gb, 0, 0)))
 2240         return ret;
 2241 
 2242     for (c = 0; c < num_gain; c++) {
 2243         int idx  = 0;
 2244         int cge  = 1;
 2245         int gain = 0;
 2246         INTFLOAT gain_cache = FIXR10(1.);
 2247         if (c) {
 2248             cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
 2249             gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
 2250             gain_cache = GET_GAIN(scale, gain);
 2251 #if USE_FIXED
 2252             if ((abs(gain_cache)-1024) >> 3 > 30)
 2253                 return AVERROR(ERANGE);
 2254 #endif
 2255         }
 2256         if (coup->coupling_point == AFTER_IMDCT) {
 2257             coup->gain[c][0] = gain_cache;
 2258         } else {
 2259             for (g = 0; g < sce->ics.num_window_groups; g++) {
 2260                 for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
 2261                     if (sce->band_type[idx] != ZERO_BT) {
 2262                         if (!cge) {
 2263                             int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
 2264                             if (t) {
 2265                                 int s = 1;
 2266                                 t = gain += t;
 2267                                 if (sign) {
 2268                                     s  -= 2 * (t & 0x1);
 2269                                     t >>= 1;
 2270                                 }
 2271                                 gain_cache = GET_GAIN(scale, t) * s;
 2272 #if USE_FIXED
 2273                                 if ((abs(gain_cache)-1024) >> 3 > 30)
 2274                                     return AVERROR(ERANGE);
 2275 #endif
 2276                             }
 2277                         }
 2278                         coup->gain[c][idx] = gain_cache;
 2279                     }
 2280                 }
 2281             }
 2282         }
 2283     }
 2284     return 0;
 2285 }
 2286 
 2287 /**
 2288  * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
 2289  *
 2290  * @return  Returns number of bytes consumed.
 2291  */
 2292 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
 2293                                          GetBitContext *gb)
 2294 {
 2295     int i;
 2296     int num_excl_chan = 0;
 2297 
 2298     do {
 2299         for (i = 0; i < 7; i++)
 2300             che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
 2301     } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
 2302 
 2303     return num_excl_chan / 7;
 2304 }
 2305 
 2306 /**
 2307  * Decode dynamic range information; reference: table 4.52.
 2308  *
 2309  * @return  Returns number of bytes consumed.
 2310  */
 2311 static int decode_dynamic_range(DynamicRangeControl *che_drc,
 2312                                 GetBitContext *gb)
 2313 {
 2314     int n             = 1;
 2315     int drc_num_bands = 1;
 2316     int i;
 2317 
 2318     /* pce_tag_present? */
 2319     if (get_bits1(gb)) {
 2320         che_drc->pce_instance_tag  = get_bits(gb, 4);
 2321         skip_bits(gb, 4); // tag_reserved_bits
 2322         n++;
 2323     }
 2324 
 2325     /* excluded_chns_present? */
 2326     if (get_bits1(gb)) {
 2327         n += decode_drc_channel_exclusions(che_drc, gb);
 2328     }
 2329 
 2330     /* drc_bands_present? */
 2331     if (get_bits1(gb)) {
 2332         che_drc->band_incr            = get_bits(gb, 4);
 2333         che_drc->interpolation_scheme = get_bits(gb, 4);
 2334         n++;
 2335         drc_num_bands += che_drc->band_incr;
 2336         for (i = 0; i < drc_num_bands; i++) {
 2337             che_drc->band_top[i] = get_bits(gb, 8);
 2338             n++;
 2339         }
 2340     }
 2341 
 2342     /* prog_ref_level_present? */
 2343     if (get_bits1(gb)) {
 2344         che_drc->prog_ref_level = get_bits(gb, 7);
 2345         skip_bits1(gb); // prog_ref_level_reserved_bits
 2346         n++;
 2347     }
 2348 
 2349     for (i = 0; i < drc_num_bands; i++) {
 2350         che_drc->dyn_rng_sgn[i] = get_bits1(gb);
 2351         che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
 2352         n++;
 2353     }
 2354 
 2355     return n;
 2356 }
 2357 
 2358 static int decode_fill(AACContext *ac, GetBitContext *gb, int len) {
 2359     uint8_t buf[256];
 2360     int i, major, minor;
 2361 
 2362     if (len < 13+7*8)
 2363         goto unknown;
 2364 
 2365     get_bits(gb, 13); len -= 13;
 2366 
 2367     for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
 2368         buf[i] = get_bits(gb, 8);
 2369 
 2370     buf[i] = 0;
 2371     if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
 2372         av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
 2373 
 2374     if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
 2375         ac->avctx->internal->skip_samples = 1024;
 2376     }
 2377 
 2378 unknown:
 2379     skip_bits_long(gb, len);
 2380 
 2381     return 0;
 2382 }
 2383 
 2384 /**
 2385  * Decode extension data (incomplete); reference: table 4.51.
 2386  *
 2387  * @param   cnt length of TYPE_FIL syntactic element in bytes
 2388  *
 2389  * @return Returns number of bytes consumed
 2390  */
 2391 static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
 2392                                     ChannelElement *che, enum RawDataBlockType elem_type)
 2393 {
 2394     int crc_flag = 0;
 2395     int res = cnt;
 2396     int type = get_bits(gb, 4);
 2397 
 2398     if (ac->avctx->debug & FF_DEBUG_STARTCODE)
 2399         av_log(ac->avctx, AV_LOG_DEBUG, "extension type: %d len:%d\n", type, cnt);
 2400 
 2401     switch (type) { // extension type
 2402     case EXT_SBR_DATA_CRC:
 2403         crc_flag++;
 2404     case EXT_SBR_DATA:
 2405         if (!che) {
 2406             av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
 2407             return res;
 2408         } else if (ac->oc[1].m4ac.frame_length_short) {
 2409             if (!ac->warned_960_sbr)
 2410               avpriv_report_missing_feature(ac->avctx,
 2411                                             "SBR with 960 frame length");
 2412             ac->warned_960_sbr = 1;
 2413             skip_bits_long(gb, 8 * cnt - 4);
 2414             return res;
 2415         } else if (!ac->oc[1].m4ac.sbr) {
 2416             av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
 2417             skip_bits_long(gb, 8 * cnt - 4);
 2418             return res;
 2419         } else if (ac->oc[1].m4ac.sbr == -1 && ac->oc[1].status == OC_LOCKED) {
 2420             av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
 2421             skip_bits_long(gb, 8 * cnt - 4);
 2422             return res;
 2423         } else if (ac->oc[1].m4ac.ps == -1 && ac->oc[1].status < OC_LOCKED && ac->avctx->channels == 1) {
 2424             ac->oc[1].m4ac.sbr = 1;
 2425             ac->oc[1].m4ac.ps = 1;
 2426             ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
 2427             output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
 2428                              ac->oc[1].status, 1);
 2429         } else {
 2430             ac->oc[1].m4ac.sbr = 1;
 2431             ac->avctx->profile = FF_PROFILE_AAC_HE;
 2432         }
 2433         res = AAC_RENAME(ff_decode_sbr_extension)(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
 2434         break;
 2435     case EXT_DYNAMIC_RANGE:
 2436         res = decode_dynamic_range(&ac->che_drc, gb);
 2437         break;
 2438     case EXT_FILL:
 2439         decode_fill(ac, gb, 8 * cnt - 4);
 2440         break;
 2441     case EXT_FILL_DATA:
 2442     case EXT_DATA_ELEMENT:
 2443     default:
 2444         skip_bits_long(gb, 8 * cnt - 4);
 2445         break;
 2446     };
 2447     return res;
 2448 }
 2449 
 2450 /**
 2451  * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
 2452  *
 2453  * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
 2454  * @param   coef    spectral coefficients
 2455  */
 2456 static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
 2457                       IndividualChannelStream *ics, int decode)
 2458 {
 2459     const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
 2460     int w, filt, m, i;
 2461     int bottom, top, order, start, end, size, inc;
 2462     INTFLOAT lpc[TNS_MAX_ORDER];
 2463     INTFLOAT tmp[TNS_MAX_ORDER+1];
 2464     UINTFLOAT *coef = coef_param;
 2465 
 2466     for (w = 0; w < ics->num_windows; w++) {
 2467         bottom = ics->num_swb;
 2468         for (filt = 0; filt < tns->n_filt[w]; filt++) {
 2469             top    = bottom;
 2470             bottom = FFMAX(0, top - tns->length[w][filt]);
 2471             order  = tns->order[w][filt];
 2472             if (order == 0)
 2473                 continue;
 2474 
 2475             // tns_decode_coef
 2476             AAC_RENAME(compute_lpc_coefs)(tns->coef[w][filt], order, lpc, 0, 0, 0);
 2477 
 2478             start = ics->swb_offset[FFMIN(bottom, mmm)];
 2479             end   = ics->swb_offset[FFMIN(   top, mmm)];
 2480             if ((size = end - start) <= 0)
 2481                 continue;
 2482             if (tns->direction[w][filt]) {
 2483                 inc = -1;
 2484                 start = end - 1;
 2485             } else {
 2486                 inc = 1;
 2487             }
 2488             start += w * 128;
 2489 
 2490             if (decode) {
 2491                 // ar filter
 2492                 for (m = 0; m < size; m++, start += inc)
 2493                     for (i = 1; i <= FFMIN(m, order); i++)
 2494                         coef[start] -= AAC_MUL26((INTFLOAT)coef[start - i * inc], lpc[i - 1]);
 2495             } else {
 2496                 // ma filter
 2497                 for (m = 0; m < size; m++, start += inc) {
 2498                     tmp[0] = coef[start];
 2499                     for (i = 1; i <= FFMIN(m, order); i++)
 2500                         coef[start] += AAC_MUL26(tmp[i], lpc[i - 1]);
 2501                     for (i = order; i > 0; i--)
 2502                         tmp[i] = tmp[i - 1];
 2503                 }
 2504             }
 2505         }
 2506     }
 2507 }
 2508 
 2509 /**
 2510  *  Apply windowing and MDCT to obtain the spectral
 2511  *  coefficient from the predicted sample by LTP.
 2512  */
 2513 static void windowing_and_mdct_ltp(AACContext *ac, INTFLOAT *out,
 2514                                    INTFLOAT *in, IndividualChannelStream *ics)
 2515 {
 2516     const INTFLOAT *lwindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
 2517     const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
 2518     const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
 2519     const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
 2520 
 2521     if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
 2522         ac->fdsp->vector_fmul(in, in, lwindow_prev, 1024);
 2523     } else {
 2524         memset(in, 0, 448 * sizeof(*in));
 2525         ac->fdsp->vector_fmul(in + 448, in + 448, swindow_prev, 128);
 2526     }
 2527     if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
 2528         ac->fdsp->vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
 2529     } else {
 2530         ac->fdsp->vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
 2531         memset(in + 1024 + 576, 0, 448 * sizeof(*in));
 2532     }
 2533     ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
 2534 }
 2535 
 2536 /**
 2537  * Apply the long term prediction
 2538  */
 2539 static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
 2540 {
 2541     const LongTermPrediction *ltp = &sce->ics.ltp;
 2542     const uint16_t *offsets = sce->ics.swb_offset;
 2543     int i, sfb;
 2544 
 2545     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
 2546         INTFLOAT *predTime = sce->ret;
 2547         INTFLOAT *predFreq = ac->buf_mdct;
 2548         int16_t num_samples = 2048;
 2549 
 2550         if (ltp->lag < 1024)
 2551             num_samples = ltp->lag + 1024;
 2552         for (i = 0; i < num_samples; i++)
 2553             predTime[i] = AAC_MUL30(sce->ltp_state[i + 2048 - ltp->lag], ltp->coef);
 2554         memset(&predTime[i], 0, (2048 - i) * sizeof(*predTime));
 2555 
 2556         ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
 2557 
 2558         if (sce->tns.present)
 2559             ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
 2560 
 2561         for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
 2562             if (ltp->used[sfb])
 2563                 for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
 2564                     sce->coeffs[i] += predFreq[i];
 2565     }
 2566 }
 2567 
 2568 /**
 2569  * Update the LTP buffer for next frame
 2570  */
 2571 static void update_ltp(AACContext *ac, SingleChannelElement *sce)
 2572 {
 2573     IndividualChannelStream *ics = &sce->ics;
 2574     INTFLOAT *saved     = sce->saved;
 2575     INTFLOAT *saved_ltp = sce->coeffs;
 2576     const INTFLOAT *lwindow = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
 2577     const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
 2578     int i;
 2579 
 2580     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2581         memcpy(saved_ltp,       saved, 512 * sizeof(*saved_ltp));
 2582         memset(saved_ltp + 576, 0,     448 * sizeof(*saved_ltp));
 2583         ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
 2584 
 2585         for (i = 0; i < 64; i++)
 2586             saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
 2587     } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
 2588         memcpy(saved_ltp,       ac->buf_mdct + 512, 448 * sizeof(*saved_ltp));
 2589         memset(saved_ltp + 576, 0,                  448 * sizeof(*saved_ltp));
 2590         ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
 2591 
 2592         for (i = 0; i < 64; i++)
 2593             saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
 2594     } else { // LONG_STOP or ONLY_LONG
 2595         ac->fdsp->vector_fmul_reverse(saved_ltp,       ac->buf_mdct + 512,     &lwindow[512],     512);
 2596 
 2597         for (i = 0; i < 512; i++)
 2598             saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], lwindow[511 - i]);
 2599     }
 2600 
 2601     memcpy(sce->ltp_state,      sce->ltp_state+1024, 1024 * sizeof(*sce->ltp_state));
 2602     memcpy(sce->ltp_state+1024, sce->ret,            1024 * sizeof(*sce->ltp_state));
 2603     memcpy(sce->ltp_state+2048, saved_ltp,           1024 * sizeof(*sce->ltp_state));
 2604 }
 2605 
 2606 /**
 2607  * Conduct IMDCT and windowing.
 2608  */
 2609 static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
 2610 {
 2611     IndividualChannelStream *ics = &sce->ics;
 2612     INTFLOAT *in    = sce->coeffs;
 2613     INTFLOAT *out   = sce->ret;
 2614     INTFLOAT *saved = sce->saved;
 2615     const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
 2616     const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_1024) : AAC_RENAME(ff_sine_1024);
 2617     const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_128) : AAC_RENAME(ff_sine_128);
 2618     INTFLOAT *buf  = ac->buf_mdct;
 2619     INTFLOAT *temp = ac->temp;
 2620     int i;
 2621 
 2622     // imdct
 2623     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2624         for (i = 0; i < 1024; i += 128)
 2625             ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
 2626     } else {
 2627         ac->mdct.imdct_half(&ac->mdct, buf, in);
 2628 #if USE_FIXED
 2629         for (i=0; i<1024; i++)
 2630           buf[i] = (buf[i] + 4) >> 3;
 2631 #endif /* USE_FIXED */
 2632     }
 2633 
 2634     /* window overlapping
 2635      * NOTE: To simplify the overlapping code, all 'meaningless' short to long
 2636      * and long to short transitions are considered to be short to short
 2637      * transitions. This leaves just two cases (long to long and short to short)
 2638      * with a little special sauce for EIGHT_SHORT_SEQUENCE.
 2639      */
 2640     if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
 2641             (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
 2642         ac->fdsp->vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 512);
 2643     } else {
 2644         memcpy(                         out,               saved,            448 * sizeof(*out));
 2645 
 2646         if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2647             ac->fdsp->vector_fmul_window(out + 448 + 0*128, saved + 448,      buf + 0*128, swindow_prev, 64);
 2648             ac->fdsp->vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow,      64);
 2649             ac->fdsp->vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow,      64);
 2650             ac->fdsp->vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow,      64);
 2651             ac->fdsp->vector_fmul_window(temp,              buf + 3*128 + 64, buf + 4*128, swindow,      64);
 2652             memcpy(                     out + 448 + 4*128, temp, 64 * sizeof(*out));
 2653         } else {
 2654             ac->fdsp->vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, 64);
 2655             memcpy(                     out + 576,         buf + 64,         448 * sizeof(*out));
 2656         }
 2657     }
 2658 
 2659     // buffer update
 2660     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2661         memcpy(                     saved,       temp + 64,         64 * sizeof(*saved));
 2662         ac->fdsp->vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 64);
 2663         ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
 2664         ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
 2665         memcpy(                     saved + 448, buf + 7*128 + 64,  64 * sizeof(*saved));
 2666     } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
 2667         memcpy(                     saved,       buf + 512,        448 * sizeof(*saved));
 2668         memcpy(                     saved + 448, buf + 7*128 + 64,  64 * sizeof(*saved));
 2669     } else { // LONG_STOP or ONLY_LONG
 2670         memcpy(                     saved,       buf + 512,        512 * sizeof(*saved));
 2671     }
 2672 }
 2673 
 2674 /**
 2675  * Conduct IMDCT and windowing.
 2676  */
 2677 static void imdct_and_windowing_960(AACContext *ac, SingleChannelElement *sce)
 2678 {
 2679 #if !USE_FIXED
 2680     IndividualChannelStream *ics = &sce->ics;
 2681     INTFLOAT *in    = sce->coeffs;
 2682     INTFLOAT *out   = sce->ret;
 2683     INTFLOAT *saved = sce->saved;
 2684     const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_120) : AAC_RENAME(ff_sine_120);
 2685     const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_960) : AAC_RENAME(ff_sine_960);
 2686     const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_120) : AAC_RENAME(ff_sine_120);
 2687     INTFLOAT *buf  = ac->buf_mdct;
 2688     INTFLOAT *temp = ac->temp;
 2689     int i;
 2690 
 2691     // imdct
 2692     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2693         for (i = 0; i < 8; i++)
 2694             ac->mdct120->imdct_half(ac->mdct120, buf + i * 120, in + i * 128, 1);
 2695     } else {
 2696         ac->mdct960->imdct_half(ac->mdct960, buf, in, 1);
 2697     }
 2698 
 2699     /* window overlapping
 2700      * NOTE: To simplify the overlapping code, all 'meaningless' short to long
 2701      * and long to short transitions are considered to be short to short
 2702      * transitions. This leaves just two cases (long to long and short to short)
 2703      * with a little special sauce for EIGHT_SHORT_SEQUENCE.
 2704      */
 2705 
 2706     if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
 2707         (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
 2708         ac->fdsp->vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 480);
 2709     } else {
 2710         memcpy(                          out,               saved,            420 * sizeof(*out));
 2711 
 2712         if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2713             ac->fdsp->vector_fmul_window(out + 420 + 0*120, saved + 420,      buf + 0*120, swindow_prev, 60);
 2714             ac->fdsp->vector_fmul_window(out + 420 + 1*120, buf + 0*120 + 60, buf + 1*120, swindow,      60);
 2715             ac->fdsp->vector_fmul_window(out + 420 + 2*120, buf + 1*120 + 60, buf + 2*120, swindow,      60);
 2716             ac->fdsp->vector_fmul_window(out + 420 + 3*120, buf + 2*120 + 60, buf + 3*120, swindow,      60);
 2717             ac->fdsp->vector_fmul_window(temp,              buf + 3*120 + 60, buf + 4*120, swindow,      60);
 2718             memcpy(                      out + 420 + 4*120, temp, 60 * sizeof(*out));
 2719         } else {
 2720             ac->fdsp->vector_fmul_window(out + 420,         saved + 420,      buf,         swindow_prev, 60);
 2721             memcpy(                      out + 540,         buf + 60,         420 * sizeof(*out));
 2722         }
 2723     }
 2724 
 2725     // buffer update
 2726     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 2727         memcpy(                      saved,       temp + 60,         60 * sizeof(*saved));
 2728         ac->fdsp->vector_fmul_window(saved + 60,  buf + 4*120 + 60, buf + 5*120, swindow, 60);
 2729         ac->fdsp->vector_fmul_window(saved + 180, buf + 5*120 + 60, buf + 6*120, swindow, 60);
 2730         ac->fdsp->vector_fmul_window(saved + 300, buf + 6*120 + 60, buf + 7*120, swindow, 60);
 2731         memcpy(                      saved + 420, buf + 7*120 + 60,  60 * sizeof(*saved));
 2732     } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
 2733         memcpy(                      saved,       buf + 480,        420 * sizeof(*saved));
 2734         memcpy(                      saved + 420, buf + 7*120 + 60,  60 * sizeof(*saved));
 2735     } else { // LONG_STOP or ONLY_LONG
 2736         memcpy(                      saved,       buf + 480,        480 * sizeof(*saved));
 2737     }
 2738 #endif
 2739 }
 2740 static void imdct_and_windowing_ld(AACContext *ac, SingleChannelElement *sce)
 2741 {
 2742     IndividualChannelStream *ics = &sce->ics;
 2743     INTFLOAT *in    = sce->coeffs;
 2744     INTFLOAT *out   = sce->ret;
 2745     INTFLOAT *saved = sce->saved;
 2746     INTFLOAT *buf  = ac->buf_mdct;
 2747 #if USE_FIXED
 2748     int i;
 2749 #endif /* USE_FIXED */
 2750 
 2751     // imdct
 2752     ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
 2753 
 2754 #if USE_FIXED
 2755     for (i = 0; i < 1024; i++)
 2756         buf[i] = (buf[i] + 2) >> 2;
 2757 #endif /* USE_FIXED */
 2758 
 2759     // window overlapping
 2760     if (ics->use_kb_window[1]) {
 2761         // AAC LD uses a low overlap sine window instead of a KBD window
 2762         memcpy(out, saved, 192 * sizeof(*out));
 2763         ac->fdsp->vector_fmul_window(out + 192, saved + 192, buf, AAC_RENAME(ff_sine_128), 64);
 2764         memcpy(                     out + 320, buf + 64, 192 * sizeof(*out));
 2765     } else {
 2766         ac->fdsp->vector_fmul_window(out, saved, buf, AAC_RENAME(ff_sine_512), 256);
 2767     }
 2768 
 2769     // buffer update
 2770     memcpy(saved, buf + 256, 256 * sizeof(*saved));
 2771 }
 2772 
 2773 static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
 2774 {
 2775     INTFLOAT *in    = sce->coeffs;
 2776     INTFLOAT *out   = sce->ret;
 2777     INTFLOAT *saved = sce->saved;
 2778     INTFLOAT *buf  = ac->buf_mdct;
 2779     int i;
 2780     const int n  = ac->oc[1].m4ac.frame_length_short ? 480 : 512;
 2781     const int n2 = n >> 1;
 2782     const int n4 = n >> 2;
 2783     const INTFLOAT *const window = n == 480 ? AAC_RENAME(ff_aac_eld_window_480) :
 2784                                            AAC_RENAME(ff_aac_eld_window_512);
 2785 
 2786     // Inverse transform, mapped to the conventional IMDCT by
 2787     // Chivukula, R.K.; Reznik, Y.A.; Devarajan, V.,
 2788     // "Efficient algorithms for MPEG-4 AAC-ELD, AAC-LD and AAC-LC filterbanks,"
 2789     // International Conference on Audio, Language and Image Processing, ICALIP 2008.
 2790     // URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4590245&isnumber=4589950
 2791     for (i = 0; i < n2; i+=2) {
 2792         INTFLOAT temp;
 2793         temp =  in[i    ]; in[i    ] = -in[n - 1 - i]; in[n - 1 - i] = temp;
 2794         temp = -in[i + 1]; in[i + 1] =  in[n - 2 - i]; in[n - 2 - i] = temp;
 2795     }
 2796 #if !USE_FIXED
 2797     if (n == 480)
 2798         ac->mdct480->imdct_half(ac->mdct480, buf, in, 1);
 2799     else
 2800 #endif
 2801         ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
 2802 
 2803 #if USE_FIXED
 2804     for (i = 0; i < 1024; i++)
 2805       buf[i] = (buf[i] + 1) >> 1;
 2806 #endif /* USE_FIXED */
 2807 
 2808     for (i = 0; i < n; i+=2) {
 2809         buf[i] = -buf[i];
 2810     }
 2811     // Like with the regular IMDCT at this point we still have the middle half
 2812     // of a transform but with even symmetry on the left and odd symmetry on
 2813     // the right
 2814 
 2815     // window overlapping
 2816     // The spec says to use samples [0..511] but the reference decoder uses
 2817     // samples [128..639].
 2818     for (i = n4; i < n2; i ++) {
 2819         out[i - n4] = AAC_MUL31(   buf[    n2 - 1 - i] , window[i       - n4]) +
 2820                       AAC_MUL31( saved[        i + n2] , window[i +   n - n4]) +
 2821                       AAC_MUL31(-saved[n + n2 - 1 - i] , window[i + 2*n - n4]) +
 2822                       AAC_MUL31(-saved[  2*n + n2 + i] , window[i + 3*n - n4]);
 2823     }
 2824     for (i = 0; i < n2; i ++) {
 2825         out[n4 + i] = AAC_MUL31(   buf[              i] , window[i + n2       - n4]) +
 2826                       AAC_MUL31(-saved[      n - 1 - i] , window[i + n2 +   n - n4]) +
 2827                       AAC_MUL31(-saved[          n + i] , window[i + n2 + 2*n - n4]) +
 2828                       AAC_MUL31( saved[2*n + n - 1 - i] , window[i + n2 + 3*n - n4]);
 2829     }
 2830     for (i = 0; i < n4; i ++) {
 2831         out[n2 + n4 + i] = AAC_MUL31(   buf[    i + n2] , window[i +   n - n4]) +
 2832                            AAC_MUL31(-saved[n2 - 1 - i] , window[i + 2*n - n4]) +
 2833                            AAC_MUL31(-saved[n + n2 + i] , window[i + 3*n - n4]);
 2834     }
 2835 
 2836     // buffer update
 2837     memmove(saved + n, saved, 2 * n * sizeof(*saved));
 2838     memcpy( saved,       buf,     n * sizeof(*saved));
 2839 }
 2840 
 2841 /**
 2842  * channel coupling transformation interface
 2843  *
 2844  * @param   apply_coupling_method   pointer to (in)dependent coupling function
 2845  */
 2846 static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
 2847                                    enum RawDataBlockType type, int elem_id,
 2848                                    enum CouplingPoint coupling_point,
 2849                                    void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
 2850 {
 2851     int i, c;
 2852 
 2853     for (i = 0; i < MAX_ELEM_ID; i++) {
 2854         ChannelElement *cce = ac->che[TYPE_CCE][i];
 2855         int index = 0;
 2856 
 2857         if (cce && cce->coup.coupling_point == coupling_point) {
 2858             ChannelCoupling *coup = &cce->coup;
 2859 
 2860             for (c = 0; c <= coup->num_coupled; c++) {
 2861                 if (coup->type[c] == type && coup->id_select[c] == elem_id) {
 2862                     if (coup->ch_select[c] != 1) {
 2863                         apply_coupling_method(ac, &cc->ch[0], cce, index);
 2864                         if (coup->ch_select[c] != 0)
 2865                             index++;
 2866                     }
 2867                     if (coup->ch_select[c] != 2)
 2868                         apply_coupling_method(ac, &cc->ch[1], cce, index++);
 2869                 } else
 2870                     index += 1 + (coup->ch_select[c] == 3);
 2871             }
 2872         }
 2873     }
 2874 }
 2875 
 2876 /**
 2877  * Convert spectral data to samples, applying all supported tools as appropriate.
 2878  */
 2879 static void spectral_to_sample(AACContext *ac, int samples)
 2880 {
 2881     int i, type;
 2882     void (*imdct_and_window)(AACContext *ac, SingleChannelElement *sce);
 2883     switch (ac->oc[1].m4ac.object_type) {
 2884     case AOT_ER_AAC_LD:
 2885         imdct_and_window = imdct_and_windowing_ld;
 2886         break;
 2887     case AOT_ER_AAC_ELD:
 2888         imdct_and_window = imdct_and_windowing_eld;
 2889         break;
 2890     default:
 2891         if (ac->oc[1].m4ac.frame_length_short)
 2892             imdct_and_window = imdct_and_windowing_960;
 2893         else
 2894             imdct_and_window = ac->imdct_and_windowing;
 2895     }
 2896     for (type = 3; type >= 0; type--) {
 2897         for (i = 0; i < MAX_ELEM_ID; i++) {
 2898             ChannelElement *che = ac->che[type][i];
 2899             if (che && che->present) {
 2900                 if (type <= TYPE_CPE)
 2901                     apply_channel_coupling(ac, che, type, i, BEFORE_TNS, AAC_RENAME(apply_dependent_coupling));
 2902                 if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
 2903                     if (che->ch[0].ics.predictor_present) {
 2904                         if (che->ch[0].ics.ltp.present)
 2905                             ac->apply_ltp(ac, &che->ch[0]);
 2906                         if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
 2907                             ac->apply_ltp(ac, &che->ch[1]);
 2908                     }
 2909                 }
 2910                 if (che->ch[0].tns.present)
 2911                     ac->apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
 2912                 if (che->ch[1].tns.present)
 2913                     ac->apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
 2914                 if (type <= TYPE_CPE)
 2915                     apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, AAC_RENAME(apply_dependent_coupling));
 2916                 if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
 2917                     imdct_and_window(ac, &che->ch[0]);
 2918                     if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
 2919                         ac->update_ltp(ac, &che->ch[0]);
 2920                     if (type == TYPE_CPE) {
 2921                         imdct_and_window(ac, &che->ch[1]);
 2922                         if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
 2923                             ac->update_ltp(ac, &che->ch[1]);
 2924                     }
 2925                     if (ac->oc[1].m4ac.sbr > 0) {
 2926                         AAC_RENAME(ff_sbr_apply)(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
 2927                     }
 2928                 }
 2929                 if (type <= TYPE_CCE)
 2930                     apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, AAC_RENAME(apply_independent_coupling));
 2931 
 2932 #if USE_FIXED
 2933                 {
 2934                     int j;
 2935                     /* preparation for resampler */
 2936                     for(j = 0; j<samples; j++){
 2937                         che->ch[0].ret[j] = (int32_t)av_clip64((int64_t)che->ch[0].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
 2938                         if(type == TYPE_CPE)
 2939                             che->ch[1].ret[j] = (int32_t)av_clip64((int64_t)che->ch[1].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
 2940                     }
 2941                 }
 2942 #endif /* USE_FIXED */
 2943                 che->present = 0;
 2944             } else if (che) {
 2945                 av_log(ac->avctx, AV_LOG_VERBOSE, "ChannelElement %d.%d missing \n", type, i);
 2946             }
 2947         }
 2948     }
 2949 }
 2950 
 2951 static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
 2952 {
 2953     int size;
 2954     AACADTSHeaderInfo hdr_info;
 2955     uint8_t layout_map[MAX_ELEM_ID*4][3];
 2956     int layout_map_tags, ret;
 2957 
 2958     size = avpriv_aac_parse_header(gb, &hdr_info);
 2959     if (size > 0) {
 2960         if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
 2961             // This is 2 for "VLB " audio in NSV files.
 2962             // See samples/nsv/vlb_audio.
 2963             avpriv_report_missing_feature(ac->avctx,
 2964                                           "More than one AAC RDB per ADTS frame");
 2965             ac->warned_num_aac_frames = 1;
 2966         }
 2967         push_output_configuration(ac);
 2968         if (hdr_info.chan_config) {
 2969             ac->oc[1].m4ac.chan_config = hdr_info.chan_config;
 2970             if ((ret = set_default_channel_config(ac->avctx,
 2971                                                   layout_map,
 2972                                                   &layout_map_tags,
 2973                                                   hdr_info.chan_config)) < 0)
 2974                 return ret;
 2975             if ((ret = output_configure(ac, layout_map, layout_map_tags,
 2976                                         FFMAX(ac->oc[1].status,
 2977                                               OC_TRIAL_FRAME), 0)) < 0)
 2978                 return ret;
 2979         } else {
 2980             ac->oc[1].m4ac.chan_config = 0;
 2981             /**
 2982              * dual mono frames in Japanese DTV can have chan_config 0
 2983              * WITHOUT specifying PCE.
 2984              *  thus, set dual mono as default.
 2985              */
 2986             if (ac->dmono_mode && ac->oc[0].status == OC_NONE) {
 2987                 layout_map_tags = 2;
 2988                 layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
 2989                 layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
 2990                 layout_map[0][1] = 0;
 2991                 layout_map[1][1] = 1;
 2992                 if (output_configure(ac, layout_map, layout_map_tags,
 2993                                      OC_TRIAL_FRAME, 0))
 2994                     return -7;
 2995             }
 2996         }
 2997         ac->oc[1].m4ac.sample_rate     = hdr_info.sample_rate;
 2998         ac->oc[1].m4ac.sampling_index  = hdr_info.sampling_index;
 2999         ac->oc[1].m4ac.object_type     = hdr_info.object_type;
 3000         ac->oc[1].m4ac.frame_length_short = 0;
 3001         if (ac->oc[0].status != OC_LOCKED ||
 3002             ac->oc[0].m4ac.chan_config != hdr_info.chan_config ||
 3003             ac->oc[0].m4ac.sample_rate != hdr_info.sample_rate) {
 3004             ac->oc[1].m4ac.sbr = -1;
 3005             ac->oc[1].m4ac.ps  = -1;
 3006         }
 3007         if (!hdr_info.crc_absent)
 3008             skip_bits(gb, 16);
 3009     }
 3010     return size;
 3011 }
 3012 
 3013 static int aac_decode_er_frame(AVCodecContext *avctx, void *data,
 3014                                int *got_frame_ptr, GetBitContext *gb)
 3015 {
 3016     AACContext *ac = avctx->priv_data;
 3017     const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
 3018     ChannelElement *che;
 3019     int err, i;
 3020     int samples = m4ac->frame_length_short ? 960 : 1024;
 3021     int chan_config = m4ac->chan_config;
 3022     int aot = m4ac->object_type;
 3023 
 3024     if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD)
 3025         samples >>= 1;
 3026 
 3027     ac->frame = data;
 3028 
 3029     if ((err = frame_configure_elements(avctx)) < 0)
 3030         return err;
 3031 
 3032     // The FF_PROFILE_AAC_* defines are all object_type - 1
 3033     // This may lead to an undefined profile being signaled
 3034     ac->avctx->profile = aot - 1;
 3035 
 3036     ac->tags_mapped = 0;
 3037 
 3038     if (chan_config < 0 || (chan_config >= 8 && chan_config < 11) || chan_config >= 13) {
 3039         avpriv_request_sample(avctx, "Unknown ER channel configuration %d",
 3040                               chan_config);
 3041         return AVERROR_INVALIDDATA;
 3042     }
 3043     for (i = 0; i < tags_per_config[chan_config]; i++) {
 3044         const int elem_type = aac_channel_layout_map[chan_config-1][i][0];
 3045         const int elem_id   = aac_channel_layout_map[chan_config-1][i][1];
 3046         if (!(che=get_che(ac, elem_type, elem_id))) {
 3047             av_log(ac->avctx, AV_LOG_ERROR,
 3048                    "channel element %d.%d is not allocated\n",
 3049                    elem_type, elem_id);
 3050             return AVERROR_INVALIDDATA;
 3051         }
 3052         che->present = 1;
 3053         if (aot != AOT_ER_AAC_ELD)
 3054             skip_bits(gb, 4);
 3055         switch (elem_type) {
 3056         case TYPE_SCE:
 3057             err = decode_ics(ac, &che->ch[0], gb, 0, 0);
 3058             break;
 3059         case TYPE_CPE:
 3060             err = decode_cpe(ac, gb, che);
 3061             break;
 3062         case TYPE_LFE:
 3063             err = decode_ics(ac, &che->ch[0], gb, 0, 0);
 3064             break;
 3065         }
 3066         if (err < 0)
 3067             return err;
 3068     }
 3069 
 3070     spectral_to_sample(ac, samples);
 3071 
 3072     if (!ac->frame->data[0] && samples) {
 3073         av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
 3074         return AVERROR_INVALIDDATA;
 3075     }
 3076 
 3077     ac->frame->nb_samples = samples;
 3078     ac->frame->sample_rate = avctx->sample_rate;
 3079     *got_frame_ptr = 1;
 3080 
 3081     skip_bits_long(gb, get_bits_left(gb));
 3082     return 0;
 3083 }
 3084 
 3085 static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
 3086                                 int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
 3087 {
 3088     AACContext *ac = avctx->priv_data;
 3089     ChannelElement *che = NULL, *che_prev = NULL;
 3090     enum RawDataBlockType elem_type, che_prev_type = TYPE_END;
 3091     int err, elem_id;
 3092     int samples = 0, multiplier, audio_found = 0, pce_found = 0;
 3093     int is_dmono, sce_count = 0;
 3094     int payload_alignment;
 3095 
 3096     ac->frame = data;
 3097 
 3098     if (show_bits(gb, 12) == 0xfff) {
 3099         if ((err = parse_adts_frame_header(ac, gb)) < 0) {
 3100             av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
 3101             goto fail;
 3102         }
 3103         if (ac->oc[1].m4ac.sampling_index > 12) {
 3104             av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->oc[1].m4ac.sampling_index);
 3105             err = AVERROR_INVALIDDATA;
 3106             goto fail;
 3107         }
 3108     }
 3109 
 3110     if ((err = frame_configure_elements(avctx)) < 0)
 3111         goto fail;
 3112 
 3113     // The FF_PROFILE_AAC_* defines are all object_type - 1
 3114     // This may lead to an undefined profile being signaled
 3115     ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
 3116 
 3117     payload_alignment = get_bits_count(gb);
 3118     ac->tags_mapped = 0;
 3119     // parse
 3120     while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
 3121         elem_id = get_bits(gb, 4);
 3122 
 3123         if (avctx->debug & FF_DEBUG_STARTCODE)
 3124             av_log(avctx, AV_LOG_DEBUG, "Elem type:%x id:%x\n", elem_type, elem_id);
 3125 
 3126         if (!avctx->channels && elem_type != TYPE_PCE) {
 3127             err = AVERROR_INVALIDDATA;
 3128             goto fail;
 3129         }
 3130 
 3131         if (elem_type < TYPE_DSE) {
 3132             if (!(che=get_che(ac, elem_type, elem_id))) {
 3133                 av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
 3134                        elem_type, elem_id);
 3135                 err = AVERROR_INVALIDDATA;
 3136                 goto fail;
 3137             }
 3138             samples = ac->oc[1].m4ac.frame_length_short ? 960 : 1024;
 3139             che->present = 1;
 3140         }
 3141 
 3142         switch (elem_type) {
 3143 
 3144         case TYPE_SCE:
 3145             err = decode_ics(ac, &che->ch[0], gb, 0, 0);
 3146             audio_found = 1;
 3147             sce_count++;
 3148             break;
 3149 
 3150         case TYPE_CPE:
 3151             err = decode_cpe(ac, gb, che);
 3152             audio_found = 1;
 3153             break;
 3154 
 3155         case TYPE_CCE:
 3156             err = decode_cce(ac, gb, che);
 3157             break;
 3158 
 3159         case TYPE_LFE:
 3160             err = decode_ics(ac, &che->ch[0], gb, 0, 0);
 3161             audio_found = 1;
 3162             break;
 3163 
 3164         case TYPE_DSE:
 3165             err = skip_data_stream_element(ac, gb);
 3166             break;
 3167 
 3168         case TYPE_PCE: {
 3169             uint8_t layout_map[MAX_ELEM_ID*4][3];
 3170             int tags;
 3171 
 3172             int pushed = push_output_configuration(ac);
 3173             if (pce_found && !pushed) {
 3174                 err = AVERROR_INVALIDDATA;
 3175                 goto fail;
 3176             }
 3177 
 3178             tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb,
 3179                               payload_alignment);
 3180             if (tags < 0) {
 3181                 err = tags;
 3182                 break;
 3183             }
 3184             if (pce_found) {
 3185                 av_log(avctx, AV_LOG_ERROR,
 3186                        "Not evaluating a further program_config_element as this construct is dubious at best.\n");
 3187                 pop_output_configuration(ac);
 3188             } else {
 3189                 err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
 3190                 if (!err)
 3191                     ac->oc[1].m4ac.chan_config = 0;
 3192                 pce_found = 1;
 3193             }
 3194             break;
 3195         }
 3196 
 3197         case TYPE_FIL:
 3198             if (elem_id == 15)
 3199                 elem_id += get_bits(gb, 8) - 1;
 3200             if (get_bits_left(gb) < 8 * elem_id) {
 3201                     av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
 3202                     err = AVERROR_INVALIDDATA;
 3203                     goto fail;
 3204             }
 3205             while (elem_id > 0)
 3206                 elem_id -= decode_extension_payload(ac, gb, elem_id, che_prev, che_prev_type);
 3207             err = 0; /* FIXME */
 3208             break;
 3209 
 3210         default:
 3211             err = AVERROR_BUG; /* should not happen, but keeps compiler happy */
 3212             break;
 3213         }
 3214 
 3215         if (elem_type < TYPE_DSE) {
 3216             che_prev      = che;
 3217             che_prev_type = elem_type;
 3218         }
 3219 
 3220         if (err)
 3221             goto fail;
 3222 
 3223         if (get_bits_left(gb) < 3) {
 3224             av_log(avctx, AV_LOG_ERROR, overread_err);
 3225             err = AVERROR_INVALIDDATA;
 3226             goto fail;
 3227         }
 3228     }
 3229 
 3230     if (!avctx->channels) {
 3231         *got_frame_ptr = 0;
 3232         return 0;
 3233     }
 3234 
 3235     multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
 3236     samples <<= multiplier;
 3237 
 3238     spectral_to_sample(ac, samples);
 3239 
 3240     if (ac->oc[1].status && audio_found) {
 3241         avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
 3242         avctx->frame_size = samples;
 3243         ac->oc[1].status = OC_LOCKED;
 3244     }
 3245 
 3246     if (multiplier)
 3247         avctx->internal->skip_samples_multiplier = 2;
 3248 
 3249     if (!ac->frame->data[0] && samples) {
 3250         av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
 3251         err = AVERROR_INVALIDDATA;
 3252         goto fail;
 3253     }
 3254 
 3255     if (samples) {
 3256         ac->frame->nb_samples = samples;
 3257         ac->frame->sample_rate = avctx->sample_rate;
 3258     } else
 3259         av_frame_unref(ac->frame);
 3260     *got_frame_ptr = !!samples;
 3261 
 3262     /* for dual-mono audio (SCE + SCE) */
 3263     is_dmono = ac->dmono_mode && sce_count == 2 &&
 3264                ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
 3265     if (is_dmono) {
 3266         if (ac->dmono_mode == 1)
 3267             ((AVFrame *)data)->data[1] =((AVFrame *)data)->data[0];
 3268         else if (ac->dmono_mode == 2)
 3269             ((AVFrame *)data)->data[0] =((AVFrame *)data)->data[1];
 3270     }
 3271 
 3272     return 0;
 3273 fail:
 3274     pop_output_configuration(ac);
 3275     return err;
 3276 }
 3277 
 3278 static int aac_decode_frame(AVCodecContext *avctx, void *data,
 3279                             int *got_frame_ptr, AVPacket *avpkt)
 3280 {
 3281     AACContext *ac = avctx->priv_data;
 3282     const uint8_t *buf = avpkt->data;
 3283     int buf_size = avpkt->size;
 3284     GetBitContext gb;
 3285     int buf_consumed;
 3286     int buf_offset;
 3287     int err;
 3288     int new_extradata_size;
 3289     const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
 3290                                        AV_PKT_DATA_NEW_EXTRADATA,
 3291                                        &new_extradata_size);
 3292     int jp_dualmono_size;
 3293     const uint8_t *jp_dualmono   = av_packet_get_side_data(avpkt,
 3294                                        AV_PKT_DATA_JP_DUALMONO,
 3295                                        &jp_dualmono_size);
 3296 
 3297     if (new_extradata && 0) {
 3298         av_free(avctx->extradata);
 3299         avctx->extradata = av_mallocz(new_extradata_size +
 3300                                       AV_INPUT_BUFFER_PADDING_SIZE);
 3301         if (!avctx->extradata)
 3302             return AVERROR(ENOMEM);
 3303         avctx->extradata_size = new_extradata_size;
 3304         memcpy(avctx->extradata, new_extradata, new_extradata_size);
 3305         push_output_configuration(ac);
 3306         if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
 3307                                          avctx->extradata,
 3308                                          avctx->extradata_size*8LL, 1) < 0) {
 3309             pop_output_configuration(ac);
 3310             return AVERROR_INVALIDDATA;
 3311         }
 3312     }
 3313 
 3314     ac->dmono_mode = 0;
 3315     if (jp_dualmono && jp_dualmono_size > 0)
 3316         ac->dmono_mode =  1 + *jp_dualmono;
 3317     if (ac->force_dmono_mode >= 0)
 3318         ac->dmono_mode = ac->force_dmono_mode;
 3319 
 3320     if (INT_MAX / 8 <= buf_size)
 3321         return AVERROR_INVALIDDATA;
 3322 
 3323     if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
 3324         return err;
 3325 
 3326     switch (ac->oc[1].m4ac.object_type) {
 3327     case AOT_ER_AAC_LC:
 3328     case AOT_ER_AAC_LTP:
 3329     case AOT_ER_AAC_LD:
 3330     case AOT_ER_AAC_ELD:
 3331         err = aac_decode_er_frame(avctx, data, got_frame_ptr, &gb);
 3332         break;
 3333     default:
 3334         err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt);
 3335     }
 3336     if (err < 0)
 3337         return err;
 3338 
 3339     buf_consumed = (get_bits_count(&gb) + 7) >> 3;
 3340     for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
 3341         if (buf[buf_offset])
 3342             break;
 3343 
 3344     return buf_size > buf_offset ? buf_consumed : buf_size;
 3345 }
 3346 
 3347 static av_cold int aac_decode_close(AVCodecContext *avctx)
 3348 {
 3349     AACContext *ac = avctx->priv_data;
 3350     int i, type;
 3351 
 3352     for (i = 0; i < MAX_ELEM_ID; i++) {
 3353         for (type = 0; type < 4; type++) {
 3354             if (ac->che[type][i])
 3355                 AAC_RENAME(ff_aac_sbr_ctx_close)(&ac->che[type][i]->sbr);
 3356             av_freep(&ac->che[type][i]);
 3357         }
 3358     }
 3359 
 3360     ff_mdct_end(&ac->mdct);
 3361     ff_mdct_end(&ac->mdct_small);
 3362     ff_mdct_end(&ac->mdct_ld);
 3363     ff_mdct_end(&ac->mdct_ltp);
 3364 #if !USE_FIXED
 3365     ff_mdct15_uninit(&ac->mdct120);
 3366     ff_mdct15_uninit(&ac->mdct480);
 3367     ff_mdct15_uninit(&ac->mdct960);
 3368 #endif
 3369     av_freep(&ac->fdsp);
 3370     return 0;
 3371 }
 3372 
 3373 static void aacdec_init(AACContext *c)
 3374 {
 3375     c->imdct_and_windowing                      = imdct_and_windowing;
 3376     c->apply_ltp                                = apply_ltp;
 3377     c->apply_tns                                = apply_tns;
 3378     c->windowing_and_mdct_ltp                   = windowing_and_mdct_ltp;
 3379     c->update_ltp                               = update_ltp;
 3380 #if USE_FIXED
 3381     c->vector_pow43                             = vector_pow43;
 3382     c->subband_scale                            = subband_scale;
 3383 #endif
 3384 
 3385 #if !USE_FIXED
 3386     if(ARCH_MIPS)
 3387         ff_aacdec_init_mips(c);
 3388 #endif /* !USE_FIXED */
 3389 }
 3390 /**
 3391  * AVOptions for Japanese DTV specific extensions (ADTS only)
 3392  */
 3393 #define AACDEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
 3394 static const AVOption options[] = {
 3395     {"dual_mono_mode", "Select the channel to decode for dual mono",
 3396      offsetof(AACContext, force_dmono_mode), AV_OPT_TYPE_INT, {.i64=-1}, -1, 2,
 3397      AACDEC_FLAGS, "dual_mono_mode"},
 3398 
 3399     {"auto", "autoselection",            0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 3400     {"main", "Select Main/Left channel", 0, AV_OPT_TYPE_CONST, {.i64= 1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 3401     {"sub" , "Select Sub/Right channel", 0, AV_OPT_TYPE_CONST, {.i64= 2}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 3402     {"both", "Select both channels",     0, AV_OPT_TYPE_CONST, {.i64= 0}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 3403 
 3404     {NULL},
 3405 };
 3406 
 3407 static const AVClass aac_decoder_class = {
 3408     .class_name = "AAC decoder",
 3409     .item_name  = av_default_item_name,
 3410     .option     = options,
 3411     .version    = LIBAVUTIL_VERSION_INT,
 3412 };