gst/effectv/gstquark.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  *
   5  * EffecTV:
   6  * Copyright (C) 2001-2002 FUKUCHI Kentarou
   7  *
   8  * QuarkTV - motion disolver.
   9  *
  10  *  EffecTV is free software. This library is free software;
  11  * you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public
  22  * License along with this library; if not, write to the
  23  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24  * Boston, MA 02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <math.h>
  32 #include <string.h>
  33
  34 #include "gstquark.h"
  35 #include "gsteffectv.h"
  36
  37 #include <gst/video/video.h>
  38
  39 /* number of frames of time-buffer. It should be as a configurable paramater */
  40 /* This number also must be 2^n just for the speed. */
  41 #define PLANES 16
  42
  43 enum
  44 {
  45   PROP_0,
  46   PROP_PLANES
  47 };
  48
  49 GST_BOILERPLATE (GstQuarkTV, gst_quarktv, GstVideoFilter,
  50     GST_TYPE_VIDEO_FILTER);
  51
  52 static void gst_quarktv_planetable_clear (GstQuarkTV * filter);
  53
  54 static GstStaticPadTemplate gst_quarktv_src_template =
  55     GST_STATIC_PAD_TEMPLATE ("src",
  56     GST_PAD_SRC,
  57     GST_PAD_ALWAYS,
  58     GST_STATIC_CAPS (GST_VIDEO_CAPS_BGRx "; " GST_VIDEO_CAPS_RGBx)
  59     );
  60
  61 static GstStaticPadTemplate gst_quarktv_sink_template =
  62     GST_STATIC_PAD_TEMPLATE ("sink",
  63     GST_PAD_SINK,
  64     GST_PAD_ALWAYS,
  65     GST_STATIC_CAPS (GST_VIDEO_CAPS_BGRx "; " GST_VIDEO_CAPS_RGBx)
  66     );
  67
  68 static gboolean
  69 gst_quarktv_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
  70     GstCaps * outcaps)
  71 {
  72   GstQuarkTV *filter = GST_QUARKTV (btrans);
  73   GstStructure *structure;
  74   gboolean ret = FALSE;
  75
  76   structure = gst_caps_get_structure (incaps, 0);
  77
  78   if (gst_structure_get_int (structure, "width", &filter->width) &&
  79       gst_structure_get_int (structure, "height", &filter->height)) {
  80     gst_quarktv_planetable_clear (filter);
  81     filter->area = filter->width * filter->height;
  82     ret = TRUE;
  83   }
  84
  85   return ret;
  86 }
  87
  88 static GstFlowReturn
  89 gst_quarktv_transform (GstBaseTransform * trans, GstBuffer * in,
  90     GstBuffer * out)
  91 {
  92   GstQuarkTV *filter = GST_QUARKTV (trans);
  93   gint area;
  94   guint32 *src, *dest;
  95   GstFlowReturn ret = GST_FLOW_OK;
  96
  97   area = filter->area;
  98   src = (guint32 *) GST_BUFFER_DATA (in);
  99   dest = (guint32 *) GST_BUFFER_DATA (out);
 100
 101   if (G_UNLIKELY (filter->planetable == NULL))
 102     return GST_FLOW_WRONG_STATE;
 103
 104   if (filter->planetable[filter->current_plane])
 105     gst_buffer_unref (filter->planetable[filter->current_plane]);
 106
 107   filter->planetable[filter->current_plane] = gst_buffer_ref (in);
 108
 109   /* For each pixel */
 110   while (--area) {
 111     GstBuffer *rand;
 112
 113     /* pick a random buffer */
 114     rand =
 115         filter->planetable[(filter->current_plane +
 116             (fastrand () >> 24)) % filter->planes];
 117
 118     /* Copy the pixel from the random buffer to dest */
 119     dest[area] =
 120         (rand ? ((guint32 *) GST_BUFFER_DATA (rand))[area] : src[area]);
 121   }
 122
 123   filter->current_plane--;
 124   if (filter->current_plane < 0)
 125     filter->current_plane = filter->planes - 1;
 126
 127   return ret;
 128 }
 129
 130 static void
 131 gst_quarktv_planetable_clear (GstQuarkTV * filter)
 132 {
 133   gint i;
 134
 135   if (filter->planetable == NULL)
 136     return;
 137
 138   for (i = 0; i < filter->planes; i++) {
 139     if (GST_IS_BUFFER (filter->planetable[i])) {
 140       gst_buffer_unref (filter->planetable[i]);
 141     }
 142     filter->planetable[i] = NULL;
 143   }
 144 }
 145
 146 static gboolean
 147 gst_quarktv_start (GstBaseTransform * trans)
 148 {
 149   GstQuarkTV *filter = GST_QUARKTV (trans);
 150
 151   if (filter->planetable) {
 152     gst_quarktv_planetable_clear (filter);
 153     g_free (filter->planetable);
 154   }
 155   filter->planetable =
 156       (GstBuffer **) g_malloc0 (filter->planes * sizeof (GstBuffer *));
 157
 158   return TRUE;
 159 }
 160
 161 static void
 162 gst_quarktv_finalize (GObject * object)
 163 {
 164   GstQuarkTV *filter = GST_QUARKTV (object);
 165
 166   if (filter->planetable) {
 167     gst_quarktv_planetable_clear (filter);
 168     g_free (filter->planetable);
 169     filter->planetable = NULL;
 170   }
 171
 172   G_OBJECT_CLASS (parent_class)->finalize (object);
 173 }
 174
 175 static void
 176 gst_quarktv_set_property (GObject * object, guint prop_id, const GValue * value,
 177     GParamSpec * pspec)
 178 {
 179   GstQuarkTV *filter = GST_QUARKTV (object);
 180
 181   switch (prop_id) {
 182     case PROP_PLANES:
 183     {
 184       gint new_n_planes = g_value_get_int (value);
 185       GstBuffer **new_planetable;
 186       gint i;
 187
 188       /* If the number of planes changed, copy across any existing planes */
 189       if (new_n_planes != filter->planes) {
 190         new_planetable =
 191             (GstBuffer **) g_malloc0 (new_n_planes * sizeof (GstBuffer *));
 192
 193         if (filter->planetable) {
 194           for (i = 0; (i < new_n_planes) && (i < filter->planes); i++) {
 195             new_planetable[i] = filter->planetable[i];
 196           }
 197           for (; i < filter->planes; i++) {
 198             if (filter->planetable[i])
 199               gst_buffer_unref (filter->planetable[i]);
 200           }
 201           g_free (filter->planetable);
 202         }
 203
 204         filter->planetable = new_planetable;
 205         filter->planes = new_n_planes;
 206         filter->current_plane = filter->planes - 1;
 207       }
 208       break;
 209     }
 210     default:
 211       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 212       break;
 213   }
 214 }
 215
 216 static void
 217 gst_quarktv_get_property (GObject * object, guint prop_id, GValue * value,
 218     GParamSpec * pspec)
 219 {
 220   GstQuarkTV *filter = GST_QUARKTV (object);
 221
 222   switch (prop_id) {
 223     case PROP_PLANES:
 224       g_value_set_int (value, filter->planes);
 225       break;
 226     default:
 227       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 228       break;
 229   }
 230 }
 231
 232 static void
 233 gst_quarktv_base_init (gpointer g_class)
 234 {
 235   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 236
 237   gst_element_class_set_details_simple (element_class, "QuarkTV effect",
 238       "Filter/Effect/Video",
 239       "Motion dissolver", "FUKUCHI, Kentarou <fukuchi@users.sourceforge.net>");
 240
 241   gst_element_class_add_pad_template (element_class,
 242       gst_static_pad_template_get (&gst_quarktv_sink_template));
 243   gst_element_class_add_pad_template (element_class,
 244       gst_static_pad_template_get (&gst_quarktv_src_template));
 245 }
 246
 247 static void
 248 gst_quarktv_class_init (GstQuarkTVClass * klass)
 249 {
 250   GObjectClass *gobject_class = (GObjectClass *) klass;
 251   GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
 252
 253   gobject_class->set_property = gst_quarktv_set_property;
 254   gobject_class->get_property = gst_quarktv_get_property;
 255
 256   gobject_class->finalize = gst_quarktv_finalize;
 257
 258   g_object_class_install_property (gobject_class, PROP_PLANES,
 259       g_param_spec_int ("planes", "Planes",
 260           "Number of planes", 0, 64, PLANES,
 261           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 262
 263   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_quarktv_set_caps);
 264   trans_class->transform = GST_DEBUG_FUNCPTR (gst_quarktv_transform);
 265   trans_class->start = GST_DEBUG_FUNCPTR (gst_quarktv_start);
 266 }
 267
 268 static void
 269 gst_quarktv_init (GstQuarkTV * filter, GstQuarkTVClass * klass)
 270 {
 271   filter->planes = PLANES;
 272   filter->current_plane = filter->planes - 1;
 273 }