Merge commit '3d3cf6745e2a5dc9c377244454c3186d75b177fa'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 26 Nov 2012 14:15:02 +0000 (15:15 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 26 Nov 2012 14:15:02 +0000 (15:15 +0100)
* commit '3d3cf6745e2a5dc9c377244454c3186d75b177fa':
  aacdec: use float planar sample format for output

Conflicts:
libavcodec/aacdec.c
libavcodec/aacsbr.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/aac.h
libavcodec/aacdec.c
libavcodec/aacenc.c
libavcodec/aacsbr.c

diff --combined libavcodec/aac.h
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
   * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
   *
 - * 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
   */
  
@@@ -236,9 -236,10 +236,10 @@@ typedef struct SingleChannelElement 
      uint8_t zeroes[128];                            ///< band is not coded (used by encoder)
      DECLARE_ALIGNED(32, float,   coeffs)[1024];     ///< coefficients for IMDCT
      DECLARE_ALIGNED(32, float,   saved)[1024];      ///< overlap
-     DECLARE_ALIGNED(32, float,   ret)[2048];        ///< PCM output
+     DECLARE_ALIGNED(32, float,   ret_buf)[2048];    ///< PCM output buffer
      DECLARE_ALIGNED(16, float,   ltp_state)[3072];  ///< time signal for LTP
      PredictorState predictor_state[MAX_PREDICTORS];
+     float *ret;                                     ///< PCM output
  } SingleChannelElement;
  
  /**
@@@ -297,25 -298,15 +298,25 @@@ typedef struct AACContext 
      /** @} */
  
      /**
-      * @name Members used for output interleaving
+      * @name Members used for output
       * @{
       */
-     float *output_data[MAX_CHANNELS];                 ///< Points to each element's 'ret' buffer (PCM output).
+     SingleChannelElement *output_element[MAX_CHANNELS]; ///< Points to each SingleChannelElement
      /** @} */
  
 +
 +    /**
 +     * @name Japanese DTV specific extension
 +     * @{
 +     */
 +    int enable_jp_dmono; ///< enable japanese DTV specific 'dual mono'
 +    int dmono_mode;      ///< select the channel to decode in dual mono.
 +    /** @} */
 +
      DECLARE_ALIGNED(32, float, temp)[128];
  
      OutputConfiguration oc[2];
 +    int warned_num_aac_frames;
  } AACContext;
  
  #endif /* AVCODEC_AAC_H */
diff --combined libavcodec/aacdec.c
@@@ -7,20 -7,20 +7,20 @@@
   * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
   * Copyright (c) 2010      Janne Grunau <janne-libav@jannau.net>
   *
 - * 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
   */
  
  static VLC vlc_scalefactors;
  static VLC vlc_spectral[11];
  
 -static const char overread_err[] = "Input buffer exhausted before END element found\n";
 +#define overread_err "Input buffer exhausted before END element found\n"
  
  static int count_channels(uint8_t (*layout)[3], int tags)
  {
  /**
   * Check for the channel element in the current channel position configuration.
   * If it exists, make sure the appropriate element is allocated and map the
 - * channel order to match the internal Libav channel layout.
 + * channel order to match the internal FFmpeg channel layout.
   *
   * @param   che_pos current channel position configuration
   * @param   type channel element type
@@@ -149,14 -149,10 +149,14 @@@ static av_cold int che_configure(AACCon
              ff_aac_sbr_ctx_init(ac, &ac->che[type][id]->sbr);
          }
          if (type != TYPE_CCE) {
-             ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;
 +            if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
 +                av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
 +                return AVERROR_INVALIDDATA;
 +            }
+             ac->output_element[(*channels)++] = &ac->che[type][id]->ch[0];
              if (type == TYPE_CPE ||
                  (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
-                 ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;
+                 ac->output_element[(*channels)++] = &ac->che[type][id]->ch[1];
              }
          }
      } else {
      return 0;
  }
  
+ static int frame_configure_elements(AVCodecContext *avctx)
+ {
+     AACContext *ac = avctx->priv_data;
+     int type, id, ch, ret;
+     /* set channel pointers to internal buffers by default */
+     for (type = 0; type < 4; type++) {
+         for (id = 0; id < MAX_ELEM_ID; id++) {
+             ChannelElement *che = ac->che[type][id];
+             if (che) {
+                 che->ch[0].ret = che->ch[0].ret_buf;
+                 che->ch[1].ret = che->ch[1].ret_buf;
+             }
+         }
+     }
+     /* get output buffer */
+     ac->frame.nb_samples = 2048;
+     if ((ret = avctx->get_buffer(avctx, &ac->frame)) < 0) {
+         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+         return ret;
+     }
+     /* map output channel pointers to AVFrame data */
+     for (ch = 0; ch < avctx->channels; ch++) {
+         if (ac->output_element[ch])
+             ac->output_element[ch]->ret = (float *)ac->frame.extended_data[ch];
+     }
+     return 0;
+ }
  struct elem_to_channel {
      uint64_t av_position;
      uint8_t syn_ele;
@@@ -382,8 -410,8 +414,8 @@@ static void pop_output_configuration(AA
   * @return  Returns error status. 0 - OK, !0 - error
   */
  static int output_configure(AACContext *ac,
-                                     uint8_t layout_map[MAX_ELEM_ID*4][3], int tags,
-                             enum OCStatus oc_type)
+                             uint8_t layout_map[MAX_ELEM_ID*4][3], int tags,
+                             enum OCStatus oc_type, int get_new_frame)
  {
      AVCodecContext *avctx = ac->avctx;
      int i, channels = 0, ret;
      }
  
      memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
 -    avctx->channel_layout = ac->oc[1].channel_layout = layout;
 +    if (layout) avctx->channel_layout = layout;
 +    ac->oc[1].channel_layout = layout;
      avctx->channels = ac->oc[1].channels = channels;
      ac->oc[1].status = oc_type;
  
+     if (get_new_frame) {
+         if ((ret = frame_configure_elements(ac->avctx)) < 0)
+             return ret;
+     }
      return 0;
  }
  
 +static void flush(AVCodecContext *avctx)
 +{
 +    AACContext *ac= avctx->priv_data;
 +    int type, i, j;
 +
 +    for (type = 3; type >= 0; type--) {
 +        for (i = 0; i < MAX_ELEM_ID; i++) {
 +            ChannelElement *che = ac->che[type][i];
 +            if (che) {
 +                for (j = 0; j <= 1; j++) {
 +                    memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
 +                }
 +            }
 +        }
 +    }
 +}
 +
  /**
   * Set up channel positions based on a default channel configuration
   * as specified in table 1.17.
@@@ -475,13 -490,11 +512,13 @@@ static ChannelElement *get_che(AACConte
          int layout_map_tags;
          push_output_configuration(ac);
  
 +        av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
 +
          if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
                                         2) < 0)
              return NULL;
          if (output_configure(ac, layout_map, layout_map_tags,
-                              OC_TRIAL_FRAME) < 0)
+                              OC_TRIAL_FRAME, 1) < 0)
              return NULL;
  
          ac->oc[1].m4ac.chan_config = 2;
          int layout_map_tags;
          push_output_configuration(ac);
  
 +        av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
 +
          if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
                                         1) < 0)
              return NULL;
          if (output_configure(ac, layout_map, layout_map_tags,
-                              OC_TRIAL_FRAME) < 0)
+                              OC_TRIAL_FRAME, 1) < 0)
              return NULL;
  
          ac->oc[1].m4ac.chan_config = 1;
@@@ -573,8 -584,6 +610,8 @@@ static void decode_channel_map(uint8_t 
          case AAC_CHANNEL_LFE:
              syn_ele = TYPE_LFE;
              break;
 +        default:
 +            av_assert0(0);
          }
          layout_map[0][0] = syn_ele;
          layout_map[0][1] = get_bits(gb, 4);
@@@ -617,10 -626,6 +654,10 @@@ static int decode_pce(AVCodecContext *a
      if (get_bits1(gb))
          skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
  
 +    if (get_bits_left(gb) < 4 * (num_front + num_side + num_back + num_lfe + num_assoc_data + num_cc)) {
 +        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
 +        return -1;
 +    }
      decode_channel_map(layout_map       , AAC_CHANNEL_FRONT, gb, num_front);
      tags = num_front;
      decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE,  gb, num_side);
      /* comment field, first byte is length */
      comment_len = get_bits(gb, 8) * 8;
      if (get_bits_left(gb) < comment_len) {
 -        av_log(avctx, AV_LOG_ERROR, overread_err);
 +        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
          return -1;
      }
      skip_bits_long(gb, comment_len);
@@@ -692,7 -697,7 +729,7 @@@ static int decode_ga_specific_config(AA
      } else if (m4ac->sbr == 1 && m4ac->ps == -1)
          m4ac->ps = 1;
  
-     if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR)))
+     if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
          return ret;
  
      if (extension_flag) {
@@@ -737,9 -742,9 +774,9 @@@ static int decode_audio_specific_config
      GetBitContext gb;
      int i;
  
 -    av_dlog(avctx, "extradata size %d\n", avctx->extradata_size);
 -    for (i = 0; i < avctx->extradata_size; i++)
 -         av_dlog(avctx, "%02x ", avctx->extradata[i]);
 +    av_dlog(avctx, "audio specific config size %d\n", bit_size >> 3);
 +    for (i = 0; i < bit_size >> 3; i++)
 +         av_dlog(avctx, "%02x ", data[i]);
      av_dlog(avctx, "\n");
  
      init_get_bits(&gb, data, bit_size);
   *
   * @return  Returns a 32-bit pseudorandom integer
   */
 -static av_always_inline int lcg_random(int previous_val)
 +static av_always_inline int lcg_random(unsigned previous_val)
  {
      return previous_val * 1664525 + 1013904223;
  }
@@@ -834,18 -839,11 +871,11 @@@ static void reset_predictor_group(Predi
  static av_cold int aac_decode_init(AVCodecContext *avctx)
  {
      AACContext *ac = avctx->priv_data;
-     float output_scale_factor;
  
      ac->avctx = avctx;
      ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
  
-     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
-         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
-         output_scale_factor = 1.0 / 32768.0;
-     } else {
-         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
-         output_scale_factor = 1.0;
-     }
+     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
  
      if (avctx->extradata_size > 0) {
          if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
                  &layout_map_tags, ac->oc[1].m4ac.chan_config);
              if (!ret)
                  output_configure(ac, layout_map, layout_map_tags,
-                                  OC_GLOBAL_HDR);
+                                  OC_GLOBAL_HDR, 0);
              else if (avctx->err_recognition & AV_EF_EXPLODE)
                  return AVERROR_INVALIDDATA;
          }
                      ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
                      352);
  
-     ff_mdct_init(&ac->mdct,       11, 1, output_scale_factor/1024.0);
-     ff_mdct_init(&ac->mdct_small,  8, 1, output_scale_factor/128.0);
-     ff_mdct_init(&ac->mdct_ltp,   11, 0, -2.0/output_scale_factor);
+     ff_mdct_init(&ac->mdct,       11, 1, 1.0 / (32768.0 * 1024.0));
+     ff_mdct_init(&ac->mdct_small,  8, 1, 1.0 / (32768.0 * 128.0));
+     ff_mdct_init(&ac->mdct_ltp,   11, 0, -2.0 * 32768.0);
      // window initialization
      ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
      ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
@@@ -939,7 -937,7 +969,7 @@@ static int skip_data_stream_element(AAC
          align_get_bits(gb);
  
      if (get_bits_left(gb) < 8 * count) {
 -        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 +        av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
          return -1;
      }
      skip_bits_long(gb, 8 * count);
@@@ -1020,11 -1018,11 +1050,11 @@@ static int decode_ics_info(AACContext *
          if (ics->predictor_present) {
              if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
                  if (decode_prediction(ac, ics, gb)) {
 -                    return AVERROR_INVALIDDATA;
 +                    goto fail;
                  }
              } else if (ac->oc[1].m4ac.object_type == AOT_AAC_LC) {
                  av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
 -                return AVERROR_INVALIDDATA;
 +                goto fail;
              } else {
                  if ((ics->ltp.present = get_bits(gb, 1)))
                      decode_ltp(&ics->ltp, gb, ics->max_sfb);
          av_log(ac->avctx, AV_LOG_ERROR,
                 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
                 ics->max_sfb, ics->num_swb);
 -        return AVERROR_INVALIDDATA;
 +        goto fail;
      }
  
      return 0;
 +fail:
 +    ics->max_sfb = 0;
 +    return AVERROR_INVALIDDATA;
  }
  
  /**
@@@ -1073,7 -1068,7 +1103,7 @@@ static int decode_band_types(AACContex
                  sect_len_incr = get_bits(gb, bits);
                  sect_end += sect_len_incr;
                  if (get_bits_left(gb) < 0) {
 -                    av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 +                    av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
                      return -1;
                  }
                  if (sect_end > ics->max_sfb) {
@@@ -1241,7 -1236,7 +1271,7 @@@ static void decode_mid_side_stereo(Chan
          for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
              cpe->ms_mask[idx] = get_bits1(gb);
      } else if (ms_present == 2) {
 -        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
 +        memset(cpe->ms_mask, 1,  sizeof(cpe->ms_mask[0]) * cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb);
      }
  }
  
@@@ -1944,32 -1939,6 +1974,32 @@@ static int decode_dynamic_range(Dynamic
      return n;
  }
  
 +static int decode_fill(AACContext *ac, GetBitContext *gb, int len) {
 +    uint8_t buf[256];
 +    int i, major, minor;
 +
 +    if (len < 13+7*8)
 +        goto unknown;
 +
 +    get_bits(gb, 13); len -= 13;
 +
 +    for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
 +        buf[i] = get_bits(gb, 8);
 +
 +    buf[i] = 0;
 +    if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
 +        av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
 +
 +    if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
 +        ac->avctx->internal->skip_samples = 1024;
 +    }
 +
 +unknown:
 +    skip_bits_long(gb, len);
 +
 +    return 0;
 +}
 +
  /**
   * Decode extension data (incomplete); reference: table 4.51.
   *
@@@ -2001,7 -1970,7 +2031,7 @@@ static int decode_extension_payload(AAC
              ac->oc[1].m4ac.sbr = 1;
              ac->oc[1].m4ac.ps = 1;
              output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
-                              ac->oc[1].status);
+                              ac->oc[1].status, 1);
          } else {
              ac->oc[1].m4ac.sbr = 1;
          }
          res = decode_dynamic_range(&ac->che_drc, gb);
          break;
      case EXT_FILL:
 +        decode_fill(ac, gb, 8 * cnt - 4);
 +        break;
      case EXT_FILL_DATA:
      case EXT_DATA_ELEMENT:
      default:
@@@ -2035,7 -2002,7 +2065,7 @@@ static void apply_tns(float coef[1024]
      int w, filt, m, i;
      int bottom, top, order, start, end, size, inc;
      float lpc[TNS_MAX_ORDER];
 -    float tmp[TNS_MAX_ORDER];
 +    float tmp[TNS_MAX_ORDER+1];
  
      for (w = 0; w < ics->num_windows; w++) {
          bottom = ics->num_swb;
@@@ -2382,11 -2349,9 +2412,11 @@@ static int parse_adts_frame_header(AACC
  
      size = avpriv_aac_parse_header(gb, &hdr_info);
      if (size > 0) {
 -        if (hdr_info.num_aac_frames != 1) {
 +        if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
 +            // This is 2 for "VLB " audio in NSV files.
 +            // See samples/nsv/vlb_audio.
              av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame", 0);
 -            return AVERROR_PATCHWELCOME;
 +            ac->warned_num_aac_frames = 1;
          }
          push_output_configuration(ac);
          if (hdr_info.chan_config) {
                      &layout_map_tags, hdr_info.chan_config))
                  return -7;
              if (output_configure(ac, layout_map, layout_map_tags,
-                                  FFMAX(ac->oc[1].status, OC_TRIAL_FRAME)))
+                                  FFMAX(ac->oc[1].status, OC_TRIAL_FRAME), 0))
                  return -7;
          } else {
              ac->oc[1].m4ac.chan_config = 0;
 +            /**
 +             * dual mono frames in Japanese DTV can have chan_config 0
 +             * WITHOUT specifying PCE.
 +             *  thus, set dual mono as default.
 +             */
++#if 0
 +            if (ac->enable_jp_dmono && ac->oc[0].status == OC_NONE) {
 +                layout_map_tags = 2;
 +                layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
 +                layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
 +                layout_map[0][1] = 0;
 +                layout_map[1][1] = 1;
 +                if (output_configure(ac, layout_map, layout_map_tags,
 +                                     OC_TRIAL_FRAME))
 +                    return -7;
 +            }
++#endif
          }
          ac->oc[1].m4ac.sample_rate     = hdr_info.sample_rate;
          ac->oc[1].m4ac.sampling_index  = hdr_info.sampling_index;
  }
  
  static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
 -                                int *got_frame_ptr, GetBitContext *gb)
 +                                int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
  {
      AACContext *ac = avctx->priv_data;
      ChannelElement *che = NULL, *che_prev = NULL;
      enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
      int err, elem_id;
      int samples = 0, multiplier, audio_found = 0, pce_found = 0;
 +    int is_dmono, sce_count = 0;
 +    float *tmp = NULL;
  
      if (show_bits(gb, 12) == 0xfff) {
          if (parse_adts_frame_header(ac, gb) < 0) {
          }
      }
  
+     if (frame_configure_elements(avctx) < 0) {
+         err = -1;
+         goto fail;
+     }
      ac->tags_mapped = 0;
      // parse
      while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
          case TYPE_SCE:
              err = decode_ics(ac, &che->ch[0], gb, 0, 0);
              audio_found = 1;
 +            sce_count++;
              break;
  
          case TYPE_CPE:
                         "Not evaluating a further program_config_element as this construct is dubious at best.\n");
                  pop_output_configuration(ac);
              } else {
-                 err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE);
+                 err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
 +                if (!err)
 +                    ac->oc[1].m4ac.chan_config = 0;
                  pce_found = 1;
              }
              break;
              if (elem_id == 15)
                  elem_id += get_bits(gb, 8) - 1;
              if (get_bits_left(gb) < 8 * elem_id) {
 -                    av_log(avctx, AV_LOG_ERROR, overread_err);
 +                    av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
                      err = -1;
                      goto fail;
              }
  
      multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
      samples <<= multiplier;
--
++#if 0
 +    /* for dual-mono audio (SCE + SCE) */
 +    is_dmono = ac->enable_jp_dmono && sce_count == 2 &&
 +               ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
 +
 +    if (is_dmono) {
 +        if (ac->dmono_mode == 0) {
 +            tmp = ac->output_data[1];
 +            ac->output_data[1] = ac->output_data[0];
 +        } else if (ac->dmono_mode == 1) {
 +            tmp = ac->output_data[0];
 +            ac->output_data[0] = ac->output_data[1];
 +        }
 +    }
++#endif
      if (samples) {
-         /* get output buffer */
          ac->frame.nb_samples = samples;
-         if ((err = avctx->get_buffer(avctx, &ac->frame)) < 0) {
-             av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-             err = -1;
-             goto fail;
-         }
-         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT)
-             ac->fmt_conv.float_interleave((float *)ac->frame.data[0],
-                                           (const float **)ac->output_data,
-                                           samples, avctx->channels);
-         else
-             ac->fmt_conv.float_to_int16_interleave((int16_t *)ac->frame.data[0],
-                                                    (const float **)ac->output_data,
-                                                    samples, avctx->channels);
          *(AVFrame *)data = ac->frame;
      }
      *got_frame_ptr = !!samples;
--
++#if 0
 +    if (is_dmono) {
 +        if (ac->dmono_mode == 0)
 +            ac->output_data[1] = tmp;
 +        else if (ac->dmono_mode == 1)
 +            ac->output_data[0] = tmp;
 +    }
++#endif
      if (ac->oc[1].status && audio_found) {
          avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
          avctx->frame_size = samples;
          ac->oc[1].status = OC_LOCKED;
      }
  
 +    if (multiplier) {
 +        int side_size;
 +        uint32_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
 +        if (side && side_size>=4)
 +            AV_WL32(side, 2*AV_RL32(side));
 +    }
      return 0;
  fail:
      pop_output_configuration(ac);
@@@ -2628,12 -2535,8 +2649,12 @@@ static int aac_decode_frame(AVCodecCont
      const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
                                         AV_PKT_DATA_NEW_EXTRADATA,
                                         &new_extradata_size);
 +    int jp_dualmono_size;
 +    const uint8_t *jp_dualmono   = av_packet_get_side_data(avpkt,
 +                                       AV_PKT_DATA_JP_DUALMONO,
 +                                       &jp_dualmono_size);
  
 -    if (new_extradata) {
 +    if (new_extradata && 0) {
          av_free(avctx->extradata);
          avctx->extradata = av_mallocz(new_extradata_size +
                                        FF_INPUT_BUFFER_PADDING_SIZE);
          }
      }
  
 +    ac->enable_jp_dmono = !!jp_dualmono;
 +    ac->dmono_mode = 0;
 +    if (jp_dualmono && jp_dualmono_size > 0)
 +        ac->dmono_mode = *jp_dualmono;
 +
      init_get_bits(&gb, buf, buf_size * 8);
  
 -    if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb)) < 0)
 +    if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt)) < 0)
          return err;
  
      buf_consumed = (get_bits_count(&gb) + 7) >> 3;
@@@ -2692,7 -2590,7 +2713,7 @@@ static av_cold int aac_decode_close(AVC
  
  struct LATMContext {
      AACContext      aac_ctx;             ///< containing AACContext
 -    int             initialized;         ///< initilized after a valid extradata was seen
 +    int             initialized;         ///< initialized after a valid extradata was seen
  
      // parser data
      int             audio_mux_version_A; ///< LATM syntax version
@@@ -2737,15 -2635,10 +2758,15 @@@ static int latm_decode_audio_specific_c
      if (bits_consumed < 0)
          return AVERROR_INVALIDDATA;
  
 -    if (ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
 +    if (!latmctx->initialized ||
 +        ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
          ac->oc[1].m4ac.chan_config != m4ac.chan_config) {
  
 -        av_log(avctx, AV_LOG_INFO, "audio config changed\n");
 +        if(latmctx->initialized) {
 +            av_log(avctx, AV_LOG_INFO, "audio config changed\n");
 +        } else {
 +            av_log(avctx, AV_LOG_INFO, "initializing latmctx\n");
 +        }
          latmctx->initialized = 0;
  
          esize = (bits_consumed+7) / 8;
@@@ -2789,9 -2682,9 +2810,9 @@@ static int read_stream_mux_config(struc
              return AVERROR_PATCHWELCOME;
          }
  
 -        // for each program (which there is only on in DVB)
 +        // for each program (which there is only one in DVB)
  
 -        // for each layer (which there is only on in DVB)
 +        // for each layer (which there is only one in DVB)
          if (get_bits(gb, 3)) {                   // numLayer
              av_log_missing_feature(latmctx->aac_ctx.avctx,
                                     "Multiple layers", 1);
@@@ -2912,7 -2805,7 +2933,7 @@@ static int latm_decode_frame(AVCodecCon
          return AVERROR_INVALIDDATA;
  
      muxlength = get_bits(&gb, 13) + 3;
 -    // not enough data, the parser should have sorted this
 +    // not enough data, the parser should have sorted this out
      if (muxlength > avpkt->size)
          return AVERROR_INVALIDDATA;
  
          return AVERROR_INVALIDDATA;
      }
  
 -    if ((err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb)) < 0)
 +    if ((err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb, avpkt)) < 0)
          return err;
  
      return muxlength;
@@@ -2970,11 -2863,10 +2991,11 @@@ AVCodec ff_aac_decoder = 
      .decode          = aac_decode_frame,
      .long_name       = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
      .sample_fmts     = (const enum AVSampleFormat[]) {
-         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
+         AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };
  
  /*
@@@ -2992,9 -2884,8 +3013,9 @@@ AVCodec ff_aac_latm_decoder = 
      .decode          = latm_decode_frame,
      .long_name       = NULL_IF_CONFIG_SMALL("AAC LATM (Advanced Audio Coding LATM syntax)"),
      .sample_fmts     = (const enum AVSampleFormat[]) {
-         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
+         AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };
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
   */
  
@@@ -146,7 -146,7 +146,7 @@@ static const uint8_t aac_chan_configs[6
  };
  
  /**
 - * Table to remap channels from Libav's default order to AAC order.
 + * Table to remap channels from libavcodec's default order to AAC order.
   */
  static const uint8_t aac_chan_maps[AAC_MAX_CHANNELS][AAC_MAX_CHANNELS] = {
      { 0 },
@@@ -191,7 -191,7 +191,7 @@@ WINDOW_FUNC(only_long
  {
      const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
      const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
--    float *out = sce->ret;
++    float *out = sce->ret_buf;
  
      fdsp->vector_fmul       (out,        audio,        lwindow, 1024);
      dsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
@@@ -201,7 -201,7 +201,7 @@@ WINDOW_FUNC(long_start
  {
      const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
      const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
--    float *out = sce->ret;
++    float *out = sce->ret_buf;
  
      fdsp->vector_fmul(out, audio, lwindow, 1024);
      memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
@@@ -213,7 -213,7 +213,7 @@@ WINDOW_FUNC(long_stop
  {
      const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
      const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
--    float *out = sce->ret;
++    float *out = sce->ret_buf;
  
      memset(out, 0, sizeof(out[0]) * 448);
      fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
@@@ -226,7 -226,7 +226,7 @@@ WINDOW_FUNC(eight_short
      const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
      const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
      const float *in = audio + 448;
--    float *out = sce->ret;
++    float *out = sce->ret_buf;
      int w;
  
      for (w = 0; w < 8; w++) {
@@@ -251,7 -251,7 +251,7 @@@ static void apply_window_and_mdct(AACEn
                                    float *audio)
  {
      int i;
--    float *output = sce->ret;
++    float *output = sce->ret_buf;
  
      apply_window[sce->ics.window_sequence[0]](&s->dsp, &s->fdsp, sce, audio);
  
@@@ -385,7 -385,8 +385,7 @@@ static void encode_scale_factors(AVCode
          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");
 +                av_assert0(diff >= 0 && diff <= 120);
                  off = sce->sf_idx[w*16 + i];
                  put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
              }
@@@ -478,7 -479,7 +478,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)
  {
@@@ -571,10 -572,11 +571,10 @@@ static int aac_encode_frame(AVCodecCont
          }
          start_ch += chans;
      }
 -    if ((ret = ff_alloc_packet(avpkt, 768 * s->channels))) {
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels))) {
          av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
          return ret;
      }
 -
      do {
          int frame_bits;
  
@@@ -776,7 -778,7 +776,7 @@@ static av_cold int aac_encode_init(AVCo
      if (ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths, s->chan_map[0], grouping))
          goto fail;
      s->psypp = ff_psy_preprocess_init(avctx);
 -    s->coder = &ff_aac_coders[2];
 +    s->coder = &ff_aac_coders[s->options.aac_coder];
  
      s->lambda = avctx->global_quality ? avctx->global_quality : 120;
  
@@@ -800,7 -802,6 +800,7 @@@ static const AVOption aacenc_options[] 
          {"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", "", offsetof(AACEncContext, options.aac_coder), AV_OPT_TYPE_INT, {.i64 = 2}, 0, AAC_CODER_NB-1, AACENC_FLAGS},
      {NULL}
  };
  
@@@ -811,13 -812,6 +811,13 @@@ static const AVClass aacenc_class = 
      LIBAVUTIL_VERSION_INT,
  };
  
 +/* duplicated from avpriv_mpeg4audio_sample_rates to avoid shared build
 + * failures */
 +static const int mpeg4audio_sample_rates[16] = {
 +    96000, 88200, 64000, 48000, 44100, 32000,
 +    24000, 22050, 16000, 12000, 11025, 8000, 7350
 +};
 +
  AVCodec ff_aac_encoder = {
      .name           = "aac",
      .type           = AVMEDIA_TYPE_AUDIO,
      .init           = aac_encode_init,
      .encode2        = aac_encode_frame,
      .close          = aac_encode_end,
 +    .supported_samplerates = mpeg4audio_sample_rates,
      .capabilities   = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY |
                        CODEC_CAP_EXPERIMENTAL,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
diff --combined libavcodec/aacsbr.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
   * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
   *
 - * 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
   */
  
  #include "aacps.h"
  #include "sbrdsp.h"
  #include "libavutil/libm.h"
 +#include "libavutil/avassert.h"
  
  #include <stdint.h>
  #include <float.h>
 +#include <math.h>
  
  #define ENVELOPE_ADJUSTMENT_OFFSET 2
  #define NOISE_FLOOR_OFFSET 6.0f
@@@ -142,9 -140,6 +142,8 @@@ static void sbr_turnoff(SpectralBandRep
  
  av_cold void ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr)
  {
-     float mdct_scale;
 +    if(sbr->mdct.mdct_bits)
 +        return;
      sbr->kx[0] = sbr->kx[1];
      sbr_turnoff(sbr);
      sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
      /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
       * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
       * and scale back down at synthesis. */
-     mdct_scale = ac->avctx->sample_fmt == AV_SAMPLE_FMT_FLT ? 32768.0f : 1.0f;
-     ff_mdct_init(&sbr->mdct,     7, 1, 1.0 / (64 * mdct_scale));
-     ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * mdct_scale);
+     ff_mdct_init(&sbr->mdct,     7, 1, 1.0 / (64 * 32768.0));
+     ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * 32768.0);
      ff_ps_ctx_init(&sbr->ps);
      ff_sbrdsp_init(&sbr->dsp);
  }
@@@ -340,6 -334,9 +338,6 @@@ static int sbr_make_f_master(AACContex
      } else
          temp = 5000;
  
 -    start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
 -    stop_min  = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
 -
      switch (sbr->sample_rate) {
      case 16000:
          sbr_offset_ptr = sbr_offset[0];
          return -1;
      }
  
 +    start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
 +    stop_min  = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
 +
      sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
  
      if (spectrum->bs_stop_freq < 14) {
@@@ -555,7 -549,7 +553,7 @@@ static int sbr_hf_calc_npatches(AACCont
              k = sbr->n_master;
      } while (sb != sbr->kx[1] + sbr->m[1]);
  
 -    if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
 +    if (sbr->num_patches > 1 && sbr->patch_num_subbands[sbr->num_patches-1] < 3)
          sbr->num_patches--;
  
      return 0;
@@@ -749,7 -743,7 +747,7 @@@ static int read_sbr_grid(AACContext *ac
          if (ch_data->bs_frame_class == FIXFIX) {
              idx = ch_data->bs_num_env >> 1;
          } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
 -            idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
 +            idx = ch_data->bs_num_env - FFMAX((int)bs_pointer - 1, 1);
          } else { // VARFIX
              if (!bs_pointer)
                  idx = 1;
@@@ -933,9 -927,7 +931,9 @@@ static void read_sbr_extension(AACConte
          }
          break;
      default:
 -        av_log_missing_feature(ac->avctx, "Reserved SBR extensions", 1);
 +        // some files contain 0-padding
 +        if (bs_extension_id || *num_bits_left > 16 || show_bits(gb, *num_bits_left))
 +            av_log_missing_feature(ac->avctx, "Reserved SBR extensions", 1);
          skip_bits_long(gb, *num_bits_left); // bs_fill_bits
          *num_bits_left = 0;
          break;
@@@ -1578,6 -1570,10 +1576,6 @@@ static void sbr_hf_assemble(float Y1[38
          0.11516383427084,
          0.03183050093751,
      };
 -    static const int8_t phi[2][4] = {
 -        {  1,  0, -1,  0}, // real
 -        {  0,  1,  0, -1}, // imaginary
 -    };
      float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
      int indexnoise = ch_data->f_indexnoise;
      int indexsine  = ch_data->f_indexsine;
  
      for (e = 0; e < ch_data->bs_num_env; e++) {
          for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
 -            int phi_sign = (1 - 2*(kx & 1));
              LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
              LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
              float *g_filt, *q_filt;
                                                     q_filt, indexnoise,
                                                     kx, m_max);
              } else {
 -                for (m = 0; m < m_max; m++) {
 -                    Y1[i][m + kx][0] +=
 -                        sbr->s_m[e][m] * phi[0][indexsine];
 -                    Y1[i][m + kx][1] +=
 -                        sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
 -                    phi_sign = -phi_sign;
 +                int idx = indexsine&1;
 +                int A = (1-((indexsine+(kx & 1))&2));
 +                int B = (A^(-idx)) + idx;
 +                float *out = &Y1[i][kx][idx];
 +                float *in  = sbr->s_m[e];
 +                for (m = 0; m+1 < m_max; m+=2) {
 +                    out[2*m  ] += in[m  ] * A;
 +                    out[2*m+2] += in[m+1] * B;
                  }
 +                if(m_max&1)
 +                    out[2*m  ] += in[m  ] * A;
              }
              indexnoise = (indexnoise + m_max) & 0x1ff;
              indexsine = (indexsine + 1) & 3;