highperfocused/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lavfi: remove mp=tile filter.

Browse Source 
The native tile video filter is now feature equivalent.
This commit is contained in:
Clément Bœsch 2012-11-08 23:42:38 +01:00
parent a8afb0830e
commit 84aed3faf0
5 changed files with 1 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
doc/filters.texi
View File

@ -2711,7 +2711,6 @@ The list of the currently supported filters follows:
@item softskip
@item spp
@item telecine
@item tile
@item tinterlace
@item unsharp
@item uspp

1
libavfilter/Makefile
View File

@ -192,7 +192,6 @@ OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_softskip.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_spp.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_stereo3d.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_telecine.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_tile.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_tinterlace.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_unsharp.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_uspp.o

330
libavfilter/libmpcodecs/vf_tile.c
View File

@ -1,330 +0,0 @@
/*
* filter to tile a series of images in a single, bigger, image
*
* The parameters are:
*
* xtile: number of tiles on the x axis (5)
* ytile: number of tiles on the y axis (5)
* xytile: when writing the image, it can be different than xtile * ytile
* (for example you can write 8 * 7 tiles, writing the file every
* 50 frames, to have one image every 2 seconds @ 25 fps ).
* start: pixels at the start (x/y), default 2
* delta: pixels between 2 tiles, (x/y), default 4
*
* For example a valid command line is:
* ... -vf tile=10:5:-1:4:8 ...
* that makes images of 10 * 5 tiles, with 4 pixels at the beginning and
* 8 pixels between tiles.
*
* The default command is:
* ... -vf tile=5:5:25:2:4
*
* If you omit a parameter or put a value less than 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 :-)
*
* Copyright (c) 2003 Daniele Forghieri ( guru@digitalfantasy.it )
*
* 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, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
// 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 *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 *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 *vf)
{
/* free local data */
free(vf->priv);
}
/* rgb/bgr 12...32 supported & some Yxxx */
static int query_format(struct vf_instance *vf, unsigned int fmt)
{
switch (fmt) {
/* rgb 12...32 bit */
case IMGFMT_RGB12:
case IMGFMT_RGB15:
case IMGFMT_RGB16:
case IMGFMT_RGB24:
case IMGFMT_RGB32:
/* bgr 12...32 bit */
case IMGFMT_BGR12:
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 vf_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 (probably 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 vf_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",
"",
vf_open,
NULL
};

2
libavfilter/version.h
View File

@ -30,7 +30,7 @@
#define LIBAVFILTER_VERSION_MAJOR 3
#define LIBAVFILTER_VERSION_MINOR 21
#define LIBAVFILTER_VERSION_MICRO 106
#define LIBAVFILTER_VERSION_MICRO 107
#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
LIBAVFILTER_VERSION_MINOR, \

2
libavfilter/vf_mp.c
View File

@ -171,7 +171,6 @@ extern const vf_info_t vf_info_stereo3d;
extern const vf_info_t vf_info_telecine;
extern const vf_info_t vf_info_test;
extern const vf_info_t vf_info_tfields;
extern const vf_info_t vf_info_tile;
extern const vf_info_t vf_info_tinterlace;
extern const vf_info_t vf_info_unsharp;
extern const vf_info_t vf_info_uspp;
@ -214,7 +213,6 @@ static const vf_info_t* const filters[]={
&vf_info_spp,
&vf_info_stereo3d,
&vf_info_telecine,
&vf_info_tile,
&vf_info_tinterlace,
&vf_info_unsharp,
&vf_info_uspp,