mirror of https://github.com/mpv-player/mpv
313 lines
8.0 KiB
C
313 lines
8.0 KiB
C
/*
|
|
* vf_tile.c - filter to tile a serie of image in a single, bigger, image
|
|
*
|
|
* The parameters are:
|
|
*
|
|
* xtile: number of tile on the x axis (5)
|
|
* ytile: number of tile on the y axis (5)
|
|
* xytile: when write the image, it can be different then xtile * ytile
|
|
* (for example you can write 8 * 7 tile, writing the file every
|
|
* 50 frame, to have one image every 2 seconds @ 25 fps ).
|
|
* start: pixel at the start (x/y), default 2
|
|
* delta: pixel between 2 tile, (x/y), default 4
|
|
*
|
|
* For example a valid command line is:
|
|
* ... -vf tile=10:5:-1:4:8 ...
|
|
* that make images of 10 * 5 tiles, with 4 pixel at the beginning and
|
|
* 8 pixel between tiles.
|
|
*
|
|
* The default command is:
|
|
* ... -vf tile=5:5:25:2:4
|
|
*
|
|
* If you omit a parameter or put a value less then 0, the default is used.
|
|
* ... -vf tile=10:5::-1:10
|
|
*
|
|
* You can also stop when you're ok
|
|
* ... -vf tile=10:5
|
|
* (and this is probably the option you will use more often ...)
|
|
*
|
|
* Probably is good to put the scale filter before the tile :-)
|
|
*
|
|
* Daniele Forghieri ( guru@digitalfantasy.it )
|
|
*/
|
|
|
|
// strtoi memcpy_pic
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "config.h"
|
|
#include "mp_msg.h"
|
|
#include "help_mp.h"
|
|
#include "cpudetect.h"
|
|
|
|
#include "img_format.h"
|
|
#include "mp_image.h"
|
|
#include "vf.h"
|
|
|
|
#include "libvo/fastmemcpy.h"
|
|
|
|
/* private data */
|
|
struct vf_priv_s {
|
|
/* configuration data */
|
|
/* Number on hor/ver tiles */
|
|
int xtile;
|
|
int ytile;
|
|
/* When write the whole frame (default = xtile * ytile) */
|
|
int xytile;
|
|
/* pixel at start / end (default = 4) */
|
|
int start;
|
|
/* pixel between image (default = 2) */
|
|
int delta;
|
|
// /* Background color, in destination format */
|
|
// int bkgSet;
|
|
|
|
/* Work data */
|
|
int frame_cur;
|
|
};
|
|
|
|
|
|
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;
|
|
int xw;
|
|
int yh;
|
|
|
|
/* Calculate new destination size */
|
|
priv = vf->priv;
|
|
xw = priv->start * 2 +
|
|
priv->xtile * width +
|
|
(priv->xtile - 1) * priv->delta;
|
|
yh = priv->start * 2 +
|
|
priv->ytile * height +
|
|
(priv->ytile - 1) * priv->delta;
|
|
|
|
mp_msg(MSGT_VFILTER,MSGL_V,"vf_tile:config size set to %d * %d\n", xw, yh);
|
|
|
|
return vf_next_config(vf, xw, yh, xw, yh, flags, outfmt);
|
|
}
|
|
|
|
/* Filter handler */
|
|
static int put_image(struct vf_instance_s* vf, mp_image_t *mpi, double pts)
|
|
{
|
|
mp_image_t *dmpi;
|
|
struct vf_priv_s *priv;
|
|
int t;
|
|
int xw;
|
|
int yh;
|
|
int xi;
|
|
int yi;
|
|
int by;
|
|
int dw;
|
|
|
|
/* Calculate new size */
|
|
priv = vf->priv;
|
|
xw = priv->start * 2 +
|
|
priv->xtile * mpi->w +
|
|
(priv->xtile - 1) * priv->delta;
|
|
yh = priv->start * 2 +
|
|
priv->ytile * mpi->h+
|
|
(priv->ytile - 1) * priv->delta;
|
|
|
|
/* Get the big image! */
|
|
dmpi=vf_get_image(vf->next, mpi->imgfmt,
|
|
MP_IMGTYPE_STATIC, MP_IMGFLAG_ACCEPT_STRIDE,
|
|
xw, yh);
|
|
|
|
/* bytes x pixel & bytes x line */
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR) {
|
|
by = 1;
|
|
dw = mpi->w;
|
|
}
|
|
else {
|
|
by = (mpi->bpp + 7) / 8;
|
|
dw = mpi->w * by;
|
|
}
|
|
/* Index position */
|
|
t = priv->frame_cur % priv->xytile;
|
|
// if ((t == 0) && (bkg != 0)) {
|
|
// /* First frame, delete the background */
|
|
//
|
|
// }
|
|
|
|
/* Position of image */
|
|
xi = priv->start + (mpi->w + priv->delta) * (t % priv->xtile);
|
|
yi = priv->start + (mpi->h + priv->delta) * (t / priv->xtile);
|
|
|
|
/* Copy first (or only) plane */
|
|
memcpy_pic( dmpi->planes[0] + xi * by + yi * dmpi->stride[0],
|
|
mpi->planes[0],
|
|
dw,
|
|
mpi->h,
|
|
dmpi->stride[0],
|
|
mpi->stride[0]);
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR) {
|
|
/* Copy the other 2 planes */
|
|
memcpy_pic( dmpi->planes[1] + (xi >> mpi->chroma_x_shift) + (yi >> mpi->chroma_y_shift) * dmpi->stride[1],
|
|
mpi->planes[1],
|
|
mpi->chroma_width,
|
|
mpi->chroma_height,
|
|
dmpi->stride[1],
|
|
mpi->stride[1]);
|
|
memcpy_pic( dmpi->planes[2] + (xi >> mpi->chroma_x_shift) + (yi >> mpi->chroma_y_shift) * dmpi->stride[2],
|
|
mpi->planes[2],
|
|
mpi->chroma_width,
|
|
mpi->chroma_height,
|
|
dmpi->stride[2],
|
|
mpi->stride[2]);
|
|
}
|
|
|
|
/* Increment current frame */
|
|
++priv->frame_cur;
|
|
|
|
if (t == priv->xytile - 1) {
|
|
/* Display the composition */
|
|
dmpi->width = xw;
|
|
dmpi->height = yh;
|
|
return vf_next_put_image(vf, dmpi, MP_NOPTS_VALUE);
|
|
}
|
|
else {
|
|
/* Skip the frame */
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
static void uninit(struct vf_instance_s* vf)
|
|
{
|
|
/* free local data */
|
|
free(vf->priv);
|
|
}
|
|
|
|
/* rgb/bgr 15->32 supported & some Yxxx */
|
|
static int query_format(struct vf_instance_s* vf, unsigned int fmt)
|
|
{
|
|
switch (fmt) {
|
|
/* rgb 15 -> 32 bit */
|
|
case IMGFMT_RGB15:
|
|
case IMGFMT_RGB16:
|
|
case IMGFMT_RGB24:
|
|
case IMGFMT_RGB32:
|
|
/* bgr 15 -> 32 bit */
|
|
case IMGFMT_BGR15:
|
|
case IMGFMT_BGR16:
|
|
case IMGFMT_BGR24:
|
|
case IMGFMT_BGR32:
|
|
/* Various Yxxx Formats */
|
|
case IMGFMT_444P:
|
|
case IMGFMT_422P:
|
|
case IMGFMT_411P:
|
|
case IMGFMT_YUY2:
|
|
case IMGFMT_YV12:
|
|
case IMGFMT_I420:
|
|
case IMGFMT_YVU9:
|
|
case IMGFMT_IF09:
|
|
case IMGFMT_IYUV:
|
|
return vf_next_query_format(vf, fmt);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Get an integer from the string pointed by s, adjusting s.
|
|
* If the value is less then 0 def_val is used.
|
|
* Return 0 for ok
|
|
*
|
|
* Look below ( in open(...) ) for a use ...
|
|
*/
|
|
static int parse_int(char **s, int *rt, int def_val)
|
|
{
|
|
|
|
int t = 0;
|
|
|
|
if (**s) {
|
|
/* Get value (dec, hex or octal) */
|
|
t = strtol( *s, s, 0 );
|
|
|
|
/* Use default */
|
|
if (t < 0) {
|
|
t = def_val;
|
|
}
|
|
|
|
if (**s == ':') {
|
|
/* Point to next character (problably a digit) */
|
|
++(*s);
|
|
}
|
|
else if (**s != '\0') {
|
|
/* Error, we got some wrong char */
|
|
return(1);
|
|
}
|
|
}
|
|
else {
|
|
t = def_val;
|
|
}
|
|
|
|
*rt = t;
|
|
return(0);
|
|
|
|
}
|
|
|
|
/* Main entry funct for the filter */
|
|
static int open(vf_instance_t *vf, char* args)
|
|
{
|
|
struct vf_priv_s *p;
|
|
int er;
|
|
|
|
vf->put_image = put_image;
|
|
vf->query_format = query_format;
|
|
vf->config = config;
|
|
vf->uninit = uninit;
|
|
vf->default_reqs = VFCAP_ACCEPT_STRIDE;
|
|
/* Private data */
|
|
vf->priv = p = calloc(1, sizeof(struct vf_priv_s));
|
|
if (p == NULL) {
|
|
return(0);
|
|
}
|
|
|
|
if (args == NULL) {
|
|
/* Use the default */
|
|
args = "";
|
|
}
|
|
/* Parse all the arguments */
|
|
er = parse_int( &args, &p->xtile, 5 );
|
|
er |= parse_int( &args, &p->ytile, 5 );
|
|
er |= parse_int( &args, &p->xytile, 0 );
|
|
er |= parse_int( &args, &p->start, 2 );
|
|
er |= parse_int( &args, &p->delta, 4 );
|
|
// er |= parse_int( &args, &p->bkgSet, 0 );
|
|
|
|
if (er) {
|
|
mp_msg(MSGT_VFILTER, MSGL_ERR, MSGTR_MPCODECS_ErrorParsingArgument);
|
|
return(0);
|
|
}
|
|
/* Load some default */
|
|
if ((p->xytile <= 0) || (p->xytile > p->xtile * p->ytile)) {
|
|
p->xytile = p->xtile * p->ytile;
|
|
}
|
|
|
|
/* Say what happen: use mp_msg(...)? */
|
|
if ( mp_msg_test(MSGT_VFILTER,MSGL_V) ) {
|
|
printf("vf_tile: tiling %d * %d, output every %d frames\n",
|
|
p->xtile,
|
|
p->ytile,
|
|
p->xytile);
|
|
printf("vf_tile: start pixel %d, delta pixel %d\n",
|
|
p->start,
|
|
p->delta);
|
|
// printf("vf_tile: background 0x%x\n",
|
|
// p->bkgSet);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
const vf_info_t vf_info_tile = {
|
|
"Make a single image tiling x/y images",
|
|
"tile",
|
|
"Daniele Forghieri",
|
|
"",
|
|
open,
|
|
NULL
|
|
};
|