gst/effectv/gstradioac.c

   1 /* GStreamer
   2  * Cradioacyright (C) <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
   3  *
   4  * EffecTV - Realtime Digital Video Effector
   5  * Cradioacyright (C) 2001-2006 FUKUCHI Kentaro
   6  *
   7  * RadioacTV - motion-enlightment effect.
   8  * Cradioacyright (C) 2001-2002 FUKUCHI Kentaro
   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 radioaction) any later version.
  15  *
  16  * This library is distributed in the hradioace 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 cradioacy 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 /**
  28  * SECTION:element-radioactv
  29  *
  30  * RadioacTV does *NOT* detect a radioactivity. It detects a difference
  31  * from previous frame and blurs it.
  32  *
  33  * RadioacTV has 4 mode, normal, strobe1, strobe2 and trigger.
  34  * In trigger mode, effect appears only when the trigger property is %TRUE.
  35  *
  36  * strobe1 and strobe2 mode drops some frames. strobe1 mode uses the difference between
  37  * current frame and previous frame dropped, while strobe2 mode uses the difference from
  38  * previous frame displayed. The effect of strobe2 is stronger than strobe1.
  39  *
  40  * <refsect2>
  41  * <title>Example launch line</title>
  42  * |[
  43  * gst-launch -v videotestsrc ! radioactv ! ffmpegcolorspace ! autovideosink
  44  * ]| This pipeline shows the effect of radioactv on a test stream.
  45  * </refsect2>
  46  */
  47
  48 #ifdef HAVE_CONFIG_H
  49 #include "config.h"
  50 #endif
  51
  52 #include <math.h>
  53 #include <string.h>
  54
  55 #include "gstradioac.h"
  56 #include "gsteffectv.h"
  57
  58 #include <gst/video/video.h>
  59 #include <gst/controller/gstcontroller.h>
  60
  61 enum
  62 {
  63   RADIOAC_NORMAL = 0,
  64   RADIOAC_STROBE,
  65   RADIOAC_STROBE2,
  66   RADIOAC_TRIGGER
  67 };
  68
  69 enum
  70 {
  71   COLOR_RED = 0,
  72   COLOR_GREEN,
  73   COLOR_BLUE,
  74   COLOR_WHITE
  75 };
  76
  77 #define GST_TYPE_RADIOACTV_MODE (gst_radioactv_mode_get_type())
  78 static GType
  79 gst_radioactv_mode_get_type (void)
  80 {
  81   static GType type = 0;
  82
  83   static const GEnumValue enumvalue[] = {
  84     {RADIOAC_NORMAL, "Normal", "normal"},
  85     {RADIOAC_STROBE, "Strobe 1", "strobe1"},
  86     {RADIOAC_STROBE2, "Strobe 2", "strobe2"},
  87     {RADIOAC_TRIGGER, "Trigger", "trigger"},
  88     {0, NULL, NULL},
  89   };
  90
  91   if (!type) {
  92     type = g_enum_register_static ("GstRadioacTVMode", enumvalue);
  93   }
  94   return type;
  95 }
  96
  97 #define GST_TYPE_RADIOACTV_COLOR (gst_radioactv_color_get_type())
  98 static GType
  99 gst_radioactv_color_get_type (void)
 100 {
 101   static GType type = 0;
 102
 103   static const GEnumValue enumvalue[] = {
 104     {COLOR_RED, "Red", "red"},
 105     {COLOR_GREEN, "Green", "green"},
 106     {COLOR_BLUE, "Blue", "blue"},
 107     {COLOR_WHITE, "White", "white"},
 108     {0, NULL, NULL},
 109   };
 110
 111   if (!type) {
 112     type = g_enum_register_static ("GstRadioacTVColor", enumvalue);
 113   }
 114   return type;
 115 }
 116
 117 #define DEFAULT_MODE RADIOAC_NORMAL
 118 #define DEFAULT_COLOR COLOR_WHITE
 119 #define DEFAULT_INTERVAL 3
 120 #define DEFAULT_TRIGGER FALSE
 121
 122 enum
 123 {
 124   PROP_0,
 125   PROP_MODE,
 126   PROP_COLOR,
 127   PROP_INTERVAL,
 128   PROP_TRIGGER
 129 };
 130
 131 #define COLORS 32
 132 #define PATTERN 4
 133 #define MAGIC_THRESHOLD 40
 134 #define RATIO 0.95
 135
 136 static guint32 palettes[COLORS * PATTERN];
 137
 138 GST_BOILERPLATE (GstRadioacTV, gst_radioactv, GstVideoFilter,
 139     GST_TYPE_VIDEO_FILTER);
 140
 141 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
 142 #define CAPS_STR GST_VIDEO_CAPS_RGBx
 143 #else
 144 #define CAPS_STR GST_VIDEO_CAPS_xBGR
 145 #endif
 146
 147 static GstStaticPadTemplate gst_radioactv_src_template =
 148 GST_STATIC_PAD_TEMPLATE ("src",
 149     GST_PAD_SRC,
 150     GST_PAD_ALWAYS,
 151     GST_STATIC_CAPS (CAPS_STR)
 152     );
 153
 154 static GstStaticPadTemplate gst_radioactv_sink_template =
 155 GST_STATIC_PAD_TEMPLATE ("sink",
 156     GST_PAD_SINK,
 157     GST_PAD_ALWAYS,
 158     GST_STATIC_CAPS (CAPS_STR)
 159     );
 160
 161 static void
 162 makePalette (void)
 163 {
 164   gint i;
 165
 166 #define DELTA (255/(COLORS/2-1))
 167
 168   for (i = 0; i < COLORS / 2; i++) {
 169     palettes[i] = i * DELTA;
 170     palettes[COLORS + i] = (i * DELTA) << 8;
 171     palettes[COLORS * 2 + i] = (i * DELTA) << 16;
 172   }
 173   for (i = 0; i < COLORS / 2; i++) {
 174     palettes[+i + COLORS / 2] = 255 | (i * DELTA) << 16 | (i * DELTA) << 8;
 175     palettes[COLORS + i + COLORS / 2] =
 176         (255 << 8) | (i * DELTA) << 16 | i * DELTA;
 177     palettes[COLORS * 2 + i + COLORS / 2] =
 178         (255 << 16) | (i * DELTA) << 8 | i * DELTA;
 179   }
 180   for (i = 0; i < COLORS; i++) {
 181     palettes[COLORS * 3 + i] = (255 * i / COLORS) * 0x10101;
 182   }
 183   for (i = 0; i < COLORS * PATTERN; i++) {
 184     palettes[i] = palettes[i] & 0xfefeff;
 185   }
 186 #undef DELTA
 187 }
 188
 189 #define VIDEO_HWIDTH (filter->buf_width/2)
 190 #define VIDEO_HHEIGHT (filter->buf_height/2)
 191
 192 /* this table assumes that video_width is times of 32 */
 193 static void
 194 setTable (GstRadioacTV * filter)
 195 {
 196   guint bits;
 197   gint x, y, tx, ty, xx;
 198   gint ptr, prevptr;
 199
 200   prevptr = (gint) (0.5 + RATIO * (-VIDEO_HWIDTH) + VIDEO_HWIDTH);
 201   for (xx = 0; xx < (filter->buf_width_blocks); xx++) {
 202     bits = 0;
 203     for (x = 0; x < 32; x++) {
 204       ptr = (gint) (0.5 + RATIO * (xx * 32 + x - VIDEO_HWIDTH) + VIDEO_HWIDTH);
 205       bits = bits >> 1;
 206       if (ptr != prevptr)
 207         bits |= 0x80000000;
 208       prevptr = ptr;
 209     }
 210     filter->blurzoomx[xx] = bits;
 211   }
 212
 213   ty = (gint) (0.5 + RATIO * (-VIDEO_HHEIGHT) + VIDEO_HHEIGHT);
 214   tx = (gint) (0.5 + RATIO * (-VIDEO_HWIDTH) + VIDEO_HWIDTH);
 215   xx = (gint) (0.5 + RATIO * (filter->buf_width - 1 - VIDEO_HWIDTH) +
 216       VIDEO_HWIDTH);
 217   filter->blurzoomy[0] = ty * filter->buf_width + tx;
 218   prevptr = ty * filter->buf_width + xx;
 219   for (y = 1; y < filter->buf_height; y++) {
 220     ty = (gint) (0.5 + RATIO * (y - VIDEO_HHEIGHT) + VIDEO_HHEIGHT);
 221     filter->blurzoomy[y] = ty * filter->buf_width + tx - prevptr;
 222     prevptr = ty * filter->buf_width + xx;
 223   }
 224 }
 225
 226 #undef VIDEO_HWIDTH
 227 #undef VIDEO_HHEIGHT
 228
 229 static void
 230 blur (GstRadioacTV * filter)
 231 {
 232   gint x, y;
 233   gint width;
 234   guint8 *p, *q;
 235   guint8 v;
 236
 237   width = filter->buf_width;
 238   p = filter->blurzoombuf + filter->width + 1;
 239   q = p + filter->buf_area;
 240
 241   for (y = filter->buf_height - 2; y > 0; y--) {
 242     for (x = width - 2; x > 0; x--) {
 243       v = (*(p - width) + *(p - 1) + *(p + 1) + *(p + width)) / 4 - 1;
 244       if (v == 255)
 245         v = 0;
 246       *q = v;
 247       p++;
 248       q++;
 249     }
 250     p += 2;
 251     q += 2;
 252   }
 253 }
 254
 255 static void
 256 zoom (GstRadioacTV * filter)
 257 {
 258   gint b, x, y;
 259   guint8 *p, *q;
 260   gint blocks, height;
 261   gint dx;
 262
 263   p = filter->blurzoombuf + filter->buf_area;
 264   q = filter->blurzoombuf;
 265   height = filter->buf_height;
 266   blocks = filter->buf_width_blocks;
 267
 268   for (y = 0; y < height; y++) {
 269     p += filter->blurzoomy[y];
 270     for (b = 0; b < blocks; b++) {
 271       dx = filter->blurzoomx[b];
 272       for (x = 0; x < 32; x++) {
 273         p += (dx & 1);
 274         *q++ = *p;
 275         dx = dx >> 1;
 276       }
 277     }
 278   }
 279 }
 280
 281 static void
 282 blurzoomcore (GstRadioacTV * filter)
 283 {
 284   blur (filter);
 285   zoom (filter);
 286 }
 287
 288 /* Background image is refreshed every frame */
 289 static void
 290 image_bgsubtract_update_y (guint32 * src, gint16 * background, guint8 * diff,
 291     gint video_area, gint y_threshold)
 292 {
 293   gint i;
 294   gint R, G, B;
 295   guint32 *p;
 296   gint16 *q;
 297   guint8 *r;
 298   gint v;
 299
 300   p = src;
 301   q = background;
 302   r = diff;
 303   for (i = 0; i < video_area; i++) {
 304     R = ((*p) & 0xff0000) >> (16 - 1);
 305     G = ((*p) & 0xff00) >> (8 - 2);
 306     B = (*p) & 0xff;
 307     v = (R + G + B) - (gint) (*q);
 308     *q = (gint16) (R + G + B);
 309     *r = ((v + y_threshold) >> 24) | ((y_threshold - v) >> 24);
 310
 311     p++;
 312     q++;
 313     r++;
 314   }
 315 }
 316
 317 static GstFlowReturn
 318 gst_radioactv_transform (GstBaseTransform * trans, GstBuffer * in,
 319     GstBuffer * out)
 320 {
 321   GstRadioacTV *filter = GST_RADIOACTV (trans);
 322   guint32 *src, *dest;
 323   GstFlowReturn ret = GST_FLOW_OK;
 324   GstClockTime timestamp, stream_time;
 325   gint x, y;
 326   guint32 a, b;
 327   guint8 *diff, *p;
 328   guint32 *palette;
 329
 330   timestamp = GST_BUFFER_TIMESTAMP (in);
 331   stream_time =
 332       gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME, timestamp);
 333
 334   GST_DEBUG_OBJECT (filter, "sync to %" GST_TIME_FORMAT,
 335       GST_TIME_ARGS (timestamp));
 336
 337   if (GST_CLOCK_TIME_IS_VALID (stream_time))
 338     gst_object_sync_values (G_OBJECT (filter), stream_time);
 339
 340   src = (guint32 *) GST_BUFFER_DATA (in);
 341   dest = (guint32 *) GST_BUFFER_DATA (out);
 342
 343   GST_OBJECT_LOCK (filter);
 344   palette = &palettes[COLORS * filter->color];
 345   diff = filter->diff;
 346
 347   if (filter->mode == 3 && filter->trigger)
 348     filter->snaptime = 0;
 349   else if (filter->mode == 3 && !filter->trigger)
 350     filter->snaptime = 1;
 351
 352   if (filter->mode != 2 || filter->snaptime <= 0) {
 353     image_bgsubtract_update_y (src, filter->background, diff,
 354         filter->width * filter->height, MAGIC_THRESHOLD * 7);
 355     if (filter->mode == 0 || filter->snaptime <= 0) {
 356       diff += filter->buf_margin_left;
 357       p = filter->blurzoombuf;
 358       for (y = 0; y < filter->buf_height; y++) {
 359         for (x = 0; x < filter->buf_width; x++) {
 360           p[x] |= diff[x] >> 3;
 361         }
 362         diff += filter->width;
 363         p += filter->buf_width;
 364       }
 365       if (filter->mode == 1 || filter->mode == 2) {
 366         memcpy (filter->snapframe, src, filter->width * filter->height * 4);
 367       }
 368     }
 369   }
 370   blurzoomcore (filter);
 371
 372   if (filter->mode == 1 || filter->mode == 2) {
 373     src = filter->snapframe;
 374   }
 375   p = filter->blurzoombuf;
 376   for (y = 0; y < filter->height; y++) {
 377     for (x = 0; x < filter->buf_margin_left; x++) {
 378       *dest++ = *src++;
 379     }
 380     for (x = 0; x < filter->buf_width; x++) {
 381       a = *src++ & 0xfefeff;
 382       b = palette[*p++];
 383       a += b;
 384       b = a & 0x1010100;
 385       *dest++ = a | (b - (b >> 8));
 386     }
 387     for (x = 0; x < filter->buf_margin_right; x++) {
 388       *dest++ = *src++;
 389     }
 390   }
 391
 392   if (filter->mode == 1 || filter->mode == 2) {
 393     filter->snaptime--;
 394     if (filter->snaptime < 0) {
 395       filter->snaptime = filter->interval;
 396     }
 397   }
 398   GST_OBJECT_UNLOCK (filter);
 399
 400   return ret;
 401 }
 402
 403 static gboolean
 404 gst_radioactv_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
 405     GstCaps * outcaps)
 406 {
 407   GstRadioacTV *filter = GST_RADIOACTV (btrans);
 408   GstStructure *structure;
 409   gboolean ret = FALSE;
 410
 411   structure = gst_caps_get_structure (incaps, 0);
 412
 413   GST_OBJECT_LOCK (filter);
 414   if (gst_structure_get_int (structure, "width", &filter->width) &&
 415       gst_structure_get_int (structure, "height", &filter->height)) {
 416     filter->buf_width_blocks = filter->width / 32;
 417     if (filter->buf_width_blocks > 255)
 418       goto out;
 419
 420     filter->buf_width = filter->buf_width_blocks * 32;
 421     filter->buf_height = filter->height;
 422     filter->buf_area = filter->buf_height * filter->buf_width;
 423     filter->buf_margin_left = (filter->width - filter->buf_width) / 2;
 424     filter->buf_margin_right =
 425         filter->height - filter->buf_width - filter->buf_margin_left;
 426
 427     if (filter->blurzoombuf)
 428       g_free (filter->blurzoombuf);
 429     filter->blurzoombuf = g_new0 (guint8, filter->buf_area * 2);
 430
 431     if (filter->blurzoomx)
 432       g_free (filter->blurzoomx);
 433     filter->blurzoomx = g_new0 (gint, filter->buf_width);
 434
 435     if (filter->blurzoomy)
 436       g_free (filter->blurzoomy);
 437     filter->blurzoomy = g_new0 (gint, filter->buf_height);
 438
 439     if (filter->snapframe)
 440       g_free (filter->snapframe);
 441     filter->snapframe = g_new (guint32, filter->width * filter->height);
 442
 443     if (filter->diff)
 444       g_free (filter->diff);
 445     filter->diff = g_new (guint8, filter->width * filter->height);
 446
 447     if (filter->background)
 448       g_free (filter->background);
 449     filter->background = g_new0 (gint16, filter->width * filter->height);
 450
 451     setTable (filter);
 452
 453     ret = TRUE;
 454   }
 455 out:
 456   GST_OBJECT_UNLOCK (filter);
 457
 458   return ret;
 459 }
 460
 461 static gboolean
 462 gst_radioactv_start (GstBaseTransform * trans)
 463 {
 464   GstRadioacTV *filter = GST_RADIOACTV (trans);
 465
 466   filter->snaptime = 0;
 467
 468   return TRUE;
 469 }
 470
 471 static void
 472 gst_radioactv_finalize (GObject * object)
 473 {
 474   GstRadioacTV *filter = GST_RADIOACTV (object);
 475
 476   if (filter->snapframe)
 477     g_free (filter->snapframe);
 478   filter->snapframe = NULL;
 479
 480   if (filter->blurzoombuf)
 481     g_free (filter->blurzoombuf);
 482   filter->blurzoombuf = NULL;
 483
 484   if (filter->diff)
 485     g_free (filter->diff);
 486   filter->diff = NULL;
 487
 488   if (filter->background)
 489     g_free (filter->background);
 490   filter->background = NULL;
 491
 492   if (filter->blurzoomx)
 493     g_free (filter->blurzoomx);
 494   filter->blurzoomx = NULL;
 495
 496   if (filter->blurzoomy)
 497     g_free (filter->blurzoomy);
 498   filter->blurzoomy = NULL;
 499
 500   G_OBJECT_CLASS (parent_class)->finalize (object);
 501 }
 502
 503 static void
 504 gst_radioactv_set_property (GObject * object, guint prop_id,
 505     const GValue * value, GParamSpec * pspec)
 506 {
 507   GstRadioacTV *filter = GST_RADIOACTV (object);
 508
 509   GST_OBJECT_LOCK (filter);
 510   switch (prop_id) {
 511     case PROP_MODE:
 512       filter->mode = g_value_get_enum (value);
 513       if (filter->mode == 3)
 514         filter->snaptime = 1;
 515       break;
 516     case PROP_COLOR:
 517       filter->color = g_value_get_enum (value);
 518       break;
 519     case PROP_INTERVAL:
 520       filter->interval = g_value_get_uint (value);
 521       break;
 522     case PROP_TRIGGER:
 523       filter->trigger = g_value_get_boolean (value);
 524       break;
 525     default:
 526       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 527       break;
 528   }
 529   GST_OBJECT_UNLOCK (filter);
 530 }
 531
 532 static void
 533 gst_radioactv_get_property (GObject * object, guint prop_id,
 534     GValue * value, GParamSpec * pspec)
 535 {
 536   GstRadioacTV *filter = GST_RADIOACTV (object);
 537
 538   switch (prop_id) {
 539     case PROP_MODE:
 540       g_value_set_enum (value, filter->mode);
 541       break;
 542     case PROP_COLOR:
 543       g_value_set_enum (value, filter->color);
 544       break;
 545     case PROP_INTERVAL:
 546       g_value_set_uint (value, filter->interval);
 547       break;
 548     case PROP_TRIGGER:
 549       g_value_set_boolean (value, filter->trigger);
 550       break;
 551     default:
 552       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 553       break;
 554   }
 555 }
 556
 557 static void
 558 gst_radioactv_base_init (gpointer g_class)
 559 {
 560   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 561
 562   gst_element_class_set_details_simple (element_class, "RadioacTV effect",
 563       "Filter/Effect/Video",
 564       "motion-enlightment effect",
 565       "FUKUCHI, Kentarou <fukuchi@users.sourceforge.net>, "
 566       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 567
 568   gst_element_class_add_pad_template (element_class,
 569       gst_static_pad_template_get (&gst_radioactv_sink_template));
 570   gst_element_class_add_pad_template (element_class,
 571       gst_static_pad_template_get (&gst_radioactv_src_template));
 572 }
 573
 574 static void
 575 gst_radioactv_class_init (GstRadioacTVClass * klass)
 576 {
 577   GObjectClass *gobject_class = (GObjectClass *) klass;
 578   GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
 579
 580   gobject_class->set_property = gst_radioactv_set_property;
 581   gobject_class->get_property = gst_radioactv_get_property;
 582
 583   gobject_class->finalize = gst_radioactv_finalize;
 584
 585   g_object_class_install_property (gobject_class, PROP_MODE,
 586       g_param_spec_enum ("mode", "Mode",
 587           "Mode", GST_TYPE_RADIOACTV_MODE, DEFAULT_MODE,
 588           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 589
 590   g_object_class_install_property (gobject_class, PROP_COLOR,
 591       g_param_spec_enum ("color", "Color",
 592           "Color", GST_TYPE_RADIOACTV_COLOR, DEFAULT_COLOR,
 593           GST_PARAM_CONTROLLABLE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 594
 595   g_object_class_install_property (gobject_class, PROP_INTERVAL,
 596       g_param_spec_uint ("interval", "Interval",
 597           "Snapshot interval (in strobe mode)", 0, G_MAXINT, DEFAULT_INTERVAL,
 598           GST_PARAM_CONTROLLABLE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 599
 600   g_object_class_install_property (gobject_class, PROP_TRIGGER,
 601       g_param_spec_boolean ("trigger", "Trigger",
 602           "Trigger (in trigger mode)", DEFAULT_TRIGGER,
 603           GST_PARAM_CONTROLLABLE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 604
 605   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_radioactv_set_caps);
 606   trans_class->transform = GST_DEBUG_FUNCPTR (gst_radioactv_transform);
 607   trans_class->start = GST_DEBUG_FUNCPTR (gst_radioactv_start);
 608
 609   makePalette ();
 610 }
 611
 612 static void
 613 gst_radioactv_init (GstRadioacTV * filter, GstRadioacTVClass * klass)
 614 {
 615   filter->mode = DEFAULT_MODE;
 616   filter->color = DEFAULT_COLOR;
 617   filter->interval = DEFAULT_INTERVAL;
 618   filter->trigger = DEFAULT_TRIGGER;
 619
 620   gst_pad_use_fixed_caps (GST_BASE_TRANSFORM_SRC_PAD (filter));
 621   gst_pad_use_fixed_caps (GST_BASE_TRANSFORM_SINK_PAD (filter));
 622 }