Merge commit '6d8629aac13692447b54eac795bf74007ebf8987'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 28 Jun 2013 08:00:51 +0000 (10:00 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 28 Jun 2013 08:00:51 +0000 (10:00 +0200)
* commit '6d8629aac13692447b54eac795bf74007ebf8987':
  aac: K&R formatting cosmetics

Conflicts:
libavcodec/aacdec.c

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

diff --combined libavcodec/aacdec.c
index cd7bbb0adb81126c1ceb6b2733ea99851aea5d5c,ad95c2e28714ee323df5557d1e4b15807d1ef754..59b724c59c17fd30df60131cfe10e976202f0bb2
@@@ -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
   */
  
@@@ -80,7 -80,6 +80,7 @@@
   */
  
  #include "libavutil/float_dsp.h"
 +#include "libavutil/opt.h"
  #include "avcodec.h"
  #include "internal.h"
  #include "get_bits.h"
  
  #if ARCH_ARM
  #   include "arm/aac.h"
 +#elif ARCH_MIPS
 +#   include "mips/aacdec_mips.h"
  #endif
  
  static VLC vlc_scalefactors;
  static VLC vlc_spectral[11];
  
 -static const char overread_err[] = "Input buffer exhausted before END element found\n";
 +static int output_configure(AACContext *ac,
 +                            uint8_t layout_map[MAX_ELEM_ID*4][3], int tags,
 +                            enum OCStatus oc_type, int get_new_frame);
 +
 +#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
@@@ -157,10 -150,6 +157,10 @@@ static av_cold int che_configure(AACCon
              ff_aac_sbr_ctx_init(ac, &ac->che[type][id]->sbr);
          }
          if (type != TYPE_CCE) {
 +            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)) {
@@@ -194,8 -183,10 +194,8 @@@ static int frame_configure_elements(AVC
      /* get output buffer */
      av_frame_unref(ac->frame);
      ac->frame->nb_samples = 2048;
 -    if ((ret = ff_get_buffer(avctx, ac->frame, 0)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +    if ((ret = ff_get_buffer(avctx, ac->frame, 0)) < 0)
          return ret;
 -    }
  
      /* map output channel pointers to AVFrame data */
      for (ch = 0; ch < avctx->channels; ch++) {
@@@ -215,28 -206,39 +215,39 @@@ struct elem_to_channel 
  
  static int assign_pair(struct elem_to_channel e2c_vec[MAX_ELEM_ID],
                         uint8_t (*layout_map)[3], int offset, uint64_t left,
-     uint64_t right, int pos)
+                        uint64_t right, int pos)
  {
      if (layout_map[offset][0] == TYPE_CPE) {
          e2c_vec[offset] = (struct elem_to_channel) {
-             .av_position = left | right, .syn_ele = TYPE_CPE,
-             .elem_id = layout_map[offset    ][1], .aac_position = pos };
+             .av_position  = left | right,
+             .syn_ele      = TYPE_CPE,
+             .elem_id      = layout_map[offset][1],
+             .aac_position = pos
+         };
          return 1;
      } else {
-         e2c_vec[offset]   = (struct elem_to_channel) {
-             .av_position = left, .syn_ele = TYPE_SCE,
-             .elem_id = layout_map[offset    ][1], .aac_position = pos };
+         e2c_vec[offset] = (struct elem_to_channel) {
+             .av_position  = left,
+             .syn_ele      = TYPE_SCE,
+             .elem_id      = layout_map[offset][1],
+             .aac_position = pos
+         };
          e2c_vec[offset + 1] = (struct elem_to_channel) {
-             .av_position = right, .syn_ele = TYPE_SCE,
-             .elem_id = layout_map[offset + 1][1], .aac_position = pos };
+             .av_position  = right,
+             .syn_ele      = TYPE_SCE,
+             .elem_id      = layout_map[offset + 1][1],
+             .aac_position = pos
+         };
          return 2;
      }
  }
  
- static int count_paired_channels(uint8_t (*layout_map)[3], int tags, int pos, int *current) {
+ static int count_paired_channels(uint8_t (*layout_map)[3], int tags, int pos,
+                                  int *current)
+ {
      int num_pos_channels = 0;
-     int first_cpe = 0;
-     int sce_parity = 0;
+     int first_cpe        = 0;
+     int sce_parity       = 0;
      int i;
      for (i = *current; i < tags; i++) {
          if (layout_map[i][2] != pos)
                  }
              }
              num_pos_channels += 2;
-             first_cpe = 1;
+             first_cpe         = 1;
          } else {
              num_pos_channels++;
              sce_parity ^= 1;
      }
      if (sce_parity &&
          ((pos == AAC_CHANNEL_FRONT && first_cpe) || pos == AAC_CHANNEL_SIDE))
-             return -1;
+         return -1;
      *current = i;
      return num_pos_channels;
  }
  static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
  {
      int i, n, total_non_cc_elements;
-     struct elem_to_channel e2c_vec[4*MAX_ELEM_ID] = {{ 0 }};
+     struct elem_to_channel e2c_vec[4 * MAX_ELEM_ID] = { { 0 } };
      int num_front_channels, num_side_channels, num_back_channels;
      uint64_t layout;
  
      i = 0;
      if (num_front_channels & 1) {
          e2c_vec[i] = (struct elem_to_channel) {
-             .av_position = AV_CH_FRONT_CENTER, .syn_ele = TYPE_SCE,
-             .elem_id = layout_map[i][1], .aac_position = AAC_CHANNEL_FRONT };
+             .av_position  = AV_CH_FRONT_CENTER,
+             .syn_ele      = TYPE_SCE,
+             .elem_id      = layout_map[i][1],
+             .aac_position = AAC_CHANNEL_FRONT
+         };
          i++;
          num_front_channels--;
      }
      }
      if (num_back_channels) {
          e2c_vec[i] = (struct elem_to_channel) {
-           .av_position = AV_CH_BACK_CENTER, .syn_ele = TYPE_SCE,
-           .elem_id = layout_map[i][1], .aac_position = AAC_CHANNEL_BACK };
+             .av_position  = AV_CH_BACK_CENTER,
+             .syn_ele      = TYPE_SCE,
+             .elem_id      = layout_map[i][1],
+             .aac_position = AAC_CHANNEL_BACK
+         };
          i++;
          num_back_channels--;
      }
  
      if (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
          e2c_vec[i] = (struct elem_to_channel) {
-           .av_position = AV_CH_LOW_FREQUENCY, .syn_ele = TYPE_LFE,
-           .elem_id = layout_map[i][1], .aac_position = AAC_CHANNEL_LFE };
+             .av_position  = AV_CH_LOW_FREQUENCY,
+             .syn_ele      = TYPE_LFE,
+             .elem_id      = layout_map[i][1],
+             .aac_position = AAC_CHANNEL_LFE
+         };
          i++;
      }
      while (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
          e2c_vec[i] = (struct elem_to_channel) {
-           .av_position = UINT64_MAX, .syn_ele = TYPE_LFE,
-           .elem_id = layout_map[i][1], .aac_position = AAC_CHANNEL_LFE };
+             .av_position  = UINT64_MAX,
+             .syn_ele      = TYPE_LFE,
+             .elem_id      = layout_map[i][1],
+             .aac_position = AAC_CHANNEL_LFE
+         };
          i++;
      }
  
      total_non_cc_elements = n = i;
      do {
          int next_n = 0;
-         for (i = 1; i < n; i++) {
-             if (e2c_vec[i-1].av_position > e2c_vec[i].av_position) {
-                 FFSWAP(struct elem_to_channel, e2c_vec[i-1], e2c_vec[i]);
+         for (i = 1; i < n; i++)
+             if (e2c_vec[i - 1].av_position > e2c_vec[i].av_position) {
+                 FFSWAP(struct elem_to_channel, e2c_vec[i - 1], e2c_vec[i]);
                  next_n = i;
              }
-         }
          n = next_n;
      } while (n > 0);
  
@@@ -412,18 -425,17 +434,19 @@@ static void pop_output_configuration(AA
          ac->oc[1] = ac->oc[0];
          ac->avctx->channels = ac->oc[1].channels;
          ac->avctx->channel_layout = ac->oc[1].channel_layout;
 +        output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
 +                         ac->oc[1].status, 0);
      }
  }
  
  /**
-  * Configure output channel order based on the current program configuration element.
+  * Configure output channel order based on the current program
+  * configuration element.
   *
   * @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,
+                             uint8_t layout_map[MAX_ELEM_ID * 4][3], int tags,
                              enum OCStatus oc_type, int get_new_frame)
  {
      AVCodecContext *avctx = ac->avctx;
      }
  
      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].channel_layout = layout;
+     avctx->channels       = ac->oc[1].channels       = channels;
      ac->oc[1].status = oc_type;
  
      if (get_new_frame) {
      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.
   * @return  Returns error status. 0 - OK, !0 - error
   */
  static int set_default_channel_config(AVCodecContext *avctx,
-                                               uint8_t (*layout_map)[3],
-                                               int *tags,
-                                               int channel_config)
+                                       uint8_t (*layout_map)[3],
+                                       int *tags,
+                                       int channel_config)
  {
      if (channel_config < 1 || channel_config > 7) {
-         av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
+         av_log(avctx, AV_LOG_ERROR,
+                "invalid default channel configuration (%d)\n",
                 channel_config);
          return -1;
      }
      *tags = tags_per_config[channel_config];
-     memcpy(layout_map, aac_channel_layout_map[channel_config-1], *tags * sizeof(*layout_map));
+     memcpy(layout_map, aac_channel_layout_map[channel_config - 1],
+            *tags * sizeof(*layout_map));
      return 0;
  }
  
  static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
  {
-     // For PCE based channel configurations map the channels solely based on tags.
+     /* For PCE based channel configurations map the channels solely based
+      * on tags. */
      if (!ac->oc[1].m4ac.chan_config) {
          return ac->tag_che_map[type][elem_id];
      }
      // Allow single CPE stereo files to be signalled with mono configuration.
-     if (!ac->tags_mapped && type == TYPE_CPE && ac->oc[1].m4ac.chan_config == 1) {
+     if (!ac->tags_mapped && type == TYPE_CPE &&
+         ac->oc[1].m4ac.chan_config == 1) {
          uint8_t layout_map[MAX_ELEM_ID*4][3];
          int layout_map_tags;
          push_output_configuration(ac);
  
-         if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
-                                        2) < 0)
 +        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, 1) < 0)
          ac->oc[1].m4ac.ps = 0;
      }
      // And vice-versa
-     if (!ac->tags_mapped && type == TYPE_SCE && ac->oc[1].m4ac.chan_config == 2) {
-         uint8_t layout_map[MAX_ELEM_ID*4][3];
+     if (!ac->tags_mapped && type == TYPE_SCE &&
+         ac->oc[1].m4ac.chan_config == 2) {
+         uint8_t layout_map[MAX_ELEM_ID * 4][3];
          int layout_map_tags;
          push_output_configuration(ac);
  
-         if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
-                                        1) < 0)
 +        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, 1) < 0)
          if (ac->oc[1].m4ac.sbr)
              ac->oc[1].m4ac.ps = -1;
      }
-     // For indexed channel configurations map the channels solely based on position.
+     /* For indexed channel configurations map the channels solely based
+      * on position. */
      switch (ac->oc[1].m4ac.chan_config) {
      case 7:
          if (ac->tags_mapped == 3 && type == TYPE_CPE) {
              return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
          }
      case 6:
-         /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
-            instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have
-            encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */
+         /* Some streams incorrectly code 5.1 audio as
+          * SCE[0] CPE[0] CPE[1] SCE[1]
+          * instead of
+          * SCE[0] CPE[0] CPE[1] LFE[0].
+          * If we seem to have encountered such a stream, transfer
+          * the LFE[0] element to the SCE[1]'s mapping */
          if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
              ac->tags_mapped++;
              return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
              return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
          }
      case 4:
-         if (ac->tags_mapped == 2 && ac->oc[1].m4ac.chan_config == 4 && type == TYPE_SCE) {
+         if (ac->tags_mapped == 2 &&
+             ac->oc[1].m4ac.chan_config == 4 &&
+             type == TYPE_SCE) {
              ac->tags_mapped++;
              return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
          }
      case 3:
      case 2:
-         if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) && type == TYPE_CPE) {
+         if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) &&
+             type == TYPE_CPE) {
              ac->tags_mapped++;
              return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
          } else if (ac->oc[1].m4ac.chan_config == 2) {
  }
  
  /**
-  * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
+  * Decode an array of 4 bit element IDs, optionally interleaved with a
+  * stereo/mono switching bit.
   *
   * @param type speaker type/position for these channels
   */
@@@ -619,8 -622,6 +655,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);
@@@ -638,7 -639,8 +674,8 @@@ static int decode_pce(AVCodecContext *a
                        uint8_t (*layout_map)[3],
                        GetBitContext *gb)
  {
-     int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
+     int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
+     int sampling_index;
      int comment_len;
      int tags;
  
  
      sampling_index = get_bits(gb, 4);
      if (m4ac->sampling_index != sampling_index)
-         av_log(avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
+         av_log(avctx, AV_LOG_WARNING,
+                "Sample rate index in program config element does not "
+                "match the sample rate index configured by the container.\n");
  
      num_front       = get_bits(gb, 4);
      num_side        = get_bits(gb, 4);
      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);
@@@ -729,7 -729,8 +768,8 @@@ static int decode_ga_specific_config(AA
          if (tags < 0)
              return tags;
      } else {
-         if ((ret = set_default_channel_config(avctx, layout_map, &tags, channel_config)))
+         if ((ret = set_default_channel_config(avctx, layout_map,
+                                               &tags, channel_config)))
              return ret;
      }
  
          case AOT_ER_AAC_LTP:
          case AOT_ER_AAC_SCALABLE:
          case AOT_ER_AAC_LD:
-             skip_bits(gb, 3);  /* aacSectionDataResilienceFlag
+             skip_bits(gb, 3);      /* aacSectionDataResilienceFlag
                                      * aacScalefactorDataResilienceFlag
                                      * aacSpectralDataResilienceFlag
                                      */
@@@ -782,20 -783,21 +822,23 @@@ static int decode_audio_specific_config
  {
      GetBitContext gb;
      int i;
 +    int ret;
  
 -    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, "%02x ", data[i]);
      av_dlog(avctx, "\n");
  
 -    init_get_bits(&gb, data, bit_size);
 +    if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
 +        return ret;
  
-     if ((i = avpriv_mpeg4audio_get_config(m4ac, data, bit_size, sync_extension)) < 0)
+     if ((i = avpriv_mpeg4audio_get_config(m4ac, data, bit_size,
+                                           sync_extension)) < 0)
          return -1;
      if (m4ac->sampling_index > 12) {
-         av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);
+         av_log(avctx, AV_LOG_ERROR,
+                "invalid sampling rate index %d\n",
+                m4ac->sampling_index);
          return -1;
      }
  
              return -1;
          break;
      default:
-         av_log(avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
-                m4ac->sbr == 1? "SBR+" : "", m4ac->object_type);
+         av_log(avctx, AV_LOG_ERROR,
+                "Audio object type %s%d is not supported.\n",
+                m4ac->sbr == 1 ? "SBR+" : "",
+                m4ac->object_type);
          return -1;
      }
  
-     av_dlog(avctx, "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
+     av_dlog(avctx,
+             "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
              m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
-             m4ac->sample_rate, m4ac->sbr, m4ac->ps);
+             m4ac->sample_rate, m4ac->sbr,
+             m4ac->ps);
  
      return get_bits_count(&gb);
  }
   *
   * @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)
  {
      union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
      return v.s;
@@@ -874,14 -880,14 +921,16 @@@ static void reset_predictor_group(Predi
          reset_predict_state(&ps[i]);
  }
  
- #define AAC_INIT_VLC_STATIC(num, size) \
-     INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num], \
-          ff_aac_spectral_bits[num], sizeof( ff_aac_spectral_bits[num][0]), sizeof( ff_aac_spectral_bits[num][0]), \
-         ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), sizeof(ff_aac_spectral_codes[num][0]), \
+ #define AAC_INIT_VLC_STATIC(num, size)                                     \
+     INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num],     \
+          ff_aac_spectral_bits[num], sizeof(ff_aac_spectral_bits[num][0]),  \
+                                     sizeof(ff_aac_spectral_bits[num][0]),  \
+         ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), \
+                                     sizeof(ff_aac_spectral_codes[num][0]), \
          size);
  
 +static void aacdec_init(AACContext *ac);
 +
  static av_cold int aac_decode_init(AVCodecContext *avctx)
  {
      AACContext *ac = avctx->priv_data;
      ac->avctx = avctx;
      ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
  
 +    aacdec_init(ac);
 +
      avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
  
      if (avctx->extradata_size > 0) {
          if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
                                           avctx->extradata,
-                                          avctx->extradata_size*8, 1) < 0)
+                                          avctx->extradata_size * 8, 1) < 0)
              return -1;
      } else {
          int sr, i;
          }
      }
  
 +    if (avctx->channels > MAX_CHANNELS) {
 +        av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
      AAC_INIT_VLC_STATIC( 0, 304);
      AAC_INIT_VLC_STATIC( 1, 270);
      AAC_INIT_VLC_STATIC( 2, 550);
  
      ff_aac_tableinit();
  
-     INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
-                     ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
-                     ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
+     INIT_VLC_STATIC(&vlc_scalefactors, 7,
+                     FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
+                     ff_aac_scalefactor_bits,
+                     sizeof(ff_aac_scalefactor_bits[0]),
+                     sizeof(ff_aac_scalefactor_bits[0]),
+                     ff_aac_scalefactor_code,
+                     sizeof(ff_aac_scalefactor_code[0]),
+                     sizeof(ff_aac_scalefactor_code[0]),
                      352);
  
      ff_mdct_init(&ac->mdct,       11, 1, 1.0 / (32768.0 * 1024.0));
@@@ -986,7 -990,7 +1040,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);
@@@ -999,8 -1003,10 +1053,10 @@@ static int decode_prediction(AACContex
      int sfb;
      if (get_bits1(gb)) {
          ics->predictor_reset_group = get_bits(gb, 5);
-         if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
-             av_log(ac->avctx, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
+         if (ics->predictor_reset_group == 0 ||
+             ics->predictor_reset_group > 30) {
+             av_log(ac->avctx, AV_LOG_ERROR,
+                    "Invalid Predictor Reset Group.\n");
              return -1;
          }
      }
@@@ -1067,11 -1073,12 +1123,12 @@@ 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");
+                 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);
  
      if (ics->max_sfb > ics->num_swb) {
          av_log(ac->avctx, AV_LOG_ERROR,
-                "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
+                "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;
  }
  
  /**
@@@ -1120,7 -1125,7 +1178,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) {
@@@ -1165,7 -1170,8 +1223,8 @@@ static int decode_scalefactors(AACConte
              if (band_type[idx] == ZERO_BT) {
                  for (; i < run_end; i++, idx++)
                      sf[idx] = 0.;
-             } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
+             } else if ((band_type[idx] == INTENSITY_BT) ||
+                        (band_type[idx] == INTENSITY_BT2)) {
                  for (; i < run_end; i++, idx++) {
                      offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
                      clipped_offset = av_clip(offset[2], -155, 100);
@@@ -1253,7 -1259,8 +1312,8 @@@ static int decode_tns(AACContext *ac, T
                  tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
  
                  if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
-                     av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
+                     av_log(ac->avctx, AV_LOG_ERROR,
+                            "TNS filter order %d is greater than maximum %d.\n",
                             tns->order[w][filt], tns_max_order);
                      tns->order[w][filt] = 0;
                      return -1;
@@@ -1285,10 -1292,12 +1345,12 @@@ static void decode_mid_side_stereo(Chan
  {
      int idx;
      if (ms_present == 1) {
-         for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
+         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);
      }
  }
  
@@@ -1384,7 -1393,8 +1446,8 @@@ static int decode_spectrum_and_dequant(
      float *coef_base = coef;
  
      for (g = 0; g < ics->num_windows; g++)
-         memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb]));
+         memset(coef + g * 128 + offsets[ics->max_sfb], 0,
+                sizeof(float) * (c - offsets[ics->max_sfb]));
  
      for (g = 0; g < ics->num_window_groups; g++) {
          unsigned g_len = ics->group_len[g];
@@@ -1654,14 -1664,20 +1717,20 @@@ static void apply_prediction(AACContex
      }
  
      if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
-         for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index]; sfb++) {
-             for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
+         for (sfb = 0;
+              sfb < ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index];
+              sfb++) {
+             for (k = sce->ics.swb_offset[sfb];
+                  k < sce->ics.swb_offset[sfb + 1];
+                  k++) {
                  predict(&sce->predictor_state[k], &sce->coeffs[k],
-                         sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
+                         sce->ics.predictor_present &&
+                         sce->ics.prediction_used[sfb]);
              }
          }
          if (sce->ics.predictor_reset_group)
-             reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
+             reset_predictor_group(sce->predictor_state,
+                                   sce->ics.predictor_reset_group);
      } else
          reset_all_predictors(sce->predictor_state);
  }
@@@ -1695,20 -1711,24 +1764,24 @@@ static int decode_ics(AACContext *ac, S
              return AVERROR_INVALIDDATA;
      }
  
-     if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
+     if (decode_band_types(ac, sce->band_type,
+                           sce->band_type_run_end, gb, ics) < 0)
          return -1;
-     if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
+     if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
+                             sce->band_type, sce->band_type_run_end) < 0)
          return -1;
  
      pulse_present = 0;
      if (!scale_flag) {
          if ((pulse_present = get_bits1(gb))) {
              if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
-                 av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
+                 av_log(ac->avctx, AV_LOG_ERROR,
+                        "Pulse tool not allowed in eight short sequence.\n");
                  return -1;
              }
              if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
-                 av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
+                 av_log(ac->avctx, AV_LOG_ERROR,
+                        "Pulse data corrupt or invalid.\n");
                  return -1;
              }
          }
          }
      }
  
-     if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
+     if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
+                                     &pulse, ics, sce->band_type) < 0)
          return -1;
  
      if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
@@@ -1742,7 -1763,8 +1816,8 @@@ static void apply_mid_side_stereo(AACCo
      for (g = 0; g < ics->num_window_groups; g++) {
          for (i = 0; i < ics->max_sfb; i++, idx++) {
              if (cpe->ms_mask[idx] &&
-                     cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
+                 cpe->ch[0].band_type[idx] < NOISE_BT &&
+                 cpe->ch[1].band_type[idx] < NOISE_BT) {
                  for (group = 0; group < ics->group_len[g]; group++) {
                      ac->fdsp.butterflies_float(ch0 + group * 128 + offsets[i],
                                                 ch1 + group * 128 + offsets[i],
   *                      [1] mask is decoded from bitstream; [2] mask is all 1s;
   *                      [3] reserved for scalable AAC
   */
- static void apply_intensity_stereo(AACContext *ac, ChannelElement *cpe, int ms_present)
+ static void apply_intensity_stereo(AACContext *ac,
+                                    ChannelElement *cpe, int ms_present)
  {
      const IndividualChannelStream *ics = &cpe->ch[1].ics;
      SingleChannelElement         *sce1 = &cpe->ch[1];
      float scale;
      for (g = 0; g < ics->num_window_groups; g++) {
          for (i = 0; i < ics->max_sfb;) {
-             if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) {
+             if (sce1->band_type[idx] == INTENSITY_BT ||
+                 sce1->band_type[idx] == INTENSITY_BT2) {
                  const int bt_run_end = sce1->band_type_run_end[idx];
                  for (; i < bt_run_end; i++, idx++) {
                      c = -1 + 2 * (sce1->band_type[idx] - 14);
@@@ -1813,7 -1837,8 +1890,8 @@@ static int decode_cpe(AACContext *ac, G
          i = cpe->ch[1].ics.use_kb_window[0];
          cpe->ch[1].ics = cpe->ch[0].ics;
          cpe->ch[1].ics.use_kb_window[1] = i;
-         if (cpe->ch[1].ics.predictor_present && (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
+         if (cpe->ch[1].ics.predictor_present &&
+             (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
              if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
                  decode_ltp(&cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
          ms_present = get_bits(gb, 2);
@@@ -1991,32 -2016,6 +2069,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.
   *
@@@ -2058,8 -2057,6 +2136,8 @@@ static int decode_extension_payload(AAC
          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:
@@@ -2082,7 -2079,7 +2160,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 + 1];
 +    float tmp[TNS_MAX_ORDER+1];
  
      for (w = 0; w < ics->num_windows; w++) {
          bottom = ics->num_swb;
@@@ -2174,10 -2171,10 +2252,10 @@@ static void apply_ltp(AACContext *ac, S
              predTime[i] = sce->ltp_state[i + 2048 - ltp->lag] * ltp->coef;
          memset(&predTime[i], 0, (2048 - i) * sizeof(float));
  
 -        windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
 +        ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
  
          if (sce->tns.present)
 -            apply_tns(predFreq, &sce->tns, &sce->ics, 0);
 +            ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
  
          for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
              if (ltp->used[sfb])
@@@ -2389,25 -2386,25 +2467,25 @@@ static void spectral_to_sample(AACConte
                  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
                      if (che->ch[0].ics.predictor_present) {
                          if (che->ch[0].ics.ltp.present)
 -                            apply_ltp(ac, &che->ch[0]);
 +                            ac->apply_ltp(ac, &che->ch[0]);
                          if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
 -                            apply_ltp(ac, &che->ch[1]);
 +                            ac->apply_ltp(ac, &che->ch[1]);
                      }
                  }
                  if (che->ch[0].tns.present)
 -                    apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
 +                    ac->apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
                  if (che->ch[1].tns.present)
 -                    apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
 +                    ac->apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
                  if (type <= TYPE_CPE)
                      apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
                  if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
 -                    imdct_and_windowing(ac, &che->ch[0]);
 +                    ac->imdct_and_windowing(ac, &che->ch[0]);
                      if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
 -                        update_ltp(ac, &che->ch[0]);
 +                        ac->update_ltp(ac, &che->ch[0]);
                      if (type == TYPE_CPE) {
 -                        imdct_and_windowing(ac, &che->ch[1]);
 +                        ac->imdct_and_windowing(ac, &che->ch[1]);
                          if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
 -                            update_ltp(ac, &che->ch[1]);
 +                            ac->update_ltp(ac, &che->ch[1]);
                      }
                      if (ac->oc[1].m4ac.sbr > 0) {
                          ff_sbr_apply(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
@@@ -2429,12 -2426,10 +2507,12 @@@ 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.
              avpriv_report_missing_feature(ac->avctx,
                                            "More than one AAC RDB per ADTS frame");
 -            return AVERROR_PATCHWELCOME;
 +            ac->warned_num_aac_frames = 1;
          }
          push_output_configuration(ac);
          if (hdr_info.chan_config) {
                  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 (ac->dmono_mode && 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, 0))
 +                    return -7;
 +            }
          }
          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;
  
      ac->frame = data;
  
          case TYPE_SCE:
              err = decode_ics(ac, &che->ch[0], gb, 0, 0);
              audio_found = 1;
 +            sce_count++;
              break;
  
          case TYPE_CPE:
              if (pce_found) {
                  av_log(avctx, AV_LOG_ERROR,
                         "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, 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;
 +    /* for dual-mono audio (SCE + SCE) */
 +    is_dmono = ac->dmono_mode && sce_count == 2 &&
 +               ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
  
      if (samples)
          ac->frame->nb_samples = samples;
 +    else
 +        av_frame_unref(ac->frame);
      *got_frame_ptr = !!samples;
  
 +    if (is_dmono) {
 +        if (ac->dmono_mode == 1)
 +            ((AVFrame *)data)->data[1] =((AVFrame *)data)->data[0];
 +        else if (ac->dmono_mode == 2)
 +            ((AVFrame *)data)->data[0] =((AVFrame *)data)->data[1];
 +    }
 +
      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;
 +        const uint8_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);
@@@ -2654,12 -2613,8 +2732,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->dmono_mode = 0;
 +    if (jp_dualmono && jp_dualmono_size > 0)
 +        ac->dmono_mode =  1 + *jp_dualmono;
 +    if (ac->force_dmono_mode >= 0)
 +        ac->dmono_mode = ac->force_dmono_mode;
 +
 +    if (INT_MAX / 8 <= buf_size)
 +        return AVERROR_INVALIDDATA;
 +
      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;
@@@ -2721,13 -2667,13 +2799,13 @@@ static av_cold int aac_decode_close(AVC
  #define LOAS_SYNC_WORD   0x2b7       ///< 11 bits LOAS sync word
  
  struct LATMContext {
-     AACContext      aac_ctx;             ///< containing AACContext
-     int             initialized;         ///< initialized after a valid extradata was seen
+     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
-     int             frame_length_type;   ///< 0/1 variable/fixed frame length
-     int             frame_length;        ///< frame length for fixed frame length
+     int audio_mux_version_A; ///< LATM syntax version
+     int frame_length_type;   ///< 0/1 variable/fixed frame length
+     int frame_length;        ///< frame length for fixed frame length
  };
  
  static inline uint32_t latm_get_value(GetBitContext *b)
@@@ -2767,15 -2713,10 +2845,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_DEBUG, "initializing latmctx\n");
 +        }
          latmctx->initialized = 0;
  
          esize = (bits_consumed+7) / 8;
@@@ -2818,9 -2759,9 +2896,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
              avpriv_request_sample(latmctx->aac_ctx.avctx, "Multiple layers");
              return AVERROR_PATCHWELCOME;
@@@ -2933,15 -2874,14 +3011,15 @@@ static int latm_decode_frame(AVCodecCon
      int                 muxlength, err;
      GetBitContext       gb;
  
 -    init_get_bits(&gb, avpkt->data, avpkt->size * 8);
 +    if ((err = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
 +        return err;
  
      // check for LOAS sync word
      if (get_bits(&gb, 11) != LOAS_SYNC_WORD)
          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;
@@@ -2988,40 -2928,6 +3066,40 @@@ static av_cold int latm_decode_init(AVC
      return ret;
  }
  
 +static void aacdec_init(AACContext *c)
 +{
 +    c->imdct_and_windowing                      = imdct_and_windowing;
 +    c->apply_ltp                                = apply_ltp;
 +    c->apply_tns                                = apply_tns;
 +    c->windowing_and_mdct_ltp                   = windowing_and_mdct_ltp;
 +    c->update_ltp                               = update_ltp;
 +
 +    if(ARCH_MIPS)
 +        ff_aacdec_init_mips(c);
 +}
 +/**
 + * AVOptions for Japanese DTV specific extensions (ADTS only)
 + */
 +#define AACDEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
 +static const AVOption options[] = {
 +    {"dual_mono_mode", "Select the channel to decode for dual mono",
 +     offsetof(AACContext, force_dmono_mode), AV_OPT_TYPE_INT, {.i64=-1}, -1, 2,
 +     AACDEC_FLAGS, "dual_mono_mode"},
 +
 +    {"auto", "autoselection",            0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 +    {"main", "Select Main/Left channel", 0, AV_OPT_TYPE_CONST, {.i64= 1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 +    {"sub" , "Select Sub/Right channel", 0, AV_OPT_TYPE_CONST, {.i64= 2}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 +    {"both", "Select both channels",     0, AV_OPT_TYPE_CONST, {.i64= 0}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
 +
 +    {NULL},
 +};
 +
 +static const AVClass aac_decoder_class = {
 +    .class_name = "AAC decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
  
  AVCodec ff_aac_decoder = {
      .name            = "aac",
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
 +    .priv_class      = &aac_decoder_class,
  };
  
  /*
@@@ -3060,5 -2964,4 +3138,5 @@@ AVCodec ff_aac_latm_decoder = 
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };