xbmc-ffmpeg10.patch

   1 diff -urN xbmc-11.0/lib/DllAvCodec.h xbmc-11.0-ffmpeg-1.0/lib/DllAvCodec.h
   2 --- xbmc-11.0/lib/DllAvCodec.h  2012-03-21 23:07:50.000000000 +0100
   3 +++ xbmc-11.0-ffmpeg-1.0/lib/DllAvCodec.h       2012-11-08 23:16:18.536405054 +0100
   4 @@ -24,7 +24,7 @@
   5    #include "config.h"
   6  #endif
   7  #include "DynamicDll.h"
   8 -#include "DllAvCore.h"
   9 +#include "DllAvUtil.h"
  10  #include "utils/log.h"
  11
  12  extern "C" {
  13 @@ -60,7 +60,6 @@
  14    #endif
  15
  16    /* From non-public audioconvert.h */
  17 -  int64_t avcodec_guess_channel_layout(int nb_channels, enum CodecID codec_id, const char *fmt_name);
  18    struct AVAudioConvert;
  19    typedef struct AVAudioConvert AVAudioConvert;
  20    AVAudioConvert *av_audio_convert_alloc(enum AVSampleFormat out_fmt, int out_channels,
  21 @@ -76,28 +75,6 @@
  22  #endif
  23  }
  24
  25 -/* Some convenience macros introduced at this particular revision of libavcodec.
  26 - */
  27 -#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52,25,0)
  28 -#define CH_LAYOUT_5POINT0_BACK      (CH_LAYOUT_SURROUND|CH_BACK_LEFT|CH_BACK_RIGHT)
  29 -#define CH_LAYOUT_5POINT1_BACK      (CH_LAYOUT_5POINT0_BACK|CH_LOW_FREQUENCY)
  30 -#undef CH_LAYOUT_7POINT1_WIDE
  31 -#define CH_LAYOUT_7POINT1_WIDE      (CH_LAYOUT_5POINT1_BACK|\
  32 -                                           CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER)
  33 -#endif
  34 -
  35 -#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52,64,0)
  36 -// API added on: 2010-03-31
  37 -#define AVMediaType            CodecType
  38 -#define AVMEDIA_TYPE_UNKNOWN    CODEC_TYPE_UNKNOWN
  39 -#define AVMEDIA_TYPE_VIDEO      CODEC_TYPE_VIDEO
  40 -#define AVMEDIA_TYPE_AUDIO      CODEC_TYPE_AUDIO
  41 -#define AVMEDIA_TYPE_DATA       CODEC_TYPE_DATA
  42 -#define AVMEDIA_TYPE_SUBTITLE   CODEC_TYPE_SUBTITLE
  43 -#define AVMEDIA_TYPE_ATTACHMENT CODEC_TYPE_ATTACHMENT
  44 -#define AVMEDIA_TYPE_NB         CODEC_TYPE_NB
  45 -#endif
  46 -
  47  #include "threads/SingleLock.h"
  48
  49  class DllAvCodecInterface
  50 @@ -106,20 +83,20 @@
  51    virtual ~DllAvCodecInterface() {}
  52    virtual void avcodec_register_all(void)=0;
  53    virtual void avcodec_flush_buffers(AVCodecContext *avctx)=0;
  54 -  virtual int avcodec_open_dont_call(AVCodecContext *avctx, AVCodec *codec)=0;
  55 +  virtual int avcodec_open2_dont_call(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)=0;
  56    virtual AVCodec *avcodec_find_decoder(enum CodecID id)=0;
  57    virtual AVCodec *avcodec_find_encoder(enum CodecID id)=0;
  58    virtual int avcodec_close_dont_call(AVCodecContext *avctx)=0;
  59    virtual AVFrame *avcodec_alloc_frame(void)=0;
  60    virtual int avpicture_fill(AVPicture *picture, uint8_t *ptr, PixelFormat pix_fmt, int width, int height)=0;
  61    virtual int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)=0;
  62 -  virtual int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples, int *frame_size_ptr, AVPacket *avpkt)=0;
  63 +  virtual int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)=0;
  64    virtual int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)=0;
  65    virtual int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, const short *samples)=0;
  66    virtual int avpicture_get_size(PixelFormat pix_fmt, int width, int height)=0;
  67 -  virtual AVCodecContext *avcodec_alloc_context(void)=0;
  68 +  virtual AVCodecContext *avcodec_alloc_context3(AVCodec *codec)=0;
  69    virtual void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)=0;
  70 -  virtual void avcodec_get_context_defaults(AVCodecContext *s)=0;
  71 +  virtual void avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec)=0;
  72    virtual AVCodecParserContext *av_parser_init(int codec_id)=0;
  73    virtual int av_parser_parse2(AVCodecParserContext *s,AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size,
  74                      const uint8_t *buf, int buf_size,
  75 @@ -137,7 +114,6 @@
  76    virtual enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt)=0;
  77    virtual int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic)=0;
  78    virtual void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)=0;
  79 -  virtual int avcodec_thread_init(AVCodecContext *s, int thread_count)=0;
  80    virtual AVCodec *av_codec_next(AVCodec *c)=0;
  81    virtual AVAudioConvert *av_audio_convert_alloc(enum AVSampleFormat out_fmt, int out_channels,
  82                                                   enum AVSampleFormat in_fmt , int in_channels,
  83 @@ -148,7 +124,6 @@
  84                                 const void * const  in[6], const int  in_stride[6], int len)=0;
  85    virtual int av_dup_packet(AVPacket *pkt)=0;
  86    virtual void av_init_packet(AVPacket *pkt)=0;
  87 -  virtual int64_t avcodec_guess_channel_layout(int nb_channels, enum CodecID codec_id, const char *fmt_name)=0;
  88  };
  89
  90  #if (defined USE_EXTERNAL_FFMPEG)
  91 @@ -166,12 +141,12 @@
  92      ::avcodec_register_all();
  93    }
  94    virtual void avcodec_flush_buffers(AVCodecContext *avctx) { ::avcodec_flush_buffers(avctx); }
  95 -  virtual int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
  96 +  virtual int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
  97    {
  98      CSingleLock lock(DllAvCodec::m_critSection);
  99 -    return ::avcodec_open(avctx, codec);
 100 +    return ::avcodec_open2(avctx, codec, options);
 101    }
 102 -  virtual int avcodec_open_dont_call(AVCodecContext *avctx, AVCodec *codec) { *(int *)0x0 = 0; return 0; }
 103 +  virtual int avcodec_open2_dont_call(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options) { *(int *)0x0 = 0; return 0; }
 104    virtual int avcodec_close_dont_call(AVCodecContext *avctx) { *(int *)0x0 = 0; return 0; }
 105    virtual AVCodec *avcodec_find_decoder(enum CodecID id) { return ::avcodec_find_decoder(id); }
 106    virtual AVCodec *avcodec_find_encoder(enum CodecID id) { return ::avcodec_find_encoder(id); }
 107 @@ -182,33 +157,21 @@
 108    }
 109    virtual AVFrame *avcodec_alloc_frame() { return ::avcodec_alloc_frame(); }
 110    virtual int avpicture_fill(AVPicture *picture, uint8_t *ptr, PixelFormat pix_fmt, int width, int height) { return ::avpicture_fill(picture, ptr, pix_fmt, width, height); }
 111 -#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52,23,0)
 112 -  // API added on: 2009-04-07
 113    virtual int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt) { return ::avcodec_decode_video2(avctx, picture, got_picture_ptr, avpkt); }
 114 -  virtual int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples, int *frame_size_ptr, AVPacket *avpkt) { return ::avcodec_decode_audio3(avctx, samples, frame_size_ptr, avpkt); }
 115 +  virtual int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt) { return ::avcodec_decode_audio4(avctx, frame, got_frame_ptr, avpkt); }
 116    virtual int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt) { return ::avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, avpkt); }
 117 -#else
 118 -  virtual int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt) { return ::avcodec_decode_video(avctx, picture, got_picture_ptr, avpkt->data, avpkt->size); }
 119 -  virtual int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples, int *frame_size_ptr, AVPacket *avpkt) { return ::avcodec_decode_audio2(avctx, samples, frame_size_ptr, avpkt->data, avpkt->size); }
 120 -  virtual int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt) { return ::avcodec_decode_subtitle(avctx, sub, got_sub_ptr, avpkt->data, avpkt->size); }
 121 -#endif
 122    virtual int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, const short *samples) { return ::avcodec_encode_audio(avctx, buf, buf_size, samples); }
 123    virtual int avpicture_get_size(PixelFormat pix_fmt, int width, int height) { return ::avpicture_get_size(pix_fmt, width, height); }
 124 -  virtual AVCodecContext *avcodec_alloc_context() { return ::avcodec_alloc_context(); }
 125 +  virtual AVCodecContext *avcodec_alloc_context3(AVCodec *codec) { return ::avcodec_alloc_context3(codec); }
 126    virtual void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode) { ::avcodec_string(buf, buf_size, enc, encode); }
 127 -  virtual void avcodec_get_context_defaults(AVCodecContext *s) { ::avcodec_get_context_defaults(s); }
 128 +  virtual void avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec) { ::avcodec_get_context_defaults3(s, codec); }
 129
 130    virtual AVCodecParserContext *av_parser_init(int codec_id) { return ::av_parser_init(codec_id); }
 131    virtual int av_parser_parse2(AVCodecParserContext *s,AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size,
 132                      const uint8_t *buf, int buf_size,
 133                      int64_t pts, int64_t dts, int64_t pos)
 134    {
 135 -#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52,21,0)
 136 -    // API added on : 2009-03-05
 137      return ::av_parser_parse2(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts, pos);
 138 -#else
 139 -    return ::av_parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts);
 140 -#endif
 141    }
 142    virtual void av_parser_close(AVCodecParserContext *s) { ::av_parser_close(s); }
 143
 144 @@ -225,7 +188,6 @@
 145    virtual int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic) { return ::avcodec_default_get_buffer(s, pic); }
 146    virtual void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic) { ::avcodec_default_release_buffer(s, pic); }
 147    virtual enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt) { return ::avcodec_default_get_format(s, fmt); }
 148 -  virtual int avcodec_thread_init(AVCodecContext *s, int thread_count) { return ::avcodec_thread_init(s, thread_count); }
 149    virtual AVCodec *av_codec_next(AVCodec *c) { return ::av_codec_next(c); }
 150    virtual AVAudioConvert *av_audio_convert_alloc(enum AVSampleFormat out_fmt, int out_channels,
 151                                                   enum AVSampleFormat in_fmt , int in_channels,
 152 @@ -241,7 +203,6 @@
 153
 154    virtual int av_dup_packet(AVPacket *pkt) { return ::av_dup_packet(pkt); }
 155    virtual void av_init_packet(AVPacket *pkt) { return ::av_init_packet(pkt); }
 156 -  virtual int64_t avcodec_guess_channel_layout(int nb_channels, enum CodecID codec_id, const char *fmt_name) { return ::avcodec_guess_channel_layout(nb_channels, codec_id, fmt_name); }
 157
 158    // DLL faking.
 159    virtual bool ResolveExports() { return true; }
 160 @@ -256,17 +217,16 @@
 161  {
 162    DECLARE_DLL_WRAPPER(DllAvCodec, DLL_PATH_LIBAVCODEC)
 163    DEFINE_FUNC_ALIGNED1(void, __cdecl, avcodec_flush_buffers, AVCodecContext*)
 164 -  DEFINE_FUNC_ALIGNED2(int, __cdecl, avcodec_open_dont_call, AVCodecContext*, AVCodec *)
 165 +  DEFINE_FUNC_ALIGNED3(int, __cdecl, avcodec_open2_dont_call, AVCodecContext*, AVCodec *, AVDictionary **)
 166    DEFINE_FUNC_ALIGNED4(int, __cdecl, avcodec_decode_video2, AVCodecContext*, AVFrame*, int*, AVPacket*)
 167 -  DEFINE_FUNC_ALIGNED4(int, __cdecl, avcodec_decode_audio3, AVCodecContext*, int16_t*, int*, AVPacket*)
 168 +  DEFINE_FUNC_ALIGNED4(int, __cdecl, avcodec_decode_audio4, AVCodecContext*, AVFrame*, int*, AVPacket*)
 169    DEFINE_FUNC_ALIGNED4(int, __cdecl, avcodec_decode_subtitle2, AVCodecContext*, AVSubtitle*, int*, AVPacket*)
 170    DEFINE_FUNC_ALIGNED4(int, __cdecl, avcodec_encode_audio, AVCodecContext*, uint8_t*, int, const short*)
 171 -  DEFINE_FUNC_ALIGNED0(AVCodecContext*, __cdecl, avcodec_alloc_context)
 172 +  DEFINE_FUNC_ALIGNED1(AVCodecContext*, __cdecl, avcodec_alloc_context3, AVCodec *)
 173    DEFINE_FUNC_ALIGNED1(AVCodecParserContext*, __cdecl, av_parser_init, int)
 174    DEFINE_FUNC_ALIGNED9(int, __cdecl, av_parser_parse2, AVCodecParserContext*,AVCodecContext*, uint8_t**, int*, const uint8_t*, int, int64_t, int64_t, int64_t)
 175    DEFINE_METHOD1(int, av_dup_packet, (AVPacket *p1))
 176    DEFINE_METHOD1(void, av_init_packet, (AVPacket *p1))
 177 -  DEFINE_METHOD3(int64_t, avcodec_guess_channel_layout, (int p1, enum CodecID p2, const char *p3))
 178
 179    LOAD_SYMBOLS();
 180
 181 @@ -278,7 +238,7 @@
 182    DEFINE_METHOD5(int, avpicture_fill, (AVPicture *p1, uint8_t *p2, PixelFormat p3, int p4, int p5))
 183    DEFINE_METHOD3(int, avpicture_get_size, (PixelFormat p1, int p2, int p3))
 184    DEFINE_METHOD4(void, avcodec_string, (char *p1, int p2, AVCodecContext *p3, int p4))
 185 -  DEFINE_METHOD1(void, avcodec_get_context_defaults, (AVCodecContext *p1))
 186 +  DEFINE_METHOD2(void, avcodec_get_context_defaults3, (AVCodecContext *p1, AVCodec *p2))
 187    DEFINE_METHOD1(void, av_parser_close, (AVCodecParserContext *p1))
 188    DEFINE_METHOD1(void, avpicture_free, (AVPicture *p1))
 189    DEFINE_METHOD1(AVBitStreamFilterContext*, av_bitstream_filter_init, (const char *p1))
 190 @@ -290,7 +250,6 @@
 191    DEFINE_METHOD2(void, avcodec_default_release_buffer, (AVCodecContext *p1, AVFrame *p2))
 192    DEFINE_METHOD2(enum PixelFormat, avcodec_default_get_format, (struct AVCodecContext *p1, const enum PixelFormat *p2))
 193
 194 -  DEFINE_METHOD2(int, avcodec_thread_init, (AVCodecContext *p1, int p2))
 195    DEFINE_METHOD1(AVCodec*, av_codec_next, (AVCodec *p1))
 196    DEFINE_METHOD6(AVAudioConvert*, av_audio_convert_alloc, (enum AVSampleFormat p1, int p2,
 197                                                             enum AVSampleFormat p3, int p4,
 198 @@ -301,7 +260,7 @@
 199                                                 const void * const p4[6], const int p5[6], int p6))
 200    BEGIN_METHOD_RESOLVE()
 201      RESOLVE_METHOD(avcodec_flush_buffers)
 202 -    RESOLVE_METHOD_RENAME(avcodec_open,avcodec_open_dont_call)
 203 +    RESOLVE_METHOD_RENAME(avcodec_open2,avcodec_open2_dont_call)
 204      RESOLVE_METHOD_RENAME(avcodec_close,avcodec_close_dont_call)
 205      RESOLVE_METHOD(avcodec_find_decoder)
 206      RESOLVE_METHOD(avcodec_find_encoder)
 207 @@ -309,13 +268,13 @@
 208      RESOLVE_METHOD_RENAME(avcodec_register_all, avcodec_register_all_dont_call)
 209      RESOLVE_METHOD(avpicture_fill)
 210      RESOLVE_METHOD(avcodec_decode_video2)
 211 -    RESOLVE_METHOD(avcodec_decode_audio3)
 212 +    RESOLVE_METHOD(avcodec_decode_audio4)
 213      RESOLVE_METHOD(avcodec_decode_subtitle2)
 214      RESOLVE_METHOD(avcodec_encode_audio)
 215      RESOLVE_METHOD(avpicture_get_size)
 216 -    RESOLVE_METHOD(avcodec_alloc_context)
 217 +    RESOLVE_METHOD(avcodec_alloc_context3)
 218      RESOLVE_METHOD(avcodec_string)
 219 -    RESOLVE_METHOD(avcodec_get_context_defaults)
 220 +    RESOLVE_METHOD(avcodec_get_context_defaults3)
 221      RESOLVE_METHOD(av_parser_init)
 222      RESOLVE_METHOD(av_parser_parse2)
 223      RESOLVE_METHOD(av_parser_close)
 224 @@ -328,26 +287,24 @@
 225      RESOLVE_METHOD(avcodec_default_get_buffer)
 226      RESOLVE_METHOD(avcodec_default_release_buffer)
 227      RESOLVE_METHOD(avcodec_default_get_format)
 228 -    RESOLVE_METHOD(avcodec_thread_init)
 229      RESOLVE_METHOD(av_codec_next)
 230      RESOLVE_METHOD(av_audio_convert_alloc)
 231      RESOLVE_METHOD(av_audio_convert_free)
 232      RESOLVE_METHOD(av_audio_convert)
 233      RESOLVE_METHOD(av_dup_packet)
 234      RESOLVE_METHOD(av_init_packet)
 235 -    RESOLVE_METHOD(avcodec_guess_channel_layout)
 236    END_METHOD_RESOLVE()
 237
 238    /* dependencies of libavcodec */
 239 -  DllAvCore m_dllAvCore;
 240 +  DllAvUtil m_dllAvUtil;
 241    // DllAvUtil loaded implicitely by m_dllAvCore
 242
 243  public:
 244      static CCriticalSection m_critSection;
 245 -    int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
 246 +    int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
 247      {
 248        CSingleLock lock(DllAvCodec::m_critSection);
 249 -      return avcodec_open_dont_call(avctx,codec);
 250 +      return avcodec_open2_dont_call(avctx,codec, options);
 251      }
 252      int avcodec_close(AVCodecContext *avctx)
 253      {
 254 @@ -361,7 +318,7 @@
 255      }
 256      virtual bool Load()
 257      {
 258 -      if (!m_dllAvCore.Load())
 259 +      if (!m_dllAvUtil.Load())
 260         return false;
 261        return DllDynamic::Load();
 262      }
 263 diff -urN xbmc-11.0/lib/DllAvCore.h xbmc-11.0-ffmpeg-1.0/lib/DllAvCore.h
 264 --- xbmc-11.0/lib/DllAvCore.h   2012-03-21 23:07:50.000000000 +0100
 265 +++ xbmc-11.0-ffmpeg-1.0/lib/DllAvCore.h        1970-01-01 01:00:00.000000000 +0100
 266 @@ -1,182 +0,0 @@
 267 -#pragma once
 268 -/*
 269 - *      Copyright (C) 2005-2010 Team XBMC
 270 - *      http://www.xbmc.org
 271 - *
 272 - *  This Program is free software; you can redistribute it and/or modify
 273 - *  it under the terms of the GNU General Public License as published by
 274 - *  the Free Software Foundation; either version 2, or (at your option)
 275 - *  any later version.
 276 - *
 277 - *  This Program is distributed in the hope that it will be useful,
 278 - *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 279 - *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 280 - *  GNU General Public License for more details.
 281 - *
 282 - *  You should have received a copy of the GNU General Public License
 283 - *  along with XBMC; see the file COPYING.  If not, write to the Free
 284 - *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 285 - *  Boston, MA  02110-1301, USA.
 286 - *  http://www.gnu.org/copyleft/gpl.html
 287 - *
 288 - */
 289 -
 290 -#if (defined HAVE_CONFIG_H) && (!defined WIN32)
 291 -  #include "config.h"
 292 -#endif
 293 -#include "DynamicDll.h"
 294 -#include "DllAvUtil.h"
 295 -#include "utils/log.h"
 296 -
 297 -extern "C" {
 298 -#ifdef USE_EXTERNAL_FFMPEG
 299 -  #ifdef HAVE_LIBAVUTIL_SAMPLEFMT_H
 300 -    // libavcore was merged to libavutil on 2010-02-15
 301 -    #include <libavutil/audioconvert.h>
 302 -    #include <libavutil/samplefmt.h>
 303 -  #endif
 304 -
 305 -  #ifdef HAVE_LIBAVCORE_AVCORE_H
 306 -    #include <libavcore/avcore.h>
 307 -  #endif
 308 -  #ifdef HAVE_LIBAVCORE_SAMPLEFMT_H
 309 -    #include <libavcore/samplefmt.h>
 310 -  #endif
 311 -
 312 -  /* Needed for old FFmpeg versions as used below */
 313 -  #ifdef HAVE_LIBAVCODEC_AVCODEC_H
 314 -    #include <libavcodec/avcodec.h>
 315 -  #else
 316 -    #include <ffmpeg/avcodec.h>
 317 -  #endif
 318 -#else
 319 -  #include "libavcore/avcore.h"
 320 -  #include "libavcore/samplefmt.h"
 321 -#endif
 322 -}
 323 -
 324 -/* Compatibility for old external FFmpeg versions. */
 325 -
 326 -#ifdef USE_EXTERNAL_FFMPEG
 327 -
 328 -#ifndef LIBAVCORE_VERSION_INT
 329 -// API added on: 2010-07-21, removed on 2010-02-15
 330 -#define LIBAVCORE_VERSION_INT 0
 331 -#endif
 332 -
 333 -#ifndef AV_SAMPLE_FMT_NONE
 334 -// API added on: 2010-11-02
 335 -#define AVSampleFormat     SampleFormat
 336 -#define AV_SAMPLE_FMT_NONE SAMPLE_FMT_NONE
 337 -#define AV_SAMPLE_FMT_U8   SAMPLE_FMT_U8
 338 -#define AV_SAMPLE_FMT_S16  SAMPLE_FMT_S16
 339 -#define AV_SAMPLE_FMT_S32  SAMPLE_FMT_S32
 340 -#define AV_SAMPLE_FMT_FLT  SAMPLE_FMT_FLT
 341 -#define AV_SAMPLE_FMT_DBL  SAMPLE_FMT_DBL
 342 -#endif
 343 -
 344 -#ifndef AV_CH_FRONT_LEFT
 345 -// API added on: 2010-11-21
 346 -#define AV_CH_FRONT_LEFT            CH_FRONT_LEFT
 347 -#define AV_CH_FRONT_RIGHT           CH_FRONT_RIGHT
 348 -#define AV_CH_FRONT_CENTER          CH_FRONT_CENTER
 349 -#define AV_CH_LOW_FREQUENCY         CH_LOW_FREQUENCY
 350 -#define AV_CH_BACK_LEFT             CH_BACK_LEFT
 351 -#define AV_CH_BACK_RIGHT            CH_BACK_RIGHT
 352 -#define AV_CH_FRONT_LEFT_OF_CENTER  CH_FRONT_LEFT_OF_CENTER
 353 -#define AV_CH_FRONT_RIGHT_OF_CENTER CH_FRONT_RIGHT_OF_CENTER
 354 -#define AV_CH_BACK_CENTER           CH_BACK_CENTER
 355 -#define AV_CH_SIDE_LEFT             CH_SIDE_LEFT
 356 -#define AV_CH_SIDE_RIGHT            CH_SIDE_RIGHT
 357 -#define AV_CH_TOP_CENTER            CH_TOP_CENTER
 358 -#define AV_CH_TOP_FRONT_LEFT        CH_TOP_FRONT_LEFT
 359 -#define AV_CH_TOP_FRONT_CENTER      CH_TOP_FRONT_CENTER
 360 -#define AV_CH_TOP_FRONT_RIGHT       CH_TOP_FRONT_RIGHT
 361 -#define AV_CH_TOP_BACK_LEFT         CH_TOP_BACK_LEFT
 362 -#define AV_CH_TOP_BACK_CENTER       CH_TOP_BACK_CENTER
 363 -#define AV_CH_TOP_BACK_RIGHT        CH_TOP_BACK_RIGHT
 364 -#define AV_CH_STEREO_LEFT           CH_STEREO_LEFT
 365 -#define AV_CH_STEREO_RIGHT          CH_STEREO_RIGHT
 366 -
 367 -#define AV_CH_LAYOUT_NATIVE         CH_LAYOUT_NATIVE
 368 -
 369 -#define AV_CH_LAYOUT_MONO           CH_LAYOUT_MONO
 370 -#define AV_CH_LAYOUT_STEREO         CH_LAYOUT_STEREO
 371 -#define AV_CH_LAYOUT_2_1            CH_LAYOUT_2_1
 372 -#define AV_CH_LAYOUT_SURROUND       CH_LAYOUT_SURROUND
 373 -#define AV_CH_LAYOUT_4POINT0        CH_LAYOUT_4POINT0
 374 -#define AV_CH_LAYOUT_2_2            CH_LAYOUT_2_2
 375 -#define AV_CH_LAYOUT_QUAD           CH_LAYOUT_QUAD
 376 -#define AV_CH_LAYOUT_5POINT0        CH_LAYOUT_5POINT0
 377 -#define AV_CH_LAYOUT_5POINT1        CH_LAYOUT_5POINT1
 378 -#define AV_CH_LAYOUT_5POINT0_BACK   CH_LAYOUT_5POINT0_BACK
 379 -#define AV_CH_LAYOUT_5POINT1_BACK   CH_LAYOUT_5POINT1_BACK
 380 -#define AV_CH_LAYOUT_7POINT0        CH_LAYOUT_7POINT0
 381 -#define AV_CH_LAYOUT_7POINT1        CH_LAYOUT_7POINT1
 382 -#define AV_CH_LAYOUT_7POINT1_WIDE   CH_LAYOUT_7POINT1_WIDE
 383 -#define AV_CH_LAYOUT_STEREO_DOWNMIX CH_LAYOUT_STEREO_DOWNMIX
 384 -#endif
 385 -
 386 -#endif // USE_EXTERNAL_FFMPEG
 387 -
 388 -class DllAvCoreInterface
 389 -{
 390 -public:
 391 -  virtual ~DllAvCoreInterface() {}
 392 -  virtual int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt) = 0;
 393 -};
 394 -
 395 -#if (defined USE_EXTERNAL_FFMPEG)
 396 -
 397 -// Use direct layer
 398 -class DllAvCore : public DllDynamic, DllAvCoreInterface
 399 -{
 400 -public:
 401 -  virtual ~DllAvCore() {}
 402 -#if LIBAVCORE_VERSION_INT >= AV_VERSION_INT(0,12,0) || LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(50,38,0)
 403 -  // API added on: 2010-11-02, moved to libavutil on 2010-02-15
 404 -  virtual int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt) { return ::av_get_bits_per_sample_fmt(sample_fmt); }
 405 -#else
 406 -  // from avcodec.h
 407 -  virtual int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt) { return ::av_get_bits_per_sample_format(sample_fmt); }
 408 -#endif
 409 -
 410 -  // DLL faking.
 411 -  virtual bool ResolveExports() { return true; }
 412 -  virtual bool Load() {
 413 -#if LIBAVCORE_VERSION_INT > 0
 414 -    CLog::Log(LOGDEBUG, "DllAvCore: Using libavcore system library");
 415 -#endif
 416 -    return true;
 417 -  }
 418 -  virtual void Unload() {}
 419 -};
 420 -
 421 -#else
 422 -
 423 -class DllAvCore : public DllDynamic, DllAvCoreInterface
 424 -{
 425 -  DECLARE_DLL_WRAPPER(DllAvCore, DLL_PATH_LIBAVCORE)
 426 -
 427 -  LOAD_SYMBOLS()
 428 -
 429 -  DEFINE_METHOD1(int, av_get_bits_per_sample_fmt, (enum AVSampleFormat p1))
 430 -
 431 -  BEGIN_METHOD_RESOLVE()
 432 -    RESOLVE_METHOD(av_get_bits_per_sample_fmt)
 433 -  END_METHOD_RESOLVE()
 434 -
 435 -  /* dependency of libavcore */
 436 -  DllAvUtil m_dllAvUtil;
 437 -
 438 -public:
 439 -  virtual bool Load()
 440 -  {
 441 -    if (!m_dllAvUtil.Load())
 442 -      return false;
 443 -    return DllDynamic::Load();
 444 -  }
 445 -};
 446 -
 447 -#endif
 448 -
 449 diff -urN xbmc-11.0/lib/DllAvFilter.h xbmc-11.0-ffmpeg-1.0/lib/DllAvFilter.h
 450 --- xbmc-11.0/lib/DllAvFilter.h 2012-03-21 23:07:50.000000000 +0100
 451 +++ xbmc-11.0-ffmpeg-1.0/lib/DllAvFilter.h      2012-11-08 23:16:12.336405273 +0100
 452 @@ -24,8 +24,8 @@
 453    #include "config.h"
 454  #endif
 455  #include "DynamicDll.h"
 456 -#include "DllAvCore.h"
 457  #include "DllAvCodec.h"
 458 +#include "DllSwResample.h"
 459  #include "utils/log.h"
 460
 461  extern "C" {
 462 @@ -43,24 +43,17 @@
 463  #if (defined USE_EXTERNAL_FFMPEG)
 464    #if (defined HAVE_LIBAVFILTER_AVFILTER_H)
 465      #include <libavfilter/avfiltergraph.h>
 466 +    #include <libavfilter/buffersink.h>
 467 +    #include <libavfilter/avcodec.h>
 468    #elif (defined HAVE_FFMPEG_AVFILTER_H)
 469      #include <ffmpeg/avfiltergraph.h>
 470 -  #endif
 471 -  /* for av_vsrc_buffer_add_frame */
 472 -  #if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,8,0)
 473 -    #include <libavfilter/avcodec.h>
 474 -  #elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,7,0)
 475 -    int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter,
 476 -                                 AVFrame *frame);
 477 -  #elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53,3,0)
 478 -    int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter,
 479 -                                 AVFrame *frame, int64_t pts);
 480 -  #else
 481 -    int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter,
 482 -          AVFrame *frame, int64_t pts, AVRational pixel_aspect);
 483 +    #include <ffmpeg/buffersink.h>
 484 +    #include <ffmpeg/avcodec.h>
 485    #endif
 486  #else
 487    #include "libavfilter/avfiltergraph.h"
 488 +  #include "libavfilter/buffersink.h"
 489 +  #include "libavfilter/avcodec.h"
 490  #endif
 491  }
 492
 493 @@ -80,20 +73,16 @@
 494    virtual void avfilter_inout_free(AVFilterInOut **inout)=0;
 495    virtual int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)=0;
 496    virtual int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)=0;
 497 -  virtual int avfilter_poll_frame(AVFilterLink *link)=0;
 498 -  virtual int avfilter_request_frame(AVFilterLink *link)=0;
 499 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,13,0)
 500 +#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,0,0)
 501    virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int flags)=0;
 502 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,7,0)
 503 -  virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame)=0;
 504 -#elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53,3,0)
 505 -  virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int64_t pts)=0;
 506  #else
 507 -  virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int64_t pts, AVRational pixel_aspect)=0;
 508 +  virtual int av_buffersrc_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int flags)=0;
 509  #endif
 510 -  virtual AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)=0;
 511    virtual void avfilter_unref_buffer(AVFilterBufferRef *ref)=0;
 512    virtual int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)=0;
 513 +  virtual int av_buffersink_get_buffer_ref(AVFilterContext *buffer_sink, AVFilterBufferRef **bufref, int flags)=0;
 514 +  virtual AVBufferSinkParams *av_buffersink_params_alloc()=0;
 515 +  virtual int av_buffersink_poll_frame(AVFilterContext *ctx)=0;
 516  };
 517
 518  #if (defined USE_EXTERNAL_FFMPEG)
 519 @@ -115,12 +104,7 @@
 520    virtual void avfilter_graph_free(AVFilterGraph **graph)
 521    {
 522      CSingleLock lock(DllAvCodec::m_critSection);
 523 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(1,76,0)
 524      ::avfilter_graph_free(graph);
 525 -#else
 526 -    ::avfilter_graph_free(*graph);
 527 -    *graph = NULL;
 528 -#endif
 529    }
 530    void avfilter_register_all()
 531    {
 532 @@ -133,56 +117,32 @@
 533    virtual AVFilterInOut *avfilter_inout_alloc()
 534    {
 535      CSingleLock lock(DllAvCodec::m_critSection);
 536 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,17,0)
 537      return ::avfilter_inout_alloc();
 538 -#else
 539 -    return (AVFilterInOut*)::av_mallocz(sizeof(AVFilterInOut));
 540 -#endif
 541    }
 542    virtual void avfilter_inout_free(AVFilterInOut **inout)
 543    {
 544      CSingleLock lock(DllAvCodec::m_critSection);
 545 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,17,0)
 546      ::avfilter_inout_free(inout);
 547 -#else
 548 -    *inout = NULL;
 549 -#endif
 550    }
 551    virtual int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)
 552    {
 553      CSingleLock lock(DllAvCodec::m_critSection);
 554 -#if   (   LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(1,79,0) \
 555 -       && LIBAVFILTER_VERSION_INT <  AV_VERSION_INT(2,0,0) ) \
 556 -    ||(   LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,16,0))
 557      return ::avfilter_graph_parse(graph, filters, inputs, outputs, log_ctx);
 558 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,15,1)
 559 -    return ::avfilter_graph_parse(graph, filters, *inputs, *outputs, log_ctx);
 560 -#else
 561 -    return ::avfilter_graph_parse(graph, filters, *inputs, *outputs, (AVClass*)log_ctx);
 562 -#endif
 563    }
 564    virtual int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
 565    {
 566 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,15,1)
 567      return ::avfilter_graph_config(graphctx, log_ctx);
 568 -#else
 569 -    return ::avfilter_graph_config(graphctx, (AVClass*)log_ctx);
 570 -#endif
 571    }
 572 -  virtual int avfilter_poll_frame(AVFilterLink *link) { return ::avfilter_poll_frame(link); }
 573 -  virtual int avfilter_request_frame(AVFilterLink *link) { return ::avfilter_request_frame(link); }
 574 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,13,0)
 575 +#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,0,0)
 576    virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int flags) { return ::av_vsrc_buffer_add_frame(buffer_filter, frame, flags); }
 577 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,7,0)
 578 -  virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame) { return ::av_vsrc_buffer_add_frame(buffer_filter, frame); }
 579 -#elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53,3,0)
 580 -  virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int64_t pts) { return ::av_vsrc_buffer_add_frame(buffer_filter, frame, pts); }
 581  #else
 582 -  virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int64_t pts, AVRational pixel_aspect) { return ::av_vsrc_buffer_add_frame(buffer_filter, frame, pts, pixel_aspect); }
 583 +  virtual int av_buffersrc_add_frame(AVFilterContext *buffer_filter, AVFrame* frame, int flags) { return ::av_buffersrc_add_frame(buffer_filter, frame, flags); }
 584  #endif
 585 -  virtual AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h) { return ::avfilter_get_video_buffer(link, perms, w, h); }
 586    virtual void avfilter_unref_buffer(AVFilterBufferRef *ref) { ::avfilter_unref_buffer(ref); }
 587    virtual int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad) { return ::avfilter_link(src, srcpad, dst, dstpad); }
 588 +  virtual int av_buffersink_get_buffer_ref(AVFilterContext *buffer_sink, AVFilterBufferRef **bufref, int flags) { return ::av_buffersink_get_buffer_ref(buffer_sink, bufref, flags); }
 589 +  virtual AVBufferSinkParams *av_buffersink_params_alloc() { return ::av_buffersink_params_alloc(); }
 590 +  virtual int av_buffersink_poll_frame(AVFilterContext *ctx) { return av_buffersink_poll_frame(ctx); }
 591    // DLL faking.
 592    virtual bool ResolveExports() { return true; }
 593    virtual bool Load() {
 594 @@ -200,45 +160,25 @@
 595
 596    DEFINE_METHOD3(int, avfilter_open_dont_call, (AVFilterContext **p1, AVFilter *p2, const char *p3))
 597    DEFINE_METHOD1(void, avfilter_free_dont_call, (AVFilterContext *p1))
 598 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(1,76,0)
 599    DEFINE_METHOD1(void, avfilter_graph_free_dont_call, (AVFilterGraph **p1))
 600 -#else
 601 -  DEFINE_METHOD1(void, avfilter_graph_free_dont_call, (AVFilterGraph *p1))
 602 -#endif
 603    DEFINE_METHOD0(void, avfilter_register_all_dont_call)
 604    DEFINE_METHOD6(int, avfilter_graph_create_filter, (AVFilterContext **p1, AVFilter *p2, const char *p3, const char *p4, void *p5, AVFilterGraph *p6))
 605    DEFINE_METHOD1(AVFilter*, avfilter_get_by_name, (const char *p1))
 606    DEFINE_METHOD0(AVFilterGraph*, avfilter_graph_alloc)
 607 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,17,0)
 608    DEFINE_METHOD0(AVFilterInOut*, avfilter_inout_alloc_dont_call)
 609    DEFINE_METHOD1(void, avfilter_inout_free_dont_call, (AVFilterInOut **p1))
 610 -#endif
 611 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,16,0)
 612 -  DEFINE_METHOD5(int, avfilter_graph_parse_dont_call, (AVFilterGraph *p1, const char *p2, AVFilterInOut **p3, AVFilterInOut **p4, void *p5))
 613 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,15,1)
 614 -  DEFINE_METHOD5(int, avfilter_graph_parse_dont_call, (AVFilterGraph *p1, const char *p2, AVFilterInOut *p3, AVFilterInOut *p4, void *p5))
 615 -#else
 616 -  DEFINE_METHOD5(int, avfilter_graph_parse_dont_call, (AVFilterGraph *p1, const char *p2, AVFilterInOut *p3, AVFilterInOut *p4, AVClass *p5))
 617 -#endif
 618 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,15,1)
 619 -  DEFINE_METHOD2(int, avfilter_graph_config_dont_call, (AVFilterGraph *p1, void *p2))
 620 -#else
 621 -  DEFINE_METHOD2(int, avfilter_graph_config_dont_call, (AVFilterGraph *p1, AVClass *p2))
 622 -#endif
 623 -  DEFINE_FUNC_ALIGNED1(int, __cdecl, avfilter_poll_frame, AVFilterLink *)
 624 -  DEFINE_FUNC_ALIGNED1(int, __cdecl, avfilter_request_frame, AVFilterLink*)
 625 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,13,0)
 626 +  DEFINE_FUNC_ALIGNED5(int, __cdecl, avfilter_graph_parse_dont_call, AVFilterGraph *, const char *, AVFilterInOut **, AVFilterInOut **, void *)
 627 +  DEFINE_FUNC_ALIGNED2(int, __cdecl, avfilter_graph_config_dont_call, AVFilterGraph *, void *)
 628 +#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,0,0)
 629    DEFINE_METHOD3(int, av_vsrc_buffer_add_frame, (AVFilterContext *p1, AVFrame *p2, int p3))
 630 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,7,0)
 631 -  DEFINE_METHOD2(int, av_vsrc_buffer_add_frame, (AVFilterContext *p1, AVFrame *p2))
 632 -#elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53,3,0)
 633 -  DEFINE_METHOD3(int, av_vsrc_buffer_add_frame, (AVFilterContext *p1, AVFrame *p2, int64_t p3))
 634  #else
 635 -  DEFINE_METHOD4(int, av_vsrc_buffer_add_frame, (AVFilterContext *p1, AVFrame *p2, int64_t p3, AVRational p4))
 636 +  DEFINE_METHOD3(int, av_buffersrc_add_frame, (AVFilterContext *p1, AVFrame *p2, int p3))
 637  #endif
 638 -  DEFINE_METHOD4(AVFilterBufferRef*, avfilter_get_video_buffer, (AVFilterLink *p1, int p2, int p3, int p4))
 639    DEFINE_METHOD1(void, avfilter_unref_buffer, (AVFilterBufferRef *p1))
 640    DEFINE_METHOD4(int, avfilter_link, (AVFilterContext *p1, unsigned p2, AVFilterContext *p3, unsigned p4))
 641 +  DEFINE_FUNC_ALIGNED3(int                , __cdecl, av_buffersink_get_buffer_ref, AVFilterContext *, AVFilterBufferRef **, int);
 642 +  DEFINE_FUNC_ALIGNED0(AVBufferSinkParams*, __cdecl, av_buffersink_params_alloc);
 643 +  DEFINE_FUNC_ALIGNED1(int                , __cdecl, av_buffersink_poll_frame, AVFilterContext *);
 644
 645    BEGIN_METHOD_RESOLVE()
 646      RESOLVE_METHOD_RENAME(avfilter_open, avfilter_open_dont_call)
 647 @@ -248,22 +188,25 @@
 648      RESOLVE_METHOD(avfilter_graph_create_filter)
 649      RESOLVE_METHOD(avfilter_get_by_name)
 650      RESOLVE_METHOD(avfilter_graph_alloc)
 651 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,17,0)
 652      RESOLVE_METHOD_RENAME(avfilter_inout_alloc, avfilter_inout_alloc_dont_call)
 653      RESOLVE_METHOD_RENAME(avfilter_inout_free, avfilter_inout_free_dont_call)
 654 -#endif
 655      RESOLVE_METHOD_RENAME(avfilter_graph_parse, avfilter_graph_parse_dont_call)
 656      RESOLVE_METHOD_RENAME(avfilter_graph_config, avfilter_graph_config_dont_call)
 657 -    RESOLVE_METHOD(avfilter_poll_frame)
 658 -    RESOLVE_METHOD(avfilter_request_frame)
 659 +#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,0,0)
 660      RESOLVE_METHOD(av_vsrc_buffer_add_frame)
 661 -    RESOLVE_METHOD(avfilter_get_video_buffer)
 662 +#else
 663 +    RESOLVE_METHOD(av_buffersrc_add_frame)
 664 +#endif
 665      RESOLVE_METHOD(avfilter_unref_buffer)
 666      RESOLVE_METHOD(avfilter_link)
 667 +    RESOLVE_METHOD(av_buffersink_get_buffer_ref)
 668 +    RESOLVE_METHOD(av_buffersink_params_alloc)
 669 +    RESOLVE_METHOD(av_buffersink_poll_frame)
 670    END_METHOD_RESOLVE()
 671
 672    /* dependencies of libavfilter */
 673    DllAvUtil m_dllAvUtil;
 674 +  DllSwResample m_dllSwResample;
 675
 676  public:
 677    int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
 678 @@ -279,12 +222,7 @@
 679    void avfilter_graph_free(AVFilterGraph **graph)
 680    {
 681      CSingleLock lock(DllAvCodec::m_critSection);
 682 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(1,76,0)
 683      avfilter_graph_free_dont_call(graph);
 684 -#else
 685 -    avfilter_graph_free_dont_call(*graph);
 686 -    m_dllAvUtil.av_freep(graph);
 687 -#endif
 688    }
 689    void avfilter_register_all()
 690    {
 691 @@ -294,45 +232,29 @@
 692    AVFilterInOut* avfilter_inout_alloc()
 693    {
 694      CSingleLock lock(DllAvCodec::m_critSection);
 695 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,17,0)
 696      return avfilter_inout_alloc_dont_call();
 697 -#else
 698 -    return (AVFilterInOut*)m_dllAvUtil.av_mallocz(sizeof(AVFilterInOut));
 699 -#endif
 700    }
 701    int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)
 702    {
 703      CSingleLock lock(DllAvCodec::m_critSection);
 704 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,16,0)
 705      return avfilter_graph_parse_dont_call(graph, filters, inputs, outputs, log_ctx);
 706 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,15,1)
 707 -    return avfilter_graph_parse_dont_call(graph, filters, *inputs, *outputs, log_ctx);
 708 -#else
 709 -    return avfilter_graph_parse_dont_call(graph, filters, *inputs, *outputs, (AVClass*)log_ctx);
 710 -#endif
 711    }
 712    void avfilter_inout_free(AVFilterInOut **inout)
 713    {
 714      CSingleLock lock(DllAvCodec::m_critSection);
 715 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,17,0)
 716      avfilter_inout_free_dont_call(inout);
 717 -#else
 718 -    *inout = NULL;
 719 -#endif
 720    }
 721    int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
 722    {
 723      CSingleLock lock(DllAvCodec::m_critSection);
 724 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,15,1)
 725      return avfilter_graph_config_dont_call(graphctx, log_ctx);
 726 -#else
 727 -    return avfilter_graph_config_dont_call(graphctx, (AVClass*)log_ctx);
 728 -#endif
 729    }
 730    virtual bool Load()
 731    {
 732      if (!m_dllAvUtil.Load())
 733        return false;
 734 +    if (!m_dllSwResample.Load())
 735 +      return false;
 736      return DllDynamic::Load();
 737    }
 738  };
 739 diff -urN xbmc-11.0/lib/DllAvFormat.h xbmc-11.0-ffmpeg-1.0/lib/DllAvFormat.h
 740 --- xbmc-11.0/lib/DllAvFormat.h 2012-03-21 23:07:50.000000000 +0100
 741 +++ xbmc-11.0-ffmpeg-1.0/lib/DllAvFormat.h      2012-11-08 23:16:03.529738917 +0100
 742 @@ -62,54 +62,42 @@
 743    virtual ~DllAvFormatInterface() {}
 744    virtual void av_register_all_dont_call(void)=0;
 745    virtual AVInputFormat *av_find_input_format(const char *short_name)=0;
 746 -  virtual int url_feof(ByteIOContext *s)=0;
 747 -  virtual AVMetadataTag *av_metadata_get(AVMetadata *m, const char *key, const AVMetadataTag *prev, int flags)=0;
 748 -  virtual void av_close_input_file(AVFormatContext *s)=0;
 749 -  virtual void av_close_input_stream(AVFormatContext *s)=0;
 750 +  virtual int url_feof(AVIOContext *s)=0;
 751 +  virtual void avformat_close_input(AVFormatContext **s)=0;
 752    virtual int av_read_frame(AVFormatContext *s, AVPacket *pkt)=0;
 753    virtual void av_read_frame_flush(AVFormatContext *s)=0;
 754    virtual int av_read_play(AVFormatContext *s)=0;
 755    virtual int av_read_pause(AVFormatContext *s)=0;
 756    virtual int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)=0;
 757  #if (!defined USE_EXTERNAL_FFMPEG)
 758 -  virtual int av_find_stream_info_dont_call(AVFormatContext *ic)=0;
 759 +  virtual int avformat_find_stream_info_dont_call(AVFormatContext *ic, AVDictionary **options)=0;
 760  #endif
 761 -  virtual int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, AVInputFormat *fmt, int buf_size, AVFormatParameters *ap)=0;
 762 -  virtual void url_set_interrupt_cb(URLInterruptCB *interrupt_cb)=0;
 763 -  virtual int av_open_input_stream(AVFormatContext **ic_ptr, ByteIOContext *pb, const char *filename, AVInputFormat *fmt, AVFormatParameters *ap)=0;
 764 -  virtual int init_put_byte(ByteIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque,
 765 +  virtual int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)=0;
 766 +  virtual AVIOContext *avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque,
 767                              int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 768                              int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 769                              offset_t (*seek)(void *opaque, offset_t offset, int whence))=0;
 770    virtual AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)=0;
 771    virtual AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)=0;
 772 -  virtual int av_probe_input_buffer(ByteIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)=0;
 773 -  virtual void dump_format(AVFormatContext *ic, int index, const char *url, int is_output)=0;
 774 -  virtual int url_fdopen(ByteIOContext **s, URLContext *h)=0;
 775 -  virtual int url_fopen(ByteIOContext **s, const char *filename, int flags)=0;
 776 -  virtual int url_fclose(ByteIOContext *s)=0;
 777 -  virtual int url_open_dyn_buf(ByteIOContext **s)=0;
 778 -  virtual int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)=0;
 779 -  virtual offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence)=0;
 780 -  virtual int get_buffer(ByteIOContext *s, unsigned char *buf, int size)=0;
 781 -  virtual int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size)=0;
 782 -  virtual void put_byte(ByteIOContext *s, int b)=0;
 783 -  virtual void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)=0;
 784 -  virtual void put_be24(ByteIOContext *s, unsigned int val)=0;
 785 -  virtual void put_be32(ByteIOContext *s, unsigned int val)=0;
 786 -  virtual void put_be16(ByteIOContext *s, unsigned int val)=0;
 787 +  virtual int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)=0;
 788 +  virtual void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)=0;
 789 +  virtual int avio_open(AVIOContext **s, const char *filename, int flags)=0;
 790 +  virtual int avio_close(AVIOContext *s)=0;
 791 +  virtual int avio_open_dyn_buf(AVIOContext **s)=0;
 792 +  virtual int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)=0;
 793 +  virtual offset_t avio_seek(AVIOContext *s, offset_t offset, int whence)=0;
 794 +  virtual int avio_read(AVIOContext *s, unsigned char *buf, int size)=0;
 795 +  virtual void avio_w8(AVIOContext *s, int b)=0;
 796 +  virtual void avio_write(AVIOContext *s, const unsigned char *buf, int size)=0;
 797 +  virtual void avio_wb24(AVIOContext *s, unsigned int val)=0;
 798 +  virtual void avio_wb32(AVIOContext *s, unsigned int val)=0;
 799 +  virtual void avio_wb16(AVIOContext *s, unsigned int val)=0;
 800    virtual AVFormatContext *avformat_alloc_context(void)=0;
 801 -  virtual AVStream *av_new_stream(AVFormatContext *s, int id)=0;
 802 +  virtual AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)=0;
 803    virtual AVOutputFormat *av_guess_format(const char *short_name, const char *filename, const char *mime_type)=0;
 804 -  virtual int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)=0;
 805 -  virtual ByteIOContext *av_alloc_put_byte(unsigned char *buffer, int buffer_size, int write_flag, void *opaque,
 806 -                                           int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 807 -                                           int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 808 -                                           offset_t (*seek)(void *opaque, offset_t offset, int whence))=0;
 809 -  virtual int av_write_header (AVFormatContext *s)=0;
 810 +  virtual int avformat_write_header (AVFormatContext *s, AVDictionary **options)=0;
 811    virtual int av_write_trailer(AVFormatContext *s)=0;
 812    virtual int av_write_frame  (AVFormatContext *s, AVPacket *pkt)=0;
 813 -  virtual int av_metadata_set2(AVMetadata **pm, const char *key, const char *value, int flags)=0;
 814  };
 815
 816  #if (defined USE_EXTERNAL_FFMPEG)
 817 @@ -126,78 +114,45 @@
 818    }
 819    virtual void av_register_all_dont_call() { *(int* )0x0 = 0; }
 820    virtual AVInputFormat *av_find_input_format(const char *short_name) { return ::av_find_input_format(short_name); }
 821 -  virtual int url_feof(ByteIOContext *s) { return ::url_feof(s); }
 822 -#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52,31,0)
 823 -  // API added on: 2009-03-01
 824 -  virtual AVMetadataTag *av_metadata_get(AVMetadata *m, const char *key, const AVMetadataTag *prev, int flags){ return ::av_metadata_get(m, key, prev, flags); }
 825 -#else
 826 -  virtual AVMetadataTag *av_metadata_get(AVMetadata *m, const char *key, const AVMetadataTag *prev, int flags){ return NULL; }
 827 -#endif
 828 -  virtual void av_close_input_file(AVFormatContext *s) { ::av_close_input_file(s); }
 829 -  virtual void av_close_input_stream(AVFormatContext *s) { ::av_close_input_stream(s); }
 830 +  virtual int url_feof(AVIOContext *s) { return ::url_feof(s); }
 831 +  virtual void avformat_close_input(AVFormatContext **s) { ::avformat_close_input(s); }
 832    virtual int av_read_frame(AVFormatContext *s, AVPacket *pkt) { return ::av_read_frame(s, pkt); }
 833    virtual void av_read_frame_flush(AVFormatContext *s) { ::av_read_frame_flush(s); }
 834    virtual int av_read_play(AVFormatContext *s) { return ::av_read_play(s); }
 835    virtual int av_read_pause(AVFormatContext *s) { return ::av_read_pause(s); }
 836    virtual int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) { return ::av_seek_frame(s, stream_index, timestamp, flags); }
 837 -  virtual int av_find_stream_info(AVFormatContext *ic)
 838 +  virtual int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
 839    {
 840      CSingleLock lock(DllAvCodec::m_critSection);
 841 -    return ::av_find_stream_info(ic);
 842 +    return ::avformat_find_stream_info(ic, options);
 843    }
 844 -  virtual int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, AVInputFormat *fmt, int buf_size, AVFormatParameters *ap) { return ::av_open_input_file(ic_ptr, filename, fmt, buf_size, ap); }
 845 -  virtual void url_set_interrupt_cb(URLInterruptCB *interrupt_cb) { ::url_set_interrupt_cb(interrupt_cb); }
 846 -  virtual int av_open_input_stream(AVFormatContext **ic_ptr, ByteIOContext *pb, const char *filename, AVInputFormat *fmt, AVFormatParameters *ap) { return ::av_open_input_stream(ic_ptr, pb, filename, fmt, ap); }
 847 -  virtual int init_put_byte(ByteIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque,
 848 +  virtual int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
 849 +  { return ::avformat_open_input(ps, filename, fmt, options); }
 850 +  virtual AVIOContext *avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque,
 851                              int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 852                              int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 853 -                            offset_t (*seek)(void *opaque, offset_t offset, int whence)) { return ::init_put_byte(s, buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek); }
 854 +                            offset_t (*seek)(void *opaque, offset_t offset, int whence)) { return ::avio_alloc_context(buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek); }
 855    virtual AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened) {return ::av_probe_input_format(pd, is_opened); }
 856    virtual AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max) {*score_max = 100; return ::av_probe_input_format(pd, is_opened); } // Use av_probe_input_format, this is not exported by ffmpeg's headers
 857 -#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52,98,0)
 858 -  // API added on: 2010-02-08
 859 -  virtual int av_probe_input_buffer(ByteIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size) { return ::av_probe_input_buffer(pb, fmt, filename, logctx, offset, max_probe_size); }
 860 -#else
 861 -  virtual int av_probe_input_buffer(ByteIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size) { return -1; }
 862 -#endif
 863 -  virtual void dump_format(AVFormatContext *ic, int index, const char *url, int is_output) { ::dump_format(ic, index, url, is_output); }
 864 -  virtual int url_fdopen(ByteIOContext **s, URLContext *h) { return ::url_fdopen(s, h); }
 865 -  virtual int url_fopen(ByteIOContext **s, const char *filename, int flags) { return ::url_fopen(s, filename, flags); }
 866 -  virtual int url_fclose(ByteIOContext *s) { return ::url_fclose(s); }
 867 -  virtual int url_open_dyn_buf(ByteIOContext **s) { return ::url_open_dyn_buf(s); }
 868 -  virtual int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer) { return ::url_close_dyn_buf(s, pbuffer); }
 869 -  virtual offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence) { return ::url_fseek(s, offset, whence); }
 870 -  virtual int get_buffer(ByteIOContext *s, unsigned char *buf, int size) { return ::get_buffer(s, buf, size); }
 871 -  virtual int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size) { return ::get_partial_buffer(s, buf, size); }
 872 -  virtual void put_byte(ByteIOContext *s, int b) { ::put_byte(s, b); }
 873 -  virtual void put_buffer(ByteIOContext *s, const unsigned char *buf, int size) { ::put_buffer(s, buf, size); }
 874 -  virtual void put_be24(ByteIOContext *s, unsigned int val) { ::put_be24(s, val); }
 875 -  virtual void put_be32(ByteIOContext *s, unsigned int val) { ::put_be32(s, val); }
 876 -  virtual void put_be16(ByteIOContext *s, unsigned int val) { ::put_be16(s, val); }
 877 +  virtual int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size) { return ::av_probe_input_buffer(pb, fmt, filename, logctx, offset, max_probe_size); }
 878 +  virtual void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output) { ::av_dump_format(ic, index, url, is_output); }
 879 +  virtual int avio_open(AVIOContext **s, const char *filename, int flags) { return ::avio_open(s, filename, flags); }
 880 +  virtual int avio_close(AVIOContext *s) { return ::avio_close(s); }
 881 +  virtual int avio_open_dyn_buf(AVIOContext **s) { return ::avio_open_dyn_buf(s); }
 882 +  virtual int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer) { return ::avio_close_dyn_buf(s, pbuffer); }
 883 +  virtual offset_t avio_seek(AVIOContext *s, offset_t offset, int whence) { return ::avio_seek(s, offset, whence); }
 884 +  virtual int avio_read(AVIOContext *s, unsigned char *buf, int size) { return ::avio_read(s, buf, size); }
 885 +  virtual void avio_w8(AVIOContext *s, int b) { ::avio_w8(s, b); }
 886 +  virtual void avio_write(AVIOContext *s, const unsigned char *buf, int size) { ::avio_write(s, buf, size); }
 887 +  virtual void avio_wb24(AVIOContext *s, unsigned int val) { ::avio_wb24(s, val); }
 888 +  virtual void avio_wb32(AVIOContext *s, unsigned int val) { ::avio_wb32(s, val); }
 889 +  virtual void avio_wb16(AVIOContext *s, unsigned int val) { ::avio_wb16(s, val); }
 890    virtual AVFormatContext *avformat_alloc_context() { return ::avformat_alloc_context(); }
 891 -  virtual AVStream *av_new_stream(AVFormatContext *s, int id) { return ::av_new_stream(s, id); }
 892 -#if LIBAVFORMAT_VERSION_INT < (52<<16 | 45<<8)
 893 -  virtual AVOutputFormat *av_guess_format(const char *short_name, const char *filename, const char *mime_type) { return ::guess_format(short_name, filename, mime_type); }
 894 -#else
 895 +  virtual AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c) { return ::avformat_new_stream(s, c); }
 896    virtual AVOutputFormat *av_guess_format(const char *short_name, const char *filename, const char *mime_type) { return ::av_guess_format(short_name, filename, mime_type); }
 897 -#endif
 898 -  virtual int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap) { return ::av_set_parameters(s, ap); }
 899 -  virtual ByteIOContext *av_alloc_put_byte(unsigned char *buffer, int buffer_size, int write_flag, void *opaque,
 900 -                                           int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 901 -                                           int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 902 -                                           offset_t (*seek)(void *opaque, offset_t offset, int whence)) { return ::av_alloc_put_byte(buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek); }
 903 -  virtual int av_write_header (AVFormatContext *s) { return ::av_write_header (s); }
 904 +  virtual int avformat_write_header (AVFormatContext *s, AVDictionary **options) { return ::avformat_write_header (s, options); }
 905    virtual int av_write_trailer(AVFormatContext *s) { return ::av_write_trailer(s); }
 906    virtual int av_write_frame  (AVFormatContext *s, AVPacket *pkt) { return ::av_write_frame(s, pkt); }
 907 -#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52,43,0)
 908 -  // API added on: 2009-12-13
 909 -  virtual int av_metadata_set2(AVMetadata **pm, const char *key, const char *value, int flags) { return ::av_metadata_set2(pm, key, value, flags); }
 910 -#elif LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52,31,0)
 911 -  // API added on: 2009-03-01
 912 -  virtual int av_metadata_set2(AVMetadata **pm, const char *key, const char *value, int flags) { return ::av_metadata_set(pm, key, value); }
 913 -#else
 914 -  virtual int av_metadata_set2(AVMetadata **pm, const char *key, const char *value, int flags) { return -1; }
 915 -#endif
 916
 917    // DLL faking.
 918    virtual bool ResolveExports() { return true; }
 919 @@ -218,108 +173,78 @@
 920
 921    DEFINE_METHOD0(void, av_register_all_dont_call)
 922    DEFINE_METHOD1(AVInputFormat*, av_find_input_format, (const char *p1))
 923 -  DEFINE_METHOD1(int, url_feof, (ByteIOContext *p1))
 924 -  DEFINE_METHOD4(AVMetadataTag*, av_metadata_get, (AVMetadata *p1, const char *p2, const AVMetadataTag *p3, int p4))
 925 -  DEFINE_METHOD1(void, av_close_input_file, (AVFormatContext *p1))
 926 -  DEFINE_METHOD1(void, av_close_input_stream, (AVFormatContext *p1))
 927 +  DEFINE_METHOD1(int, url_feof, (AVIOContext *p1))
 928 +  DEFINE_METHOD1(void, avformat_close_input, (AVFormatContext **p1))
 929    DEFINE_METHOD1(int, av_read_play, (AVFormatContext *p1))
 930    DEFINE_METHOD1(int, av_read_pause, (AVFormatContext *p1))
 931    DEFINE_METHOD1(void, av_read_frame_flush, (AVFormatContext *p1))
 932    DEFINE_FUNC_ALIGNED2(int, __cdecl, av_read_frame, AVFormatContext *, AVPacket *)
 933    DEFINE_FUNC_ALIGNED4(int, __cdecl, av_seek_frame, AVFormatContext*, int, int64_t, int)
 934 -  DEFINE_FUNC_ALIGNED1(int, __cdecl, av_find_stream_info_dont_call, AVFormatContext*)
 935 -  DEFINE_FUNC_ALIGNED5(int, __cdecl, av_open_input_file, AVFormatContext**, const char *, AVInputFormat *, int, AVFormatParameters *)
 936 -  DEFINE_FUNC_ALIGNED5(int,__cdecl, av_open_input_stream, AVFormatContext **, ByteIOContext *, const char *, AVInputFormat *, AVFormatParameters *)
 937 +  DEFINE_FUNC_ALIGNED2(int, __cdecl, avformat_find_stream_info_dont_call, AVFormatContext*, AVDictionary **)
 938 +  DEFINE_FUNC_ALIGNED4(int, __cdecl, avformat_open_input, AVFormatContext **, const char *, AVInputFormat *, AVDictionary **)
 939    DEFINE_FUNC_ALIGNED2(AVInputFormat*, __cdecl, av_probe_input_format, AVProbeData*, int)
 940    DEFINE_FUNC_ALIGNED3(AVInputFormat*, __cdecl, av_probe_input_format2, AVProbeData*, int, int*)
 941 -  DEFINE_FUNC_ALIGNED6(int, __cdecl, av_probe_input_buffer, ByteIOContext *, AVInputFormat **, const char *, void *, unsigned int, unsigned int)
 942 -  DEFINE_FUNC_ALIGNED3(int, __cdecl, get_buffer, ByteIOContext*, unsigned char *, int)
 943 -  DEFINE_FUNC_ALIGNED3(int, __cdecl, get_partial_buffer, ByteIOContext*, unsigned char *, int)
 944 -  DEFINE_FUNC_ALIGNED2(void, __cdecl, put_byte, ByteIOContext*, int)
 945 -  DEFINE_FUNC_ALIGNED3(void, __cdecl, put_buffer, ByteIOContext*, const unsigned char *, int)
 946 -  DEFINE_FUNC_ALIGNED2(void, __cdecl, put_be24, ByteIOContext*, unsigned int)
 947 -  DEFINE_FUNC_ALIGNED2(void, __cdecl, put_be32, ByteIOContext*, unsigned int)
 948 -  DEFINE_FUNC_ALIGNED2(void, __cdecl, put_be16, ByteIOContext*, unsigned int)
 949 -  DEFINE_METHOD1(void, url_set_interrupt_cb, (URLInterruptCB *p1))
 950 -  DEFINE_METHOD8(int, init_put_byte, (ByteIOContext *p1, unsigned char *p2, int p3, int p4, void *p5,
 951 +  DEFINE_FUNC_ALIGNED6(int, __cdecl, av_probe_input_buffer, AVIOContext *, AVInputFormat **, const char *, void *, unsigned int, unsigned int)
 952 +  DEFINE_FUNC_ALIGNED3(int, __cdecl, avio_read, AVIOContext*, unsigned char *, int)
 953 +  DEFINE_FUNC_ALIGNED2(void, __cdecl, avio_w8, AVIOContext*, int)
 954 +  DEFINE_FUNC_ALIGNED3(void, __cdecl, avio_write, AVIOContext*, const unsigned char *, int)
 955 +  DEFINE_FUNC_ALIGNED2(void, __cdecl, avio_wb24, AVIOContext*, unsigned int)
 956 +  DEFINE_FUNC_ALIGNED2(void, __cdecl, avio_wb32, AVIOContext*, unsigned int)
 957 +  DEFINE_FUNC_ALIGNED2(void, __cdecl, avio_wb16, AVIOContext*, unsigned int)
 958 +  DEFINE_METHOD7(AVIOContext *, avio_alloc_context, (unsigned char *p1, int p2, int p3, void *p4,
 959 +                  int (*p5)(void *opaque, uint8_t *buf, int buf_size),
 960                    int (*p6)(void *opaque, uint8_t *buf, int buf_size),
 961 -                  int (*p7)(void *opaque, uint8_t *buf, int buf_size),
 962 -                  offset_t (*p8)(void *opaque, offset_t offset, int whence)))
 963 -  DEFINE_METHOD4(void, dump_format, (AVFormatContext *p1, int p2, const char *p3, int p4))
 964 -  DEFINE_METHOD2(int, url_fdopen, (ByteIOContext **p1, URLContext *p2))
 965 -  DEFINE_METHOD3(int, url_fopen, (ByteIOContext **p1, const char *p2, int p3))
 966 -  DEFINE_METHOD1(int, url_fclose, (ByteIOContext *p1))
 967 -  DEFINE_METHOD1(int, url_open_dyn_buf, (ByteIOContext **p1))
 968 -  DEFINE_METHOD2(int, url_close_dyn_buf, (ByteIOContext *p1, uint8_t **p2))
 969 -  DEFINE_METHOD3(offset_t, url_fseek, (ByteIOContext *p1, offset_t p2, int p3))
 970 +                  offset_t (*p7)(void *opaque, offset_t offset, int whence)))
 971 +  DEFINE_METHOD4(void, av_dump_format, (AVFormatContext *p1, int p2, const char *p3, int p4))
 972 +  DEFINE_METHOD3(int, avio_open, (AVIOContext **p1, const char *p2, int p3))
 973 +  DEFINE_METHOD1(int, avio_close, (AVIOContext *p1))
 974 +  DEFINE_METHOD1(int, avio_open_dyn_buf, (AVIOContext **p1))
 975 +  DEFINE_METHOD2(int, avio_close_dyn_buf, (AVIOContext *p1, uint8_t **p2))
 976 +  DEFINE_METHOD3(offset_t, avio_seek, (AVIOContext *p1, offset_t p2, int p3))
 977    DEFINE_METHOD0(AVFormatContext *, avformat_alloc_context)
 978 -  DEFINE_METHOD2(AVStream *, av_new_stream, (AVFormatContext *p1, int p2))
 979 -#if LIBAVFORMAT_VERSION_INT < (52<<16 | 45<<8)
 980 -  DEFINE_METHOD3(AVOutputFormat *, guess_format, (const char *p1, const char *p2, const char *p3))
 981 -#else
 982 +  DEFINE_METHOD2(AVStream *, avformat_new_stream, (AVFormatContext *p1, AVCodec *p2))
 983    DEFINE_METHOD3(AVOutputFormat *, av_guess_format, (const char *p1, const char *p2, const char *p3))
 984 -#endif
 985 -  DEFINE_METHOD2(int, av_set_parameters, (AVFormatContext *p1, AVFormatParameters *p2));
 986 -  DEFINE_METHOD7(ByteIOContext *, av_alloc_put_byte, (unsigned char *p1, int p2, int p3, void *p4,
 987 -                  int(*p5)(void *opaque, uint8_t *buf, int buf_size),
 988 -                  int(*p6)(void *opaque, uint8_t *buf, int buf_size),
 989 -                  offset_t(*p7)(void *opaque, offset_t offset, int whence)))
 990 -  DEFINE_METHOD1(int, av_write_header , (AVFormatContext *p1))
 991 +  DEFINE_METHOD2(int, avformat_write_header , (AVFormatContext *p1, AVDictionary **p2))
 992    DEFINE_METHOD1(int, av_write_trailer, (AVFormatContext *p1))
 993    DEFINE_METHOD2(int, av_write_frame  , (AVFormatContext *p1, AVPacket *p2))
 994 -  DEFINE_METHOD4(int, av_metadata_set2, (AVMetadata **p1, const char *p2, const char *p3, int p4));
 995    BEGIN_METHOD_RESOLVE()
 996      RESOLVE_METHOD_RENAME(av_register_all, av_register_all_dont_call)
 997      RESOLVE_METHOD(av_find_input_format)
 998      RESOLVE_METHOD(url_feof)
 999 -    RESOLVE_METHOD(av_metadata_get)
1000 -    RESOLVE_METHOD(av_close_input_file)
1001 -    RESOLVE_METHOD(av_close_input_stream)
1002 +    RESOLVE_METHOD(avformat_close_input)
1003      RESOLVE_METHOD(av_read_frame)
1004      RESOLVE_METHOD(av_read_play)
1005      RESOLVE_METHOD(av_read_pause)
1006 -    RESOLVE_METHOD_RENAME(ff_read_frame_flush, av_read_frame_flush)
1007 +    RESOLVE_METHOD(av_read_frame_flush)
1008      RESOLVE_METHOD(av_seek_frame)
1009 -    RESOLVE_METHOD_RENAME(av_find_stream_info, av_find_stream_info_dont_call)
1010 -    RESOLVE_METHOD(av_open_input_file)
1011 -    RESOLVE_METHOD(url_set_interrupt_cb)
1012 -    RESOLVE_METHOD(av_open_input_stream)
1013 -    RESOLVE_METHOD(init_put_byte)
1014 +    RESOLVE_METHOD_RENAME(avformat_find_stream_info, avformat_find_stream_info_dont_call)
1015 +    RESOLVE_METHOD(avformat_open_input)
1016 +    RESOLVE_METHOD(avio_alloc_context)
1017      RESOLVE_METHOD(av_probe_input_format)
1018      RESOLVE_METHOD(av_probe_input_format2)
1019      RESOLVE_METHOD(av_probe_input_buffer)
1020 -    RESOLVE_METHOD(dump_format)
1021 -    RESOLVE_METHOD(url_fdopen)
1022 -    RESOLVE_METHOD(url_fopen)
1023 -    RESOLVE_METHOD(url_fclose)
1024 -    RESOLVE_METHOD(url_open_dyn_buf)
1025 -    RESOLVE_METHOD(url_close_dyn_buf)
1026 -    RESOLVE_METHOD(url_fseek)
1027 -    RESOLVE_METHOD(get_buffer)
1028 -    RESOLVE_METHOD(get_partial_buffer)
1029 -    RESOLVE_METHOD(put_byte)
1030 -    RESOLVE_METHOD(put_buffer)
1031 -    RESOLVE_METHOD(put_be24)
1032 -    RESOLVE_METHOD(put_be32)
1033 -    RESOLVE_METHOD(put_be16)
1034 +    RESOLVE_METHOD(av_dump_format)
1035 +    RESOLVE_METHOD(avio_open)
1036 +    RESOLVE_METHOD(avio_close)
1037 +    RESOLVE_METHOD(avio_open_dyn_buf)
1038 +    RESOLVE_METHOD(avio_close_dyn_buf)
1039 +    RESOLVE_METHOD(avio_seek)
1040 +    RESOLVE_METHOD(avio_read)
1041 +    RESOLVE_METHOD(avio_w8)
1042 +    RESOLVE_METHOD(avio_write)
1043 +    RESOLVE_METHOD(avio_wb24)
1044 +    RESOLVE_METHOD(avio_wb32)
1045 +    RESOLVE_METHOD(avio_wb16)
1046      RESOLVE_METHOD(avformat_alloc_context)
1047 -    RESOLVE_METHOD(av_new_stream)
1048 -#if LIBAVFORMAT_VERSION_INT < (52<<16 | 45<<8)
1049 -    RESOLVE_METHOD(guess_format)
1050 -#else
1051 +    RESOLVE_METHOD(avformat_new_stream)
1052      RESOLVE_METHOD(av_guess_format)
1053 -#endif
1054 -    RESOLVE_METHOD(av_set_parameters)
1055 -    RESOLVE_METHOD(av_alloc_put_byte)
1056 -    RESOLVE_METHOD(av_write_header)
1057 +    RESOLVE_METHOD(avformat_write_header)
1058      RESOLVE_METHOD(av_write_trailer)
1059      RESOLVE_METHOD(av_write_frame)
1060 -    RESOLVE_METHOD(av_metadata_set2)
1061    END_METHOD_RESOLVE()
1062
1063    /* dependencies of libavformat */
1064    DllAvCodec m_dllAvCodec;
1065 -  // DllAvCore loaded implicitely by m_dllAvCodec
1066    // DllAvUtil loaded implicitely by m_dllAvCodec
1067
1068  public:
1069 @@ -328,10 +253,10 @@
1070      CSingleLock lock(DllAvCodec::m_critSection);
1071      av_register_all_dont_call();
1072    }
1073 -  int av_find_stream_info(AVFormatContext *ic)
1074 +  int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
1075    {
1076      CSingleLock lock(DllAvCodec::m_critSection);
1077 -    return(av_find_stream_info_dont_call(ic));
1078 +    return avformat_find_stream_info_dont_call(ic, options);
1079    }
1080
1081    virtual bool Load()
1082 diff -urN xbmc-11.0/lib/DllAvUtil.h xbmc-11.0-ffmpeg-1.0/lib/DllAvUtil.h
1083 --- xbmc-11.0/lib/DllAvUtil.h   2012-03-21 23:07:50.000000000 +0100
1084 +++ xbmc-11.0-ffmpeg-1.0/lib/DllAvUtil.h        2012-11-08 23:16:18.536405054 +0100
1085 @@ -65,6 +65,7 @@
1086    #include "libavutil/opt.h"
1087    #include "libavutil/mem.h"
1088    #include "libavutil/fifo.h"
1089 +  #include "libavutil/samplefmt.h"
1090  #endif
1091  }
1092
1093 @@ -89,7 +90,7 @@
1094    virtual int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)=0;
1095    virtual const AVCRC* av_crc_get_table(AVCRCId crc_id)=0;
1096    virtual uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)=0;
1097 -  virtual int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)=0;
1098 +  virtual int av_opt_set(void *obj, const char *name, const char *val, int search_flags)=0;
1099    virtual AVFifoBuffer *av_fifo_alloc(unsigned int size) = 0;
1100    virtual void av_fifo_free(AVFifoBuffer *f) = 0;
1101    virtual void av_fifo_reset(AVFifoBuffer *f) = 0;
1102 @@ -97,6 +98,11 @@
1103    virtual int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int)) = 0;
1104    virtual int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int)) = 0;
1105    virtual char *av_strdup(const char *s)=0;
1106 +  virtual int av_get_bytes_per_sample(enum AVSampleFormat p1) = 0;
1107 +  virtual AVDictionaryEntry *av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags) = 0;
1108 +  virtual int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)=0;
1109 +  virtual int av_samples_get_buffer_size (int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align) = 0;
1110 +  virtual int64_t av_get_default_channel_layout(int nb_channels)=0;
1111  };
1112
1113  #if (defined USE_EXTERNAL_FFMPEG)
1114 @@ -117,12 +123,7 @@
1115     virtual int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) { return ::av_rescale_q(a, bq, cq); }
1116     virtual const AVCRC* av_crc_get_table(AVCRCId crc_id) { return ::av_crc_get_table(crc_id); }
1117     virtual uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length) { return ::av_crc(ctx, crc, buffer, length); }
1118 -#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52,7,0)
1119 -   // API added on: 2008-12-16
1120 -   virtual int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out) { return ::av_set_string3(obj, name, val, alloc, o_out); }
1121 -#else
1122 -   virtual int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out) { return AVERROR(ENOENT); }
1123 -#endif
1124 +   virtual int av_opt_set(void *obj, const char *name, const char *val, int search_flags) { return ::av_opt_set(obj, name, val, search_flags); }
1125    virtual AVFifoBuffer *av_fifo_alloc(unsigned int size) {return ::av_fifo_alloc(size); }
1126    virtual void av_fifo_free(AVFifoBuffer *f) { ::av_fifo_free(f); }
1127    virtual void av_fifo_reset(AVFifoBuffer *f) { ::av_fifo_reset(f); }
1128 @@ -132,6 +133,13 @@
1129    virtual int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int))
1130      { return ::av_fifo_generic_write(f, src, size, func); }
1131    virtual char *av_strdup(const char *s) { return ::av_strdup(s); }
1132 +  virtual int av_get_bytes_per_sample(enum AVSampleFormat p1)
1133 +    { return ::av_get_bytes_per_sample(p1); }
1134 +  virtual AVDictionaryEntry *av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags){ return ::av_dict_get(m, key, prev, flags); }
1135 +  virtual int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags) { return ::av_dict_set(pm, key, value, flags); }
1136 +  virtual int av_samples_get_buffer_size (int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
1137 +    { return ::av_samples_get_buffer_size(linesize, nb_channels, nb_samples, sample_fmt, align); }
1138 +  virtual int64_t av_get_default_channel_layout(int nb_channels) { return ::av_get_default_channel_layout(nb_channels); }
1139
1140     // DLL faking.
1141     virtual bool ResolveExports() { return true; }
1142 @@ -160,7 +168,7 @@
1143    DEFINE_METHOD3(int64_t, av_rescale_q, (int64_t p1, AVRational p2, AVRational p3));
1144    DEFINE_METHOD1(const AVCRC*, av_crc_get_table, (AVCRCId p1))
1145    DEFINE_METHOD4(uint32_t, av_crc, (const AVCRC *p1, uint32_t p2, const uint8_t *p3, size_t p4));
1146 -  DEFINE_METHOD5(int, av_set_string3, (void *p1, const char *p2, const char *p3, int p4, const AVOption **p5));
1147 +  DEFINE_METHOD4(int, av_opt_set, (void *p1, const char *p2, const char *p3, int p4));
1148    DEFINE_METHOD1(AVFifoBuffer*, av_fifo_alloc, (unsigned int p1))
1149    DEFINE_METHOD1(void, av_fifo_free, (AVFifoBuffer *p1))
1150    DEFINE_METHOD1(void, av_fifo_reset, (AVFifoBuffer *p1))
1151 @@ -168,6 +176,11 @@
1152    DEFINE_METHOD4(int, av_fifo_generic_read, (AVFifoBuffer *p1, void *p2, int p3, void (*p4)(void*, void*, int)))
1153    DEFINE_METHOD4(int, av_fifo_generic_write, (AVFifoBuffer *p1, void *p2, int p3, int (*p4)(void*, void*, int)))
1154    DEFINE_METHOD1(char*, av_strdup, (const char *p1))
1155 +  DEFINE_METHOD1(int, av_get_bytes_per_sample, (enum AVSampleFormat p1))
1156 +  DEFINE_METHOD4(AVDictionaryEntry *, av_dict_get, (AVDictionary *p1, const char *p2, const AVDictionaryEntry *p3, int p4))
1157 +  DEFINE_METHOD4(int, av_dict_set, (AVDictionary **p1, const char *p2, const char *p3, int p4));
1158 +  DEFINE_METHOD5(int, av_samples_get_buffer_size, (int *p1, int p2, int p3, enum AVSampleFormat p4, int p5))
1159 +  DEFINE_METHOD1(int64_t, av_get_default_channel_layout, (int p1))
1160
1161    public:
1162    BEGIN_METHOD_RESOLVE()
1163 @@ -181,7 +194,7 @@
1164      RESOLVE_METHOD(av_rescale_q)
1165      RESOLVE_METHOD(av_crc_get_table)
1166      RESOLVE_METHOD(av_crc)
1167 -    RESOLVE_METHOD(av_set_string3)
1168 +    RESOLVE_METHOD(av_opt_set)
1169      RESOLVE_METHOD(av_fifo_alloc)
1170      RESOLVE_METHOD(av_fifo_free)
1171      RESOLVE_METHOD(av_fifo_reset)
1172 @@ -189,6 +202,11 @@
1173      RESOLVE_METHOD(av_fifo_generic_read)
1174      RESOLVE_METHOD(av_fifo_generic_write)
1175      RESOLVE_METHOD(av_strdup)
1176 +    RESOLVE_METHOD(av_get_bytes_per_sample)
1177 +    RESOLVE_METHOD(av_dict_get)
1178 +    RESOLVE_METHOD(av_dict_set)
1179 +    RESOLVE_METHOD(av_samples_get_buffer_size)
1180 +    RESOLVE_METHOD(av_get_default_channel_layout)
1181    END_METHOD_RESOLVE()
1182  };
1183
1184 diff -urN xbmc-11.0/lib/DllSwResample.h xbmc-11.0-ffmpeg-1.0/lib/DllSwResample.h
1185 --- xbmc-11.0/lib/DllSwResample.h       1970-01-01 01:00:00.000000000 +0100
1186 +++ xbmc-11.0-ffmpeg-1.0/lib/DllSwResample.h    2012-11-08 23:15:55.399739205 +0100
1187 @@ -0,0 +1,87 @@
1188 +#pragma once
1189 +/*
1190 + *      Copyright (C) 2005-2010 Team XBMC
1191 + *      http://www.xbmc.org
1192 + *
1193 + *  This Program is free software; you can redistribute it and/or modify
1194 + *  it under the terms of the GNU General Public License as published by
1195 + *  the Free Software Foundation; either version 2, or (at your option)
1196 + *  any later version.
1197 + *
1198 + *  This Program is distributed in the hope that it will be useful,
1199 + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
1200 + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1201 + *  GNU General Public License for more details.
1202 + *
1203 + *  You should have received a copy of the GNU General Public License
1204 + *  along with XBMC; see the file COPYING.  If not, write to
1205 + *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
1206 + *  http://www.gnu.org/copyleft/gpl.html
1207 + *
1208 + */
1209 +
1210 +#if (defined HAVE_CONFIG_H) && (!defined WIN32)
1211 +  #include "config.h"
1212 +#endif
1213 +#include "DynamicDll.h"
1214 +
1215 +extern "C" {
1216 +#ifndef HAVE_MMX
1217 +#define HAVE_MMX
1218 +#endif
1219 +#ifndef __STDC_CONSTANT_MACROS
1220 +#define __STDC_CONSTANT_MACROS
1221 +#endif
1222 +#ifndef __GNUC__
1223 +#pragma warning(disable:4244)
1224 +#endif
1225 +#if (defined USE_EXTERNAL_FFMPEG)
1226 +  #include <libswresample/swresample.h>
1227 +#else
1228 +  #include "libswresample/swresample.h"
1229 +#endif
1230 +}
1231 +
1232 +
1233 +#if (defined USE_EXTERNAL_FFMPEG)
1234 +
1235 +// Use direct mapping
1236 +class DllSwResample : public DllDynamic
1237 +{
1238 +public:
1239 +  virtual ~DllSwResample() {}
1240 +
1241 +  // DLL faking.
1242 +  virtual bool ResolveExports() { return true; }
1243 +  virtual bool Load() {
1244 +    CLog::Log(LOGDEBUG, "DllAvFormat: Using libswresample system library");
1245 +    return true;
1246 +  }
1247 +  virtual void Unload() {}
1248 +};
1249 +
1250 +#else
1251 +
1252 +class DllSwResample : public DllDynamic
1253 +{
1254 +  DECLARE_DLL_WRAPPER(DllSwResample, DLL_PATH_LIBSWRESAMPLE)
1255 +
1256 +  LOAD_SYMBOLS()
1257 +
1258 +  BEGIN_METHOD_RESOLVE()
1259 +  END_METHOD_RESOLVE()
1260 +
1261 +  /* dependencies of libavformat */
1262 +  DllAvUtil m_dllAvUtil;
1263 +
1264 +public:
1265 +
1266 +  virtual bool Load()
1267 +  {
1268 +    if (!m_dllAvUtil.Load())
1269 +      return false;
1270 +    return DllDynamic::Load();
1271 +  }
1272 +};
1273 +
1274 +#endif
1275 diff -urN xbmc-11.0/lib/Makefile.in xbmc-11.0-ffmpeg-1.0/lib/Makefile.in
1276 --- xbmc-11.0/lib/Makefile.in   2012-03-21 23:07:50.000000000 +0100
1277 +++ xbmc-11.0-ffmpeg-1.0/lib/Makefile.in        2012-11-08 23:15:55.399739205 +0100
1278 @@ -17,6 +17,14 @@
1279  WRAPPER=@abs_top_srcdir@/xbmc/cores/DllLoader/exports/wrapper.o
1280  WRAPPER_MACH_ALIAS=@abs_top_srcdir@/xbmc/cores/DllLoader/exports/wrapper_mach_alias
1281
1282 +AVFORMAT_SO=avformat-53-$(ARCH).so
1283 +AVCODEC_SO=avcodec-53-$(ARCH).so
1284 +AVUTIL_SO=avutil-51-$(ARCH).so
1285 +AVFILTER_SO=avfilter-2-$(ARCH).so
1286 +SWSCALE_SO=swscale-2-$(ARCH).so
1287 +POSTPROC_SO=postproc-52-$(ARCH).so
1288 +SWRESAMPLE_SO=swresample-0-$(ARCH).so
1289 +
1290  DIRS=
1291  ifneq (@USE_EXTERNAL_FFMPEG@,1)
1292    DIRS+=ffmpeg
1293 @@ -24,13 +32,13 @@
1294
1295  LIBS=
1296  ifneq (@USE_EXTERNAL_FFMPEG@,1)
1297 -  LIBS+=avutil-50-$(ARCH).so \
1298 -       avcodec-52-$(ARCH).so \
1299 -       avcore-0-$(ARCH).so \
1300 -       avformat-52-$(ARCH).so \
1301 -       postproc-51-$(ARCH).so \
1302 -       avfilter-1-$(ARCH).so \
1303 -       swscale-0-$(ARCH).so
1304 +  LIBS+=$(AVUTIL_SO) \
1305 +       $(AVCODEC_SO) \
1306 +       $(AVFORMAT_SO) \
1307 +       $(POSTPROC_SO) \
1308 +       $(AVFILTER_SO) \
1309 +       $(SWSCALE_SO) \
1310 +       $(SWRESAMPLE_SO)
1311  endif
1312
1313  ifneq (,$(findstring powerpc,$(ARCH)))
1314 @@ -54,90 +62,90 @@
1315  BUNDLE1_O = -lbundle1.o
1316  endif
1317
1318 -$(SYSDIR)/avutil-50-$(ARCH).so: $(WRAPPER) ffmpeg/libavutil/libavutil.dylib
1319 +$(SYSDIR)/$(AVUTIL_SO): $(WRAPPER) ffmpeg/libavutil/libavutil.dylib
1320         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS) -o $@ \
1321                 $(WRAPPER) ffmpeg/libavutil/*.o \
1322                 ffmpeg/libavutil/$(ARCH_DIR)/*.o $(BUNDLE1_O)
1323
1324 -$(SYSDIR)/avcodec-52-$(ARCH).so: $(WRAPPER) ffmpeg/libavcodec/libavcodec.dylib
1325 +$(SYSDIR)/$(AVCODEC_SO): $(WRAPPER) ffmpeg/libavcodec/libavcodec.dylib
1326         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS) -o $@ \
1327                 $(WRAPPER) ffmpeg/libavcodec/*.o \
1328                 ffmpeg/libavcodec/$(ARCH_DIR)/*.o $(BUNDLE1_O)
1329
1330 -$(SYSDIR)/avcore-0-$(ARCH).so: $(WRAPPER) ffmpeg/libavcore/libavcore.dylib
1331 -       $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1332 -               $(WRAPPER) ffmpeg/libavcore/*.o $(BUNDLE1_O)
1333 -
1334 -$(SYSDIR)/avformat-52-$(ARCH).so: $(WRAPPER) ffmpeg/libavformat/libavformat.dylib
1335 +$(SYSDIR)/$(AVFORMAT_SO): $(WRAPPER) ffmpeg/libavformat/libavformat.dylib
1336         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1337                 $(WRAPPER) ffmpeg/libavformat/*.o $(BUNDLE1_O)
1338
1339  ifeq ($(findstring x86,$(ARCH_DIR)), x86)
1340 -$(SYSDIR)/avfilter-1-$(ARCH).so: $(WRAPPER) ffmpeg/libavfilter/libavfilter.dylib
1341 +$(SYSDIR)/$(AVFILTER_SO): $(WRAPPER) ffmpeg/libavfilter/libavfilter.dylib
1342         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1343                 $(WRAPPER) ffmpeg/libavfilter/$(ARCH_DIR)/*.o \
1344                 ffmpeg/libavfilter/*.o $(BUNDLE1_O)
1345  else # No libavfilter/ppc or libavfilter/arm
1346 -$(SYSDIR)/avfilter-1-$(ARCH).so: $(WRAPPER) ffmpeg/libavfilter/libavfilter.dylib
1347 +$(SYSDIR)/$(AVFILTER_SO): $(WRAPPER) ffmpeg/libavfilter/libavfilter.dylib
1348         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1349                 $(WRAPPER) ffmpeg/libavfilter/*.o $(BUNDLE1_O)
1350  endif
1351
1352  ifneq ($(findstring arm,$(ARCH)), arm)
1353 -$(SYSDIR)/swscale-0-$(ARCH).so: $(WRAPPER) ffmpeg/libswscale/libswscale.dylib
1354 +$(SYSDIR)/$(SWSCALE_SO): $(WRAPPER) ffmpeg/libswscale/libswscale.dylib
1355         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1356                 $(WRAPPER) ffmpeg/libswscale/*.o \
1357                 ffmpeg/libswscale/$(ARCH_DIR)/*.o $(BUNDLE1_O)
1358  else # No ARM version of swscale available yet.
1359 -$(SYSDIR)/swscale-0-$(ARCH).so: $(WRAPPER) ffmpeg/libswscale/libswscale.dylib
1360 +$(SYSDIR)/$(SWSCALE_SO): $(WRAPPER) ffmpeg/libswscale/libswscale.dylib
1361         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1362                 $(WRAPPER) ffmpeg/libswscale/*.o
1363  endif
1364
1365 -$(SYSDIR)/postproc-51-$(ARCH).so: $(WRAPPER) ffmpeg/libpostproc/libpostproc.dylib
1366 +$(SYSDIR)/$(POSTPROC_SO): $(WRAPPER) ffmpeg/libpostproc/libpostproc.dylib
1367         $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1368                 $(WRAPPER) ffmpeg/libpostproc/*.o $(BUNDLE1_O)
1369
1370 +$(SYSDIR)/$(SWRESAMPLE_SO): $(WRAPPER) ffmpeg/libswresample/libswresample.dylib
1371 +       $(LD) $(LDFLAGS) -alias_list $(WRAPPER_MACH_ALIAS)  -o $@ \
1372 +               $(WRAPPER) ffmpeg/libswresample/*.o $(BUNDLE1_O)
1373 +
1374  ffmpeg/libavutil/libavutil.dylib     : ffmpeg;
1375  ffmpeg/libavcodec/libavcodec.dylib   : ffmpeg;
1376 -ffmpeg/libavcore/libavcore.dylib     : ffmpeg;
1377  ffmpeg/libavformat/libavformat.dylib : ffmpeg;
1378  ffmpeg/libavformat/libavfilter.dylib : ffmpeg;
1379  ffmpeg/libswscale/libswscale.dylib   : ffmpeg;
1380  ffmpeg/libpostproc/libpostproc.dylib : ffmpeg;
1381 +ffmpeg/libswresample/libswresample.dylib : ffmpeg;
1382  ffmpeg:
1383         $(MAKE) -C $@
1384
1385  else
1386
1387 -$(SYSDIR)/avutil-50-$(ARCH).so: ffmpeg/libavutil/libavutil.so
1388 +$(SYSDIR)/$(AVUTIL_SO): ffmpeg/libavutil/libavutil.so
1389         cp ffmpeg/libavutil/libavutil.so $@
1390
1391 -$(SYSDIR)/avcodec-52-$(ARCH).so: $(WRAPPER) ffmpeg/libavcodec/libavcodec.so
1392 +$(SYSDIR)/$(AVCODEC_SO): $(WRAPPER) ffmpeg/libavcodec/libavcodec.so
1393         cp ffmpeg/libavcodec/libavcodec.so $@
1394
1395 -$(SYSDIR)/avcore-0-$(ARCH).so: $(WRAPPER) ffmpeg/libavcore/libavcore.so
1396 -       cp ffmpeg/libavcore/libavcore.so $@
1397 -
1398 -$(SYSDIR)/avformat-52-$(ARCH).so: $(WRAPPER) ffmpeg/libavformat/libavformat.so
1399 +$(SYSDIR)/$(AVFORMAT_SO): $(WRAPPER) ffmpeg/libavformat/libavformat.so
1400         cp ffmpeg/libavformat/libavformat.so $@
1401
1402 -$(SYSDIR)/avfilter-1-$(ARCH).so: $(WRAPPER) ffmpeg/libavfilter/libavfilter.so
1403 +$(SYSDIR)/$(AVFILTER_SO): $(WRAPPER) ffmpeg/libavfilter/libavfilter.so
1404         cp ffmpeg/libavfilter/libavfilter.so $@
1405
1406 -$(SYSDIR)/swscale-0-$(ARCH).so: $(WRAPPER) ffmpeg/libswscale/libswscale.so
1407 +$(SYSDIR)/$(SWSCALE_SO): $(WRAPPER) ffmpeg/libswscale/libswscale.so
1408         cp ffmpeg/libswscale/libswscale.so $@
1409
1410 -$(SYSDIR)/postproc-51-$(ARCH).so: $(WRAPPER) ffmpeg/libpostproc/libpostproc.so
1411 +$(SYSDIR)/$(POSTPROC_SO): $(WRAPPER) ffmpeg/libpostproc/libpostproc.so
1412         cp ffmpeg/libpostproc/libpostproc.so $@
1413
1414 +$(SYSDIR)/$(SWRESAMPLE_SO): $(WRAPPER) ffmpeg/libswresample/libswresample.so
1415 +       cp ffmpeg/libswresample/libswresample.so $@
1416 +
1417  ffmpeg/libavutil/libavutil.so     : ffmpeg;
1418  ffmpeg/libavcodec/libavcodec.so   : ffmpeg;
1419 -ffmpeg/libavcore/libavcore.so     : ffmpeg;
1420  ffmpeg/libavformat/libavformat.so : ffmpeg;
1421  ffmpeg/libavfilter/libavfilter.so : ffmpeg;
1422  ffmpeg/libswscale/libswscale.so   : ffmpeg;
1423  ffmpeg/libpostproc/libpostproc.so : ffmpeg;
1424 +ffmpeg/libswresample/libswresample.so : ffmpeg;
1425  ffmpeg:
1426         $(MAKE) -C $@
1427
1428 diff -urN xbmc-11.0/lib/xbmc-dll-symbols/DllAvFormat.c xbmc-11.0-ffmpeg-1.0/lib/xbmc-dll-symbols/DllAvFormat.c
1429 --- xbmc-11.0/lib/xbmc-dll-symbols/DllAvFormat.c        2012-03-21 23:07:50.000000000 +0100
1430 +++ xbmc-11.0-ffmpeg-1.0/lib/xbmc-dll-symbols/DllAvFormat.c     2012-11-08 23:15:47.383072821 +0100
1431 @@ -28,6 +28,7 @@
1432  #include <libavformat/avformat.h>
1433
1434  /* Taken from libavformat/utils.c */
1435 +#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(54,0,0)
1436  static void flush_packet_queue(AVFormatContext *s)
1437  {
1438      AVPacketList *pktl;
1439 @@ -53,6 +54,27 @@
1440      s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1441  #endif
1442  }
1443 +#else
1444 +static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1445 +{
1446 +    while (*pkt_buf) {
1447 +        AVPacketList *pktl = *pkt_buf;
1448 +        *pkt_buf = pktl->next;
1449 +        av_free_packet(&pktl->pkt);
1450 +        av_freep(&pktl);
1451 +    }
1452 +    *pkt_buf_end = NULL;
1453 +}
1454 +/* XXX: suppress the packet queue */
1455 +static void flush_packet_queue(AVFormatContext *s)
1456 +{
1457 +    free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1458 +    free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1459 +    free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1460 +
1461 +    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1462 +}
1463 +#endif
1464
1465  /* Taken from libavformat/utils.c */
1466  void av_read_frame_flush(AVFormatContext *s)
1467 @@ -62,7 +84,9 @@
1468
1469      flush_packet_queue(s);
1470
1471 +#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(54,0,0)
1472      s->cur_st = NULL;
1473 +#endif
1474
1475      /* for each stream, reset read state */
1476      for(i = 0; i < s->nb_streams; i++) {
1477 @@ -71,14 +95,25 @@
1478          if (st->parser) {
1479              av_parser_close(st->parser);
1480              st->parser = NULL;
1481 +#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(54,0,0)
1482              av_free_packet(&st->cur_pkt);
1483 +#endif
1484          }
1485          st->last_IP_pts = AV_NOPTS_VALUE;
1486 +#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(54,0,0)
1487          st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1488          st->reference_dts = AV_NOPTS_VALUE;
1489          /* fail safe */
1490          st->cur_ptr = NULL;
1491          st->cur_len = 0;
1492 +#else
1493 +#define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
1494 +        if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1495 +        else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1496 +        st->reference_dts = AV_NOPTS_VALUE;
1497 +
1498 +        st->probe_packets = MAX_PROBE_PACKETS;
1499 +#endif
1500
1501          for(j=0; j<MAX_REORDER_DELAY+1; j++)
1502              st->pts_buffer[j]= AV_NOPTS_VALUE;
1503 diff -urN xbmc-11.0/xbmc/cdrip/EncoderFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cdrip/EncoderFFmpeg.cpp
1504 --- xbmc-11.0/xbmc/cdrip/EncoderFFmpeg.cpp      2012-03-21 23:07:50.000000000 +0100
1505 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cdrip/EncoderFFmpeg.cpp   2012-11-08 23:16:18.536405054 +0100
1506 @@ -59,11 +59,7 @@
1507
1508    CStdString filename = URIUtils::GetFileName(strFile);
1509    AVOutputFormat *fmt = NULL;
1510 -#if LIBAVFORMAT_VERSION_MAJOR < 52
1511 -  fmt = m_dllAvFormat.guess_format(NULL, filename.c_str(), NULL);
1512 -#else
1513    fmt = m_dllAvFormat.av_guess_format(NULL, filename.c_str(), NULL);
1514 -#endif
1515    if (!fmt)
1516    {
1517      CLog::Log(LOGERROR, "CEncoderFFmpeg::Init - Unable to guess the output format for the file %s", filename.c_str());
1518 @@ -82,7 +78,7 @@
1519    }
1520
1521    m_Format     = m_dllAvFormat.avformat_alloc_context();
1522 -  m_Format->pb = m_dllAvFormat.av_alloc_put_byte(m_BCBuffer, sizeof(m_BCBuffer), URL_RDONLY, this,  NULL, MuxerReadPacket, NULL);
1523 +  m_Format->pb = m_dllAvFormat.avio_alloc_context(m_BCBuffer, sizeof(m_BCBuffer), AVIO_FLAG_READ, this,  NULL, MuxerReadPacket, NULL);
1524    if (!m_Format->pb)
1525    {
1526      m_dllAvUtil.av_freep(&m_Format);
1527 @@ -93,17 +89,8 @@
1528    m_Format->oformat  = fmt;
1529    m_Format->bit_rate = g_guiSettings.GetInt("audiocds.bitrate") * 1000;
1530
1531 -  /* setup the muxer */
1532 -  if (m_dllAvFormat.av_set_parameters(m_Format, NULL) != 0)
1533 -  {
1534 -    m_dllAvUtil.av_freep(&m_Format->pb);
1535 -    m_dllAvUtil.av_freep(&m_Format);
1536 -    CLog::Log(LOGERROR, "CEncoderFFmpeg::Init - Failed to set the muxer parameters");
1537 -    return false;
1538 -  }
1539 -
1540    /* add a stream to it */
1541 -  m_Stream = m_dllAvFormat.av_new_stream(m_Format, 1);
1542 +  m_Stream = m_dllAvFormat.avformat_new_stream(m_Format, codec);
1543    if (!m_Stream)
1544    {
1545      m_dllAvUtil.av_freep(&m_Format->pb);
1546 @@ -119,7 +106,7 @@
1547    m_CodecCtx->bit_rate       = m_Format->bit_rate;
1548    m_CodecCtx->sample_rate    = iInRate;
1549    m_CodecCtx->channels       = iInChannels;
1550 -  m_CodecCtx->channel_layout = m_dllAvCodec.avcodec_guess_channel_layout(iInChannels, codec->id, NULL);
1551 +  m_CodecCtx->channel_layout = m_dllAvUtil.av_get_default_channel_layout(iInChannels);
1552    m_CodecCtx->time_base      = (AVRational){1, iInRate};
1553
1554    if(fmt->flags & AVFMT_GLOBALHEADER)
1555 @@ -144,7 +131,7 @@
1556        return false;
1557    }
1558
1559 -  if (m_dllAvCodec.avcodec_open(m_CodecCtx, codec))
1560 +  if (m_dllAvCodec.avcodec_open2(m_CodecCtx, codec, NULL))
1561    {
1562      CLog::Log(LOGERROR, "CEncoderFFmpeg::Init - Failed to open the codec");
1563      m_dllAvUtil.av_freep(&m_Stream);
1564 @@ -179,7 +166,7 @@
1565    SetTag("encoder"     , "XBMC FFmpeg Encoder");
1566
1567    /* write the header */
1568 -  if (m_dllAvFormat.av_write_header(m_Format) != 0)
1569 +  if (m_dllAvFormat.avformat_write_header(m_Format, NULL) != 0)
1570    {
1571      CLog::Log(LOGERROR, "CEncoderFFmpeg::Init - Failed to write the header");
1572      delete[] m_Buffer;
1573 @@ -194,7 +181,7 @@
1574
1575  void CEncoderFFmpeg::SetTag(const CStdString tag, const CStdString value)
1576  {
1577 -  m_dllAvFormat.av_metadata_set2(&m_Format->metadata, tag.c_str(), value.c_str(), 0);
1578 +  m_dllAvUtil.av_dict_set(&m_Format->metadata, tag.c_str(), value.c_str(), 0);
1579  }
1580
1581  int CEncoderFFmpeg::MuxerReadPacket(void *opaque, uint8_t *buf, int buf_size)
1582 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.cpp
1583 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.cpp      2012-03-21 23:07:50.000000000 +0100
1584 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.cpp   2012-11-08 23:16:18.536405054 +0100
1585 @@ -29,10 +29,6 @@
1586
1587  CDVDAudioCodecFFmpeg::CDVDAudioCodecFFmpeg() : CDVDAudioCodec()
1588  {
1589 -  m_iBufferSize1 = 0;
1590 -  m_pBuffer1     = (BYTE*)_aligned_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE, 16);
1591 -  memset(m_pBuffer1, 0, AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
1592 -
1593    m_iBufferSize2 = 0;
1594    m_pBuffer2     = (BYTE*)_aligned_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE, 16);
1595    memset(m_pBuffer2, 0, AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
1596 @@ -45,11 +41,11 @@
1597    m_channelMap[0] = PCM_INVALID;
1598    m_channels = 0;
1599    m_layout = 0;
1600 +  m_pFrame1 = NULL;
1601  }
1602
1603  CDVDAudioCodecFFmpeg::~CDVDAudioCodecFFmpeg()
1604  {
1605 -  _aligned_free(m_pBuffer1);
1606    _aligned_free(m_pBuffer2);
1607    Dispose();
1608  }
1609 @@ -59,12 +55,10 @@
1610    AVCodec* pCodec;
1611    m_bOpenedCodec = false;
1612
1613 -  if (!m_dllAvCore.Load() || !m_dllAvUtil.Load() || !m_dllAvCodec.Load())
1614 +  if (!m_dllAvUtil.Load() || !m_dllAvCodec.Load())
1615      return false;
1616
1617    m_dllAvCodec.avcodec_register_all();
1618 -  m_pCodecContext = m_dllAvCodec.avcodec_alloc_context();
1619 -  m_dllAvCodec.avcodec_get_context_defaults(m_pCodecContext);
1620
1621    pCodec = m_dllAvCodec.avcodec_find_decoder(hints.codec);
1622    if (!pCodec)
1623 @@ -73,6 +67,7 @@
1624      return false;
1625    }
1626
1627 +  m_pCodecContext = m_dllAvCodec.avcodec_alloc_context3(pCodec);
1628    m_pCodecContext->debug_mv = 0;
1629    m_pCodecContext->debug = 0;
1630    m_pCodecContext->workaround_bugs = 1;
1631 @@ -97,13 +92,14 @@
1632      memcpy(m_pCodecContext->extradata, hints.extradata, hints.extrasize);
1633    }
1634
1635 -  if (m_dllAvCodec.avcodec_open(m_pCodecContext, pCodec) < 0)
1636 +  if (m_dllAvCodec.avcodec_open2(m_pCodecContext, pCodec, NULL) < 0)
1637    {
1638      CLog::Log(LOGDEBUG,"CDVDAudioCodecFFmpeg::Open() Unable to open codec");
1639      Dispose();
1640      return false;
1641    }
1642
1643 +  m_pFrame1 = m_dllAvCodec.avcodec_alloc_frame();
1644    m_bOpenedCodec = true;
1645    m_iSampleFormat = AV_SAMPLE_FMT_NONE;
1646    return true;
1647 @@ -111,6 +107,9 @@
1648
1649  void CDVDAudioCodecFFmpeg::Dispose()
1650  {
1651 +  if (m_pFrame1) m_dllAvUtil.av_free(m_pFrame1);
1652 +  m_pFrame1 = NULL;
1653 +
1654    if (m_pConvert)
1655    {
1656      m_dllAvCodec.av_audio_convert_free(m_pConvert);
1657 @@ -135,7 +134,7 @@
1658
1659  int CDVDAudioCodecFFmpeg::Decode(BYTE* pData, int iSize)
1660  {
1661 -  int iBytesUsed;
1662 +  int iBytesUsed, got_frame;
1663    if (!m_pCodecContext) return -1;
1664
1665    m_iBufferSize1 = AVCODEC_MAX_AUDIO_FRAME_SIZE ;
1666 @@ -145,10 +144,13 @@
1667    m_dllAvCodec.av_init_packet(&avpkt);
1668    avpkt.data = pData;
1669    avpkt.size = iSize;
1670 -  iBytesUsed = m_dllAvCodec.avcodec_decode_audio3( m_pCodecContext
1671 -                                                 , (int16_t*)m_pBuffer1
1672 -                                                 , &m_iBufferSize1
1673 +  iBytesUsed = m_dllAvCodec.avcodec_decode_audio4( m_pCodecContext
1674 +                                                 , m_pFrame1
1675 +                                                 , &got_frame
1676                                                   , &avpkt);
1677 +  if (iBytesUsed < 0 || !got_frame)
1678 +    return iBytesUsed;
1679 +  m_iBufferSize1 = m_dllAvUtil.av_samples_get_buffer_size(NULL, m_pCodecContext->channels, m_pFrame1->nb_samples, m_pCodecContext->sample_fmt, 1);
1680
1681    /* some codecs will attempt to consume more data than what we gave */
1682    if (iBytesUsed > iSize)
1683 @@ -184,9 +186,9 @@
1684        return iBytesUsed;
1685      }
1686
1687 -    const void *ibuf[6] = { m_pBuffer1 };
1688 +    const void *ibuf[6] = { m_pFrame1->data[0] };
1689      void       *obuf[6] = { m_pBuffer2 };
1690 -    int         istr[6] = { m_dllAvCore.av_get_bits_per_sample_fmt(m_pCodecContext->sample_fmt)/8 };
1691 +    int         istr[6] = { m_dllAvUtil.av_get_bytes_per_sample(m_pCodecContext->sample_fmt) };
1692      int         ostr[6] = { 2 };
1693      int         len     = m_iBufferSize1 / istr[0];
1694      if(m_dllAvCodec.av_audio_convert(m_pConvert, obuf, ostr, ibuf, istr, len) < 0)
1695 @@ -208,7 +210,7 @@
1696  {
1697    if(m_iBufferSize1)
1698    {
1699 -    *dst = m_pBuffer1;
1700 +    *dst = m_pFrame1->data[0];
1701      return m_iBufferSize1;
1702    }
1703    if(m_iBufferSize2)
1704 @@ -273,7 +275,7 @@
1705    else
1706    {
1707      CLog::Log(LOGINFO, "CDVDAudioCodecFFmpeg::GetChannelMap - FFmpeg reported %d channels, but the layout contains %d ignoring", m_pCodecContext->channels, bits);
1708 -    layout = m_dllAvCodec.avcodec_guess_channel_layout(m_pCodecContext->channels, m_pCodecContext->codec_id, NULL);
1709 +    layout = m_dllAvUtil.av_get_default_channel_layout(m_pCodecContext->channels);
1710    }
1711
1712    int index = 0;
1713 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.h xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.h
1714 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.h        2012-03-21 23:07:50.000000000 +0100
1715 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecFFmpeg.h     2012-11-08 23:16:03.529738917 +0100
1716 @@ -23,7 +23,6 @@
1717
1718  #include "DVDAudioCodec.h"
1719  #include "DllAvCodec.h"
1720 -#include "DllAvCore.h"
1721  #include "DllAvFormat.h"
1722  #include "DllAvUtil.h"
1723
1724 @@ -51,7 +50,7 @@
1725    enum AVSampleFormat m_iSampleFormat;
1726    enum PCMChannels m_channelMap[PCM_MAX_CH + 1];
1727
1728 -  BYTE *m_pBuffer1;
1729 +  AVFrame* m_pFrame1;
1730    int   m_iBufferSize1;
1731
1732    BYTE *m_pBuffer2;
1733 @@ -64,7 +63,6 @@
1734    int64_t m_layout;
1735
1736    DllAvCodec m_dllAvCodec;
1737 -  DllAvCore m_dllAvCore;
1738    DllAvUtil m_dllAvUtil;
1739
1740    void BuildChannelMap();
1741 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecPassthroughFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecPassthroughFFmpeg.cpp
1742 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecPassthroughFFmpeg.cpp   2012-03-21 23:07:50.000000000 +0100
1743 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/DVDAudioCodecPassthroughFFmpeg.cpp        2012-11-08 23:16:03.529738917 +0100
1744 @@ -79,11 +79,7 @@
1745    /* get the muxer */
1746    AVOutputFormat *fOut = NULL;
1747
1748 -#if LIBAVFORMAT_VERSION_MAJOR < 52
1749 -  fOut = m_dllAvFormat.guess_format(muxerName.c_str(), NULL, NULL);
1750 -#else
1751    fOut = m_dllAvFormat.av_guess_format(muxerName.c_str(), NULL, NULL);
1752 -#endif
1753    if (!fOut)
1754    {
1755      CLog::Log(LOGERROR, "CDVDAudioCodecPassthroughFFmpeg::SetupMuxer - Failed to get the FFmpeg %s muxer", muxerName.c_str());
1756 @@ -103,7 +99,7 @@
1757    muxer.m_pFormat->oformat = fOut;
1758
1759    /* allocate a put_byte struct so we can grab the output */
1760 -  muxer.m_pFormat->pb = m_dllAvFormat.av_alloc_put_byte(muxer.m_BCBuffer, sizeof(muxer.m_BCBuffer), URL_RDONLY, &muxer,  NULL, MuxerReadPacket, NULL);
1761 +  muxer.m_pFormat->pb = m_dllAvFormat.avio_alloc_context(muxer.m_BCBuffer, sizeof(muxer.m_BCBuffer), AVIO_FLAG_READ, &muxer,  NULL, MuxerReadPacket, NULL);
1762    if (!muxer.m_pFormat->pb)
1763    {
1764      CLog::Log(LOGERROR, "CDVDAudioCodecPassthroughFFmpeg::SetupMuxer - Failed to allocate ByteIOContext");
1765 @@ -112,21 +108,10 @@
1766    }
1767
1768    /* this is streamed, no file, and ignore the index */
1769 -  muxer.m_pFormat->pb->is_streamed   = 1;
1770 +  muxer.m_pFormat->pb->seekable      = 0;
1771    muxer.m_pFormat->flags            |= AVFMT_NOFILE | AVFMT_FLAG_IGNIDX;
1772    muxer.m_pFormat->bit_rate          = hints.bitrate;
1773
1774 -  /* setup the muxer */
1775 -  if (m_dllAvFormat.av_set_parameters(muxer.m_pFormat, NULL) != 0)
1776 -  {
1777 -    CLog::Log(LOGERROR, "CDVDAudioCodecPassthroughFFmpeg::SetupMuxer - Failed to set the %s muxer parameters", muxerName.c_str());
1778 -    Dispose();
1779 -    return false;
1780 -  }
1781 -
1782 -#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52,92,0)
1783 -  // API added on: 2011-01-02
1784 -
1785    /* While this is strictly only needed on big-endian systems, we do it on
1786     * both to avoid as much dead code as possible.
1787     * CoreAudio (at least on the cases we've seen) wants IEC 61937 in
1788 @@ -138,8 +123,7 @@
1789  #endif
1790
1791    /* request output of wanted endianness */
1792 -  if (!fOut->priv_class || m_dllAvUtil.av_set_string3(muxer.m_pFormat->priv_data, "spdif_flags", spdifFlags, 0, NULL) != 0)
1793 -#endif
1794 +  if (!fOut->priv_class || m_dllAvUtil.av_opt_set(muxer.m_pFormat->priv_data, "spdif_flags", spdifFlags, 0) != 0)
1795    {
1796  #if defined(WORDS_BIGENDIAN) && !defined(__APPLE__)
1797      CLog::Log(LOGERROR, "CDVDAudioCodecPassthroughFFmpeg::SetupMuxer - Unable to set big-endian stream mode (FFmpeg too old?), disabling passthrough");
1798 @@ -149,7 +133,7 @@
1799    }
1800
1801    /* add a stream to it */
1802 -  muxer.m_pStream = m_dllAvFormat.av_new_stream(muxer.m_pFormat, 1);
1803 +  muxer.m_pStream = m_dllAvFormat.avformat_new_stream(muxer.m_pFormat, NULL);
1804    if (!muxer.m_pStream)
1805    {
1806      CLog::Log(LOGERROR, "CDVDAudioCodecPassthroughFFmpeg::SetupMuxer - Failed to allocate AVStream context");
1807 @@ -159,8 +143,6 @@
1808
1809
1810    /* set the stream's parameters */
1811 -  muxer.m_pStream->stream_copy           = 1;
1812 -
1813    m_SampleRate = hints.samplerate;
1814    if(!m_SampleRate && hints.codec == CODEC_ID_AC3)
1815      m_SampleRate = 48000;
1816 @@ -176,7 +158,7 @@
1817    codec->extradata_size = hints.extrasize;
1818    memcpy(codec->extradata, hints.extradata, hints.extrasize);
1819
1820 -  muxer.m_WroteHeader = m_dllAvFormat.av_write_header(muxer.m_pFormat) == 0;
1821 +  muxer.m_WroteHeader = m_dllAvFormat.avformat_write_header(muxer.m_pFormat, NULL) == 0;
1822    if (!muxer.m_WroteHeader)
1823    {
1824      CLog::Log(LOGERROR, "CDVDAudioCodecPassthrough::SetupMuxer - Failed to write the frame header");
1825 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.cpp
1826 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.cpp   2012-03-21 23:07:50.000000000 +0100
1827 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.cpp        2012-11-08 23:16:03.533072250 +0100
1828 @@ -55,7 +55,7 @@
1829  bool CDVDAudioEncoderFFmpeg::Initialize(unsigned int channels, enum PCMChannels *channelMap, unsigned int bitsPerSample, unsigned int sampleRate)
1830  {
1831    Reset();
1832 -  if (!channelMap || !m_dllAvUtil.Load() || !m_dllAvCore.Load() || !m_dllAvCodec.Load())
1833 +  if (!channelMap || !m_dllAvUtil.Load() || !m_dllAvCodec.Load())
1834      return false;
1835
1836    m_dllAvCodec.avcodec_register_all();
1837 @@ -65,7 +65,7 @@
1838      return false;
1839
1840    /* always assume 6 channels, 5.1... m_remap will give us what we want */
1841 -  m_CodecCtx = m_dllAvCodec.avcodec_alloc_context();
1842 +  m_CodecCtx = m_dllAvCodec.avcodec_alloc_context3(codec);
1843    m_CodecCtx->bit_rate       = AC3_ENCODE_BITRATE;
1844    m_CodecCtx->sample_rate    = sampleRate;
1845    m_CodecCtx->channels       = 6;
1846 @@ -104,7 +104,7 @@
1847      }
1848    }
1849
1850 -  if (m_dllAvCodec.avcodec_open(m_CodecCtx, codec))
1851 +  if (m_dllAvCodec.avcodec_open2(m_CodecCtx, codec, NULL))
1852    {
1853      m_dllAvUtil.av_freep(&m_CodecCtx);
1854      return false;
1855 @@ -149,7 +149,7 @@
1856
1857    if (m_AudioConvert)
1858        m_TmpBuffer2   = new uint8_t[m_NeededFrames * m_CodecCtx->channels *
1859 -                                   m_dllAvCore.av_get_bits_per_sample_fmt(m_CodecCtx->sample_fmt) / 8];
1860 +                                   m_dllAvUtil.av_get_bytes_per_sample(m_CodecCtx->sample_fmt)];
1861
1862    return true;
1863  }
1864 @@ -186,7 +186,7 @@
1865      void *convInBuf[] = { m_TmpBuffer };
1866      int convInStr[] = { m_BitsPerSample / 8 };
1867      void *convOutBuf[] = { m_TmpBuffer2 };
1868 -    int convOutStr[] = { m_dllAvCore.av_get_bits_per_sample_fmt(m_CodecCtx->sample_fmt) / 8 };
1869 +    int convOutStr[] = { m_dllAvUtil.av_get_bytes_per_sample(m_CodecCtx->sample_fmt) };
1870      if (m_dllAvCodec.av_audio_convert(m_AudioConvert, convOutBuf, convOutStr,
1871                                        convInBuf, convInStr, m_NeededFrames * m_CodecCtx->channels) < 0) {
1872        CLog::Log(LOGERROR, "CDVDAudioEncoderFFmpeg: Audio conversion failed");
1873 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.h xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.h
1874 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.h     2012-03-21 23:07:50.000000000 +0100
1875 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Audio/Encoders/DVDAudioEncoderFFmpeg.h  2012-11-08 23:15:55.399739205 +0100
1876 @@ -43,7 +43,6 @@
1877    virtual int GetData(uint8_t **data);
1878  private:
1879    DllAvCodec m_dllAvCodec;
1880 -  DllAvCore  m_dllAvCore;
1881    DllAvUtil  m_dllAvUtil;
1882
1883    AVCodecContext   *m_CodecCtx;
1884 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Overlay/DVDOverlayCodecFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Overlay/DVDOverlayCodecFFmpeg.cpp
1885 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Overlay/DVDOverlayCodecFFmpeg.cpp  2012-03-21 23:07:50.000000000 +0100
1886 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Overlay/DVDOverlayCodecFFmpeg.cpp       2012-11-08 23:16:03.533072250 +0100
1887 @@ -49,7 +49,14 @@
1888
1889    m_dllAvCodec.avcodec_register_all();
1890
1891 -  m_pCodecContext = m_dllAvCodec.avcodec_alloc_context();
1892 +  AVCodec* pCodec = m_dllAvCodec.avcodec_find_decoder(hints.codec);
1893 +  if (!pCodec)
1894 +  {
1895 +    CLog::Log(LOGDEBUG,"%s - Unable to find codec %d", __FUNCTION__, hints.codec);
1896 +    return false;
1897 +  }
1898 +
1899 +  m_pCodecContext = m_dllAvCodec.avcodec_alloc_context3(pCodec);
1900    m_pCodecContext->debug_mv = 0;
1901    m_pCodecContext->debug = 0;
1902    m_pCodecContext->workaround_bugs = FF_BUG_AUTODETECT;
1903 @@ -100,14 +107,7 @@
1904      delete[] parse_extra;
1905    }
1906
1907 -  AVCodec* pCodec = m_dllAvCodec.avcodec_find_decoder(hints.codec);
1908 -  if (!pCodec)
1909 -  {
1910 -    CLog::Log(LOGDEBUG,"%s - Unable to find codec %d", __FUNCTION__, hints.codec);
1911 -    return false;
1912 -  }
1913 -
1914 -  if (m_dllAvCodec.avcodec_open(m_pCodecContext, pCodec) < 0)
1915 +  if (m_dllAvCodec.avcodec_open2(m_pCodecContext, pCodec, NULL) < 0)
1916    {
1917      CLog::Log(LOGDEBUG,"CDVDVideoCodecFFmpeg::Open() Unable to open codec");
1918      return false;
1919 @@ -134,19 +134,12 @@
1920  {
1921    for(unsigned i=0;i<sub.num_rects;i++)
1922    {
1923 -#if LIBAVCODEC_VERSION_INT >= (52<<10)
1924      if(sub.rects[i])
1925      {
1926        m_dllAvUtil.av_free(sub.rects[i]->pict.data[0]);
1927        m_dllAvUtil.av_free(sub.rects[i]->pict.data[1]);
1928        m_dllAvUtil.av_freep(&sub.rects[i]);
1929      }
1930 -#else
1931 -    if(sub.rects[i].bitmap)
1932 -      m_dllAvUtil.av_freep(&sub.rects[i].bitmap);
1933 -    if(m_Subtitle.rects[i].rgba_palette)
1934 -      m_dllAvUtil.av_freep(&sub.rects[i].rgba_palette);
1935 -#endif
1936    }
1937    if(sub.rects)
1938      m_dllAvUtil.av_freep(&sub.rects);
1939 @@ -294,7 +287,6 @@
1940      overlay->source_width  = m_width;
1941      overlay->source_height = m_height;
1942
1943 -#if LIBAVCODEC_VERSION_INT >= (52<<10)
1944      BYTE* s = rect.pict.data[0];
1945      BYTE* t = overlay->data;
1946      for(int i=0;i<rect.h;i++)
1947 @@ -310,21 +302,6 @@
1948      m_dllAvUtil.av_free(rect.pict.data[0]);
1949      m_dllAvUtil.av_free(rect.pict.data[1]);
1950      m_dllAvUtil.av_freep(&m_Subtitle.rects[m_SubtitleIndex]);
1951 -#else
1952 -    BYTE* s = rect.bitmap;
1953 -    BYTE* t = overlay->data;
1954 -    for(int i=0;i<rect.h;i++)
1955 -    {
1956 -      memcpy(t, s, rect.w);
1957 -      s += rect.linesize;
1958 -      t += overlay->linesize;
1959 -    }
1960 -
1961 -    memcpy(overlay->palette, rect.rgba_palette, rect.nb_colors*4);
1962 -
1963 -    m_dllAvUtil.av_freep(&rect.bitmap);
1964 -    m_dllAvUtil.av_freep(&rect.rgba_palette);
1965 -#endif
1966      m_SubtitleIndex++;
1967
1968      return overlay;
1969 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp
1970 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp      2012-03-21 23:07:50.000000000 +0100
1971 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp   2012-11-08 23:16:12.336405273 +0100
1972 @@ -123,12 +123,11 @@
1973  CDVDVideoCodecFFmpeg::CDVDVideoCodecFFmpeg() : CDVDVideoCodec()
1974  {
1975    m_pCodecContext = NULL;
1976 -  m_pConvertFrame = NULL;
1977    m_pFrame = NULL;
1978    m_pFilterGraph  = NULL;
1979    m_pFilterIn     = NULL;
1980    m_pFilterOut    = NULL;
1981 -  m_pFilterLink   = NULL;
1982 +  m_pBufferRef    = NULL;
1983
1984    m_iPictureWidth = 0;
1985    m_iPictureHeight = 0;
1986 @@ -163,9 +162,13 @@
1987    m_dllAvFilter.avfilter_register_all();
1988
1989    m_bSoftware     = hints.software;
1990 -  m_pCodecContext = m_dllAvCodec.avcodec_alloc_context();
1991 +
1992 +  m_formats.push_back(PIX_FMT_YUV420P);
1993 +  m_formats.push_back(PIX_FMT_YUVJ420P);
1994 +  m_formats.push_back(PIX_FMT_NONE); /* always add none to get a terminated list in ffmpeg world */
1995
1996    pCodec = NULL;
1997 +  m_pCodecContext = NULL;
1998
1999    if (hints.codec == CODEC_ID_H264)
2000    {
2001 @@ -196,6 +199,7 @@
2002
2003          CLog::Log(LOGNOTICE,"CDVDVideoCodecFFmpeg::Open() Creating VDPAU(%ix%i, %d)",hints.width, hints.height, hints.codec);
2004          CVDPAU* vdp = new CVDPAU();
2005 +        m_pCodecContext = m_dllAvCodec.avcodec_alloc_context3(pCodec);
2006          m_pCodecContext->codec_id = hints.codec;
2007          m_pCodecContext->width    = hints.width;
2008          m_pCodecContext->height   = hints.height;
2009 @@ -207,7 +211,7 @@
2010            m_pCodecContext->codec_id = CODEC_ID_NONE; // ffmpeg will complain if this has been set
2011            break;
2012          }
2013 -        m_pCodecContext->codec_id = CODEC_ID_NONE; // ffmpeg will complain if this has been set
2014 +        m_dllAvUtil.av_freep(&m_pCodecContext);
2015          CLog::Log(LOGNOTICE,"CDVDVideoCodecFFmpeg::Open() Failed to get VDPAU device");
2016          vdp->Release();
2017        }
2018 @@ -226,6 +230,9 @@
2019
2020    CLog::Log(LOGNOTICE,"CDVDVideoCodecFFmpeg::Open() Using codec: %s",pCodec->long_name ? pCodec->long_name : pCodec->name);
2021
2022 +  if(m_pCodecContext == NULL)
2023 +    m_pCodecContext = m_dllAvCodec.avcodec_alloc_context3(pCodec);
2024 +
2025    m_pCodecContext->opaque = (void*)this;
2026    m_pCodecContext->debug_mv = 0;
2027    m_pCodecContext->debug = 0;
2028 @@ -238,9 +245,7 @@
2029    m_pCodecContext->flags &= CODEC_FLAG_EMU_EDGE;
2030  #else
2031    if (pCodec->id != CODEC_ID_H264 && pCodec->capabilities & CODEC_CAP_DR1
2032 -#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52,69,0)
2033        && pCodec->id != CODEC_ID_VP8
2034 -#endif
2035       )
2036      m_pCodecContext->flags |= CODEC_FLAG_EMU_EDGE;
2037  #endif
2038 @@ -272,16 +277,16 @@
2039      if (it->m_name == "surfaces")
2040        m_uSurfacesCount = std::atoi(it->m_value.c_str());
2041      else
2042 -      m_dllAvUtil.av_set_string3(m_pCodecContext, it->m_name.c_str(), it->m_value.c_str(), 0, NULL);
2043 +      m_dllAvUtil.av_opt_set(m_pCodecContext, it->m_name.c_str(), it->m_value.c_str(), 0);
2044    }
2045
2046    int num_threads = std::min(8 /*MAX_THREADS*/, g_cpuInfo.getCPUCount());
2047    if( num_threads > 1 && !hints.software && m_pHardware == NULL // thumbnail extraction fails when run threaded
2048    && ( pCodec->id == CODEC_ID_H264
2049      || pCodec->id == CODEC_ID_MPEG4 ))
2050 -    m_dllAvCodec.avcodec_thread_init(m_pCodecContext, num_threads);
2051 +    m_pCodecContext->thread_count = num_threads;
2052
2053 -  if (m_dllAvCodec.avcodec_open(m_pCodecContext, pCodec) < 0)
2054 +  if (m_dllAvCodec.avcodec_open2(m_pCodecContext, pCodec, NULL) < 0)
2055    {
2056      CLog::Log(LOGDEBUG,"CDVDVideoCodecFFmpeg::Open() Unable to open codec");
2057      return false;
2058 @@ -306,13 +311,6 @@
2059    if (m_pFrame) m_dllAvUtil.av_free(m_pFrame);
2060    m_pFrame = NULL;
2061
2062 -  if (m_pConvertFrame)
2063 -  {
2064 -    m_dllAvCodec.avpicture_free(m_pConvertFrame);
2065 -    m_dllAvUtil.av_free(m_pConvertFrame);
2066 -  }
2067 -  m_pConvertFrame = NULL;
2068 -
2069    if (m_pCodecContext)
2070    {
2071      if (m_pCodecContext->codec) m_dllAvCodec.avcodec_close(m_pCodecContext);
2072 @@ -458,9 +456,6 @@
2073      return VC_ERROR;
2074    }
2075
2076 -  if (len != iSize && m_pCodecContext->skip_frame != AVDISCARD_NONREF)
2077 -    CLog::Log(LOGWARNING, "%s - avcodec_decode_video didn't consume the full packet. size: %d, consumed: %d", __FUNCTION__, iSize, len);
2078 -
2079    if (!iGotPicture)
2080      return VC_BUFFER;
2081
2082 @@ -478,67 +473,32 @@
2083    if(m_pCodecContext->codec_id == CODEC_ID_H264)
2084      m_started = true;
2085
2086 -  if(m_pCodecContext->pix_fmt != PIX_FMT_YUV420P
2087 -  && m_pCodecContext->pix_fmt != PIX_FMT_YUVJ420P
2088 -  && m_pHardware == NULL)
2089 -  {
2090 -    if (!m_dllSwScale.IsLoaded() && !m_dllSwScale.Load())
2091 -        return VC_ERROR;
2092 -
2093 -    if (!m_pConvertFrame)
2094 -    {
2095 -      // Allocate an AVFrame structure
2096 -      m_pConvertFrame = (AVPicture*)m_dllAvUtil.av_mallocz(sizeof(AVPicture));
2097 -      // Due to a bug in swsscale we need to allocate one extra line of data
2098 -      if(m_dllAvCodec.avpicture_alloc( m_pConvertFrame
2099 -                                     , PIX_FMT_YUV420P
2100 -                                     , m_pCodecContext->width
2101 -                                     , m_pCodecContext->height+1) < 0)
2102 -      {
2103 -        m_dllAvUtil.av_free(m_pConvertFrame);
2104 -        m_pConvertFrame = NULL;
2105 -        return VC_ERROR;
2106 -      }
2107 -    }
2108 +  if(m_pHardware == NULL)
2109 +  {
2110 +    bool need_scale = std::find( m_formats.begin()
2111 +                               , m_formats.end()
2112 +                               , m_pCodecContext->pix_fmt) == m_formats.end();
2113
2114 -    // convert the picture
2115 -    struct SwsContext *context = m_dllSwScale.sws_getContext(m_pCodecContext->width, m_pCodecContext->height,
2116 -                                         m_pCodecContext->pix_fmt, m_pCodecContext->width, m_pCodecContext->height,
2117 -                                         PIX_FMT_YUV420P, SWS_FAST_BILINEAR | SwScaleCPUFlags(), NULL, NULL, NULL);
2118 +    bool need_reopen  = false;
2119 +    if(!m_filters.Equals(m_filters_next))
2120 +      need_reopen = true;
2121
2122 -    if(context == NULL)
2123 +    if(m_pFilterIn)
2124      {
2125 -      CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::Decode - unable to obtain sws context for w:%i, h:%i, pixfmt: %i", m_pCodecContext->width, m_pCodecContext->height, m_pCodecContext->pix_fmt);
2126 -      return VC_ERROR;
2127 +      if(m_pFilterIn->outputs[0]->format != m_pCodecContext->pix_fmt
2128 +      || m_pFilterIn->outputs[0]->w      != m_pCodecContext->width
2129 +      || m_pFilterIn->outputs[0]->h      != m_pCodecContext->height)
2130 +        need_reopen = true;
2131      }
2132
2133 -    m_dllSwScale.sws_scale(context
2134 -                          , m_pFrame->data
2135 -                          , m_pFrame->linesize
2136 -                          , 0
2137 -                          , m_pCodecContext->height
2138 -                          , m_pConvertFrame->data
2139 -                          , m_pConvertFrame->linesize);
2140 -
2141 -    m_dllSwScale.sws_freeContext(context);
2142 -  }
2143 -  else
2144 -  {
2145 -    // no need to convert, just free any existing convert buffers
2146 -    if (m_pConvertFrame)
2147 +    // try to setup new filters
2148 +    if (need_reopen || (need_scale && m_pFilterGraph == NULL))
2149      {
2150 -      m_dllAvCodec.avpicture_free(m_pConvertFrame);
2151 -      m_dllAvUtil.av_free(m_pConvertFrame);
2152 -      m_pConvertFrame = NULL;
2153 -    }
2154 -  }
2155 +      m_filters = m_filters_next;
2156
2157 -  // try to setup new filters
2158 -  if (!m_filters.Equals(m_filters_next))
2159 -  {
2160 -    m_filters = m_filters_next;
2161 -    if(FilterOpen(m_filters) < 0)
2162 -      FilterClose();
2163 +      if(FilterOpen(m_filters, need_scale) < 0)
2164 +        FilterClose();
2165 +    }
2166    }
2167
2168    int result;
2169 @@ -564,12 +524,6 @@
2170    if (m_pHardware)
2171      m_pHardware->Reset();
2172
2173 -  if (m_pConvertFrame)
2174 -  {
2175 -    m_dllAvCodec.avpicture_free(m_pConvertFrame);
2176 -    m_dllAvUtil.av_free(m_pConvertFrame);
2177 -    m_pConvertFrame = NULL;
2178 -  }
2179    m_filters = "";
2180    FilterClose();
2181  }
2182 @@ -579,10 +533,10 @@
2183    pDvdVideoPicture->iWidth = m_pCodecContext->width;
2184    pDvdVideoPicture->iHeight = m_pCodecContext->height;
2185
2186 -  if(m_pFilterLink)
2187 +  if(m_pBufferRef)
2188    {
2189 -    pDvdVideoPicture->iWidth  = m_pFilterLink->cur_buf->video->w;
2190 -    pDvdVideoPicture->iHeight = m_pFilterLink->cur_buf->video->h;
2191 +    pDvdVideoPicture->iWidth  = m_pBufferRef->video->w;
2192 +    pDvdVideoPicture->iHeight = m_pBufferRef->video->h;
2193    }
2194
2195    /* crop of 10 pixels if demuxer asked it */
2196 @@ -598,12 +552,8 @@
2197
2198    /* use variable in the frame */
2199    AVRational pixel_aspect = m_pCodecContext->sample_aspect_ratio;
2200 -  if (m_pFilterLink)
2201 -#ifdef HAVE_AVFILTERBUFFERREFVIDEOPROPS_SAMPLE_ASPECT_RATIO
2202 -    pixel_aspect = m_pFilterLink->cur_buf->video->sample_aspect_ratio;
2203 -#else
2204 -    pixel_aspect = m_pFilterLink->cur_buf->video->pixel_aspect;
2205 -#endif
2206 +  if (m_pBufferRef)
2207 +    pixel_aspect = m_pBufferRef->video->sample_aspect_ratio;
2208
2209    if (pixel_aspect.num == 0)
2210      aspect_ratio = 0;
2211 @@ -632,8 +582,6 @@
2212    pDvdVideoPicture->iFlags = DVP_FLAG_ALLOCATED;
2213    pDvdVideoPicture->iFlags |= m_pFrame->interlaced_frame ? DVP_FLAG_INTERLACED : 0;
2214    pDvdVideoPicture->iFlags |= m_pFrame->top_field_first ? DVP_FLAG_TOP_FIELD_FIRST: 0;
2215 -  if(m_pCodecContext->pix_fmt == PIX_FMT_YUVJ420P)
2216 -    pDvdVideoPicture->color_range = 1;
2217
2218    pDvdVideoPicture->chroma_position = m_pCodecContext->chroma_sample_location;
2219    pDvdVideoPicture->color_primaries = m_pCodecContext->color_primaries;
2220 @@ -677,14 +625,6 @@
2221    if(!GetPictureCommon(pDvdVideoPicture))
2222      return false;
2223
2224 -  if(m_pConvertFrame)
2225 -  {
2226 -    for (int i = 0; i < 4; i++)
2227 -      pDvdVideoPicture->data[i]      = m_pConvertFrame->data[i];
2228 -    for (int i = 0; i < 4; i++)
2229 -      pDvdVideoPicture->iLineSize[i] = m_pConvertFrame->linesize[i];
2230 -  }
2231 -  else
2232    {
2233      for (int i = 0; i < 4; i++)
2234        pDvdVideoPicture->data[i]      = m_pFrame->data[i];
2235 @@ -693,20 +633,38 @@
2236    }
2237
2238    pDvdVideoPicture->iFlags |= pDvdVideoPicture->data[0] ? 0 : DVP_FLAG_DROPPED;
2239 -  pDvdVideoPicture->format = DVDVideoPicture::FMT_YUV420P;
2240    pDvdVideoPicture->extended_format = 0;
2241 +  pDvdVideoPicture->color_range = 0;
2242 +
2243 +  PixelFormat pix_fmt;
2244 +  if(m_pBufferRef)
2245 +    pix_fmt = (PixelFormat)m_pBufferRef->format;
2246 +  else
2247 +    pix_fmt = m_pCodecContext->pix_fmt;
2248 +
2249 +  switch(pix_fmt)
2250 +  {
2251 +    case PIX_FMT_YUVJ420P:
2252 +      pDvdVideoPicture->format = DVDVideoPicture::FMT_YUV420P;
2253 +      pDvdVideoPicture->color_range = 1;
2254 +      break;
2255 +    default:
2256 +      pDvdVideoPicture->format = DVDVideoPicture::FMT_YUV420P;
2257 +      break;
2258 +  }
2259
2260    return true;
2261  }
2262
2263 -int CDVDVideoCodecFFmpeg::FilterOpen(const CStdString& filters)
2264 +int CDVDVideoCodecFFmpeg::FilterOpen(const CStdString& filters, bool scale)
2265  {
2266    int result;
2267 +  AVBufferSinkParams *buffersink_params;
2268
2269    if (m_pFilterGraph)
2270      FilterClose();
2271
2272 -  if (filters.IsEmpty())
2273 +  if (filters.IsEmpty() && !scale)
2274      return 0;
2275
2276    if (!(m_pFilterGraph = m_dllAvFilter.avfilter_graph_alloc()))
2277 @@ -715,17 +673,8 @@
2278      return -1;
2279    }
2280
2281 -  // CrHasher HACK (if an alternative becomes available use it!): In order to display the output
2282 -  // produced by a combination of filters we insert "nullsink" as the last filter and we use
2283 -  // its input pin as our output pin.
2284 -  //
2285 -  // input --> .. --> last_filter --> [in] nullsink [null]     [in] --> output
2286 -  //                                   |                        |
2287 -  //                                   |                        |
2288 -  //                                   +------------------------+
2289 -  //
2290    AVFilter* srcFilter = m_dllAvFilter.avfilter_get_by_name("buffer");
2291 -  AVFilter* outFilter = m_dllAvFilter.avfilter_get_by_name("nullsink"); // should be last filter in the graph for now
2292 +  AVFilter* outFilter = m_dllAvFilter.avfilter_get_by_name("buffersink"); // should be last filter in the graph for now
2293
2294    CStdString args;
2295
2296 @@ -744,11 +693,19 @@
2297      return result;
2298    }
2299
2300 -  if ((result = m_dllAvFilter.avfilter_graph_create_filter(&m_pFilterOut, outFilter, "out", NULL, NULL/*nullsink=>NULL*/, m_pFilterGraph)) < 0)
2301 +  buffersink_params = m_dllAvFilter.av_buffersink_params_alloc();
2302 +  buffersink_params->pixel_fmts = &m_formats[0];
2303 +#ifdef FF_API_OLD_VSINK_API
2304 +  if ((result = m_dllAvFilter.avfilter_graph_create_filter(&m_pFilterOut, outFilter, "out", NULL, (void*)buffersink_params->pixel_fmts, m_pFilterGraph)) < 0)
2305 +#else
2306 +  if ((result = m_dllAvFilter.avfilter_graph_create_filter(&m_pFilterOut, outFilter, "out", NULL, buffersink_params, m_pFilterGraph)) < 0)
2307 +#endif
2308    {
2309 +    m_dllAvUtil.av_freep(&buffersink_params);
2310      CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_create_filter: out");
2311      return result;
2312    }
2313 +  m_dllAvUtil.av_freep(&buffersink_params);
2314
2315    if (!filters.empty())
2316    {
2317 @@ -794,6 +751,12 @@
2318
2319  void CDVDVideoCodecFFmpeg::FilterClose()
2320  {
2321 +  if(m_pBufferRef)
2322 +  {
2323 +    m_dllAvFilter.avfilter_unref_buffer(m_pBufferRef);
2324 +    m_pBufferRef = NULL;
2325 +  }
2326 +
2327    if (m_pFilterGraph)
2328    {
2329      m_dllAvFilter.avfilter_graph_free(&m_pFilterGraph);
2330 @@ -801,7 +764,6 @@
2331      // Disposed by above code
2332      m_pFilterIn   = NULL;
2333      m_pFilterOut  = NULL;
2334 -    m_pFilterLink = NULL;
2335    }
2336  }
2337
2338 @@ -809,48 +771,41 @@
2339  {
2340    int result, frames;
2341
2342 -  m_pFilterLink = m_pFilterOut->inputs[0];
2343 -
2344    if (frame)
2345    {
2346 -#if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,13,0)
2347 +#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,0,0)
2348      result = m_dllAvFilter.av_vsrc_buffer_add_frame(m_pFilterIn, frame, 0);
2349 -#elif LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(2,7,0)
2350 -    result = m_dllAvFilter.av_vsrc_buffer_add_frame(m_pFilterIn, frame);
2351 -#elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53,3,0)
2352 -    result = m_dllAvFilter.av_vsrc_buffer_add_frame(m_pFilterIn, frame, frame->pts);
2353  #else
2354 -    result = m_dllAvFilter.av_vsrc_buffer_add_frame(m_pFilterIn, frame, frame->pts, m_pCodecContext->sample_aspect_ratio);
2355 +    result = m_dllAvFilter.av_buffersrc_add_frame(m_pFilterIn, frame, 0);
2356  #endif
2357 -
2358      if (result < 0)
2359      {
2360 +#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,0,0)
2361        CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterProcess - av_vsrc_buffer_add_frame");
2362 +#else
2363 +      CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterProcess - av_buffersrc_add_frame");
2364 +#endif
2365        return VC_ERROR;
2366      }
2367    }
2368
2369 -  if ((frames = m_dllAvFilter.avfilter_poll_frame(m_pFilterLink)) < 0)
2370 +  if(m_pBufferRef)
2371 +  {
2372 +    m_dllAvFilter.avfilter_unref_buffer(m_pBufferRef);
2373 +    m_pBufferRef = NULL;
2374 +  }
2375 +
2376 +  if ((frames = m_dllAvFilter.av_buffersink_poll_frame(m_pFilterOut)) < 0)
2377    {
2378 -    CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterProcess - avfilter_poll_frame");
2379 +    CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterProcess - av_buffersink_poll_frame");
2380      return VC_ERROR;
2381    }
2382
2383    if (frames > 0)
2384    {
2385 -    if (m_pFilterLink->cur_buf)
2386 -    {
2387 -      m_dllAvFilter.avfilter_unref_buffer(m_pFilterLink->cur_buf);
2388 -      m_pFilterLink->cur_buf = NULL;
2389 -    }
2390 -
2391 -    if ((result = m_dllAvFilter.avfilter_request_frame(m_pFilterLink)) < 0)
2392 -    {
2393 -      CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterProcess - avfilter_request_frame");
2394 -      return VC_ERROR;
2395 -    }
2396
2397 -    if (!m_pFilterLink->cur_buf)
2398 +    result = m_dllAvFilter.av_buffersink_get_buffer_ref(m_pFilterOut, &m_pBufferRef, 0);
2399 +    if(!m_pBufferRef)
2400      {
2401        CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterProcess - cur_buf");
2402        return VC_ERROR;
2403 @@ -861,11 +816,11 @@
2404      else
2405        m_pFrame->repeat_pict      = -(frames - 1);
2406
2407 -    m_pFrame->interlaced_frame = m_pFilterLink->cur_buf->video->interlaced;
2408 -    m_pFrame->top_field_first  = m_pFilterLink->cur_buf->video->top_field_first;
2409 +    m_pFrame->interlaced_frame = m_pBufferRef->video->interlaced;
2410 +    m_pFrame->top_field_first  = m_pBufferRef->video->top_field_first;
2411
2412 -    memcpy(m_pFrame->linesize, m_pFilterLink->cur_buf->linesize, 4*sizeof(int));
2413 -    memcpy(m_pFrame->data    , m_pFilterLink->cur_buf->data    , 4*sizeof(uint8_t*));
2414 +    memcpy(m_pFrame->linesize, m_pBufferRef->linesize, 4*sizeof(int));
2415 +    memcpy(m_pFrame->data    , m_pBufferRef->data    , 4*sizeof(uint8_t*));
2416
2417      if(frames > 1)
2418        return VC_PICTURE;
2419 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.h xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.h
2420 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.h        2012-03-21 23:07:50.000000000 +0100
2421 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.h     2012-11-08 23:16:03.533072250 +0100
2422 @@ -75,20 +75,19 @@
2423  protected:
2424    static enum PixelFormat GetFormat(struct AVCodecContext * avctx, const PixelFormat * fmt);
2425
2426 -  int  FilterOpen(const CStdString& filters);
2427 +  int  FilterOpen(const CStdString& filters, bool scale);
2428    void FilterClose();
2429    int  FilterProcess(AVFrame* frame);
2430
2431    AVFrame* m_pFrame;
2432    AVCodecContext* m_pCodecContext;
2433
2434 -  AVPicture* m_pConvertFrame;
2435    CStdString       m_filters;
2436    CStdString       m_filters_next;
2437    AVFilterGraph*   m_pFilterGraph;
2438    AVFilterContext* m_pFilterIn;
2439    AVFilterContext* m_pFilterOut;
2440 -  AVFilterLink*    m_pFilterLink;
2441 +  AVFilterBufferRef* m_pBufferRef;
2442
2443    int m_iPictureWidth;
2444    int m_iPictureHeight;
2445 @@ -109,4 +108,5 @@
2446    int m_iLastKeyframe;
2447    double m_dts;
2448    bool   m_started;
2449 +  std::vector<PixelFormat> m_formats;
2450  };
2451 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVDA.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVDA.cpp
2452 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVDA.cpp 2012-03-21 23:07:50.000000000 +0100
2453 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVDA.cpp      2012-11-08 23:16:03.533072250 +0100
2454 @@ -525,8 +525,8 @@
2455    {
2456      while (!*(nal_start++));
2457      nal_end = avc_find_startcode(nal_start, end);
2458 -    av_format_ctx->put_be32(pb, nal_end - nal_start);
2459 -    av_format_ctx->put_buffer(pb, nal_start, nal_end - nal_start);
2460 +    av_format_ctx->avio_wb32(pb, nal_end - nal_start);
2461 +    av_format_ctx->avio_write(pb, nal_start, nal_end - nal_start);
2462      size += 4 + nal_end - nal_start;
2463      nal_start = nal_end;
2464    }
2465 @@ -537,14 +537,14 @@
2466    const uint8_t *buf_in, uint8_t **buf, int *size)
2467  {
2468    ByteIOContext *pb;
2469 -  int ret = av_format_ctx->url_open_dyn_buf(&pb);
2470 +  int ret = av_format_ctx->avio_open_dyn_buf(&pb);
2471    if (ret < 0)
2472      return ret;
2473
2474    avc_parse_nal_units(av_format_ctx, pb, buf_in, *size);
2475
2476    av_util_ctx->av_freep(buf);
2477 -  *size = av_format_ctx->url_close_dyn_buf(pb, buf);
2478 +  *size = av_format_ctx->avio_close_dyn_buf(pb, buf);
2479    return 0;
2480  }
2481
2482 @@ -590,26 +590,26 @@
2483        }
2484        assert(sps);
2485
2486 -      av_format_ctx->put_byte(pb, 1); /* version */
2487 -      av_format_ctx->put_byte(pb, sps[1]); /* profile */
2488 -      av_format_ctx->put_byte(pb, sps[2]); /* profile compat */
2489 -      av_format_ctx->put_byte(pb, sps[3]); /* level */
2490 -      av_format_ctx->put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
2491 -      av_format_ctx->put_byte(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
2492 +      av_format_ctx->avio_w8(pb, 1); /* version */
2493 +      av_format_ctx->avio_w8(pb, sps[1]); /* profile */
2494 +      av_format_ctx->avio_w8(pb, sps[2]); /* profile compat */
2495 +      av_format_ctx->avio_w8(pb, sps[3]); /* level */
2496 +      av_format_ctx->avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
2497 +      av_format_ctx->avio_w8(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
2498
2499 -      av_format_ctx->put_be16(pb, sps_size);
2500 -      av_format_ctx->put_buffer(pb, sps, sps_size);
2501 +      av_format_ctx->avio_wb16(pb, sps_size);
2502 +      av_format_ctx->avio_write(pb, sps, sps_size);
2503        if (pps)
2504        {
2505 -        av_format_ctx->put_byte(pb, 1); /* number of pps */
2506 -        av_format_ctx->put_be16(pb, pps_size);
2507 -        av_format_ctx->put_buffer(pb, pps, pps_size);
2508 +        av_format_ctx->avio_w8(pb, 1); /* number of pps */
2509 +        av_format_ctx->avio_wb16(pb, pps_size);
2510 +        av_format_ctx->avio_write(pb, pps, pps_size);
2511        }
2512        av_util_ctx->av_free(start);
2513      }
2514      else
2515      {
2516 -      av_format_ctx->put_buffer(pb, data, len);
2517 +      av_format_ctx->avio_write(pb, data, len);
2518      }
2519    }
2520    return 0;
2521 @@ -706,7 +706,7 @@
2522              }
2523
2524              ByteIOContext *pb;
2525 -            if (m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2526 +            if (m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2527              {
2528                return false;
2529              }
2530 @@ -717,7 +717,7 @@
2531              // unhook from ffmpeg's extradata
2532              extradata = NULL;
2533              // extract the avcC atom data into extradata then write it into avcCData for VDADecoder
2534 -            extrasize = m_dllAvFormat->url_close_dyn_buf(pb, &extradata);
2535 +            extrasize = m_dllAvFormat->avio_close_dyn_buf(pb, &extradata);
2536              // CFDataCreate makes a copy of extradata contents
2537              avcCData = CFDataCreate(kCFAllocatorDefault, (const uint8_t*)extradata, extrasize);
2538              // done with the converted extradata, we MUST free using av_free
2539 @@ -948,12 +948,12 @@
2540        int demuxer_bytes;
2541        uint8_t *demuxer_content;
2542
2543 -      if(m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2544 +      if(m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2545        {
2546          return VC_ERROR;
2547        }
2548        demuxer_bytes = avc_parse_nal_units(m_dllAvFormat, pb, pData, iSize);
2549 -      demuxer_bytes = m_dllAvFormat->url_close_dyn_buf(pb, &demuxer_content);
2550 +      demuxer_bytes = m_dllAvFormat->avio_close_dyn_buf(pb, &demuxer_content);
2551        avc_demux = CFDataCreate(kCFAllocatorDefault, demuxer_content, demuxer_bytes);
2552        m_dllAvUtil->av_free(demuxer_content);
2553      }
2554 @@ -961,7 +961,7 @@
2555      {
2556        // convert demuxer packet from 3 byte NAL sizes to 4 byte
2557        ByteIOContext *pb;
2558 -      if (m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2559 +      if (m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2560          return VC_ERROR;
2561
2562        uint32_t nal_size;
2563 @@ -970,14 +970,14 @@
2564        while (nal_start < end)
2565        {
2566          nal_size = VDA_RB24(nal_start);
2567 -        m_dllAvFormat->put_be32(pb, nal_size);
2568 +        m_dllAvFormat->avio_wb32(pb, nal_size);
2569          nal_start += 3;
2570 -        m_dllAvFormat->put_buffer(pb, nal_start, nal_size);
2571 +        m_dllAvFormat->avio_write(pb, nal_start, nal_size);
2572          nal_start += nal_size;
2573        }
2574
2575        uint8_t *demuxer_content;
2576 -      int demuxer_bytes = m_dllAvFormat->url_close_dyn_buf(pb, &demuxer_content);
2577 +      int demuxer_bytes = m_dllAvFormat->avio_close_dyn_buf(pb, &demuxer_content);
2578        avc_demux = CFDataCreate(kCFAllocatorDefault, demuxer_content, demuxer_bytes);
2579        m_dllAvUtil->av_free(demuxer_content);
2580      }
2581 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVideoToolBox.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVideoToolBox.cpp
2582 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVideoToolBox.cpp        2012-03-21 23:07:50.000000000 +0100
2583 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodecVideoToolBox.cpp     2012-11-08 23:16:03.533072250 +0100
2584 @@ -474,7 +474,7 @@
2585      {
2586        b |= 0x80;
2587      }
2588 -    av_format_ctx->put_byte(pb, b);
2589 +    av_format_ctx->avio_w8(pb, b);
2590    }
2591
2592    return numBytes;
2593 @@ -482,37 +482,37 @@
2594
2595  void quicktime_write_esds(DllAvFormat *av_format_ctx, ByteIOContext *pb, quicktime_esds_t *esds)
2596  {
2597 -  av_format_ctx->put_byte(pb, 0);     // Version
2598 -  av_format_ctx->put_be24(pb, 0);     // Flags
2599 +  av_format_ctx->avio_w8(pb, 0);     // Version
2600 +  av_format_ctx->avio_wb24(pb, 0);     // Flags
2601
2602    // elementary stream descriptor tag
2603 -  av_format_ctx->put_byte(pb, 0x03);
2604 +  av_format_ctx->avio_w8(pb, 0x03);
2605    quicktime_write_mp4_descr_length(av_format_ctx, pb,
2606      3 + 5 + (13 + 5 + esds->decoderConfigLen) + 3, false);
2607    // 3 bytes + 5 bytes for tag
2608 -  av_format_ctx->put_be16(pb, esds->esid);
2609 -  av_format_ctx->put_byte(pb, esds->stream_priority);
2610 +  av_format_ctx->avio_wb16(pb, esds->esid);
2611 +  av_format_ctx->avio_w8(pb, esds->stream_priority);
2612
2613    // decoder configuration description tag
2614 -  av_format_ctx->put_byte(pb, 0x04);
2615 +  av_format_ctx->avio_w8(pb, 0x04);
2616    quicktime_write_mp4_descr_length(av_format_ctx, pb,
2617      13 + 5 + esds->decoderConfigLen, false);
2618    // 13 bytes + 5 bytes for tag
2619 -  av_format_ctx->put_byte(pb, esds->objectTypeId); // objectTypeIndication
2620 -  av_format_ctx->put_byte(pb, esds->streamType);   // streamType
2621 -  av_format_ctx->put_be24(pb, esds->bufferSizeDB); // buffer size
2622 -  av_format_ctx->put_be32(pb, esds->maxBitrate);   // max bitrate
2623 -  av_format_ctx->put_be32(pb, esds->avgBitrate);   // average bitrate
2624 +  av_format_ctx->avio_w8(pb, esds->objectTypeId); // objectTypeIndication
2625 +  av_format_ctx->avio_w8(pb, esds->streamType);   // streamType
2626 +  av_format_ctx->avio_wb24(pb, esds->bufferSizeDB); // buffer size
2627 +  av_format_ctx->avio_wb32(pb, esds->maxBitrate);   // max bitrate
2628 +  av_format_ctx->avio_wb32(pb, esds->avgBitrate);   // average bitrate
2629
2630    // decoder specific description tag
2631 -  av_format_ctx->put_byte(pb, 0x05);
2632 +  av_format_ctx->avio_w8(pb, 0x05);
2633    quicktime_write_mp4_descr_length(av_format_ctx, pb, esds->decoderConfigLen, false);
2634 -  av_format_ctx->put_buffer(pb, esds->decoderConfig, esds->decoderConfigLen);
2635 +  av_format_ctx->avio_write(pb, esds->decoderConfig, esds->decoderConfigLen);
2636
2637    // sync layer configuration descriptor tag
2638 -  av_format_ctx->put_byte(pb, 0x06);  // tag
2639 -  av_format_ctx->put_byte(pb, 0x01);  // length
2640 -  av_format_ctx->put_byte(pb, 0x7F);  // no SL
2641 +  av_format_ctx->avio_w8(pb, 0x06);  // tag
2642 +  av_format_ctx->avio_w8(pb, 0x01);  // length
2643 +  av_format_ctx->avio_w8(pb, 0x7F);  // no SL
2644
2645    /* no IPI_DescrPointer */
2646         /* no IP_IdentificationDataSet */
2647 @@ -666,8 +666,8 @@
2648    {
2649      while (!*(nal_start++));
2650      nal_end = avc_find_startcode(nal_start, end);
2651 -    av_format_ctx->put_be32(pb, nal_end - nal_start);
2652 -    av_format_ctx->put_buffer(pb, nal_start, nal_end - nal_start);
2653 +    av_format_ctx->avio_wb32(pb, nal_end - nal_start);
2654 +    av_format_ctx->avio_write(pb, nal_start, nal_end - nal_start);
2655      size += 4 + nal_end - nal_start;
2656      nal_start = nal_end;
2657    }
2658 @@ -678,14 +678,14 @@
2659    const uint8_t *buf_in, uint8_t **buf, int *size)
2660  {
2661    ByteIOContext *pb;
2662 -  int ret = av_format_ctx->url_open_dyn_buf(&pb);
2663 +  int ret = av_format_ctx->avio_open_dyn_buf(&pb);
2664    if (ret < 0)
2665      return ret;
2666
2667    avc_parse_nal_units(av_format_ctx, pb, buf_in, *size);
2668
2669    av_util_ctx->av_freep(buf);
2670 -  *size = av_format_ctx->url_close_dyn_buf(pb, buf);
2671 +  *size = av_format_ctx->avio_close_dyn_buf(pb, buf);
2672    return 0;
2673  }
2674
2675 @@ -770,26 +770,26 @@
2676        }
2677        assert(sps);
2678
2679 -      av_format_ctx->put_byte(pb, 1); /* version */
2680 -      av_format_ctx->put_byte(pb, sps[1]); /* profile */
2681 -      av_format_ctx->put_byte(pb, sps[2]); /* profile compat */
2682 -      av_format_ctx->put_byte(pb, sps[3]); /* level */
2683 -      av_format_ctx->put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
2684 -      av_format_ctx->put_byte(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
2685 +      av_format_ctx->avio_w8(pb, 1); /* version */
2686 +      av_format_ctx->avio_w8(pb, sps[1]); /* profile */
2687 +      av_format_ctx->avio_w8(pb, sps[2]); /* profile compat */
2688 +      av_format_ctx->avio_w8(pb, sps[3]); /* level */
2689 +      av_format_ctx->avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
2690 +      av_format_ctx->avio_w8(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
2691
2692 -      av_format_ctx->put_be16(pb, sps_size);
2693 -      av_format_ctx->put_buffer(pb, sps, sps_size);
2694 +      av_format_ctx->avio_wb16(pb, sps_size);
2695 +      av_format_ctx->avio_write(pb, sps, sps_size);
2696        if (pps)
2697        {
2698 -        av_format_ctx->put_byte(pb, 1); /* number of pps */
2699 -        av_format_ctx->put_be16(pb, pps_size);
2700 -        av_format_ctx->put_buffer(pb, pps, pps_size);
2701 +        av_format_ctx->avio_w8(pb, 1); /* number of pps */
2702 +        av_format_ctx->avio_wb16(pb, pps_size);
2703 +        av_format_ctx->avio_write(pb, pps, pps_size);
2704        }
2705        av_util_ctx->av_free(start);
2706      }
2707      else
2708      {
2709 -      av_format_ctx->put_buffer(pb, data, len);
2710 +      av_format_ctx->avio_write(pb, data, len);
2711      }
2712    }
2713    return 0;
2714 @@ -1086,7 +1086,7 @@
2715            ByteIOContext *pb;
2716            quicktime_esds_t *esds;
2717
2718 -          if (m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2719 +          if (m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2720              return false;
2721
2722            esds = quicktime_set_esds(m_dllAvFormat, extradata, extrasize);
2723 @@ -1095,7 +1095,7 @@
2724            // unhook from ffmpeg's extradata
2725            extradata = NULL;
2726            // extract the esds atom decoderConfig from extradata
2727 -          extrasize = m_dllAvFormat->url_close_dyn_buf(pb, &extradata);
2728 +          extrasize = m_dllAvFormat->avio_close_dyn_buf(pb, &extradata);
2729            free(esds->decoderConfig);
2730            free(esds);
2731
2732 @@ -1152,7 +1152,7 @@
2733              // NAL reformating to bitstream format required
2734
2735              ByteIOContext *pb;
2736 -            if (m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2737 +            if (m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2738                return false;
2739
2740              m_convert_bytestream = true;
2741 @@ -1161,7 +1161,7 @@
2742              // unhook from ffmpeg's extradata
2743              extradata = NULL;
2744              // extract the avcC atom data into extradata getting size into extrasize
2745 -            extrasize = m_dllAvFormat->url_close_dyn_buf(pb, &extradata);
2746 +            extrasize = m_dllAvFormat->avio_close_dyn_buf(pb, &extradata);
2747
2748              // check for interlaced and get number of ref frames
2749              if (!validate_avcC_spc(extradata, extrasize, &m_max_ref_frames))
2750 @@ -1301,17 +1301,17 @@
2751      if (m_convert_bytestream)
2752      {
2753        // convert demuxer packet from bytestream (AnnexB) to bitstream
2754 -      if(m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2755 +      if(m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2756          return VC_ERROR;
2757
2758        demux_size = avc_parse_nal_units(m_dllAvFormat, pb, pData, iSize);
2759 -      demux_size = m_dllAvFormat->url_close_dyn_buf(pb, &demux_buff);
2760 +      demux_size = m_dllAvFormat->avio_close_dyn_buf(pb, &demux_buff);
2761        sampleBuff = CreateSampleBufferFrom(m_fmt_desc, demux_buff, demux_size);
2762      }
2763      else if (m_convert_3byteTo4byteNALSize)
2764      {
2765        // convert demuxer packet from 3 byte NAL sizes to 4 byte
2766 -      if (m_dllAvFormat->url_open_dyn_buf(&pb) < 0)
2767 +      if (m_dllAvFormat->avio_open_dyn_buf(&pb) < 0)
2768          return VC_ERROR;
2769
2770        uint32_t nal_size;
2771 @@ -1320,13 +1320,13 @@
2772        while (nal_start < end)
2773        {
2774          nal_size = VDA_RB24(nal_start);
2775 -        m_dllAvFormat->put_be32(pb, nal_size);
2776 +        m_dllAvFormat->avio_wb32(pb, nal_size);
2777          nal_start += 3;
2778 -        m_dllAvFormat->put_buffer(pb, nal_start, nal_size);
2779 +        m_dllAvFormat->avio_write(pb, nal_start, nal_size);
2780          nal_start += nal_size;
2781        }
2782
2783 -      demux_size = m_dllAvFormat->url_close_dyn_buf(pb, &demux_buff);
2784 +      demux_size = m_dllAvFormat->avio_close_dyn_buf(pb, &demux_buff);
2785        sampleBuff = CreateSampleBufferFrom(m_fmt_desc, demux_buff, demux_size);
2786      }
2787      else
2788 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp
2789 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp    2012-03-21 23:07:50.000000000 +0100
2790 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp 2012-11-08 23:16:03.533072250 +0100
2791 @@ -223,7 +223,6 @@
2792    }
2793
2794    pic->type           = FF_BUFFER_TYPE_USER;
2795 -  pic->age            = 1;
2796    pic->data[0]        = (uint8_t*)wrapper;
2797    pic->data[1]        = NULL;
2798    pic->data[2]        = NULL;
2799 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp
2800 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp    2012-03-21 23:07:50.000000000 +0100
2801 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp 2012-11-08 23:16:03.533072250 +0100
2802 @@ -1197,14 +1197,12 @@
2803
2804    if(pic->reference)
2805    {
2806 -    pic->age = pA->ip_age[0];
2807      pA->ip_age[0]= pA->ip_age[1]+1;
2808      pA->ip_age[1]= 1;
2809      pA->b_age++;
2810    }
2811    else
2812    {
2813 -    pic->age = pA->b_age;
2814      pA->ip_age[0]++;
2815      pA->ip_age[1]++;
2816      pA->b_age = 1;
2817 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.cpp xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.cpp
2818 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.cpp       2012-03-21 23:07:50.000000000 +0100
2819 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.cpp    2012-11-08 23:16:03.533072250 +0100
2820 @@ -160,7 +160,7 @@
2821  #define g_demuxer (*((CDVDDemuxFFmpeg**)g_tls.Get()))
2822  #endif
2823
2824 -static int interrupt_cb(void)
2825 +static int interrupt_cb(void* unused)
2826  {
2827    if(g_demuxer && g_demuxer->Aborted())
2828      return 1;
2829 @@ -178,7 +178,7 @@
2830
2831  static int dvd_file_read(void *h, uint8_t* buf, int size)
2832  {
2833 -  if(interrupt_cb())
2834 +  if(interrupt_cb(NULL))
2835      return -1;
2836
2837    CDVDInputStream* pInputStream = (CDVDInputStream*)h;
2838 @@ -192,7 +192,7 @@
2839  */
2840  static offset_t dvd_file_seek(void *h, offset_t pos, int whence)
2841  {
2842 -  if(interrupt_cb())
2843 +  if(interrupt_cb(NULL))
2844      return -1;
2845
2846    CDVDInputStream* pInputStream = (CDVDInputStream*)h;
2847 @@ -236,6 +236,7 @@
2848    m_speed = DVD_PLAYSPEED_NORMAL;
2849    g_demuxer = this;
2850    m_program = UINT_MAX;
2851 +  const AVIOInterruptCB int_cb = { interrupt_cb, NULL };
2852
2853    if (!pInput) return false;
2854
2855 @@ -246,10 +247,6 @@
2856
2857    // register codecs
2858    m_dllAvFormat.av_register_all();
2859 -  m_dllAvFormat.url_set_interrupt_cb(interrupt_cb);
2860 -
2861 -  // could be used for interupting ffmpeg while opening a file (eg internet streams)
2862 -  // url_set_interrupt_cb(NULL);
2863
2864    m_pInput = pInput;
2865    strFile = m_pInput->GetFileName();
2866 @@ -284,14 +281,14 @@
2867        // try mmsh, then mmst
2868        CStdString strFile2;
2869        strFile2.Format("mmsh://%s",strFile.substr(6,strFile.size()-6).c_str());
2870 -      result = m_dllAvFormat.av_open_input_file(&m_pFormatContext, strFile2.c_str(), iformat, FFMPEG_FILE_BUFFER_SIZE, NULL);
2871 +      result = m_dllAvFormat.avformat_open_input(&m_pFormatContext, strFile2.c_str(), iformat, NULL);
2872        if (result < 0)
2873        {
2874          strFile = "mmst://";
2875          strFile += strFile2.Mid(7).c_str();
2876        }
2877      }
2878 -    if (result < 0 && m_dllAvFormat.av_open_input_file(&m_pFormatContext, strFile.c_str(), iformat, FFMPEG_FILE_BUFFER_SIZE, NULL) < 0 )
2879 +    if (result < 0 && m_dllAvFormat.avformat_open_input(&m_pFormatContext, strFile.c_str(), iformat, NULL) < 0 )
2880      {
2881        CLog::Log(LOGDEBUG, "Error, could not open file %s", strFile.c_str());
2882        Dispose();
2883 @@ -301,24 +298,16 @@
2884    else
2885    {
2886      unsigned char* buffer = (unsigned char*)m_dllAvUtil.av_malloc(FFMPEG_FILE_BUFFER_SIZE);
2887 -    m_ioContext = m_dllAvFormat.av_alloc_put_byte(buffer, FFMPEG_FILE_BUFFER_SIZE, 0, m_pInput, dvd_file_read, NULL, dvd_file_seek);
2888 +    m_ioContext = m_dllAvFormat.avio_alloc_context(buffer, FFMPEG_FILE_BUFFER_SIZE, 0, m_pInput, dvd_file_read, NULL, dvd_file_seek);
2889      m_ioContext->max_packet_size = m_pInput->GetBlockSize();
2890      if(m_ioContext->max_packet_size)
2891        m_ioContext->max_packet_size *= FFMPEG_FILE_BUFFER_SIZE / m_ioContext->max_packet_size;
2892
2893      if(m_pInput->Seek(0, SEEK_POSSIBLE) == 0)
2894 -      m_ioContext->is_streamed = 1;
2895 +      m_ioContext->seekable = 0;
2896
2897      if( iformat == NULL )
2898      {
2899 -#if defined(USE_EXTERNAL_FFMPEG) && LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(52,98,0)
2900 -      // API added on: 2011-02-09
2901 -      // Old versions of ffmpeg do not have av_probe_input_format, so we need
2902 -      // to always probe using the lower-level functions as well.
2903 -      const bool legacyProbing = true;
2904 -#else
2905 -      const bool legacyProbing = false;
2906 -#endif
2907        // let ffmpeg decide which demuxer we have to open
2908
2909        bool trySPDIFonly = (m_pInput->GetContent() == "audio/x-spdif-compressed");
2910 @@ -331,7 +320,7 @@
2911        // want to probe for spdif (DTS or IEC 61937) compressed audio
2912        // specifically, or in case the file is a wav which may contain DTS or
2913        // IEC 61937 (e.g. ac3-in-wav) and we want to check for those formats.
2914 -      if (legacyProbing || trySPDIFonly || (iformat && strcmp(iformat->name, "wav") == 0))
2915 +      if (trySPDIFonly || (iformat && strcmp(iformat->name, "wav") == 0))
2916        {
2917          AVProbeData pd;
2918          BYTE probe_buffer[FFMPEG_FILE_BUFFER_SIZE + AVPROBE_PADDING_SIZE];
2919 @@ -341,7 +330,7 @@
2920          pd.filename = strFile.c_str();
2921
2922          // read data using avformat's buffers
2923 -        pd.buf_size = m_dllAvFormat.get_buffer(m_ioContext, pd.buf, m_ioContext->max_packet_size ? m_ioContext->max_packet_size : m_ioContext->buffer_size);
2924 +        pd.buf_size = m_dllAvFormat.avio_read(m_ioContext, pd.buf, m_ioContext->max_packet_size ? m_ioContext->max_packet_size : m_ioContext->buffer_size);
2925          if (pd.buf_size <= 0)
2926          {
2927            CLog::Log(LOGERROR, "%s - error reading from input stream, %s", __FUNCTION__, strFile.c_str());
2928 @@ -350,10 +339,7 @@
2929          memset(pd.buf+pd.buf_size, 0, AVPROBE_PADDING_SIZE);
2930
2931          // restore position again
2932 -        m_dllAvFormat.url_fseek(m_ioContext , 0, SEEK_SET);
2933 -
2934 -        if (legacyProbing && !trySPDIFonly)
2935 -          iformat = m_dllAvFormat.av_probe_input_format(&pd, 1);
2936 +        m_dllAvFormat.avio_seek(m_ioContext , 0, SEEK_SET);
2937
2938          // the advancedsetting is for allowing the user to force outputting the
2939          // 44.1 kHz DTS wav file as PCM, so that an A/V receiver can decode
2940 @@ -424,7 +410,10 @@
2941
2942
2943      // open the demuxer
2944 -    if (m_dllAvFormat.av_open_input_stream(&m_pFormatContext, m_ioContext, strFile.c_str(), iformat, NULL) < 0)
2945 +    m_pFormatContext     = m_dllAvFormat.avformat_alloc_context();
2946 +    m_pFormatContext->pb = m_ioContext;
2947 +
2948 +    if (m_dllAvFormat.avformat_open_input(&m_pFormatContext, strFile.c_str(), iformat, NULL) < 0)
2949      {
2950        CLog::Log(LOGERROR, "%s - Error, could not open file %s", __FUNCTION__, strFile.c_str());
2951        Dispose();
2952 @@ -432,8 +421,11 @@
2953      }
2954    }
2955
2956 +  // set the interrupt callback, appeared in libavformat 53.15.0
2957 +  m_pFormatContext->interrupt_callback = int_cb;
2958 +
2959    // analyse very short to speed up mjpeg playback start
2960 -  if (iformat && (strcmp(iformat->name, "mjpeg") == 0) && m_ioContext->is_streamed)
2961 +  if (iformat && (strcmp(iformat->name, "mjpeg") == 0) && m_ioContext->seekable == 0)
2962      m_pFormatContext->max_analyze_duration = 500000;
2963
2964    // we need to know if this is matroska or avi later
2965 @@ -447,8 +439,8 @@
2966        m_pFormatContext->max_analyze_duration = 500000;
2967
2968
2969 -    CLog::Log(LOGDEBUG, "%s - av_find_stream_info starting", __FUNCTION__);
2970 -    int iErr = m_dllAvFormat.av_find_stream_info(m_pFormatContext);
2971 +    CLog::Log(LOGDEBUG, "%s - avformat_find_stream_info starting", __FUNCTION__);
2972 +    int iErr = m_dllAvFormat.avformat_find_stream_info(m_pFormatContext, NULL);
2973      if (iErr < 0)
2974      {
2975        CLog::Log(LOGWARNING,"could not find codec parameters for %s", strFile.c_str());
2976 @@ -471,7 +463,7 @@
2977    m_pFormatContext->flags |= AVFMT_FLAG_NONBLOCK;
2978
2979    // print some extra information
2980 -  m_dllAvFormat.dump_format(m_pFormatContext, 0, strFile.c_str(), 0);
2981 +  m_dllAvFormat.av_dump_format(m_pFormatContext, 0, strFile.c_str(), 0);
2982
2983    UpdateCurrentPTS();
2984
2985 @@ -510,20 +502,12 @@
2986
2987    if (m_pFormatContext)
2988    {
2989 -    if (m_ioContext)
2990 +    if (m_ioContext && m_pFormatContext->pb && m_pFormatContext->pb != m_ioContext)
2991      {
2992 -      if(m_pFormatContext->pb && m_pFormatContext->pb != m_ioContext)
2993 -      {
2994 -        CLog::Log(LOGWARNING, "CDVDDemuxFFmpeg::Dispose - demuxer changed our byte context behind our back, possible memleak");
2995 -        m_ioContext = m_pFormatContext->pb;
2996 -      }
2997 -      m_dllAvFormat.av_close_input_stream(m_pFormatContext);
2998 -      if (m_ioContext->buffer)
2999 -        m_dllAvUtil.av_free(m_ioContext->buffer);
3000 -      m_dllAvUtil.av_free(m_ioContext);
3001 +      CLog::Log(LOGWARNING, "CDVDDemuxFFmpeg::Dispose - demuxer changed our byte context behind our back, possible memleak");
3002 +      m_ioContext = m_pFormatContext->pb;
3003      }
3004 -    else
3005 -      m_dllAvFormat.av_close_input_file(m_pFormatContext);
3006 +    m_dllAvFormat.avformat_close_input(&m_pFormatContext);
3007    }
3008    m_ioContext = NULL;
3009    m_pFormatContext = NULL;
3010 @@ -773,19 +757,12 @@
3011            {
3012              stream->duration = duration;
3013              duration = m_dllAvUtil.av_rescale_rnd(stream->duration, (int64_t)stream->time_base.num * AV_TIME_BASE, stream->time_base.den, AV_ROUND_NEAR_INF);
3014 -            if ((m_pFormatContext->duration == (int64_t)AV_NOPTS_VALUE && m_pFormatContext->file_size > 0)
3015 +            if ((m_pFormatContext->duration == (int64_t)AV_NOPTS_VALUE)
3016                  ||  (m_pFormatContext->duration != (int64_t)AV_NOPTS_VALUE && duration > m_pFormatContext->duration))
3017                m_pFormatContext->duration = duration;
3018            }
3019          }
3020
3021 -        // check if stream seem to have grown since start
3022 -        if(m_pFormatContext->file_size > 0 && m_pFormatContext->pb)
3023 -        {
3024 -          if(m_pFormatContext->pb->pos > m_pFormatContext->file_size)
3025 -            m_pFormatContext->file_size = m_pFormatContext->pb->pos;
3026 -        }
3027 -
3028          pPacket->iStreamId = pkt.stream_index; // XXX just for now
3029        }
3030        m_dllAvCodec.av_free_packet(&pkt);
3031 @@ -923,19 +900,6 @@
3032    if (!m_pFormatContext)
3033      return 0;
3034
3035 -  /* apperently ffmpeg messes up sometimes, so check for negative value too */
3036 -  if (m_pFormatContext->duration == (int64_t)AV_NOPTS_VALUE || m_pFormatContext->duration < 0LL)
3037 -  {
3038 -    // no duration is available for us
3039 -    // try to calculate it
3040 -    int iLength = 0;
3041 -    if (m_iCurrentPts != DVD_NOPTS_VALUE && m_pFormatContext->file_size > 0 && m_pFormatContext->pb && m_pFormatContext->pb->pos > 0)
3042 -    {
3043 -      iLength = (int)(((m_iCurrentPts * m_pFormatContext->file_size) / m_pFormatContext->pb->pos) / 1000) & 0xFFFFFFFF;
3044 -    }
3045 -    return iLength;
3046 -  }
3047 -
3048    return (int)(m_pFormatContext->duration / (AV_TIME_BASE / 1000));
3049  }
3050
3051 @@ -987,8 +951,8 @@
3052          st->iBitRate = pStream->codec->bit_rate;
3053          st->iBitsPerSample = pStream->codec->bits_per_coded_sample;
3054
3055 -        if(m_dllAvFormat.av_metadata_get(pStream->metadata, "title", NULL, 0))
3056 -          st->m_description = m_dllAvFormat.av_metadata_get(pStream->metadata, "title", NULL, 0)->value;
3057 +        if(m_dllAvUtil.av_dict_get(pStream->metadata, "title", NULL, 0))
3058 +          st->m_description = m_dllAvUtil.av_dict_get(pStream->metadata, "title", NULL, 0)->value;
3059
3060          break;
3061        }
3062 @@ -1077,8 +1041,8 @@
3063            if(pStream->codec)
3064              st->identifier = pStream->codec->sub_id;
3065
3066 -          if(m_dllAvFormat.av_metadata_get(pStream->metadata, "title", NULL, 0))
3067 -            st->m_description = m_dllAvFormat.av_metadata_get(pStream->metadata, "title", NULL, 0)->value;
3068 +          if(m_dllAvUtil.av_dict_get(pStream->metadata, "title", NULL, 0))
3069 +            st->m_description = m_dllAvUtil.av_dict_get(pStream->metadata, "title", NULL, 0)->value;
3070
3071            break;
3072          }
3073 @@ -1089,7 +1053,7 @@
3074          {
3075            std::string fileName = "special://temp/fonts/";
3076            XFILE::CDirectory::Create(fileName);
3077 -          AVMetadataTag *nameTag = m_dllAvFormat.av_metadata_get(pStream->metadata, "filename", NULL, 0);
3078 +          AVDictionaryEntry *nameTag = m_dllAvUtil.av_dict_get(pStream->metadata, "filename", NULL, 0);
3079            if (!nameTag) {
3080              CLog::Log(LOGERROR, "%s: TTF attachment has no name", __FUNCTION__);
3081              break;
3082 @@ -1138,7 +1102,7 @@
3083      // API added on: 2010-10-15
3084      // (Note that while the function was available earlier, the generic
3085      // metadata tags were not populated by default)
3086 -    AVMetadataTag *langTag = m_dllAvFormat.av_metadata_get(pStream->metadata, "language", NULL, 0);
3087 +    AVDictionaryEntry *langTag = m_dllAvUtil.av_dict_get(pStream->metadata, "language", NULL, 0);
3088      if (langTag)
3089        strncpy(m_streams[iId]->language, langTag->value, 3);
3090  #else
3091 @@ -1248,7 +1212,7 @@
3092        // API added on: 2010-10-15
3093        // (Note that while the function was available earlier, the generic
3094        // metadata tags were not populated by default)
3095 -      AVMetadataTag *titleTag = m_dllAvFormat.av_metadata_get(m_pFormatContext->chapters[chapterIdx-1]->metadata,
3096 +      AVDictionaryEntry *titleTag = m_dllAvUtil.av_dict_get(m_pFormatContext->chapters[chapterIdx-1]->metadata,
3097                                                                "title", NULL, 0);
3098        if (titleTag)
3099          strChapterName = titleTag->value;
3100 diff -urN xbmc-11.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.h xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.h
3101 --- xbmc-11.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.h 2012-03-21 23:07:50.000000000 +0100
3102 +++ xbmc-11.0-ffmpeg-1.0/xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxFFmpeg.h      2012-11-08 23:16:03.533072250 +0100
3103 @@ -128,7 +128,7 @@
3104    #define MAX_STREAMS 100
3105    CDemuxStream* m_streams[MAX_STREAMS]; // maximum number of streams that ffmpeg can handle
3106
3107 -  ByteIOContext* m_ioContext;
3108 +  AVIOContext* m_ioContext;
3109
3110    DllAvFormat m_dllAvFormat;
3111    DllAvCodec  m_dllAvCodec;
3112 diff -urN xbmc-11.0/xbmc/DllPaths_generated.h.in xbmc-11.0-ffmpeg-1.0/xbmc/DllPaths_generated.h.in
3113 --- xbmc-11.0/xbmc/DllPaths_generated.h.in      2012-03-21 23:07:50.000000000 +0100
3114 +++ xbmc-11.0-ffmpeg-1.0/xbmc/DllPaths_generated.h.in   2012-11-08 23:15:55.399739205 +0100
3115 @@ -74,13 +74,13 @@
3116  #define DLL_PATH_LIBMAD        "@MAD_SONAME@"
3117
3118  /* ffmpeg */
3119 -#define DLL_PATH_LIBAVCODEC    "special://xbmcbin/system/players/dvdplayer/avcodec-52-@ARCH@.so"
3120 -#define DLL_PATH_LIBAVCORE     "special://xbmcbin/system/players/dvdplayer/avcore-0-@ARCH@.so"
3121 -#define DLL_PATH_LIBAVFORMAT   "special://xbmcbin/system/players/dvdplayer/avformat-52-@ARCH@.so"
3122 -#define DLL_PATH_LIBAVUTIL     "special://xbmcbin/system/players/dvdplayer/avutil-50-@ARCH@.so"
3123 -#define DLL_PATH_LIBPOSTPROC   "special://xbmcbin/system/players/dvdplayer/postproc-51-@ARCH@.so"
3124 -#define DLL_PATH_LIBSWSCALE    "special://xbmcbin/system/players/dvdplayer/swscale-0-@ARCH@.so"
3125 -#define DLL_PATH_LIBAVFILTER   "special://xbmcbin/system/players/dvdplayer/avfilter-1-@ARCH@.so"
3126 +#define DLL_PATH_LIBAVCODEC    "special://xbmcbin/system/players/dvdplayer/avcodec-53-@ARCH@.so"
3127 +#define DLL_PATH_LIBAVFORMAT   "special://xbmcbin/system/players/dvdplayer/avformat-53-@ARCH@.so"
3128 +#define DLL_PATH_LIBAVUTIL     "special://xbmcbin/system/players/dvdplayer/avutil-51-@ARCH@.so"
3129 +#define DLL_PATH_LIBPOSTPROC   "special://xbmcbin/system/players/dvdplayer/postproc-52-@ARCH@.so"
3130 +#define DLL_PATH_LIBSWSCALE    "special://xbmcbin/system/players/dvdplayer/swscale-2-@ARCH@.so"
3131 +#define DLL_PATH_LIBAVFILTER   "special://xbmcbin/system/players/dvdplayer/avfilter-2-@ARCH@.so"
3132 +#define DLL_PATH_LIBSWRESAMPLE "special://xbmcbin/system/players/dvdplayer/swresample-0-@ARCH@.so"
3133
3134  /* cdrip */
3135  #if defined(_LINUX) && !defined(__APPLE__)
3136 diff -urN xbmc-11.0/xbmc/DllPaths_win32.h xbmc-11.0-ffmpeg-1.0/xbmc/DllPaths_win32.h
3137 --- xbmc-11.0/xbmc/DllPaths_win32.h     2012-03-21 23:07:50.000000000 +0100
3138 +++ xbmc-11.0-ffmpeg-1.0/xbmc/DllPaths_win32.h  2012-11-08 23:15:55.399739205 +0100
3139 @@ -58,13 +58,13 @@
3140  #define DLL_PATH_LIBRTMP       "special://xbmcbin/system/players/dvdplayer/librtmp.dll"
3141
3142  /* ffmpeg */
3143 -#define DLL_PATH_LIBAVCODEC    "special://xbmcbin/system/players/dvdplayer/avcodec-52.dll"
3144 -#define DLL_PATH_LIBAVCORE     "special://xbmcbin/system/players/dvdplayer/avcore-0.dll"
3145 -#define DLL_PATH_LIBAVFORMAT   "special://xbmcbin/system/players/dvdplayer/avformat-52.dll"
3146 -#define DLL_PATH_LIBAVUTIL     "special://xbmcbin/system/players/dvdplayer/avutil-50.dll"
3147 -#define DLL_PATH_LIBAVFILTER   "special://xbmcbin/system/players/dvdplayer/avfilter-1.dll"
3148 -#define DLL_PATH_LIBPOSTPROC   "special://xbmcbin/system/players/dvdplayer/postproc-51.dll"
3149 -#define DLL_PATH_LIBSWSCALE    "special://xbmcbin/system/players/dvdplayer/swscale-0.dll"
3150 +#define DLL_PATH_LIBAVCODEC    "special://xbmcbin/system/players/dvdplayer/avcodec-53.dll"
3151 +#define DLL_PATH_LIBAVFORMAT   "special://xbmcbin/system/players/dvdplayer/avformat-53.dll"
3152 +#define DLL_PATH_LIBAVUTIL     "special://xbmcbin/system/players/dvdplayer/avutil-51.dll"
3153 +#define DLL_PATH_LIBAVFILTER   "special://xbmcbin/system/players/dvdplayer/avfilter-2.dll"
3154 +#define DLL_PATH_LIBPOSTPROC   "special://xbmcbin/system/players/dvdplayer/postproc-52.dll"
3155 +#define DLL_PATH_LIBSWSCALE    "special://xbmcbin/system/players/dvdplayer/swscale-2.dll"
3156 +#define DLL_PATH_LIBSWRESAMPLE "special://xbmcbin/system/players/dvdplayer/swresample-0.dll"
3157
3158  /* cdrip */
3159  #define DLL_PATH_LAME_ENC      "special://xbmcbin/system/cdrip/lame_enc.dll"