libmpcodecs/vf_tinterlace.c

   1 /*
   2     Copyright (C) 2003 Michael Zucchi <notzed@ximian.com>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17 */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "../config.h"
  24 #include "../mp_msg.h"
  25
  26 #include "img_format.h"
  27 #include "mp_image.h"
  28 #include "vf.h"
  29
  30 #include "../libvo/fastmemcpy.h"
  31
  32 struct vf_priv_s {
  33         int mode;
  34         int frame;
  35         mp_image_t *dmpi;
  36 };
  37
  38 static int put_image(struct vf_instance_s* vf, mp_image_t *mpi)
  39 {
  40         int ret = 0;
  41         mp_image_t *dmpi;
  42
  43         switch (vf->priv->mode) {
  44         case 0:
  45                 dmpi = vf->priv->dmpi;
  46                 if (dmpi == NULL) {
  47                         dmpi = vf_get_image(vf->next, mpi->imgfmt,
  48                                             MP_IMGTYPE_STATIC, MP_IMGFLAG_ACCEPT_STRIDE |
  49                                             MP_IMGFLAG_PRESERVE | MP_IMGFLAG_READABLE,
  50                                             mpi->width, mpi->height*2);
  51
  52                         vf->priv->dmpi = dmpi;
  53
  54                         memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h,
  55                                    dmpi->stride[0]*2, mpi->stride[0]);
  56                         if (mpi->flags & MP_IMGFLAG_PLANAR) {
  57                                 memcpy_pic(dmpi->planes[1], mpi->planes[1],
  58                                            mpi->chroma_width, mpi->chroma_height,
  59                                            dmpi->stride[1]*2, mpi->stride[1]);
  60                                 memcpy_pic(dmpi->planes[2], mpi->planes[2],
  61                                            mpi->chroma_width, mpi->chroma_height,
  62                                            dmpi->stride[2]*2, mpi->stride[2]);
  63                         }
  64                 } else {
  65                         vf->priv->dmpi = NULL;
  66
  67                         memcpy_pic(dmpi->planes[0]+dmpi->stride[0], mpi->planes[0], mpi->w, mpi->h,
  68                                    dmpi->stride[0]*2, mpi->stride[0]);
  69                         if (mpi->flags & MP_IMGFLAG_PLANAR) {
  70                                 memcpy_pic(dmpi->planes[1]+dmpi->stride[1], mpi->planes[1],
  71                                            mpi->chroma_width, mpi->chroma_height,
  72                                            dmpi->stride[1]*2, mpi->stride[1]);
  73                                 memcpy_pic(dmpi->planes[2]+dmpi->stride[2], mpi->planes[2],
  74                                            mpi->chroma_width, mpi->chroma_height,
  75                                            dmpi->stride[2]*2, mpi->stride[2]);
  76                         }
  77                         ret = vf_next_put_image(vf, dmpi);
  78                 }
  79                 break;
  80         case 1:
  81                 if (vf->priv->frame & 1)
  82                         ret = vf_next_put_image(vf, mpi);
  83                 break;
  84         case 2:
  85                 if ((vf->priv->frame & 1) == 0)
  86                         ret = vf_next_put_image(vf, mpi);
  87                 break;
  88         case 3:
  89                 dmpi = vf_get_image(vf->next, mpi->imgfmt,
  90                                     MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
  91                                     mpi->width, mpi->height*2);
  92                 /* fixme, just clear alternate lines */
  93                 vf_mpi_clear(dmpi, 0, 0, dmpi->w, dmpi->h);
  94                 if ((vf->priv->frame & 1) == 0) {
  95                         memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h,
  96                                    dmpi->stride[0]*2, mpi->stride[0]);
  97                         if (mpi->flags & MP_IMGFLAG_PLANAR) {
  98                                 memcpy_pic(dmpi->planes[1], mpi->planes[1],
  99                                            mpi->chroma_width, mpi->chroma_height,
 100                                            dmpi->stride[1]*2, mpi->stride[1]);
 101                                 memcpy_pic(dmpi->planes[2], mpi->planes[2],
 102                                            mpi->chroma_width, mpi->chroma_height,
 103                                            dmpi->stride[2]*2, mpi->stride[2]);
 104                         }
 105                 } else {
 106                         memcpy_pic(dmpi->planes[0]+dmpi->stride[0], mpi->planes[0], mpi->w, mpi->h,
 107                                    dmpi->stride[0]*2, mpi->stride[0]);
 108                         if (mpi->flags & MP_IMGFLAG_PLANAR) {
 109                                 memcpy_pic(dmpi->planes[1]+dmpi->stride[1], mpi->planes[1],
 110                                            mpi->chroma_width, mpi->chroma_height,
 111                                            dmpi->stride[1]*2, mpi->stride[1]);
 112                                 memcpy_pic(dmpi->planes[2]+dmpi->stride[2], mpi->planes[2],
 113                                            mpi->chroma_width, mpi->chroma_height,
 114                                            dmpi->stride[2]*2, mpi->stride[2]);
 115                         }
 116                 }
 117                 ret = vf_next_put_image(vf, dmpi);
 118                 break;
 119         }
 120
 121         vf->priv->frame++;
 122
 123         return ret;
 124 }
 125
 126 static int query_format(struct vf_instance_s* vf, unsigned int fmt)
 127 {
 128         /* FIXME - figure out which other formats work */
 129         switch (fmt) {
 130         case IMGFMT_YV12:
 131         case IMGFMT_IYUV:
 132         case IMGFMT_I420:
 133                 return vf_next_query_format(vf, fmt);
 134         }
 135         return 0;
 136 }
 137
 138 static int config(struct vf_instance_s* vf,
 139         int width, int height, int d_width, int d_height,
 140         unsigned int flags, unsigned int outfmt)
 141 {
 142         switch (vf->priv->mode) {
 143         case 0:
 144         case 3:
 145                 return vf_next_config(vf,width,height*2,d_width,d_height*2,flags,outfmt);
 146         case 1:                 /* odd frames */
 147         case 2:                 /* even frames */
 148                 return vf_next_config(vf,width,height,d_width,d_height,flags,outfmt);
 149         }
 150         return 0;
 151 }
 152
 153 static void uninit(struct vf_instance_s* vf)
 154 {
 155         free(vf->priv);
 156 }
 157
 158 static int open(vf_instance_t *vf, char* args)
 159 {
 160         struct vf_priv_s *p;
 161         vf->config = config;
 162         vf->put_image = put_image;
 163         vf->query_format = query_format;
 164         vf->uninit = uninit;
 165         vf->default_reqs = VFCAP_ACCEPT_STRIDE;
 166         vf->priv = p = calloc(1, sizeof(struct vf_priv_s));
 167         vf->priv->mode = 0;
 168         if (args)
 169           sscanf(args, "%d", &vf->priv->mode);
 170         vf->priv->frame = 0;
 171         return 1;
 172 }
 173
 174 vf_info_t vf_info_tinterlace = {
 175         "temporal field interlacing",
 176         "tinterlace",
 177         "Michael Zucchi",
 178         "",
 179         open,
 180         NULL
 181 };