"Fossies" - the Fresh Open Source Software Archive

Member "ffmpeg-3.4.2/libavcodec/aacenc.c" (12 Feb 2018, 42146 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 "aacenc.c" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * AAC encoder
    3  * Copyright (C) 2008 Konstantin Shishkov
    4  *
    5  * This file is part of FFmpeg.
    6  *
    7  * FFmpeg is free software; you can redistribute it and/or
    8  * modify it under the terms of the GNU Lesser General Public
    9  * License as published by the Free Software Foundation; either
   10  * version 2.1 of the License, or (at your option) any later version.
   11  *
   12  * FFmpeg is distributed in the hope that it will be useful,
   13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   15  * Lesser General Public License for more details.
   16  *
   17  * You should have received a copy of the GNU Lesser General Public
   18  * License along with FFmpeg; if not, write to the Free Software
   19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   20  */
   21 
   22 /**
   23  * @file
   24  * AAC encoder
   25  */
   26 
   27 /***********************************
   28  *              TODOs:
   29  * add sane pulse detection
   30  ***********************************/
   31 
   32 #include "libavutil/libm.h"
   33 #include "libavutil/thread.h"
   34 #include "libavutil/float_dsp.h"
   35 #include "libavutil/opt.h"
   36 #include "avcodec.h"
   37 #include "put_bits.h"
   38 #include "internal.h"
   39 #include "mpeg4audio.h"
   40 #include "kbdwin.h"
   41 #include "sinewin.h"
   42 
   43 #include "aac.h"
   44 #include "aactab.h"
   45 #include "aacenc.h"
   46 #include "aacenctab.h"
   47 #include "aacenc_utils.h"
   48 
   49 #include "psymodel.h"
   50 
   51 static AVOnce aac_table_init = AV_ONCE_INIT;
   52 
   53 /**
   54  * Make AAC audio config object.
   55  * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
   56  */
   57 static void put_audio_specific_config(AVCodecContext *avctx)
   58 {
   59     PutBitContext pb;
   60     AACEncContext *s = avctx->priv_data;
   61     int channels = s->channels - (s->channels == 8 ? 1 : 0);
   62 
   63     init_put_bits(&pb, avctx->extradata, avctx->extradata_size);
   64     put_bits(&pb, 5, s->profile+1); //profile
   65     put_bits(&pb, 4, s->samplerate_index); //sample rate index
   66     put_bits(&pb, 4, channels);
   67     //GASpecificConfig
   68     put_bits(&pb, 1, 0); //frame length - 1024 samples
   69     put_bits(&pb, 1, 0); //does not depend on core coder
   70     put_bits(&pb, 1, 0); //is not extension
   71 
   72     //Explicitly Mark SBR absent
   73     put_bits(&pb, 11, 0x2b7); //sync extension
   74     put_bits(&pb, 5,  AOT_SBR);
   75     put_bits(&pb, 1,  0);
   76     flush_put_bits(&pb);
   77 }
   78 
   79 void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
   80 {
   81     ++s->quantize_band_cost_cache_generation;
   82     if (s->quantize_band_cost_cache_generation == 0) {
   83         memset(s->quantize_band_cost_cache, 0, sizeof(s->quantize_band_cost_cache));
   84         s->quantize_band_cost_cache_generation = 1;
   85     }
   86 }
   87 
   88 #define WINDOW_FUNC(type) \
   89 static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
   90                                     SingleChannelElement *sce, \
   91                                     const float *audio)
   92 
   93 WINDOW_FUNC(only_long)
   94 {
   95     const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
   96     const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
   97     float *out = sce->ret_buf;
   98 
   99     fdsp->vector_fmul        (out,        audio,        lwindow, 1024);
  100     fdsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
  101 }
  102 
  103 WINDOW_FUNC(long_start)
  104 {
  105     const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
  106     const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
  107     float *out = sce->ret_buf;
  108 
  109     fdsp->vector_fmul(out, audio, lwindow, 1024);
  110     memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
  111     fdsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
  112     memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
  113 }
  114 
  115 WINDOW_FUNC(long_stop)
  116 {
  117     const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
  118     const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
  119     float *out = sce->ret_buf;
  120 
  121     memset(out, 0, sizeof(out[0]) * 448);
  122     fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
  123     memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
  124     fdsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
  125 }
  126 
  127 WINDOW_FUNC(eight_short)
  128 {
  129     const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
  130     const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
  131     const float *in = audio + 448;
  132     float *out = sce->ret_buf;
  133     int w;
  134 
  135     for (w = 0; w < 8; w++) {
  136         fdsp->vector_fmul        (out, in, w ? pwindow : swindow, 128);
  137         out += 128;
  138         in  += 128;
  139         fdsp->vector_fmul_reverse(out, in, swindow, 128);
  140         out += 128;
  141     }
  142 }
  143 
  144 static void (*const apply_window[4])(AVFloatDSPContext *fdsp,
  145                                      SingleChannelElement *sce,
  146                                      const float *audio) = {
  147     [ONLY_LONG_SEQUENCE]   = apply_only_long_window,
  148     [LONG_START_SEQUENCE]  = apply_long_start_window,
  149     [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
  150     [LONG_STOP_SEQUENCE]   = apply_long_stop_window
  151 };
  152 
  153 static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce,
  154                                   float *audio)
  155 {
  156     int i;
  157     const float *output = sce->ret_buf;
  158 
  159     apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
  160 
  161     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE)
  162         s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
  163     else
  164         for (i = 0; i < 1024; i += 128)
  165             s->mdct128.mdct_calc(&s->mdct128, &sce->coeffs[i], output + i*2);
  166     memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
  167     memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
  168 }
  169 
  170 /**
  171  * Encode ics_info element.
  172  * @see Table 4.6 (syntax of ics_info)
  173  */
  174 static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
  175 {
  176     int w;
  177 
  178     put_bits(&s->pb, 1, 0);                // ics_reserved bit
  179     put_bits(&s->pb, 2, info->window_sequence[0]);
  180     put_bits(&s->pb, 1, info->use_kb_window[0]);
  181     if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
  182         put_bits(&s->pb, 6, info->max_sfb);
  183         put_bits(&s->pb, 1, !!info->predictor_present);
  184     } else {
  185         put_bits(&s->pb, 4, info->max_sfb);
  186         for (w = 1; w < 8; w++)
  187             put_bits(&s->pb, 1, !info->group_len[w]);
  188     }
  189 }
  190 
  191 /**
  192  * Encode MS data.
  193  * @see 4.6.8.1 "Joint Coding - M/S Stereo"
  194  */
  195 static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
  196 {
  197     int i, w;
  198 
  199     put_bits(pb, 2, cpe->ms_mode);
  200     if (cpe->ms_mode == 1)
  201         for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
  202             for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
  203                 put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
  204 }
  205 
  206 /**
  207  * Produce integer coefficients from scalefactors provided by the model.
  208  */
  209 static void adjust_frame_information(ChannelElement *cpe, int chans)
  210 {
  211     int i, w, w2, g, ch;
  212     int maxsfb, cmaxsfb;
  213 
  214     for (ch = 0; ch < chans; ch++) {
  215         IndividualChannelStream *ics = &cpe->ch[ch].ics;
  216         maxsfb = 0;
  217         cpe->ch[ch].pulse.num_pulse = 0;
  218         for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
  219             for (w2 =  0; w2 < ics->group_len[w]; w2++) {
  220                 for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
  221                     ;
  222                 maxsfb = FFMAX(maxsfb, cmaxsfb);
  223             }
  224         }
  225         ics->max_sfb = maxsfb;
  226 
  227         //adjust zero bands for window groups
  228         for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
  229             for (g = 0; g < ics->max_sfb; g++) {
  230                 i = 1;
  231                 for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
  232                     if (!cpe->ch[ch].zeroes[w2*16 + g]) {
  233                         i = 0;
  234                         break;
  235                     }
  236                 }
  237                 cpe->ch[ch].zeroes[w*16 + g] = i;
  238             }
  239         }
  240     }
  241 
  242     if (chans > 1 && cpe->common_window) {
  243         IndividualChannelStream *ics0 = &cpe->ch[0].ics;
  244         IndividualChannelStream *ics1 = &cpe->ch[1].ics;
  245         int msc = 0;
  246         ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
  247         ics1->max_sfb = ics0->max_sfb;
  248         for (w = 0; w < ics0->num_windows*16; w += 16)
  249             for (i = 0; i < ics0->max_sfb; i++)
  250                 if (cpe->ms_mask[w+i])
  251                     msc++;
  252         if (msc == 0 || ics0->max_sfb == 0)
  253             cpe->ms_mode = 0;
  254         else
  255             cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
  256     }
  257 }
  258 
  259 static void apply_intensity_stereo(ChannelElement *cpe)
  260 {
  261     int w, w2, g, i;
  262     IndividualChannelStream *ics = &cpe->ch[0].ics;
  263     if (!cpe->common_window)
  264         return;
  265     for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
  266         for (w2 =  0; w2 < ics->group_len[w]; w2++) {
  267             int start = (w+w2) * 128;
  268             for (g = 0; g < ics->num_swb; g++) {
  269                 int p  = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
  270                 float scale = cpe->ch[0].is_ener[w*16+g];
  271                 if (!cpe->is_mask[w*16 + g]) {
  272                     start += ics->swb_sizes[g];
  273                     continue;
  274                 }
  275                 if (cpe->ms_mask[w*16 + g])
  276                     p *= -1;
  277                 for (i = 0; i < ics->swb_sizes[g]; i++) {
  278                     float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
  279                     cpe->ch[0].coeffs[start+i] = sum;
  280                     cpe->ch[1].coeffs[start+i] = 0.0f;
  281                 }
  282                 start += ics->swb_sizes[g];
  283             }
  284         }
  285     }
  286 }
  287 
  288 static void apply_mid_side_stereo(ChannelElement *cpe)
  289 {
  290     int w, w2, g, i;
  291     IndividualChannelStream *ics = &cpe->ch[0].ics;
  292     if (!cpe->common_window)
  293         return;
  294     for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
  295         for (w2 =  0; w2 < ics->group_len[w]; w2++) {
  296             int start = (w+w2) * 128;
  297             for (g = 0; g < ics->num_swb; g++) {
  298                 /* ms_mask can be used for other purposes in PNS and I/S,
  299                  * so must not apply M/S if any band uses either, even if
  300                  * ms_mask is set.
  301                  */
  302                 if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
  303                     || cpe->ch[0].band_type[w*16 + g] >= NOISE_BT
  304                     || cpe->ch[1].band_type[w*16 + g] >= NOISE_BT) {
  305                     start += ics->swb_sizes[g];
  306                     continue;
  307                 }
  308                 for (i = 0; i < ics->swb_sizes[g]; i++) {
  309                     float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
  310                     float R = L - cpe->ch[1].coeffs[start+i];
  311                     cpe->ch[0].coeffs[start+i] = L;
  312                     cpe->ch[1].coeffs[start+i] = R;
  313                 }
  314                 start += ics->swb_sizes[g];
  315             }
  316         }
  317     }
  318 }
  319 
  320 /**
  321  * Encode scalefactor band coding type.
  322  */
  323 static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
  324 {
  325     int w;
  326 
  327     if (s->coder->set_special_band_scalefactors)
  328         s->coder->set_special_band_scalefactors(s, sce);
  329 
  330     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
  331         s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
  332 }
  333 
  334 /**
  335  * Encode scalefactors.
  336  */
  337 static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
  338                                  SingleChannelElement *sce)
  339 {
  340     int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
  341     int off_is = 0, noise_flag = 1;
  342     int i, w;
  343 
  344     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
  345         for (i = 0; i < sce->ics.max_sfb; i++) {
  346             if (!sce->zeroes[w*16 + i]) {
  347                 if (sce->band_type[w*16 + i] == NOISE_BT) {
  348                     diff = sce->sf_idx[w*16 + i] - off_pns;
  349                     off_pns = sce->sf_idx[w*16 + i];
  350                     if (noise_flag-- > 0) {
  351                         put_bits(&s->pb, NOISE_PRE_BITS, diff + NOISE_PRE);
  352                         continue;
  353                     }
  354                 } else if (sce->band_type[w*16 + i] == INTENSITY_BT  ||
  355                            sce->band_type[w*16 + i] == INTENSITY_BT2) {
  356                     diff = sce->sf_idx[w*16 + i] - off_is;
  357                     off_is = sce->sf_idx[w*16 + i];
  358                 } else {
  359                     diff = sce->sf_idx[w*16 + i] - off_sf;
  360                     off_sf = sce->sf_idx[w*16 + i];
  361                 }
  362                 diff += SCALE_DIFF_ZERO;
  363                 av_assert0(diff >= 0 && diff <= 120);
  364                 put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
  365             }
  366         }
  367     }
  368 }
  369 
  370 /**
  371  * Encode pulse data.
  372  */
  373 static void encode_pulses(AACEncContext *s, Pulse *pulse)
  374 {
  375     int i;
  376 
  377     put_bits(&s->pb, 1, !!pulse->num_pulse);
  378     if (!pulse->num_pulse)
  379         return;
  380 
  381     put_bits(&s->pb, 2, pulse->num_pulse - 1);
  382     put_bits(&s->pb, 6, pulse->start);
  383     for (i = 0; i < pulse->num_pulse; i++) {
  384         put_bits(&s->pb, 5, pulse->pos[i]);
  385         put_bits(&s->pb, 4, pulse->amp[i]);
  386     }
  387 }
  388 
  389 /**
  390  * Encode spectral coefficients processed by psychoacoustic model.
  391  */
  392 static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
  393 {
  394     int start, i, w, w2;
  395 
  396     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
  397         start = 0;
  398         for (i = 0; i < sce->ics.max_sfb; i++) {
  399             if (sce->zeroes[w*16 + i]) {
  400                 start += sce->ics.swb_sizes[i];
  401                 continue;
  402             }
  403             for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
  404                 s->coder->quantize_and_encode_band(s, &s->pb,
  405                                                    &sce->coeffs[start + w2*128],
  406                                                    NULL, sce->ics.swb_sizes[i],
  407                                                    sce->sf_idx[w*16 + i],
  408                                                    sce->band_type[w*16 + i],
  409                                                    s->lambda,
  410                                                    sce->ics.window_clipping[w]);
  411             }
  412             start += sce->ics.swb_sizes[i];
  413         }
  414     }
  415 }
  416 
  417 /**
  418  * Downscale spectral coefficients for near-clipping windows to avoid artifacts
  419  */
  420 static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
  421 {
  422     int start, i, j, w;
  423 
  424     if (sce->ics.clip_avoidance_factor < 1.0f) {
  425         for (w = 0; w < sce->ics.num_windows; w++) {
  426             start = 0;
  427             for (i = 0; i < sce->ics.max_sfb; i++) {
  428                 float *swb_coeffs = &sce->coeffs[start + w*128];
  429                 for (j = 0; j < sce->ics.swb_sizes[i]; j++)
  430                     swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
  431                 start += sce->ics.swb_sizes[i];
  432             }
  433         }
  434     }
  435 }
  436 
  437 /**
  438  * Encode one channel of audio data.
  439  */
  440 static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s,
  441                                      SingleChannelElement *sce,
  442                                      int common_window)
  443 {
  444     put_bits(&s->pb, 8, sce->sf_idx[0]);
  445     if (!common_window) {
  446         put_ics_info(s, &sce->ics);
  447         if (s->coder->encode_main_pred)
  448             s->coder->encode_main_pred(s, sce);
  449         if (s->coder->encode_ltp_info)
  450             s->coder->encode_ltp_info(s, sce, 0);
  451     }
  452     encode_band_info(s, sce);
  453     encode_scale_factors(avctx, s, sce);
  454     encode_pulses(s, &sce->pulse);
  455     put_bits(&s->pb, 1, !!sce->tns.present);
  456     if (s->coder->encode_tns_info)
  457         s->coder->encode_tns_info(s, sce);
  458     put_bits(&s->pb, 1, 0); //ssr
  459     encode_spectral_coeffs(s, sce);
  460     return 0;
  461 }
  462 
  463 /**
  464  * Write some auxiliary information about the created AAC file.
  465  */
  466 static void put_bitstream_info(AACEncContext *s, const char *name)
  467 {
  468     int i, namelen, padbits;
  469 
  470     namelen = strlen(name) + 2;
  471     put_bits(&s->pb, 3, TYPE_FIL);
  472     put_bits(&s->pb, 4, FFMIN(namelen, 15));
  473     if (namelen >= 15)
  474         put_bits(&s->pb, 8, namelen - 14);
  475     put_bits(&s->pb, 4, 0); //extension type - filler
  476     padbits = -put_bits_count(&s->pb) & 7;
  477     avpriv_align_put_bits(&s->pb);
  478     for (i = 0; i < namelen - 2; i++)
  479         put_bits(&s->pb, 8, name[i]);
  480     put_bits(&s->pb, 12 - padbits, 0);
  481 }
  482 
  483 /*
  484  * Copy input samples.
  485  * Channels are reordered from libavcodec's default order to AAC order.
  486  */
  487 static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
  488 {
  489     int ch;
  490     int end = 2048 + (frame ? frame->nb_samples : 0);
  491     const uint8_t *channel_map = aac_chan_maps[s->channels - 1];
  492 
  493     /* copy and remap input samples */
  494     for (ch = 0; ch < s->channels; ch++) {
  495         /* copy last 1024 samples of previous frame to the start of the current frame */
  496         memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
  497 
  498         /* copy new samples and zero any remaining samples */
  499         if (frame) {
  500             memcpy(&s->planar_samples[ch][2048],
  501                    frame->extended_data[channel_map[ch]],
  502                    frame->nb_samples * sizeof(s->planar_samples[0][0]));
  503         }
  504         memset(&s->planar_samples[ch][end], 0,
  505                (3072 - end) * sizeof(s->planar_samples[0][0]));
  506     }
  507 }
  508 
  509 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
  510                             const AVFrame *frame, int *got_packet_ptr)
  511 {
  512     AACEncContext *s = avctx->priv_data;
  513     float **samples = s->planar_samples, *samples2, *la, *overlap;
  514     ChannelElement *cpe;
  515     SingleChannelElement *sce;
  516     IndividualChannelStream *ics;
  517     int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
  518     int target_bits, rate_bits, too_many_bits, too_few_bits;
  519     int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
  520     int chan_el_counter[4];
  521     FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
  522 
  523     /* add current frame to queue */
  524     if (frame) {
  525         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
  526             return ret;
  527     } else {
  528         if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
  529             return 0;
  530     }
  531 
  532     copy_input_samples(s, frame);
  533     if (s->psypp)
  534         ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
  535 
  536     if (!avctx->frame_number)
  537         return 0;
  538 
  539     start_ch = 0;
  540     for (i = 0; i < s->chan_map[0]; i++) {
  541         FFPsyWindowInfo* wi = windows + start_ch;
  542         tag      = s->chan_map[i+1];
  543         chans    = tag == TYPE_CPE ? 2 : 1;
  544         cpe      = &s->cpe[i];
  545         for (ch = 0; ch < chans; ch++) {
  546             int k;
  547             float clip_avoidance_factor;
  548             sce = &cpe->ch[ch];
  549             ics = &sce->ics;
  550             s->cur_channel = start_ch + ch;
  551             overlap  = &samples[s->cur_channel][0];
  552             samples2 = overlap + 1024;
  553             la       = samples2 + (448+64);
  554             if (!frame)
  555                 la = NULL;
  556             if (tag == TYPE_LFE) {
  557                 wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
  558                 wi[ch].window_shape   = 0;
  559                 wi[ch].num_windows    = 1;
  560                 wi[ch].grouping[0]    = 1;
  561                 wi[ch].clipping[0]    = 0;
  562 
  563                 /* Only the lowest 12 coefficients are used in a LFE channel.
  564                  * The expression below results in only the bottom 8 coefficients
  565                  * being used for 11.025kHz to 16kHz sample rates.
  566                  */
  567                 ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
  568             } else {
  569                 wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
  570                                               ics->window_sequence[0]);
  571             }
  572             ics->window_sequence[1] = ics->window_sequence[0];
  573             ics->window_sequence[0] = wi[ch].window_type[0];
  574             ics->use_kb_window[1]   = ics->use_kb_window[0];
  575             ics->use_kb_window[0]   = wi[ch].window_shape;
  576             ics->num_windows        = wi[ch].num_windows;
  577             ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];
  578             ics->num_swb            = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
  579             ics->max_sfb            = FFMIN(ics->max_sfb, ics->num_swb);
  580             ics->swb_offset         = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
  581                                         ff_swb_offset_128 [s->samplerate_index]:
  582                                         ff_swb_offset_1024[s->samplerate_index];
  583             ics->tns_max_bands      = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
  584                                         ff_tns_max_bands_128 [s->samplerate_index]:
  585                                         ff_tns_max_bands_1024[s->samplerate_index];
  586 
  587             for (w = 0; w < ics->num_windows; w++)
  588                 ics->group_len[w] = wi[ch].grouping[w];
  589 
  590             /* Calculate input sample maximums and evaluate clipping risk */
  591             clip_avoidance_factor = 0.0f;
  592             for (w = 0; w < ics->num_windows; w++) {
  593                 const float *wbuf = overlap + w * 128;
  594                 const int wlen = 2048 / ics->num_windows;
  595                 float max = 0;
  596                 int j;
  597                 /* mdct input is 2 * output */
  598                 for (j = 0; j < wlen; j++)
  599                     max = FFMAX(max, fabsf(wbuf[j]));
  600                 wi[ch].clipping[w] = max;
  601             }
  602             for (w = 0; w < ics->num_windows; w++) {
  603                 if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
  604                     ics->window_clipping[w] = 1;
  605                     clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
  606                 } else {
  607                     ics->window_clipping[w] = 0;
  608                 }
  609             }
  610             if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
  611                 ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
  612             } else {
  613                 ics->clip_avoidance_factor = 1.0f;
  614             }
  615 
  616             apply_window_and_mdct(s, sce, overlap);
  617 
  618             if (s->options.ltp && s->coder->update_ltp) {
  619                 s->coder->update_ltp(s, sce);
  620                 apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
  621                 s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);
  622             }
  623 
  624             for (k = 0; k < 1024; k++) {
  625                 if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
  626                     av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
  627                     return AVERROR(EINVAL);
  628                 }
  629             }
  630             avoid_clipping(s, sce);
  631         }
  632         start_ch += chans;
  633     }
  634     if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels, 0)) < 0)
  635         return ret;
  636     frame_bits = its = 0;
  637     do {
  638         init_put_bits(&s->pb, avpkt->data, avpkt->size);
  639 
  640         if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
  641             put_bitstream_info(s, LIBAVCODEC_IDENT);
  642         start_ch = 0;
  643         target_bits = 0;
  644         memset(chan_el_counter, 0, sizeof(chan_el_counter));
  645         for (i = 0; i < s->chan_map[0]; i++) {
  646             FFPsyWindowInfo* wi = windows + start_ch;
  647             const float *coeffs[2];
  648             tag      = s->chan_map[i+1];
  649             chans    = tag == TYPE_CPE ? 2 : 1;
  650             cpe      = &s->cpe[i];
  651             cpe->common_window = 0;
  652             memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
  653             memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
  654             put_bits(&s->pb, 3, tag);
  655             put_bits(&s->pb, 4, chan_el_counter[tag]++);
  656             for (ch = 0; ch < chans; ch++) {
  657                 sce = &cpe->ch[ch];
  658                 coeffs[ch] = sce->coeffs;
  659                 sce->ics.predictor_present = 0;
  660                 sce->ics.ltp.present = 0;
  661                 memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
  662                 memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
  663                 memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
  664                 for (w = 0; w < 128; w++)
  665                     if (sce->band_type[w] > RESERVED_BT)
  666                         sce->band_type[w] = 0;
  667             }
  668             s->psy.bitres.alloc = -1;
  669             s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
  670             s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
  671             if (s->psy.bitres.alloc > 0) {
  672                 /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
  673                 target_bits += s->psy.bitres.alloc
  674                     * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
  675                 s->psy.bitres.alloc /= chans;
  676             }
  677             s->cur_type = tag;
  678             for (ch = 0; ch < chans; ch++) {
  679                 s->cur_channel = start_ch + ch;
  680                 if (s->options.pns && s->coder->mark_pns)
  681                     s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
  682                 s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
  683             }
  684             if (chans > 1
  685                 && wi[0].window_type[0] == wi[1].window_type[0]
  686                 && wi[0].window_shape   == wi[1].window_shape) {
  687 
  688                 cpe->common_window = 1;
  689                 for (w = 0; w < wi[0].num_windows; w++) {
  690                     if (wi[0].grouping[w] != wi[1].grouping[w]) {
  691                         cpe->common_window = 0;
  692                         break;
  693                     }
  694                 }
  695             }
  696             for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
  697                 sce = &cpe->ch[ch];
  698                 s->cur_channel = start_ch + ch;
  699                 if (s->options.tns && s->coder->search_for_tns)
  700                     s->coder->search_for_tns(s, sce);
  701                 if (s->options.tns && s->coder->apply_tns_filt)
  702                     s->coder->apply_tns_filt(s, sce);
  703                 if (sce->tns.present)
  704                     tns_mode = 1;
  705                 if (s->options.pns && s->coder->search_for_pns)
  706                     s->coder->search_for_pns(s, avctx, sce);
  707             }
  708             s->cur_channel = start_ch;
  709             if (s->options.intensity_stereo) { /* Intensity Stereo */
  710                 if (s->coder->search_for_is)
  711                     s->coder->search_for_is(s, avctx, cpe);
  712                 if (cpe->is_mode) is_mode = 1;
  713                 apply_intensity_stereo(cpe);
  714             }
  715             if (s->options.pred) { /* Prediction */
  716                 for (ch = 0; ch < chans; ch++) {
  717                     sce = &cpe->ch[ch];
  718                     s->cur_channel = start_ch + ch;
  719                     if (s->options.pred && s->coder->search_for_pred)
  720                         s->coder->search_for_pred(s, sce);
  721                     if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
  722                 }
  723                 if (s->coder->adjust_common_pred)
  724                     s->coder->adjust_common_pred(s, cpe);
  725                 for (ch = 0; ch < chans; ch++) {
  726                     sce = &cpe->ch[ch];
  727                     s->cur_channel = start_ch + ch;
  728                     if (s->options.pred && s->coder->apply_main_pred)
  729                         s->coder->apply_main_pred(s, sce);
  730                 }
  731                 s->cur_channel = start_ch;
  732             }
  733             if (s->options.mid_side) { /* Mid/Side stereo */
  734                 if (s->options.mid_side == -1 && s->coder->search_for_ms)
  735                     s->coder->search_for_ms(s, cpe);
  736                 else if (cpe->common_window)
  737                     memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
  738                 apply_mid_side_stereo(cpe);
  739             }
  740             adjust_frame_information(cpe, chans);
  741             if (s->options.ltp) { /* LTP */
  742                 for (ch = 0; ch < chans; ch++) {
  743                     sce = &cpe->ch[ch];
  744                     s->cur_channel = start_ch + ch;
  745                     if (s->coder->search_for_ltp)
  746                         s->coder->search_for_ltp(s, sce, cpe->common_window);
  747                     if (sce->ics.ltp.present) pred_mode = 1;
  748                 }
  749                 s->cur_channel = start_ch;
  750                 if (s->coder->adjust_common_ltp)
  751                     s->coder->adjust_common_ltp(s, cpe);
  752             }
  753             if (chans == 2) {
  754                 put_bits(&s->pb, 1, cpe->common_window);
  755                 if (cpe->common_window) {
  756                     put_ics_info(s, &cpe->ch[0].ics);
  757                     if (s->coder->encode_main_pred)
  758                         s->coder->encode_main_pred(s, &cpe->ch[0]);
  759                     if (s->coder->encode_ltp_info)
  760                         s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
  761                     encode_ms_info(&s->pb, cpe);
  762                     if (cpe->ms_mode) ms_mode = 1;
  763                 }
  764             }
  765             for (ch = 0; ch < chans; ch++) {
  766                 s->cur_channel = start_ch + ch;
  767                 encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
  768             }
  769             start_ch += chans;
  770         }
  771 
  772         if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
  773             /* When using a constant Q-scale, don't mess with lambda */
  774             break;
  775         }
  776 
  777         /* rate control stuff
  778          * allow between the nominal bitrate, and what psy's bit reservoir says to target
  779          * but drift towards the nominal bitrate always
  780          */
  781         frame_bits = put_bits_count(&s->pb);
  782         rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
  783         rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
  784         too_many_bits = FFMAX(target_bits, rate_bits);
  785         too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
  786         too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
  787 
  788         /* When using ABR, be strict (but only for increasing) */
  789         too_few_bits = too_few_bits - too_few_bits/8;
  790         too_many_bits = too_many_bits + too_many_bits/2;
  791 
  792         if (   its == 0 /* for steady-state Q-scale tracking */
  793             || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
  794             || frame_bits >= 6144 * s->channels - 3  )
  795         {
  796             float ratio = ((float)rate_bits) / frame_bits;
  797 
  798             if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
  799                 /*
  800                  * This path is for steady-state Q-scale tracking
  801                  * When frame bits fall within the stable range, we still need to adjust
  802                  * lambda to maintain it like so in a stable fashion (large jumps in lambda
  803                  * create artifacts and should be avoided), but slowly
  804                  */
  805                 ratio = sqrtf(sqrtf(ratio));
  806                 ratio = av_clipf(ratio, 0.9f, 1.1f);
  807             } else {
  808                 /* Not so fast though */
  809                 ratio = sqrtf(ratio);
  810             }
  811             s->lambda = FFMIN(s->lambda * ratio, 65536.f);
  812 
  813             /* Keep iterating if we must reduce and lambda is in the sky */
  814             if (ratio > 0.9f && ratio < 1.1f) {
  815                 break;
  816             } else {
  817                 if (is_mode || ms_mode || tns_mode || pred_mode) {
  818                     for (i = 0; i < s->chan_map[0]; i++) {
  819                         // Must restore coeffs
  820                         chans = tag == TYPE_CPE ? 2 : 1;
  821                         cpe = &s->cpe[i];
  822                         for (ch = 0; ch < chans; ch++)
  823                             memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
  824                     }
  825                 }
  826                 its++;
  827             }
  828         } else {
  829             break;
  830         }
  831     } while (1);
  832 
  833     if (s->options.ltp && s->coder->ltp_insert_new_frame)
  834         s->coder->ltp_insert_new_frame(s);
  835 
  836     put_bits(&s->pb, 3, TYPE_END);
  837     flush_put_bits(&s->pb);
  838 
  839     s->last_frame_pb_count = put_bits_count(&s->pb);
  840 
  841     s->lambda_sum += s->lambda;
  842     s->lambda_count++;
  843 
  844     ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
  845                        &avpkt->duration);
  846 
  847     avpkt->size = put_bits_count(&s->pb) >> 3;
  848     *got_packet_ptr = 1;
  849     return 0;
  850 }
  851 
  852 static av_cold int aac_encode_end(AVCodecContext *avctx)
  853 {
  854     AACEncContext *s = avctx->priv_data;
  855 
  856     av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_sum / s->lambda_count);
  857 
  858     ff_mdct_end(&s->mdct1024);
  859     ff_mdct_end(&s->mdct128);
  860     ff_psy_end(&s->psy);
  861     ff_lpc_end(&s->lpc);
  862     if (s->psypp)
  863         ff_psy_preprocess_end(s->psypp);
  864     av_freep(&s->buffer.samples);
  865     av_freep(&s->cpe);
  866     av_freep(&s->fdsp);
  867     ff_af_queue_close(&s->afq);
  868     return 0;
  869 }
  870 
  871 static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
  872 {
  873     int ret = 0;
  874 
  875     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
  876     if (!s->fdsp)
  877         return AVERROR(ENOMEM);
  878 
  879     // window init
  880     ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
  881     ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
  882     ff_init_ff_sine_windows(10);
  883     ff_init_ff_sine_windows(7);
  884 
  885     if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
  886         return ret;
  887     if ((ret = ff_mdct_init(&s->mdct128,   8, 0, 32768.0)) < 0)
  888         return ret;
  889 
  890     return 0;
  891 }
  892 
  893 static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
  894 {
  895     int ch;
  896     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail);
  897     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail);
  898     FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + AV_INPUT_BUFFER_PADDING_SIZE, alloc_fail);
  899 
  900     for(ch = 0; ch < s->channels; ch++)
  901         s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
  902 
  903     return 0;
  904 alloc_fail:
  905     return AVERROR(ENOMEM);
  906 }
  907 
  908 static av_cold void aac_encode_init_tables(void)
  909 {
  910     ff_aac_tableinit();
  911 }
  912 
  913 static av_cold int aac_encode_init(AVCodecContext *avctx)
  914 {
  915     AACEncContext *s = avctx->priv_data;
  916     int i, ret = 0;
  917     const uint8_t *sizes[2];
  918     uint8_t grouping[AAC_MAX_CHANNELS];
  919     int lengths[2];
  920 
  921     /* Constants */
  922     s->last_frame_pb_count = 0;
  923     avctx->extradata_size = 5;
  924     avctx->frame_size = 1024;
  925     avctx->initial_padding = 1024;
  926     s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
  927 
  928     /* Channel map and unspecified bitrate guessing */
  929     s->channels = avctx->channels;
  930     ERROR_IF(s->channels > AAC_MAX_CHANNELS || s->channels == 7,
  931              "Unsupported number of channels: %d\n", s->channels);
  932     s->chan_map = aac_chan_configs[s->channels-1];
  933     if (!avctx->bit_rate) {
  934         for (i = 1; i <= s->chan_map[0]; i++) {
  935             avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
  936                                s->chan_map[i] == TYPE_LFE ? 16000  : /* LFE  */
  937                                                             69000  ; /* SCE  */
  938         }
  939     }
  940 
  941     /* Samplerate */
  942     for (i = 0; i < 16; i++)
  943         if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])
  944             break;
  945     s->samplerate_index = i;
  946     ERROR_IF(s->samplerate_index == 16 ||
  947              s->samplerate_index >= ff_aac_swb_size_1024_len ||
  948              s->samplerate_index >= ff_aac_swb_size_128_len,
  949              "Unsupported sample rate %d\n", avctx->sample_rate);
  950 
  951     /* Bitrate limiting */
  952     WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
  953              "Too many bits %f > %d per frame requested, clamping to max\n",
  954              1024.0 * avctx->bit_rate / avctx->sample_rate,
  955              6144 * s->channels);
  956     avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
  957                                      avctx->bit_rate);
  958 
  959     /* Profile and option setting */
  960     avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
  961                      avctx->profile;
  962     for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
  963         if (avctx->profile == aacenc_profiles[i])
  964             break;
  965     if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
  966         avctx->profile = FF_PROFILE_AAC_LOW;
  967         ERROR_IF(s->options.pred,
  968                  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
  969         ERROR_IF(s->options.ltp,
  970                  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
  971         WARN_IF(s->options.pns,
  972                 "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
  973         s->options.pns = 0;
  974     } else if (avctx->profile == FF_PROFILE_AAC_LTP) {
  975         s->options.ltp = 1;
  976         ERROR_IF(s->options.pred,
  977                  "Main prediction unavailable in the \"aac_ltp\" profile\n");
  978     } else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
  979         s->options.pred = 1;
  980         ERROR_IF(s->options.ltp,
  981                  "LTP prediction unavailable in the \"aac_main\" profile\n");
  982     } else if (s->options.ltp) {
  983         avctx->profile = FF_PROFILE_AAC_LTP;
  984         WARN_IF(1,
  985                 "Chainging profile to \"aac_ltp\"\n");
  986         ERROR_IF(s->options.pred,
  987                  "Main prediction unavailable in the \"aac_ltp\" profile\n");
  988     } else if (s->options.pred) {
  989         avctx->profile = FF_PROFILE_AAC_MAIN;
  990         WARN_IF(1,
  991                 "Chainging profile to \"aac_main\"\n");
  992         ERROR_IF(s->options.ltp,
  993                  "LTP prediction unavailable in the \"aac_main\" profile\n");
  994     }
  995     s->profile = avctx->profile;
  996 
  997     /* Coder limitations */
  998     s->coder = &ff_aac_coders[s->options.coder];
  999     if (s->options.coder == AAC_CODER_ANMR) {
 1000         ERROR_IF(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL,
 1001                  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
 1002         s->options.intensity_stereo = 0;
 1003         s->options.pns = 0;
 1004     }
 1005     ERROR_IF(s->options.ltp && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL,
 1006              "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
 1007 
 1008     /* M/S introduces horrible artifacts with multichannel files, this is temporary */
 1009     if (s->channels > 3)
 1010         s->options.mid_side = 0;
 1011 
 1012     if ((ret = dsp_init(avctx, s)) < 0)
 1013         goto fail;
 1014 
 1015     if ((ret = alloc_buffers(avctx, s)) < 0)
 1016         goto fail;
 1017 
 1018     put_audio_specific_config(avctx);
 1019 
 1020     sizes[0]   = ff_aac_swb_size_1024[s->samplerate_index];
 1021     sizes[1]   = ff_aac_swb_size_128[s->samplerate_index];
 1022     lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
 1023     lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
 1024     for (i = 0; i < s->chan_map[0]; i++)
 1025         grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
 1026     if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
 1027                            s->chan_map[0], grouping)) < 0)
 1028         goto fail;
 1029     s->psypp = ff_psy_preprocess_init(avctx);
 1030     ff_lpc_init(&s->lpc, 2*avctx->frame_size, TNS_MAX_ORDER, FF_LPC_TYPE_LEVINSON);
 1031     s->random_state = 0x1f2e3d4c;
 1032 
 1033     s->abs_pow34   = abs_pow34_v;
 1034     s->quant_bands = quantize_bands;
 1035 
 1036     if (ARCH_X86)
 1037         ff_aac_dsp_init_x86(s);
 1038 
 1039     if (HAVE_MIPSDSP)
 1040         ff_aac_coder_init_mips(s);
 1041 
 1042     if ((ret = ff_thread_once(&aac_table_init, &aac_encode_init_tables)) != 0)
 1043         return AVERROR_UNKNOWN;
 1044 
 1045     ff_af_queue_init(avctx, &s->afq);
 1046 
 1047     return 0;
 1048 fail:
 1049     aac_encode_end(avctx);
 1050     return ret;
 1051 }
 1052 
 1053 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
 1054 static const AVOption aacenc_options[] = {
 1055     {"aac_coder", "Coding algorithm", offsetof(AACEncContext, options.coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, "coder"},
 1056         {"anmr",     "ANMR method",               0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 1057         {"twoloop",  "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 1058         {"fast",     "Constant quantizer",        0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 1059     {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
 1060     {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
 1061     {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
 1062     {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
 1063     {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
 1064     {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
 1065     {NULL}
 1066 };
 1067 
 1068 static const AVClass aacenc_class = {
 1069     "AAC encoder",
 1070     av_default_item_name,
 1071     aacenc_options,
 1072     LIBAVUTIL_VERSION_INT,
 1073 };
 1074 
 1075 static const AVCodecDefault aac_encode_defaults[] = {
 1076     { "b", "0" },
 1077     { NULL }
 1078 };
 1079 
 1080 AVCodec ff_aac_encoder = {
 1081     .name           = "aac",
 1082     .long_name      = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
 1083     .type           = AVMEDIA_TYPE_AUDIO,
 1084     .id             = AV_CODEC_ID_AAC,
 1085     .priv_data_size = sizeof(AACEncContext),
 1086     .init           = aac_encode_init,
 1087     .encode2        = aac_encode_frame,
 1088     .close          = aac_encode_end,
 1089     .defaults       = aac_encode_defaults,
 1090     .supported_samplerates = mpeg4audio_sample_rates,
 1091     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 1092     .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
 1093     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
 1094                                                      AV_SAMPLE_FMT_NONE },
 1095     .priv_class     = &aacenc_class,
 1096 };