mirror of
https://github.com/mpv-player/mpv
synced 2024-12-13 10:26:00 +00:00
c7944423a3
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@7369 b3059339-0415-0410-9bf9-f77b7e298cf2
197 lines
4.1 KiB
C
197 lines
4.1 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "../config.h"
|
|
#include "../mp_msg.h"
|
|
#include "../help_mp.h"
|
|
|
|
#ifdef USE_LIBAVCODEC
|
|
|
|
#include "img_format.h"
|
|
#include "mp_image.h"
|
|
#include "vf.h"
|
|
|
|
//#include "../libvo/fastmemcpy.h"
|
|
|
|
#ifdef USE_LIBAVCODEC_SO
|
|
#include <ffmpeg/avcodec.h>
|
|
#else
|
|
#include "libavcodec/avcodec.h"
|
|
#endif
|
|
|
|
extern int avcodec_inited;
|
|
|
|
struct vf_priv_s
|
|
{
|
|
int width, height;
|
|
int pix_fmt;
|
|
};
|
|
|
|
#define lavc_venc_context (vf->priv->context)
|
|
|
|
|
|
/* Support for avcodec's built-in deinterlacer.
|
|
* Based on vf_lavc.c
|
|
*/
|
|
|
|
//===========================================================================//
|
|
|
|
|
|
/* Convert mplayer's IMGFMT_* to avcodec's PIX_FMT_* for the supported
|
|
* IMGFMT's, and return -1 if the deinterlacer doesn't support
|
|
* that format (-1 because 0 is a valid PIX_FMT).
|
|
*/
|
|
/* The deinterlacer supports planer 4:2:0, 4:2:2, and 4:4:4 YUV */
|
|
static int
|
|
imgfmt_to_pixfmt (int imgfmt)
|
|
{
|
|
switch(imgfmt)
|
|
{
|
|
/* I hope I got all the supported formats */
|
|
|
|
/* 4:2:0 */
|
|
case IMGFMT_YV12:
|
|
case IMGFMT_I420:
|
|
case IMGFMT_IYUV:
|
|
return PIX_FMT_YUV420P;
|
|
break;
|
|
|
|
#if 0
|
|
/* 4:2:2 */
|
|
case IMGFMT_UYVY:
|
|
case IMGFMT_UYNV:
|
|
case IMGFMT_Y422:
|
|
case IMGFMT_YUY2:
|
|
case IMGFMT_YUNV:
|
|
case IMGFMT_YVYU:
|
|
case IMGFMT_Y42T:
|
|
case IMGFMT_V422:
|
|
case IMGFMT_V655:
|
|
return PIX_FMT_YUV422P;
|
|
break;
|
|
#endif
|
|
|
|
/* Are there any _planar_ YUV 4:4:4 formats? */
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
static int
|
|
config (struct vf_instance_s* vf,
|
|
int width, int height, int d_width, int d_height,
|
|
unsigned int flags, unsigned int outfmt)
|
|
{
|
|
struct vf_priv_s *priv = vf->priv;
|
|
|
|
priv->pix_fmt = imgfmt_to_pixfmt(outfmt);
|
|
if(priv->pix_fmt == -1)
|
|
return 0;
|
|
|
|
/* The deinterlacer will fail if this is false */
|
|
if ((width & 1) != 0 || (height & 3) != 0)
|
|
return 0;
|
|
|
|
/* If we get here, the deinterlacer is guaranteed not to fail */
|
|
|
|
priv->width = width;
|
|
priv->height = height;
|
|
|
|
return vf_next_config(vf,
|
|
width, height,
|
|
d_width, d_height,
|
|
flags, outfmt);
|
|
}
|
|
|
|
static int
|
|
put_image (struct vf_instance_s* vf, mp_image_t *mpi)
|
|
{
|
|
struct vf_priv_s *priv = vf->priv;
|
|
mp_image_t* dmpi;
|
|
AVPicture pic;
|
|
AVPicture lavc_picture;
|
|
|
|
lavc_picture.data[0] = mpi->planes[0];
|
|
lavc_picture.data[1] = mpi->planes[1];
|
|
lavc_picture.data[2] = mpi->planes[2];
|
|
lavc_picture.linesize[0] = mpi->stride[0];
|
|
lavc_picture.linesize[1] = mpi->stride[1];
|
|
lavc_picture.linesize[2] = mpi->stride[2];
|
|
|
|
dmpi = vf_get_image(vf->next, mpi->imgfmt,
|
|
MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
|
|
priv->width, priv->height);
|
|
|
|
pic.data[0] = dmpi->planes[0];
|
|
pic.data[1] = dmpi->planes[1];
|
|
pic.data[2] = dmpi->planes[2];
|
|
pic.linesize[0] = dmpi->stride[0];
|
|
pic.linesize[1] = dmpi->stride[1];
|
|
pic.linesize[2] = dmpi->stride[2];
|
|
|
|
if (avpicture_deinterlace(&pic, &lavc_picture,
|
|
priv->pix_fmt, priv->width, priv->height) < 0)
|
|
{
|
|
/* This should not happen -- see config() */
|
|
return 0;
|
|
}
|
|
|
|
return vf_next_put_image(vf, dmpi);
|
|
}
|
|
|
|
|
|
static int
|
|
query_format (struct vf_instance_s* vf, unsigned int fmt)
|
|
{
|
|
if(imgfmt_to_pixfmt(fmt) == -1)
|
|
return 0;
|
|
|
|
return vf_next_query_format(vf,fmt);
|
|
}
|
|
|
|
|
|
static int
|
|
open (vf_instance_t *vf, char* args)
|
|
{
|
|
/* We don't have any args */
|
|
(void) args;
|
|
|
|
vf->config = config;
|
|
vf->put_image = put_image;
|
|
vf->query_format = query_format;
|
|
vf->priv = malloc(sizeof(struct vf_priv_s));
|
|
memset(vf->priv,0,sizeof(struct vf_priv_s));
|
|
|
|
/* This may not technically be necessary just for a deinterlace,
|
|
* but it seems like a good idea.
|
|
*/
|
|
if(!avcodec_inited)
|
|
{
|
|
avcodec_init();
|
|
avcodec_register_all();
|
|
avcodec_inited=1;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
vf_info_t vf_info_lavcdeint = {
|
|
"libavcodec's deinterlacing filter",
|
|
"lavcdeint",
|
|
"Joe Rabinoff",
|
|
"libavcodec's internal deinterlacer, in case you don't like "
|
|
"the builtin ones (invoked with -pp or -npp)",
|
|
open
|
|
};
|
|
|
|
|
|
//===========================================================================//
|
|
|
|
#endif /* USE_LIBAVCODEC */
|
|
|