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/

DOCS/man/en/vf.rst

@@ -1405,3 +1405,23 @@ fixpts[=options]
 
     *NOTE*: Using this filter together with any sort of seeking (including
     ``--ss``) may make demons fly out of your nose.
+
+dlopen=dll[:a0[:a1[:a2[:a3]]]]
+    Loads an external library to filter the image. The library interface
+    is the vf_dlopen interface specified using libmpcodecs/vf_dlopen.h.
+
+    dll=<library>
+        Specify the library to load. This may require a full file system path
+        in some cases! This argument is required.
+
+    a0=<string>
+        Specify the first parameter to pass to the library.
+
+    a1=<string>
+        Specify the second parameter to pass to the library.
+
+    a2=<string>
+        Specify the third parameter to pass to the library.
+
+    a3=<string>
+        Specify the fourth parameter to pass to the library.

Makefile

@@ -161,6 +161,7 @@ SRCS_COMMON = asxparser.c \
               libmpcodecs/vf_detc.c \
               libmpcodecs/vf_dint.c \
               libmpcodecs/vf_divtc.c \
+              libmpcodecs/vf_dlopen.c \
               libmpcodecs/vf_down3dright.c \
               libmpcodecs/vf_dsize.c \
               libmpcodecs/vf_dvbscale.c \

TOOLS/vf_dlopen/Makefile

@@ -0,0 +1,24 @@
+FILTERS = showqscale telecine tile
+COMMON = filterutils.o
+
+OBJECTS = $(patsubst %,%.o,$(FILTERS)) $(COMMON)
+HEADERS = $(wildcard *.h)
+OUT = $(patsubst %,%.so,$(FILTERS))
+
+CFLAGS ?= -Wall -Wextra -O3 -march=native -mtune=native
+
+CPPFLAGS += -I../../libmpcodecs
+CFLAGS += -fPIC
+LDFLAGS += -shared -fPIC
+
+all: $(OUT)
+
+clean:
+	$(RM) $(OBJECTS) $(OUT)
+
+%.so: %.o $(COMMON)
+	$(CC) $(LDFLAGS) $(LIBS) -o $@ $(COMMON) $<
+
+# FIXME replace this by real dependency tracking
+%.o: %.c $(HEADERS)
+

TOOLS/vf_dlopen/filterutils.c

@@ -0,0 +1,19 @@
+#include <assert.h>
+#include <string.h>
+
+#include "filterutils.h"
+
+void copy_plane(
+    unsigned char *dest, unsigned dest_stride,
+    const unsigned char *src, unsigned src_stride,
+    unsigned length,
+    unsigned rows
+    )
+{
+    unsigned i;
+    assert(dest_stride >= length);
+    assert(src_stride >= length);
+    for (i = 0; i < rows; ++i)
+        memcpy(&dest[dest_stride * i], &src[src_stride * i], length);
+}
+

TOOLS/vf_dlopen/filterutils.h

@@ -0,0 +1,6 @@
+void copy_plane(
+    unsigned char *dest, unsigned dest_stride,
+    const unsigned char *src, unsigned src_stride,
+    unsigned length,
+    unsigned rows
+    );

TOOLS/vf_dlopen/showqscale.c

@@ -0,0 +1,99 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "vf_dlopen.h"
+
+/*
+ * qscale visualizer
+ *
+ * usage: -vf dlopen=./showqscale.so
+ *
+ * uses reddish colors for high QPs, and greenish colors for low QPs
+ */
+
+#define PLANE_Y 0
+#define PLANE_U 1
+#define PLANE_V 2
+
+static int qs_put_image(struct vf_dlopen_context *ctx)
+{
+    unsigned int x, y, p;
+
+    assert(ctx->inpic.planes == ctx->outpic[0].planes);
+
+    for (p = 0; p < ctx->outpic[0].planes; ++p) {
+        assert(ctx->inpic.planewidth[p] == ctx->outpic[0].planewidth[p]);
+        assert(ctx->inpic.planeheight[p] == ctx->outpic[0].planeheight[p]);
+        if ((p == PLANE_U || p == PLANE_V) && ctx->inpic_qscale)
+            continue;
+#if 0
+        // copy as is
+        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
+            memcpy(
+                &ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y],
+                &inpic[ctx->outpic[0].planeofs[p] + ctx->inpic.planestride[p] * y],
+                ctx->outpic[0].planewidth[p]
+                );
+#else
+        // reduce contrast
+        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
+            for (x = 0; x < ctx->outpic[0].planewidth[p]; ++x)
+                ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y + x] =
+                    0x20 + ((ctx->inpic.plane[p][ctx->inpic.planestride[p] * y + x] * 3) >> 2);
+#endif
+    }
+
+    if (ctx->inpic_qscale) {
+        int qmin = 255;
+        int qmax = -255;
+
+        // clear U plane
+        p = PLANE_U;
+        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
+            memset(
+                &ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y],
+                0x80,
+                ctx->outpic[0].planewidth[p]
+                );
+
+        // replace V by the qp (0 = green, 12 = red)
+        p = PLANE_V;
+        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
+            for (x = 0; x < ctx->outpic[0].planewidth[p]; ++x) {
+                int q = ctx->inpic_qscale[
+                    (x >> (ctx->inpic_qscaleshift - ctx->inpic.planexshift[p])) +
+                    (y >> (ctx->inpic_qscaleshift - ctx->inpic.planeyshift[p])) * ctx->inpic_qscalestride];
+                if (q < qmin)
+                    qmin = q;
+                if (q > qmax)
+                    qmax = q;
+                int v = 128 + 21 * (q - 6); // range: 0 = green, 12 = red
+                if (v < 0)
+                    v = 0;
+                if (v > 255)
+                    v = 255;
+                ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y + x] = v;
+            }
+
+        // printf("qscale range: %d .. %d\n", qmin, qmax);
+    }
+
+    ctx->outpic[0].pts = ctx->inpic.pts;
+    return 1;
+}
+
+int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **argv)
+{
+    VF_DLOPEN_CHECK_VERSION(ctx);
+    (void) argc;
+    (void) argv;
+    static struct vf_dlopen_formatpair map[] = {
+        { "yv12", "yv12" },
+        { NULL, NULL }
+    };
+    ctx->format_mapping = map;
+    ctx->put_image = qs_put_image;
+    return 1;
+}

TOOLS/vf_dlopen/telecine.c

@@ -0,0 +1,242 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "vf_dlopen.h"
+#include "filterutils.h"
+
+#define MIN(a,b) ((a)<(b)?(a):(b))
+
+/*
+ * telecine filter
+ *
+ * usage: -vf dlopen=./telecine.so:t:32
+ *
+ * Parameter: first parameter is "t" for top field first, "b" for bottom field first
+ * then digits (0-9) for how many fields a frame is to be displayed
+ *
+ * Typical patterns (see http://en.wikipedia.org/wiki/Telecine):
+ *
+ * NTSC output (30i):
+ * 27.5p: 32222
+ * 24p: 23 (classic)
+ * 24p: 2332 (preferred)
+ * 20p: 33
+ * 18p: 334
+ * 16p: 3444
+ *
+ * PAL output (25i):
+ * 27.5p: 12222
+ * 24p: 222222222223 ("Euro pulldown")
+ * 16.67p: 33
+ * 16p: 33333334
+ */
+
+typedef struct {
+    int firstfield;
+    const char *pattern;
+    unsigned int pattern_pos;
+    unsigned char *buffer_plane[4];
+    size_t buffer_size[4];
+    int pts_num;
+    int pts_denom;
+    int occupied;
+    double lastpts_in;
+    double lastpts_out;
+} tc_data_t;
+
+static int tc_config(struct vf_dlopen_context *ctx)
+{
+    // we may return more than one pic!
+    tc_data_t *tc = ctx->priv;
+    const char *p;
+    int max = 0;
+    tc->pts_num = 0;
+    tc->pts_denom = 0;
+    for (p = tc->pattern; *p; ++p) {
+        if (*p - '0' > max)
+            max = *p - '0';
+        tc->pts_num += 2;
+        tc->pts_denom += *p - '0';
+    }
+    ctx->out_cnt = (max + 1) / 2;
+    printf(
+        "Telecine pattern %s yields up to %d frames per frame, pts advance factor: %d/%d\n",
+        tc->pattern, ctx->out_cnt, tc->pts_num, tc->pts_denom);
+    return 1;
+}
+
+static int tc_put_image(struct vf_dlopen_context *ctx)
+{
+    tc_data_t *tc = ctx->priv;
+
+    unsigned p;
+    unsigned np = ctx->outpic[0].planes;
+    assert(ctx->inpic.planes == ctx->outpic[0].planes);
+
+    int need_reinit = 0;
+
+    // fix buffers
+    for (p = 0; p < np; ++p) {
+        size_t sz = ctx->inpic.planestride[p] * ctx->inpic.planeheight[p];
+        if (sz != tc->buffer_size[p]) {
+            if (p == 0 && tc->buffer_plane[p])
+                printf("WARNING: reinitializing telecine buffers.\n");
+            tc->buffer_plane[p] = realloc(tc->buffer_plane[p], sz);
+            tc->buffer_size[p] = sz;
+            need_reinit = 1;
+        }
+    }
+
+    // too big pts change? reinit
+    if (ctx->inpic.pts < tc->lastpts_in || ctx->inpic.pts > tc->lastpts_in + 0.5)
+        need_reinit = 1;
+
+    if (need_reinit) {
+        // initialize telecine
+        tc->pattern_pos = 0;
+        tc->occupied = 0;
+        tc->lastpts_in = ctx->inpic.pts;
+        tc->lastpts_out = ctx->inpic.pts;
+    }
+
+    int len = tc->pattern[tc->pattern_pos] - '0';
+    unsigned nout;
+    double delta = ctx->inpic.pts - tc->lastpts_in;
+    tc->lastpts_in = ctx->inpic.pts;
+
+    for (nout = 0; nout < ctx->out_cnt; ++nout) {
+        for (p = 0; p < np; ++p) {
+            assert(ctx->inpic.planewidth[p] == ctx->outpic[nout].planewidth[p]);
+            assert(ctx->inpic.planeheight[p] == ctx->outpic[nout].planeheight[p]);
+        }
+    }
+    nout = 0;
+
+    if (tc->pattern_pos == 0 && !tc->occupied) {
+        // at the start of the pattern, reset pts
+        double newpts = ctx->inpic.pts - (delta * tc->pts_num) / tc->pts_denom;
+        // printf("pts reset: %f -> %f (delta: %f)\n", tc->lastpts_out, newpts, newpts - tc->lastpts_out);
+        tc->lastpts_out = newpts;
+    }
+    ++tc->pattern_pos;
+    if (!tc->pattern[tc->pattern_pos])
+        tc->pattern_pos = 0;
+
+    if (len == 0) {
+        // do not output any field from this frame
+        return 0;
+    }
+
+    if (tc->occupied) {
+        for (p = 0; p < np; ++p) {
+            // fill in the EARLIER field from the buffered pic
+            copy_plane(
+                &ctx->outpic[nout].plane[p][ctx->outpic[nout].planestride[p] * tc->firstfield],
+                ctx->outpic[nout].planestride[p] * 2,
+                &tc->buffer_plane[p][ctx->inpic.planestride[p] * tc->firstfield],
+                ctx->inpic.planestride[p] * 2,
+                MIN(ctx->inpic.planestride[p], ctx->outpic[nout].planestride[p]),
+                (ctx->inpic.planeheight[p] - tc->firstfield + 1) / 2
+                );
+            // fill in the LATER field from the new pic
+            copy_plane(
+                &ctx->outpic[nout].plane[p][ctx->outpic[nout].planestride[p] * !tc->firstfield],
+                ctx->outpic[nout].planestride[p] * 2,
+                &ctx->inpic.plane[p][ctx->inpic.planestride[p] * !tc->firstfield],
+                ctx->inpic.planestride[p] * 2,
+                MIN(ctx->inpic.planestride[p], ctx->outpic[nout].planestride[p]),
+                (ctx->inpic.planeheight[p] - !tc->firstfield + 1) / 2
+                );
+        }
+        tc->lastpts_out += (delta * tc->pts_num) / tc->pts_denom;
+        ctx->outpic[nout].pts = tc->lastpts_out;
+        // printf("pts written: %f\n", ctx->outpic[nout].pts);
+        ++nout;
+        --len;
+        tc->occupied = 0;
+    }
+
+    while (len >= 2) {
+        // output THIS image as-is
+        for (p = 0; p < np; ++p)
+            copy_plane(
+                ctx->outpic[nout].plane[p], ctx->outpic[nout].planestride[p],
+                ctx->inpic.plane[p], ctx->inpic.planestride[p],
+                MIN(ctx->inpic.planestride[p], ctx->outpic[nout].planestride[p]),
+                ctx->inpic.planeheight[p]
+                );
+        tc->lastpts_out += (delta * tc->pts_num) / tc->pts_denom;
+        ctx->outpic[nout].pts = tc->lastpts_out;
+        // printf("pts written: %f\n", ctx->outpic[nout].pts);
+        ++nout;
+        len -= 2;
+    }
+
+    if (len >= 1) {
+        // copy THIS image to the buffer, we need it later
+        for (p = 0; p < np; ++p)
+            copy_plane(
+                &tc->buffer_plane[p][0], ctx->inpic.planestride[p],
+                &ctx->inpic.plane[p][0], ctx->inpic.planestride[p],
+                ctx->inpic.planestride[p],
+                ctx->inpic.planeheight[p]
+                );
+        tc->occupied = 1;
+    }
+
+    return nout;
+}
+
+void tc_uninit(struct vf_dlopen_context *ctx)
+{
+    tc_data_t *tc = ctx->priv;
+    free(tc->buffer_plane[3]);
+    free(tc->buffer_plane[2]);
+    free(tc->buffer_plane[1]);
+    free(tc->buffer_plane[0]);
+    free(tc);
+}
+
+int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **argv)
+{
+    VF_DLOPEN_CHECK_VERSION(ctx);
+
+    const char *a0 = (argc < 1) ? "t" : argv[0];
+    const char *a1 = (argc < 2) ? "23" : argv[1];
+
+    if (!a0[0] || a0[1] || !a1[0] || argc > 2)
+        return -1;
+
+    tc_data_t *tc = malloc(sizeof(tc_data_t));
+    memset(tc, 0, sizeof(*tc));
+
+    if (a0[0] == 't')
+        tc->firstfield = 0;
+    else if (a0[0] == 'b')
+        tc->firstfield = 1;
+    else {
+        printf("telecine: invalid first field\n");
+        free(tc);
+        return -1;
+    }
+
+    tc->pattern = a1;
+
+    const char *p;
+    for (p = tc->pattern; *p; ++p)
+        if (*p < '0' || *p > '9') {
+            printf("telecine: invalid pattern\n");
+            free(tc);
+            return -1;
+        }
+
+    ctx->priv = tc;
+    ctx->format_mapping = NULL; // anything goes
+    ctx->config = tc_config;
+    ctx->put_image = tc_put_image;
+    ctx->uninit = tc_uninit;
+
+    return 1;
+}

TOOLS/vf_dlopen/tile.c

@@ -0,0 +1,157 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "vf_dlopen.h"
+#include "filterutils.h"
+
+/*
+ * tile filter
+ *
+ * usage: -vf dlopen=./tile.so:4:3
+ *
+ * only supports rgb24 and yv12 for now
+ * in theory can support any format where rows are a multiple of bytes, and the
+ * multiple is known
+ */
+
+#define ALLFORMATS \
+    /*     format   bytes   xmul   ymul */ \
+    FORMAT("rgb24", 3,      1,     1) \
+    FORMAT("yv12",  1,      2,     2)
+
+typedef struct {
+    int rows, cols;
+    unsigned char *buffer_plane[4];
+    size_t buffer_size[4];
+    int pos;
+    int pixelbytes;
+} tile_data_t;
+
+static int tile_config(struct vf_dlopen_context *ctx)
+{
+    // we may return more than one pic!
+    tile_data_t *tile = ctx->priv;
+
+    ctx->out_width = tile->cols * ctx->in_width;
+    ctx->out_height = tile->rows * ctx->in_height;
+    ctx->out_d_width = tile->cols * ctx->in_d_width;
+    ctx->out_d_height = tile->rows * ctx->in_d_height;
+
+#define FORMAT(fmt,sz,xmul,ymul) \
+        if (!strcmp(ctx->in_fmt, fmt)) { \
+            if (ctx->in_width % xmul || ctx->in_height % ymul) { \
+                printf("Format " fmt " requires width to be a multiple of %d and height to be a multiple of %d\n", \
+                       xmul, ymul); \
+                return -1; \
+            } \
+            tile->pixelbytes = sz; \
+        } else
+    ALLFORMATS
+#undef FORMAT
+    {
+        printf("Format %s is not in the list, how come?\n", ctx->in_fmt);
+        return -1;
+    }
+
+    return 1;
+}
+
+static int tile_put_image(struct vf_dlopen_context *ctx)
+{
+    tile_data_t *tile = ctx->priv;
+
+    unsigned p;
+    unsigned np = ctx->outpic[0].planes;
+    assert(ctx->inpic.planes == ctx->outpic[0].planes);
+
+    // fix buffers
+    for (p = 0; p < np; ++p) {
+        size_t sz = ctx->outpic->planestride[p] * ctx->outpic->planeheight[p];
+        if (sz != tile->buffer_size[p]) {
+            if (p == 0 && tile->buffer_plane[p])
+                printf("WARNING: reinitializing output buffers.\n");
+            tile->buffer_plane[p] = realloc(tile->buffer_plane[p], sz);
+            tile->buffer_size[p] = sz;
+            tile->pos = 0;
+        }
+    }
+
+    for (p = 0; p < np; ++p) {
+        assert(ctx->inpic.planewidth[p] * tile->cols == ctx->outpic->planewidth[p]);
+        assert(ctx->inpic.planeheight[p] * tile->rows == ctx->outpic->planeheight[p]);
+    }
+
+    // copy this frame
+    for (p = 0; p < np; ++p)
+        copy_plane(
+            &tile->buffer_plane[p][ctx->outpic->planestride[p] * ctx->inpic.planeheight[p] * (tile->pos / tile->cols) + tile->pixelbytes * ctx->inpic.planewidth[p] * (tile->pos % tile->cols)],
+            ctx->outpic->planestride[p],
+            ctx->inpic.plane[p],
+            ctx->inpic.planestride[p],
+            tile->pixelbytes * ctx->inpic.planewidth[p],
+            ctx->inpic.planeheight[p]
+            );
+
+    ++tile->pos;
+    if (tile->pos == tile->rows * tile->cols) {
+        // copy THIS image to the buffer, we need it later
+        for (p = 0; p < np; ++p)
+            copy_plane(
+                ctx->outpic->plane[p], ctx->outpic->planestride[p],
+                &tile->buffer_plane[p][0], ctx->outpic->planestride[p],
+                tile->pixelbytes * ctx->outpic->planewidth[p],
+                ctx->outpic->planeheight[p]
+                );
+        ctx->outpic->pts = ctx->inpic.pts;
+        tile->pos = 0;
+        return 1;
+    }
+
+    return 0;
+}
+
+void tile_uninit(struct vf_dlopen_context *ctx)
+{
+    tile_data_t *tile = ctx->priv;
+    free(tile->buffer_plane[3]);
+    free(tile->buffer_plane[2]);
+    free(tile->buffer_plane[1]);
+    free(tile->buffer_plane[0]);
+    free(tile);
+}
+
+int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **argv)
+{
+    VF_DLOPEN_CHECK_VERSION(ctx);
+
+    if (argc != 2)
+        return -1;
+
+    tile_data_t *tile = malloc(sizeof(tile_data_t));
+    memset(tile, 0, sizeof(*tile));
+
+    tile->cols = atoi(argv[0]);
+    tile->rows = atoi(argv[1]);
+
+    if (!tile->rows || !tile->cols) {
+        printf("tile: invalid rows/cols\n");
+        free(tile);
+        return -1;
+    }
+
+    ctx->priv = tile;
+    static struct vf_dlopen_formatpair map[] = {
+#define FORMAT(fmt,sz,xmul,ymul) {fmt, NULL},
+        ALLFORMATS
+#undef FORMAT
+        {NULL, NULL}
+    };
+    ctx->format_mapping = map;
+    ctx->config = tile_config;
+    ctx->put_image = tile_put_image;
+    ctx->uninit = tile_uninit;
+
+    return 1;
+}

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
 };
 

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
+};
+
+//===========================================================================//

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