gst/effectv/gstvertigo.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * EffecTV:
   5  * Copyright (C) 2001 FUKUCHI Kentarou
   6  *
   7  * EffecTV is free software. This library is free software;
   8  * you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /**
  25  * SECTION:element-vertigotv
  26  *
  27  * VertigoTV is a loopback alpha blending effector with rotating and scaling.
  28  *
  29  * <refsect2>
  30  * <title>Example launch line</title>
  31  * |[
  32  * gst-launch -v videotestsrc ! vertigotv ! videoconvert ! autovideosink
  33  * ]| This pipeline shows the effect of vertigotv on a test stream.
  34  * </refsect2>
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include <math.h>
  42 #include <string.h>
  43
  44 #include "gstvertigo.h"
  45
  46 #include <gst/controller/gstcontroller.h>
  47
  48 #define gst_vertigotv_parent_class parent_class
  49 G_DEFINE_TYPE (GstVertigoTV, gst_vertigotv, GST_TYPE_VIDEO_FILTER);
  50
  51 /* Filter signals and args */
  52 enum
  53 {
  54   PROP_0,
  55   PROP_SPEED,
  56   PROP_ZOOM_SPEED
  57 };
  58
  59 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
  60 #define CAPS_STR GST_VIDEO_CAPS_MAKE ("{ RGBx, BGRx }")
  61 #else
  62 #define CAPS_STR GST_VIDEO_CAPS_MAKE ("{ xRGB, xBGR }")
  63 #endif
  64
  65 static GstStaticPadTemplate gst_vertigotv_src_template =
  66 GST_STATIC_PAD_TEMPLATE ("src",
  67     GST_PAD_SRC,
  68     GST_PAD_ALWAYS,
  69     GST_STATIC_CAPS (CAPS_STR)
  70     );
  71
  72 static GstStaticPadTemplate gst_vertigotv_sink_template =
  73 GST_STATIC_PAD_TEMPLATE ("sink",
  74     GST_PAD_SINK,
  75     GST_PAD_ALWAYS,
  76     GST_STATIC_CAPS (CAPS_STR)
  77     );
  78
  79 static gboolean
  80 gst_vertigotv_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
  81     GstCaps * outcaps)
  82 {
  83   GstVertigoTV *filter = GST_VERTIGOTV (btrans);
  84   GstVideoInfo info;
  85   gint area, width, height;
  86
  87   if (!gst_video_info_from_caps (&info, incaps))
  88     goto invalid_caps;
  89
  90   filter->info = info;
  91
  92   width = GST_VIDEO_INFO_WIDTH (&info);
  93   height = GST_VIDEO_INFO_HEIGHT (&info);
  94
  95   area = width * height;
  96
  97   g_free (filter->buffer);
  98   filter->buffer = (guint32 *) g_malloc0 (area * 2 * sizeof (guint32));
  99
 100   filter->current_buffer = filter->buffer;
 101   filter->alt_buffer = filter->buffer + area;
 102   filter->phase = 0;
 103
 104   return TRUE;
 105
 106   /* ERRORS */
 107 invalid_caps:
 108   {
 109     GST_DEBUG_OBJECT (filter, "invalid caps received");
 110     return FALSE;
 111   }
 112 }
 113
 114 static void
 115 gst_vertigotv_set_parms (GstVertigoTV * filter)
 116 {
 117   double vx, vy;
 118   double t;
 119   double x, y;
 120   double dizz;
 121   gint width, height;
 122
 123   dizz = sin (filter->phase) * 10 + sin (filter->phase * 1.9 + 5) * 5;
 124
 125   width = GST_VIDEO_INFO_WIDTH (&filter->info);
 126   height = GST_VIDEO_INFO_HEIGHT (&filter->info);
 127
 128   x = width / 2;
 129   y = height / 2;
 130
 131   t = (x * x + y * y) * filter->zoomrate;
 132
 133   if (width > height) {
 134     if (dizz >= 0) {
 135       if (dizz > x)
 136         dizz = x;
 137       vx = (x * (x - dizz) + y * y) / t;
 138     } else {
 139       if (dizz < -x)
 140         dizz = -x;
 141       vx = (x * (x + dizz) + y * y) / t;
 142     }
 143     vy = (dizz * y) / t;
 144   } else {
 145     if (dizz >= 0) {
 146       if (dizz > y)
 147         dizz = y;
 148       vx = (x * x + y * (y - dizz)) / t;
 149     } else {
 150       if (dizz < -y)
 151         dizz = -y;
 152       vx = (x * x + y * (y + dizz)) / t;
 153     }
 154     vy = (dizz * x) / t;
 155   }
 156   filter->dx = vx * 65536;
 157   filter->dy = vy * 65536;
 158   filter->sx = (-vx * x + vy * y + x + cos (filter->phase * 5) * 2) * 65536;
 159   filter->sy = (-vx * y - vy * x + y + sin (filter->phase * 6) * 2) * 65536;
 160
 161   filter->phase += filter->phase_increment;
 162   if (filter->phase > 5700000)
 163     filter->phase = 0;
 164 }
 165
 166 static GstFlowReturn
 167 gst_vertigotv_transform (GstBaseTransform * trans, GstBuffer * in,
 168     GstBuffer * out)
 169 {
 170   GstVertigoTV *filter = GST_VERTIGOTV (trans);
 171   guint32 *src, *dest, *p;
 172   guint32 v;
 173   gint x, y, ox, oy, i, width, height, area;
 174   GstClockTime timestamp, stream_time;
 175   GstVideoFrame in_frame, out_frame;
 176
 177   timestamp = GST_BUFFER_TIMESTAMP (in);
 178   stream_time =
 179       gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME, timestamp);
 180
 181   GST_DEBUG_OBJECT (filter, "sync to %" GST_TIME_FORMAT,
 182       GST_TIME_ARGS (timestamp));
 183
 184   if (GST_CLOCK_TIME_IS_VALID (stream_time))
 185     gst_object_sync_values (G_OBJECT (filter), stream_time);
 186
 187   if (!gst_video_frame_map (&in_frame, &filter->info, in, GST_MAP_READ))
 188     goto invalid_in;
 189
 190   if (!gst_video_frame_map (&out_frame, &filter->info, out, GST_MAP_WRITE))
 191     goto invalid_out;
 192
 193   src = GST_VIDEO_FRAME_PLANE_DATA (&in_frame, 0);
 194   dest = GST_VIDEO_FRAME_PLANE_DATA (&in_frame, 0);
 195
 196   width = GST_VIDEO_FRAME_WIDTH (&in_frame);
 197   height = GST_VIDEO_FRAME_HEIGHT (&in_frame);
 198
 199   area = width * height;
 200
 201   gst_vertigotv_set_parms (filter);
 202   p = filter->alt_buffer;
 203
 204   for (y = height; y > 0; y--) {
 205     ox = filter->sx;
 206     oy = filter->sy;
 207
 208     for (x = width; x > 0; x--) {
 209       i = (oy >> 16) * width + (ox >> 16);
 210       if (i < 0)
 211         i = 0;
 212       if (i >= area)
 213         i = area;
 214
 215       v = filter->current_buffer[i] & 0xfcfcff;
 216       v = (v * 3) + ((*src++) & 0xfcfcff);
 217
 218       *p++ = (v >> 2);
 219       ox += filter->dx;
 220       oy += filter->dy;
 221     }
 222     filter->sx -= filter->dy;
 223     filter->sy += filter->dx;
 224   }
 225
 226   memcpy (dest, filter->alt_buffer, area * sizeof (guint32));
 227
 228   p = filter->current_buffer;
 229   filter->current_buffer = filter->alt_buffer;
 230   filter->alt_buffer = p;
 231
 232   return GST_FLOW_OK;
 233
 234   /* ERRORS */
 235 invalid_in:
 236   {
 237     GST_DEBUG_OBJECT (filter, "invalid input frame");
 238     return GST_FLOW_ERROR;
 239   }
 240 invalid_out:
 241   {
 242     GST_DEBUG_OBJECT (filter, "invalid output frame");
 243     gst_video_frame_unmap (&in_frame);
 244     return GST_FLOW_ERROR;
 245   }
 246
 247 }
 248
 249 static gboolean
 250 gst_vertigotv_start (GstBaseTransform * trans)
 251 {
 252   GstVertigoTV *filter = GST_VERTIGOTV (trans);
 253
 254   filter->phase = 0.0;
 255
 256   return TRUE;
 257 }
 258
 259 static void
 260 gst_vertigotv_set_property (GObject * object, guint prop_id,
 261     const GValue * value, GParamSpec * pspec)
 262 {
 263   GstVertigoTV *filter = GST_VERTIGOTV (object);
 264
 265   GST_OBJECT_LOCK (filter);
 266   switch (prop_id) {
 267     case PROP_SPEED:
 268       filter->phase_increment = g_value_get_float (value);
 269       break;
 270     case PROP_ZOOM_SPEED:
 271       filter->zoomrate = g_value_get_float (value);
 272       break;
 273     default:
 274       break;
 275   }
 276   GST_OBJECT_UNLOCK (filter);
 277 }
 278
 279 static void
 280 gst_vertigotv_get_property (GObject * object, guint prop_id, GValue * value,
 281     GParamSpec * pspec)
 282 {
 283   GstVertigoTV *filter = GST_VERTIGOTV (object);
 284
 285   switch (prop_id) {
 286     case PROP_SPEED:
 287       g_value_set_float (value, filter->phase_increment);
 288       break;
 289     case PROP_ZOOM_SPEED:
 290       g_value_set_float (value, filter->zoomrate);
 291       break;
 292     default:
 293       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 294       break;
 295   }
 296 }
 297
 298 static void
 299 gst_vertigotv_finalize (GObject * object)
 300 {
 301   GstVertigoTV *filter = GST_VERTIGOTV (object);
 302
 303   g_free (filter->buffer);
 304   filter->buffer = NULL;
 305
 306   G_OBJECT_CLASS (parent_class)->finalize (object);
 307 }
 308
 309 static void
 310 gst_vertigotv_class_init (GstVertigoTVClass * klass)
 311 {
 312   GObjectClass *gobject_class = (GObjectClass *) klass;
 313   GstElementClass *gstelement_class = (GstElementClass *) klass;
 314   GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
 315
 316   gobject_class->set_property = gst_vertigotv_set_property;
 317   gobject_class->get_property = gst_vertigotv_get_property;
 318   gobject_class->finalize = gst_vertigotv_finalize;
 319
 320   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SPEED,
 321       g_param_spec_float ("speed", "Speed", "Control the speed of movement",
 322           0.01, 100.0, 0.02, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 323   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ZOOM_SPEED,
 324       g_param_spec_float ("zoom-speed", "Zoom Speed",
 325           "Control the rate of zooming", 1.01, 1.1, 1.01,
 326           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 327
 328   gst_element_class_set_details_simple (gstelement_class, "VertigoTV effect",
 329       "Filter/Effect/Video",
 330       "A loopback alpha blending effector with rotating and scaling",
 331       "Wim Taymans <wim.taymans@gmail.be>");
 332
 333   gst_element_class_add_pad_template (gstelement_class,
 334       gst_static_pad_template_get (&gst_vertigotv_sink_template));
 335   gst_element_class_add_pad_template (gstelement_class,
 336       gst_static_pad_template_get (&gst_vertigotv_src_template));
 337
 338   trans_class->start = GST_DEBUG_FUNCPTR (gst_vertigotv_start);
 339   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_vertigotv_set_caps);
 340   trans_class->transform = GST_DEBUG_FUNCPTR (gst_vertigotv_transform);
 341 }
 342
 343 static void
 344 gst_vertigotv_init (GstVertigoTV * filter)
 345 {
 346   filter->buffer = NULL;
 347   filter->phase = 0.0;
 348   filter->phase_increment = 0.02;
 349   filter->zoomrate = 1.01;
 350
 351   gst_pad_use_fixed_caps (GST_BASE_TRANSFORM_SRC_PAD (filter));
 352   gst_pad_use_fixed_caps (GST_BASE_TRANSFORM_SINK_PAD (filter));
 353 }