gst/effectv/gstdice.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  * dice.c: a 'dicing' effect
   6  *  copyright (c) 2001 Sam Mertens.  This code is subject to the provisions of
   7  *  the GNU Library Public License.
   8  *
   9  * I suppose this looks similar to PuzzleTV, but it's not. The screen is
  10  * divided into small squares, each of which is rotated either 0, 90, 180 or
  11  * 270 degrees.  The amount of rotation for each square is chosen at random.
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Library General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Library General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Library General Public
  24  * License along with this library; if not, write to the
  25  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  26  * Boston, MA 02110-1301, USA.
  27  */
  28
  29 /**
  30  * SECTION:element-dicetv
  31  *
  32  * DiceTV 'dices' the screen up into many small squares, each defaulting
  33  * to a size of 16 pixels by 16 pixels.. Each square is rotated randomly
  34  * in one of four directions: up (no change), down (180 degrees, or
  35  * upside down), right (90 degrees clockwise), or left (90 degrees
  36  * counterclockwise). The direction of each square normally remains
  37  * consistent between each frame.
  38  *
  39  * <refsect2>
  40  * <title>Example launch line</title>
  41  * |[
  42  * gst-launch-1.0 -v videotestsrc ! dicetv ! videoconvert ! autovideosink
  43  * ]| This pipeline shows the effect of dicetv on a test stream.
  44  * </refsect2>
  45  */
  46
  47 #ifdef HAVE_CONFIG_H
  48 #include "config.h"
  49 #endif
  50
  51 #include <string.h>
  52
  53 #include "gstdice.h"
  54 #include "gsteffectv.h"
  55
  56 #define DEFAULT_CUBE_BITS   4
  57 #define MAX_CUBE_BITS       5
  58 #define MIN_CUBE_BITS       0
  59
  60 typedef enum _dice_dir
  61 {
  62   DICE_UP = 0,
  63   DICE_RIGHT = 1,
  64   DICE_DOWN = 2,
  65   DICE_LEFT = 3
  66 } DiceDir;
  67
  68 #define gst_dicetv_parent_class parent_class
  69 G_DEFINE_TYPE (GstDiceTV, gst_dicetv, GST_TYPE_VIDEO_FILTER);
  70
  71 static void gst_dicetv_create_map (GstDiceTV * filter, GstVideoInfo * info);
  72
  73 static GstStaticPadTemplate gst_dicetv_src_template =
  74 GST_STATIC_PAD_TEMPLATE ("src",
  75     GST_PAD_SRC,
  76     GST_PAD_ALWAYS,
  77     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGBx, xRGB, BGRx, xBGR }"))
  78     );
  79
  80 static GstStaticPadTemplate gst_dicetv_sink_template =
  81 GST_STATIC_PAD_TEMPLATE ("sink",
  82     GST_PAD_SINK,
  83     GST_PAD_ALWAYS,
  84     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGBx, xRGB, BGRx, xBGR }"))
  85     );
  86
  87 enum
  88 {
  89   PROP_0,
  90   PROP_CUBE_BITS
  91 };
  92
  93 static gboolean
  94 gst_dicetv_set_info (GstVideoFilter * vfilter, GstCaps * incaps,
  95     GstVideoInfo * in_info, GstCaps * outcaps, GstVideoInfo * out_info)
  96 {
  97   GstDiceTV *filter = GST_DICETV (vfilter);
  98
  99   g_free (filter->dicemap);
 100   filter->dicemap =
 101       (guint8 *) g_malloc (GST_VIDEO_INFO_WIDTH (in_info) *
 102       GST_VIDEO_INFO_WIDTH (in_info));
 103   gst_dicetv_create_map (filter, in_info);
 104
 105   return TRUE;
 106 }
 107
 108 static GstFlowReturn
 109 gst_dicetv_transform_frame (GstVideoFilter * vfilter, GstVideoFrame * in_frame,
 110     GstVideoFrame * out_frame)
 111 {
 112   GstDiceTV *filter = GST_DICETV (vfilter);
 113   guint32 *src, *dest;
 114   gint i, map_x, map_y, map_i, base, dx, dy, di;
 115   gint video_stride, g_cube_bits, g_cube_size;
 116   gint g_map_height, g_map_width;
 117   GstClockTime timestamp, stream_time;
 118   const guint8 *dicemap;
 119
 120   timestamp = GST_BUFFER_TIMESTAMP (in_frame->buffer);
 121   stream_time =
 122       gst_segment_to_stream_time (&GST_BASE_TRANSFORM (vfilter)->segment,
 123       GST_FORMAT_TIME, timestamp);
 124
 125   GST_DEBUG_OBJECT (filter, "sync to %" GST_TIME_FORMAT,
 126       GST_TIME_ARGS (timestamp));
 127
 128   if (GST_CLOCK_TIME_IS_VALID (stream_time))
 129     gst_object_sync_values (GST_OBJECT (filter), stream_time);
 130
 131   src = (guint32 *) GST_VIDEO_FRAME_PLANE_DATA (in_frame, 0);
 132   dest = (guint32 *) GST_VIDEO_FRAME_PLANE_DATA (out_frame, 0);
 133   video_stride = GST_VIDEO_FRAME_PLANE_STRIDE (in_frame, 0);
 134
 135   GST_OBJECT_LOCK (filter);
 136   g_cube_bits = filter->g_cube_bits;
 137   g_cube_size = filter->g_cube_size;
 138   g_map_height = filter->g_map_height;
 139   g_map_width = filter->g_map_width;
 140
 141   dicemap = filter->dicemap;
 142   video_stride /= 4;
 143
 144   map_i = 0;
 145   for (map_y = 0; map_y < g_map_height; map_y++) {
 146     for (map_x = 0; map_x < g_map_width; map_x++) {
 147       base = (map_y << g_cube_bits) * video_stride + (map_x << g_cube_bits);
 148
 149       switch (dicemap[map_i]) {
 150         case DICE_UP:
 151           for (dy = 0; dy < g_cube_size; dy++) {
 152             i = base + dy * video_stride;
 153             for (dx = 0; dx < g_cube_size; dx++) {
 154               dest[i] = src[i];
 155               i++;
 156             }
 157           }
 158           break;
 159         case DICE_LEFT:
 160           for (dy = 0; dy < g_cube_size; dy++) {
 161             i = base + dy * video_stride;
 162
 163             for (dx = 0; dx < g_cube_size; dx++) {
 164               di = base + (dx * video_stride) + (g_cube_size - dy - 1);
 165               dest[di] = src[i];
 166               i++;
 167             }
 168           }
 169           break;
 170         case DICE_DOWN:
 171           for (dy = 0; dy < g_cube_size; dy++) {
 172             di = base + dy * video_stride;
 173             i = base + (g_cube_size - dy - 1) * video_stride + g_cube_size;
 174             for (dx = 0; dx < g_cube_size; dx++) {
 175               i--;
 176               dest[di] = src[i];
 177               di++;
 178             }
 179           }
 180           break;
 181         case DICE_RIGHT:
 182           for (dy = 0; dy < g_cube_size; dy++) {
 183             i = base + (dy * video_stride);
 184             for (dx = 0; dx < g_cube_size; dx++) {
 185               di = base + dy + (g_cube_size - dx - 1) * video_stride;
 186               dest[di] = src[i];
 187               i++;
 188             }
 189           }
 190           break;
 191         default:
 192           g_assert_not_reached ();
 193           break;
 194       }
 195       map_i++;
 196     }
 197   }
 198   GST_OBJECT_UNLOCK (filter);
 199
 200   return GST_FLOW_OK;
 201 }
 202
 203 static void
 204 gst_dicetv_create_map (GstDiceTV * filter, GstVideoInfo * info)
 205 {
 206   gint x, y, i;
 207   gint width, height;
 208
 209   width = GST_VIDEO_INFO_WIDTH (info);
 210   height = GST_VIDEO_INFO_HEIGHT (info);
 211
 212   if (width <= 0 || height <= 0)
 213     return;
 214
 215   filter->g_map_height = height >> filter->g_cube_bits;
 216   filter->g_map_width = width >> filter->g_cube_bits;
 217   filter->g_cube_size = 1 << filter->g_cube_bits;
 218
 219   i = 0;
 220
 221   for (y = 0; y < filter->g_map_height; y++) {
 222     for (x = 0; x < filter->g_map_width; x++) {
 223       // dicemap[i] = ((i + y) & 0x3); /* Up, Down, Left or Right */
 224       filter->dicemap[i] = (fastrand () >> 24) & 0x03;
 225       i++;
 226     }
 227   }
 228 }
 229
 230 static void
 231 gst_dicetv_set_property (GObject * object, guint prop_id, const GValue * value,
 232     GParamSpec * pspec)
 233 {
 234   GstDiceTV *filter = GST_DICETV (object);
 235
 236   switch (prop_id) {
 237     case PROP_CUBE_BITS:
 238       GST_OBJECT_LOCK (filter);
 239       filter->g_cube_bits = g_value_get_int (value);
 240       gst_dicetv_create_map (filter, &GST_VIDEO_FILTER (filter)->in_info);
 241       GST_OBJECT_UNLOCK (filter);
 242       break;
 243     default:
 244       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 245       break;
 246   }
 247 }
 248
 249 static void
 250 gst_dicetv_get_property (GObject * object, guint prop_id, GValue * value,
 251     GParamSpec * pspec)
 252 {
 253   GstDiceTV *filter = GST_DICETV (object);
 254
 255   switch (prop_id) {
 256     case PROP_CUBE_BITS:
 257       g_value_set_int (value, filter->g_cube_bits);
 258       break;
 259     default:
 260       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 261       break;
 262   }
 263 }
 264
 265 static void
 266 gst_dicetv_finalize (GObject * object)
 267 {
 268   GstDiceTV *filter = GST_DICETV (object);
 269
 270   g_free (filter->dicemap);
 271   filter->dicemap = NULL;
 272
 273   G_OBJECT_CLASS (parent_class)->finalize (object);
 274 }
 275
 276 static void
 277 gst_dicetv_class_init (GstDiceTVClass * klass)
 278 {
 279   GObjectClass *gobject_class = (GObjectClass *) klass;
 280   GstElementClass *gstelement_class = (GstElementClass *) klass;
 281   GstVideoFilterClass *vfilter_class = (GstVideoFilterClass *) klass;
 282
 283   gobject_class->set_property = gst_dicetv_set_property;
 284   gobject_class->get_property = gst_dicetv_get_property;
 285   gobject_class->finalize = gst_dicetv_finalize;
 286
 287   g_object_class_install_property (gobject_class, PROP_CUBE_BITS,
 288       g_param_spec_int ("square-bits", "Square Bits", "The size of the Squares",
 289           MIN_CUBE_BITS, MAX_CUBE_BITS, DEFAULT_CUBE_BITS,
 290           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_CONTROLLABLE));
 291
 292   gst_element_class_set_static_metadata (gstelement_class, "DiceTV effect",
 293       "Filter/Effect/Video",
 294       "'Dices' the screen up into many small squares",
 295       "Wim Taymans <wim.taymans@gmail.be>");
 296
 297   gst_element_class_add_static_pad_template (gstelement_class,
 298       &gst_dicetv_sink_template);
 299   gst_element_class_add_static_pad_template (gstelement_class,
 300       &gst_dicetv_src_template);
 301
 302   vfilter_class->set_info = GST_DEBUG_FUNCPTR (gst_dicetv_set_info);
 303   vfilter_class->transform_frame =
 304       GST_DEBUG_FUNCPTR (gst_dicetv_transform_frame);
 305 }
 306
 307 static void
 308 gst_dicetv_init (GstDiceTV * filter)
 309 {
 310   filter->dicemap = NULL;
 311   filter->g_cube_bits = DEFAULT_CUBE_BITS;
 312   filter->g_cube_size = 0;
 313   filter->g_map_height = 0;
 314   filter->g_map_width = 0;
 315 }