mirror of https://github.com/mpv-player/mpv
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/
This commit is contained in:
Rudolf Polzer
wm4
parent
2e6450c7cc
commit
2adc81f0a2
|
|
@ -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.
|
||||
|
|
|
|||
1
Makefile
1
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 \
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
void copy_plane(
|
||||
unsigned char *dest, unsigned dest_stride,
|
||||
const unsigned char *src, unsigned src_stride,
|
||||
unsigned length,
|
||||
unsigned rows
|
||||
);
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
};
|
||||
|
||||
//===========================================================================//
|
||||
|
|
@ -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
|
||||
Loading…
Reference in New Issue