Mercurial > mplayer.hg
view libmpcodecs/vf_tile.c @ 33179:218edd8fc782
Cosmetic: Format to MPlayer coding style.
Additionally: remove needless includes, group and sort includes, group
and sort variables, rename gtkAOFakeSurround declaration gtkAOSurround,
add #ifdefs to variable declarations, group statements by adding or
removing new lines to ease reading, move assignments outside conditions,
add parentheses, avoid mixing declaration and code, revise comments and
add new ones.
author | ib |
---|---|
date | Fri, 15 Apr 2011 14:30:58 +0000 |
parents | 7af3e6f901fd |
children |
line wrap: on
line source
/* * 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 :-) * * 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 (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 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 };