Merge commit 'ad0c9f2d5d81e22207c6ccecc426bf7306acc327'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 8 Mar 2013 18:35:37 +0000 (19:35 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 8 Mar 2013 18:35:37 +0000 (19:35 +0100)
* commit 'ad0c9f2d5d81e22207c6ccecc426bf7306acc327':
  lavc: move AVFrame.hwaccel_picture_private to Picture.

Conflicts:
libavcodec/avcodec.h
libavcodec/mpegvideo.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/avcodec.h
libavcodec/dxva2_h264.c
libavcodec/dxva2_mpeg2.c
libavcodec/dxva2_vc1.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavutil/version.h

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
   */
  
@@@ -31,7 -31,6 +31,7 @@@
  #include "libavutil/avutil.h"
  #include "libavutil/buffer.h"
  #include "libavutil/cpu.h"
 +#include "libavutil/channel_layout.h"
  #include "libavutil/dict.h"
  #include "libavutil/log.h"
  #include "libavutil/pixfmt.h"
@@@ -89,8 -88,7 +89,8 @@@
   *
   * If you add a codec ID to this list, add it so that
   * 1. no value of a existing codec ID changes (that would break ABI),
 - * 2. it is as close as possible to similar codecs.
 + * 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec.
 + *    This ensures that 2 forks can independently add AVCodecIDs without producing conflicts.
   *
   * After adding new codec IDs, do not forget to add an entry to the codec
   * descriptor list and bump libavcodec minor version.
@@@ -155,7 -153,9 +155,7 @@@ enum AVCodecID 
      AV_CODEC_ID_MSZH,
      AV_CODEC_ID_ZLIB,
      AV_CODEC_ID_QTRLE,
 -#if FF_API_SNOW
      AV_CODEC_ID_SNOW,
 -#endif
      AV_CODEC_ID_TSCC,
      AV_CODEC_ID_ULTI,
      AV_CODEC_ID_QDRAW,
      AV_CODEC_ID_CLLC,
      AV_CODEC_ID_MSS2,
      AV_CODEC_ID_VP9,
 +    AV_CODEC_ID_BRENDER_PIX= MKBETAG('B','P','I','X'),
 +    AV_CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),
 +    AV_CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),
 +    AV_CODEC_ID_EXR        = MKBETAG('0','E','X','R'),
 +    AV_CODEC_ID_AVRP       = MKBETAG('A','V','R','P'),
 +
 +    AV_CODEC_ID_012V       = MKBETAG('0','1','2','V'),
 +    AV_CODEC_ID_G2M        = MKBETAG( 0 ,'G','2','M'),
 +    AV_CODEC_ID_AVUI       = MKBETAG('A','V','U','I'),
 +    AV_CODEC_ID_AYUV       = MKBETAG('A','Y','U','V'),
 +    AV_CODEC_ID_TARGA_Y216 = MKBETAG('T','2','1','6'),
 +    AV_CODEC_ID_V308       = MKBETAG('V','3','0','8'),
 +    AV_CODEC_ID_V408       = MKBETAG('V','4','0','8'),
 +    AV_CODEC_ID_YUV4       = MKBETAG('Y','U','V','4'),
 +    AV_CODEC_ID_SANM       = MKBETAG('S','A','N','M'),
 +    AV_CODEC_ID_PAF_VIDEO  = MKBETAG('P','A','F','V'),
 +    AV_CODEC_ID_AVRN       = MKBETAG('A','V','R','n'),
 +    AV_CODEC_ID_CPIA       = MKBETAG('C','P','I','A'),
 +    AV_CODEC_ID_XFACE      = MKBETAG('X','F','A','C'),
 +    AV_CODEC_ID_SGIRLE     = MKBETAG('S','G','I','R'),
 +    AV_CODEC_ID_MVC1       = MKBETAG('M','V','C','1'),
 +    AV_CODEC_ID_MVC2       = MKBETAG('M','V','C','2'),
  
      /* various PCM "codecs" */
      AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
      AV_CODEC_ID_PCM_LXF,
      AV_CODEC_ID_S302M,
      AV_CODEC_ID_PCM_S8_PLANAR,
 +    AV_CODEC_ID_PCM_S24LE_PLANAR = MKBETAG(24,'P','S','P'),
 +    AV_CODEC_ID_PCM_S32LE_PLANAR = MKBETAG(32,'P','S','P'),
 +    AV_CODEC_ID_PCM_S16BE_PLANAR = MKBETAG('P','S','P',16),
  
      /* various ADPCM codecs */
      AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
      AV_CODEC_ID_ADPCM_IMA_ISS,
      AV_CODEC_ID_ADPCM_G722,
      AV_CODEC_ID_ADPCM_IMA_APC,
 +    AV_CODEC_ID_VIMA       = MKBETAG('V','I','M','A'),
 +    AV_CODEC_ID_ADPCM_AFC  = MKBETAG('A','F','C',' '),
 +    AV_CODEC_ID_ADPCM_IMA_OKI = MKBETAG('O','K','I',' '),
  
      /* AMR */
      AV_CODEC_ID_AMR_NB = 0x12000,
      AV_CODEC_ID_RALF,
      AV_CODEC_ID_IAC,
      AV_CODEC_ID_ILBC,
 -    AV_CODEC_ID_OPUS,
 +    AV_CODEC_ID_OPUS_DEPRECATED,
      AV_CODEC_ID_COMFORT_NOISE,
 -    AV_CODEC_ID_TAK,
 +    AV_CODEC_ID_TAK_DEPRECATED,
 +    AV_CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
 +#if LIBAVCODEC_VERSION_MAJOR <= 54
 +    AV_CODEC_ID_8SVX_RAW    = MKBETAG('8','S','V','X'),
 +#endif
 +    AV_CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
 +    AV_CODEC_ID_SONIC_LS    = MKBETAG('S','O','N','L'),
 +    AV_CODEC_ID_PAF_AUDIO   = MKBETAG('P','A','F','A'),
 +    AV_CODEC_ID_OPUS        = MKBETAG('O','P','U','S'),
 +    AV_CODEC_ID_TAK         = MKBETAG('t','B','a','K'),
 +    AV_CODEC_ID_EVRC        = MKBETAG('s','e','v','c'),
 +    AV_CODEC_ID_SMV         = MKBETAG('s','s','m','v'),
  
      /* subtitle codecs */
      AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
      AV_CODEC_ID_HDMV_PGS_SUBTITLE,
      AV_CODEC_ID_DVB_TELETEXT,
      AV_CODEC_ID_SRT,
 +    AV_CODEC_ID_MICRODVD   = MKBETAG('m','D','V','D'),
 +    AV_CODEC_ID_EIA_608    = MKBETAG('c','6','0','8'),
 +    AV_CODEC_ID_JACOSUB    = MKBETAG('J','S','U','B'),
 +    AV_CODEC_ID_SAMI       = MKBETAG('S','A','M','I'),
 +    AV_CODEC_ID_REALTEXT   = MKBETAG('R','T','X','T'),
 +    AV_CODEC_ID_SUBVIEWER1 = MKBETAG('S','b','V','1'),
 +    AV_CODEC_ID_SUBVIEWER  = MKBETAG('S','u','b','V'),
 +    AV_CODEC_ID_SUBRIP     = MKBETAG('S','R','i','p'),
 +    AV_CODEC_ID_WEBVTT     = MKBETAG('W','V','T','T'),
 +    AV_CODEC_ID_MPL2       = MKBETAG('M','P','L','2'),
 +    AV_CODEC_ID_VPLAYER    = MKBETAG('V','P','l','r'),
 +    AV_CODEC_ID_PJS        = MKBETAG('P','h','J','S'),
  
      /* other specific kind of codecs (generally used for attachments) */
      AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
      AV_CODEC_ID_TTF = 0x18000,
 +    AV_CODEC_ID_BINTEXT    = MKBETAG('B','T','X','T'),
 +    AV_CODEC_ID_XBIN       = MKBETAG('X','B','I','N'),
 +    AV_CODEC_ID_IDF        = MKBETAG( 0 ,'I','D','F'),
 +    AV_CODEC_ID_OTF        = MKBETAG( 0 ,'O','T','F'),
 +    AV_CODEC_ID_SMPTE_KLV  = MKBETAG('K','L','V','A'),
  
      AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
  
@@@ -541,10 -485,6 +541,10 @@@ typedef struct AVCodecDescriptor 
   * Codec supports lossless compression. Audio and video codecs only.
   */
  #define AV_CODEC_PROP_LOSSLESS      (1 << 2)
 +/**
 + * Subtitle codec is bitmap based
 + */
 +#define AV_CODEC_PROP_BITMAP_SUB    (1 << 16)
  
  #if FF_API_OLD_DECODE_AUDIO
  /* in bytes */
   * 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
  
  /**
   * @ingroup lavc_encoding
@@@ -582,7 -522,9 +582,7 @@@ enum Motion_Est_ID 
      ME_X1,          ///< reserved for experiments
      ME_HEX,         ///< hexagon based search
      ME_UMH,         ///< uneven multi-hexagon search
 -#if FF_API_SNOW
      ME_ITER,        ///< iterative search
 -#endif
      ME_TESA,        ///< transformed exhaustive search algorithm
  };
  
@@@ -631,7 -573,6 +631,7 @@@ enum AVColorSpace
      AVCOL_SPC_YCOCG       = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
      AVCOL_SPC_NB             , ///< Not part of ABI
  };
 +#define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
  
  enum AVColorRange{
      AVCOL_RANGE_UNSPECIFIED = 0,
@@@ -717,7 -658,6 +717,7 @@@ typedef struct RcOverride
  #define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.
  #define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.
  #define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.
 +#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
  #define CODEC_FLAG2_IGNORE_CROP   0x00010000 ///< Discard cropping information from SPS.
  
  #if FF_API_MPV_GLOBAL_OPTS
  #define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping
  #endif
  #define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
 +#define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe
  
  /* Unsupported options :
   *              Syntax Arithmetic coding (SAC)
   * 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.
   */
   * Audio encoder supports receiving a different number of samples in each call.
   */
  #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
 +/**
 + * Codec is intra only.
 + */
 +#define CODEC_CAP_INTRA_ONLY       0x40000000
 +/**
 + * 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
@@@ -950,52 -879,6 +950,52 @@@ enum AVPacketSideDataType 
       * @endcode
       */
      AV_PKT_DATA_H263_MB_INFO,
 +
 +    /**
 +     * Recommmends skipping the specified number of samples
 +     * @code
 +     * u32le number of samples to skip from start of this packet
 +     * u32le number of samples to skip from end of this packet
 +     * u8    reason for start skip
 +     * u8    reason for end   skip (0=padding silence, 1=convergence)
 +     * @endcode
 +     */
 +    AV_PKT_DATA_SKIP_SAMPLES=70,
 +
 +    /**
 +     * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
 +     * the packet may contain "dual mono" audio specific to Japanese DTV
 +     * and if it is true, recommends only the selected channel to be used.
 +     * @code
 +     * u8    selected channels (0=mail/left, 1=sub/right, 2=both)
 +     * @endcode
 +     */
 +    AV_PKT_DATA_JP_DUALMONO,
 +
 +    /**
 +     * A list of zero terminated key/value strings. There is no end marker for
 +     * the list, so it is required to rely on the side data size to stop.
 +     */
 +    AV_PKT_DATA_STRINGS_METADATA,
 +
 +    /**
 +     * Subtitle event position
 +     * @code
 +     * u32le x1
 +     * u32le y1
 +     * u32le x2
 +     * u32le y2
 +     * @endcode
 +     */
 +    AV_PKT_DATA_SUBTITLE_POSITION,
 +
 +    /**
 +     * Data found in BlockAdditional element of matroska container. There is
 +     * no end marker for the data, so it is required to rely on the side data
 +     * size to recognize the end. 8 byte id (as found in BlockAddId) followed
 +     * by data.
 +     */
 +    AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
  };
  
  /**
   * For video, it should typically contain one compressed frame. For audio it may
   * contain several compressed frames.
   *
 - * AVPacket is one of the few structs in Libav, whose size is a part of public
 + * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
   * ABI. Thus it may be allocated on stack and no new fields can be added to it
   * without libavcodec and libavformat major bump.
   *
@@@ -1120,9 -1003,6 +1120,9 @@@ enum AVSideDataParamChangeFlags 
   *
   * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added
   * to the end with a minor bump.
 + * Similarly fields that are marked as to be only accessed by
 + * av_opt_ptr() can be reordered. This allows 2 forks to add fields
 + * without breaking compatibility with each other.
   */
  typedef struct AVFrame {
  #define AV_NUM_DATA_POINTERS 8
       */
      int64_t reordered_opaque;
  
+ #if FF_API_AVFRAME_LAVC
      /**
-      * hardware accelerator private data (FFmpeg-allocated)
-      * - encoding: unused
-      * - decoding: Set by libavcodec
+      * @deprecated this field is unused
       */
-     void *hwaccel_picture_private;
+     attribute_deprecated void *hwaccel_picture_private;
+ #endif
  
      /**
       * the AVCodecContext which ff_thread_get_buffer() was last called on
       * Sample rate of the audio data.
       *
       * - encoding: unused
 -     * - decoding: set by get_buffer()
 +     * - decoding: read by user
       */
      int sample_rate;
  
       * Channel layout of the audio data.
       *
       * - encoding: unused
 -     * - decoding: set by get_buffer()
 +     * - decoding: read by user.
       */
      uint64_t channel_layout;
 +
 +    /**
 +     * frame timestamp estimated using various heuristics, in stream time base
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_best_effort_timestamp(frame)
 +     * - 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
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_pkt_pos(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_pos;
 +
 +    /**
 +     * duration of the corresponding packet, expressed in
 +     * AVStream->time_base units, 0 if unknown.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_pkt_duration(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_duration;
 +
 +    /**
 +     * metadata.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_metadata(frame)
 +     * - encoding: Set by user.
 +     * - decoding: Set by libavcodec.
 +     */
 +    AVDictionary *metadata;
 +
 +    /**
 +     * decode error flags of the frame, set to a combination of
 +     * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there
 +     * were errors during the decoding.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_decode_error_flags(frame)
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int decode_error_flags;
 +#define FF_DECODE_ERROR_INVALID_BITSTREAM   1
 +#define FF_DECODE_ERROR_MISSING_REFERENCE   2
 +
 +    /**
 +     * number of audio channels, only used for audio.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_channels(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int channels;
 +
 +    /**
 +     * size of the corresponding packet containing the compressed
 +     * frame. It must be accessed using av_frame_get_pkt_size() and
 +     * av_frame_set_pkt_size().
 +     * It is set to a negative value if unknown.
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int pkt_size;
  } AVFrame;
  
 +/**
 + * Accessors for some AVFrame fields.
 + * The position of these field in the structure is not part of the ABI,
 + * they should not be accessed directly outside libavcodec.
 + */
 +int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
 +void    av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
 +int64_t av_frame_get_pkt_duration         (const AVFrame *frame);
 +void    av_frame_set_pkt_duration         (AVFrame *frame, int64_t val);
 +int64_t av_frame_get_pkt_pos              (const AVFrame *frame);
 +void    av_frame_set_pkt_pos              (AVFrame *frame, int64_t val);
 +int64_t av_frame_get_channel_layout       (const AVFrame *frame);
 +void    av_frame_set_channel_layout       (AVFrame *frame, int64_t val);
 +int     av_frame_get_channels             (const AVFrame *frame);
 +void    av_frame_set_channels             (AVFrame *frame, int     val);
 +int     av_frame_get_sample_rate          (const AVFrame *frame);
 +void    av_frame_set_sample_rate          (AVFrame *frame, int     val);
 +AVDictionary *av_frame_get_metadata       (const AVFrame *frame);
 +void          av_frame_set_metadata       (AVFrame *frame, AVDictionary *val);
 +int     av_frame_get_decode_error_flags   (const AVFrame *frame);
 +void    av_frame_set_decode_error_flags   (AVFrame *frame, int     val);
 +int     av_frame_get_pkt_size(const AVFrame *frame);
 +void    av_frame_set_pkt_size(AVFrame *frame, int val);
 +
  struct AVCodecInternal;
  
  enum AVFieldOrder {
   * New fields can be added to the end with minor version bumps.
   * Removal, reordering and changes to existing fields require a major
   * version bump.
 + * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user
 + * applications.
   * sizeof(AVCodecContext) must not be used outside libav*.
   */
  typedef struct AVCodecContext {
      /**
       * Codec delay.
       *
 +     * Encoding: Number of frames delay there will be from the encoder input to
 +     *           the decoder output. (we assume the decoder matches the spec)
 +     * Decoding: Number of frames delay in addition to what a standard decoder
 +     *           as specified in the spec would produce.
 +     *
       * Video:
       *   Number of frames the decoded output will be delayed relative to the
       *   encoded input.
      int width, height;
  
      /**
 -     * Bitstream width / height, may be different from width/height.
 +     * Bitstream width / height, may be different from width/height if lowres enabled.
       * - encoding: unused
       * - decoding: Set by user before init if known. Codec should override / dynamically change if needed.
       */
      /**
       * Pixel format, see AV_PIX_FMT_xxx.
       * May be set by the demuxer if known from headers.
 -     * May be overriden by the decoder if it knows better.
 +     * May be overridden by the decoder if it knows better.
       * - encoding: Set by user.
       * - decoding: Set by user if known, overridden by libavcodec if known
       */
      /**
       * Motion estimation algorithm used for video coding.
       * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex),
 -     * 8 (umh), 10 (tesa) [7, 8, 10 are x264 specific]
 +     * 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific]
       * - encoding: MUST be set by user.
       * - decoding: unused
       */
  #define FF_CMP_VSAD   8
  #define FF_CMP_VSSE   9
  #define FF_CMP_NSSE   10
 -#if FF_API_SNOW
  #define FF_CMP_W53    11
  #define FF_CMP_W97    12
 -#endif
  #define FF_CMP_DCTMAX 13
  #define FF_CMP_DCT264 14
  #define FF_CMP_CHROMA 256
  
      /** Field order
       * - encoding: set by libavcodec
 -     * - decoding: Set by libavcodec
 +     * - decoding: Set by user.
       */
      enum AVFieldOrder field_order;
  
      /**
       * Audio channel layout.
       * - encoding: set by user.
 -     * - decoding: set by libavcodec.
 +     * - decoding: set by user, may be overwritten by libavcodec.
       */
      uint64_t channel_layout;
  
      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;
  
      int max_prediction_order;
  
      /**
 -     * GOP timecode frame start number, in non drop frame format
 -     * - encoding: Set by user.
 -     * - decoding: unused
 +     * GOP timecode frame start number
 +     * - encoding: Set by user, in non drop frame format
 +     * - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
       */
      int64_t timecode_frame_start;
  
  #define AV_EF_BUFFER    (1<<2)
  #define AV_EF_EXPLODE   (1<<3)
  
 +#define AV_EF_CAREFUL    (1<<16)
 +#define AV_EF_COMPLIANT  (1<<17)
 +#define AV_EF_AGGRESSIVE (1<<18)
 +
 +
      /**
       * opaque 64bit number (generally a PTS) that will be reordered and
       * output in AVFrame.reordered_opaque
       * 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
  #define FF_IDCT_INT           1
  #define FF_IDCT_SIMPLE        2
  #define FF_IDCT_SIMPLEMMX     3
 -#if FF_API_LIBMPEG2
  #define FF_IDCT_LIBMPEG2MMX   4
 -#endif
  #if FF_API_MMI
  #define FF_IDCT_MMI           5
  #endif
       * - encoding: unused
       * - decoding: Set by user.
       */
 -    attribute_deprecated int lowres;
 +     int lowres;
  
      /**
       * the picture in the bitstream
       * - decoding: unused.
       */
      uint64_t vbv_delay;
 +
 +    /**
 +     * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_pkt_timebase(avctx)
 +     * - encoding unused.
 +     * - decodimg set by user
 +     */
 +    AVRational pkt_timebase;
 +
 +    /**
 +     * AVCodecDescriptor
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_codec_descriptor(avctx)
 +     * - encoding: unused.
 +     * - decoding: set by libavcodec.
 +     */
 +    const AVCodecDescriptor *codec_descriptor;
 +
 +    /**
 +     * 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
 +
 +    /**
 +     * Current frame metadata.
 +     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
 +     * - encoding: unused
 +     */
 +    AVDictionary *metadata;
 +
 +    /**
 +     * Character encoding of the input subtitles file.
 +     * - decoding: set by user
 +     * - encoding: unused
 +     */
 +    char *sub_charenc;
 +
 +    /**
 +     * Subtitles character encoding mode. Formats or codecs might be adjusting
 +     * this setting (if they are doing the conversion themselves for instance).
 +     * - decoding: set by libavcodec
 +     * - encoding: unused
 +     */
 +    int sub_charenc_mode;
 +#define FF_SUB_CHARENC_MODE_DO_NOTHING  -1  ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
 +#define FF_SUB_CHARENC_MODE_AUTOMATIC    0  ///< libavcodec will select the mode itself
 +#define FF_SUB_CHARENC_MODE_PRE_DECODER  1  ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
  } AVCodecContext;
  
 +AVRational av_codec_get_pkt_timebase         (const AVCodecContext *avctx);
 +void       av_codec_set_pkt_timebase         (AVCodecContext *avctx, AVRational val);
 +
 +const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
 +void                     av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
 +
  /**
   * AVProfile.
   */
@@@ -3285,7 -3004,7 +3285,7 @@@ typedef struct AVCodec 
      const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
      const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
      const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
 -    attribute_deprecated uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
 +    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
      const AVClass *priv_class;              ///< AVClass for the private context
      const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
  
@@@ -3462,6 -3181,9 +3462,6 @@@ typedef struct AVPicture 
   * @}
   */
  
 -#define AVPALETTE_SIZE 1024
 -#define AVPALETTE_COUNT 256
 -
  enum AVSubtitleType {
      SUBTITLE_NONE,
  
@@@ -3500,11 -3222,10 +3500,11 @@@ typedef struct AVSubtitleRect 
  
      /**
       * 0 terminated ASS/SSA compatible event line.
 -     * The pressentation of this is unaffected by the other values in this
 +     * The presentation of this is unaffected by the other values in this
       * struct.
       */
      char *ass;
 +
      int flags;
  } AVSubtitleRect;
  
@@@ -3561,40 -3282,6 +3561,40 @@@ void avcodec_register(AVCodec *codec)
   */
  void avcodec_register_all(void);
  
 +
 +#if FF_API_ALLOC_CONTEXT
 +/**
 + * Allocate an AVCodecContext and set its fields to default values.  The
 + * resulting struct can be deallocated by simply calling av_free().
 + *
 + * @return An AVCodecContext filled with default values or NULL on failure.
 + * @see avcodec_get_context_defaults
 + *
 + * @deprecated use avcodec_alloc_context3()
 + */
 +attribute_deprecated
 +AVCodecContext *avcodec_alloc_context(void);
 +
 +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
 + *  we WILL change its arguments and name a few times! */
 +attribute_deprecated
 +AVCodecContext *avcodec_alloc_context2(enum AVMediaType);
 +
 +/**
 + * Set the fields of the given AVCodecContext to default values.
 + *
 + * @param s The AVCodecContext of which the fields should be set to default values.
 + * @deprecated use avcodec_get_context_defaults3
 + */
 +attribute_deprecated
 +void avcodec_get_context_defaults(AVCodecContext *s);
 +
 +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
 + *  we WILL change its arguments and name a few times! */
 +attribute_deprecated
 +void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType);
 +#endif
 +
  /**
   * Allocate an AVCodecContext and set its fields to default values.  The
   * resulting struct can be deallocated by calling avcodec_close() on it followed
@@@ -3632,22 -3319,6 +3632,22 @@@ int avcodec_get_context_defaults3(AVCod
  const AVClass *avcodec_get_class(void);
  
  /**
 + * Get the AVClass for AVFrame. It can be used in combination with
 + * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 + *
 + * @see av_opt_find().
 + */
 +const AVClass *avcodec_get_frame_class(void);
 +
 +/**
 + * Get the AVClass for AVSubtitleRect. It can be used in combination with
 + * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 + *
 + * @see av_opt_find().
 + */
 +const AVClass *avcodec_get_subtitle_rect_class(void);
 +
 +/**
   * Copy the settings of the source AVCodecContext into the destination
   * AVCodecContext. The resulting destination codec context will be
   * unopened, i.e. you are required to call avcodec_open2() before you
@@@ -3688,40 -3359,6 +3688,40 @@@ void avcodec_get_frame_defaults(AVFram
   */
  void avcodec_free_frame(AVFrame **frame);
  
 +#if FF_API_AVCODEC_OPEN
 +/**
 + * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
 + * function the context has to be allocated.
 + *
 + * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
 + * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
 + * retrieving a codec.
 + *
 + * @warning This function is not thread safe!
 + *
 + * @code
 + * avcodec_register_all();
 + * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
 + * if (!codec)
 + *     exit(1);
 + *
 + * context = avcodec_alloc_context3(codec);
 + *
 + * if (avcodec_open(context, codec) < 0)
 + *     exit(1);
 + * @endcode
 + *
 + * @param avctx The context which will be set up to use the given codec.
 + * @param codec The codec to use within the context.
 + * @return zero on success, a negative value on error
 + * @see avcodec_alloc_context3, avcodec_find_decoder, avcodec_find_encoder, avcodec_close
 + *
 + * @deprecated use avcodec_open2
 + */
 +attribute_deprecated
 +int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
 +#endif
 +
  /**
   * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
   * function the context has to be allocated with avcodec_alloc_context3().
@@@ -3854,13 -3491,6 +3854,13 @@@ int av_packet_from_data(AVPacket *pkt, 
  int av_dup_packet(AVPacket *pkt);
  
  /**
 + * Copy packet, including contents
 + *
 + * @return 0 on success, negative AVERROR on fail
 + */
 +int av_copy_packet(AVPacket *dst, AVPacket *src);
 +
 +/**
   * Free a packet.
   *
   * @param pkt packet to free
@@@ -3900,11 -3530,6 +3900,11 @@@ int av_packet_shrink_side_data(AVPacke
  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);
 +
 +
  /**
   * @}
   */
@@@ -4060,7 -3685,7 +4060,7 @@@ attribute_deprecated int avcodec_decode
   *         AVPacket is returned.
   */
  int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
 -                          int *got_frame_ptr, AVPacket *avpkt);
 +                          int *got_frame_ptr, const AVPacket *avpkt);
  
  /**
   * Decode the video frame of size avpkt->size from avpkt->data into picture.
   */
  int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                           int *got_picture_ptr,
 -                         AVPacket *avpkt);
 +                         const AVPacket *avpkt);
  
  /**
   * Decode a subtitle message.
@@@ -4170,7 -3795,6 +4170,7 @@@ typedef struct AVCodecParserContext 
  #define PARSER_FLAG_ONCE                      0x0002
  /// Set if the parser has a valid file offset
  #define PARSER_FLAG_FETCHED_OFFSET            0x0004
 +#define PARSER_FLAG_USE_CODEC_TS              0x1000
  
      int64_t offset;      ///< byte offset from starting packet start
      int64_t cur_frame_end[AV_PARSER_PTS_NB];
@@@ -4400,12 -4024,11 +4400,12 @@@ int attribute_deprecated avcodec_encode
   *                  The user can supply an output buffer by setting
   *                  avpkt->data and avpkt->size prior to calling the
   *                  function, but if the size of the user-provided data is not
 - *                  large enough, encoding will fail. All other AVPacket fields
 - *                  will be reset by the encoder using av_init_packet(). If
 - *                  avpkt->data is NULL, the encoder will allocate it.
 - *                  The encoder will set avpkt->size to the size of the
 - *                  output packet.
 + *                  large enough, encoding will fail. If avpkt->data and
 + *                  avpkt->size are set, avpkt->destruct must also be set. All
 + *                  other AVPacket fields will be reset by the encoder using
 + *                  av_init_packet(). If avpkt->data is NULL, the encoder will
 + *                  allocate it. The encoder will set avpkt->size to the size
 + *                  of the output packet.
   *
   *                  If this function fails or produces no output, avpkt will be
   *                  freed using av_free_packet() (i.e. avpkt->destruct will be
@@@ -4498,7 -4121,7 +4498,7 @@@ int avcodec_encode_subtitle(AVCodecCont
  /**
   * @defgroup lavc_resample Audio resampling
   * @ingroup libavc
 - * @deprecated use libavresample instead
 + * @deprecated use libswresample instead
   *
   * @{
   */
@@@ -4619,19 -4242,42 +4619,19 @@@ int avpicture_alloc(AVPicture *picture
  void avpicture_free(AVPicture *picture);
  
  /**
 - * Fill in the AVPicture fields.
 - * The fields of the given AVPicture are filled in by using the 'ptr' address
 - * which points to the image data buffer. Depending on the specified picture
 - * format, one or multiple image data pointers and line sizes will be set.
 - * If a planar format is specified, several pointers will be set pointing to
 - * the different picture planes and the line sizes of the different planes
 - * will be stored in the lines_sizes array.
 - * Call with ptr == NULL to get the required size for the ptr buffer.
 + * Fill in the AVPicture fields, always assume a linesize alignment of
 + * 1.
   *
 - * To allocate the buffer and fill in the AVPicture fields in one call,
 - * use avpicture_alloc().
 - *
 - * @param picture AVPicture whose fields are to be filled in
 - * @param ptr Buffer which will contain or contains the actual image data
 - * @param pix_fmt The format in which the picture data is stored.
 - * @param width the width of the image in pixels
 - * @param height the height of the image in pixels
 - * @return size of the image data in bytes
 + * @see av_image_fill_arrays()
   */
 -int avpicture_fill(AVPicture *picture, uint8_t *ptr,
 +int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
                     enum AVPixelFormat pix_fmt, int width, int height);
  
  /**
 - * Copy pixel data from an AVPicture into a buffer.
 - * The data is stored compactly, without any gaps for alignment or padding
 - * which may be applied by avpicture_fill().
 - *
 - * @see avpicture_get_size()
 + * Copy pixel data from an AVPicture into a buffer, always assume a
 + * linesize alignment of 1.
   *
 - * @param[in] src AVPicture containing image data
 - * @param[in] pix_fmt The format in which the picture data is stored.
 - * @param[in] width the width of the image in pixels.
 - * @param[in] height the height of the image in pixels.
 - * @param[out] dest A buffer into which picture data will be copied.
 - * @param[in] dest_size The size of 'dest'.
 - * @return The number of bytes written to dest, or a negative value (error code) on error.
 + * @see av_image_copy_to_buffer()
   */
  int avpicture_layout(const AVPicture* src, enum AVPixelFormat pix_fmt,
                       int width, int height,
  /**
   * Calculate the size in bytes that a picture of the given width and height
   * would occupy if stored in the given picture format.
 - * Note that this returns the size of a compact representation as generated
 - * by avpicture_layout(), which can be smaller than the size required for e.g.
 - * avpicture_fill().
 + * Always assume a linesize alignment of 1.
   *
 - * @param pix_fmt the given picture format
 - * @param width the width of the image
 - * @param height the height of the image
 - * @return Image data size in bytes or -1 on error (e.g. too large dimensions).
 + * @see av_image_get_buffer_size().
   */
  int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
  
@@@ -4657,7 -4308,7 +4657,7 @@@ int avpicture_deinterlace(AVPicture *ds
                            enum AVPixelFormat pix_fmt, int width, int height);
  #endif
  /**
 - * Copy image src to dst. Wraps av_picture_data_copy() above.
 + * Copy image src to dst. Wraps av_image_copy().
   */
  void av_picture_copy(AVPicture *dst, const AVPicture *src,
                       enum AVPixelFormat pix_fmt, int width, int height);
@@@ -4695,21 -4346,10 +4695,21 @@@ int av_picture_pad(AVPicture *dst, cons
   */
  
  /**
 - * @deprecated Use av_pix_fmt_get_chroma_sub_sample
 + * Utility function to access log2_chroma_w log2_chroma_h from
 + * the pixel format AVPixFmtDescriptor.
 + *
 + * This function asserts that pix_fmt is valid. See av_pix_fmt_get_chroma_sub_sample
 + * for one that returns a failure code and continues in case of invalid
 + * pix_fmts.
 + *
 + * @param[in]  pix_fmt the pixel format
 + * @param[out] h_shift store log2_chroma_h
 + * @param[out] v_shift store log2_chroma_w
 + *
 + * @see av_pix_fmt_get_chroma_sub_sample
   */
  
 -void attribute_deprecated avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
 +void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
  
  /**
   * Return a value representing the fourCC code associated to the
@@@ -4740,15 -4380,14 +4740,15 @@@ unsigned int avcodec_pix_fmt_to_codec_t
   * @param[in] dst_pix_fmt destination pixel format
   * @param[in] src_pix_fmt source pixel format
   * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 - * @return Combination of flags informing you what kind of losses will occur.
 + * @return Combination of flags informing you what kind of losses will occur
 + * (maximum loss for an invalid dst_pix_fmt).
   */
  int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
                               int has_alpha);
  
  #if FF_API_FIND_BEST_PIX_FMT
  /**
 - * @deprecated use avcodec_find_best_pix_fmt2() instead.
 + * @deprecated use avcodec_find_best_pix_fmt_of_2() instead.
   *
   * Find the best pixel format to convert to given a certain source pixel
   * format.  When converting from one pixel format to another, information loss
   * The pixel formats from which it chooses one, are determined by the
   * pix_fmt_mask parameter.
   *
 + * Note, only the first 64 pixel formats will fit in pix_fmt_mask.
 + *
   * @code
   * src_pix_fmt = AV_PIX_FMT_YUV420P;
 - * pix_fmt_mask = (1 << AV_PIX_FMT_YUV422P) || (1 << AV_PIX_FMT_RGB24);
 + * pix_fmt_mask = (1 << AV_PIX_FMT_YUV422P) | (1 << AV_PIX_FMT_RGB24);
   * dst_pix_fmt = avcodec_find_best_pix_fmt(pix_fmt_mask, src_pix_fmt, alpha, &loss);
   * @endcode
   *
@@@ -4783,7 -4420,7 +4783,7 @@@ enum AVPixelFormat avcodec_find_best_pi
   * format.  When converting from one pixel format to another, information loss
   * may occur.  For example, when converting from RGB24 to GRAY, the color
   * information will be lost. Similarly, other losses occur when converting from
 - * some formats to other formats. avcodec_find_best_pix_fmt2() searches which of
 + * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of
   * the given pixel formats should be used to suffer the least amount of loss.
   * The pixel formats from which it chooses one, are determined by the
   * pix_fmt_list parameter.
   * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.
   * @return The best pixel format to convert to or -1 if none was found.
   */
 +enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(enum AVPixelFormat *pix_fmt_list,
 +                                            enum AVPixelFormat src_pix_fmt,
 +                                            int has_alpha, int *loss_ptr);
 +
 +/**
 + * Find the best pixel format to convert to given a certain source pixel
 + * format and a selection of two destination pixel formats. When converting from
 + * one pixel format to another, information loss may occur.  For example, when converting
 + * from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when
 + * converting from some formats to other formats. avcodec_find_best_pix_fmt_of_2() selects which of
 + * the given pixel formats should be used to suffer the least amount of loss.
 + *
 + * If one of the destination formats is AV_PIX_FMT_NONE the other pixel format (if valid) will be
 + * returned.
 + *
 + * @code
 + * src_pix_fmt = AV_PIX_FMT_YUV420P;
 + * dst_pix_fmt1= AV_PIX_FMT_RGB24;
 + * dst_pix_fmt2= AV_PIX_FMT_GRAY8;
 + * dst_pix_fmt3= AV_PIX_FMT_RGB8;
 + * loss= FF_LOSS_CHROMA; // don't care about chroma loss, so chroma loss will be ignored.
 + * dst_pix_fmt = avcodec_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, alpha, &loss);
 + * dst_pix_fmt = avcodec_find_best_pix_fmt_of_2(dst_pix_fmt, dst_pix_fmt3, src_pix_fmt, alpha, &loss);
 + * @endcode
 + *
 + * @param[in] dst_pix_fmt1 One of the two destination pixel formats to choose from
 + * @param[in] dst_pix_fmt2 The other of the two destination pixel formats to choose from
 + * @param[in] src_pix_fmt Source pixel format
 + * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 + * @param[in, out] loss_ptr Combination of loss flags. In: selects which of the losses to ignore, i.e.
 + *                               NULL or value of zero means we care about all losses. Out: the loss
 + *                               that occurs when converting from src to selected dst pixel format.
 + * @return The best pixel format to convert to or -1 if none was found.
 + */
 +enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
 +                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +
 +attribute_deprecated
 +#if AV_HAVE_INCOMPATIBLE_FORK_ABI
  enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list,
                                                enum AVPixelFormat src_pix_fmt,
                                                int has_alpha, int *loss_ptr);
 +#else
 +enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
 +                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +#endif
 +
  
  enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
  
@@@ -4876,12 -4469,7 +4876,12 @@@ int avcodec_default_execute2(AVCodecCon
  //FIXME func typedef
  
  /**
 - * Fill audio frame data and linesize.
 + * Fill AVFrame audio data and linesize pointers.
 + *
 + * The buffer buf must be a preallocated buffer with a size big enough
 + * to contain the specified samples amount. The filled AVFrame data
 + * pointers will point to this buffer.
 + *
   * AVFrame extended_data channel pointers are allocated if necessary for
   * planar audio.
   *
   * @param buf         buffer to use for frame data
   * @param buf_size    size of buffer
   * @param align       plane size sample alignment (0 = default)
 - * @return            0 on success, negative error code on failure
 + * @return            >=0 on success, negative error code on failure
 + * @todo return the size in bytes required to store the samples in
 + * case of success, at the next libavutil bump
   */
  int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
                               enum AVSampleFormat sample_fmt, const uint8_t *buf,
@@@ -4918,14 -4504,6 +4918,14 @@@ void avcodec_default_free_buffers(AVCod
  int av_get_bits_per_sample(enum AVCodecID codec_id);
  
  /**
 + * Return the PCM codec associated with a sample format.
 + * @param be  endianness, 0 for little, 1 for big,
 + *            -1 (or anything else) for native
 + * @return  AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
 + */
 +enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
 +
 +/**
   * Return codec bits per sample.
   * Only return non-zero if the bits per sample is exactly correct, not an
   * approximation.
@@@ -4999,21 -4577,15 +4999,21 @@@ void *av_fast_realloc(void *ptr, unsign
  void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
  
  /**
 - * Allocate a buffer with padding, reusing the given one if large enough.
 - *
   * Same behaviour av_fast_malloc but the buffer has additional
 - * FF_INPUT_PADDING_SIZE at the end which will always memset to 0.
 + * FF_INPUT_BUFFER_PADDING_SIZE at the end which will will always be 0.
   *
 + * In addition the whole buffer will initially and after resizes
 + * be 0-initialized so that no uninitialized data will ever appear.
   */
  void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
  
  /**
 + * Same behaviour av_fast_padded_malloc except that buffer will always
 + * be 0-initialized after call.
 + */
 +void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);
 +
 +/**
   * Encode extradata length to a buffer. Used by xiph codecs.
   *
   * @param s buffer to write to; must be at least (v/255+1) bytes long
@@@ -5024,7 -4596,7 +5024,7 @@@ unsigned int av_xiphlacing(unsigned cha
  
  /**
   * Log 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
@@@ -5038,7 -4610,7 +5038,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
@@@ -5075,7 -4647,7 +5075,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.
@@@ -5090,12 -4662,6 +5090,12 @@@ int av_lockmgr_register(int (*cb)(void 
  enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
  
  /**
 + * Get the name of a codec.
 + * @return  a static string identifying the codec; never NULL
 + */
 +const char *avcodec_get_name(enum AVCodecID id);
 +
 +/**
   * @return a positive value if s is open (i.e. avcodec_open2() was called on it
   * with no corresponding avcodec_close()), 0 otherwise.
   */
diff --combined libavcodec/dxva2_h264.c
@@@ -3,20 -3,20 +3,20 @@@
   *
   * copyright (c) 2009 Laurent Aimar
   *
 - * 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
   */
  
@@@ -95,7 -95,7 +95,7 @@@ static void fill_picture_parameters(str
                                          ((h->sps.mb_aff &&
                                          (h->picture_structure == PICT_FRAME)) <<  1) |
                                          (h->sps.residual_color_transform_flag <<  2) |
 -                                        /* sp_for_switch_flag (not implemented by Libav) */
 +                                        /* sp_for_switch_flag (not implemented by FFmpeg) */
                                          (0                                    <<  3) |
                                          (h->sps.chroma_format_idc             <<  4) |
                                          ((h->nal_ref_idc != 0)                <<  6) |
      pp->deblocking_filter_control_present_flag = h->pps.deblocking_filter_parameters_present;
      pp->redundant_pic_cnt_present_flag= h->pps.redundant_pic_cnt_present;
      pp->Reserved8BitsB                = 0;
 -    pp->slice_group_change_rate_minus1= 0;  /* XXX not implemented by Libav */
 -    //pp->SliceGroupMap[810];               /* XXX not implemented by Libav */
 +    pp->slice_group_change_rate_minus1= 0;  /* XXX not implemented by FFmpeg */
 +    //pp->SliceGroupMap[810];               /* XXX not implemented by FFmpeg */
  }
  
  static void fill_scaling_lists(struct dxva_context *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
@@@ -257,7 -257,7 +257,7 @@@ static void fill_slice_long(AVCodecCont
              }
          }
      }
 -    slice->slice_qs_delta    = 0; /* XXX not implemented by Libav */
 +    slice->slice_qs_delta    = 0; /* XXX not implemented by FFmpeg */
      slice->slice_qp_delta    = h->qscale - h->pps.init_qp;
      slice->redundant_pic_cnt = h->redundant_pic_count;
      if (h->slice_type == AV_PICTURE_TYPE_B)
@@@ -278,7 -278,7 +278,7 @@@ static int commit_bitstream_and_slice_b
      const unsigned mb_count = h->mb_width * h->mb_height;
      struct dxva_context *ctx = avctx->hwaccel_context;
      const Picture *current_picture = h->cur_pic_ptr;
-     struct dxva2_picture_context *ctx_pic = current_picture->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
      DXVA_Slice_H264_Short *slice = NULL;
      uint8_t  *dxva_data, *current, *end;
      unsigned dxva_size;
      /* Create an annex B bitstream buffer with only slice NAL and finalize slice */
      if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->decoder,
                                                 DXVA2_BitStreamDateBufferType,
 -                                               &dxva_data, &dxva_size)))
 +                                               (void **)&dxva_data, &dxva_size)))
          return -1;
      current = dxva_data;
      end = dxva_data + dxva_size;
@@@ -373,7 -373,7 +373,7 @@@ static int dxva2_h264_start_frame(AVCod
  {
      const H264Context *h = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
-     struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->hwaccel_picture_private;
  
      if (!ctx->decoder || !ctx->cfg || ctx->surface_count <= 0)
          return -1;
@@@ -398,7 -398,7 +398,7 @@@ static int dxva2_h264_decode_slice(AVCo
      const H264Context *h = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
      const Picture *current_picture = h->cur_pic_ptr;
-     struct dxva2_picture_context *ctx_pic = current_picture->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
      unsigned position;
  
      if (ctx_pic->slice_count >= MAX_SLICES)
@@@ -426,7 -426,7 +426,7 @@@ static int dxva2_h264_end_frame(AVCodec
  {
      H264Context *h = avctx->priv_data;
      struct dxva2_picture_context *ctx_pic =
-         h->cur_pic_ptr->f.hwaccel_picture_private;
+         h->cur_pic_ptr->hwaccel_picture_private;
      int ret;
  
      if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
diff --combined libavcodec/dxva2_mpeg2.c
@@@ -3,20 -3,20 +3,20 @@@
   *
   * copyright (c) 2010 Laurent Aimar
   *
 - * 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
   */
  
@@@ -109,10 -109,10 +109,10 @@@ static void fill_quantization_matrices(
          qm->bNewQmatrix[i] = 1;
      for (i = 0; i < 64; i++) {
          int n = s->dsp.idct_permutation[ff_zigzag_direct[i]];
 -        qm->Qmatrix[0][i] = s->intra_matrix[n];;
 -        qm->Qmatrix[1][i] = s->inter_matrix[n];;
 -        qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];;
 -        qm->Qmatrix[3][i] = s->chroma_inter_matrix[n];;
 +        qm->Qmatrix[0][i] = s->intra_matrix[n];
 +        qm->Qmatrix[1][i] = s->inter_matrix[n];
 +        qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];
 +        qm->Qmatrix[3][i] = s->chroma_inter_matrix[n];
      }
  }
  
@@@ -151,7 -151,7 +151,7 @@@ static int commit_bitstream_and_slice_b
      const struct MpegEncContext *s = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
      struct dxva2_picture_context *ctx_pic =
-         s->current_picture_ptr->f.hwaccel_picture_private;
+         s->current_picture_ptr->hwaccel_picture_private;
      const int is_field = s->picture_structure != PICT_FRAME;
      const unsigned mb_count = s->mb_width * (s->mb_height >> is_field);
      uint8_t  *dxva_data, *current, *end;
  
      if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->decoder,
                                                DXVA2_BitStreamDateBufferType,
 -                                              &dxva_data, &dxva_size)))
 +                                              (void **)&dxva_data, &dxva_size)))
          return -1;
      current = dxva_data;
      end = dxva_data + dxva_size;
@@@ -210,7 -210,7 +210,7 @@@ static int dxva2_mpeg2_start_frame(AVCo
      const struct MpegEncContext *s = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
      struct dxva2_picture_context *ctx_pic =
-         s->current_picture_ptr->f.hwaccel_picture_private;
+         s->current_picture_ptr->hwaccel_picture_private;
  
      if (!ctx->decoder || !ctx->cfg || ctx->surface_count <= 0)
          return -1;
@@@ -230,7 -230,7 +230,7 @@@ static int dxva2_mpeg2_decode_slice(AVC
  {
      const struct MpegEncContext *s = avctx->priv_data;
      struct dxva2_picture_context *ctx_pic =
-         s->current_picture_ptr->f.hwaccel_picture_private;
+         s->current_picture_ptr->hwaccel_picture_private;
      unsigned position;
  
      if (ctx_pic->slice_count >= MAX_SLICES)
@@@ -250,7 -250,7 +250,7 @@@ static int dxva2_mpeg2_end_frame(AVCode
  {
      struct MpegEncContext *s = avctx->priv_data;
      struct dxva2_picture_context *ctx_pic =
-         s->current_picture_ptr->f.hwaccel_picture_private;
+         s->current_picture_ptr->hwaccel_picture_private;
      int ret;
  
      if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
diff --combined libavcodec/dxva2_vc1.c
@@@ -3,20 -3,20 +3,20 @@@
   *
   * copyright (c) 2010 Laurent Aimar
   *
 - * 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
   */
  
@@@ -68,7 -68,7 +68,7 @@@ static void fill_picture_parameters(AVC
          pp->bPicStructure      |= 0x01;
      if (s->picture_structure & PICT_BOTTOM_FIELD)
          pp->bPicStructure      |= 0x02;
 -    pp->bSecondField            = v->interlace && v->fcm != ILACE_FIELD && !s->first_field;
 +    pp->bSecondField            = v->interlace && v->fcm == ILACE_FIELD && v->second_field;
      pp->bPicIntra               = s->pict_type == AV_PICTURE_TYPE_I || v->bi_type;
      pp->bPicBackwardPrediction  = s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type;
      pp->bBidirectionalAveragingMode = (1                                           << 7) |
@@@ -162,7 -162,7 +162,7 @@@ static int commit_bitstream_and_slice_b
      const VC1Context *v = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
      const MpegEncContext *s = &v->s;
-     struct dxva2_picture_context *ctx_pic = s->current_picture_ptr->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;
  
      DXVA_SliceInfo *slice = &ctx_pic->si;
  
  
      if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->decoder,
                                                DXVA2_BitStreamDateBufferType,
 -                                              &dxva_data, &dxva_size)))
 +                                              (void **)&dxva_data, &dxva_size)))
          return -1;
  
      result = data_size <= dxva_size ? 0 : -1;
      if (!result) {
 -        if (start_code_size > 0)
 +        if (start_code_size > 0) {
              memcpy(dxva_data, start_code, start_code_size);
 +            if (v->second_field)
 +                dxva_data[3] = 0x0c;
 +        }
          memcpy(dxva_data + start_code_size,
                 ctx_pic->bitstream + slice->dwSliceDataLocation, slice_size);
          if (padding > 0)
@@@ -217,7 -214,7 +217,7 @@@ static int dxva2_vc1_start_frame(AVCode
  {
      const VC1Context *v = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
-     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;
  
      if (!ctx->decoder || !ctx->cfg || ctx->surface_count <= 0)
          return -1;
@@@ -236,7 -233,7 +236,7 @@@ static int dxva2_vc1_decode_slice(AVCod
  {
      const VC1Context *v = avctx->priv_data;
      const Picture *current_picture = v->s.current_picture_ptr;
-     struct dxva2_picture_context *ctx_pic = current_picture->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
  
      if (ctx_pic->bitstream_size > 0)
          return -1;
  static int dxva2_vc1_end_frame(AVCodecContext *avctx)
  {
      VC1Context *v = avctx->priv_data;
-     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->f.hwaccel_picture_private;
+     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;
      int ret;
  
      if (ctx_pic->bitstream_size <= 0)
diff --combined libavcodec/mpegvideo.c
@@@ -5,20 -5,20 +5,20 @@@
   *
   * 4MV & hq & B-frame encoding stuff by 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
   */
  
@@@ -30,7 -30,6 +30,7 @@@
  #include "libavutil/imgutils.h"
  #include "avcodec.h"
  #include "dsputil.h"
 +#include "h264chroma.h"
  #include "internal.h"
  #include "mathops.h"
  #include "mpegvideo.h"
@@@ -59,6 -58,9 +59,6 @@@ static void dct_unquantize_h263_inter_c
                                    int16_t *block, int n, int qscale);
  
  
 -/* enable all paranoid tests for rounding, overflows, etc... */
 -//#define PARANOID
 -
  //#define DEBUG
  
  
@@@ -155,9 -157,9 +155,9 @@@ static void mpeg_er_decode_mb(void *opa
      ff_MPV_decode_mb(s, s->block);
  }
  
 -const uint8_t *avpriv_mpv_find_start_code(const uint8_t *restrict p,
 +const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
                                            const uint8_t *end,
 -                                          uint32_t * restrict state)
 +                                          uint32_t *av_restrict state)
  {
      int i;
  
  av_cold int ff_dct_common_init(MpegEncContext *s)
  {
      ff_dsputil_init(&s->dsp, s->avctx);
 +    ff_h264chroma_init(&s->h264chroma, 8); //for lowres
      ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
  
      s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
@@@ -243,7 -244,6 +243,7 @@@ void ff_copy_picture(Picture *dst, Pict
   */
  static void free_frame_buffer(MpegEncContext *s, Picture *pic)
  {
 +    pic->period_since_free = 0;
      /* WM Image / Screen codecs allocate internal buffers with different
       * dimensions / colorspaces; ignore user-defined callbacks for these. */
      if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
          ff_thread_release_buffer(s->avctx, &pic->f);
      else
          avcodec_default_release_buffer(s->avctx, &pic->f);
-     av_freep(&pic->f.hwaccel_picture_private);
+     av_freep(&pic->hwaccel_picture_private);
  }
  
  int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
  {
 -    int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
 +    int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
  
      // edge emu needs blocksize + filter length - 1
      // (= 17x17 for  halfpel / 21x21 for  h264)
      // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
      // at uvlinesize. It supports only YUV420 so 24x24 is enough
      // linesize * interlaced * MBsize
 -    FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 2 * 24,
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 4 * 24,
                        fail);
  
 -    FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 2 * 16 * 2,
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 4 * 16 * 2,
                        fail)
      s->me.temp         = s->me.scratchpad;
      s->rd_scratchpad   = s->me.scratchpad;
@@@ -288,10 -288,10 +288,10 @@@ static int alloc_frame_buffer(MpegEncCo
      int r, ret;
  
      if (s->avctx->hwaccel) {
-         assert(!pic->f.hwaccel_picture_private);
+         assert(!pic->hwaccel_picture_private);
          if (s->avctx->hwaccel->priv_data_size) {
-             pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
-             if (!pic->f.hwaccel_picture_private) {
+             pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
+             if (!pic->hwaccel_picture_private) {
                  av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
                  return -1;
              }
      if (r < 0 || !pic->f.type || !pic->f.data[0]) {
          av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
                 r, pic->f.type, pic->f.data[0]);
-         av_freep(&pic->f.hwaccel_picture_private);
+         av_freep(&pic->hwaccel_picture_private);
          return -1;
      }
  
@@@ -584,35 -584,27 +584,35 @@@ int ff_mpeg_update_thread_context(AVCod
                                    const AVCodecContext *src)
  {
      int i;
 +    int err;
      MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
  
 -    if (dst == src || !s1->context_initialized)
 +    if (dst == src)
          return 0;
  
 +    av_assert0(s != s1);
 +
      // FIXME can parameters change on I-frames?
      // in that case dst may need a reinit
      if (!s->context_initialized) {
          memcpy(s, s1, sizeof(MpegEncContext));
  
          s->avctx                 = dst;
 -        s->picture_range_start  += MAX_PICTURE_COUNT;
 -        s->picture_range_end    += MAX_PICTURE_COUNT;
          s->bitstream_buffer      = NULL;
          s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
  
 -        ff_MPV_common_init(s);
 +        if (s1->context_initialized){
 +            s->picture_range_start  += MAX_PICTURE_COUNT;
 +            s->picture_range_end    += MAX_PICTURE_COUNT;
 +            if((err = ff_MPV_common_init(s)) < 0){
 +                memset(s, 0, sizeof(MpegEncContext));
 +                s->avctx = dst;
 +                return err;
 +            }
 +        }
      }
  
      if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
 -        int err;
          s->context_reinit = 0;
          s->height = s1->height;
          s->width  = s1->width;
      s->picture_number       = s1->picture_number;
      s->input_picture_number = s1->input_picture_number;
  
 +    av_assert0(!s->picture || s->picture != s1->picture);
      memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
      memcpy(&s->last_picture, &s1->last_picture,
             (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
  
      // reset s->picture[].f.extended_data to s->picture[].f.data
 -    for (i = 0; i < s->picture_count; i++)
 +    for (i = 0; i < s->picture_count; i++) {
          s->picture[i].f.extended_data = s->picture[i].f.data;
 +        s->picture[i].period_since_free ++;
 +    }
  
      s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
      s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
      // Error/bug resilience
      s->next_p_frame_damaged = s1->next_p_frame_damaged;
      s->workaround_bugs      = s1->workaround_bugs;
 +    s->padding_bug_score    = s1->padding_bug_score;
  
      // MPEG4 timing info
      memcpy(&s->time_increment_bits, &s1->time_increment_bits,
          } else {
              av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
                     "be allocated due to unknown size.\n");
 -            return AVERROR_BUG;
          }
  
      // MPEG2/interlacing info
@@@ -813,32 -802,44 +813,32 @@@ static int init_context_frame(MpegEncCo
      c_size  = s->mb_stride * (s->mb_height + 1);
      yc_size = y_size + 2   * c_size;
  
 -    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
 -                      fail); // error ressilience code looks cleaner with this
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
      for (y = 0; y < s->mb_height; y++)
          for (x = 0; x < s->mb_width; x++)
              s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
  
 -    s->mb_index2xy[s->mb_height * s->mb_width] =
 -        (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
 +    s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
  
      if (s->encoding) {
          /* Allocate MV tables */
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
 -                          mv_table_size * 2 * sizeof(int16_t), fail);
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
 -                          mv_table_size * 2 * sizeof(int16_t), fail);
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
 -                          mv_table_size * 2 * sizeof(int16_t), fail);
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
 -                          mv_table_size * 2 * sizeof(int16_t), fail);
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
 -                          mv_table_size * 2 * sizeof(int16_t), fail);
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
 -                          mv_table_size * 2 * sizeof(int16_t), fail);
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
          s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
          s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
          s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
 -        s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
 -                                   s->mb_stride + 1;
 -        s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
 -                                   s->mb_stride + 1;
 +        s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 +        s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
          s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
  
          /* Allocate MB type table */
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
 -                          sizeof(uint16_t), fail); // needed for encoding
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
  
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
 -                          sizeof(int), fail);
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
  
          FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
                           mb_array_size * sizeof(float), fail);
                      s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
                                                     s->mb_stride + 1;
                  }
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
 -                                  mb_array_size * 2 * sizeof(uint8_t), fail);
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
 -                                  mv_table_size * 2 * sizeof(int16_t), fail);
 -                s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
 -                                            + s->mb_stride + 1;
 +                FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 +                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 +                s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
              }
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
 -                              mb_array_size * 2 * sizeof(uint8_t), fail);
 +            FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
          }
      }
      if (s->out_format == FMT_H263) {
          s->coded_block = s->coded_block_base + s->b8_stride + 1;
  
          /* cbp, ac_pred, pred_dir */
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
 -                          mb_array_size * sizeof(uint8_t), fail);
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
 -                          mb_array_size * sizeof(uint8_t), fail);
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
      }
  
      if (s->h263_pred || s->h263_plus || !s->encoding) {
          /* dc values */
          // MN: we need these for  error resilience of intra-frames
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
 -                          yc_size * sizeof(int16_t), fail);
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
          s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
          s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
          s->dc_val[2] = s->dc_val[1] + c_size;
      FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
      // Note the + 1 is for  a quicker mpeg4 slice_end detection
  
 -    if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
 -        s->avctx->debug_mv) {
 -        s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +
 -                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
 -        s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +
 -                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
 -        s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +
 -                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
 -    }
 -
      return init_er(s);
  fail:
      return AVERROR(ENOMEM);
@@@ -947,34 -965,44 +947,34 @@@ av_cold int ff_MPV_common_init(MpegEncC
      s->flags  = s->avctx->flags;
      s->flags2 = s->avctx->flags2;
  
 -    if (s->width && s->height) {
 -        /* set chroma shifts */
 -        av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
 -                                         &s->chroma_x_shift,
 -                                         &s->chroma_y_shift);
 +    /* set chroma shifts */
 +    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
  
 -        /* convert fourcc to upper case */
 -        s->codec_tag          = avpriv_toupper4(s->avctx->codec_tag);
 +    /* convert fourcc to upper case */
 +    s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
 +    s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
  
 -        s->stream_codec_tag   = avpriv_toupper4(s->avctx->stream_codec_tag);
 +    s->avctx->coded_frame = &s->current_picture.f;
  
 -        s->avctx->coded_frame = &s->current_picture.f;
 +    if (s->encoding) {
 +        if (s->msmpeg4_version) {
 +            FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
 +                                2 * 2 * (MAX_LEVEL + 1) *
 +                                (MAX_RUN + 1) * 2 * sizeof(int), fail);
 +        }
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
  
 -        if (s->encoding) {
 -            if (s->msmpeg4_version) {
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
 -                                  2 * 2 * (MAX_LEVEL + 1) *
 -                                  (MAX_RUN + 1) * 2 * sizeof(int), fail);
 -            }
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
 -
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,
 -                              64 * 32   * sizeof(int), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,
 -                              64 * 32   * sizeof(int), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,
 -                              64 * 32 * 2 * sizeof(uint16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,
 -                              64 * 32 * 2 * sizeof(uint16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
 -                              MAX_PICTURE_COUNT * sizeof(Picture *), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
 -                              MAX_PICTURE_COUNT * sizeof(Picture *), fail);
 -
 -            if (s->avctx->noise_reduction) {
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
 -                                  2 * 64 * sizeof(uint16_t), fail);
 -            }
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,          64 * 32   * sizeof(int), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix,   64 * 32   * sizeof(int), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,          64 * 32   * sizeof(int), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,           MAX_PICTURE_COUNT * sizeof(Picture *), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
 +
 +        if (s->avctx->noise_reduction) {
 +            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
          }
      }
  
          avcodec_get_frame_defaults(&s->picture[i].f);
      }
  
 -    if (s->width && s->height) {
          if (init_context_frame(s))
              goto fail;
  
          s->parse_context.state = -1;
 -    }
  
 -    s->context_initialized = 1;
 -    s->thread_context[0]   = s;
 +        s->context_initialized = 1;
 +        s->thread_context[0]   = s;
  
 -    if (s->width && s->height) {
 +//     if (s->width && s->height) {
          if (nb_slices > 1) {
              for (i = 1; i < nb_slices; i++) {
                  s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
              s->end_mb_y   = s->mb_height;
          }
          s->slice_context_count = nb_slices;
 -    }
 +//     }
  
      return 0;
   fail:
@@@ -1070,7 -1100,6 +1070,7 @@@ static int free_context_frame(MpegEncCo
      av_freep(&s->er.er_temp_buffer);
      av_freep(&s->mb_index2xy);
      av_freep(&s->lambda_table);
 +
      av_freep(&s->cplx_tab);
      av_freep(&s->bits_tab);
  
@@@ -1177,10 -1206,6 +1177,10 @@@ void ff_MPV_common_end(MpegEncContext *
      av_freep(&s->avctx->stats_out);
      av_freep(&s->ac_stats);
  
 +    if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
 +    if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
 +    s->q_chroma_intra_matrix=   NULL;
 +    s->q_chroma_intra_matrix16= NULL;
      av_freep(&s->q_intra_matrix);
      av_freep(&s->q_inter_matrix);
      av_freep(&s->q_intra_matrix16);
@@@ -1317,10 -1342,6 +1317,10 @@@ void ff_release_unused_pictures(MpegEnc
  
  static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
  {
 +    if (   (s->avctx->active_thread_type & FF_THREAD_FRAME)
 +        && pic->f.qscale_table //check if the frame has anything allocated
 +        && pic->period_since_free < s->avctx->thread_count)
 +        return 0;
      if (pic->f.data[0] == NULL)
          return 1;
      if (pic->needs_realloc && !(pic->f.reference & DELAYED_PIC_REF))
@@@ -1349,21 -1370,7 +1349,21 @@@ static int find_unused_picture(MpegEncC
          }
      }
  
 -    return AVERROR_INVALIDDATA;
 +    av_log(s->avctx, AV_LOG_FATAL,
 +           "Internal error, picture buffer overflow\n");
 +    /* We could return -1, but the codec would crash trying to draw into a
 +     * non-existing frame anyway. This is safer than waiting for a random crash.
 +     * Also the return of this is never useful, an encoder must only allocate
 +     * as much as allowed in the specification. This has no relationship to how
 +     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
 +     * enough for such valid streams).
 +     * Plus, a decoder has to check stream validity and remove frames if too
 +     * many reference frames are around. Waiting for "OOM" is not correct at
 +     * all. Similarly, missing reference frames have to be replaced by
 +     * interpolated/MC frames, anything else is a bug in the codec ...
 +     */
 +    abort();
 +    return -1;
  }
  
  int ff_find_unused_picture(MpegEncContext *s, int shared)
@@@ -1411,11 -1418,6 +1411,11 @@@ int ff_MPV_frame_start(MpegEncContext *
      Picture *pic;
      s->mb_skipped = 0;
  
 +    if (!ff_thread_can_start_frame(avctx)) {
 +        av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
 +        return -1;
 +    }
 +
      /* mark & release old frames */
      if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
          if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
                  return i;
              }
              s->last_picture_ptr = &s->picture[i];
 +            s->last_picture_ptr->f.key_frame = 0;
              if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
                  s->last_picture_ptr = NULL;
                  return -1;
              }
  
 -            memset(s->last_picture_ptr->f.data[0], 0,
 +            memset(s->last_picture_ptr->f.data[0], 0x80,
                     avctx->height * s->last_picture_ptr->f.linesize[0]);
              memset(s->last_picture_ptr->f.data[1], 0x80,
                     (avctx->height >> v_chroma_shift) *
                     (avctx->height >> v_chroma_shift) *
                     s->last_picture_ptr->f.linesize[2]);
  
 +            if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
 +                for(i=0; i<avctx->height; i++)
 +                    memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
 +            }
 +
              ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
              ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
              s->last_picture_ptr->f.reference = 3;
                  return i;
              }
              s->next_picture_ptr = &s->picture[i];
 +            s->next_picture_ptr->f.key_frame = 0;
              if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
                  s->next_picture_ptr = NULL;
                  return -1;
          }
      }
  
 +    memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
 +    memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
      if (s->last_picture_ptr)
          ff_copy_picture(&s->last_picture, s->last_picture_ptr);
      if (s->next_picture_ptr)
@@@ -1638,30 -1631,28 +1638,30 @@@ void ff_MPV_frame_end(MpegEncContext *s
      // just to make sure that all data is rendered.
      if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
          ff_xvmc_field_end(s);
 -   } else if ((s->er.error_count || s->encoding) &&
 +   } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
                !s->avctx->hwaccel &&
                !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
                s->unrestricted_mv &&
                s->current_picture.f.reference &&
                !s->intra_only &&
 -              !(s->flags & CODEC_FLAG_EMU_EDGE)) {
 -       const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
 -       int hshift = desc->log2_chroma_w;
 -       int vshift = desc->log2_chroma_h;
 -       s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
 -                         s->h_edge_pos, s->v_edge_pos,
 -                         EDGE_WIDTH, EDGE_WIDTH,
 -                         EDGE_TOP | EDGE_BOTTOM);
 -       s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
 -                         s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 -                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 -                         EDGE_TOP | EDGE_BOTTOM);
 -       s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
 -                         s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 -                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 -                         EDGE_TOP | EDGE_BOTTOM);
 +              !(s->flags & CODEC_FLAG_EMU_EDGE) &&
 +              !s->avctx->lowres
 +            ) {
 +        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
 +        int hshift = desc->log2_chroma_w;
 +        int vshift = desc->log2_chroma_h;
 +        s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
 +                          s->h_edge_pos, s->v_edge_pos,
 +                          EDGE_WIDTH, EDGE_WIDTH,
 +                          EDGE_TOP | EDGE_BOTTOM);
 +        s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
 +                          s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 +                          EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 +                          EDGE_TOP | EDGE_BOTTOM);
 +        s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
 +                          s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 +                          EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 +                          EDGE_TOP | EDGE_BOTTOM);
      }
  
      emms_c();
@@@ -1735,7 -1726,7 +1735,7 @@@ static void draw_line(uint8_t *buf, in
              y  = (x * f) >> 16;
              fr = (x * f) & 0xFFFF;
              buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
 -            buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
 +            if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
          }
      } else {
          if (sy > ey) {
          buf += sx + sy * stride;
          ey  -= sy;
          if (ey)
 -            f  = ((ex - sx) << 16) / ey;
 +            f = ((ex - sx) << 16) / ey;
          else
              f = 0;
 -        for (y = 0; y = ey; y++) {
 -            x  = (y * f) >> 16;
 -            fr = (y * f) & 0xFFFF;
 +        for(y= 0; y <= ey; y++){
 +            x  = (y*f) >> 16;
 +            fr = (y*f) & 0xFFFF;
              buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
 -            buf[y * stride + x + 1] += (color *            fr ) >> 16;
 +            if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
          }
      }
  }
@@@ -1795,136 -1786,149 +1795,136 @@@ static void draw_arrow(uint8_t *buf, in
  /**
   * Print debugging info for the given picture.
   */
 -void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
 +void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
 +                         uint8_t *visualization_buffer[3], int *low_delay,
 +                         int mb_width, int mb_height, int mb_stride, int quarter_sample)
  {
 -    if (s->avctx->hwaccel || !pict || !pict->mb_type)
 +    if (   avctx->hwaccel || !pict || !pict->mb_type
 +        || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
          return;
  
 -    if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
 +
 +    if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
          int x,y;
  
 -        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
 -        switch (pict->pict_type) {
 -        case AV_PICTURE_TYPE_I:
 -            av_log(s->avctx,AV_LOG_DEBUG,"I\n");
 -            break;
 -        case AV_PICTURE_TYPE_P:
 -            av_log(s->avctx,AV_LOG_DEBUG,"P\n");
 -            break;
 -        case AV_PICTURE_TYPE_B:
 -            av_log(s->avctx,AV_LOG_DEBUG,"B\n");
 -            break;
 -        case AV_PICTURE_TYPE_S:
 -            av_log(s->avctx,AV_LOG_DEBUG,"S\n");
 -            break;
 -        case AV_PICTURE_TYPE_SI:
 -            av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
 -            break;
 -        case AV_PICTURE_TYPE_SP:
 -            av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
 -            break;
 -        }
 -        for (y = 0; y < s->mb_height; y++) {
 -            for (x = 0; x < s->mb_width; x++) {
 -                if (s->avctx->debug & FF_DEBUG_SKIP) {
 -                    int count = s->mbskip_table[x + y * s->mb_stride];
 +        av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
 +               av_get_picture_type_char(pict->pict_type));
 +        for (y = 0; y < mb_height; y++) {
 +            for (x = 0; x < mb_width; x++) {
 +                if (avctx->debug & FF_DEBUG_SKIP) {
 +                    int count = mbskip_table[x + y * mb_stride];
                      if (count > 9)
                          count = 9;
 -                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
 +                    av_log(avctx, AV_LOG_DEBUG, "%1d", count);
                  }
 -                if (s->avctx->debug & FF_DEBUG_QP) {
 -                    av_log(s->avctx, AV_LOG_DEBUG, "%2d",
 -                           pict->qscale_table[x + y * s->mb_stride]);
 +                if (avctx->debug & FF_DEBUG_QP) {
 +                    av_log(avctx, AV_LOG_DEBUG, "%2d",
 +                           pict->qscale_table[x + y * mb_stride]);
                  }
 -                if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
 -                    int mb_type = pict->mb_type[x + y * s->mb_stride];
 +                if (avctx->debug & FF_DEBUG_MB_TYPE) {
 +                    int mb_type = pict->mb_type[x + y * mb_stride];
                      // Type & MV direction
                      if (IS_PCM(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "P");
 +                        av_log(avctx, AV_LOG_DEBUG, "P");
                      else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "A");
 +                        av_log(avctx, AV_LOG_DEBUG, "A");
                      else if (IS_INTRA4x4(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "i");
 +                        av_log(avctx, AV_LOG_DEBUG, "i");
                      else if (IS_INTRA16x16(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "I");
 +                        av_log(avctx, AV_LOG_DEBUG, "I");
                      else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "d");
 +                        av_log(avctx, AV_LOG_DEBUG, "d");
                      else if (IS_DIRECT(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "D");
 +                        av_log(avctx, AV_LOG_DEBUG, "D");
                      else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "g");
 +                        av_log(avctx, AV_LOG_DEBUG, "g");
                      else if (IS_GMC(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "G");
 +                        av_log(avctx, AV_LOG_DEBUG, "G");
                      else if (IS_SKIP(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "S");
 +                        av_log(avctx, AV_LOG_DEBUG, "S");
                      else if (!USES_LIST(mb_type, 1))
 -                        av_log(s->avctx, AV_LOG_DEBUG, ">");
 +                        av_log(avctx, AV_LOG_DEBUG, ">");
                      else if (!USES_LIST(mb_type, 0))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "<");
 +                        av_log(avctx, AV_LOG_DEBUG, "<");
                      else {
 -                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
 -                        av_log(s->avctx, AV_LOG_DEBUG, "X");
 +                        av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
 +                        av_log(avctx, AV_LOG_DEBUG, "X");
                      }
  
                      // segmentation
                      if (IS_8X8(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "+");
 +                        av_log(avctx, AV_LOG_DEBUG, "+");
                      else if (IS_16X8(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "-");
 +                        av_log(avctx, AV_LOG_DEBUG, "-");
                      else if (IS_8X16(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "|");
 +                        av_log(avctx, AV_LOG_DEBUG, "|");
                      else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, " ");
 +                        av_log(avctx, AV_LOG_DEBUG, " ");
                      else
 -                        av_log(s->avctx, AV_LOG_DEBUG, "?");
 +                        av_log(avctx, AV_LOG_DEBUG, "?");
  
  
                      if (IS_INTERLACED(mb_type))
 -                        av_log(s->avctx, AV_LOG_DEBUG, "=");
 +                        av_log(avctx, AV_LOG_DEBUG, "=");
                      else
 -                        av_log(s->avctx, AV_LOG_DEBUG, " ");
 +                        av_log(avctx, AV_LOG_DEBUG, " ");
                  }
              }
 -            av_log(s->avctx, AV_LOG_DEBUG, "\n");
 +            av_log(avctx, AV_LOG_DEBUG, "\n");
          }
      }
  
 -    if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
 -        (s->avctx->debug_mv)) {
 -        const int shift = 1 + s->quarter_sample;
 +    if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
 +        (avctx->debug_mv)) {
 +        const int shift = 1 + quarter_sample;
          int mb_y;
          uint8_t *ptr;
          int i;
          int h_chroma_shift, v_chroma_shift, block_height;
 -        const int width          = s->avctx->width;
 -        const int height         = s->avctx->height;
 +        const int width          = avctx->width;
 +        const int height         = avctx->height;
          const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
 -        const int mv_stride      = (s->mb_width << mv_sample_log2) +
 -                                   (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
 -        s->low_delay = 0; // needed to see the vectors without trashing the buffers
 +        const int mv_stride      = (mb_width << mv_sample_log2) +
 +                                   (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
 +        *low_delay = 0; // needed to see the vectors without trashing the buffers
 +
 +        avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
  
 -        av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
 -                                         &h_chroma_shift, &v_chroma_shift);
          for (i = 0; i < 3; i++) {
 -            memcpy(s->visualization_buffer[i], pict->data[i],
 -                   (i == 0) ? pict->linesize[i] * height:
 -                              pict->linesize[i] * height >> v_chroma_shift);
 -            pict->data[i] = s->visualization_buffer[i];
 +            size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
 +                         pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
 +            visualization_buffer[i]= av_realloc(visualization_buffer[i], size);
 +            memcpy(visualization_buffer[i], pict->data[i], size);
 +            pict->data[i] = visualization_buffer[i];
          }
          pict->type   = FF_BUFFER_TYPE_COPY;
 +        pict->opaque= NULL;
          ptr          = pict->data[0];
          block_height = 16 >> v_chroma_shift;
  
 -        for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
 +        for (mb_y = 0; mb_y < mb_height; mb_y++) {
              int mb_x;
 -            for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
 -                const int mb_index = mb_x + mb_y * s->mb_stride;
 -                if ((s->avctx->debug_mv) && pict->motion_val) {
 +            for (mb_x = 0; mb_x < mb_width; mb_x++) {
 +                const int mb_index = mb_x + mb_y * mb_stride;
 +                if ((avctx->debug_mv) && pict->motion_val[0]) {
                      int type;
                      for (type = 0; type < 3; type++) {
                          int direction = 0;
                          switch (type) {
                          case 0:
 -                            if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
 +                            if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
                                  (pict->pict_type!= AV_PICTURE_TYPE_P))
                                  continue;
                              direction = 0;
                              break;
                          case 1:
 -                            if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
 +                            if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
                                  (pict->pict_type!= AV_PICTURE_TYPE_B))
                                  continue;
                              direction = 0;
                              break;
                          case 2:
 -                            if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
 +                            if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
                                  (pict->pict_type!= AV_PICTURE_TYPE_B))
                                  continue;
                              direction = 1;
                                  int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
                                  int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
                                  draw_arrow(ptr, sx, sy, mx, my, width,
 -                                           height, s->linesize, 100);
 +                                           height, pict->linesize[0], 100);
                              }
                          } else if (IS_16X8(pict->mb_type[mb_index])) {
                              int i;
                                      my *= 2;
  
                              draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
 -                                       height, s->linesize, 100);
 +                                       height, pict->linesize[0], 100);
                              }
                          } else if (IS_8X16(pict->mb_type[mb_index])) {
                              int i;
                                      my *= 2;
  
                                  draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
 -                                           height, s->linesize, 100);
 +                                           height, pict->linesize[0], 100);
                              }
                          } else {
 -                              int sx = mb_x * 16 + 8;
 -                              int sy = mb_y * 16 + 8;
 -                              int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
 -                              int mx = pict->motion_val[direction][xy][0] >> shift + sx;
 -                              int my = pict->motion_val[direction][xy][1] >> shift + sy;
 -                              draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
 +                              int sx= mb_x * 16 + 8;
 +                              int sy= mb_y * 16 + 8;
 +                              int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
 +                              int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
 +                              int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
 +                              draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100);
                          }
                      }
                  }
 -                if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
 +                if ((avctx->debug & FF_DEBUG_VIS_QP)) {
                      uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
                                   0x0101010101010101ULL;
                      int y;
                                        pict->linesize[2]) = c;
                      }
                  }
 -                if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
 -                    pict->motion_val) {
 +                if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
 +                    pict->motion_val[0]) {
                      int mb_type = pict->mb_type[mb_index];
                      uint64_t u,v;
                      int y;
                      } else if (!USES_LIST(mb_type, 0)) {
                          COLOR(0, 48)
                      } else {
 -                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
 +                        av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
                          COLOR(300,48)
                      }
  
                      }
  
                      if (IS_INTERLACED(mb_type) &&
 -                        s->codec_id == AV_CODEC_ID_H264) {
 +                        avctx->codec->id == AV_CODEC_ID_H264) {
                          // hmm
                      }
                  }
 -                s->mbskip_table[mb_index] = 0;
 +                mbskip_table[mb_index] = 0;
              }
          }
      }
  }
  
 +void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
 +{
 +    ff_print_debug_info2(s->avctx, pict, s->mbskip_table, s->visualization_buffer, &s->low_delay,
 +                             s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
 +}
 +
 +static inline int hpel_motion_lowres(MpegEncContext *s,
 +                                     uint8_t *dest, uint8_t *src,
 +                                     int field_based, int field_select,
 +                                     int src_x, int src_y,
 +                                     int width, int height, int stride,
 +                                     int h_edge_pos, int v_edge_pos,
 +                                     int w, int h, h264_chroma_mc_func *pix_op,
 +                                     int motion_x, int motion_y)
 +{
 +    const int lowres   = s->avctx->lowres;
 +    const int op_index = FFMIN(lowres, 2);
 +    const int s_mask   = (2 << lowres) - 1;
 +    int emu = 0;
 +    int sx, sy;
 +
 +    if (s->quarter_sample) {
 +        motion_x /= 2;
 +        motion_y /= 2;
 +    }
 +
 +    sx = motion_x & s_mask;
 +    sy = motion_y & s_mask;
 +    src_x += motion_x >> lowres + 1;
 +    src_y += motion_y >> lowres + 1;
 +
 +    src   += src_y * stride + src_x;
 +
 +    if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
 +        (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
 +        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
 +                                (h + 1) << field_based, src_x,
 +                                src_y   << field_based,
 +                                h_edge_pos,
 +                                v_edge_pos);
 +        src = s->edge_emu_buffer;
 +        emu = 1;
 +    }
 +
 +    sx = (sx << 2) >> lowres;
 +    sy = (sy << 2) >> lowres;
 +    if (field_select)
 +        src += s->linesize;
 +    pix_op[op_index](dest, src, stride, h, sx, sy);
 +    return emu;
 +}
 +
 +/* apply one mpeg motion vector to the three components */
 +static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
 +                                                uint8_t *dest_y,
 +                                                uint8_t *dest_cb,
 +                                                uint8_t *dest_cr,
 +                                                int field_based,
 +                                                int bottom_field,
 +                                                int field_select,
 +                                                uint8_t **ref_picture,
 +                                                h264_chroma_mc_func *pix_op,
 +                                                int motion_x, int motion_y,
 +                                                int h, int mb_y)
 +{
 +    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
 +    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
 +        uvsx, uvsy;
 +    const int lowres     = s->avctx->lowres;
 +    const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
 +    const int block_s    = 8>>lowres;
 +    const int s_mask     = (2 << lowres) - 1;
 +    const int h_edge_pos = s->h_edge_pos >> lowres;
 +    const int v_edge_pos = s->v_edge_pos >> lowres;
 +    linesize   = s->current_picture.f.linesize[0] << field_based;
 +    uvlinesize = s->current_picture.f.linesize[1] << field_based;
 +
 +    // FIXME obviously not perfect but qpel will not work in lowres anyway
 +    if (s->quarter_sample) {
 +        motion_x /= 2;
 +        motion_y /= 2;
 +    }
 +
 +    if(field_based){
 +        motion_y += (bottom_field - field_select)*((1 << lowres)-1);
 +    }
 +
 +    sx = motion_x & s_mask;
 +    sy = motion_y & s_mask;
 +    src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
 +    src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
 +
 +    if (s->out_format == FMT_H263) {
 +        uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
 +        uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
 +        uvsrc_x = src_x >> 1;
 +        uvsrc_y = src_y >> 1;
 +    } else if (s->out_format == FMT_H261) {
 +        // even chroma mv's are full pel in H261
 +        mx      = motion_x / 4;
 +        my      = motion_y / 4;
 +        uvsx    = (2 * mx) & s_mask;
 +        uvsy    = (2 * my) & s_mask;
 +        uvsrc_x = s->mb_x * block_s + (mx >> lowres);
 +        uvsrc_y =    mb_y * block_s + (my >> lowres);
 +    } else {
 +        if(s->chroma_y_shift){
 +            mx      = motion_x / 2;
 +            my      = motion_y / 2;
 +            uvsx    = mx & s_mask;
 +            uvsy    = my & s_mask;
 +            uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
 +            uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
 +        } else {
 +            if(s->chroma_x_shift){
 +            //Chroma422
 +                mx = motion_x / 2;
 +                uvsx = mx & s_mask;
 +                uvsy = motion_y & s_mask;
 +                uvsrc_y = src_y;
 +                uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
 +            } else {
 +            //Chroma444
 +                uvsx = motion_x & s_mask;
 +                uvsy = motion_y & s_mask;
 +                uvsrc_x = src_x;
 +                uvsrc_y = src_y;
 +            }
 +        }
 +    }
 +
 +    ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
 +    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
 +    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
 +
 +    if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
 +        (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
 +        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
 +                                linesize >> field_based, 17, 17 + field_based,
 +                                src_x, src_y << field_based, h_edge_pos,
 +                                v_edge_pos);
 +        ptr_y = s->edge_emu_buffer;
 +        if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 +            uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
 +            s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
 +                                    9 + field_based,
 +                                    uvsrc_x, uvsrc_y << field_based,
 +                                    h_edge_pos >> 1, v_edge_pos >> 1);
 +            s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
 +                                    9 + field_based,
 +                                    uvsrc_x, uvsrc_y << field_based,
 +                                    h_edge_pos >> 1, v_edge_pos >> 1);
 +            ptr_cb = uvbuf;
 +            ptr_cr = uvbuf + 16;
 +        }
 +    }
 +
 +    // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
 +    if (bottom_field) {
 +        dest_y  += s->linesize;
 +        dest_cb += s->uvlinesize;
 +        dest_cr += s->uvlinesize;
 +    }
 +
 +    if (field_select) {
 +        ptr_y   += s->linesize;
 +        ptr_cb  += s->uvlinesize;
 +        ptr_cr  += s->uvlinesize;
 +    }
 +
 +    sx = (sx << 2) >> lowres;
 +    sy = (sy << 2) >> lowres;
 +    pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
 +
 +    if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 +        uvsx = (uvsx << 2) >> lowres;
 +        uvsy = (uvsy << 2) >> lowres;
 +        if (h >> s->chroma_y_shift) {
 +            pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
 +            pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
 +        }
 +    }
 +    // FIXME h261 lowres loop filter
 +}
 +
 +static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
 +                                            uint8_t *dest_cb, uint8_t *dest_cr,
 +                                            uint8_t **ref_picture,
 +                                            h264_chroma_mc_func * pix_op,
 +                                            int mx, int my)
 +{
 +    const int lowres     = s->avctx->lowres;
 +    const int op_index   = FFMIN(lowres, 2);
 +    const int block_s    = 8 >> lowres;
 +    const int s_mask     = (2 << lowres) - 1;
 +    const int h_edge_pos = s->h_edge_pos >> lowres + 1;
 +    const int v_edge_pos = s->v_edge_pos >> lowres + 1;
 +    int emu = 0, src_x, src_y, offset, sx, sy;
 +    uint8_t *ptr;
 +
 +    if (s->quarter_sample) {
 +        mx /= 2;
 +        my /= 2;
 +    }
 +
 +    /* In case of 8X8, we construct a single chroma motion vector
 +       with a special rounding */
 +    mx = ff_h263_round_chroma(mx);
 +    my = ff_h263_round_chroma(my);
 +
 +    sx = mx & s_mask;
 +    sy = my & s_mask;
 +    src_x = s->mb_x * block_s + (mx >> lowres + 1);
 +    src_y = s->mb_y * block_s + (my >> lowres + 1);
 +
 +    offset = src_y * s->uvlinesize + src_x;
 +    ptr = ref_picture[1] + offset;
 +    if (s->flags & CODEC_FLAG_EMU_EDGE) {
 +        if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
 +            (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
 +            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
 +                                    9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
 +            ptr = s->edge_emu_buffer;
 +            emu = 1;
 +        }
 +    }
 +    sx = (sx << 2) >> lowres;
 +    sy = (sy << 2) >> lowres;
 +    pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
 +
 +    ptr = ref_picture[2] + offset;
 +    if (emu) {
 +        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
 +                                src_x, src_y, h_edge_pos, v_edge_pos);
 +        ptr = s->edge_emu_buffer;
 +    }
 +    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
 +}
 +
 +/**
 + * motion compensation of a single macroblock
 + * @param s context
 + * @param dest_y luma destination pointer
 + * @param dest_cb chroma cb/u destination pointer
 + * @param dest_cr chroma cr/v destination pointer
 + * @param dir direction (0->forward, 1->backward)
 + * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
 + * @param pix_op halfpel motion compensation function (average or put normally)
 + * the motion vectors are taken from s->mv and the MV type from s->mv_type
 + */
 +static inline void MPV_motion_lowres(MpegEncContext *s,
 +                                     uint8_t *dest_y, uint8_t *dest_cb,
 +                                     uint8_t *dest_cr,
 +                                     int dir, uint8_t **ref_picture,
 +                                     h264_chroma_mc_func *pix_op)
 +{
 +    int mx, my;
 +    int mb_x, mb_y, i;
 +    const int lowres  = s->avctx->lowres;
 +    const int block_s = 8 >>lowres;
 +
 +    mb_x = s->mb_x;
 +    mb_y = s->mb_y;
 +
 +    switch (s->mv_type) {
 +    case MV_TYPE_16X16:
 +        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                           0, 0, 0,
 +                           ref_picture, pix_op,
 +                           s->mv[dir][0][0], s->mv[dir][0][1],
 +                           2 * block_s, mb_y);
 +        break;
 +    case MV_TYPE_8X8:
 +        mx = 0;
 +        my = 0;
 +        for (i = 0; i < 4; i++) {
 +            hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
 +                               s->linesize) * block_s,
 +                               ref_picture[0], 0, 0,
 +                               (2 * mb_x + (i & 1)) * block_s,
 +                               (2 * mb_y + (i >> 1)) * block_s,
 +                               s->width, s->height, s->linesize,
 +                               s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
 +                               block_s, block_s, pix_op,
 +                               s->mv[dir][i][0], s->mv[dir][i][1]);
 +
 +            mx += s->mv[dir][i][0];
 +            my += s->mv[dir][i][1];
 +        }
 +
 +        if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
 +            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
 +                                     pix_op, mx, my);
 +        break;
 +    case MV_TYPE_FIELD:
 +        if (s->picture_structure == PICT_FRAME) {
 +            /* top field */
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               1, 0, s->field_select[dir][0],
 +                               ref_picture, pix_op,
 +                               s->mv[dir][0][0], s->mv[dir][0][1],
 +                               block_s, mb_y);
 +            /* bottom field */
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               1, 1, s->field_select[dir][1],
 +                               ref_picture, pix_op,
 +                               s->mv[dir][1][0], s->mv[dir][1][1],
 +                               block_s, mb_y);
 +        } else {
 +            if (s->picture_structure != s->field_select[dir][0] + 1 &&
 +                s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
 +                ref_picture = s->current_picture_ptr->f.data;
 +
 +            }
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               0, 0, s->field_select[dir][0],
 +                               ref_picture, pix_op,
 +                               s->mv[dir][0][0],
 +                               s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
 +            }
 +        break;
 +    case MV_TYPE_16X8:
 +        for (i = 0; i < 2; i++) {
 +            uint8_t **ref2picture;
 +
 +            if (s->picture_structure == s->field_select[dir][i] + 1 ||
 +                s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
 +                ref2picture = ref_picture;
 +            } else {
 +                ref2picture = s->current_picture_ptr->f.data;
 +            }
 +
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               0, 0, s->field_select[dir][i],
 +                               ref2picture, pix_op,
 +                               s->mv[dir][i][0], s->mv[dir][i][1] +
 +                               2 * block_s * i, block_s, mb_y >> 1);
 +
 +            dest_y  +=  2 * block_s *  s->linesize;
 +            dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
 +            dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
 +        }
 +        break;
 +    case MV_TYPE_DMV:
 +        if (s->picture_structure == PICT_FRAME) {
 +            for (i = 0; i < 2; i++) {
 +                int j;
 +                for (j = 0; j < 2; j++) {
 +                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                                       1, j, j ^ i,
 +                                       ref_picture, pix_op,
 +                                       s->mv[dir][2 * i + j][0],
 +                                       s->mv[dir][2 * i + j][1],
 +                                       block_s, mb_y);
 +                }
 +                pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
 +            }
 +        } else {
 +            for (i = 0; i < 2; i++) {
 +                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                                   0, 0, s->picture_structure != i + 1,
 +                                   ref_picture, pix_op,
 +                                   s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
 +                                   2 * block_s, mb_y >> 1);
 +
 +                // after put we make avg of the same block
 +                pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
 +
 +                // opposite parity is always in the same
 +                // frame if this is second field
 +                if (!s->first_field) {
 +                    ref_picture = s->current_picture_ptr->f.data;
 +                }
 +            }
 +        }
 +        break;
 +    default:
 +        av_assert2(0);
 +    }
 +}
 +
  /**
   * find the lowest MB row referenced in the MVs
   */
@@@ -2577,7 -2200,7 +2577,7 @@@ void ff_clean_intra_table_entries(MpegE
   */
  static av_always_inline
  void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
 -                            int is_mpeg12)
 +                            int lowres_flag, int is_mpeg12)
  {
      const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
      if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
          qpel_mc_func (*op_qpix)[16];
          const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
          const int uvlinesize = s->current_picture.f.linesize[1];
 -        const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
 -        const int block_size = 8;
 +        const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
 +        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
  
          /* avoid copy if macroblock skipped in last frame too */
          /* skip only during decoding as we might trash the buffers during encoding a bit */
  
              if (s->mb_skipped) {
                  s->mb_skipped= 0;
 -                assert(s->pict_type!=AV_PICTURE_TYPE_I);
 +                av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
                  *mbskip_ptr = 1;
              } else if(!s->current_picture.f.reference) {
                  *mbskip_ptr = 1;
                      }
                  }
  
 -                op_qpix= s->me.qpel_put;
 -                if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 -                    op_pix = s->dsp.put_pixels_tab;
 +                if(lowres_flag){
 +                    h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
 +
 +                    if (s->mv_dir & MV_DIR_FORWARD) {
 +                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
 +                        op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
 +                    }
 +                    if (s->mv_dir & MV_DIR_BACKWARD) {
 +                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
 +                    }
                  }else{
 -                    op_pix = s->dsp.put_no_rnd_pixels_tab;
 -                }
 -                if (s->mv_dir & MV_DIR_FORWARD) {
 -                    ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
 -                    op_pix = s->dsp.avg_pixels_tab;
 -                    op_qpix= s->me.qpel_avg;
 -                }
 -                if (s->mv_dir & MV_DIR_BACKWARD) {
 -                    ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
 +                    op_qpix= s->me.qpel_put;
 +                    if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 +                        op_pix = s->dsp.put_pixels_tab;
 +                    }else{
 +                        op_pix = s->dsp.put_no_rnd_pixels_tab;
 +                    }
 +                    if (s->mv_dir & MV_DIR_FORWARD) {
 +                        ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
 +                        op_pix = s->dsp.avg_pixels_tab;
 +                        op_qpix= s->me.qpel_avg;
 +                    }
 +                    if (s->mv_dir & MV_DIR_BACKWARD) {
 +                        ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
 +                    }
                  }
              }
  
                      }else{
                          //chroma422
                          dct_linesize = uvlinesize << s->interlaced_dct;
 -                        dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
 +                        dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
  
                          add_dct(s, block[4], 4, dest_cb, dct_linesize);
                          add_dct(s, block[5], 5, dest_cr, dct_linesize);
                          add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
                          add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
                          if(!s->chroma_x_shift){//Chroma444
 -                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
 -                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
 -                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
 -                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
 +                            add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
 +                            add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
 +                            add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
 +                            add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
                          }
                      }
                  }//fi gray
                      }else{
  
                          dct_linesize = uvlinesize << s->interlaced_dct;
 -                        dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
 +                        dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
  
                          s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
                          s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
                          s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
                          s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
                          if(!s->chroma_x_shift){//Chroma444
 -                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
 -                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
 -                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
 -                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
 +                            s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
 +                            s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
 +                            s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
 +                            s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
                          }
                      }
                  }//gray
@@@ -2822,12 -2433,10 +2822,12 @@@ skip_idct
  void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
  #if !CONFIG_SMALL
      if(s->out_format == FMT_MPEG1) {
 -        MPV_decode_mb_internal(s, block, 1);
 +        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
 +        else                 MPV_decode_mb_internal(s, block, 0, 1);
      } else
  #endif
 -        MPV_decode_mb_internal(s, block, 0);
 +    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
 +    else                  MPV_decode_mb_internal(s, block, 0, 0);
  }
  
  /**
@@@ -2921,7 -2530,7 +2921,7 @@@ void ff_mpeg_draw_horiz_band(MpegEncCon
  void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
      const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
      const int uvlinesize = s->current_picture.f.linesize[1];
 -    const int mb_size= 4;
 +    const int mb_size= 4 - s->avctx->lowres;
  
      s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
      s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
              s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
              s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
              s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
 -            assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
 +            av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
          }
      }
  }
@@@ -2995,7 -2604,6 +2995,7 @@@ void ff_mpeg_flush(AVCodecContext *avct
      s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
  
      s->mb_x= s->mb_y= 0;
 +    s->closed_gop= 0;
  
      s->parse_context.state= -1;
      s->parse_context.frame_start_found= 0;
@@@ -3015,7 -2623,10 +3015,7 @@@ static void dct_unquantize_mpeg1_intra_
  
      nCoeffs= s->block_last_index[n];
  
 -    if (n < 4)
 -        block[0] = block[0] * s->y_dc_scale;
 -    else
 -        block[0] = block[0] * s->c_dc_scale;
 +    block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
      /* XXX: only mpeg1 */
      quant_matrix = s->intra_matrix;
      for(i=1;i<=nCoeffs;i++) {
@@@ -3074,7 -2685,10 +3074,7 @@@ static void dct_unquantize_mpeg2_intra_
      if(s->alternate_scan) nCoeffs= 63;
      else nCoeffs= s->block_last_index[n];
  
 -    if (n < 4)
 -        block[0] = block[0] * s->y_dc_scale;
 -    else
 -        block[0] = block[0] * s->c_dc_scale;
 +    block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
      quant_matrix = s->intra_matrix;
      for(i=1;i<=nCoeffs;i++) {
          int j= s->intra_scantable.permutated[i];
@@@ -3102,8 -2716,10 +3102,8 @@@ static void dct_unquantize_mpeg2_intra_
      if(s->alternate_scan) nCoeffs= 63;
      else nCoeffs= s->block_last_index[n];
  
 -    if (n < 4)
 -        block[0] = block[0] * s->y_dc_scale;
 -    else
 -        block[0] = block[0] * s->c_dc_scale;
 +    block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
 +    sum += block[0];
      quant_matrix = s->intra_matrix;
      for(i=1;i<=nCoeffs;i++) {
          int j= s->intra_scantable.permutated[i];
@@@ -3165,7 -2781,10 +3165,7 @@@ static void dct_unquantize_h263_intra_c
      qmul = qscale << 1;
  
      if (!s->h263_aic) {
 -        if (n < 4)
 -            block[0] = block[0] * s->y_dc_scale;
 -        else
 -            block[0] = block[0] * s->c_dc_scale;
 +        block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
          qadd = (qscale - 1) | 1;
      }else{
          qadd = 0;
diff --combined libavcodec/mpegvideo.h
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer
   *
 - * 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
   */
  
@@@ -32,7 -32,6 +32,7 @@@
  #include "dsputil.h"
  #include "error_resilience.h"
  #include "get_bits.h"
 +#include "h264chroma.h"
  #include "put_bits.h"
  #include "ratecontrol.h"
  #include "parser.h"
@@@ -41,7 -40,6 +41,7 @@@
  #include "videodsp.h"
  
  #include "libavutil/opt.h"
 +#include "libavutil/timecode.h"
  
  #define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not coded
  
@@@ -56,13 -54,14 +56,13 @@@ enum OutputFormat 
  #define MPEG_BUF_SIZE (16 * 1024)
  
  #define QMAT_SHIFT_MMX 16
 -#define QMAT_SHIFT 22
 +#define QMAT_SHIFT 21
  
  #define MAX_FCODE 7
 -#define MAX_MV 2048
 +#define MAX_MV 4096
  
 -#define MAX_THREADS 16
 -
 -#define MAX_PICTURE_COUNT 32
 +#define MAX_THREADS 32
 +#define MAX_PICTURE_COUNT 36
  
  #define ME_MAP_SIZE 64
  #define ME_MAP_SHIFT 3
@@@ -131,11 -130,10 +131,11 @@@ typedef struct Picture
      int pic_id;                 /**< h264 pic_num (short -> no wrap version of pic_num,
                                       pic_num & max_pic_num; long -> long_pic_num) */
      int long_ref;               ///< 1->long term reference 0->short term reference
 -    int ref_poc[2][2][32];      ///< h264 POCs of the frames used as reference (FIXME need per slice)
 +    int ref_poc[2][2][32];      ///< h264 POCs of the frames/fields used as reference (FIXME need per slice)
      int ref_count[2][2];        ///< number of entries in ref_poc              (FIXME need per slice)
      int mbaff;                  ///< h264 1 -> MBAFF frame 0-> not MBAFF
      int field_picture;          ///< whether or not the picture was encoded in separate fields
 +    int sync;                   ///< has been decoded after a keyframe
  
      int mb_var_sum;             ///< sum of MB variance for current frame
      int mc_mb_var_sum;          ///< motion compensated MB variance for current frame
      int b_frame_score;          /* */
      void *owner2;               ///< pointer to the context that allocated this picture
      int needs_realloc;          ///< Picture needs to be reallocated (eg due to a frame size change)
 +    int period_since_free;      ///< "cycles" since this Picture has been freed
+     /**
+      * hardware accelerator private data
+      */
+     void *hwaccel_picture_private;
  } Picture;
  
  /**
@@@ -345,14 -346,11 +349,14 @@@ typedef struct MpegEncContext 
      int *lambda_table;
      int adaptive_quant;         ///< use adaptive quantization
      int dquant;                 ///< qscale difference to prev qscale
 +    int closed_gop;             ///< MPEG1/2 GOP is closed
      int pict_type;              ///< AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
 +    int vbv_delay;
      int last_pict_type; //FIXME removes
      int last_non_b_pict_type;   ///< used for mpeg4 gmc b-frames & ratecontrol
      int droppable;
      int frame_rate_index;
 +    AVRational mpeg2_frame_rate_ext;
      int last_lambda_for[5];     ///< last lambda for a specific pict type
      int skipdct;                ///< skip dct and code zero residual
  
      int h263_long_vectors;      ///< use horrible h263v1 long vector mode
  
      DSPContext dsp;             ///< pointers for accelerated dsp functions
 +    H264ChromaContext h264chroma;
      VideoDSPContext vdsp;
      int f_code;                 ///< forward MV resolution
      int b_code;                 ///< backward MV resolution for B Frames (mpeg4)
      uint8_t *luma_dc_vlc_length;
  #define UNI_AC_ENC_INDEX(run,level) ((run)*128 + (level))
  
 -    int coded_score[8];
 +    int coded_score[12];
  
      /** precomputed matrix (combine qscale and DCT renorm) */
      int (*q_intra_matrix)[64];
 +    int (*q_chroma_intra_matrix)[64];
      int (*q_inter_matrix)[64];
      /** identical to the above but for MMX & these are not permutated, second 64 entries are bias*/
      uint16_t (*q_intra_matrix16)[2][64];
 +    uint16_t (*q_chroma_intra_matrix16)[2][64];
      uint16_t (*q_inter_matrix16)[2][64];
  
      /* noise reduction */
      /* bit rate control */
      int64_t total_bits;
      int frame_bits;                ///< bits used for the current frame
 +    int stuffing_bits;             ///< bits used for stuffing
      int next_lambda;               ///< next lambda used for retrying to encode a frame
      RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
  
      struct MJpegContext *mjpeg_ctx;
      int mjpeg_vsample[3];       ///< vertical sampling factors, default = {2, 1, 1}
      int mjpeg_hsample[3];       ///< horizontal sampling factors, default = {2, 1, 1}
 +    int esc_pos;
  
      /* MSMPEG4 specific */
      int mv_table_index;
      /* RTP specific */
      int rtp_mode;
  
 +    char *tc_opt_str;        ///< timecode option string
 +    AVTimecode tc;           ///< timecode context
 +
      uint8_t *ptr_lastgob;
      int swap_uv;             //vcr2 codec is an MPEG-2 variant with U and V swapped
      int16_t (*pblocks[12])[64];
  
      int16_t (*block)[64]; ///< points to one of the following blocks
 -    int16_t (*blocks)[8][64]; // for HQ mode we need to keep the best block
 +    int16_t (*blocks)[12][64]; // for HQ mode we need to keep the best block
      int (*decode_mb)(struct MpegEncContext *s, int16_t block[6][64]); // used by some codecs to avoid a switch()
  #define SLICE_OK         0
  #define SLICE_ERROR     -1
@@@ -766,8 -756,8 +770,8 @@@ void ff_MPV_frame_end(MpegEncContext *s
  int ff_MPV_encode_init(AVCodecContext *avctx);
  int ff_MPV_encode_end(AVCodecContext *avctx);
  int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 -                          const AVFrame *frame, int *got_packet);
 -void ff_MPV_encode_init_x86(MpegEncContext *s);
 +                          AVFrame *frame, int *got_packet);
 +void ff_dct_encode_init_x86(MpegEncContext *s);
  void ff_MPV_common_init_x86(MpegEncContext *s);
  void ff_MPV_common_init_axp(MpegEncContext *s);
  void ff_MPV_common_init_arm(MpegEncContext *s);
@@@ -795,7 -785,6 +799,7 @@@ void ff_set_qscale(MpegEncContext * s, 
  void ff_mpeg_er_frame_start(MpegEncContext *s);
  
  int ff_dct_common_init(MpegEncContext *s);
 +int ff_dct_encode_init(MpegEncContext *s);
  void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
                         const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra);
  int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
@@@ -825,7 -814,7 +829,7 @@@ extern const enum AVPixelFormat ff_pixf
  void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last);
  
  static inline void ff_update_block_index(MpegEncContext *s){
 -    const int block_size = 8;
 +    const int block_size= 8 >> s->avctx->lowres;
  
      s->block_index[0]+=2;
      s->block_index[1]+=2;
diff --combined libavutil/version.h
@@@ -1,63 -1,25 +1,63 @@@
  /*
 - * This file is part of Libav.
 + * copyright (c) 2003 Fabrice Bellard
   *
 - * Libav is free software; you can redistribute it and/or
 + * This file is part of FFmpeg.
 + *
 + * 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
   */
  
  #ifndef AVUTIL_VERSION_H
  #define AVUTIL_VERSION_H
  
 -#include "avutil.h"
 +/**
 + * @defgroup preproc_misc Preprocessor String Macros
 + *
 + * String manipulation macros
 + *
 + * @{
 + */
 +
 +#define AV_STRINGIFY(s)         AV_TOSTRING(s)
 +#define AV_TOSTRING(s) #s
 +
 +#define AV_GLUE(a, b) a ## b
 +#define AV_JOIN(a, b) AV_GLUE(a, b)
 +
 +#define AV_PRAGMA(s) _Pragma(#s)
 +
 +/**
 + * @}
 + */
 +
 +/**
 + * @defgroup version_utils Library Version Macros
 + *
 + * Useful to check and match library version in order to maintain
 + * backward compatibility.
 + *
 + * @{
 + */
 +
 +#define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
 +#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
 +#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
 +
 +/**
 + * @}
 + */
 +
  
  /**
   * @file
@@@ -74,9 -36,9 +74,9 @@@
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 52
 -#define LIBAVUTIL_VERSION_MINOR  8
 -#define LIBAVUTIL_VERSION_MICRO  0
 +#define LIBAVUTIL_VERSION_MAJOR  52
 +#define LIBAVUTIL_VERSION_MINOR  19
 +#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \
   * @{
   */
  
 +#ifndef FF_API_GET_BITS_PER_SAMPLE_FMT
 +#define FF_API_GET_BITS_PER_SAMPLE_FMT (LIBAVUTIL_VERSION_MAJOR < 53)
 +#endif
 +#ifndef FF_API_FIND_OPT
 +#define FF_API_FIND_OPT                 (LIBAVUTIL_VERSION_MAJOR < 53)
 +#endif
 +#ifndef FF_API_OLD_AVOPTIONS
 +#define FF_API_OLD_AVOPTIONS            (LIBAVUTIL_VERSION_MAJOR < 53)
 +#endif
  #ifndef FF_API_PIX_FMT
  #define FF_API_PIX_FMT                  (LIBAVUTIL_VERSION_MAJOR < 53)
  #endif
  #ifndef FF_API_CPU_FLAG_MMX2
  #define FF_API_CPU_FLAG_MMX2            (LIBAVUTIL_VERSION_MAJOR < 53)
  #endif
 +#ifndef FF_API_SAMPLES_UTILS_RETURN_ZERO
 +#define FF_API_SAMPLES_UTILS_RETURN_ZERO (LIBAVUTIL_VERSION_MAJOR < 53)
 +#endif
  #ifndef FF_API_LLS_PRIVATE
  #define FF_API_LLS_PRIVATE              (LIBAVUTIL_VERSION_MAJOR < 53)
  #endif
+ #ifndef FF_API_AVFRAME_LAVC
+ #define FF_API_AVFRAME_LAVC             (LIBAVUTIL_VERSION_MAJOR < 53)
+ #endif
  
  /**
   * @}
   */
  
  #endif /* AVUTIL_VERSION_H */
 +