diff options
author | Rudolf Polzer <divverent@xonotic.org> | 2012-08-23 12:32:13 +0200 |
---|---|---|
committer | wm4 <wm4@nowhere> | 2012-08-23 13:13:53 +0200 |
commit | 2adc81f0a2459a565437009ff6f4ace1dca3d46c (patch) | |
tree | 4fb92807ad61980fac5230d670af374aaaa9d082 /libmpcodecs | |
parent | 2e6450c7cc88f1e39034ac111e9b54a421bca661 (diff) | |
download | mpv-2adc81f0a2459a565437009ff6f4ace1dca3d46c.tar.bz2 mpv-2adc81f0a2459a565437009ff6f4ace1dca3d46c.tar.xz |
vf_dlopen: add a generic filter to load external filters
Usage: -vf dlopen=filename.so:args...
Examples of such filters are provided in TOOLS/vf_dlopen/
Diffstat (limited to 'libmpcodecs')
-rw-r--r-- | libmpcodecs/vf.c | 2 | ||||
-rw-r--r-- | libmpcodecs/vf_dlopen.c | 356 | ||||
-rw-r--r-- | libmpcodecs/vf_dlopen.h | 88 |
3 files changed, 446 insertions, 0 deletions
diff --git a/libmpcodecs/vf.c b/libmpcodecs/vf.c index 8017b6b510..4dc4da1835 100644 --- a/libmpcodecs/vf.c +++ b/libmpcodecs/vf.c @@ -114,6 +114,7 @@ extern const vf_info_t vf_info_geq; extern const vf_info_t vf_info_ow; extern const vf_info_t vf_info_fixpts; extern const vf_info_t vf_info_stereo3d; +extern const vf_info_t vf_info_dlopen; // list of available filters: static const vf_info_t *const filter_list[] = { @@ -205,6 +206,7 @@ static const vf_info_t *const filter_list[] = { &vf_info_ow, &vf_info_fixpts, &vf_info_stereo3d, + &vf_info_dlopen, NULL }; diff --git a/libmpcodecs/vf_dlopen.c b/libmpcodecs/vf_dlopen.c new file mode 100644 index 0000000000..1468a05998 --- /dev/null +++ b/libmpcodecs/vf_dlopen.c @@ -0,0 +1,356 @@ +/* + * This file is part of mplayer. + * + * mplayer is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * mplayer is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with mplayer. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <inttypes.h> + +#include "config.h" +#include "mp_msg.h" + +#include "img_format.h" +#include "mp_image.h" +#include "vf.h" + +#include "m_option.h" +#include "m_struct.h" + +#include "vf_dlopen.h" + +#ifdef _WIN32 +# include <windows.h> +# define DLLOpen(name) LoadLibrary(name) +# define DLLClose(handle) FreeLibrary(handle) +# define DLLSymbol(handle, name) ((void *)GetProcAddress(handle, name)) +#else +# include <dlfcn.h> +# define DLLOpen(name) dlopen(name, RTLD_NOW) +# define DLLClose(handle) dlclose(handle) +# define DLLSymbol(handle, name) dlsym(handle, name) +#endif + +static struct vf_priv_s { + const char *cfg_dllname; + int cfg_argc; + const char *cfg_argv[4]; + void *dll; + struct vf_dlopen_context filter; + + // output mp_image_t stuff + mp_image_t *outpic[FILTER_MAX_OUTCNT]; + + // multi frame output + unsigned int outbufferpos; + unsigned int outbufferlen; + mp_image_t *outbuffermpi; + + // qscale buffer + unsigned char *qbuffer; + size_t qbuffersize; + + unsigned int outfmt; + + int argc; +} const vf_priv_dflt = {}; + +//===========================================================================// + +static void set_imgprop(struct vf_dlopen_picdata *out, const mp_image_t *mpi) +{ + int i; + out->planes = mpi->num_planes; + for (i = 0; i < mpi->num_planes; ++i) { + out->plane[i] = mpi->planes[i]; + out->planestride[i] = mpi->stride[i]; + out->planewidth[i] = + i ? (/*mpi->chroma_width*/ mpi->w >> mpi->chroma_x_shift) : mpi->w; + out->planeheight[i] = + i ? (/*mpi->chroma_height*/ mpi->h >> mpi->chroma_y_shift) : mpi->h; + out->planexshift[i] = i ? mpi->chroma_x_shift : 0; + out->planeyshift[i] = i ? mpi->chroma_y_shift : 0; + } +} + +static int config(struct vf_instance *vf, + int width, int height, int d_width, int d_height, + unsigned int flags, unsigned int fmt) +{ + vf->priv->filter.in_width = width; + vf->priv->filter.in_height = height; + vf->priv->filter.in_d_width = d_width; + vf->priv->filter.in_d_height = d_height; + vf->priv->filter.in_fmt = mp_imgfmt_to_name(fmt); + vf->priv->filter.out_width = width; + vf->priv->filter.out_height = height; + vf->priv->filter.out_d_width = d_width; + vf->priv->filter.out_d_height = d_height; + vf->priv->filter.out_fmt = NULL; + vf->priv->filter.out_cnt = 1; + + if (!vf->priv->filter.in_fmt) { + mp_msg(MSGT_VFILTER, MSGL_ERR, "invalid input/output format\n"); + return 0; + } + if (vf->priv->filter.config && vf->priv->filter.config(&vf->priv->filter) < 0) { + mp_msg(MSGT_VFILTER, MSGL_ERR, "filter config failed\n"); + return 0; + } + + if (vf->priv->filter.out_fmt) + vf->priv->outfmt = mp_imgfmt_from_name(vf->priv->filter.out_fmt); + else { + struct vf_dlopen_formatpair *p = vf->priv->filter.format_mapping; + vf->priv->outfmt = 0; + if (p) { + for (; p->from; ++p) { + // TODO support pixel format classes in matching + if (!strcmp(p->from, vf->priv->filter.in_fmt)) { + vf->priv->outfmt = p->to ? mp_imgfmt_from_name(p->to) : fmt; + break; + } + } + } else + vf->priv->outfmt = fmt; + vf->priv->filter.out_fmt = mp_imgfmt_to_name(vf->priv->outfmt); + } + + if (!vf->priv->outfmt) { + mp_msg(MSGT_VFILTER, MSGL_ERR, + "filter config wants an unsupported output format\n"); + return 0; + } + if (!vf->priv->filter.out_cnt || vf->priv->filter.out_cnt > + FILTER_MAX_OUTCNT) { + mp_msg(MSGT_VFILTER, MSGL_ERR, + "filter config wants to yield zero or too many output frames\n"); + return 0; + } + + int i; + for (i = 0; i < vf->priv->filter.out_cnt; ++i) { + vf->priv->outpic[i] = + alloc_mpi(vf->priv->filter.out_width, vf->priv->filter.out_height, + vf->priv->outfmt); + set_imgprop(&vf->priv->filter.outpic[i], vf->priv->outpic[i]); + } + + return vf_next_config(vf, vf->priv->filter.out_width, + vf->priv->filter.out_height, + vf->priv->filter.out_d_width, + vf->priv->filter.out_d_height, + flags, vf->priv->outfmt); +} + +static void uninit(struct vf_instance *vf) +{ + if (vf->priv->filter.uninit) + vf->priv->filter.uninit(&vf->priv->filter); + memset(&vf->priv->filter, 0, sizeof(&vf->priv->filter)); + if (vf->priv->dll) { + DLLClose(vf->priv->dll); + vf->priv->dll = NULL; + } + int i; + for (i = 0; i < vf->priv->filter.out_cnt; ++i) { + free_mp_image(vf->priv->outpic[i]); + vf->priv->outpic[i] = NULL; + } + if (vf->priv->qbuffer) { + free(vf->priv->qbuffer); + vf->priv->qbuffer = NULL; + } +} + +static int continue_put_image(struct vf_instance *vf) +{ + int k; + int ret = 0; + + mp_image_t *dmpi = + vf_get_image(vf->next, vf->priv->outfmt, MP_IMGTYPE_EXPORT, 0, + vf->priv->outpic[vf->priv->outbufferpos]->w, + vf->priv->outpic[vf->priv->outbufferpos]->h); + for (k = 0; k < vf->priv->outpic[vf->priv->outbufferpos]->num_planes; + ++k) { + dmpi->planes[k] = vf->priv->outpic[vf->priv->outbufferpos]->planes[k]; + dmpi->stride[k] = vf->priv->outpic[vf->priv->outbufferpos]->stride[k]; + } + + // pass through qscale if we can + vf_clone_mpi_attributes(dmpi, vf->priv->outbuffermpi); + + ret = + vf_next_put_image(vf, dmpi, + vf->priv->filter.outpic[vf->priv->outbufferpos].pts); + + ++vf->priv->outbufferpos; + + // more frames left? + if (vf->priv->outbufferpos < vf->priv->outbufferlen) + vf_queue_frame(vf, continue_put_image); + + return ret; +} + +static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts) +{ + int i, k; + + set_imgprop(&vf->priv->filter.inpic, mpi); + if (mpi->qscale) { + if (mpi->qscale_type != 0) { + k = mpi->qstride * ((mpi->height + 15) >> 4); + if (vf->priv->qbuffersize != k) { + vf->priv->qbuffer = realloc(vf->priv->qbuffer, k); + vf->priv->qbuffersize = k; + } + for (i = 0; i < k; ++i) + vf->priv->qbuffer[i] = norm_qscale(mpi->qscale[i], + mpi->qscale_type); + vf->priv->filter.inpic_qscale = vf->priv->qbuffer; + } else + vf->priv->filter.inpic_qscale = mpi->qscale; + vf->priv->filter.inpic_qscalestride = mpi->qstride; + vf->priv->filter.inpic_qscaleshift = 4; + } else { + vf->priv->filter.inpic_qscale = NULL; + vf->priv->filter.inpic_qscalestride = 0; + vf->priv->filter.inpic_qscaleshift = 0; + } + vf->priv->filter.inpic.pts = pts; + + int ret = vf->priv->filter.put_image(&vf->priv->filter); + if (ret <= 0) + return ret; + + vf->priv->outbuffermpi = mpi; + vf->priv->outbufferlen = ret; + vf->priv->outbufferpos = 0; + return continue_put_image(vf); +} + +//===========================================================================// + +static int query_format(struct vf_instance *vf, unsigned int fmt) +{ + if (IMGFMT_IS_HWACCEL(fmt) || fmt == IMGFMT_MJPEG || fmt == IMGFMT_MPEGPES) + return 0; // these can't really be filtered + if (fmt == IMGFMT_RGB8 || fmt == IMGFMT_BGR8) + return 0; // we don't have palette support, sorry + const char *fmtname = mp_imgfmt_to_name(fmt); + if (!fmtname) + return 0; + struct vf_dlopen_formatpair *p = vf->priv->filter.format_mapping; + unsigned int outfmt = 0; + if (p) { + for (; p->from; ++p) { + // TODO support pixel format classes in matching + if (!strcmp(p->from, fmtname)) { + outfmt = p->to ? mp_imgfmt_from_name(p->to) : fmt; + break; + } + } + } else + outfmt = fmt; + if (!outfmt) + return 0; + return vf_next_query_format(vf, outfmt); +} + +static int vf_open(vf_instance_t *vf, char *args) +{ + if (!vf->priv->cfg_dllname) { + mp_msg(MSGT_VFILTER, MSGL_ERR, + "usage: -vf dlopen=filename.so:function:args\n"); + return 0; + } + + vf->priv->dll = DLLOpen(vf->priv->cfg_dllname); + if (!vf->priv->dll) { + mp_msg(MSGT_VFILTER, MSGL_ERR, "library not found: %s\n", + vf->priv->cfg_dllname); + return 0; + } + + vf_dlopen_getcontext_func *func = + (vf_dlopen_getcontext_func *) DLLSymbol(vf->priv->dll, "vf_dlopen_getcontext"); + if (!func) { + mp_msg(MSGT_VFILTER, MSGL_ERR, "library is not a filter: %s\n", + vf->priv->cfg_dllname); + return 0; + } + + memset(&vf->priv->filter, 0, sizeof(vf->priv->filter)); + vf->priv->filter.major_version = VF_DLOPEN_MAJOR_VERSION; + vf->priv->filter.minor_version = VF_DLOPEN_MINOR_VERSION; + + // count arguments + for (vf->priv->cfg_argc = 0; + vf->priv->cfg_argc < sizeof(vf->priv->cfg_argv) / sizeof(vf->priv->cfg_argv[0]) && vf->priv->cfg_argv[vf->priv->cfg_argc]; + ++vf->priv->cfg_argc) + ; + + if (func(&vf->priv->filter, vf->priv->cfg_argc, vf->priv->cfg_argv) < 0) { + mp_msg(MSGT_VFILTER, MSGL_ERR, + "function did not create a filter: %s\n", + vf->priv->cfg_dllname); + return 0; + } + + if (!vf->priv->filter.put_image) { + mp_msg(MSGT_VFILTER, MSGL_ERR, + "function did not create a filter that can put images: %s\n", + vf->priv->cfg_dllname); + return 0; + } + + vf->put_image = put_image; + vf->query_format = query_format; + vf->config = config; + vf->uninit = uninit; + + return 1; +} + +#define ST_OFF(f) M_ST_OFF(struct vf_priv_s, f) +static m_option_t vf_opts_fields[] = { + {"dll", ST_OFF(cfg_dllname), CONF_TYPE_STRING, 0, 0, 0, NULL}, + {"a0", ST_OFF(cfg_argv[0]), CONF_TYPE_STRING, 0, 0, 0, NULL}, + {"a1", ST_OFF(cfg_argv[1]), CONF_TYPE_STRING, 0, 0, 0, NULL}, + {"a2", ST_OFF(cfg_argv[2]), CONF_TYPE_STRING, 0, 0, 0, NULL}, + {"a3", ST_OFF(cfg_argv[3]), CONF_TYPE_STRING, 0, 0, 0, NULL}, + { NULL, NULL, 0, 0, 0, 0, NULL } +}; + +static const m_struct_t vf_opts = { + "dlopen", + sizeof(struct vf_priv_s), + &vf_priv_dflt, + vf_opts_fields +}; + +const vf_info_t vf_info_dlopen = { + "Dynamic library filter", + "dlopen", + "Rudolf Polzer", + "", + vf_open, + &vf_opts +}; + +//===========================================================================// diff --git a/libmpcodecs/vf_dlopen.h b/libmpcodecs/vf_dlopen.h new file mode 100644 index 0000000000..962605ca28 --- /dev/null +++ b/libmpcodecs/vf_dlopen.h @@ -0,0 +1,88 @@ +#ifndef VF_DLOPEN_H +#define VF_DLOPEN_H + +// when doing a two-way compatible change, don't change these +// when doing a backwards compatible change, bump minor version +// when doing an incompatible change, bump major version and zero minor version +#define VF_DLOPEN_MAJOR_VERSION 1 +#define VF_DLOPEN_MINOR_VERSION 0 + +#if VF_DLOPEN_MINOR_VERSION > 0 +# define VF_DLOPEN_CHECK_VERSION(ctx) \ + do { \ + if (ctx->major_version != VF_DLOPEN_MAJOR_VERSION || \ + ctx->minor_version < VF_DLOPEN_MINOR_VERSION) \ + return -1; \ + } while (0) +#else +// workaround for "comparison is always false" warning +# define VF_DLOPEN_CHECK_VERSION(ctx) \ + do { \ + if (ctx->major_version != VF_DLOPEN_MAJOR_VERSION) \ + return -1; \ + } while (0) +#endif + +// valid pixel format names: +// "yv12": planar YUV, U and V planes have an xshift and yshift of 1 +// "rgb24": packed RGB24 +struct vf_dlopen_formatpair { + const char *from; // (LATER) can also be a name of a format class + const char *to; // if NULL, this means identical format as source +}; + +#define FILTER_MAX_OUTCNT 16 + +struct vf_dlopen_picdata { + unsigned int planes; + unsigned char *plane[4]; + signed int planestride[4]; + unsigned int planewidth[4]; + unsigned int planeheight[4]; + unsigned int planexshift[4]; + unsigned int planeyshift[4]; + double pts; +}; + +struct vf_dlopen_context { + unsigned short major_version; + unsigned short minor_version; + + void *priv; + + struct vf_dlopen_formatpair *format_mapping; + // {NULL, NULL} terminated list of supported format pairs + // if NULL, anything goes + + int (*config)(struct vf_dlopen_context *ctx); // -1 = error + // image config is put into the in_* members before calling this + // fills in the out_* members (which are preinitialized for an identity vf_dlopen_context) + + int (*put_image)(struct vf_dlopen_context *ctx); // returns number of images written, or negative on error + // before this is called, inpic_* and outpic_* are filled + + void (*uninit)(struct vf_dlopen_context *ctx); + + unsigned int in_width; + unsigned int in_height; + unsigned int in_d_width; + unsigned int in_d_height; + const char *in_fmt; + unsigned int out_width; + unsigned int out_height; + unsigned int out_d_width; + unsigned int out_d_height; + const char *out_fmt; + unsigned int out_cnt; + + struct vf_dlopen_picdata inpic; + char *inpic_qscale; + unsigned int inpic_qscalestride; + unsigned int inpic_qscaleshift; + + struct vf_dlopen_picdata outpic[FILTER_MAX_OUTCNT]; +}; +typedef int (vf_dlopen_getcontext_func)(struct vf_dlopen_context *ctx, int argc, const char **argv); // negative on error +vf_dlopen_getcontext_func vf_dlopen_getcontext; + +#endif |