media-video/mplayer: backport upstream patch to build against ffmpeg git master

Package-Manager: portage-2.2.20.1

9 files changed, 1021 insertions, 0 deletions

diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-alloc.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-alloc.patch
new file mode 100644
index 000000000000..72ad5ee86a87
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-alloc.patch
@@ -0,0 +1,58 @@
+r37445 | rtogni | 2015-08-08 22:25:14 +0200 (Sat, 08 Aug 2015) | 3 lines
+
+Replace deprecated avcodec_alloc_frame() with av_frame_alloc()
+
+Index: libmpcodecs/vf_mcdeint.c
+===================================================================
+--- libmpcodecs/vf_mcdeint.c	(revision 37444)
++++ libmpcodecs/vf_mcdeint.c	(revision 37445)
+@@ -251,7 +251,7 @@
+             av_dict_free(&opts);
+ 
+         }
+-        vf->priv->frame= avcodec_alloc_frame();
++        vf->priv->frame= av_frame_alloc();
+ 
+         vf->priv->outbuf_size= width*height*10;
+         vf->priv->outbuf= malloc(vf->priv->outbuf_size);
+Index: libmpcodecs/vf_lavc.c
+===================================================================
+--- libmpcodecs/vf_lavc.c	(revision 37444)
++++ libmpcodecs/vf_lavc.c	(revision 37445)
+@@ -144,7 +144,7 @@
+     }
+ 
+     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);
+Index: libmpcodecs/ve_lavc.c
+===================================================================
+--- libmpcodecs/ve_lavc.c	(revision 37444)
++++ libmpcodecs/ve_lavc.c	(revision 37445)
+@@ -987,7 +987,7 @@
+ 	return 0;
+     }
+ 
+-    vf->priv->pic = avcodec_alloc_frame();
++    vf->priv->pic = av_frame_alloc();
+     vf->priv->context = avcodec_alloc_context3(vf->priv->codec);
+     vf->priv->context->codec_id = vf->priv->codec->id;
+ 
+Index: libmpcodecs/vf_uspp.c
+===================================================================
+--- libmpcodecs/vf_uspp.c	(revision 37444)
++++ libmpcodecs/vf_uspp.c	(revision 37445)
+@@ -244,8 +244,8 @@
+             av_dict_free(&opts);
+             assert(avctx_enc->codec);
+         }
+-        vf->priv->frame= avcodec_alloc_frame();
+-        vf->priv->frame_dec= avcodec_alloc_frame();
++        vf->priv->frame= av_frame_alloc();
++        vf->priv->frame_dec= av_frame_alloc();
+ 
+         vf->priv->outbuf_size= (width + BLOCK)*(height + BLOCK)*10;
+         vf->priv->outbuf= malloc(vf->priv->outbuf_size);
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-av_fmt.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-av_fmt.patch
new file mode 100644
index 000000000000..07e34f7ff052
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-av_fmt.patch
@@ -0,0 +1,432 @@
+r37443 | reimar | 2015-08-01 09:44:07 +0200 (Sat, 01 Aug 2015) | 1 line
+
+Add AV_ prefix to all PIX_FMT constants used.
+
+
+Index: libvo/mga_template.c
+===================================================================
+--- libvo/mga_template.c	(revision 37442)
++++ libvo/mga_template.c	(revision 37443)
+@@ -74,7 +74,7 @@
+ 	int dst_stride[4] = { bespitch, bespitch };
+ 	uint8_t *dst[4];
+ 
+-	av_image_fill_pointers(dst, PIX_FMT_NV12, mga_vid_config.src_height,
++	av_image_fill_pointers(dst, AV_PIX_FMT_NV12, mga_vid_config.src_height,
+ 	                       vid_data, dst_stride);
+ 
+ 	sws_scale(sws_ctx, image, stride, y, height, dst, dst_stride);
+@@ -419,8 +419,8 @@
+ 		}
+ 	}
+ 	if (mga_vid_config.card_type == MGA_G200) {
+-		sws_ctx = sws_getContext(width, height, PIX_FMT_YUV420P,
+-		                         width, height, PIX_FMT_NV12,
++		sws_ctx = sws_getContext(width, height, AV_PIX_FMT_YUV420P,
++		                         width, height, AV_PIX_FMT_NV12,
+ 		                         SWS_BILINEAR, NULL, NULL, NULL);
+ 		if (!sws_ctx) {
+ 			mp_msg(MSGT_VO, MSGL_FATAL,
+Index: libmpcodecs/vf_lavfi.c
+===================================================================
+--- libmpcodecs/vf_lavfi.c	(revision 37442)
++++ libmpcodecs/vf_lavfi.c	(revision 37443)
+@@ -107,7 +107,7 @@
+         if (vf->next->query_format(vf->next, ifmt) > 0)
+             sup[nsup++] = all->formats[i];
+     }
+-    sup[nsup++] = PIX_FMT_NONE;
++    sup[nsup++] = AV_PIX_FMT_NONE;
+     avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(sup));
+     av_free(sup);
+     return 0;
+@@ -186,7 +186,7 @@
+ static int mpsrc_query_formats(AVFilterContext *ctx)
+ {
+     struct mpsrc_priv *c = ctx->priv;
+-    enum AVPixelFormat pix_fmts[] = { c->vf->priv->in_pixfmt, PIX_FMT_NONE };
++    enum AVPixelFormat pix_fmts[] = { c->vf->priv->in_pixfmt, AV_PIX_FMT_NONE };
+     avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+     return 0;
+ }
+Index: libmpcodecs/vd_ffmpeg.c
+===================================================================
+--- libmpcodecs/vd_ffmpeg.c	(revision 37442)
++++ libmpcodecs/vd_ffmpeg.c	(revision 37443)
+@@ -191,7 +191,7 @@
+ #if CONFIG_XVMC
+         case IMGFMT_XVMC_IDCT_MPEG2:
+         case IMGFMT_XVMC_MOCO_MPEG2:
+-            if(avctx->pix_fmt==PIX_FMT_XVMC_MPEG2_IDCT) return CONTROL_TRUE;
++            if(avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT) return CONTROL_TRUE;
+ #endif
+         }
+         return CONTROL_FALSE;
+@@ -289,7 +289,7 @@
+     sh_video_t *sh     = avctx->opaque;
+     vd_ffmpeg_ctx *ctx = sh->context;
+     int imgfmt;
+-    if (fmt == PIX_FMT_NONE)
++    if (fmt == AV_PIX_FMT_NONE)
+         return;
+     ctx->use_hwaccel = fmt == AV_PIX_FMT_VDPAU;
+     imgfmt = pixfmt2imgfmt2(fmt, avctx->codec_id);
+@@ -1127,7 +1127,7 @@
+         for (i = 0; fmt[i] != AV_PIX_FMT_NONE; i++)
+             if (fmt[i] == ctx->pix_fmt) return ctx->pix_fmt;
+ 
+-    for(i=0;fmt[i]!=PIX_FMT_NONE;i++){
++    for(i=0;fmt[i]!=AV_PIX_FMT_NONE;i++){
+         // it is incorrect of FFmpeg to even offer these, filter them out
+         if(!(avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
+            (fmt[i] == AV_PIX_FMT_VDPAU_MPEG1 || fmt[i] == AV_PIX_FMT_VDPAU_MPEG2))
+@@ -1140,7 +1140,7 @@
+         }
+     }
+     selected_format = fmt[i];
+-    if (selected_format == PIX_FMT_NONE) {
++    if (selected_format == AV_PIX_FMT_NONE) {
+         selected_format = avcodec_default_get_format(avctx, fmt);
+         update_configuration(sh, selected_format, 1);
+     }
+Index: libmpcodecs/vf_screenshot.c
+===================================================================
+--- libmpcodecs/vf_screenshot.c	(revision 37442)
++++ libmpcodecs/vf_screenshot.c	(revision 37443)
+@@ -78,7 +78,7 @@
+     av_fast_malloc(&vf->priv->outbuffer, &vf->priv->outbuffer_size, d_width * d_height * 3 * 2);
+     if (!vf->priv->avctx) {
+         vf->priv->avctx = avcodec_alloc_context3(NULL);
+-        vf->priv->avctx->pix_fmt = PIX_FMT_RGB24;
++        vf->priv->avctx->pix_fmt = AV_PIX_FMT_RGB24;
+         vf->priv->avctx->width = d_width;
+         vf->priv->avctx->height = d_height;
+         vf->priv->avctx->compression_level = 0;
+Index: libmpcodecs/ve_lavc.c
+===================================================================
+--- libmpcodecs/ve_lavc.c	(revision 37442)
++++ libmpcodecs/ve_lavc.c	(revision 37443)
+@@ -587,7 +587,7 @@
+ 
+     mux_v->imgfmt = lavc_param_format;
+     lavc_venc_context->pix_fmt = imgfmt2pixfmt(lavc_param_format);
+-    if (lavc_venc_context->pix_fmt == PIX_FMT_NONE)
++    if (lavc_venc_context->pix_fmt == AV_PIX_FMT_NONE)
+         return 0;
+ 
+     if(!stats_file) {
+Index: libmpcodecs/vf_zrmjpeg.c
+===================================================================
+--- libmpcodecs/vf_zrmjpeg.c	(revision 37442)
++++ libmpcodecs/vf_zrmjpeg.c	(revision 37443)
+@@ -495,7 +495,7 @@
+ 	j->s->avctx->dct_algo = FF_DCT_AUTO;
+ 	j->s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
+ 	// indicate we 'decode' to jpeg 4:2:2
+-	j->s->avctx->pix_fmt = PIX_FMT_YUVJ422P;
++	j->s->avctx->pix_fmt = AV_PIX_FMT_YUVJ422P;
+ 
+ 	j->s->avctx->thread_count = 1;
+ 
+Index: libmpcodecs/vf_mcdeint.c
+===================================================================
+--- libmpcodecs/vf_mcdeint.c	(revision 37442)
++++ libmpcodecs/vf_mcdeint.c	(revision 37443)
+@@ -225,7 +225,7 @@
+             avctx_enc->time_base= (AVRational){1,25};  // meaningless
+             avctx_enc->gop_size = 300;
+             avctx_enc->max_b_frames= 0;
+-            avctx_enc->pix_fmt = PIX_FMT_YUV420P;
++            avctx_enc->pix_fmt = AV_PIX_FMT_YUV420P;
+             avctx_enc->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
+             avctx_enc->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
+             avctx_enc->global_quality= 1;
+Index: libmpcodecs/vf_scale.c
+===================================================================
+--- libmpcodecs/vf_scale.c	(revision 37442)
++++ libmpcodecs/vf_scale.c	(revision 37443)
+@@ -220,7 +220,7 @@
+         return 0;
+     }
+     sfmt = imgfmt2pixfmt(outfmt);
+-    if (outfmt == IMGFMT_BGR8) sfmt = PIX_FMT_PAL8;
++    if (outfmt == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;
+     dfmt = imgfmt2pixfmt(best);
+ 
+     vo_flags=vf->next->query_format(vf->next,best);
+@@ -544,7 +544,7 @@
+ //  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
+@@ -646,7 +646,7 @@
+ 
+         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, srcFilterParam, dstFilterParam, NULL);
+Index: libmpcodecs/vf_sab.c
+===================================================================
+--- libmpcodecs/vf_sab.c	(revision 37442)
++++ libmpcodecs/vf_sab.c	(revision 37443)
+@@ -105,7 +105,7 @@
+     swsF.lumH= swsF.lumV= vec;
+     swsF.chrH= swsF.chrV= NULL;
+     f->preFilterContext= sws_getContext(
+-        width, height, PIX_FMT_GRAY8, width, height, PIX_FMT_GRAY8, SWS_POINT, &swsF, NULL, NULL);
++        width, height, AV_PIX_FMT_GRAY8, width, height, AV_PIX_FMT_GRAY8, SWS_POINT, &swsF, NULL, NULL);
+ 
+     sws_freeVec(vec);
+     vec = sws_getGaussianVec(f->strength, 5.0);
+Index: libmpcodecs/vf_smartblur.c
+===================================================================
+--- libmpcodecs/vf_smartblur.c	(revision 37442)
++++ libmpcodecs/vf_smartblur.c	(revision 37443)
+@@ -89,7 +89,7 @@
+     swsF.lumH= swsF.lumV= vec;
+     swsF.chrH= swsF.chrV= NULL;
+     f->filterContext= sws_getContext(
+-        width, height, PIX_FMT_GRAY8, width, height, PIX_FMT_GRAY8, SWS_BICUBIC, &swsF, NULL, NULL);
++        width, height, AV_PIX_FMT_GRAY8, width, height, AV_PIX_FMT_GRAY8, SWS_BICUBIC, &swsF, NULL, NULL);
+ 
+     sws_freeVec(vec);
+ 
+Index: libmpcodecs/vf_uspp.c
+===================================================================
+--- libmpcodecs/vf_uspp.c	(revision 37442)
++++ libmpcodecs/vf_uspp.c	(revision 37443)
+@@ -234,7 +234,7 @@
+             avctx_enc->time_base= (AVRational){1,25};  // meaningless
+             avctx_enc->gop_size = 300;
+             avctx_enc->max_b_frames= 0;
+-            avctx_enc->pix_fmt = PIX_FMT_YUV420P;
++            avctx_enc->pix_fmt = AV_PIX_FMT_YUV420P;
+             avctx_enc->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
+             avctx_enc->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
+             avctx_enc->global_quality= 123;
+Index: libmpcodecs/vf_halfpack.c
+===================================================================
+--- libmpcodecs/vf_halfpack.c	(revision 37442)
++++ libmpcodecs/vf_halfpack.c	(revision 37443)
+@@ -198,8 +198,8 @@
+ 		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_getContext(width, height / 2, AV_PIX_FMT_YUV422P,
++			               width, height / 2, AV_PIX_FMT_YUYV422,
+ 			               SWS_POINT | SWS_PRINT_INFO,
+ 			               NULL, NULL, NULL);
+ 	}
+Index: libmpcodecs/vf_lavc.c
+===================================================================
+--- libmpcodecs/vf_lavc.c	(revision 37442)
++++ libmpcodecs/vf_lavc.c	(revision 37443)
+@@ -161,7 +161,7 @@
+     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;
+ }
+Index: gui/util/bitmap.c
+===================================================================
+--- gui/util/bitmap.c	(revision 37442)
++++ gui/util/bitmap.c	(revision 37443)
+@@ -134,19 +134,19 @@
+     memset(img, 0, sizeof(*img));
+ 
+     switch (avctx->pix_fmt) {
+-    case PIX_FMT_GRAY8:
++    case AV_PIX_FMT_GRAY8:
+         img->Bpp = 8;
+         break;
+ 
+-    case PIX_FMT_GRAY16BE:
++    case AV_PIX_FMT_GRAY16BE:
+         img->Bpp = 16;
+         break;
+ 
+-    case PIX_FMT_RGB24:
++    case AV_PIX_FMT_RGB24:
+         img->Bpp = 24;
+         break;
+ 
+-    case PIX_FMT_RGBA:
++    case AV_PIX_FMT_RGBA:
+         img->Bpp = 32;
+         break;
+ 
+Index: gui/win32/skinload.c
+===================================================================
+--- gui/win32/skinload.c	(revision 37442)
++++ gui/win32/skinload.c	(revision 37443)
+@@ -185,12 +185,12 @@
+       int src_stride[4] = { 4 * bmp.Width, 0, 0, 0 };
+       uint8_t *dst[4] = { NULL, NULL, NULL, NULL };
+       int dst_stride[4];
+-      enum AVPixelFormat out_pix_fmt = PIX_FMT_NONE;
++      enum AVPixelFormat out_pix_fmt = AV_PIX_FMT_NONE;
+       struct SwsContext *sws;
+-      if      (skin->desktopbpp == 16) out_pix_fmt = PIX_FMT_RGB555;
+-      else if (skin->desktopbpp == 24) out_pix_fmt = PIX_FMT_RGB24;
++      if      (skin->desktopbpp == 16) out_pix_fmt = AV_PIX_FMT_RGB555;
++      else if (skin->desktopbpp == 24) out_pix_fmt = AV_PIX_FMT_RGB24;
+       av_image_fill_linesizes(dst_stride, out_pix_fmt, bmp.Width);
+-      sws = sws_getContext(bmp.Width, bmp.Height, PIX_FMT_RGB32,
++      sws = sws_getContext(bmp.Width, bmp.Height, AV_PIX_FMT_RGB32,
+                            bmp.Width, bmp.Height, out_pix_fmt,
+                            SWS_POINT, NULL, NULL, NULL);
+       bf->data = malloc(bf->size);
+Index: gui/wm/ws.c
+===================================================================
+--- gui/wm/ws.c	(revision 37442)
++++ gui/wm/ws.c	(revision 37443)
+@@ -79,7 +79,7 @@
+ static int wsUseXShm   = True;
+ static int wsUseXShape = True;
+ 
+-static enum AVPixelFormat out_pix_fmt = PIX_FMT_NONE;
++static enum AVPixelFormat out_pix_fmt = AV_PIX_FMT_NONE;
+ 
+ /* --- */
+ 
+@@ -275,21 +275,21 @@
+ #endif
+ 
+     if (wsScreenDepth == 32 && wsRedMask == 0xff0000 && wsGreenMask == 0x00ff00 && wsBlueMask == 0x0000ff)
+-        out_pix_fmt = PIX_FMT_RGB32;
++        out_pix_fmt = AV_PIX_FMT_RGB32;
+     else if (wsScreenDepth == 32 && wsRedMask == 0x0000ff && wsGreenMask == 0x00ff00 && wsBlueMask == 0xff0000)
+-        out_pix_fmt = PIX_FMT_BGR32;
++        out_pix_fmt = AV_PIX_FMT_BGR32;
+     else if (wsScreenDepth == 24 && wsRedMask == 0xff0000 && wsGreenMask == 0x00ff00 && wsBlueMask == 0x0000ff)
+-        out_pix_fmt = PIX_FMT_RGB24;
++        out_pix_fmt = AV_PIX_FMT_RGB24;
+     else if (wsScreenDepth == 24 && wsRedMask == 0x0000ff && wsGreenMask == 0x00ff00 && wsBlueMask == 0xff0000)
+-        out_pix_fmt = PIX_FMT_BGR24;
++        out_pix_fmt = AV_PIX_FMT_BGR24;
+     else if (wsScreenDepth == 16 && wsRedMask == 0xf800 && wsGreenMask == 0x7e0 && wsBlueMask == 0x1f)
+-        out_pix_fmt = PIX_FMT_RGB565;
++        out_pix_fmt = AV_PIX_FMT_RGB565;
+     else if (wsScreenDepth == 16 && wsRedMask == 0x1f && wsGreenMask == 0x7e0 && wsBlueMask == 0xf800)
+-        out_pix_fmt = PIX_FMT_BGR565;
++        out_pix_fmt = AV_PIX_FMT_BGR565;
+     else if (wsScreenDepth == 15 && wsRedMask == 0x7c00 && wsGreenMask == 0x3e0 && wsBlueMask == 0x1f)
+-        out_pix_fmt = PIX_FMT_RGB555;
++        out_pix_fmt = AV_PIX_FMT_RGB555;
+     else if (wsScreenDepth == 15 && wsRedMask == 0x1f && wsGreenMask == 0x3e0 && wsBlueMask == 0x7c00)
+-        out_pix_fmt = PIX_FMT_BGR555;
++        out_pix_fmt = AV_PIX_FMT_BGR555;
+ }
+ 
+ void wsDone(void)
+@@ -1049,29 +1049,29 @@
+     int color = 0;
+ 
+     switch (out_pix_fmt) {
+-    case PIX_FMT_RGB32:
+-    case PIX_FMT_RGB24:
++    case AV_PIX_FMT_RGB32:
++    case AV_PIX_FMT_RGB24:
+         color = (r << 16) + (g << 8) + b;
+         break;
+ 
+-    case PIX_FMT_BGR32:
+-    case PIX_FMT_BGR24:
++    case AV_PIX_FMT_BGR32:
++    case AV_PIX_FMT_BGR24:
+         color = (b << 16) + (g << 8) + r;
+         break;
+ 
+-    case PIX_FMT_RGB565:
++    case AV_PIX_FMT_RGB565:
+         color = pack_rgb16(r, g, b);
+         break;
+ 
+-    case PIX_FMT_BGR565:
++    case AV_PIX_FMT_BGR565:
+         color = pack_rgb16(b, g, r);
+         break;
+ 
+-    case PIX_FMT_RGB555:
++    case AV_PIX_FMT_RGB555:
+         color = pack_rgb15(r, g, b);
+         break;
+ 
+-    case PIX_FMT_BGR555:
++    case AV_PIX_FMT_BGR555:
+         color = pack_rgb15(b, g, r);
+         break;
+ 
+@@ -1367,7 +1367,7 @@
+     int dst_stride[4];
+     int i;
+ 
+-    sws_ctx = sws_getCachedContext(sws_ctx, win->xImage->width, win->xImage->height, PIX_FMT_RGB32,
++    sws_ctx = sws_getCachedContext(sws_ctx, win->xImage->width, win->xImage->height, AV_PIX_FMT_RGB32,
+                                    win->xImage->width, win->xImage->height, out_pix_fmt,
+                                    SWS_POINT, NULL, NULL, NULL);
+     av_image_fill_linesizes(dst_stride, out_pix_fmt, win->xImage->width);
+Index: sub/spudec.c
+===================================================================
+--- sub/spudec.c	(revision 37442)
++++ sub/spudec.c	(revision 37443)
+@@ -891,7 +891,7 @@
+ 		oldvar = spu_gaussvar;
+ 	}
+ 
+-	ctx=sws_getContext(sw, sh, PIX_FMT_GRAY8, dw, dh, PIX_FMT_GRAY8, SWS_GAUSS, &filter, NULL, NULL);
++	ctx=sws_getContext(sw, sh, AV_PIX_FMT_GRAY8, dw, dh, AV_PIX_FMT_GRAY8, SWS_GAUSS, &filter, NULL, NULL);
+ 	sws_scale(ctx,&s1,&ss,0,sh,&d1,&ds);
+ 	for (i=ss*sh-1; i>=0; i--) s2[i] = -s2[i];
+ 	sws_scale(ctx,&s2,&ss,0,sh,&d2,&ds);
+Index: fmt-conversion.c
+===================================================================
+--- fmt-conversion.c	(revision 37442)
++++ fmt-conversion.c	(revision 37443)
+@@ -155,7 +155,7 @@
+         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;
+ }
+@@ -164,7 +164,7 @@
+ {
+     int i;
+     int fmt;
+-    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;
+     fmt = conversion_map[i].fmt;
+Index: libmpdemux/demux_lavf.c
+===================================================================
+--- libmpdemux/demux_lavf.c	(revision 37442)
++++ libmpdemux/demux_lavf.c	(revision 37443)
+@@ -364,10 +364,10 @@
+ 
+             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');
+                         break;
+-                    case PIX_FMT_BGR24:
++                    case AV_PIX_FMT_BGR24:
+                         codec->codec_tag= MKTAG(24, 'R', 'G', 'B');
+                         break;
+                 }
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-chan.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-chan.patch
new file mode 100644
index 000000000000..a448d0849458
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-chan.patch
@@ -0,0 +1,25 @@
+r37447 | rtogni | 2015-08-14 21:30:34 +0200 (Fri, 14 Aug 2015) | 3 lines
+
+Replace deprecated avctx->request_channels with request_channel_layout
+
+Index: libmpcodecs/ad_ffmpeg.c
+===================================================================
+--- libmpcodecs/ad_ffmpeg.c	(revision 37446)
++++ libmpcodecs/ad_ffmpeg.c	(revision 37447)
+@@ -46,6 +46,7 @@
+ 
+ #include "libavcodec/avcodec.h"
+ #include "libavutil/dict.h"
++#include "libavutil/channel_layout.h"
+ 
+ struct adctx {
+     int last_samplerate;
+@@ -127,7 +128,7 @@
+ 	lavc_context->bits_per_coded_sample = sh_audio->wf->wBitsPerSample;
+     }
+     lavc_context->channel_layout = sh_audio->channel_layout;
+-    lavc_context->request_channels = audio_output_channels;
++    lavc_context->request_channel_layout = av_get_default_channel_layout(audio_output_channels);
+     lavc_context->codec_tag = sh_audio->format; //FOURCC
+     lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
+ 
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-encode.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-encode.patch
new file mode 100644
index 000000000000..06a33f832f07
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-encode.patch
@@ -0,0 +1,82 @@
+r37453 | rtogni | 2015-08-23 22:32:50 +0200 (Sun, 23 Aug 2015) | 3 lines
+
+Replace deprecated av_encode_video() with av_encode_video2()
+
+Index: libmpcodecs/vf_uspp.c
+===================================================================
+--- libmpcodecs/vf_uspp.c	(revision 37452)
++++ libmpcodecs/vf_uspp.c	(revision 37453)
+@@ -177,11 +177,16 @@
+         const int x1= offset[i+count-1][0];
+         const int y1= offset[i+count-1][1];
+         int offset;
++        AVPacket pkt;
++        int ret, got_pkt;
+         p->frame->data[0]= p->src[0] + x1 + y1 * p->frame->linesize[0];
+         p->frame->data[1]= p->src[1] + x1/2 + y1/2 * p->frame->linesize[1];
+         p->frame->data[2]= p->src[2] + x1/2 + y1/2 * p->frame->linesize[2];
+ 
+-        avcodec_encode_video(p->avctx_enc[i], p->outbuf, p->outbuf_size, p->frame);
++        av_init_packet(&pkt);
++        pkt.data = p->outbuf;
++        pkt.size = p->outbuf_size;
++        avcodec_encode_video2(p->avctx_enc[i], &pkt, p->frame, &got_pkt);
+         p->frame_dec = p->avctx_enc[i]->coded_frame;
+ 
+         offset= (BLOCK-x1) + (BLOCK-y1)*p->frame_dec->linesize[0];
+Index: libmpcodecs/vf_lavc.c
+===================================================================
+--- libmpcodecs/vf_lavc.c	(revision 37452)
++++ libmpcodecs/vf_lavc.c	(revision 37453)
+@@ -86,6 +86,8 @@
+     mp_image_t* dmpi;
+     int out_size;
+     AVFrame *pic= vf->priv->pic;
++    int ret, got_pkt;
++    AVPacket pkt;
+ 
+     pic->data[0]=mpi->planes[0];
+     pic->data[1]=mpi->planes[1];
+@@ -94,10 +96,14 @@
+     pic->linesize[1]=mpi->stride[1];
+     pic->linesize[2]=mpi->stride[2];
+ 
+-    out_size = avcodec_encode_video(&lavc_venc_context,
+-	vf->priv->outbuf, vf->priv->outbuf_size, pic);
++    av_init_packet(&pkt);
++    pkt.data = vf->priv->outbuf;
++    pkt.size = vf->priv->outbuf_size;
++    ret = avcodec_encode_video2(&lavc_venc_context, &pkt, pic, &got_pkt);
+ 
+-    if(out_size<=0) return 1;
++    if(ret<=0) return 1;
++    if(!got_pkt) return 1;
++    out_size =  pkt.size;
+ 
+     dmpi=vf_get_image(vf->next,IMGFMT_MPEGPES,
+ 	MP_IMGTYPE_EXPORT, 0,
+Index: libmpcodecs/vf_mcdeint.c
+===================================================================
+--- libmpcodecs/vf_mcdeint.c	(revision 37452)
++++ libmpcodecs/vf_mcdeint.c	(revision 37453)
+@@ -92,6 +92,8 @@
+ 
+ static void filter(struct vf_priv_s *p, uint8_t *dst[3], uint8_t *src[3], int dst_stride[3], int src_stride[3], int width, int height){
+     int x, y, i;
++    int got_pkt;
++    AVPacket pkt;
+ 
+     for(i=0; i<3; i++){
+         p->frame->data[i]= src[i];
+@@ -101,7 +103,10 @@
+     p->avctx_enc->me_cmp=
+     p->avctx_enc->me_sub_cmp= FF_CMP_SAD /*| (p->parity ? FF_CMP_ODD : FF_CMP_EVEN)*/;
+     p->frame->quality= p->qp*FF_QP2LAMBDA;
+-    avcodec_encode_video(p->avctx_enc, p->outbuf, p->outbuf_size, p->frame);
++    av_init_packet(&pkt);
++    pkt.data = p->outbuf;
++    pkt.size = p->outbuf_size;
++    avcodec_encode_video2(p->avctx_enc, &pkt, p->frame, &got_pkt);
+     p->frame_dec = p->avctx_enc->coded_frame;
+ 
+     for(i=0; i<3; i++){
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-frame.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-frame.patch
new file mode 100644
index 000000000000..48c46c73db08
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-frame.patch
@@ -0,0 +1,17 @@
+r37465 | rtogni | 2015-08-28 21:37:24 +0200 (Fri, 28 Aug 2015) | 3 lines
+
+Use av_frame_free() instead of av_freep() to free AVFrame
+
+Index: libmpcodecs/vd_ffmpeg.c
+===================================================================
+--- libmpcodecs/vd_ffmpeg.c	(revision 37464)
++++ libmpcodecs/vd_ffmpeg.c	(revision 37465)
+@@ -539,7 +539,7 @@
+     }
+ 
+     av_freep(&avctx);
+-    av_freep(&ctx->pic);
++    av_frame_free(&ctx->pic);
+     free(ctx);
+ }
+ 
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-get_buffer.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-get_buffer.patch
new file mode 100644
index 000000000000..156fca5497a7
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-get_buffer.patch
@@ -0,0 +1,325 @@
+r37476 | rtogni | 2015-09-05 18:20:27 +0200 (Sat, 05 Sep 2015) | 5 lines
+
+Replace deprecated get_buffer, buffer_hints, and others
+
+This is needed to compile with latest FFmpeg
+
+
+Index: libmpcodecs/vd_ffmpeg.c
+===================================================================
+--- libmpcodecs/vd_ffmpeg.c	(revision 37475)
++++ libmpcodecs/vd_ffmpeg.c	(revision 37476)
+@@ -40,6 +40,7 @@
+ #if CONFIG_VDPAU
+ #include "libavcodec/vdpau.h"
+ #endif
++#include "libavutil/pixdesc.h"
+ 
+ static const vd_info_t info = {
+     "FFmpeg's libavcodec codec family",
+@@ -95,8 +96,11 @@
+ 
+ #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);
+ 
+@@ -269,16 +273,10 @@
+     if (lavc_param_vismv || (lavc_param_debug & (FF_DEBUG_VIS_MB_TYPE|FF_DEBUG_VIS_QP))) {
+         ctx->do_slices = ctx->do_dr1 = 0;
+     }
+     if(ctx->do_dr1){
+-        avctx->flags |= CODEC_FLAG_EMU_EDGE;
+-        avctx->  reget_buffer =
+-        avctx->    get_buffer =     get_buffer;
+-        avctx->release_buffer = release_buffer;
++        avctx->get_buffer2 = get_buffer2;
+     } else if (lavc_codec->capabilities & CODEC_CAP_DR1) {
+-        avctx->flags &= ~CODEC_FLAG_EMU_EDGE;
+-        avctx->  reget_buffer = avcodec_default_reget_buffer;
+-        avctx->    get_buffer = avcodec_default_get_buffer;
+-        avctx->release_buffer = avcodec_default_release_buffer;
++        avctx->get_buffer2 = avcodec_default_get_buffer2;
+     }
+     avctx->slice_flags = 0;
+ }
+@@ -309,9 +304,7 @@
+     if (IMGFMT_IS_HWACCEL(imgfmt)) {
+         ctx->do_dr1    = 1;
+         ctx->nonref_dr = 0;
+-        avctx->get_buffer      = get_buffer;
+-        avctx->release_buffer  = release_buffer;
+-        avctx->reget_buffer    = get_buffer;
++        avctx->get_buffer2 = get_buffer2;
+         mp_msg(MSGT_DECVIDEO, MSGL_V, IMGFMT_IS_XVMC(imgfmt) ?
+                MSGTR_MPCODECS_XVMCAcceleratedMPEG2 :
+                "[VD_FFMPEG] VDPAU accelerated decoding\n");
+@@ -384,7 +377,6 @@
+ #endif
+     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;
+@@ -668,7 +660,7 @@
+     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;
+     mp_image_t *mpi=NULL;
+@@ -677,27 +669,12 @@
+     int width = FFMAX(avctx->width,  -(-avctx->coded_width  >> avctx->lowres));
+     int height= FFMAX(avctx->height, -(-avctx->coded_height >> avctx->lowres));
+     // special case to handle reget_buffer
+-    if (pic->opaque && pic->data[0] && (!pic->buffer_hints || pic->buffer_hints & FF_BUFFER_HINTS_REUSABLE))
++    if (pic->opaque && pic->data[0])
+         return 0;
+     avcodec_align_dimensions(avctx, &width, &height);
+ //printf("get_buffer %d %d %d\n", pic->reference, ctx->ip_count, ctx->b_count);
+ 
+-    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 ||
+-            pic->buffer_hints & FF_BUFFER_HINTS_REUSABLE) {
+-            ctx->ip_count++;
+-            type = MP_IMGTYPE_IP;
+-            flags |= MP_IMGFLAG_PRESERVE;
+-        }
+-        flags|=(avctx->skip_idct<=AVDISCARD_DEFAULT && avctx->skip_frame<=AVDISCARD_DEFAULT && ctx->do_slices) ?
+-                 MP_IMGFLAG_DRAW_CALLBACK:0;
+-        mp_msg(MSGT_DECVIDEO, MSGL_DBG2, type == MP_IMGTYPE_IP ? "using IP\n" : "using TEMP\n");
+-    } else {
+-        if(!pic->reference){
++        if(!isreference){
+             ctx->b_count++;
+             flags|=(avctx->skip_idct<=AVDISCARD_DEFAULT && avctx->skip_frame<=AVDISCARD_DEFAULT && ctx->do_slices) ?
+                      MP_IMGFLAG_DRAW_CALLBACK:0;
+@@ -711,11 +688,10 @@
+         }else{
+             type= MP_IMGTYPE_IP;
+         }
+-    }
+ 
+     if (ctx->nonref_dr) {
+         if (flags & MP_IMGFLAG_PRESERVE)
+-            return avcodec_default_get_buffer(avctx, pic);
++            return mpcodec_default_get_buffer(avctx, pic);
+         // Use NUMBERED since for e.g. TEMP vos assume there will
+         // be no other frames between the get_image and matching put_image.
+         type = MP_IMGTYPE_NUMBERED;
+@@ -722,7 +698,6 @@
+     }
+ 
+     if(init_vo(sh, avctx->pix_fmt, 1) < 0){
+-        avctx->release_buffer= avcodec_default_release_buffer;
+         goto disable_dr1;
+     }
+ 
+@@ -822,7 +797,6 @@
+ else
+     printf(".");
+ #endif
+-    pic->type= FF_BUFFER_TYPE_USER;
+     return 0;
+ 
+ disable_dr1:
+@@ -829,13 +803,11 @@
+     ctx->do_dr1 = 0;
+     // For frame-multithreading these contexts aren't
+     // the same and must both be updated.
+-    ctx->avctx->get_buffer   =
+-    avctx->get_buffer        = avcodec_default_get_buffer;
+-    ctx->avctx->reget_buffer =
+-    avctx->reget_buffer      = avcodec_default_reget_buffer;
++    ctx->avctx->get_buffer2   =
++    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);
+ }
+ 
+ static void release_buffer(struct AVCodecContext *avctx, AVFrame *pic){
+@@ -843,8 +815,8 @@
+     sh_video_t *sh = avctx->opaque;
+     vd_ffmpeg_ctx *ctx = sh->context;
+     int i;
+-    if (pic->type != FF_BUFFER_TYPE_USER) {
+-        avcodec_default_release_buffer(avctx, pic);
++    if (pic->opaque == NULL) {
++        mpcodec_default_release_buffer(avctx, pic);
+         return;
+     }
+ 
+@@ -954,7 +926,7 @@
+     // even when we do dr we might actually get a buffer we had
+     // FFmpeg allocate - this mostly happens with nonref_dr.
+     // Ensure we treat it correctly.
+-    dr1= ctx->do_dr1 && pic->type == FF_BUFFER_TYPE_USER;
++    dr1= ctx->do_dr1 && pic->opaque != NULL;
+     if(ret<0) mp_msg(MSGT_DECVIDEO, MSGL_WARN, "Error while decoding frame!\n");
+ //printf("repeat: %d\n", pic->repeat_pict);
+ //-- vstats generation
+@@ -1128,3 +1100,148 @@
+     set_format_params(avctx, selected_format);
+     return selected_format;
+ }
++
++
++/*
++ 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 with 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->buf[i], frame->extended_data[i], frame->linesize[0]);
++
++        for (i = 0; i < frame->nb_extended_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;
++}
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-pkt_destruct.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-pkt_destruct.patch
new file mode 100644
index 000000000000..e101ee769ec7
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-pkt_destruct.patch
@@ -0,0 +1,25 @@
+r37450 | rtogni | 2015-08-17 23:17:16 +0200 (Mon, 17 Aug 2015) | 3 lines
+
+Stop using deprecatet AVPacket.destruct
+
+Index: libmpdemux/demux_lavf.c
+===================================================================
+--- libmpdemux/demux_lavf.c	(revision 37449)
++++ libmpdemux/demux_lavf.c	(revision 37450)
+@@ -682,16 +682,9 @@
+         return 1;
+     }
+ 
+-    if(pkt.destruct == av_destruct_packet && !CONFIG_MEMALIGN_HACK){
+-        dp=new_demux_packet(0);
+-        dp->len=pkt.size;
+-        dp->buffer=pkt.data;
+-        pkt.destruct= NULL;
+-    }else{
+         dp=new_demux_packet(pkt.size);
+         memcpy(dp->buffer, pkt.data, pkt.size);
+         av_free_packet(&pkt);
+-    }
+ 
+     if(pkt.pts != AV_NOPTS_VALUE){
+         dp->pts=pkt.pts * av_q2d(priv->avfc->streams[id]->time_base);
diff --git a/media-video/mplayer/files/mplayer-1.2_pre20150730-rev.patch b/media-video/mplayer/files/mplayer-1.2_pre20150730-rev.patch
new file mode 100644
index 000000000000..903e2a7763e8
--- /dev/null
+++ b/media-video/mplayer/files/mplayer-1.2_pre20150730-rev.patch
@@ -0,0 +1,46 @@
+r37448 | rtogni | 2015-08-14 21:44:21 +0200 (Fri, 14 Aug 2015) | 5 lines
+
+Replace deprecated av_reverse with a local copy
+
+Patch by Andreas Cadhalpun andreas.cadhalpun (at) googlemail
+
+
+Index: libmpcodecs/dec_teletext.c
+===================================================================
+--- libmpcodecs/dec_teletext.c	(revision 37447)
++++ libmpcodecs/dec_teletext.c	(revision 37448)
+@@ -403,6 +403,25 @@
+   { 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)
+@@ -1554,7 +1573,7 @@
+     /* 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)
diff --git a/media-video/mplayer/mplayer-1.2_pre20150730.ebuild b/media-video/mplayer/mplayer-1.2_pre20150730.ebuild
index f12d8851fd49..118dbc4bb0b9 100644
--- a/media-video/mplayer/mplayer-1.2_pre20150730.ebuild
+++ b/media-video/mplayer/mplayer-1.2_pre20150730.ebuild
@@ -265,6 +265,17 @@ src_prepare() {
 
 	# Use sane default for >=virtual/udev-197
 	sed -i -e '/default_dvd_device/s:/dev/dvd:/dev/cdrom:' configure || die
+
+	if has_version '>=media-video/ffmpeg-2.9'; then
+		epatch "${FILESDIR}/${P}-av_fmt.patch"
+		epatch "${FILESDIR}/${P}-rev.patch"
+		epatch "${FILESDIR}/${P}-chan.patch"
+		epatch "${FILESDIR}/${P}-frame.patch"
+		epatch "${FILESDIR}/${P}-get_buffer.patch"
+		epatch "${FILESDIR}/${P}-pkt_destruct.patch"
+		epatch "${FILESDIR}/${P}-alloc.patch"
+		epatch "${FILESDIR}/${P}-encode.patch"
+	fi
 }
 
 src_configure() {