Attachment #177530 for bug #214896




--- fmt-conversion.c.orig	2013-07-09 16:33:12 UTC
+++ fmt-conversion.c
@@ -24,117 +24,117 @@
 
 static const struct {
     int fmt;
-    enum PixelFormat pix_fmt;
+    enum AVPixelFormat pix_fmt;
 } conversion_map[] = {
-    {IMGFMT_ARGB, PIX_FMT_ARGB},
-    {IMGFMT_BGRA, PIX_FMT_BGRA},
-    {IMGFMT_BGR24, PIX_FMT_BGR24},
-    {IMGFMT_BGR16BE, PIX_FMT_RGB565BE},
-    {IMGFMT_BGR16LE, PIX_FMT_RGB565LE},
-    {IMGFMT_BGR15BE, PIX_FMT_RGB555BE},
-    {IMGFMT_BGR15LE, PIX_FMT_RGB555LE},
-    {IMGFMT_BGR12BE, PIX_FMT_RGB444BE},
-    {IMGFMT_BGR12LE, PIX_FMT_RGB444LE},
-    {IMGFMT_BGR8,  PIX_FMT_RGB8},
-    {IMGFMT_BGR4,  PIX_FMT_RGB4},
-    {IMGFMT_BGR1,  PIX_FMT_MONOBLACK},
-    {IMGFMT_RGB1,  PIX_FMT_MONOBLACK},
-    {IMGFMT_RG4B,  PIX_FMT_BGR4_BYTE},
-    {IMGFMT_BG4B,  PIX_FMT_RGB4_BYTE},
-    {IMGFMT_RGB48LE, PIX_FMT_RGB48LE},
-    {IMGFMT_RGB48BE, PIX_FMT_RGB48BE},
-    {IMGFMT_ABGR, PIX_FMT_ABGR},
-    {IMGFMT_RGBA, PIX_FMT_RGBA},
-    {IMGFMT_RGB24, PIX_FMT_RGB24},
-    {IMGFMT_RGB16BE, PIX_FMT_BGR565BE},
-    {IMGFMT_RGB16LE, PIX_FMT_BGR565LE},
-    {IMGFMT_RGB15BE, PIX_FMT_BGR555BE},
-    {IMGFMT_RGB15LE, PIX_FMT_BGR555LE},
-    {IMGFMT_RGB12BE, PIX_FMT_BGR444BE},
-    {IMGFMT_RGB12LE, PIX_FMT_BGR444LE},
-    {IMGFMT_RGB8,  PIX_FMT_BGR8},
-    {IMGFMT_RGB4,  PIX_FMT_BGR4},
-    {IMGFMT_BGR8,  PIX_FMT_PAL8},
-    {IMGFMT_GBRP,  PIX_FMT_GBRP},
-    {IMGFMT_GBRP9, PIX_FMT_GBRP9},
-    {IMGFMT_GBRP10, PIX_FMT_GBRP10},
-    {IMGFMT_YUY2,  PIX_FMT_YUYV422},
-    {IMGFMT_UYVY,  PIX_FMT_UYVY422},
-    {IMGFMT_NV12,  PIX_FMT_NV12},
-    {IMGFMT_NV21,  PIX_FMT_NV21},
-    {IMGFMT_Y800,  PIX_FMT_GRAY8},
-    {IMGFMT_Y8,    PIX_FMT_GRAY8},
-    {IMGFMT_YVU9,  PIX_FMT_YUV410P},
-    {IMGFMT_IF09,  PIX_FMT_YUV410P},
-    {IMGFMT_YV12,  PIX_FMT_YUV420P},
-    {IMGFMT_I420,  PIX_FMT_YUV420P},
-    {IMGFMT_IYUV,  PIX_FMT_YUV420P},
-    {IMGFMT_411P,  PIX_FMT_YUV411P},
-    {IMGFMT_422P,  PIX_FMT_YUV422P},
-    {IMGFMT_444P,  PIX_FMT_YUV444P},
-    {IMGFMT_440P,  PIX_FMT_YUV440P},
+    {IMGFMT_ARGB, AV_PIX_FMT_ARGB},
+    {IMGFMT_BGRA, AV_PIX_FMT_BGRA},
+    {IMGFMT_BGR24, AV_PIX_FMT_BGR24},
+    {IMGFMT_BGR16BE, AV_PIX_FMT_RGB565BE},
+    {IMGFMT_BGR16LE, AV_PIX_FMT_RGB565LE},
+    {IMGFMT_BGR15BE, AV_PIX_FMT_RGB555BE},
+    {IMGFMT_BGR15LE, AV_PIX_FMT_RGB555LE},
+    {IMGFMT_BGR12BE, AV_PIX_FMT_RGB444BE},
+    {IMGFMT_BGR12LE, AV_PIX_FMT_RGB444LE},
+    {IMGFMT_BGR8,  AV_PIX_FMT_RGB8},
+    {IMGFMT_BGR4,  AV_PIX_FMT_RGB4},
+    {IMGFMT_BGR1,  AV_PIX_FMT_MONOBLACK},
+    {IMGFMT_RGB1,  AV_PIX_FMT_MONOBLACK},
+    {IMGFMT_RG4B,  AV_PIX_FMT_BGR4_BYTE},
+    {IMGFMT_BG4B,  AV_PIX_FMT_RGB4_BYTE},
+    {IMGFMT_RGB48LE, AV_PIX_FMT_RGB48LE},
+    {IMGFMT_RGB48BE, AV_PIX_FMT_RGB48BE},
+    {IMGFMT_ABGR, AV_PIX_FMT_ABGR},
+    {IMGFMT_RGBA, AV_PIX_FMT_RGBA},
+    {IMGFMT_RGB24, AV_PIX_FMT_RGB24},
+    {IMGFMT_RGB16BE, AV_PIX_FMT_BGR565BE},
+    {IMGFMT_RGB16LE, AV_PIX_FMT_BGR565LE},
+    {IMGFMT_RGB15BE, AV_PIX_FMT_BGR555BE},
+    {IMGFMT_RGB15LE, AV_PIX_FMT_BGR555LE},
+    {IMGFMT_RGB12BE, AV_PIX_FMT_BGR444BE},
+    {IMGFMT_RGB12LE, AV_PIX_FMT_BGR444LE},
+    {IMGFMT_RGB8,  AV_PIX_FMT_BGR8},
+    {IMGFMT_RGB4,  AV_PIX_FMT_BGR4},
+    {IMGFMT_BGR8,  AV_PIX_FMT_PAL8},
+    {IMGFMT_GBRP,  AV_PIX_FMT_GBRP},
+    {IMGFMT_GBRP9, AV_PIX_FMT_GBRP9},
+    {IMGFMT_GBRP10, AV_PIX_FMT_GBRP10},
+    {IMGFMT_YUY2,  AV_PIX_FMT_YUYV422},
+    {IMGFMT_UYVY,  AV_PIX_FMT_UYVY422},
+    {IMGFMT_NV12,  AV_PIX_FMT_NV12},
+    {IMGFMT_NV21,  AV_PIX_FMT_NV21},
+    {IMGFMT_Y800,  AV_PIX_FMT_GRAY8},
+    {IMGFMT_Y8,    AV_PIX_FMT_GRAY8},
+    {IMGFMT_YVU9,  AV_PIX_FMT_YUV410P},
+    {IMGFMT_IF09,  AV_PIX_FMT_YUV410P},
+    {IMGFMT_YV12,  AV_PIX_FMT_YUV420P},
+    {IMGFMT_I420,  AV_PIX_FMT_YUV420P},
+    {IMGFMT_IYUV,  AV_PIX_FMT_YUV420P},
+    {IMGFMT_411P,  AV_PIX_FMT_YUV411P},
+    {IMGFMT_422P,  AV_PIX_FMT_YUV422P},
+    {IMGFMT_444P,  AV_PIX_FMT_YUV444P},
+    {IMGFMT_440P,  AV_PIX_FMT_YUV440P},
 
-    {IMGFMT_420A,  PIX_FMT_YUVA420P},
+    {IMGFMT_420A,  AV_PIX_FMT_YUVA420P},
 
-    {IMGFMT_420P16_LE,  PIX_FMT_YUV420P16LE},
-    {IMGFMT_420P16_BE,  PIX_FMT_YUV420P16BE},
-    {IMGFMT_420P9_LE,   PIX_FMT_YUV420P9LE},
-    {IMGFMT_420P9_BE,   PIX_FMT_YUV420P9BE},
-    {IMGFMT_420P10_LE,  PIX_FMT_YUV420P10LE},
-    {IMGFMT_420P10_BE,  PIX_FMT_YUV420P10BE},
-    {IMGFMT_422P10_LE,  PIX_FMT_YUV422P10LE},
-    {IMGFMT_422P10_BE,  PIX_FMT_YUV422P10BE},
-    {IMGFMT_444P9_BE ,  PIX_FMT_YUV444P9BE},
-    {IMGFMT_444P9_LE ,  PIX_FMT_YUV444P9LE},
-    {IMGFMT_444P10_BE,  PIX_FMT_YUV444P10BE},
-    {IMGFMT_444P10_LE,  PIX_FMT_YUV444P10LE},
-    {IMGFMT_422P16_LE,  PIX_FMT_YUV422P16LE},
-    {IMGFMT_422P16_BE,  PIX_FMT_YUV422P16BE},
-    {IMGFMT_422P9_LE,   PIX_FMT_YUV422P9LE},
-    {IMGFMT_422P9_BE,   PIX_FMT_YUV422P9BE},
-    {IMGFMT_444P16_LE,  PIX_FMT_YUV444P16LE},
-    {IMGFMT_444P16_BE,  PIX_FMT_YUV444P16BE},
+    {IMGFMT_420P16_LE,  AV_PIX_FMT_YUV420P16LE},
+    {IMGFMT_420P16_BE,  AV_PIX_FMT_YUV420P16BE},
+    {IMGFMT_420P9_LE,   AV_PIX_FMT_YUV420P9LE},
+    {IMGFMT_420P9_BE,   AV_PIX_FMT_YUV420P9BE},
+    {IMGFMT_420P10_LE,  AV_PIX_FMT_YUV420P10LE},
+    {IMGFMT_420P10_BE,  AV_PIX_FMT_YUV420P10BE},
+    {IMGFMT_422P10_LE,  AV_PIX_FMT_YUV422P10LE},
+    {IMGFMT_422P10_BE,  AV_PIX_FMT_YUV422P10BE},
+    {IMGFMT_444P9_BE ,  AV_PIX_FMT_YUV444P9BE},
+    {IMGFMT_444P9_LE ,  AV_PIX_FMT_YUV444P9LE},
+    {IMGFMT_444P10_BE,  AV_PIX_FMT_YUV444P10BE},
+    {IMGFMT_444P10_LE,  AV_PIX_FMT_YUV444P10LE},
+    {IMGFMT_422P16_LE,  AV_PIX_FMT_YUV422P16LE},
+    {IMGFMT_422P16_BE,  AV_PIX_FMT_YUV422P16BE},
+    {IMGFMT_422P9_LE,   AV_PIX_FMT_YUV422P9LE},
+    {IMGFMT_422P9_BE,   AV_PIX_FMT_YUV422P9BE},
+    {IMGFMT_444P16_LE,  AV_PIX_FMT_YUV444P16LE},
+    {IMGFMT_444P16_BE,  AV_PIX_FMT_YUV444P16BE},
 
     // YUVJ are YUV formats that use the full Y range and not just
     // 16 - 235 (see colorspaces.txt).
     // Currently they are all treated the same way.
-    {IMGFMT_YV12,  PIX_FMT_YUVJ420P},
-    {IMGFMT_422P,  PIX_FMT_YUVJ422P},
-    {IMGFMT_444P,  PIX_FMT_YUVJ444P},
-    {IMGFMT_440P,  PIX_FMT_YUVJ440P},
+    {IMGFMT_YV12,  AV_PIX_FMT_YUVJ420P},
+    {IMGFMT_422P,  AV_PIX_FMT_YUVJ422P},
+    {IMGFMT_444P,  AV_PIX_FMT_YUVJ444P},
+    {IMGFMT_440P,  AV_PIX_FMT_YUVJ440P},
 
-    {IMGFMT_VDPAU_MPEG1,     PIX_FMT_VDPAU_MPEG1},
-    {IMGFMT_VDPAU_MPEG2,     PIX_FMT_VDPAU_MPEG2},
-    {IMGFMT_VDPAU_H264,      PIX_FMT_VDPAU_H264},
-    {IMGFMT_VDPAU_WMV3,      PIX_FMT_VDPAU_WMV3},
-    {IMGFMT_VDPAU_VC1,       PIX_FMT_VDPAU_VC1},
-    {IMGFMT_VDPAU_MPEG4,     PIX_FMT_VDPAU_MPEG4},
-    {0, PIX_FMT_NONE}
+    {IMGFMT_VDPAU_MPEG1,     AV_PIX_FMT_VDPAU_MPEG1},
+    {IMGFMT_VDPAU_MPEG2,     AV_PIX_FMT_VDPAU_MPEG2},
+    {IMGFMT_VDPAU_H264,      AV_PIX_FMT_VDPAU_H264},
+    {IMGFMT_VDPAU_WMV3,      AV_PIX_FMT_VDPAU_WMV3},
+    {IMGFMT_VDPAU_VC1,       AV_PIX_FMT_VDPAU_VC1},
+    {IMGFMT_VDPAU_MPEG4,     AV_PIX_FMT_VDPAU_MPEG4},
+    {0,                      AV_PIX_FMT_NONE}
 };
 
-enum PixelFormat imgfmt2pixfmt(int fmt)
+enum AVPixelFormat imgfmt2pixfmt(int fmt)
 {
     int i;
-    enum PixelFormat pix_fmt;
+    enum AVPixelFormat pix_fmt;
     for (i = 0; conversion_map[i].fmt; i++)
         if (conversion_map[i].fmt == fmt)
             break;
     pix_fmt = conversion_map[i].pix_fmt;
-    if (pix_fmt == PIX_FMT_NONE)
+    if (pix_fmt == AV_PIX_FMT_NONE)
         mp_msg(MSGT_GLOBAL, MSGL_ERR, "Unsupported format %s\n", vo_format_name(fmt));
     return pix_fmt;
 }
 
-int pixfmt2imgfmt(enum PixelFormat pix_fmt)
+int pixfmt2imgfmt(enum AVPixelFormat pix_fmt)
 {
     int i;
-    for (i = 0; conversion_map[i].pix_fmt != PIX_FMT_NONE; i++)
+    for (i = 0; conversion_map[i].pix_fmt != AV_PIX_FMT_NONE; i++)
         if (conversion_map[i].pix_fmt == pix_fmt)
             break;
     int fmt = conversion_map[i].fmt;
     if (!fmt) {
         const char *fmtname = av_get_pix_fmt_name(pix_fmt);
-        mp_msg(MSGT_GLOBAL, MSGL_ERR, "Unsupported PixelFormat %s (%d)\n",
+        mp_msg(MSGT_GLOBAL, MSGL_ERR, "Unsupported AVPixelFormat %s (%d)\n",
                fmtname ? fmtname : "INVALID", pix_fmt);
     }
     return fmt;




--- fmt-conversion.h.orig	2016-11-29 15:06:09 UTC
+++ fmt-conversion.h
@@ -22,7 +22,7 @@
 #include "libavutil/avutil.h"
 #include <libavutil/pixfmt.h>
 
-enum PixelFormat imgfmt2pixfmt(int fmt);
-int pixfmt2imgfmt(enum PixelFormat pix_fmt);
+enum AVPixelFormat imgfmt2pixfmt(int fmt);
+int pixfmt2imgfmt(enum AVPixelFormat pix_fmt);
 
 #endif /* MPLAYER_FMT_CONVERSION_H */




--- libaf/af_lavcac3enc.c.orig	2013-07-09 16:33:12 UTC
+++ libaf/af_lavcac3enc.c
@@ -27,7 +27,6 @@
 #include <assert.h>
 
 #include <libavcodec/avcodec.h>
-#include <libavutil/audioconvert.h>
 #include <libavutil/error.h>
 #include <libavutil/intreadwrite.h>
 #include <libavutil/mem.h>
@@ -219,7 +218,7 @@ static void uninit(struct af_instance_s*
             av_free(s->lavc_actx);
         }
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
-        avcodec_free_frame(&s->frame);
+        av_frame_free(&s->frame);
 #else
         av_freep(&s->frame);
 #endif
@@ -398,7 +397,7 @@ static int af_open(af_instance_t* af){
         mp_tmsg(MSGT_AFILTER, MSGL_ERR, "Audio LAVC, couldn't allocate context!\n");
         return AF_ERROR;
     }
-    s->frame = avcodec_alloc_frame();
+    s->frame = av_frame_alloc();
     if (!s->frame)
         return AF_ERROR;
     const enum AVSampleFormat *fmts = s->lavc_acodec->sample_fmts;




--- libmpcodecs/ad_ffmpeg.c.orig	2013-07-09 16:33:13 UTC
+++ libmpcodecs/ad_ffmpeg.c
@@ -23,7 +23,6 @@
 #include <assert.h>
 
 #include <libavcodec/avcodec.h>
-#include <libavutil/audioconvert.h>
 #include <libavutil/opt.h>
 #include <libavutil/samplefmt.h>
 
@@ -236,7 +235,7 @@ static int init(sh_audio_t *sh_audio)
     sh_audio->context = ctx;
     lavc_context = avcodec_alloc_context3(lavc_codec);
     ctx->avctx = lavc_context;
-    ctx->avframe = avcodec_alloc_frame();
+    ctx->avframe = av_frame_alloc();
 
     // Always try to set - option only exists for AC3 at the moment
     av_opt_set_double(lavc_context, "drc_scale", opts->drc_level,
@@ -250,7 +249,6 @@ static int init(sh_audio_t *sh_audio)
         lavc_context->block_align = sh_audio->wf->nBlockAlign;
         lavc_context->bits_per_coded_sample = sh_audio->wf->wBitsPerSample;
     }
-    lavc_context->request_channels = opts->audio_output_channels;
     lavc_context->codec_tag = sh_audio->format; //FOURCC
     lavc_context->codec_type = AVMEDIA_TYPE_AUDIO;
     lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
@@ -333,7 +331,7 @@ static void uninit(sh_audio_t *sh)
     avresample_free(&ctx->avr);
 #endif
 #if LIBAVCODEC_VERSION_INT >= (54 << 16 | 28 << 8)
-    avcodec_free_frame(&ctx->avframe);
+    av_frame_free(&ctx->avframe);
 #else
     av_free(ctx->avframe);
 #endif




--- libmpcodecs/dec_teletext.c.orig	2013-07-09 16:33:13 UTC
+++ libmpcodecs/dec_teletext.c
@@ -402,6 +402,25 @@ struct {
   { 0x00, LATIN,     "English"},
 };
 
+static const uint8_t reverse[256] = {
+0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
+0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
+0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
+0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
+0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
+0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
+0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
+0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
+0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
+0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
+0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
+0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
+0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
+0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
+0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
+0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
+};
+
 /**
  * \brief 24/18 Hamming code decoding
  * \param data bytes with hamming code (array must be at least 3 bytes long)
@@ -1549,7 +1568,7 @@ static void vbi_decode_dvb(priv_vbi_t *p
     /* Reverse bit order, skipping the first two bytes (field parity, line
        offset and framing code). */
     for (i = 0; i < sizeof(data); i++)
-        data[i] = av_reverse[buf[2 + i]];
+        data[i] = reverse[buf[2 + i]];
 
     vbi_decode_line(priv, data);
     if (priv->cache_reset)




--- libmpcodecs/vd_ffmpeg.c.orig	2013-07-09 16:33:13 UTC
+++ libmpcodecs/vd_ffmpeg.c
@@ -25,6 +25,7 @@
 #include <libavutil/common.h>
 #include <libavutil/opt.h>
 #include <libavutil/intreadwrite.h>
+#include <libavutil/pixdesc.h>
 
 #include "talloc.h"
 #include "config.h"
@@ -61,7 +62,7 @@ static const vd_info_t info = {
 typedef struct {
     AVCodecContext *avctx;
     AVFrame *pic;
-    enum PixelFormat pix_fmt;
+    enum AVPixelFormat pix_fmt;
     int do_slices;
     int do_dr1;
     int vo_initialized;
@@ -77,13 +78,16 @@ typedef struct {
 
 #include "m_option.h"
 
-static int get_buffer(AVCodecContext *avctx, AVFrame *pic);
+static int get_buffer(AVCodecContext *avctx, AVFrame *pic, int isreference);
+static int mpcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame);
+static int get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags);
 static void release_buffer(AVCodecContext *avctx, AVFrame *pic);
+static void mpcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
 static void draw_slice(struct AVCodecContext *s, const AVFrame *src,
                        int offset[4], int y, int type, int height);
 
-static enum PixelFormat get_format(struct AVCodecContext *avctx,
-                                   const enum PixelFormat *pix_fmt);
+static enum AVPixelFormat get_format(struct AVCodecContext *avctx,
+                                   const enum AVPixelFormat *pix_fmt);
 static void uninit(struct sh_video *sh);
 
 const m_option_t lavc_decode_opts_conf[] = {
@@ -169,7 +173,7 @@ static int init(sh_video_t *sh)
         ctx->do_dr1 = 1;
     ctx->ip_count = ctx->b_count = 0;
 
-    ctx->pic = avcodec_alloc_frame();
+    ctx->pic = av_frame_alloc();
     ctx->avctx = avcodec_alloc_context3(lavc_codec);
     avctx = ctx->avctx;
     avctx->opaque = sh;
@@ -182,9 +186,7 @@ static int init(sh_video_t *sh)
         ctx->do_slices = true;
         lavc_param->threads    = 1;
         avctx->get_format      = get_format;
-        avctx->get_buffer      = get_buffer;
-        avctx->release_buffer  = release_buffer;
-        avctx->reget_buffer    = get_buffer;
+        avctx->get_buffer2      = get_buffer2;
         avctx->draw_horiz_band = draw_slice;
         if (lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
             mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] VDPAU hardware "
@@ -212,10 +214,7 @@ static int init(sh_video_t *sh)
     }
 
     if (ctx->do_dr1) {
-        avctx->flags |= CODEC_FLAG_EMU_EDGE;
-        avctx->get_buffer = get_buffer;
-        avctx->release_buffer = release_buffer;
-        avctx->reget_buffer = get_buffer;
+        avctx->get_buffer2 = get_buffer2;
     }
 
     avctx->flags |= lavc_param->bitexact;
@@ -227,7 +226,6 @@ static int init(sh_video_t *sh)
         avctx->flags |= CODEC_FLAG_GRAY;
     avctx->flags2 |= lavc_param->fast;
     avctx->codec_tag = sh->format;
-    avctx->stream_codec_tag = sh->video.fccHandler;
     avctx->idct_algo = lavc_param->idct_algo;
     avctx->error_concealment = lavc_param->error_concealment;
     avctx->debug = lavc_param->debug;
@@ -357,7 +355,7 @@ static void uninit(sh_video_t *sh)
 
     av_freep(&avctx);
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
-    avcodec_free_frame(&ctx->pic);
+    av_frame_free(&ctx->pic);
 #else
     av_freep(&ctx->pic);
 #endif
@@ -423,7 +421,7 @@ static enum mp_csp_levels avcol_range_to
     }
 }
 
-static int init_vo(sh_video_t *sh, enum PixelFormat pix_fmt)
+static int init_vo(sh_video_t *sh, enum AVPixelFormat pix_fmt)
 {
     vd_ffmpeg_ctx *ctx = sh->context;
     AVCodecContext *avctx = ctx->avctx;
@@ -488,7 +486,7 @@ static int init_vo(sh_video_t *sh, enum 
     return 0;
 }
 
-static int get_buffer(AVCodecContext *avctx, AVFrame *pic)
+static int get_buffer(AVCodecContext *avctx, AVFrame *pic, int isreference)
 {
     sh_video_t *sh = avctx->opaque;
     vd_ffmpeg_ctx *ctx = sh->context;
@@ -499,29 +497,11 @@ static int get_buffer(AVCodecContext *av
     int width = avctx->width;
     int height = avctx->height;
     // special case to handle reget_buffer without buffer hints
-    if (pic->opaque && pic->data[0] && !pic->buffer_hints)
+    if (pic->opaque && pic->data[0])
         return 0;
     avcodec_align_dimensions(avctx, &width, &height);
 
-    if (pic->buffer_hints) {
-        mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "Buffer hints: %u\n",
-               pic->buffer_hints);
-        type = MP_IMGTYPE_TEMP;
-        if (pic->buffer_hints & FF_BUFFER_HINTS_READABLE)
-            flags |= MP_IMGFLAG_READABLE;
-        if (pic->buffer_hints & FF_BUFFER_HINTS_PRESERVE) {
-            type = MP_IMGTYPE_STATIC;
-            flags |= MP_IMGFLAG_PRESERVE;
-        }
-        if (pic->buffer_hints & FF_BUFFER_HINTS_REUSABLE) {
-            type = MP_IMGTYPE_STATIC;
-            flags |= MP_IMGFLAG_PRESERVE;
-        }
-        flags |= ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0;
-        mp_msg(MSGT_DECVIDEO, MSGL_DBG2,
-               type == MP_IMGTYPE_STATIC ? "using STATIC\n" : "using TEMP\n");
-    } else {
-        if (!pic->reference) {
+        if (!isreference) {
             ctx->b_count++;
             flags |= ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0;
         } else {
@@ -529,29 +509,25 @@ static int get_buffer(AVCodecContext *av
             flags |= MP_IMGFLAG_PRESERVE | MP_IMGFLAG_READABLE
                      | (ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0);
         }
-    }
 
     if (init_vo(sh, avctx->pix_fmt) < 0) {
-        avctx->release_buffer = avcodec_default_release_buffer;
-        avctx->get_buffer = avcodec_default_get_buffer;
-        avctx->reget_buffer = avcodec_default_reget_buffer;
+        avctx->get_buffer2 = avcodec_default_get_buffer2;
         if (pic->data[0])
-            release_buffer(avctx, pic);
-        return avctx->get_buffer(avctx, pic);
+            mpcodec_default_release_buffer(avctx, pic);
+        return avctx->get_buffer2(avctx, pic,0);
     }
 
     if (IMGFMT_IS_HWACCEL(ctx->best_csp))
         type =  MP_IMGTYPE_NUMBERED | (0xffff << 16);
-    else if (!pic->buffer_hints) {
+    else {
         if (ctx->b_count > 1 || ctx->ip_count > 2) {
             mp_tmsg(MSGT_DECVIDEO, MSGL_WARN, "[VD_FFMPEG] DRI failure.\n");
 
             ctx->do_dr1 = 0; //FIXME
-            avctx->get_buffer = avcodec_default_get_buffer;
-            avctx->reget_buffer = avcodec_default_reget_buffer;
+            avctx->get_buffer2 = avcodec_default_get_buffer2;
             if (pic->data[0])
-                release_buffer(avctx, pic);
-            return avctx->get_buffer(avctx, pic);
+                mpcodec_default_release_buffer(avctx, pic);
+            return avctx->get_buffer2(avctx, pic,0);
         }
 
         if (avctx->has_b_frames || ctx->b_count)
@@ -594,7 +570,6 @@ static int get_buffer(AVCodecContext *av
 
     pic->opaque = mpi;
 
-    pic->type = FF_BUFFER_TYPE_USER;
 
     /* The libavcodec reordered_opaque functionality is implemented by
      * a similar copy in avcodec_default_get_buffer() and without a
@@ -626,8 +601,8 @@ static void release_buffer(struct AVCode
         mpi->usage_count--;
     }
 
-    if (pic->type != FF_BUFFER_TYPE_USER) {
-        avcodec_default_release_buffer(avctx, pic);
+    if (pic->opaque == NULL) {
+        mpcodec_default_release_buffer(avctx, pic);
         return;
     }
 
@@ -822,13 +797,13 @@ static struct mp_image *decode(struct sh
     return mpi;
 }
 
-static enum PixelFormat get_format(struct AVCodecContext *avctx,
-                                   const enum PixelFormat *fmt)
+static enum AVPixelFormat get_format(struct AVCodecContext *avctx,
+                                   const enum AVPixelFormat *fmt)
 {
     sh_video_t *sh = avctx->opaque;
     int i;
 
-    for (i = 0; fmt[i] != PIX_FMT_NONE; i++) {
+    for (i = 0; fmt[i] != AV_PIX_FMT_NONE; i++) {
         int imgfmt = pixfmt2imgfmt(fmt[i]);
         if (!IMGFMT_IS_HWACCEL(imgfmt))
             continue;
@@ -886,3 +861,144 @@ const struct vd_functions mpcodecs_vd_ff
     .control = control,
     .decode2 = decode
 };
+
+/*
+FFWrapper
+*/
+static int mpcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
+{
+    return avcodec_default_get_buffer2(avctx, frame, 0);
+}
+
+static void mpcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
+{
+    av_frame_unref(pic);
+}
+
+typedef struct CompatReleaseBufPriv {
+    AVCodecContext avctx;
+    AVFrame frame;
+    uint8_t avframe_padding[1024]; // hack to allow linking to a avutil larger AVFrame
+} CompatReleaseBufPriv;
+
+static void compat_free_buffer(void *opaque, uint8_t *data)
+{
+    CompatReleaseBufPriv *priv = opaque;
+    release_buffer(&priv->avctx, &priv->frame);
+    av_freep(&priv);
+}
+
+static void compat_release_buffer(void *opaque, uint8_t *data)
+{
+    AVBufferRef *buf = opaque;
+    av_buffer_unref(&buf);
+}
+
+static int get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
+{
+    /*
+     * Wrap an old get_buffer()-allocated buffer in a bunch of AVBuffers.
+     * We wrap each plane in its own AVBuffer. Each of those has a reference to
+     * a dummy AVBuffer as its private data, unreffing it on free,
+     * When all the planes are freed, the dummy buffer's free callback calls
+     * release_buffer().
+     */
+    CompatReleaseBufPriv *priv = NULL;
+    AVBufferRef *dummy_buf = NULL;
+    int planes, i, ret;
+
+    ret = get_buffer(avctx, frame, flags & AV_GET_BUFFER_FLAG_REF);
+    if (ret < 0)
+        return ret;
+
+    /* return if the buffers are already set up
+     * this would happen e.g. when a custom get_buffer() calls
+     * avcodec_default_get_buffer
+     */
+    if (frame->buf[0])
+       goto end0;
+
+    priv = av_mallocz(sizeof(*priv));
+    if (!priv) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    priv->avctx = *avctx;
+    priv->frame = *frame; 
+
+    dummy_buf = av_buffer_create(NULL, 0, compat_free_buffer, priv, 0);
+    if (!dummy_buf) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+#define WRAP_PLANE(ref_out, data, data_size)                            \
+do {                                                                    \
+    AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf);                  \
+    if (!dummy_ref) {                                                   \
+        ret = AVERROR(ENOMEM);                                          \
+        goto fail;                                                      \
+    }                                                                   \
+    ref_out = av_buffer_create(data, data_size, compat_release_buffer,  \
+                               dummy_ref, 0);                           \
+    if (!ref_out) {                                                     \
+        av_buffer_unref(&dummy_ref);                                    \
+        av_frame_unref(frame);                                          \
+        ret = AVERROR(ENOMEM);                                          \
+        goto fail;                                                      \
+    }                                                                   \
+} while (0)
+
+    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
+
+        planes = av_pix_fmt_count_planes(frame->format);
+        /* workaround for AVHWAccel plane count of 0, buf[0] is used as
+           check for allocated buffers: make libavcodec happy */
+        if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
+            planes = 1;
+        if (!desc || planes <= 0) {
+            ret = AVERROR(EINVAL);
+            goto fail;
+        }
+
+        for (i = 0; i < planes; i++) {
+            int v_shift    = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
+            int plane_size = (frame->height >> v_shift) * frame->linesize[i];
+
+            WRAP_PLANE(frame->buf[i], frame->data[i], plane_size);
+        }
+    } else {
+        int planar = av_sample_fmt_is_planar(frame->format);
+        planes = planar ? avctx->channels : 1;
+
+        if (planes > FF_ARRAY_ELEMS(frame->buf)) {
+            frame->nb_extended_buf = planes - FF_ARRAY_ELEMS(frame->buf);
+            frame->extended_buf = av_malloc_array(sizeof(*frame->extended_buf),
+                                            frame->nb_extended_buf);
+            if (!frame->extended_buf) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+         }
+
+         for (i = 0; i < FFMIN(planes, FF_ARRAY_ELEMS(frame->buf)); i++)
+             WRAP_PLANE(frame->extended_buf[i],
+                        frame->extended_data[i + FF_ARRAY_ELEMS(frame->buf)],
+                        frame->linesize[0]);
+    }
+    
+    av_buffer_unref(&dummy_buf);
+
+end0:
+    frame->width  = avctx->width;
+    frame->height = avctx->height;
+
+    return 0;
+
+fail:
+    release_buffer(avctx, frame);
+    av_freep(&priv);
+    av_buffer_unref(&dummy_buf);
+    return ret;
+}




--- libmpcodecs/vf_halfpack.c.orig	2013-07-09 16:33:16 UTC
+++ libmpcodecs/vf_halfpack.c
@@ -198,9 +198,9 @@ static int config(struct vf_instance *vf
 		sws_freeContext(vf->priv->ctx);
 		// get unscaled 422p -> yuy2 conversion
 		vf->priv->ctx =
-			sws_getContext(width, height / 2, PIX_FMT_YUV422P,
-			               width, height / 2, PIX_FMT_YUYV422,
-			               SWS_POINT | SWS_PRINT_INFO | get_sws_cpuflags(),
+			sws_getContext(width, height / 2, AV_PIX_FMT_YUV422P,
+			               width, height / 2, AV_PIX_FMT_YUYV422,
+			               SWS_POINT | SWS_PRINT_INFO,
 			               NULL, NULL, NULL);
 	}
 	/* FIXME - also support UYVY output? */




--- libmpcodecs/vf_lavc.c.orig	2013-07-09 16:33:16 UTC
+++ libmpcodecs/vf_lavc.c
@@ -139,7 +139,7 @@ static int vf_open(vf_instance_t *vf, ch
     }
 
     vf->priv->context=avcodec_alloc_context3(vf->priv->codec);
-    vf->priv->pic = avcodec_alloc_frame();
+    vf->priv->pic = av_frame_alloc();
 
     // TODO: parse args ->
     if(args) sscanf(args, "%d:%f", &p_quality, &p_fps);
@@ -156,7 +156,7 @@ static int vf_open(vf_instance_t *vf, ch
     lavc_venc_context.time_base.num = 1000*1001;
     lavc_venc_context.time_base.den = (p_fps<1.0) ? 1000*1001*25 : (p_fps * lavc_venc_context.time_base.num);
     lavc_venc_context.gop_size = 0; // I-only
-    lavc_venc_context.pix_fmt= PIX_FMT_YUV420P;
+    lavc_venc_context.pix_fmt= AV_PIX_FMT_YUV420P;
 
     return 1;
 }




--- libmpcodecs/vf_lavcdeint.c.orig	2013-07-09 16:33:16 UTC
+++ libmpcodecs/vf_lavcdeint.c
@@ -59,7 +59,7 @@ imgfmt_to_pixfmt (int imgfmt)
     case IMGFMT_YV12:
     case IMGFMT_I420:
     case IMGFMT_IYUV:
-      return PIX_FMT_YUV420P;
+      return AV_PIX_FMT_YUV420P;
       break;
 
 #if 0
@@ -73,7 +73,7 @@ imgfmt_to_pixfmt (int imgfmt)
     case IMGFMT_Y42T:
     case IMGFMT_V422:
     case IMGFMT_V655:
-      return PIX_FMT_YUV422P;
+      return AV_PIX_FMT_YUV422P;
       break;
 #endif
 

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__sab.c (+11 lines)
	1	--- libmpcodecs/vf_sab.c.orig 2016-11-29 23:52:42 UTC
	2	+++ libmpcodecs/vf_sab.c
	3	@@ -72,7 +72,7 @@ static int allocStuff(FilterParam *f, in
	4	swsF.lumH= swsF.lumV= vec;
	5	swsF.chrH= swsF.chrV= NULL;
	6	f->preFilterContext= sws_getContext(
	7	- width, height, PIX_FMT_GRAY8, width, height, PIX_FMT_GRAY8, get_sws_cpuflags()\|SWS_POINT, &swsF, NULL, NULL);
	8	+ width, height, AV_PIX_FMT_GRAY8, width, height, AV_PIX_FMT_GRAY8, SWS_POINT, &swsF, NULL, NULL);
	9
	10	sws_freeVec(vec);
	11	vec = sws_getGaussianVec(f->strength, 5.0);




--- libmpcodecs/vf_scale.c.orig	2013-07-09 16:33:16 UTC
+++ libmpcodecs/vf_scale.c
@@ -201,7 +201,7 @@ static int config(struct vf_instance *vf
     int round_w=0, round_h=0;
     int i;
     SwsFilter *srcFilter, *dstFilter;
-    enum PixelFormat dfmt, sfmt;
+    enum AVPixelFormat dfmt, sfmt;
 
     vf->priv->colorspace = (struct mp_csp_details) {0};
 
@@ -210,7 +210,7 @@ static int config(struct vf_instance *vf
 	return 0;
     }
     sfmt = imgfmt2pixfmt(outfmt);
-    if (outfmt == IMGFMT_RGB8 || outfmt == IMGFMT_BGR8) sfmt = PIX_FMT_PAL8;
+    if (outfmt == IMGFMT_RGB8 || outfmt == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;
     dfmt = imgfmt2pixfmt(best);
 
     vo_flags=vf->next->query_format(vf->next,best);
@@ -319,13 +319,13 @@ static int config(struct vf_instance *vf
 	    sfmt,
 		  vf->priv->w, vf->priv->h >> vf->priv->interlaced,
 	    dfmt,
-	    int_sws_flags | get_sws_cpuflags(), srcFilter, dstFilter, vf->priv->param);
+	    int_sws_flags, srcFilter, dstFilter, vf->priv->param);
     if(vf->priv->interlaced){
         vf->priv->ctx2=sws_getContext(width, height >> 1,
 	    sfmt,
 		  vf->priv->w, vf->priv->h >> 1,
 	    dfmt,
-	    int_sws_flags | get_sws_cpuflags(), srcFilter, dstFilter, vf->priv->param);
+	    int_sws_flags, srcFilter, dstFilter, vf->priv->param);
     }
     if(!vf->priv->ctx){
 	// error...
@@ -612,7 +612,7 @@ error_out:
 //  supported Input formats: YV12, I420, IYUV, YUY2, UYVY, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8, Y800
 
 static int query_format(struct vf_instance *vf, unsigned int fmt){
-    if (!IMGFMT_IS_HWACCEL(fmt) && imgfmt2pixfmt(fmt) != PIX_FMT_NONE) {
+    if (!IMGFMT_IS_HWACCEL(fmt) && imgfmt2pixfmt(fmt) != AV_PIX_FMT_NONE) {
 	unsigned int best=find_best_out(vf, fmt);
 	int flags;
 	if(!best) return 0;	 // no matching out-fmt
@@ -661,14 +661,6 @@ int sws_chr_hshift= 0;
 float sws_chr_sharpen= 0.0;
 float sws_lum_sharpen= 0.0;
 
-int get_sws_cpuflags(void){
-    return
-          (gCpuCaps.hasMMX   ? SWS_CPU_CAPS_MMX   : 0)
-	| (gCpuCaps.hasMMX2  ? SWS_CPU_CAPS_MMX2  : 0)
-	| (gCpuCaps.has3DNow ? SWS_CPU_CAPS_3DNOW : 0)
-        | (gCpuCaps.hasAltiVec ? SWS_CPU_CAPS_ALTIVEC : 0);
-}
-
 void sws_getFlagsAndFilterFromCmdLine(int *flags, SwsFilter **srcFilterParam, SwsFilter **dstFilterParam)
 {
 	static int firstTime=1;
@@ -717,14 +709,14 @@ static struct SwsContext *sws_getContext
 {
 	int flags;
 	SwsFilter *dstFilterParam, *srcFilterParam;
-	enum PixelFormat dfmt, sfmt;
+	enum AVPixelFormat dfmt, sfmt;
 
 	dfmt = imgfmt2pixfmt(dstFormat);
 	sfmt = imgfmt2pixfmt(srcFormat);
-	if (srcFormat == IMGFMT_RGB8 || srcFormat == IMGFMT_BGR8) sfmt = PIX_FMT_PAL8;
+	if (srcFormat == IMGFMT_RGB8 || srcFormat == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;
 	sws_getFlagsAndFilterFromCmdLine(&flags, &srcFilterParam, &dstFilterParam);
 
-	return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags | extraflags | get_sws_cpuflags(), srcFilterParam, dstFilterParam, NULL);
+	return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags, srcFilterParam, dstFilterParam, NULL);
 }
 
 struct SwsContext *sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__scale.h (+10 lines)
	1	--- libmpcodecs/vf_scale.h.orig 2016-11-30 00:01:44 UTC
	2	+++ libmpcodecs/vf_scale.h
	3	@@ -19,7 +19,6 @@
	4	#ifndef MPLAYER_VF_SCALE_H
	5	#define MPLAYER_VF_SCALE_H
	6
	7	-int get_sws_cpuflags(void);
	8	struct SwsContext *sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat);
	9	struct SwsContext *sws_getContextFromCmdLine_hq(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat);
	10




--- libmpcodecs/vf_screenshot.c.orig	2016-11-30 00:06:27 UTC
+++ libmpcodecs/vf_screenshot.c
@@ -167,9 +167,9 @@ static int control (vf_instance_t *vf, i
 
 static int query_format(struct vf_instance *vf, unsigned int fmt)
 {
-    enum PixelFormat av_format = imgfmt2pixfmt(fmt);
+    enum AVPixelFormat av_format = imgfmt2pixfmt(fmt);
 
-    if (av_format != PIX_FMT_NONE && sws_isSupportedInput(av_format))
+    if (av_format != AV_PIX_FMT_NONE && sws_isSupportedInput(av_format))
         return vf_next_query_format(vf, fmt);
     return 0;
 }

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__smartblur.c (+11 lines)
	1	--- libmpcodecs/vf_smartblur.c.orig 2016-11-30 00:10:36 UTC
	2	+++ libmpcodecs/vf_smartblur.c
	3	@@ -61,7 +61,7 @@ static int allocStuff(FilterParam *f, in
	4	swsF.lumH= swsF.lumV= vec;
	5	swsF.chrH= swsF.chrV= NULL;
	6	f->filterContext= sws_getContext(
	7	- width, height, PIX_FMT_GRAY8, width, height, PIX_FMT_GRAY8, SWS_BICUBIC \| get_sws_cpuflags(), &swsF, NULL, NULL);
	8	+ width, height, AV_PIX_FMT_GRAY8, width, height, AV_PIX_FMT_GRAY8, SWS_BICUBIC, &swsF, NULL, NULL);
	9
	10	sws_freeVec(vec);
	11




--- libmpdemux/demux_lavf.c.orig	2013-07-09 16:33:16 UTC
+++ libmpdemux/demux_lavf.c
@@ -159,6 +159,7 @@ static int lavf_check_file(demuxer_t *de
     int probe_data_size = 0;

         priv->avif = av_probe_input_format2(&avpd, probe_data_size > 0, &score);
         read_size = FFMIN(2 * read_size, PROBE_BUF_SIZE - probe_data_size);
     } while ((demuxer->desc->type != DEMUXER_TYPE_LAVF_PREFERRED ||
@@ -383,9 +385,9 @@ static void handle_stream(demuxer_t *dem
 
         if (codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
             switch (codec->pix_fmt) {
-            case PIX_FMT_RGB24:
+            case AV_PIX_FMT_RGB24:
                 codec->codec_tag = MKTAG(24, 'B', 'G', 'R');
-            case PIX_FMT_BGR24:
+            case AV_PIX_FMT_BGR24:
                 codec->codec_tag = MKTAG(24, 'R', 'G', 'B');
             }
             if (!codec->codec_tag)




--- screenshot.c.orig	2013-07-09 16:33:27 UTC
+++ screenshot.c
@@ -57,7 +57,7 @@ static int destroy_ctx(void *ptr)
 {
     struct screenshot_ctx *ctx = ptr;
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
-    avcodec_free_frame(&ctx->pic);
+    av_frame_free(&ctx->pic);
 #else
     av_free(ctx->pic);
 #endif
@@ -69,7 +69,7 @@ static screenshot_ctx *screenshot_get_ct
     if (!mpctx->screenshot_ctx) {
         struct screenshot_ctx *ctx = talloc_zero(mpctx, screenshot_ctx);
         talloc_set_destructor(ctx, destroy_ctx);
-        ctx->pic = avcodec_alloc_frame();
+        ctx->pic = av_frame_alloc();
         assert(ctx->pic);
         mpctx->screenshot_ctx = ctx;
     }
@@ -94,7 +94,7 @@ static int write_png(screenshot_ctx *ctx
     avctx->time_base = AV_TIME_BASE_Q;
     avctx->width = image->width;
     avctx->height = image->height;
-    avctx->pix_fmt = PIX_FMT_RGB24;
+    avctx->pix_fmt = AV_PIX_FMT_RGB24;
     avctx->compression_level = 0;
 
     if (avcodec_open2(avctx, png_codec, NULL) < 0) {
@@ -110,7 +110,7 @@ static int write_png(screenshot_ctx *ctx
         goto error_exit;
 
     AVFrame *pic = ctx->pic;
-    avcodec_get_frame_defaults(pic);
+    av_frame_unref(pic);
     for (int n = 0; n < 4; n++) {
         pic->data[n] = image->planes[n];
         pic->linesize[n] = image->stride[n];

Line 0 Link Here

(-)mplayer2/files/patch-sub_spudec.c (+11 lines)
	1	--- sub/spudec.c.orig 2016-11-30 00:23:04 UTC
	2	+++ sub/spudec.c
	3	@@ -861,7 +861,7 @@ static void sws_spu_image(unsigned char
	4	oldvar = spu_gaussvar;
	5	}
	6
	7	- ctx=sws_getContext(sw, sh, PIX_FMT_GRAY8, dw, dh, PIX_FMT_GRAY8, SWS_GAUSS, &filter, NULL, NULL);
	8	+ ctx=sws_getContext(sw, sh, AV_PIX_FMT_GRAY8, dw, dh, AV_PIX_FMT_GRAY8, SWS_GAUSS, &filter, NULL, NULL);
	9	sws_scale(ctx,&s1,&ss,0,sh,&d1,&ds);
	10	for (i=ss*sh-1; i>=0; i--) if (!s2[i]) s2[i] = 255; //else s2[i] = 1;
	11	sws_scale(ctx,(const uint8_t **)&s2,&ss,0,sh,&d2,&ds);

Return to bug 214896

Line 0 Link Here

(-)mplayer2/files/patch-fmt-conversion.c (+204 lines)
		1	--- fmt-conversion.c.orig 2013-07-09 16:33:12 UTC
		2	+++ fmt-conversion.c
		3	@@ -24,117 +24,117 @@
		4
		5	static const struct {
		6	int fmt;
		7	- enum PixelFormat pix_fmt;
		8	+ enum AVPixelFormat pix_fmt;
		9	} conversion_map[] = {
		10	- {IMGFMT_ARGB, PIX_FMT_ARGB},
		11	- {IMGFMT_BGRA, PIX_FMT_BGRA},
		12	- {IMGFMT_BGR24, PIX_FMT_BGR24},
		13	- {IMGFMT_BGR16BE, PIX_FMT_RGB565BE},
		14	- {IMGFMT_BGR16LE, PIX_FMT_RGB565LE},
		15	- {IMGFMT_BGR15BE, PIX_FMT_RGB555BE},
		16	- {IMGFMT_BGR15LE, PIX_FMT_RGB555LE},
		17	- {IMGFMT_BGR12BE, PIX_FMT_RGB444BE},
		18	- {IMGFMT_BGR12LE, PIX_FMT_RGB444LE},
		19	- {IMGFMT_BGR8, PIX_FMT_RGB8},
		20	- {IMGFMT_BGR4, PIX_FMT_RGB4},
		21	- {IMGFMT_BGR1, PIX_FMT_MONOBLACK},
		22	- {IMGFMT_RGB1, PIX_FMT_MONOBLACK},
		23	- {IMGFMT_RG4B, PIX_FMT_BGR4_BYTE},
		24	- {IMGFMT_BG4B, PIX_FMT_RGB4_BYTE},
		25	- {IMGFMT_RGB48LE, PIX_FMT_RGB48LE},
		26	- {IMGFMT_RGB48BE, PIX_FMT_RGB48BE},
		27	- {IMGFMT_ABGR, PIX_FMT_ABGR},
		28	- {IMGFMT_RGBA, PIX_FMT_RGBA},
		29	- {IMGFMT_RGB24, PIX_FMT_RGB24},
		30	- {IMGFMT_RGB16BE, PIX_FMT_BGR565BE},
		31	- {IMGFMT_RGB16LE, PIX_FMT_BGR565LE},
		32	- {IMGFMT_RGB15BE, PIX_FMT_BGR555BE},
		33	- {IMGFMT_RGB15LE, PIX_FMT_BGR555LE},
		34	- {IMGFMT_RGB12BE, PIX_FMT_BGR444BE},
		35	- {IMGFMT_RGB12LE, PIX_FMT_BGR444LE},
		36	- {IMGFMT_RGB8, PIX_FMT_BGR8},
		37	- {IMGFMT_RGB4, PIX_FMT_BGR4},
		38	- {IMGFMT_BGR8, PIX_FMT_PAL8},
		39	- {IMGFMT_GBRP, PIX_FMT_GBRP},
		40	- {IMGFMT_GBRP9, PIX_FMT_GBRP9},
		41	- {IMGFMT_GBRP10, PIX_FMT_GBRP10},
		42	- {IMGFMT_YUY2, PIX_FMT_YUYV422},
		43	- {IMGFMT_UYVY, PIX_FMT_UYVY422},
		44	- {IMGFMT_NV12, PIX_FMT_NV12},
		45	- {IMGFMT_NV21, PIX_FMT_NV21},
		46	- {IMGFMT_Y800, PIX_FMT_GRAY8},
		47	- {IMGFMT_Y8, PIX_FMT_GRAY8},
		48	- {IMGFMT_YVU9, PIX_FMT_YUV410P},
		49	- {IMGFMT_IF09, PIX_FMT_YUV410P},
		50	- {IMGFMT_YV12, PIX_FMT_YUV420P},
		51	- {IMGFMT_I420, PIX_FMT_YUV420P},
		52	- {IMGFMT_IYUV, PIX_FMT_YUV420P},
		53	- {IMGFMT_411P, PIX_FMT_YUV411P},
		54	- {IMGFMT_422P, PIX_FMT_YUV422P},
		55	- {IMGFMT_444P, PIX_FMT_YUV444P},
		56	- {IMGFMT_440P, PIX_FMT_YUV440P},
		57	+ {IMGFMT_ARGB, AV_PIX_FMT_ARGB},
		58	+ {IMGFMT_BGRA, AV_PIX_FMT_BGRA},
		59	+ {IMGFMT_BGR24, AV_PIX_FMT_BGR24},
		60	+ {IMGFMT_BGR16BE, AV_PIX_FMT_RGB565BE},
		61	+ {IMGFMT_BGR16LE, AV_PIX_FMT_RGB565LE},
		62	+ {IMGFMT_BGR15BE, AV_PIX_FMT_RGB555BE},
		63	+ {IMGFMT_BGR15LE, AV_PIX_FMT_RGB555LE},
		64	+ {IMGFMT_BGR12BE, AV_PIX_FMT_RGB444BE},
65	+ {IMGFMT_BGR12LE, AV_PIX_FMT_RGB444LE},
66	+ {IMGFMT_BGR8, AV_PIX_FMT_RGB8},
67	+ {IMGFMT_BGR4, AV_PIX_FMT_RGB4},
68	+ {IMGFMT_BGR1, AV_PIX_FMT_MONOBLACK},
69	+ {IMGFMT_RGB1, AV_PIX_FMT_MONOBLACK},
70	+ {IMGFMT_RG4B, AV_PIX_FMT_BGR4_BYTE},
71	+ {IMGFMT_BG4B, AV_PIX_FMT_RGB4_BYTE},
72	+ {IMGFMT_RGB48LE, AV_PIX_FMT_RGB48LE},
73	+ {IMGFMT_RGB48BE, AV_PIX_FMT_RGB48BE},
74	+ {IMGFMT_ABGR, AV_PIX_FMT_ABGR},
75	+ {IMGFMT_RGBA, AV_PIX_FMT_RGBA},
76	+ {IMGFMT_RGB24, AV_PIX_FMT_RGB24},
77	+ {IMGFMT_RGB16BE, AV_PIX_FMT_BGR565BE},
78	+ {IMGFMT_RGB16LE, AV_PIX_FMT_BGR565LE},
79	+ {IMGFMT_RGB15BE, AV_PIX_FMT_BGR555BE},
80	+ {IMGFMT_RGB15LE, AV_PIX_FMT_BGR555LE},
81	+ {IMGFMT_RGB12BE, AV_PIX_FMT_BGR444BE},
82	+ {IMGFMT_RGB12LE, AV_PIX_FMT_BGR444LE},
83	+ {IMGFMT_RGB8, AV_PIX_FMT_BGR8},
84	+ {IMGFMT_RGB4, AV_PIX_FMT_BGR4},
85	+ {IMGFMT_BGR8, AV_PIX_FMT_PAL8},
86	+ {IMGFMT_GBRP, AV_PIX_FMT_GBRP},
87	+ {IMGFMT_GBRP9, AV_PIX_FMT_GBRP9},
88	+ {IMGFMT_GBRP10, AV_PIX_FMT_GBRP10},
89	+ {IMGFMT_YUY2, AV_PIX_FMT_YUYV422},
90	+ {IMGFMT_UYVY, AV_PIX_FMT_UYVY422},
91	+ {IMGFMT_NV12, AV_PIX_FMT_NV12},
92	+ {IMGFMT_NV21, AV_PIX_FMT_NV21},
93	+ {IMGFMT_Y800, AV_PIX_FMT_GRAY8},
94	+ {IMGFMT_Y8, AV_PIX_FMT_GRAY8},
95	+ {IMGFMT_YVU9, AV_PIX_FMT_YUV410P},
96	+ {IMGFMT_IF09, AV_PIX_FMT_YUV410P},
97	+ {IMGFMT_YV12, AV_PIX_FMT_YUV420P},
98	+ {IMGFMT_I420, AV_PIX_FMT_YUV420P},
99	+ {IMGFMT_IYUV, AV_PIX_FMT_YUV420P},
100	+ {IMGFMT_411P, AV_PIX_FMT_YUV411P},
101	+ {IMGFMT_422P, AV_PIX_FMT_YUV422P},
102	+ {IMGFMT_444P, AV_PIX_FMT_YUV444P},
103	+ {IMGFMT_440P, AV_PIX_FMT_YUV440P},
104
105	- {IMGFMT_420A, PIX_FMT_YUVA420P},
106	+ {IMGFMT_420A, AV_PIX_FMT_YUVA420P},
107
108	- {IMGFMT_420P16_LE, PIX_FMT_YUV420P16LE},
109	- {IMGFMT_420P16_BE, PIX_FMT_YUV420P16BE},
110	- {IMGFMT_420P9_LE, PIX_FMT_YUV420P9LE},
111	- {IMGFMT_420P9_BE, PIX_FMT_YUV420P9BE},
112	- {IMGFMT_420P10_LE, PIX_FMT_YUV420P10LE},
113	- {IMGFMT_420P10_BE, PIX_FMT_YUV420P10BE},
114	- {IMGFMT_422P10_LE, PIX_FMT_YUV422P10LE},
115	- {IMGFMT_422P10_BE, PIX_FMT_YUV422P10BE},
116	- {IMGFMT_444P9_BE , PIX_FMT_YUV444P9BE},
117	- {IMGFMT_444P9_LE , PIX_FMT_YUV444P9LE},
118	- {IMGFMT_444P10_BE, PIX_FMT_YUV444P10BE},
119	- {IMGFMT_444P10_LE, PIX_FMT_YUV444P10LE},
120	- {IMGFMT_422P16_LE, PIX_FMT_YUV422P16LE},
121	- {IMGFMT_422P16_BE, PIX_FMT_YUV422P16BE},
122	- {IMGFMT_422P9_LE, PIX_FMT_YUV422P9LE},
123	- {IMGFMT_422P9_BE, PIX_FMT_YUV422P9BE},
124	- {IMGFMT_444P16_LE, PIX_FMT_YUV444P16LE},
125	- {IMGFMT_444P16_BE, PIX_FMT_YUV444P16BE},
126	+ {IMGFMT_420P16_LE, AV_PIX_FMT_YUV420P16LE},
127	+ {IMGFMT_420P16_BE, AV_PIX_FMT_YUV420P16BE},
128	+ {IMGFMT_420P9_LE, AV_PIX_FMT_YUV420P9LE},
129	+ {IMGFMT_420P9_BE, AV_PIX_FMT_YUV420P9BE},
130	+ {IMGFMT_420P10_LE, AV_PIX_FMT_YUV420P10LE},
131	+ {IMGFMT_420P10_BE, AV_PIX_FMT_YUV420P10BE},
132	+ {IMGFMT_422P10_LE, AV_PIX_FMT_YUV422P10LE},
133	+ {IMGFMT_422P10_BE, AV_PIX_FMT_YUV422P10BE},
134	+ {IMGFMT_444P9_BE , AV_PIX_FMT_YUV444P9BE},
135	+ {IMGFMT_444P9_LE , AV_PIX_FMT_YUV444P9LE},
136	+ {IMGFMT_444P10_BE, AV_PIX_FMT_YUV444P10BE},
137	+ {IMGFMT_444P10_LE, AV_PIX_FMT_YUV444P10LE},
138	+ {IMGFMT_422P16_LE, AV_PIX_FMT_YUV422P16LE},
139	+ {IMGFMT_422P16_BE, AV_PIX_FMT_YUV422P16BE},
140	+ {IMGFMT_422P9_LE, AV_PIX_FMT_YUV422P9LE},
141	+ {IMGFMT_422P9_BE, AV_PIX_FMT_YUV422P9BE},
142	+ {IMGFMT_444P16_LE, AV_PIX_FMT_YUV444P16LE},
143	+ {IMGFMT_444P16_BE, AV_PIX_FMT_YUV444P16BE},
144
145	// YUVJ are YUV formats that use the full Y range and not just
146	// 16 - 235 (see colorspaces.txt).
147	// Currently they are all treated the same way.
148	- {IMGFMT_YV12, PIX_FMT_YUVJ420P},
149	- {IMGFMT_422P, PIX_FMT_YUVJ422P},
150	- {IMGFMT_444P, PIX_FMT_YUVJ444P},
151	- {IMGFMT_440P, PIX_FMT_YUVJ440P},
152	+ {IMGFMT_YV12, AV_PIX_FMT_YUVJ420P},
153	+ {IMGFMT_422P, AV_PIX_FMT_YUVJ422P},
154	+ {IMGFMT_444P, AV_PIX_FMT_YUVJ444P},
155	+ {IMGFMT_440P, AV_PIX_FMT_YUVJ440P},
156
157	- {IMGFMT_VDPAU_MPEG1, PIX_FMT_VDPAU_MPEG1},
158	- {IMGFMT_VDPAU_MPEG2, PIX_FMT_VDPAU_MPEG2},
159	- {IMGFMT_VDPAU_H264, PIX_FMT_VDPAU_H264},
160	- {IMGFMT_VDPAU_WMV3, PIX_FMT_VDPAU_WMV3},
161	- {IMGFMT_VDPAU_VC1, PIX_FMT_VDPAU_VC1},
162	- {IMGFMT_VDPAU_MPEG4, PIX_FMT_VDPAU_MPEG4},
163	- {0, PIX_FMT_NONE}
164	+ {IMGFMT_VDPAU_MPEG1, AV_PIX_FMT_VDPAU_MPEG1},
165	+ {IMGFMT_VDPAU_MPEG2, AV_PIX_FMT_VDPAU_MPEG2},
166	+ {IMGFMT_VDPAU_H264, AV_PIX_FMT_VDPAU_H264},
167	+ {IMGFMT_VDPAU_WMV3, AV_PIX_FMT_VDPAU_WMV3},
168	+ {IMGFMT_VDPAU_VC1, AV_PIX_FMT_VDPAU_VC1},
169	+ {IMGFMT_VDPAU_MPEG4, AV_PIX_FMT_VDPAU_MPEG4},
170	+ {0, AV_PIX_FMT_NONE}
171	};
172
173	-enum PixelFormat imgfmt2pixfmt(int fmt)
174	+enum AVPixelFormat imgfmt2pixfmt(int fmt)
175	{
176	int i;
177	- enum PixelFormat pix_fmt;
178	+ enum AVPixelFormat pix_fmt;
179	for (i = 0; conversion_map[i].fmt; i++)
180	if (conversion_map[i].fmt == fmt)
181	break;
182	pix_fmt = conversion_map[i].pix_fmt;
183	- if (pix_fmt == PIX_FMT_NONE)
184	+ if (pix_fmt == AV_PIX_FMT_NONE)
185	mp_msg(MSGT_GLOBAL, MSGL_ERR, "Unsupported format %s\n", vo_format_name(fmt));
186	return pix_fmt;
187	}
188
189	-int pixfmt2imgfmt(enum PixelFormat pix_fmt)
190	+int pixfmt2imgfmt(enum AVPixelFormat pix_fmt)
191	{
192	int i;
193	- for (i = 0; conversion_map[i].pix_fmt != PIX_FMT_NONE; i++)
194	+ for (i = 0; conversion_map[i].pix_fmt != AV_PIX_FMT_NONE; i++)
195	if (conversion_map[i].pix_fmt == pix_fmt)
196	break;
197	int fmt = conversion_map[i].fmt;
198	if (!fmt) {
199	const char *fmtname = av_get_pix_fmt_name(pix_fmt);
200	- mp_msg(MSGT_GLOBAL, MSGL_ERR, "Unsupported PixelFormat %s (%d)\n",
201	+ mp_msg(MSGT_GLOBAL, MSGL_ERR, "Unsupported AVPixelFormat %s (%d)\n",
202	fmtname ? fmtname : "INVALID", pix_fmt);
203	}
204	return fmt;

Line 0 Link Here

(-)mplayer2/files/patch-fmt-conversion.h (+12 lines)
	1	--- fmt-conversion.h.orig 2016-11-29 15:06:09 UTC
	2	+++ fmt-conversion.h
	3	@@ -22,7 +22,7 @@
	4	#include "libavutil/avutil.h"
	5	#include <libavutil/pixfmt.h>
	6
	7	-enum PixelFormat imgfmt2pixfmt(int fmt);
	8	-int pixfmt2imgfmt(enum PixelFormat pix_fmt);
	9	+enum AVPixelFormat imgfmt2pixfmt(int fmt);
	10	+int pixfmt2imgfmt(enum AVPixelFormat pix_fmt);
	11
	12	#endif /* MPLAYER_FMT_CONVERSION_H */

Line 0 Link Here

(-)mplayer2/files/patch-libaf_af__lavcac3enc.c (+28 lines)
	1	--- libaf/af_lavcac3enc.c.orig 2013-07-09 16:33:12 UTC
	2	+++ libaf/af_lavcac3enc.c
	3	@@ -27,7 +27,6 @@
	4	#include <assert.h>
	5
	6	#include <libavcodec/avcodec.h>
	7	-#include <libavutil/audioconvert.h>
	8	#include <libavutil/error.h>
	9	#include <libavutil/intreadwrite.h>
	10	#include <libavutil/mem.h>
	11	@@ -219,7 +218,7 @@ static void uninit(struct af_instance_s*
	12	av_free(s->lavc_actx);
	13	}
	14	#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
	15	- avcodec_free_frame(&s->frame);
	16	+ av_frame_free(&s->frame);
	17	#else
	18	av_freep(&s->frame);
	19	#endif
	20	@@ -398,7 +397,7 @@ static int af_open(af_instance_t* af){
	21	mp_tmsg(MSGT_AFILTER, MSGL_ERR, "Audio LAVC, couldn't allocate context!\n");
	22	return AF_ERROR;
	23	}
	24	- s->frame = avcodec_alloc_frame();
	25	+ s->frame = av_frame_alloc();
	26	if (!s->frame)
	27	return AF_ERROR;
	28	const enum AVSampleFormat *fmts = s->lavc_acodec->sample_fmts;

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_ad__ffmpeg.c (+36 lines)
	1	--- libmpcodecs/ad_ffmpeg.c.orig 2013-07-09 16:33:13 UTC
	2	+++ libmpcodecs/ad_ffmpeg.c
	3	@@ -23,7 +23,6 @@
	4	#include <assert.h>
	5
	6	#include <libavcodec/avcodec.h>
	7	-#include <libavutil/audioconvert.h>
	8	#include <libavutil/opt.h>
	9	#include <libavutil/samplefmt.h>
	10
	11	@@ -236,7 +235,7 @@ static int init(sh_audio_t *sh_audio)
	12	sh_audio->context = ctx;
	13	lavc_context = avcodec_alloc_context3(lavc_codec);
	14	ctx->avctx = lavc_context;
	15	- ctx->avframe = avcodec_alloc_frame();
	16	+ ctx->avframe = av_frame_alloc();
	17
	18	// Always try to set - option only exists for AC3 at the moment
	19	av_opt_set_double(lavc_context, "drc_scale", opts->drc_level,
	20	@@ -250,7 +249,6 @@ static int init(sh_audio_t *sh_audio)
	21	lavc_context->block_align = sh_audio->wf->nBlockAlign;
	22	lavc_context->bits_per_coded_sample = sh_audio->wf->wBitsPerSample;
	23	}
	24	- lavc_context->request_channels = opts->audio_output_channels;
	25	lavc_context->codec_tag = sh_audio->format; //FOURCC
	26	lavc_context->codec_type = AVMEDIA_TYPE_AUDIO;
	27	lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
	28	@@ -333,7 +331,7 @@ static void uninit(sh_audio_t *sh)
	29	avresample_free(&ctx->avr);
	30	#endif
	31	#if LIBAVCODEC_VERSION_INT >= (54 << 16 \| 28 << 8)
	32	- avcodec_free_frame(&ctx->avframe);
	33	+ av_frame_free(&ctx->avframe);
	34	#else
	35	av_free(ctx->avframe);
	36	#endif

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_dec__teletext.c (+37 lines)
	1	--- libmpcodecs/dec_teletext.c.orig 2013-07-09 16:33:13 UTC
	2	+++ libmpcodecs/dec_teletext.c
	3	@@ -402,6 +402,25 @@ struct {
	4	{ 0x00, LATIN, "English"},
	5	};
	6
	7	+static const uint8_t reverse[256] = {
	8	+0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
	9	+0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
	10	+0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
	11	+0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
	12	+0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
	13	+0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
	14	+0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
	15	+0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
	16	+0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
	17	+0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
	18	+0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
	19	+0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
	20	+0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
	21	+0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
	22	+0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
	23	+0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
	24	+};
	25	+
	26	/**
	27	* \brief 24/18 Hamming code decoding
	28	* \param data bytes with hamming code (array must be at least 3 bytes long)
	29	@@ -1549,7 +1568,7 @@ static void vbi_decode_dvb(priv_vbi_t *p
	30	/* Reverse bit order, skipping the first two bytes (field parity, line
	31	offset and framing code). */
	32	for (i = 0; i < sizeof(data); i++)
	33	- data[i] = av_reverse[buf[2 + i]];
	34	+ data[i] = reverse[buf[2 + i]];
	35
	36	vbi_decode_line(priv, data);
	37	if (priv->cache_reset)

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vd__ffmpeg.c (+356 lines)
		1	--- libmpcodecs/vd_ffmpeg.c.orig 2013-07-09 16:33:13 UTC
		2	+++ libmpcodecs/vd_ffmpeg.c
		3	@@ -25,6 +25,7 @@
		4	#include <libavutil/common.h>
		5	#include <libavutil/opt.h>
		6	#include <libavutil/intreadwrite.h>
		7	+#include <libavutil/pixdesc.h>
		8
		9	#include "talloc.h"
		10	#include "config.h"
		11	@@ -61,7 +62,7 @@ static const vd_info_t info = {
		12	typedef struct {
		13	AVCodecContext *avctx;
		14	AVFrame *pic;
		15	- enum PixelFormat pix_fmt;
		16	+ enum AVPixelFormat pix_fmt;
		17	int do_slices;
		18	int do_dr1;
		19	int vo_initialized;
		20	@@ -77,13 +78,16 @@ typedef struct {
		21
		22	#include "m_option.h"
		23
		24	-static int get_buffer(AVCodecContext avctx, AVFrame pic);
		25	+static int get_buffer(AVCodecContext avctx, AVFrame pic, int isreference);
		26	+static int mpcodec_default_get_buffer(AVCodecContext avctx, AVFrame frame);
		27	+static int get_buffer2(AVCodecContext avctx, AVFrame frame, int flags);
		28	static void release_buffer(AVCodecContext avctx, AVFrame pic);
		29	+static void mpcodec_default_release_buffer(AVCodecContext s, AVFrame pic);
		30	static void draw_slice(struct AVCodecContext s, const AVFrame src,
		31	int offset[4], int y, int type, int height);
		32
		33	-static enum PixelFormat get_format(struct AVCodecContext *avctx,
		34	- const enum PixelFormat *pix_fmt);
		35	+static enum AVPixelFormat get_format(struct AVCodecContext *avctx,
		36	+ const enum AVPixelFormat *pix_fmt);
		37	static void uninit(struct sh_video *sh);
		38
		39	const m_option_t lavc_decode_opts_conf[] = {
		40	@@ -169,7 +173,7 @@ static int init(sh_video_t *sh)
		41	ctx->do_dr1 = 1;
		42	ctx->ip_count = ctx->b_count = 0;
		43
		44	- ctx->pic = avcodec_alloc_frame();
		45	+ ctx->pic = av_frame_alloc();
		46	ctx->avctx = avcodec_alloc_context3(lavc_codec);
		47	avctx = ctx->avctx;
		48	avctx->opaque = sh;
		49	@@ -182,9 +186,7 @@ static int init(sh_video_t *sh)
		50	ctx->do_slices = true;
		51	lavc_param->threads = 1;
		52	avctx->get_format = get_format;
		53	- avctx->get_buffer = get_buffer;
		54	- avctx->release_buffer = release_buffer;
		55	- avctx->reget_buffer = get_buffer;
		56	+ avctx->get_buffer2 = get_buffer2;
		57	avctx->draw_horiz_band = draw_slice;
		58	if (lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
		59	mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] VDPAU hardware "
		60	@@ -212,10 +214,7 @@ static int init(sh_video_t *sh)
		61	}
		62
		63	if (ctx->do_dr1) {
		64	- avctx->flags \|= CODEC_FLAG_EMU_EDGE;
65	- avctx->get_buffer = get_buffer;
66	- avctx->release_buffer = release_buffer;
67	- avctx->reget_buffer = get_buffer;
68	+ avctx->get_buffer2 = get_buffer2;
69	}
70
71	avctx->flags \|= lavc_param->bitexact;
72	@@ -227,7 +226,6 @@ static int init(sh_video_t *sh)
73	avctx->flags \|= CODEC_FLAG_GRAY;
74	avctx->flags2 \|= lavc_param->fast;
75	avctx->codec_tag = sh->format;
76	- avctx->stream_codec_tag = sh->video.fccHandler;
77	avctx->idct_algo = lavc_param->idct_algo;
78	avctx->error_concealment = lavc_param->error_concealment;
79	avctx->debug = lavc_param->debug;
80	@@ -357,7 +355,7 @@ static void uninit(sh_video_t *sh)
81
82	av_freep(&avctx);
83	#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
84	- avcodec_free_frame(&ctx->pic);
85	+ av_frame_free(&ctx->pic);
86	#else
87	av_freep(&ctx->pic);
88	#endif
89	@@ -423,7 +421,7 @@ static enum mp_csp_levels avcol_range_to
90	}
91	}
92
93	-static int init_vo(sh_video_t *sh, enum PixelFormat pix_fmt)
94	+static int init_vo(sh_video_t *sh, enum AVPixelFormat pix_fmt)
95	{
96	vd_ffmpeg_ctx *ctx = sh->context;
97	AVCodecContext *avctx = ctx->avctx;
98	@@ -488,7 +486,7 @@ static int init_vo(sh_video_t *sh, enum
99	return 0;
100	}
101
102	-static int get_buffer(AVCodecContext avctx, AVFrame pic)
103	+static int get_buffer(AVCodecContext avctx, AVFrame pic, int isreference)
104	{
105	sh_video_t *sh = avctx->opaque;
106	vd_ffmpeg_ctx *ctx = sh->context;
107	@@ -499,29 +497,11 @@ static int get_buffer(AVCodecContext *av
108	int width = avctx->width;
109	int height = avctx->height;
110	// special case to handle reget_buffer without buffer hints
111	- if (pic->opaque && pic->data[0] && !pic->buffer_hints)
112	+ if (pic->opaque && pic->data[0])
113	return 0;
114	avcodec_align_dimensions(avctx, &width, &height);
115
116	- if (pic->buffer_hints) {
117	- mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "Buffer hints: %u\n",
118	- pic->buffer_hints);
119	- type = MP_IMGTYPE_TEMP;
120	- if (pic->buffer_hints & FF_BUFFER_HINTS_READABLE)
121	- flags \|= MP_IMGFLAG_READABLE;
122	- if (pic->buffer_hints & FF_BUFFER_HINTS_PRESERVE) {
123	- type = MP_IMGTYPE_STATIC;
124	- flags \|= MP_IMGFLAG_PRESERVE;
125	- }
126	- if (pic->buffer_hints & FF_BUFFER_HINTS_REUSABLE) {
127	- type = MP_IMGTYPE_STATIC;
128	- flags \|= MP_IMGFLAG_PRESERVE;
129	- }
130	- flags \|= ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0;
131	- mp_msg(MSGT_DECVIDEO, MSGL_DBG2,
132	- type == MP_IMGTYPE_STATIC ? "using STATIC\n" : "using TEMP\n");
133	- } else {
134	- if (!pic->reference) {
135	+ if (!isreference) {
136	ctx->b_count++;
137	flags \|= ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0;
138	} else {
139	@@ -529,29 +509,25 @@ static int get_buffer(AVCodecContext *av
140	flags \|= MP_IMGFLAG_PRESERVE \| MP_IMGFLAG_READABLE
141	\| (ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0);
142	}
143	- }
144
145	if (init_vo(sh, avctx->pix_fmt) < 0) {
146	- avctx->release_buffer = avcodec_default_release_buffer;
147	- avctx->get_buffer = avcodec_default_get_buffer;
148	- avctx->reget_buffer = avcodec_default_reget_buffer;
149	+ avctx->get_buffer2 = avcodec_default_get_buffer2;
150	if (pic->data[0])
151	- release_buffer(avctx, pic);
152	- return avctx->get_buffer(avctx, pic);
153	+ mpcodec_default_release_buffer(avctx, pic);
154	+ return avctx->get_buffer2(avctx, pic,0);
155	}
156
157	if (IMGFMT_IS_HWACCEL(ctx->best_csp))
158	type = MP_IMGTYPE_NUMBERED \| (0xffff << 16);
159	- else if (!pic->buffer_hints) {
160	+ else {
161	if (ctx->b_count > 1 \|\| ctx->ip_count > 2) {
162	mp_tmsg(MSGT_DECVIDEO, MSGL_WARN, "[VD_FFMPEG] DRI failure.\n");
163
164	ctx->do_dr1 = 0; //FIXME
165	- avctx->get_buffer = avcodec_default_get_buffer;
166	- avctx->reget_buffer = avcodec_default_reget_buffer;
167	+ avctx->get_buffer2 = avcodec_default_get_buffer2;
168	if (pic->data[0])
169	- release_buffer(avctx, pic);
170	- return avctx->get_buffer(avctx, pic);
171	+ mpcodec_default_release_buffer(avctx, pic);
172	+ return avctx->get_buffer2(avctx, pic,0);
173	}
174
175	if (avctx->has_b_frames \|\| ctx->b_count)
176	@@ -594,7 +570,6 @@ static int get_buffer(AVCodecContext *av
177
178	pic->opaque = mpi;
179
180	- pic->type = FF_BUFFER_TYPE_USER;
181
182	/* The libavcodec reordered_opaque functionality is implemented by
183	* a similar copy in avcodec_default_get_buffer() and without a
184	@@ -626,8 +601,8 @@ static void release_buffer(struct AVCode
185	mpi->usage_count--;
186	}
187
188	- if (pic->type != FF_BUFFER_TYPE_USER) {
189	- avcodec_default_release_buffer(avctx, pic);
190	+ if (pic->opaque == NULL) {
191	+ mpcodec_default_release_buffer(avctx, pic);
192	return;
193	}
194
195	@@ -822,13 +797,13 @@ static struct mp_image *decode(struct sh
196	return mpi;
197	}
198
199	-static enum PixelFormat get_format(struct AVCodecContext *avctx,
200	- const enum PixelFormat *fmt)
201	+static enum AVPixelFormat get_format(struct AVCodecContext *avctx,
202	+ const enum AVPixelFormat *fmt)
203	{
204	sh_video_t *sh = avctx->opaque;
205	int i;
206
207	- for (i = 0; fmt[i] != PIX_FMT_NONE; i++) {
208	+ for (i = 0; fmt[i] != AV_PIX_FMT_NONE; i++) {
209	int imgfmt = pixfmt2imgfmt(fmt[i]);
210	if (!IMGFMT_IS_HWACCEL(imgfmt))
211	continue;
212	@@ -886,3 +861,144 @@ const struct vd_functions mpcodecs_vd_ff
213	.control = control,
214	.decode2 = decode
215	};
216	+
217	+/*
218	+FFWrapper
219	+*/
220	+static int mpcodec_default_get_buffer(AVCodecContext avctx, AVFrame frame)
221	+{
222	+ return avcodec_default_get_buffer2(avctx, frame, 0);
223	+}
224	+
225	+static void mpcodec_default_release_buffer(AVCodecContext s, AVFrame pic)
226	+{
227	+ av_frame_unref(pic);
228	+}
229	+
230	+typedef struct CompatReleaseBufPriv {
231	+ AVCodecContext avctx;
232	+ AVFrame frame;
233	+ uint8_t avframe_padding[1024]; // hack to allow linking to a avutil larger AVFrame
234	+} CompatReleaseBufPriv;
235	+
236	+static void compat_free_buffer(void opaque, uint8_t data)
237	+{
238	+ CompatReleaseBufPriv *priv = opaque;
239	+ release_buffer(&priv->avctx, &priv->frame);
240	+ av_freep(&priv);
241	+}
242	+
243	+static void compat_release_buffer(void opaque, uint8_t data)
244	+{
245	+ AVBufferRef *buf = opaque;
246	+ av_buffer_unref(&buf);
247	+}
248	+
249	+static int get_buffer2(AVCodecContext avctx, AVFrame frame, int flags)
250	+{
251	+ /*
252	+ * Wrap an old get_buffer()-allocated buffer in a bunch of AVBuffers.
253	+ * We wrap each plane in its own AVBuffer. Each of those has a reference to
254	+ * a dummy AVBuffer as its private data, unreffing it on free,
255	+ * When all the planes are freed, the dummy buffer's free callback calls
256	+ * release_buffer().
257	+ */
258	+ CompatReleaseBufPriv *priv = NULL;
259	+ AVBufferRef *dummy_buf = NULL;
260	+ int planes, i, ret;
261	+
262	+ ret = get_buffer(avctx, frame, flags & AV_GET_BUFFER_FLAG_REF);
263	+ if (ret < 0)
264	+ return ret;
265	+
266	+ /* return if the buffers are already set up
267	+ * this would happen e.g. when a custom get_buffer() calls
268	+ * avcodec_default_get_buffer
269	+ */
270	+ if (frame->buf[0])
271	+ goto end0;
272	+
273	+ priv = av_mallocz(sizeof(*priv));
274	+ if (!priv) {
275	+ ret = AVERROR(ENOMEM);
276	+ goto fail;
277	+ }
278	+ priv->avctx = *avctx;
279	+ priv->frame = *frame;
280	+
281	+ dummy_buf = av_buffer_create(NULL, 0, compat_free_buffer, priv, 0);
282	+ if (!dummy_buf) {
283	+ ret = AVERROR(ENOMEM);
284	+ goto fail;
285	+ }
286	+
287	+#define WRAP_PLANE(ref_out, data, data_size) \
288	+do { \
289	+ AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf); \
290	+ if (!dummy_ref) { \
291	+ ret = AVERROR(ENOMEM); \
292	+ goto fail; \
293	+ } \
294	+ ref_out = av_buffer_create(data, data_size, compat_release_buffer, \
295	+ dummy_ref, 0); \
296	+ if (!ref_out) { \
297	+ av_buffer_unref(&dummy_ref); \
298	+ av_frame_unref(frame); \
299	+ ret = AVERROR(ENOMEM); \
300	+ goto fail; \
301	+ } \
302	+} while (0)
303	+
304	+ if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
305	+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
306	+
307	+ planes = av_pix_fmt_count_planes(frame->format);
308	+ /* workaround for AVHWAccel plane count of 0, buf[0] is used as
309	+ check for allocated buffers: make libavcodec happy */
310	+ if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
311	+ planes = 1;
312	+ if (!desc \|\| planes <= 0) {
313	+ ret = AVERROR(EINVAL);
314	+ goto fail;
315	+ }
316	+
317	+ for (i = 0; i < planes; i++) {
318	+ int v_shift = (i == 1 \|\| i == 2) ? desc->log2_chroma_h : 0;
319	+ int plane_size = (frame->height >> v_shift) * frame->linesize[i];
320	+
321	+ WRAP_PLANE(frame->buf[i], frame->data[i], plane_size);
322	+ }
323	+ } else {
324	+ int planar = av_sample_fmt_is_planar(frame->format);
325	+ planes = planar ? avctx->channels : 1;
326	+
327	+ if (planes > FF_ARRAY_ELEMS(frame->buf)) {
328	+ frame->nb_extended_buf = planes - FF_ARRAY_ELEMS(frame->buf);
329	+ frame->extended_buf = av_malloc_array(sizeof(*frame->extended_buf),
330	+ frame->nb_extended_buf);
331	+ if (!frame->extended_buf) {
332	+ ret = AVERROR(ENOMEM);
333	+ goto fail;
334	+ }
335	+ }
336	+
337	+ for (i = 0; i < FFMIN(planes, FF_ARRAY_ELEMS(frame->buf)); i++)
338	+ WRAP_PLANE(frame->extended_buf[i],
339	+ frame->extended_data[i + FF_ARRAY_ELEMS(frame->buf)],
340	+ frame->linesize[0]);
341	+ }
342	+
343	+ av_buffer_unref(&dummy_buf);
344	+
345	+end0:
346	+ frame->width = avctx->width;
347	+ frame->height = avctx->height;
348	+
349	+ return 0;
350	+
351	+fail:
352	+ release_buffer(avctx, frame);
353	+ av_freep(&priv);
354	+ av_buffer_unref(&dummy_buf);
355	+ return ret;
356	+}

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__halfpack.c (+15 lines)
	1	--- libmpcodecs/vf_halfpack.c.orig 2013-07-09 16:33:16 UTC
	2	+++ libmpcodecs/vf_halfpack.c
	3	@@ -198,9 +198,9 @@ static int config(struct vf_instance *vf
	4	sws_freeContext(vf->priv->ctx);
	5	// get unscaled 422p -> yuy2 conversion
	6	vf->priv->ctx =
	7	- sws_getContext(width, height / 2, PIX_FMT_YUV422P,
	8	- width, height / 2, PIX_FMT_YUYV422,
	9	- SWS_POINT \| SWS_PRINT_INFO \| get_sws_cpuflags(),
	10	+ sws_getContext(width, height / 2, AV_PIX_FMT_YUV422P,
	11	+ width, height / 2, AV_PIX_FMT_YUYV422,
	12	+ SWS_POINT \| SWS_PRINT_INFO,
	13	NULL, NULL, NULL);
	14	}
	15	/* FIXME - also support UYVY output? */

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__lavc.c (+20 lines)
	1	--- libmpcodecs/vf_lavc.c.orig 2013-07-09 16:33:16 UTC
	2	+++ libmpcodecs/vf_lavc.c
	3	@@ -139,7 +139,7 @@ static int vf_open(vf_instance_t *vf, ch
	4	}
	5
	6	vf->priv->context=avcodec_alloc_context3(vf->priv->codec);
	7	- vf->priv->pic = avcodec_alloc_frame();
	8	+ vf->priv->pic = av_frame_alloc();
	9
	10	// TODO: parse args ->
	11	if(args) sscanf(args, "%d:%f", &p_quality, &p_fps);
	12	@@ -156,7 +156,7 @@ static int vf_open(vf_instance_t *vf, ch
	13	lavc_venc_context.time_base.num = 1000*1001;
	14	lavc_venc_context.time_base.den = (p_fps<1.0) ? 1000100125 : (p_fps * lavc_venc_context.time_base.num);
	15	lavc_venc_context.gop_size = 0; // I-only
	16	- lavc_venc_context.pix_fmt= PIX_FMT_YUV420P;
	17	+ lavc_venc_context.pix_fmt= AV_PIX_FMT_YUV420P;
	18
	19	return 1;
	20	}

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__lavcdeint.c (+20 lines)
	1	--- libmpcodecs/vf_lavcdeint.c.orig 2013-07-09 16:33:16 UTC
	2	+++ libmpcodecs/vf_lavcdeint.c
	3	@@ -59,7 +59,7 @@ imgfmt_to_pixfmt (int imgfmt)
	4	case IMGFMT_YV12:
	5	case IMGFMT_I420:
	6	case IMGFMT_IYUV:
	7	- return PIX_FMT_YUV420P;
	8	+ return AV_PIX_FMT_YUV420P;
	9	break;
	10
	11	#if 0
	12	@@ -73,7 +73,7 @@ imgfmt_to_pixfmt (int imgfmt)
	13	case IMGFMT_Y42T:
	14	case IMGFMT_V422:
	15	case IMGFMT_V655:
	16	- return PIX_FMT_YUV422P;
	17	+ return AV_PIX_FMT_YUV422P;
	18	break;
	19	#endif
	20

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__scale.c (+78 lines)
		1	--- libmpcodecs/vf_scale.c.orig 2013-07-09 16:33:16 UTC
		2	+++ libmpcodecs/vf_scale.c
		3	@@ -201,7 +201,7 @@ static int config(struct vf_instance *vf
		4	int round_w=0, round_h=0;
		5	int i;
		6	SwsFilter srcFilter, dstFilter;
		7	- enum PixelFormat dfmt, sfmt;
		8	+ enum AVPixelFormat dfmt, sfmt;
		9
		10	vf->priv->colorspace = (struct mp_csp_details) {0};
		11
		12	@@ -210,7 +210,7 @@ static int config(struct vf_instance *vf
		13	return 0;
		14	}
		15	sfmt = imgfmt2pixfmt(outfmt);
		16	- if (outfmt == IMGFMT_RGB8 \|\| outfmt == IMGFMT_BGR8) sfmt = PIX_FMT_PAL8;
		17	+ if (outfmt == IMGFMT_RGB8 \|\| outfmt == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;
		18	dfmt = imgfmt2pixfmt(best);
		19
		20	vo_flags=vf->next->query_format(vf->next,best);
		21	@@ -319,13 +319,13 @@ static int config(struct vf_instance *vf
		22	sfmt,
		23	vf->priv->w, vf->priv->h >> vf->priv->interlaced,
		24	dfmt,
		25	- int_sws_flags \| get_sws_cpuflags(), srcFilter, dstFilter, vf->priv->param);
		26	+ int_sws_flags, srcFilter, dstFilter, vf->priv->param);
		27	if(vf->priv->interlaced){
		28	vf->priv->ctx2=sws_getContext(width, height >> 1,
		29	sfmt,
		30	vf->priv->w, vf->priv->h >> 1,
		31	dfmt,
		32	- int_sws_flags \| get_sws_cpuflags(), srcFilter, dstFilter, vf->priv->param);
		33	+ int_sws_flags, srcFilter, dstFilter, vf->priv->param);
		34	}
		35	if(!vf->priv->ctx){
		36	// error...
		37	@@ -612,7 +612,7 @@ error_out:
		38	// supported Input formats: YV12, I420, IYUV, YUY2, UYVY, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8, Y800
		39
		40	static int query_format(struct vf_instance *vf, unsigned int fmt){
		41	- if (!IMGFMT_IS_HWACCEL(fmt) && imgfmt2pixfmt(fmt) != PIX_FMT_NONE) {
		42	+ if (!IMGFMT_IS_HWACCEL(fmt) && imgfmt2pixfmt(fmt) != AV_PIX_FMT_NONE) {
		43	unsigned int best=find_best_out(vf, fmt);
		44	int flags;
		45	if(!best) return 0; // no matching out-fmt
		46	@@ -661,14 +661,6 @@ int sws_chr_hshift= 0;
		47	float sws_chr_sharpen= 0.0;
		48	float sws_lum_sharpen= 0.0;
		49
		50	-int get_sws_cpuflags(void){
		51	- return
		52	- (gCpuCaps.hasMMX ? SWS_CPU_CAPS_MMX : 0)
		53	- \| (gCpuCaps.hasMMX2 ? SWS_CPU_CAPS_MMX2 : 0)
		54	- \| (gCpuCaps.has3DNow ? SWS_CPU_CAPS_3DNOW : 0)
		55	- \| (gCpuCaps.hasAltiVec ? SWS_CPU_CAPS_ALTIVEC : 0);
		56	-}
		57	-
		58	void sws_getFlagsAndFilterFromCmdLine(int flags, SwsFilter srcFilterParam, SwsFilter *dstFilterParam)
		59	{
		60	static int firstTime=1;
		61	@@ -717,14 +709,14 @@ static struct SwsContext *sws_getContext
		62	{
		63	int flags;
		64	SwsFilter dstFilterParam, srcFilterParam;
65	- enum PixelFormat dfmt, sfmt;
66	+ enum AVPixelFormat dfmt, sfmt;
67
68	dfmt = imgfmt2pixfmt(dstFormat);
69	sfmt = imgfmt2pixfmt(srcFormat);
70	- if (srcFormat == IMGFMT_RGB8 \|\| srcFormat == IMGFMT_BGR8) sfmt = PIX_FMT_PAL8;
71	+ if (srcFormat == IMGFMT_RGB8 \|\| srcFormat == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;
72	sws_getFlagsAndFilterFromCmdLine(&flags, &srcFilterParam, &dstFilterParam);
73
74	- return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags \| extraflags \| get_sws_cpuflags(), srcFilterParam, dstFilterParam, NULL);
75	+ return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags, srcFilterParam, dstFilterParam, NULL);
76	}
77
78	struct SwsContext *sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)

Line 0 Link Here

(-)mplayer2/files/patch-libmpcodecs_vf__screenshot.c (+14 lines)
	1	--- libmpcodecs/vf_screenshot.c.orig 2016-11-30 00:06:27 UTC
	2	+++ libmpcodecs/vf_screenshot.c
	3	@@ -167,9 +167,9 @@ static int control (vf_instance_t *vf, i
	4
	5	static int query_format(struct vf_instance *vf, unsigned int fmt)
	6	{
	7	- enum PixelFormat av_format = imgfmt2pixfmt(fmt);
	8	+ enum AVPixelFormat av_format = imgfmt2pixfmt(fmt);
	9
	10	- if (av_format != PIX_FMT_NONE && sws_isSupportedInput(av_format))
	11	+ if (av_format != AV_PIX_FMT_NONE && sws_isSupportedInput(av_format))
	12	return vf_next_query_format(vf, fmt);
	13	return 0;
	14	}

Lines 1-4 Link Here

(-)mplayer2/files/patch-libmpdemux_demux__lavf.c (-1 / +13 lines)
1	--- libmpdemux/demux_lavf.c.orig 2016-03-16 10:57:42 UTC	1	--- libmpdemux/demux_lavf.c.orig 2013-07-09 16:33:16 UTC
2	+++ libmpdemux/demux_lavf.c	2	+++ libmpdemux/demux_lavf.c
3	@@ -159,6 +159,7 @@ static int lavf_check_file(demuxer_t *de	3	@@ -159,6 +159,7 @@ static int lavf_check_file(demuxer_t *de
4	int probe_data_size = 0;	4	int probe_data_size = 0;
Lines 16-18 Link Here
16	priv->avif = av_probe_input_format2(&avpd, probe_data_size > 0, &score);	16	priv->avif = av_probe_input_format2(&avpd, probe_data_size > 0, &score);
17	read_size = FFMIN(2 * read_size, PROBE_BUF_SIZE - probe_data_size);	17	read_size = FFMIN(2 * read_size, PROBE_BUF_SIZE - probe_data_size);
18	} while ((demuxer->desc->type != DEMUXER_TYPE_LAVF_PREFERRED \|\|	18	} while ((demuxer->desc->type != DEMUXER_TYPE_LAVF_PREFERRED \|\|
		19	@@ -383,9 +385,9 @@ static void handle_stream(demuxer_t *dem
		20
		21	if (codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
		22	switch (codec->pix_fmt) {
		23	- case PIX_FMT_RGB24:
		24	+ case AV_PIX_FMT_RGB24:
		25	codec->codec_tag = MKTAG(24, 'B', 'G', 'R');
		26	- case PIX_FMT_BGR24:
		27	+ case AV_PIX_FMT_BGR24:
		28	codec->codec_tag = MKTAG(24, 'R', 'G', 'B');
		29	}
		30	if (!codec->codec_tag)

Line 0 Link Here

(-)mplayer2/files/patch-screenshot.c (+38 lines)
	1	--- screenshot.c.orig 2013-07-09 16:33:27 UTC
	2	+++ screenshot.c
	3	@@ -57,7 +57,7 @@ static int destroy_ctx(void *ptr)
	4	{
	5	struct screenshot_ctx *ctx = ptr;
	6	#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
	7	- avcodec_free_frame(&ctx->pic);
	8	+ av_frame_free(&ctx->pic);
	9	#else
	10	av_free(ctx->pic);
	11	#endif
	12	@@ -69,7 +69,7 @@ static screenshot_ctx *screenshot_get_ct
	13	if (!mpctx->screenshot_ctx) {
	14	struct screenshot_ctx *ctx = talloc_zero(mpctx, screenshot_ctx);
	15	talloc_set_destructor(ctx, destroy_ctx);
	16	- ctx->pic = avcodec_alloc_frame();
	17	+ ctx->pic = av_frame_alloc();
	18	assert(ctx->pic);
	19	mpctx->screenshot_ctx = ctx;
	20	}
	21	@@ -94,7 +94,7 @@ static int write_png(screenshot_ctx *ctx
	22	avctx->time_base = AV_TIME_BASE_Q;
	23	avctx->width = image->width;
	24	avctx->height = image->height;
	25	- avctx->pix_fmt = PIX_FMT_RGB24;
	26	+ avctx->pix_fmt = AV_PIX_FMT_RGB24;
	27	avctx->compression_level = 0;
	28
	29	if (avcodec_open2(avctx, png_codec, NULL) < 0) {
	30	@@ -110,7 +110,7 @@ static int write_png(screenshot_ctx *ctx
	31	goto error_exit;
	32
	33	AVFrame *pic = ctx->pic;
	34	- avcodec_get_frame_defaults(pic);
	35	+ av_frame_unref(pic);
	36	for (int n = 0; n < 4; n++) {
	37	pic->data[n] = image->planes[n];
	38	pic->linesize[n] = image->stride[n];