Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Aug 2011 14:29:46 +0000 (16:29 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 10 Aug 2011 14:29:51 +0000 (16:29 +0200)
* qatar/master:
  lavc: make avcodec_init() static on next bump.
  ac3enc: remove unneeded #include
  ac3enc: restructure coupling coordinate reuse calculation
  ac3enc: allow new coupling coordinates to be sent independently for each channel.
  ac3enc: separate exponent bit counting from exponent grouping.
  h264: propagate error return values for AV_LOG_ERROR-triggering events
  aac: Don't attempt to output configure an invalid channel configuration.

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/aacdec.c
libavcodec/ac3enc.c
libavcodec/ac3enc.h
libavcodec/avcodec.h
libavcodec/h264.c
libavcodec/h264_refs.c
libavcodec/utils.c
libavcodec/version.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-ffmpeg@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
   */
  
@@@ -170,7 -170,7 +170,7 @@@ static ChannelElement *get_che(AACConte
  /**
   * 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
@@@ -251,6 -251,8 +251,6 @@@ static av_cold int output_configure(AAC
          }
  
          memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
 -
 -        avctx->channel_layout = 0;
      }
  
      avctx->channels = channels;
@@@ -313,10 -315,6 +313,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, overread_err);
 +        return -1;
 +    }
      decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
      decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE,  gb, num_side );
      decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK,  gb, num_back );
@@@ -591,10 -589,11 +591,11 @@@ static av_cold int aac_decode_init(AVCo
          ac->m4ac.chan_config = i;
  
          if (ac->m4ac.chan_config) {
-             if (set_default_channel_config(avctx, new_che_pos, ac->m4ac.chan_config) < 0 &&
-                 avctx->error_recognition >= FF_ER_EXPLODE)
-               return AVERROR_INVALIDDATA;
-             output_configure(ac, ac->che_pos, new_che_pos, ac->m4ac.chan_config, OC_GLOBAL_HDR);
+             int ret = set_default_channel_config(avctx, new_che_pos, ac->m4ac.chan_config);
+             if (!ret)
+                 output_configure(ac, ac->che_pos, new_che_pos, ac->m4ac.chan_config, OC_GLOBAL_HDR);
+             else if (avctx->error_recognition >= FF_ER_EXPLODE)
+                 return AVERROR_INVALIDDATA;
          }
      }
  
diff --combined libavcodec/ac3enc.c
@@@ -4,20 -4,20 +4,20 @@@
   * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
   * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
   *
 - * 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
   */
  
@@@ -526,20 -526,47 +526,47 @@@ static void encode_exponents(AC3EncodeC
  }
  
  
+ /**
+  * Count exponent bits based on bandwidth, coupling, and exponent strategies.
+  */
+ static int count_exponent_bits(AC3EncodeContext *s)
+ {
+     int blk, ch;
+     int nb_groups, bit_count;
+     bit_count = 0;
+     for (blk = 0; blk < s->num_blocks; blk++) {
+         AC3Block *block = &s->blocks[blk];
+         for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
+             int exp_strategy = s->exp_strategy[ch][blk];
+             int cpl          = (ch == CPL_CH);
+             int nb_coefs     = block->end_freq[ch] - s->start_freq[ch];
+             if (exp_strategy == EXP_REUSE)
+                 continue;
+             nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs];
+             bit_count += 4 + (nb_groups * 7);
+         }
+     }
+     return bit_count;
+ }
  /**
   * Group exponents.
   * 3 delta-encoded exponents are in each 7-bit group. The number of groups
   * varies depending on exponent strategy and bandwidth.
   */
static void group_exponents(AC3EncodeContext *s)
void ff_ac3_group_exponents(AC3EncodeContext *s)
  {
      int blk, ch, i, cpl;
-     int group_size, nb_groups, bit_count;
+     int group_size, nb_groups;
      uint8_t *p;
      int delta0, delta1, delta2;
      int exp0, exp1;
  
-     bit_count = 0;
      for (blk = 0; blk < s->num_blocks; blk++) {
          AC3Block *block = &s->blocks[blk];
          for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
              cpl = (ch == CPL_CH);
              group_size = exp_strategy + (exp_strategy == EXP_D45);
              nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
-             bit_count += 4 + (nb_groups * 7);
              p = block->exp[ch] + s->start_freq[ch] - cpl;
  
              /* DC exponent */
              }
          }
      }
-     s->exponent_bits = bit_count;
  }
  
  
@@@ -599,8 -623,6 +623,6 @@@ void ff_ac3_process_exponents(AC3Encode
  
      encode_exponents(s);
  
-     group_exponents(s);
      emms_c();
  }
  
@@@ -842,9 -864,9 +864,9 @@@ static void count_frame_bits(AC3EncodeC
          if (block->cpl_in_use) {
              for (ch = 1; ch <= s->fbw_channels; ch++) {
                  if (block->channel_in_cpl[ch]) {
-                     if (!s->eac3 || block->new_cpl_coords != 2)
+                     if (!s->eac3 || block->new_cpl_coords[ch] != 2)
                          frame_bits++;
-                     if (block->new_cpl_coords) {
+                     if (block->new_cpl_coords[ch]) {
                          frame_bits += 2;
                          frame_bits += (4 + 4) * s->num_cpl_bands;
                      }
@@@ -1095,6 -1117,8 +1117,8 @@@ int ff_ac3_compute_bit_allocation(AC3En
  {
      count_frame_bits(s);
  
+     s->exponent_bits = count_exponent_bits(s);
      bit_alloc_masking(s);
  
      return cbr_bit_allocation(s);
@@@ -1370,9 -1394,9 +1394,9 @@@ static void output_audio_block(AC3Encod
      if (block->cpl_in_use) {
          for (ch = 1; ch <= s->fbw_channels; ch++) {
              if (block->channel_in_cpl[ch]) {
-                 if (!s->eac3 || block->new_cpl_coords != 2)
-                     put_bits(&s->pb, 1, block->new_cpl_coords);
-                 if (block->new_cpl_coords) {
+                 if (!s->eac3 || block->new_cpl_coords[ch] != 2)
+                     put_bits(&s->pb, 1, block->new_cpl_coords[ch]);
+                 if (block->new_cpl_coords[ch]) {
                      put_bits(&s->pb, 2, block->cpl_master_exp[ch]);
                      for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
                          put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]);
diff --combined libavcodec/ac3enc.h
@@@ -66,7 -66,6 +66,7 @@@ typedef int64_t CoefSumType
  #endif
  
  
 +#if 0
  /**
   * Encoding Options used by AVOption.
   */
@@@ -101,7 -100,7 +101,7 @@@ typedef struct AC3EncOptions 
      int channel_coupling;
      int cpl_start;
  } AC3EncOptions;
 -
 +#endif
  /**
   * Data for a single audio block.
   */
@@@ -124,7 -123,7 +124,7 @@@ typedef struct AC3Block 
      int      cpl_in_use;                        ///< coupling in use for this block     (cplinu)
      uint8_t  channel_in_cpl[AC3_MAX_CHANNELS];  ///< channel in coupling                (chincpl)
      int      num_cpl_channels;                  ///< number of channels in coupling
-     uint8_t  new_cpl_coords;                    ///< send new coupling coordinates      (cplcoe)
+     uint8_t  new_cpl_coords[AC3_MAX_CHANNELS];  ///< send new coupling coordinates      (cplcoe)
      uint8_t  cpl_master_exp[AC3_MAX_CHANNELS];  ///< coupling coord master exponents    (mstrcplco)
      int      new_snr_offsets;                   ///< send new SNR offsets
      int      new_cpl_leak;                      ///< send new coupling leak info
@@@ -240,6 -239,8 +240,6 @@@ typedef struct AC3EncodeContext 
  } AC3EncodeContext;
  
  
 -extern const int64_t ff_ac3_channel_layouts[19];
 -
  int ff_ac3_encode_init(AVCodecContext *avctx);
  
  int ff_ac3_encode_close(AVCodecContext *avctx);
@@@ -256,6 -257,8 +256,8 @@@ void ff_ac3_process_exponents(AC3Encode
  
  int ff_ac3_compute_bit_allocation(AC3EncodeContext *s);
  
+ void ff_ac3_group_exponents(AC3EncodeContext *s);
  void ff_ac3_quantize_mantissas(AC3EncodeContext *s);
  
  void ff_ac3_output_frame(AC3EncodeContext *s, unsigned char *frame);
diff --combined libavcodec/avcodec.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * copyright (c) 2001 Fabrice Bellard
   *
 - * 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
   */
  
@@@ -208,8 -208,6 +208,8 @@@ enum CodecID 
      CODEC_ID_PRORES,
      CODEC_ID_JV,
      CODEC_ID_DFA,
 +    CODEC_ID_8SVX_RAW,
 +    CODEC_ID_G2M,
  
      /* various PCM "codecs" */
      CODEC_ID_PCM_S16LE= 0x10000,
      CODEC_ID_BINKAUDIO_DCT,
      CODEC_ID_AAC_LATM,
      CODEC_ID_QDMC,
 +    CODEC_ID_CELT,
  
      /* subtitle codecs */
      CODEC_ID_DVD_SUBTITLE= 0x17000,
      CODEC_ID_HDMV_PGS_SUBTITLE,
      CODEC_ID_DVB_TELETEXT,
      CODEC_ID_SRT,
 +    CODEC_ID_MICRODVD,
  
      /* other specific kind of codecs (generally used for attachments) */
      CODEC_ID_TTF= 0x18000,
   * Note: If the first 23 bits of the additional bytes are not 0, then damaged
   * MPEG bitstreams could cause overread and segfault.
   */
 -#define FF_INPUT_BUFFER_PADDING_SIZE 8
 +#define FF_INPUT_BUFFER_PADDING_SIZE 16
  
  /**
   * minimum encoding buffer size
@@@ -679,12 -675,10 +679,12 @@@ typedef struct RcOverride
   * Codec should fill in channel configuration and samplerate instead of container
   */
  #define CODEC_CAP_CHANNEL_CONF     0x0400
 +
  /**
   * Codec is able to deal with negative linesizes
   */
  #define CODEC_CAP_NEG_LINESIZES    0x0800
 +
  /**
   * Codec supports frame-level multithreading.
   */
   * Codec supports slice-based (or partition-based) multithreading.
   */
  #define CODEC_CAP_SLICE_THREADS    0x2000
 +/**
 + * Codec is lossless.
 + */
 +#define CODEC_CAP_LOSSLESS         0x80000000
  
  //The following defines may change, don't expect compatibility if you use them.
  #define MB_TYPE_INTRA4x4   0x0001
@@@ -1080,7 -1070,7 +1080,7 @@@ typedef struct AVFrame 
      int64_t reordered_opaque;
  
      /**
 -     * hardware accelerator private data (Libav-allocated)
 +     * hardware accelerator private data (FFmpeg-allocated)
       * - encoding: unused
       * - decoding: Set by libavcodec
       */
       * - decoding: Set by libavcodec.
       */
      void *thread_opaque;
 +
 +    /**
 +     * frame timestamp estimated using various heuristics, in stream time base
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int64_t best_effort_timestamp;
 +
 +    /**
 +     * reordered pos from the last AVPacket that has been input into the decoder
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_pos;
 +
 +    /**
 +     * reordered sample aspect ratio for the video frame, 0/1 if unknown\unspecified
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    AVRational sample_aspect_ratio;
 +
 +    /**
 +     * width and height of the video frame
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int width, height;
 +
 +    /**
 +     * format of the frame, -1 if unknown or unset
 +     * It should be cast to the corresponding enum (enum PixelFormat
 +     * for video, enum AVSampleFormat for audio)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int format;
 +
  } AVFrame;
  
  /**
@@@ -2644,7 -2596,7 +2644,7 @@@ typedef struct AVCodecContext 
      /**
       * Audio channel layout.
       * - encoding: set by user.
 -     * - decoding: set by libavcodec.
 +     * - decoding: set by user, may be overwritten by libavcodec.
       */
      int64_t channel_layout;
  
       * Hardware accelerator context.
       * For some hardware accelerators, a global context needs to be
       * provided by the user. In that case, this holds display-dependent
 -     * data Libav cannot instantiate itself. Please refer to the
 -     * Libav HW accelerator documentation to know how to fill this
 +     * data FFmpeg cannot instantiate itself. Please refer to the
 +     * FFmpeg HW accelerator documentation to know how to fill this
       * is. e.g. for VA API, this is a struct vaapi_context.
       * - encoding: unused
       * - decoding: Set by user
      enum AVAudioServiceType audio_service_type;
  
      /**
 -     * Used to request a sample format from the decoder.
 -     * - encoding: unused.
 +     * desired sample format
 +     * - encoding: Not used.
       * - decoding: Set by user.
 +     * Decoder will decode to this format if it can.
       */
      enum AVSampleFormat request_sample_fmt;
 +
 +    /**
 +     * Current statistics for PTS correction.
 +     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
 +     * - encoding: unused
 +     */
 +    int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
 +    int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
 +    int64_t pts_correction_last_pts;       /// PTS of the last frame
 +    int64_t pts_correction_last_dts;       /// DTS of the last frame
 +
 +
  } AVCodecContext;
  
  /**
@@@ -3269,11 -3208,6 +3269,11 @@@ uint8_t* av_packet_new_side_data(AVPack
  uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                   int *size);
  
 +int av_packet_merge_side_data(AVPacket *pkt);
 +
 +int av_packet_split_side_data(AVPacket *pkt);
 +
 +
  /* resample.c */
  
  struct ReSampleContext;
@@@ -3433,9 -3367,6 +3433,9 @@@ void avcodec_get_chroma_sub_sample(enu
  
  #if FF_API_GET_PIX_FMT_NAME
  /**
 + * Return the short name for a pixel format.
 + *
 + * \see av_get_pix_fmt(), av_get_pix_fmt_string().
   * @deprecated Deprecated in favor of av_get_pix_fmt_name().
   */
  attribute_deprecated
@@@ -3551,21 -3482,22 +3551,22 @@@ const char *avcodec_configuration(void)
   */
  const char *avcodec_license(void);
  
+ #if FF_API_AVCODEC_INIT
  /**
-  * Initialize libavcodec.
-  * If called more than once, does nothing.
-  *
-  * @warning This function must be called before any other libavcodec
-  * function.
-  *
-  * @warning This function is not thread-safe.
+  * @deprecated this function is called automatically from avcodec_register()
+  * and avcodec_register_all(), there is no need to call it manually
   */
+ attribute_deprecated
  void avcodec_init(void);
+ #endif
  
  /**
   * Register the codec codec and initialize libavcodec.
   *
-  * @see avcodec_init(), avcodec_register_all()
+  * @warning either this function or avcodec_register_all() must be called
+  * before any other libavcodec functions.
+  *
+  * @see avcodec_register_all()
   */
  void avcodec_register(AVCodec *codec);
  
@@@ -4282,7 -4214,7 +4283,7 @@@ unsigned int av_xiphlacing(unsigned cha
  
  /**
   * Logs a generic warning message about a missing feature. This function is
 - * intended to be used internally by Libav (libavcodec, libavformat, etc.)
 + * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
   * only, and would normally not be used by applications.
   * @param[in] avc a pointer to an arbitrary struct of which the first field is
   * a pointer to an AVClass struct
@@@ -4296,7 -4228,7 +4297,7 @@@ void av_log_missing_feature(void *avc, 
  
  /**
   * Log a generic warning message asking for a sample. This function is
 - * intended to be used internally by Libav (libavcodec, libavformat, etc.)
 + * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
   * only, and would normally not be used by applications.
   * @param[in] avc a pointer to an arbitrary struct of which the first field is
   * a pointer to an AVClass struct
@@@ -4333,7 -4265,7 +4334,7 @@@ enum AVLockOp 
   * lockmgr should store/get a pointer to a user allocated mutex. It's
   * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
   *
 - * @param cb User defined callback. Note: Libav may invoke calls to this
 + * @param cb User defined callback. Note: FFmpeg may invoke calls to this
   *           callback during the call to av_lockmgr_register().
   *           Thus, the application must be prepared to handle that.
   *           If cb is set to NULL the lockmgr will be unregistered.
diff --combined libavcodec/h264.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... decoder
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * 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
   */
  
@@@ -671,7 -671,7 +671,7 @@@ static inline void prefetch_motion(H264
              s->dsp.prefetch(src[1]+off, s->linesize, 4);
              s->dsp.prefetch(src[2]+off, s->linesize, 4);
          }else{
 -            off= ((mx>>1) << pixel_shift) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + (64 << pixel_shift);
 +            off= (((mx>>1)+64)<<pixel_shift) + ((my>>1) + (s->mb_x&7))*s->uvlinesize;
              s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
          }
      }
@@@ -1194,7 -1194,7 +1194,7 @@@ static int decode_update_thread_context
      if(!s->current_picture_ptr) return 0;
  
      if(!s->dropable) {
-         ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
+         err = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
          h->prev_poc_msb     = h->poc_msb;
          h->prev_poc_lsb     = h->poc_lsb;
      }
      h->prev_frame_num       = h->frame_num;
      h->outputed_poc         = h->next_outputed_poc;
  
-     return 0;
+     return err;
  }
  
  int ff_h264_frame_start(H264Context *h){
@@@ -1809,8 -1809,8 +1809,8 @@@ static av_always_inline void hl_decode_
      }
  
      if (!simple && IS_INTRA_PCM(mb_type)) {
 +        const int bit_depth = h->sps.bit_depth_luma;
          if (pixel_shift) {
 -            const int bit_depth = h->sps.bit_depth_luma;
              int j;
              GetBitContext gb;
              init_get_bits(&gb, (uint8_t*)h->mb, 384*bit_depth);
                      tmp_y[j] = get_bits(&gb, bit_depth);
              }
              if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
 +                if (!h->sps.chroma_format_idc) {
 +                    for (i = 0; i < 8; i++) {
 +                        uint16_t *tmp_cb = (uint16_t*)(dest_cb + i*uvlinesize);
 +                        uint16_t *tmp_cr = (uint16_t*)(dest_cr + i*uvlinesize);
 +                        for (j = 0; j < 8; j++) {
 +                            tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
 +                        }
 +                    }
 +                } else {
                  for (i = 0; i < 8; i++) {
                      uint16_t *tmp_cb = (uint16_t*)(dest_cb + i*uvlinesize);
                      for (j = 0; j < 8; j++)
                      for (j = 0; j < 8; j++)
                          tmp_cr[j] = get_bits(&gb, bit_depth);
                  }
 +                }
              }
          } else {
              for (i=0; i<16; i++) {
                  memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);
              }
              if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
 +                if (!h->sps.chroma_format_idc) {
 +                    for (i=0; i<8; i++) {
 +                        memset(dest_cb+ i*uvlinesize, 1 << (bit_depth - 1), 8);
 +                        memset(dest_cr+ i*uvlinesize, 1 << (bit_depth - 1), 8);
 +                    }
 +                } else {
                  for (i=0; i<8; i++) {
                      memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);
                      memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);
                  }
 +                }
              }
          }
      } else {
                      h->h264dsp.h264_idct_add8(dest, block_offset,
                                                h->mb, uvlinesize,
                                                h->non_zero_count_cache);
 -                }else{
 +                }
 +#if CONFIG_SVQ3_DECODER
 +                else{
                      h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*1, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
                      h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*2, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
                      for(j=1; j<3; j++){
                          }
                      }
                  }
 +#endif
              }
          }
      }
@@@ -2174,10 -2154,9 +2174,10 @@@ static void implicit_weight_table(H264C
      for(ref0=ref_start; ref0 < ref_count0; ref0++){
          int poc0 = h->ref_list[0][ref0].poc;
          for(ref1=ref_start; ref1 < ref_count1; ref1++){
 +            int w= 32;
 +            if (!h->ref_list[0][ref0].long_ref && !h->ref_list[1][ref1].long_ref){
              int poc1 = h->ref_list[1][ref1].poc;
              int td = av_clip(poc1 - poc0, -128, 127);
 -            int w= 32;
              if(td){
                  int tb = av_clip(cur_poc - poc0, -128, 127);
                  int tx = (16384 + (FFABS(td) >> 1)) / td;
                  if(dist_scale_factor >= -64 && dist_scale_factor <= 128)
                      w = 64 - dist_scale_factor;
              }
 +            }
              if(field<0){
                  h->implicit_weight[ref0][ref1][0]=
                  h->implicit_weight[ref0][ref1][1]= w;
@@@ -2340,9 -2318,10 +2340,10 @@@ static void init_scan_tables(H264Contex
      }
  }
  
- static void field_end(H264Context *h, int in_setup){
+ static int field_end(H264Context *h, int in_setup){
      MpegEncContext * const s = &h->s;
      AVCodecContext * const avctx= s->avctx;
+     int err = 0;
      s->mb_y= 0;
  
      if (!in_setup && !s->dropable)
  
      if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){
          if(!s->dropable) {
-             ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
+             err = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
              h->prev_poc_msb= h->poc_msb;
              h->prev_poc_lsb= h->poc_lsb;
          }
      MPV_frame_end(s);
  
      h->current_slice=0;
+     return err;
  }
  
  /**
@@@ -2690,7 -2671,9 +2693,9 @@@ static int decode_slice_header(H264Cont
              ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);
              ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);
              ff_generate_sliding_window_mmcos(h);
-             ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
+             if (ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index) < 0 &&
+                 s->avctx->error_recognition >= FF_ER_EXPLODE)
+                 return AVERROR_INVALIDDATA;
              /* Error concealment: if a ref is missing, copy the previous ref in its place.
               * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
               * about there being no actual duplicates.
          }
      }
  
-     if(h->nal_ref_idc)
-         ff_h264_decode_ref_pic_marking(h0, &s->gb);
+     if(h->nal_ref_idc && ff_h264_decode_ref_pic_marking(h0, &s->gb) < 0 &&
+        s->avctx->error_recognition >= FF_ER_EXPLODE)
+         return AVERROR_INVALIDDATA;
  
      if(FRAME_MBAFF){
          ff_h264_fill_mbaff_ref_list(h);
      h0->last_slice_type = slice_type;
      h->slice_num = ++h0->current_slice;
      if(h->slice_num >= MAX_SLICES){
 -        av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
 +        av_log(s->avctx, AV_LOG_WARNING, "Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", h->slice_num, MAX_SLICES);
      }
  
      for(j=0; j<2; j++){
@@@ -3454,8 -3438,7 +3460,8 @@@ static int decode_slice(struct AVCodecC
                  if(s->mb_y >= s->mb_height){
                      tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  
 -                    if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
 +                    if(   get_bits_count(&s->gb) == s->gb.size_in_bits
 +                       || get_bits_count(&s->gb) <  s->gb.size_in_bits && s->avctx->error_recognition < FF_ER_AGGRESSIVE) {
                          ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
  
                          return 0;
   * @param h h264 master context
   * @param context_count number of contexts to execute
   */
- static void execute_decode_slices(H264Context *h, int context_count){
+ static int execute_decode_slices(H264Context *h, int context_count){
      MpegEncContext * const s = &h->s;
      AVCodecContext * const avctx= s->avctx;
      H264Context *hx;
      int i;
  
-     if (s->avctx->hwaccel)
-         return;
-     if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
-         return;
+     if (s->avctx->hwaccel || s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
+         return 0;
      if(context_count == 1) {
-         decode_slice(avctx, &h);
+         return decode_slice(avctx, &h);
      } else {
          for(i = 1; i < context_count; i++) {
              hx = h->thread_context[i];
              hx->s.error_recognition = avctx->error_recognition;
              hx->s.error_count = 0;
 +            hx->x264_build= h->x264_build;
          }
  
          avctx->execute(avctx, (void *)decode_slice,
          for(i = 1; i < context_count; i++)
              h->s.error_count += h->thread_context[i]->s.error_count;
      }
+     return 0;
  }
  
  
@@@ -3599,7 -3581,7 +3605,7 @@@ static int decode_nal_units(H264Contex
          bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));
  
          if(s->avctx->debug&FF_DEBUG_STARTCODE){
 -            av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length);
 +            av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d/%d at %d/%d length %d\n", hx->nal_unit_type, hx->nal_ref_idc, buf_index, buf_size, dst_length);
          }
  
          if (h->is_avc && (nalsize != consumed) && nalsize){
@@@ -3890,7 -3872,6 +3896,7 @@@ static inline void fill_mb_avail(H264Co
  #undef random
  #define COUNT 8000
  #define SIZE (COUNT*40)
 +extern AVCodec ff_h264_decoder;
  int main(void){
      int i;
      uint8_t temp[SIZE];
      DSPContext dsp;
      AVCodecContext avctx;
  
 +    avcodec_get_context_defaults3(&avctx, &ff_h264_decoder);
 +
      dsputil_init(&dsp, &avctx);
  
      init_put_bits(&pb, temp, SIZE);
diff --combined libavcodec/h264_refs.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * 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
   */
  
@@@ -25,7 -25,6 +25,7 @@@
   * @author Michael Niedermayer <michaelni@gmx.at>
   */
  
 +#include "libavutil/avassert.h"
  #include "internal.h"
  #include "dsputil.h"
  #include "avcodec.h"
@@@ -479,7 -478,7 +479,7 @@@ static void print_long_term(H264Contex
  
  void ff_generate_sliding_window_mmcos(H264Context *h) {
      MpegEncContext * const s = &h->s;
 -    assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
 +    av_assert0(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
  
      h->mmco_index= 0;
      if(h->short_ref_count && h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count &&
  int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
      MpegEncContext * const s = &h->s;
      int i, av_uninit(j);
-     int current_ref_assigned=0;
+     int current_ref_assigned=0, err=0;
      Picture *av_uninit(pic);
  
      if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
                  if(mmco[i].opcode != MMCO_SHORT2LONG || !h->long_ref[mmco[i].long_arg]
                     || h->long_ref[mmco[i].long_arg]->frame_num != frame_num)
                  av_log(h->s.avctx, AV_LOG_ERROR, "mmco: unref short failure\n");
+                 err = AVERROR_INVALIDDATA;
                  continue;
              }
          }
                                               "assignment for second field "
                                               "in complementary field pair "
                                               "(first field is long term)\n");
+             err = AVERROR_INVALIDDATA;
          } else {
              pic= remove_short(h, s->current_picture_ptr->frame_num, 0);
              if(pic){
                  av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
+                 err = AVERROR_INVALIDDATA;
              }
  
              if(h->short_ref_count)
          }
      }
  
 -    if (h->long_ref_count + h->short_ref_count -
 -            (h->short_ref[0] == s->current_picture_ptr) > h->sps.ref_frame_count){
 +    if (h->long_ref_count + h->short_ref_count > FFMAX(h->sps.ref_frame_count, 1)){
  
          /* We have too many reference frames, probably due to corrupted
           * stream. Need to discard one frame. Prevents overrun of the
                 "number of reference frames (%d+%d) exceeds max (%d; probably "
                 "corrupt input), discarding one\n",
                 h->long_ref_count, h->short_ref_count, h->sps.ref_frame_count);
+         err = AVERROR_INVALIDDATA;
  
          if (h->long_ref_count && !h->short_ref_count) {
              for (i = 0; i < 16; ++i)
  
      print_short_term(h);
      print_long_term(h);
-     return 0;
+     return err;
  }
  
  int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb){
                  }
                  if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
                      unsigned int long_arg= get_ue_golomb_31(gb);
 -                    if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){
 +                    if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG && long_arg == 16) && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){
                          av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
                          return -1;
                      }
diff --combined libavcodec/utils.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2001 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * 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
   */
  
@@@ -348,18 -348,9 +348,18 @@@ int avcodec_default_get_buffer(AVCodecC
      }
      s->internal_buffer_count++;
  
 -    if(s->pkt) pic->pkt_pts= s->pkt->pts;
 -    else       pic->pkt_pts= AV_NOPTS_VALUE;
 +    if (s->pkt) {
 +        pic->pkt_pts = s->pkt->pts;
 +        pic->pkt_pos = s->pkt->pos;
 +    } else {
 +        pic->pkt_pts = AV_NOPTS_VALUE;
 +        pic->pkt_pos = -1;
 +    }
      pic->reordered_opaque= s->reordered_opaque;
 +    pic->sample_aspect_ratio = s->sample_aspect_ratio;
 +    pic->width               = s->width;
 +    pic->height              = s->height;
 +    pic->format              = s->pix_fmt;
  
      if(s->debug&FF_DEBUG_BUFFERS)
          av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
@@@ -463,11 -454,8 +463,11 @@@ enum PixelFormat avcodec_default_get_fo
  void avcodec_get_frame_defaults(AVFrame *pic){
      memset(pic, 0, sizeof(AVFrame));
  
 -    pic->pts= AV_NOPTS_VALUE;
 +    pic->pts = pic->best_effort_timestamp = AV_NOPTS_VALUE;
 +    pic->pkt_pos = -1;
      pic->key_frame= 1;
 +    pic->sample_aspect_ratio = (AVRational){0, 1};
 +    pic->format = -1;           /* unknown */
  }
  
  AVFrame *avcodec_alloc_frame(void){
      return pic;
  }
  
 +static void avcodec_get_subtitle_defaults(AVSubtitle *sub)
 +{
 +    memset(sub, 0, sizeof(*sub));
 +    sub->pts = AV_NOPTS_VALUE;
 +}
 +
  #if FF_API_AVCODEC_OPEN
  int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
  {
@@@ -531,7 -513,7 +531,7 @@@ int attribute_align_arg avcodec_open2(A
              av_opt_set_defaults(avctx->priv_data);
          }
        }
 -      if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp) < 0))
 +      if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
            goto free_and_end;
      } else {
          avctx->priv_data = NULL;
          }
      }
  
 -    if (avctx->codec->max_lowres < avctx->lowres) {
 +    if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
          av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
                 avctx->codec->max_lowres);
          ret = AVERROR(EINVAL);
          }
      }
  
 +    avctx->pts_correction_num_faulty_pts =
 +    avctx->pts_correction_num_faulty_dts = 0;
 +    avctx->pts_correction_last_pts =
 +    avctx->pts_correction_last_dts = INT64_MIN;
 +
      if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){
          ret = avctx->codec->init(avctx);
          if (ret < 0) {
              goto free_and_end;
          }
      }
 +
 +    ret=0;
  end:
      entangled_thread_counter--;
  
@@@ -711,44 -686,13 +711,44 @@@ int avcodec_encode_subtitle(AVCodecCont
          av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
          return -1;
      }
 -    if(sub->num_rects == 0 || !sub->rects)
 -        return -1;
 +
      ret = avctx->codec->encode(avctx, buf, buf_size, sub);
      avctx->frame_number++;
      return ret;
  }
  
 +/**
 + * Attempt to guess proper monotonic timestamps for decoded video frames
 + * which might have incorrect times. Input timestamps may wrap around, in
 + * which case the output will as well.
 + *
 + * @param pts the pts field of the decoded AVPacket, as passed through
 + * AVFrame.pkt_pts
 + * @param dts the dts field of the decoded AVPacket
 + * @return one of the input values, may be AV_NOPTS_VALUE
 + */
 +static int64_t guess_correct_pts(AVCodecContext *ctx,
 +                                 int64_t reordered_pts, int64_t dts)
 +{
 +    int64_t pts = AV_NOPTS_VALUE;
 +
 +    if (dts != AV_NOPTS_VALUE) {
 +        ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
 +        ctx->pts_correction_last_dts = dts;
 +    }
 +    if (reordered_pts != AV_NOPTS_VALUE) {
 +        ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
 +        ctx->pts_correction_last_pts = reordered_pts;
 +    }
 +    if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
 +       && reordered_pts != AV_NOPTS_VALUE)
 +        pts = reordered_pts;
 +    else
 +        pts = dts;
 +
 +    return pts;
 +}
 +
  int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                           int *got_picture_ptr,
                           AVPacket *avpkt)
      if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
          return -1;
  
 -    avctx->pkt = avpkt;
 -
      if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type&FF_THREAD_FRAME)){
 +        av_packet_split_side_data(avpkt);
 +        avctx->pkt = avpkt;
          if (HAVE_PTHREADS && avctx->active_thread_type&FF_THREAD_FRAME)
               ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
                                            avpkt);
              ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
                                avpkt);
              picture->pkt_dts= avpkt->dts;
 +
 +            if(!avctx->has_b_frames){
 +            picture->pkt_pos= avpkt->pos;
 +            }
 +            //FIXME these should be under if(!avctx->has_b_frames)
 +            if (!picture->sample_aspect_ratio.num)
 +                picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
 +            if (!picture->width)
 +                picture->width = avctx->width;
 +            if (!picture->height)
 +                picture->height = avctx->height;
 +            if (picture->format == PIX_FMT_NONE)
 +                picture->format = avctx->pix_fmt;
          }
  
          emms_c(); //needed to avoid an emms_c() call before every return;
  
 -        if (*got_picture_ptr)
 +
 +        if (*got_picture_ptr){
              avctx->frame_number++;
 +            picture->best_effort_timestamp = guess_correct_pts(avctx,
 +                                                            picture->pkt_pts,
 +                                                            picture->pkt_dts);
 +        }
      }else
          ret= 0;
  
@@@ -836,7 -762,6 +836,7 @@@ int avcodec_decode_subtitle2(AVCodecCon
  
      avctx->pkt = avpkt;
      *got_sub_ptr = 0;
 +    avcodec_get_subtitle_defaults(sub);
      ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
      if (*got_sub_ptr)
          avctx->frame_number++;
@@@ -933,18 -858,14 +933,18 @@@ AVCodec *avcodec_find_encoder_by_name(c
  
  AVCodec *avcodec_find_decoder(enum CodecID id)
  {
 -    AVCodec *p;
 +    AVCodec *p, *experimental=NULL;
      p = first_avcodec;
      while (p) {
 -        if (p->decode != NULL && p->id == id)
 -            return p;
 +        if (p->decode != NULL && p->id == id) {
 +            if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
 +                experimental = p;
 +            } else
 +                return p;
 +        }
          p = p->next;
      }
 -    return NULL;
 +    return experimental;
  }
  
  AVCodec *avcodec_find_decoder_by_name(const char *name)
@@@ -1053,7 -974,7 +1053,7 @@@ void avcodec_string(char *buf, int buf_
                            enc->height*enc->sample_aspect_ratio.den,
                            1024*1024);
                  snprintf(buf + strlen(buf), buf_size - strlen(buf),
 -                         " [PAR %d:%d DAR %d:%d]",
 +                         " [SAR %d:%d DAR %d:%d]",
                           enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
                           display_aspect_ratio.num, display_aspect_ratio.den);
              }
@@@ -1135,15 -1056,18 +1135,18 @@@ unsigned avcodec_version( void 
  
  const char *avcodec_configuration(void)
  {
 -    return LIBAV_CONFIGURATION;
 +    return FFMPEG_CONFIGURATION;
  }
  
  const char *avcodec_license(void)
  {
  #define LICENSE_PREFIX "libavcodec license: "
 -    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  }
  
+ #if !FF_API_AVCODEC_INIT
+ static
+ #endif
  void avcodec_init(void)
  {
      static int initialized = 0;
@@@ -1268,7 -1192,7 +1271,7 @@@ int ff_match_2uint16(const uint16_t (*t
  
  void av_log_missing_feature(void *avc, const char *feature, int want_sample)
  {
 -    av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your Libav "
 +    av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your FFmpeg "
              "version to the newest one from Git. If the problem still "
              "occurs, it means that your file has a feature which has not "
              "been implemented.\n", feature);
@@@ -1285,8 -1209,8 +1288,8 @@@ void av_log_ask_for_sample(void *avc, c
      if (msg)
          av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
      av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
 -            "of this file to ftp://upload.libav.org/incoming/ "
 -            "and contact the libav-devel mailing list.\n");
 +            "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
 +            "and contact the ffmpeg-devel mailing list.\n");
  
      va_end(argument_list);
  }
diff --combined libavcodec/version.h
@@@ -1,19 -1,19 +1,19 @@@
  /*
   *
 - * 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
   */
  
@@@ -21,8 -21,8 +21,8 @@@
  #define AVCODEC_VERSION_H
  
  #define LIBAVCODEC_VERSION_MAJOR 53
 -#define LIBAVCODEC_VERSION_MINOR  7
 -#define LIBAVCODEC_VERSION_MICRO  1
 +#define LIBAVCODEC_VERSION_MINOR 10
 +#define LIBAVCODEC_VERSION_MICRO  0
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
@@@ -80,5 -80,8 +80,8 @@@
  #ifndef FF_API_VERY_AGGRESSIVE
  #define FF_API_VERY_AGGRESSIVE  (LIBAVCODEC_VERSION_MAJOR < 54)
  #endif
+ #ifndef FF_API_AVCODEC_INIT
+ #define FF_API_AVCODEC_INIT     (LIBAVCODEC_VERSION_MAJOR < 54)
+ #endif
  
  #endif /* AVCODEC_VERSION_H */