Merge commit 'b805482b1fba1d82fbe47023a24c9261f18979b6'
authorHendrik Leppkes <h.leppkes@gmail.com>
Tue, 8 Dec 2015 08:59:45 +0000 (09:59 +0100)
committerHendrik Leppkes <h.leppkes@gmail.com>
Tue, 8 Dec 2015 08:59:45 +0000 (09:59 +0100)
* commit 'b805482b1fba1d82fbe47023a24c9261f18979b6':
  aac: Provide more information on the failure message

Merged-by: Hendrik Leppkes <h.leppkes@gmail.com>
1  2 
libavcodec/aacenc.c

diff --combined libavcodec/aacenc.c
@@@ -2,20 -2,20 +2,20 @@@
   * AAC encoder
   * Copyright (C) 2008 Konstantin Shishkov
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -27,9 -27,9 +27,9 @@@
  /***********************************
   *              TODOs:
   * add sane pulse detection
 - * add temporal noise shaping
   ***********************************/
  
 +#include "libavutil/thread.h"
  #include "libavutil/float_dsp.h"
  #include "libavutil/opt.h"
  #include "avcodec.h"
  #include "aac.h"
  #include "aactab.h"
  #include "aacenc.h"
 +#include "aacenctab.h"
 +#include "aacenc_utils.h"
  
  #include "psymodel.h"
  
 -#define AAC_MAX_CHANNELS 6
 -
 -#define ERROR_IF(cond, ...) \
 -    if (cond) { \
 -        av_log(avctx, AV_LOG_ERROR, __VA_ARGS__); \
 -        return AVERROR(EINVAL); \
 -    }
 -
 -float ff_aac_pow34sf_tab[428];
 -
 -static const uint8_t swb_size_1024_96[] = {
 -    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8,
 -    12, 12, 12, 12, 12, 16, 16, 24, 28, 36, 44,
 -    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
 -};
 -
 -static const uint8_t swb_size_1024_64[] = {
 -    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
 -    12, 12, 12, 16, 16, 16, 20, 24, 24, 28, 36,
 -    40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40
 -};
 -
 -static const uint8_t swb_size_1024_48[] = {
 -    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8,
 -    12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28,
 -    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 -    96
 -};
 -
 -static const uint8_t swb_size_1024_32[] = {
 -    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8,
 -    12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28,
 -    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
 -};
 -
 -static const uint8_t swb_size_1024_24[] = {
 -    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
 -    12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28,
 -    32, 36, 36, 40, 44, 48, 52, 52, 64, 64, 64, 64, 64
 -};
 -
 -static const uint8_t swb_size_1024_16[] = {
 -    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
 -    12, 12, 12, 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24, 24, 28, 28,
 -    32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64, 64
 -};
 -
 -static const uint8_t swb_size_1024_8[] = {
 -    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
 -    16, 16, 16, 16, 16, 16, 16, 20, 20, 20, 20, 24, 24, 24, 28, 28,
 -    32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 80
 -};
 -
 -static const uint8_t *swb_size_1024[] = {
 -    swb_size_1024_96, swb_size_1024_96, swb_size_1024_64,
 -    swb_size_1024_48, swb_size_1024_48, swb_size_1024_32,
 -    swb_size_1024_24, swb_size_1024_24, swb_size_1024_16,
 -    swb_size_1024_16, swb_size_1024_16, swb_size_1024_8
 -};
 -
 -static const uint8_t swb_size_128_96[] = {
 -    4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36
 -};
 -
 -static const uint8_t swb_size_128_48[] = {
 -    4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16
 -};
 -
 -static const uint8_t swb_size_128_24[] = {
 -    4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 20
 -};
 -
 -static const uint8_t swb_size_128_16[] = {
 -    4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20
 -};
 -
 -static const uint8_t swb_size_128_8[] = {
 -    4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 20
 -};
 -
 -static const uint8_t *swb_size_128[] = {
 -    /* the last entry on the following row is swb_size_128_64 but is a
 -       duplicate of swb_size_128_96 */
 -    swb_size_128_96, swb_size_128_96, swb_size_128_96,
 -    swb_size_128_48, swb_size_128_48, swb_size_128_48,
 -    swb_size_128_24, swb_size_128_24, swb_size_128_16,
 -    swb_size_128_16, swb_size_128_16, swb_size_128_8
 -};
 -
 -/** default channel configurations */
 -static const uint8_t aac_chan_configs[6][5] = {
 - {1, TYPE_SCE},                               // 1 channel  - single channel element
 - {1, TYPE_CPE},                               // 2 channels - channel pair
 - {2, TYPE_SCE, TYPE_CPE},                     // 3 channels - center + stereo
 - {3, TYPE_SCE, TYPE_CPE, TYPE_SCE},           // 4 channels - front center + stereo + back center
 - {3, TYPE_SCE, TYPE_CPE, TYPE_CPE},           // 5 channels - front center + stereo + back stereo
 - {4, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_LFE}, // 6 channels - front center + stereo + back stereo + LFE
 -};
 -
 -/**
 - * Table to remap channels from Libav's default order to AAC order.
 - */
 -static const uint8_t aac_chan_maps[AAC_MAX_CHANNELS][AAC_MAX_CHANNELS] = {
 -    { 0 },
 -    { 0, 1 },
 -    { 2, 0, 1 },
 -    { 2, 0, 1, 3 },
 -    { 2, 0, 1, 3, 4 },
 -    { 2, 0, 1, 4, 5, 3 },
 -};
 +static AVOnce aac_table_init = AV_ONCE_INIT;
  
  /**
   * Make AAC audio config object.
@@@ -57,12 -164,11 +57,12 @@@ static void put_audio_specific_config(A
  {
      PutBitContext pb;
      AACEncContext *s = avctx->priv_data;
 +    int channels = s->channels - (s->channels == 8 ? 1 : 0);
  
 -    init_put_bits(&pb, avctx->extradata, avctx->extradata_size*8);
 -    put_bits(&pb, 5, 2); //object type - AAC-LC
 +    init_put_bits(&pb, avctx->extradata, avctx->extradata_size);
 +    put_bits(&pb, 5, s->profile+1); //profile
      put_bits(&pb, 4, s->samplerate_index); //sample rate index
 -    put_bits(&pb, 4, s->channels);
 +    put_bits(&pb, 4, channels);
      //GASpecificConfig
      put_bits(&pb, 1, 0); //frame length - 1024 samples
      put_bits(&pb, 1, 0); //does not depend on core coder
      flush_put_bits(&pb);
  }
  
 +void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
 +{
 +    int sf, g;
 +    for (sf = 0; sf < 256; sf++) {
 +        for (g = 0; g < 128; g++) {
 +            s->quantize_band_cost_cache[sf][g].bits = -1;
 +        }
 +    }
 +}
 +
  #define WINDOW_FUNC(type) \
  static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
                                      SingleChannelElement *sce, \
@@@ -156,15 -252,14 +156,15 @@@ static void apply_window_and_mdct(AACEn
      int i;
      float *output = sce->ret_buf;
  
 -    apply_window[sce->ics.window_sequence[0]](&s->fdsp, sce, audio);
 +    apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
  
      if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE)
          s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
      else
          for (i = 0; i < 1024; i += 128)
 -            s->mdct128.mdct_calc(&s->mdct128, sce->coeffs + i, output + i*2);
 +            s->mdct128.mdct_calc(&s->mdct128, &sce->coeffs[i], output + i*2);
      memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
 +    memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
  }
  
  /**
@@@ -180,7 -275,7 +180,7 @@@ static void put_ics_info(AACEncContext 
      put_bits(&s->pb, 1, info->use_kb_window[0]);
      if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
          put_bits(&s->pb, 6, info->max_sfb);
 -        put_bits(&s->pb, 1, 0);            // no prediction
 +        put_bits(&s->pb, 1, !!info->predictor_present);
      } else {
          put_bits(&s->pb, 4, info->max_sfb);
          for (w = 1; w < 8; w++)
@@@ -209,18 -304,27 +209,18 @@@ static void encode_ms_info(PutBitContex
  static void adjust_frame_information(ChannelElement *cpe, int chans)
  {
      int i, w, w2, g, ch;
 -    int start, maxsfb, cmaxsfb;
 +    int maxsfb, cmaxsfb;
  
      for (ch = 0; ch < chans; ch++) {
          IndividualChannelStream *ics = &cpe->ch[ch].ics;
 -        start = 0;
          maxsfb = 0;
          cpe->ch[ch].pulse.num_pulse = 0;
 -        for (w = 0; w < ics->num_windows*16; w += 16) {
 -            for (g = 0; g < ics->num_swb; g++) {
 -                //apply M/S
 -                if (cpe->common_window && !ch && cpe->ms_mask[w + g]) {
 -                    for (i = 0; i < ics->swb_sizes[g]; i++) {
 -                        cpe->ch[0].coeffs[start+i] = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) / 2.0;
 -                        cpe->ch[1].coeffs[start+i] =  cpe->ch[0].coeffs[start+i] - cpe->ch[1].coeffs[start+i];
 -                    }
 -                }
 -                start += ics->swb_sizes[g];
 +        for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
 +            for (w2 =  0; w2 < ics->group_len[w]; w2++) {
 +                for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
 +                    ;
 +                maxsfb = FFMAX(maxsfb, cmaxsfb);
              }
 -            for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w+cmaxsfb-1]; cmaxsfb--)
 -                ;
 -            maxsfb = FFMAX(maxsfb, cmaxsfb);
          }
          ics->max_sfb = maxsfb;
  
      }
  }
  
 +static void apply_intensity_stereo(ChannelElement *cpe)
 +{
 +    int w, w2, g, i;
 +    IndividualChannelStream *ics = &cpe->ch[0].ics;
 +    if (!cpe->common_window)
 +        return;
 +    for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
 +        for (w2 =  0; w2 < ics->group_len[w]; w2++) {
 +            int start = (w+w2) * 128;
 +            for (g = 0; g < ics->num_swb; g++) {
 +                int p  = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
 +                float scale = cpe->ch[0].is_ener[w*16+g];
 +                if (!cpe->is_mask[w*16 + g]) {
 +                    start += ics->swb_sizes[g];
 +                    continue;
 +                }
 +                if (cpe->ms_mask[w*16 + g])
 +                    p *= -1;
 +                for (i = 0; i < ics->swb_sizes[g]; i++) {
 +                    float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
 +                    cpe->ch[0].coeffs[start+i] = sum;
 +                    cpe->ch[1].coeffs[start+i] = 0.0f;
 +                }
 +                start += ics->swb_sizes[g];
 +            }
 +        }
 +    }
 +}
 +
 +static void apply_mid_side_stereo(ChannelElement *cpe)
 +{
 +    int w, w2, g, i;
 +    IndividualChannelStream *ics = &cpe->ch[0].ics;
 +    if (!cpe->common_window)
 +        return;
 +    for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
 +        for (w2 =  0; w2 < ics->group_len[w]; w2++) {
 +            int start = (w+w2) * 128;
 +            for (g = 0; g < ics->num_swb; g++) {
 +                /* ms_mask can be used for other purposes in PNS and I/S,
 +                 * so must not apply M/S if any band uses either, even if
 +                 * ms_mask is set.
 +                 */
 +                if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
 +                    || cpe->ch[0].band_type[w*16 + g] == NOISE_BT
 +                    || cpe->ch[1].band_type[w*16 + g] == NOISE_BT) {
 +                    start += ics->swb_sizes[g];
 +                    continue;
 +                }
 +                for (i = 0; i < ics->swb_sizes[g]; i++) {
 +                    float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
 +                    float R = L - cpe->ch[1].coeffs[start+i];
 +                    cpe->ch[0].coeffs[start+i] = L;
 +                    cpe->ch[1].coeffs[start+i] = R;
 +                }
 +                start += ics->swb_sizes[g];
 +            }
 +        }
 +    }
 +}
 +
  /**
   * Encode scalefactor band coding type.
   */
@@@ -324,9 -367,6 +324,9 @@@ static void encode_band_info(AACEncCont
  {
      int w;
  
 +    if (s->coder->set_special_band_scalefactors)
 +        s->coder->set_special_band_scalefactors(s, sce);
 +
      for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
          s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
  }
  static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
                                   SingleChannelElement *sce)
  {
 -    int off = sce->sf_idx[0], diff;
 +    int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
 +    int off_is = 0, noise_flag = 1;
      int i, w;
  
      for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
          for (i = 0; i < sce->ics.max_sfb; i++) {
              if (!sce->zeroes[w*16 + i]) {
 -                diff = sce->sf_idx[w*16 + i] - off + SCALE_DIFF_ZERO;
 -                if (diff < 0 || diff > 120)
 -                    av_log(avctx, AV_LOG_ERROR, "Scalefactor difference is too big to be coded\n");
 -                off = sce->sf_idx[w*16 + i];
 +                if (sce->band_type[w*16 + i] == NOISE_BT) {
 +                    diff = sce->sf_idx[w*16 + i] - off_pns;
 +                    off_pns = sce->sf_idx[w*16 + i];
 +                    if (noise_flag-- > 0) {
 +                        put_bits(&s->pb, NOISE_PRE_BITS, diff + NOISE_PRE);
 +                        continue;
 +                    }
 +                } else if (sce->band_type[w*16 + i] == INTENSITY_BT  ||
 +                           sce->band_type[w*16 + i] == INTENSITY_BT2) {
 +                    diff = sce->sf_idx[w*16 + i] - off_is;
 +                    off_is = sce->sf_idx[w*16 + i];
 +                } else {
 +                    diff = sce->sf_idx[w*16 + i] - off_sf;
 +                    off_sf = sce->sf_idx[w*16 + i];
 +                }
 +                diff += SCALE_DIFF_ZERO;
 +                av_assert0(diff >= 0 && diff <= 120);
                  put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
              }
          }
@@@ -400,41 -426,18 +400,41 @@@ static void encode_spectral_coeffs(AACE
                  start += sce->ics.swb_sizes[i];
                  continue;
              }
 -            for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++)
 -                s->coder->quantize_and_encode_band(s, &s->pb, sce->coeffs + start + w2*128,
 -                                                   sce->ics.swb_sizes[i],
 +            for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
 +                s->coder->quantize_and_encode_band(s, &s->pb,
 +                                                   &sce->coeffs[start + w2*128],
 +                                                   NULL, sce->ics.swb_sizes[i],
                                                     sce->sf_idx[w*16 + i],
                                                     sce->band_type[w*16 + i],
 -                                                   s->lambda);
 +                                                   s->lambda,
 +                                                   sce->ics.window_clipping[w]);
 +            }
              start += sce->ics.swb_sizes[i];
          }
      }
  }
  
  /**
 + * Downscale spectral coefficients for near-clipping windows to avoid artifacts
 + */
 +static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
 +{
 +    int start, i, j, w;
 +
 +    if (sce->ics.clip_avoidance_factor < 1.0f) {
 +        for (w = 0; w < sce->ics.num_windows; w++) {
 +            start = 0;
 +            for (i = 0; i < sce->ics.max_sfb; i++) {
 +                float *swb_coeffs = &sce->coeffs[start + w*128];
 +                for (j = 0; j < sce->ics.swb_sizes[i]; j++)
 +                    swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
 +                start += sce->ics.swb_sizes[i];
 +            }
 +        }
 +    }
 +}
 +
 +/**
   * Encode one channel of audio data.
   */
  static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s,
                                       int common_window)
  {
      put_bits(&s->pb, 8, sce->sf_idx[0]);
 -    if (!common_window)
 +    if (!common_window) {
          put_ics_info(s, &sce->ics);
 +        if (s->coder->encode_main_pred)
 +            s->coder->encode_main_pred(s, sce);
 +        if (s->coder->encode_ltp_info)
 +            s->coder->encode_ltp_info(s, sce, 0);
 +    }
      encode_band_info(s, sce);
      encode_scale_factors(avctx, s, sce);
      encode_pulses(s, &sce->pulse);
 -    put_bits(&s->pb, 1, 0); //tns
 +    put_bits(&s->pb, 1, !!sce->tns.present);
 +    if (s->coder->encode_tns_info)
 +        s->coder->encode_tns_info(s, sce);
      put_bits(&s->pb, 1, 0); //ssr
      encode_spectral_coeffs(s, sce);
      return 0;
@@@ -482,7 -478,7 +482,7 @@@ static void put_bitstream_info(AACEncCo
  
  /*
   * Copy input samples.
 - * Channels are reordered from Libav's default order to AAC order.
 + * Channels are reordered from libavcodec's default order to AAC order.
   */
  static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
  {
@@@ -512,11 -508,7 +512,11 @@@ static int aac_encode_frame(AVCodecCont
      AACEncContext *s = avctx->priv_data;
      float **samples = s->planar_samples, *samples2, *la, *overlap;
      ChannelElement *cpe;
 -    int i, ch, w, g, chans, tag, start_ch, ret;
 +    SingleChannelElement *sce;
 +    IndividualChannelStream *ics;
 +    int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
 +    int target_bits, rate_bits, too_many_bits, too_few_bits;
 +    int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
      int chan_el_counter[4];
      FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
  
          chans    = tag == TYPE_CPE ? 2 : 1;
          cpe      = &s->cpe[i];
          for (ch = 0; ch < chans; ch++) {
 -            IndividualChannelStream *ics = &cpe->ch[ch].ics;
 -            int cur_channel = start_ch + ch;
 -            overlap  = &samples[cur_channel][0];
 +            float clip_avoidance_factor;
 +            sce = &cpe->ch[ch];
 +            ics = &sce->ics;
 +            s->cur_channel = start_ch + ch;
 +            overlap  = &samples[s->cur_channel][0];
              samples2 = overlap + 1024;
              la       = samples2 + (448+64);
              if (!frame)
                   */
                  ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
              } else {
 -                wi[ch] = s->psy.model->window(&s->psy, samples2, la, cur_channel,
 +                wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
                                                ics->window_sequence[0]);
              }
              ics->window_sequence[1] = ics->window_sequence[0];
              ics->num_windows        = wi[ch].num_windows;
              ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];
              ics->num_swb            = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
 +            ics->swb_offset         = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
 +                                        ff_swb_offset_128 [s->samplerate_index]:
 +                                        ff_swb_offset_1024[s->samplerate_index];
 +            ics->tns_max_bands      = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
 +                                        ff_tns_max_bands_128 [s->samplerate_index]:
 +                                        ff_tns_max_bands_1024[s->samplerate_index];
 +            clip_avoidance_factor = 0.0f;
              for (w = 0; w < ics->num_windows; w++)
                  ics->group_len[w] = wi[ch].grouping[w];
 +            for (w = 0; w < ics->num_windows; w++) {
 +                if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
 +                    ics->window_clipping[w] = 1;
 +                    clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
 +                } else {
 +                    ics->window_clipping[w] = 0;
 +                }
 +            }
 +            if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
 +                ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
 +            } else {
 +                ics->clip_avoidance_factor = 1.0f;
 +            }
 +
 +            apply_window_and_mdct(s, sce, overlap);
  
 -            apply_window_and_mdct(s, &cpe->ch[ch], overlap);
 +            if (s->options.ltp && s->coder->update_ltp) {
 +                s->coder->update_ltp(s, sce);
 +                apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
 +                s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);
 +            }
 +
 +            if (isnan(cpe->ch->coeffs[0])) {
 +                av_log(avctx, AV_LOG_ERROR, "Input contains NaN\n");
 +                return AVERROR(EINVAL);
 +            }
 +            avoid_clipping(s, sce);
          }
          start_ch += chans;
      }
 -    if ((ret = ff_alloc_packet(avpkt, 768 * s->channels))) {
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels, 0)) < 0)
          return ret;
 -    }
 -
 +    frame_bits = its = 0;
      do {
 -        int frame_bits;
 -
          init_put_bits(&s->pb, avpkt->data, avpkt->size);
  
          if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
              put_bitstream_info(s, LIBAVCODEC_IDENT);
          start_ch = 0;
 +        target_bits = 0;
          memset(chan_el_counter, 0, sizeof(chan_el_counter));
          for (i = 0; i < s->chan_map[0]; i++) {
              FFPsyWindowInfo* wi = windows + start_ch;
              tag      = s->chan_map[i+1];
              chans    = tag == TYPE_CPE ? 2 : 1;
              cpe      = &s->cpe[i];
 +            cpe->common_window = 0;
 +            memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
 +            memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
              put_bits(&s->pb, 3, tag);
              put_bits(&s->pb, 4, chan_el_counter[tag]++);
 -            for (ch = 0; ch < chans; ch++)
 -                coeffs[ch] = cpe->ch[ch].coeffs;
 +            for (ch = 0; ch < chans; ch++) {
 +                sce = &cpe->ch[ch];
 +                coeffs[ch] = sce->coeffs;
 +                sce->ics.predictor_present = 0;
 +                sce->ics.ltp.present = 0;
 +                memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
 +                memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
 +                memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
 +                for (w = 0; w < 128; w++)
 +                    if (sce->band_type[w] > RESERVED_BT)
 +                        sce->band_type[w] = 0;
 +            }
 +            s->psy.bitres.alloc = -1;
 +            s->psy.bitres.bits = avctx->frame_bits / s->channels;
              s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
 +            if (s->psy.bitres.alloc > 0) {
 +                /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
 +                target_bits += s->psy.bitres.alloc
 +                    * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
 +                s->psy.bitres.alloc /= chans;
 +            }
 +            s->cur_type = tag;
              for (ch = 0; ch < chans; ch++) {
                  s->cur_channel = start_ch + ch;
 +                if (s->options.pns && s->coder->mark_pns)
 +                    s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
                  s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
              }
 -            cpe->common_window = 0;
              if (chans > 1
                  && wi[0].window_type[0] == wi[1].window_type[0]
                  && wi[0].window_shape   == wi[1].window_shape) {
                      }
                  }
              }
 +            for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
 +                sce = &cpe->ch[ch];
 +                s->cur_channel = start_ch + ch;
 +                if (s->options.tns && s->coder->search_for_tns)
 +                    s->coder->search_for_tns(s, sce);
 +                if (s->options.tns && s->coder->apply_tns_filt)
 +                    s->coder->apply_tns_filt(s, sce);
 +                if (sce->tns.present)
 +                    tns_mode = 1;
 +                if (s->options.pns && s->coder->search_for_pns)
 +                    s->coder->search_for_pns(s, avctx, sce);
 +            }
              s->cur_channel = start_ch;
 -            if (s->options.stereo_mode && cpe->common_window) {
 -                if (s->options.stereo_mode > 0) {
 -                    IndividualChannelStream *ics = &cpe->ch[0].ics;
 -                    for (w = 0; w < ics->num_windows; w += ics->group_len[w])
 -                        for (g = 0;  g < ics->num_swb; g++)
 -                            cpe->ms_mask[w*16+g] = 1;
 -                } else if (s->coder->search_for_ms) {
 -                    s->coder->search_for_ms(s, cpe, s->lambda);
 +            if (s->options.intensity_stereo) { /* Intensity Stereo */
 +                if (s->coder->search_for_is)
 +                    s->coder->search_for_is(s, avctx, cpe);
 +                if (cpe->is_mode) is_mode = 1;
 +                apply_intensity_stereo(cpe);
 +            }
 +            if (s->options.pred) { /* Prediction */
 +                for (ch = 0; ch < chans; ch++) {
 +                    sce = &cpe->ch[ch];
 +                    s->cur_channel = start_ch + ch;
 +                    if (s->options.pred && s->coder->search_for_pred)
 +                        s->coder->search_for_pred(s, sce);
 +                    if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
                  }
 +                if (s->coder->adjust_common_pred)
 +                    s->coder->adjust_common_pred(s, cpe);
 +                for (ch = 0; ch < chans; ch++) {
 +                    sce = &cpe->ch[ch];
 +                    s->cur_channel = start_ch + ch;
 +                    if (s->options.pred && s->coder->apply_main_pred)
 +                        s->coder->apply_main_pred(s, sce);
 +                }
 +                s->cur_channel = start_ch;
 +            }
 +            if (s->options.mid_side) { /* Mid/Side stereo */
 +                if (s->options.mid_side == -1 && s->coder->search_for_ms)
 +                    s->coder->search_for_ms(s, cpe);
 +                else if (cpe->common_window)
 +                    memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
 +                apply_mid_side_stereo(cpe);
              }
              adjust_frame_information(cpe, chans);
 +            if (s->options.ltp) { /* LTP */
 +                for (ch = 0; ch < chans; ch++) {
 +                    sce = &cpe->ch[ch];
 +                    s->cur_channel = start_ch + ch;
 +                    if (s->coder->search_for_ltp)
 +                        s->coder->search_for_ltp(s, sce, cpe->common_window);
 +                    if (sce->ics.ltp.present) pred_mode = 1;
 +                }
 +                s->cur_channel = start_ch;
 +                if (s->coder->adjust_common_ltp)
 +                    s->coder->adjust_common_ltp(s, cpe);
 +            }
              if (chans == 2) {
                  put_bits(&s->pb, 1, cpe->common_window);
                  if (cpe->common_window) {
                      put_ics_info(s, &cpe->ch[0].ics);
 +                    if (s->coder->encode_main_pred)
 +                        s->coder->encode_main_pred(s, &cpe->ch[0]);
 +                    if (s->coder->encode_ltp_info)
 +                        s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
                      encode_ms_info(&s->pb, cpe);
 +                    if (cpe->ms_mode) ms_mode = 1;
                  }
              }
              for (ch = 0; ch < chans; ch++) {
              start_ch += chans;
          }
  
 -        frame_bits = put_bits_count(&s->pb);
 -        if (frame_bits <= 6144 * s->channels - 3) {
 -            s->psy.bitres.bits = frame_bits / s->channels;
 +        if (avctx->flags & CODEC_FLAG_QSCALE) {
 +            /* When using a constant Q-scale, don't mess with lambda */
              break;
          }
  
 -        s->lambda *= avctx->bit_rate * 1024.0f / avctx->sample_rate / frame_bits;
 +        /* rate control stuff
 +         * allow between the nominal bitrate, and what psy's bit reservoir says to target
 +         * but drift towards the nominal bitrate always
 +         */
 +        frame_bits = put_bits_count(&s->pb);
 +        rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
 +        rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
 +        too_many_bits = FFMAX(target_bits, rate_bits);
 +        too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
 +        too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
 +
 +        /* When using ABR, be strict (but only for increasing) */
 +        too_few_bits = too_few_bits - too_few_bits/8;
 +        too_many_bits = too_many_bits + too_many_bits/2;
 +
 +        if (   its == 0 /* for steady-state Q-scale tracking */
 +            || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
 +            || frame_bits >= 6144 * s->channels - 3  )
 +        {
 +            float ratio = ((float)rate_bits) / frame_bits;
 +
 +            if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
 +                /*
 +                 * This path is for steady-state Q-scale tracking
 +                 * When frame bits fall within the stable range, we still need to adjust
 +                 * lambda to maintain it like so in a stable fashion (large jumps in lambda
 +                 * create artifacts and should be avoided), but slowly
 +                 */
 +                ratio = sqrtf(sqrtf(ratio));
 +                ratio = av_clipf(ratio, 0.9f, 1.1f);
 +            } else {
 +                /* Not so fast though */
 +                ratio = sqrtf(ratio);
 +            }
 +            s->lambda = FFMIN(s->lambda * ratio, 65536.f);
  
 +            /* Keep iterating if we must reduce and lambda is in the sky */
 +            if (ratio > 0.9f && ratio < 1.1f) {
 +                break;
 +            } else {
 +                if (is_mode || ms_mode || tns_mode || pred_mode) {
 +                    for (i = 0; i < s->chan_map[0]; i++) {
 +                        // Must restore coeffs
 +                        chans = tag == TYPE_CPE ? 2 : 1;
 +                        cpe = &s->cpe[i];
 +                        for (ch = 0; ch < chans; ch++)
 +                            memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
 +                    }
 +                }
 +                its++;
 +            }
 +        } else {
 +            break;
 +        }
      } while (1);
  
 +    if (s->options.ltp && s->coder->ltp_insert_new_frame)
 +        s->coder->ltp_insert_new_frame(s);
 +
      put_bits(&s->pb, 3, TYPE_END);
      flush_put_bits(&s->pb);
      avctx->frame_bits = put_bits_count(&s->pb);
 -
 -    // rate control stuff
 -    if (!(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
 -        float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits;
 -        s->lambda *= ratio;
 -        s->lambda = FFMIN(s->lambda, 65536.f);
 -    }
 +    s->lambda_sum += s->lambda;
 +    s->lambda_count++;
  
      if (!frame)
          s->last_frame++;
@@@ -836,17 -675,13 +836,17 @@@ static av_cold int aac_encode_end(AVCod
  {
      AACEncContext *s = avctx->priv_data;
  
 +    av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_sum / s->lambda_count);
 +
      ff_mdct_end(&s->mdct1024);
      ff_mdct_end(&s->mdct128);
      ff_psy_end(&s->psy);
 +    ff_lpc_end(&s->lpc);
      if (s->psypp)
          ff_psy_preprocess_end(s->psypp);
      av_freep(&s->buffer.samples);
      av_freep(&s->cpe);
 +    av_freep(&s->fdsp);
      ff_af_queue_close(&s->afq);
      return 0;
  }
@@@ -855,9 -690,7 +855,9 @@@ static av_cold int dsp_init(AVCodecCont
  {
      int ret = 0;
  
 -    avpriv_float_dsp_init(&s->fdsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
 +    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 +    if (!s->fdsp)
 +        return AVERROR(ENOMEM);
  
      // window init
      ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
      ff_init_ff_sine_windows(10);
      ff_init_ff_sine_windows(7);
  
 -    if (ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0))
 +    if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
          return ret;
 -    if (ret = ff_mdct_init(&s->mdct128,   8, 0, 32768.0))
 +    if ((ret = ff_mdct_init(&s->mdct128,   8, 0, 32768.0)) < 0)
          return ret;
  
      return 0;
  static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
  {
      int ch;
 -    FF_ALLOCZ_OR_GOTO(avctx, s->buffer.samples, 3 * 1024 * s->channels * sizeof(s->buffer.samples[0]), alloc_fail);
 -    FF_ALLOCZ_OR_GOTO(avctx, s->cpe, sizeof(ChannelElement) * s->chan_map[0], alloc_fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail);
      FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + AV_INPUT_BUFFER_PADDING_SIZE, alloc_fail);
  
      for(ch = 0; ch < s->channels; ch++)
@@@ -888,11 -721,6 +888,11 @@@ alloc_fail
      return AVERROR(ENOMEM);
  }
  
 +static av_cold void aac_encode_init_tables(void)
 +{
 +    ff_aac_tableinit();
 +}
 +
  static av_cold int aac_encode_init(AVCodecContext *avctx)
  {
      AACEncContext *s = avctx->priv_data;
      uint8_t grouping[AAC_MAX_CHANNELS];
      int lengths[2];
  
 +    s->channels = avctx->channels;
 +    s->chan_map = aac_chan_configs[s->channels-1];
 +    s->random_state = 0x1f2e3d4c;
 +    s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
 +    avctx->extradata_size = 5;
      avctx->frame_size = 1024;
 +    avctx->initial_padding = 1024;
 +    avctx->bit_rate = (int)FFMIN(
 +        6144 * s->channels / 1024.0 * avctx->sample_rate,
 +        avctx->bit_rate);
 +    avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
 +                     avctx->profile;
  
      for (i = 0; i < 16; i++)
          if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])
              break;
 +    s->samplerate_index = i;
  
 -    s->channels = avctx->channels;
 -
 -    ERROR_IF(i == 16,
 +    ERROR_IF(s->samplerate_index == 16 ||
 +             s->samplerate_index >= ff_aac_swb_size_1024_len ||
 +             s->samplerate_index >= ff_aac_swb_size_128_len,
               "Unsupported sample rate %d\n", avctx->sample_rate);
 -    ERROR_IF(s->channels > AAC_MAX_CHANNELS,
 +    ERROR_IF(s->channels > AAC_MAX_CHANNELS || s->channels == 7,
               "Unsupported number of channels: %d\n", s->channels);
 -    ERROR_IF(avctx->profile != FF_PROFILE_UNKNOWN && avctx->profile != FF_PROFILE_AAC_LOW,
 -             "Unsupported profile %d\n", avctx->profile);
 -    ERROR_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
 -             "Too many bits %f > %d per frame requested\n",
 +    WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
-              "Too many bits per frame requested, clamping to max\n");
++             "Too many bits %f > %d per frame requested, clamping to max\n",
+              1024.0 * avctx->bit_rate / avctx->sample_rate,
+              6144 * s->channels);
  
 -    s->samplerate_index = i;
 -
 -    s->chan_map = aac_chan_configs[s->channels-1];
 +    for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
 +        if (avctx->profile == aacenc_profiles[i])
 +            break;
 +    ERROR_IF(i == FF_ARRAY_ELEMS(aacenc_profiles),
 +             "Unsupported encoding profile: %d\n", avctx->profile);
 +    if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
 +        avctx->profile = FF_PROFILE_AAC_LOW;
 +        ERROR_IF(s->options.pred,
 +                 "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
 +        ERROR_IF(s->options.ltp,
 +                 "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
 +        WARN_IF(s->options.pns,
 +                "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
 +        s->options.pns = 0;
 +    } else if (avctx->profile == FF_PROFILE_AAC_LTP) {
 +        s->options.ltp = 1;
 +        ERROR_IF(s->options.pred,
 +                 "Main prediction unavailable in the \"aac_ltp\" profile\n");
 +    } else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
 +        s->options.pred = 1;
 +        ERROR_IF(s->options.ltp,
 +                 "LTP prediction unavailable in the \"aac_main\" profile\n");
 +    } else if (s->options.ltp) {
 +        avctx->profile = FF_PROFILE_AAC_LTP;
 +        WARN_IF(1,
 +                "Chainging profile to \"aac_ltp\"\n");
 +        ERROR_IF(s->options.pred,
 +                 "Main prediction unavailable in the \"aac_ltp\" profile\n");
 +    } else if (s->options.pred) {
 +        avctx->profile = FF_PROFILE_AAC_MAIN;
 +        WARN_IF(1,
 +                "Chainging profile to \"aac_main\"\n");
 +        ERROR_IF(s->options.ltp,
 +                 "LTP prediction unavailable in the \"aac_main\" profile\n");
 +    }
 +    s->profile = avctx->profile;
 +    s->coder = &ff_aac_coders[s->options.coder];
 +
 +    if (s->options.coder != AAC_CODER_TWOLOOP) {
 +        ERROR_IF(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL,
 +                 "Coders other than twoloop require -strict -2 and some may be removed in the future\n");
 +        WARN_IF(s->options.coder == AAC_CODER_FAAC,
 +                "The FAAC-like coder will be removed in the near future, please use twoloop!\n");
 +        s->options.intensity_stereo = 0;
 +        s->options.pns = 0;
 +    }
  
      if ((ret = dsp_init(avctx, s)) < 0)
          goto fail;
      if ((ret = alloc_buffers(avctx, s)) < 0)
          goto fail;
  
 -    avctx->extradata_size = 5;
      put_audio_specific_config(avctx);
  
 -    sizes[0]   = swb_size_1024[i];
 -    sizes[1]   = swb_size_128[i];
 -    lengths[0] = ff_aac_num_swb_1024[i];
 -    lengths[1] = ff_aac_num_swb_128[i];
 +    sizes[0]   = ff_aac_swb_size_1024[s->samplerate_index];
 +    sizes[1]   = ff_aac_swb_size_128[s->samplerate_index];
 +    lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
 +    lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
      for (i = 0; i < s->chan_map[0]; i++)
          grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
      if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
                             s->chan_map[0], grouping)) < 0)
          goto fail;
      s->psypp = ff_psy_preprocess_init(avctx);
 -    s->coder = &ff_aac_coders[2];
 -
 -    s->lambda = avctx->global_quality ? avctx->global_quality : 120;
 +    ff_lpc_init(&s->lpc, 2*avctx->frame_size, TNS_MAX_ORDER, FF_LPC_TYPE_LEVINSON);
  
 -    ff_aac_tableinit();
 +    if (HAVE_MIPSDSP)
 +        ff_aac_coder_init_mips(s);
  
 -    for (i = 0; i < 428; i++)
 -        ff_aac_pow34sf_tab[i] = sqrt(ff_aac_pow2sf_tab[i] * sqrt(ff_aac_pow2sf_tab[i]));
 +    if ((ret = ff_thread_once(&aac_table_init, &aac_encode_init_tables)) != 0)
 +        return AVERROR_UNKNOWN;
  
 -    avctx->initial_padding = 1024;
      ff_af_queue_init(avctx, &s->afq);
  
      return 0;
@@@ -1011,17 -791,10 +1013,17 @@@ fail
  
  #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
  static const AVOption aacenc_options[] = {
 -    {"stereo_mode", "Stereo coding method", offsetof(AACEncContext, options.stereo_mode), AV_OPT_TYPE_INT, {.i64 = 0}, -1, 1, AACENC_FLAGS, "stereo_mode"},
 -        {"auto",     "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.i64 = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
 -        {"ms_off",   "Disable Mid/Side coding", 0, AV_OPT_TYPE_CONST, {.i64 =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
 -        {"ms_force", "Force Mid/Side for the whole frame if possible", 0, AV_OPT_TYPE_CONST, {.i64 =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
 +    {"aac_coder", "Coding algorithm", offsetof(AACEncContext, options.coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, -1, AAC_CODER_NB-1, AACENC_FLAGS, "coder"},
 +        {"faac",     "FAAC-inspired method",      0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAAC},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 +        {"anmr",     "ANMR method",               0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 +        {"twoloop",  "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 +        {"fast",     "Constant quantizer",        0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
 +    {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
 +    {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
 +    {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
 +    {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
 +    {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
 +    {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
      {NULL}
  };
  
@@@ -1041,9 -814,8 +1043,9 @@@ AVCodec ff_aac_encoder = 
      .init           = aac_encode_init,
      .encode2        = aac_encode_frame,
      .close          = aac_encode_end,
 -    .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY |
 -                      AV_CODEC_CAP_EXPERIMENTAL,
 +    .supported_samplerates = mpeg4audio_sample_rates,
 +    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 +    .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
                                                       AV_SAMPLE_FMT_NONE },
      .priv_class     = &aacenc_class,