gst/shapewipe/gstshapewipe.c

   1 /* GStreamer
   2  * Copyright (C) 2009,2010 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-shapewipe
  22  *
  23  * The shapewipe element provides custom transitions on video streams
  24  * based on a grayscale bitmap. The state of the transition can be
  25  * controlled by the position property and an optional blended border
  26  * can be added by the border property.
  27  *
  28  * Transition bitmaps can be downloaded from the
  29  * <ulink url="http://cinelerra.org/transitions.php">Cinelerra transition</ulink>
  30  * page.
  31  *
  32  * <refsect2>
  33  * <title>Example launch line</title>
  34  * |[
  35  * gst-launch -v videotestsrc ! video/x-raw,format=(string)AYUV,width=640,height=480 ! shapewipe position=0.5 name=shape ! videomixer name=mixer ! videoconvert ! autovideosink     filesrc location=mask.png ! typefind ! decodebin2 ! videoconvert ! videoscale ! queue ! shape.mask_sink    videotestsrc pattern=snow ! video/x-raw,format=(string)AYUV,width=640,height=480 ! queue ! mixer.
  36  * ]| This pipeline adds the transition from mask.png with position 0.5 to an SMPTE test screen and snow.
  37  * </refsect2>
  38  */
  39
  40
  41 #ifdef HAVE_CONFIG_H
  42 #  include "config.h"
  43 #endif
  44
  45 #include <string.h>
  46
  47 #include <gst/gst.h>
  48 #include <gst/controller/gstcontroller.h>
  49
  50 #include "gstshapewipe.h"
  51
  52 static void gst_shape_wipe_finalize (GObject * object);
  53 static void gst_shape_wipe_get_property (GObject * object, guint prop_id,
  54     GValue * value, GParamSpec * pspec);
  55 static void gst_shape_wipe_set_property (GObject * object, guint prop_id,
  56     const GValue * value, GParamSpec * pspec);
  57
  58 static void gst_shape_wipe_reset (GstShapeWipe * self);
  59 static void gst_shape_wipe_update_qos (GstShapeWipe * self, gdouble proportion,
  60     GstClockTimeDiff diff, GstClockTime time);
  61 static void gst_shape_wipe_reset_qos (GstShapeWipe * self);
  62 static void gst_shape_wipe_read_qos (GstShapeWipe * self, gdouble * proportion,
  63     GstClockTime * time);
  64
  65 static GstStateChangeReturn gst_shape_wipe_change_state (GstElement * element,
  66     GstStateChange transition);
  67
  68 static GstFlowReturn gst_shape_wipe_video_sink_chain (GstPad * pad,
  69     GstBuffer * buffer);
  70 static gboolean gst_shape_wipe_video_sink_event (GstPad * pad,
  71     GstEvent * event);
  72 static gboolean gst_shape_wipe_video_sink_setcaps (GstShapeWipe * self,
  73     GstCaps * caps);
  74 static GstCaps *gst_shape_wipe_video_sink_getcaps (GstPad * pad,
  75     GstCaps * filter);
  76 static gboolean gst_shape_wipe_video_sink_query (GstPad * pad,
  77     GstQuery * query);
  78 static GstFlowReturn gst_shape_wipe_mask_sink_chain (GstPad * pad,
  79     GstBuffer * buffer);
  80 static gboolean gst_shape_wipe_mask_sink_event (GstPad * pad, GstEvent * event);
  81 static gboolean gst_shape_wipe_mask_sink_setcaps (GstShapeWipe * self,
  82     GstCaps * caps);
  83 static GstCaps *gst_shape_wipe_mask_sink_getcaps (GstPad * pad,
  84     GstCaps * filter);
  85 static gboolean gst_shape_wipe_src_event (GstPad * pad, GstEvent * event);
  86 static GstCaps *gst_shape_wipe_src_getcaps (GstPad * pad, GstCaps * filter);
  87 static gboolean gst_shape_wipe_src_query (GstPad * pad, GstQuery * query);
  88
  89 enum
  90 {
  91   PROP_0,
  92   PROP_POSITION,
  93   PROP_BORDER
  94 };
  95
  96 #define DEFAULT_POSITION 0.0
  97 #define DEFAULT_BORDER 0.0
  98
  99 static GstStaticPadTemplate video_sink_pad_template =
 100 GST_STATIC_PAD_TEMPLATE ("video_sink",
 101     GST_PAD_SINK,
 102     GST_PAD_ALWAYS,
 103     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ AYUV, ARGB, BGRA, ABGR, RGBA }")));
 104
 105 static GstStaticPadTemplate mask_sink_pad_template =
 106     GST_STATIC_PAD_TEMPLATE ("mask_sink",
 107     GST_PAD_SINK,
 108     GST_PAD_ALWAYS,
 109     GST_STATIC_CAPS ("video/x-raw, "
 110         "format = (string) GRAY8, "
 111         "width = " GST_VIDEO_SIZE_RANGE ", "
 112         "height = " GST_VIDEO_SIZE_RANGE ", " "framerate = 0/1 ; "
 113         "video/x-raw, " "format = (string) " GST_VIDEO_NE (GRAY16) ", "
 114         "width = " GST_VIDEO_SIZE_RANGE ", "
 115         "height = " GST_VIDEO_SIZE_RANGE ", " "framerate = 0/1"));
 116
 117 static GstStaticPadTemplate src_pad_template =
 118 GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
 119     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ AYUV, ARGB, BGRA, ABGR, RGBA }")));
 120
 121 GST_DEBUG_CATEGORY_STATIC (gst_shape_wipe_debug);
 122 #define GST_CAT_DEFAULT gst_shape_wipe_debug
 123
 124 #define gst_shape_wipe_parent_class parent_class
 125 G_DEFINE_TYPE (GstShapeWipe, gst_shape_wipe, GST_TYPE_ELEMENT);
 126
 127 static void
 128 gst_shape_wipe_class_init (GstShapeWipeClass * klass)
 129 {
 130   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 131   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 132
 133   gobject_class->finalize = gst_shape_wipe_finalize;
 134   gobject_class->set_property = gst_shape_wipe_set_property;
 135   gobject_class->get_property = gst_shape_wipe_get_property;
 136
 137   g_object_class_install_property (gobject_class, PROP_POSITION,
 138       g_param_spec_float ("position", "Position", "Position of the mask",
 139           0.0, 1.0, DEFAULT_POSITION,
 140           G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 141   g_object_class_install_property (gobject_class, PROP_BORDER,
 142       g_param_spec_float ("border", "Border", "Border of the mask",
 143           0.0, 1.0, DEFAULT_BORDER,
 144           G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 145
 146   gstelement_class->change_state =
 147       GST_DEBUG_FUNCPTR (gst_shape_wipe_change_state);
 148
 149   gst_element_class_set_details_simple (gstelement_class,
 150       "Shape Wipe transition filter",
 151       "Filter/Editor/Video",
 152       "Adds a shape wipe transition to a video stream",
 153       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 154
 155   gst_element_class_add_pad_template (gstelement_class,
 156       gst_static_pad_template_get (&video_sink_pad_template));
 157   gst_element_class_add_pad_template (gstelement_class,
 158       gst_static_pad_template_get (&mask_sink_pad_template));
 159   gst_element_class_add_pad_template (gstelement_class,
 160       gst_static_pad_template_get (&src_pad_template));
 161 }
 162
 163 static void
 164 gst_shape_wipe_init (GstShapeWipe * self)
 165 {
 166   self->video_sinkpad =
 167       gst_pad_new_from_static_template (&video_sink_pad_template, "video_sink");
 168   gst_pad_set_chain_function (self->video_sinkpad,
 169       GST_DEBUG_FUNCPTR (gst_shape_wipe_video_sink_chain));
 170   gst_pad_set_event_function (self->video_sinkpad,
 171       GST_DEBUG_FUNCPTR (gst_shape_wipe_video_sink_event));
 172   gst_pad_set_getcaps_function (self->video_sinkpad,
 173       GST_DEBUG_FUNCPTR (gst_shape_wipe_video_sink_getcaps));
 174   gst_pad_set_query_function (self->video_sinkpad,
 175       GST_DEBUG_FUNCPTR (gst_shape_wipe_video_sink_query));
 176   gst_element_add_pad (GST_ELEMENT (self), self->video_sinkpad);
 177
 178   self->mask_sinkpad =
 179       gst_pad_new_from_static_template (&mask_sink_pad_template, "mask_sink");
 180   gst_pad_set_chain_function (self->mask_sinkpad,
 181       GST_DEBUG_FUNCPTR (gst_shape_wipe_mask_sink_chain));
 182   gst_pad_set_event_function (self->mask_sinkpad,
 183       GST_DEBUG_FUNCPTR (gst_shape_wipe_mask_sink_event));
 184   gst_pad_set_getcaps_function (self->mask_sinkpad,
 185       GST_DEBUG_FUNCPTR (gst_shape_wipe_mask_sink_getcaps));
 186   gst_element_add_pad (GST_ELEMENT (self), self->mask_sinkpad);
 187
 188   self->srcpad = gst_pad_new_from_static_template (&src_pad_template, "src");
 189   gst_pad_set_event_function (self->srcpad,
 190       GST_DEBUG_FUNCPTR (gst_shape_wipe_src_event));
 191   gst_pad_set_getcaps_function (self->srcpad,
 192       GST_DEBUG_FUNCPTR (gst_shape_wipe_src_getcaps));
 193   gst_pad_set_query_function (self->srcpad,
 194       GST_DEBUG_FUNCPTR (gst_shape_wipe_src_query));
 195   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
 196
 197   self->mask_mutex = g_mutex_new ();
 198   self->mask_cond = g_cond_new ();
 199
 200   gst_shape_wipe_reset (self);
 201 }
 202
 203 static void
 204 gst_shape_wipe_get_property (GObject * object, guint prop_id,
 205     GValue * value, GParamSpec * pspec)
 206 {
 207   GstShapeWipe *self = GST_SHAPE_WIPE (object);
 208
 209   switch (prop_id) {
 210     case PROP_POSITION:
 211       g_value_set_float (value, self->mask_position);
 212       break;
 213     case PROP_BORDER:
 214       g_value_set_float (value, self->mask_border);
 215       break;
 216     default:
 217       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 218       break;
 219   }
 220 }
 221
 222 static void
 223 gst_shape_wipe_set_property (GObject * object, guint prop_id,
 224     const GValue * value, GParamSpec * pspec)
 225 {
 226   GstShapeWipe *self = GST_SHAPE_WIPE (object);
 227
 228   switch (prop_id) {
 229     case PROP_POSITION:{
 230       gfloat f = g_value_get_float (value);
 231
 232       GST_LOG_OBJECT (self, "Setting mask position: %f", f);
 233       self->mask_position = f;
 234       break;
 235     }
 236     case PROP_BORDER:{
 237       gfloat f = g_value_get_float (value);
 238
 239       GST_LOG_OBJECT (self, "Setting mask border: %f", f);
 240       self->mask_border = f;
 241       break;
 242     }
 243     default:
 244       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 245       break;
 246   }
 247 }
 248
 249 static void
 250 gst_shape_wipe_finalize (GObject * object)
 251 {
 252   GstShapeWipe *self = GST_SHAPE_WIPE (object);
 253
 254   gst_shape_wipe_reset (self);
 255
 256   if (self->mask_cond)
 257     g_cond_free (self->mask_cond);
 258   self->mask_cond = NULL;
 259
 260   if (self->mask_mutex)
 261     g_mutex_free (self->mask_mutex);
 262   self->mask_mutex = NULL;
 263
 264   G_OBJECT_CLASS (parent_class)->finalize (object);
 265 }
 266
 267 static void
 268 gst_shape_wipe_reset (GstShapeWipe * self)
 269 {
 270   GST_DEBUG_OBJECT (self, "Resetting internal state");
 271
 272   if (self->mask)
 273     gst_buffer_unref (self->mask);
 274   self->mask = NULL;
 275
 276   g_mutex_lock (self->mask_mutex);
 277   g_cond_signal (self->mask_cond);
 278   g_mutex_unlock (self->mask_mutex);
 279
 280   gst_video_info_init (&self->info);
 281   self->mask_bpp = 0;
 282
 283   gst_segment_init (&self->segment, GST_FORMAT_TIME);
 284
 285   gst_shape_wipe_reset_qos (self);
 286   self->frame_duration = 0;
 287 }
 288
 289 static gboolean
 290 gst_shape_wipe_video_sink_setcaps (GstShapeWipe * self, GstCaps * caps)
 291 {
 292   gboolean ret = TRUE;
 293   GstVideoInfo info;
 294
 295   GST_DEBUG_OBJECT (self, "Setting caps: %" GST_PTR_FORMAT, caps);
 296
 297   if (!gst_video_info_from_caps (&info, caps))
 298     goto invalid_caps;
 299
 300   if (self->info.width != info.width || self->info.height != info.height) {
 301     g_mutex_lock (self->mask_mutex);
 302     self->info = info;
 303     if (self->mask)
 304       gst_buffer_unref (self->mask);
 305     self->mask = NULL;
 306     g_mutex_unlock (self->mask_mutex);
 307   }
 308
 309
 310   if (info.fps_n != 0)
 311     self->frame_duration =
 312         gst_util_uint64_scale (GST_SECOND, info.fps_d, info.fps_n);
 313   else
 314     self->frame_duration = 0;
 315
 316   ret = gst_pad_set_caps (self->srcpad, caps);
 317
 318   return ret;
 319
 320   /* ERRORS */
 321 invalid_caps:
 322   {
 323     GST_ERROR_OBJECT (self, "Invalid caps");
 324     return FALSE;
 325   }
 326 }
 327
 328 static GstCaps *
 329 gst_shape_wipe_video_sink_getcaps (GstPad * pad, GstCaps * filter)
 330 {
 331   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
 332   GstCaps *ret, *tmp;
 333
 334   if (gst_pad_has_current_caps (pad))
 335     return gst_pad_get_current_caps (pad);
 336
 337   tmp = gst_pad_peer_get_caps (self->srcpad, NULL);
 338   if (tmp) {
 339     ret = gst_caps_intersect (tmp, gst_pad_get_pad_template_caps (pad));
 340     gst_caps_unref (tmp);
 341   } else {
 342     ret = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
 343   }
 344
 345   GST_LOG_OBJECT (pad, "srcpad accepted caps: %" GST_PTR_FORMAT, ret);
 346
 347   if (gst_caps_is_empty (ret))
 348     goto done;
 349
 350   tmp = gst_pad_peer_get_caps (pad, NULL);
 351
 352   GST_LOG_OBJECT (pad, "peerpad accepted caps: %" GST_PTR_FORMAT, tmp);
 353   if (tmp) {
 354     GstCaps *intersection;
 355
 356     intersection = gst_caps_intersect (tmp, ret);
 357     gst_caps_unref (tmp);
 358     gst_caps_unref (ret);
 359     ret = intersection;
 360   }
 361
 362   GST_LOG_OBJECT (pad, "intersection: %" GST_PTR_FORMAT, tmp);
 363
 364   if (gst_caps_is_empty (ret))
 365     goto done;
 366
 367   if (self->info.height && self->info.width) {
 368     guint i, n;
 369
 370     n = gst_caps_get_size (ret);
 371     for (i = 0; i < n; i++) {
 372       GstStructure *s = gst_caps_get_structure (ret, i);
 373
 374       gst_structure_set (s, "width", G_TYPE_INT, self->info.width, "height",
 375           G_TYPE_INT, self->info.height, NULL);
 376     }
 377   }
 378
 379   tmp = gst_pad_peer_get_caps (self->mask_sinkpad, NULL);
 380
 381   GST_LOG_OBJECT (pad, "mask accepted caps: %" GST_PTR_FORMAT, tmp);
 382   if (tmp) {
 383     GstCaps *intersection, *tmp2;
 384     guint i, n;
 385
 386     tmp = gst_caps_make_writable (tmp);
 387
 388     tmp2 = gst_caps_copy (gst_pad_get_pad_template_caps (self->mask_sinkpad));
 389
 390     intersection = gst_caps_intersect (tmp, tmp2);
 391     gst_caps_unref (tmp);
 392     gst_caps_unref (tmp2);
 393     tmp = intersection;
 394
 395     n = gst_caps_get_size (tmp);
 396
 397     for (i = 0; i < n; i++) {
 398       GstStructure *s = gst_caps_get_structure (tmp, i);
 399
 400       gst_structure_remove_fields (s, "format", "framerate", NULL);
 401       gst_structure_set_name (s, "video/x-raw");
 402     }
 403
 404     intersection = gst_caps_intersect (tmp, ret);
 405     gst_caps_unref (tmp);
 406     gst_caps_unref (ret);
 407     ret = intersection;
 408   }
 409 done:
 410
 411   gst_object_unref (self);
 412
 413   GST_LOG_OBJECT (pad, "Returning caps: %" GST_PTR_FORMAT, ret);
 414
 415   return ret;
 416 }
 417
 418 static gboolean
 419 gst_shape_wipe_mask_sink_setcaps (GstShapeWipe * self, GstCaps * caps)
 420 {
 421   gboolean ret = TRUE;
 422   GstStructure *s;
 423   gint width, height, bpp;
 424
 425   GST_DEBUG_OBJECT (self, "Setting caps: %" GST_PTR_FORMAT, caps);
 426
 427   s = gst_caps_get_structure (caps, 0);
 428
 429   if (!gst_structure_get_int (s, "width", &width) ||
 430       !gst_structure_get_int (s, "height", &height) ||
 431       !gst_structure_get_int (s, "bpp", &bpp)) {
 432     ret = FALSE;
 433     goto done;
 434   }
 435
 436   if ((self->info.width != width || self->info.height != height) &&
 437       self->info.width > 0 && self->info.height > 0) {
 438     GST_ERROR_OBJECT (self, "Mask caps must have the same width/height "
 439         "as the video caps");
 440     ret = FALSE;
 441     goto done;
 442   } else {
 443     self->info.width = width;
 444     self->info.height = height;
 445   }
 446
 447   self->mask_bpp = bpp;
 448
 449 done:
 450   return ret;
 451 }
 452
 453 static GstCaps *
 454 gst_shape_wipe_mask_sink_getcaps (GstPad * pad, GstCaps * filter)
 455 {
 456   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
 457   GstCaps *ret, *tmp;
 458   guint i, n;
 459
 460   if (gst_pad_has_current_caps (pad))
 461     return gst_pad_get_current_caps (pad);
 462
 463   tmp = gst_pad_peer_get_caps (self->video_sinkpad, NULL);
 464   if (tmp) {
 465     ret =
 466         gst_caps_intersect (tmp,
 467         gst_pad_get_pad_template_caps (self->video_sinkpad));
 468     gst_caps_unref (tmp);
 469   } else {
 470     ret = gst_caps_copy (gst_pad_get_pad_template_caps (self->video_sinkpad));
 471   }
 472
 473   GST_LOG_OBJECT (pad, "video sink accepted caps: %" GST_PTR_FORMAT, ret);
 474
 475   if (gst_caps_is_empty (ret))
 476     goto done;
 477
 478   tmp = gst_pad_peer_get_caps (self->srcpad, NULL);
 479   GST_LOG_OBJECT (pad, "srcpad accepted caps: %" GST_PTR_FORMAT, ret);
 480
 481   if (tmp) {
 482     GstCaps *intersection;
 483
 484     intersection = gst_caps_intersect (ret, tmp);
 485     gst_caps_unref (ret);
 486     gst_caps_unref (tmp);
 487     ret = intersection;
 488   }
 489
 490   GST_LOG_OBJECT (pad, "intersection: %" GST_PTR_FORMAT, ret);
 491
 492   if (gst_caps_is_empty (ret))
 493     goto done;
 494
 495   n = gst_caps_get_size (ret);
 496   tmp = gst_caps_new_empty ();
 497   for (i = 0; i < n; i++) {
 498     GstStructure *s = gst_caps_get_structure (ret, i);
 499     GstStructure *t;
 500
 501     gst_structure_set_name (s, "video/x-raw");
 502     gst_structure_remove_fields (s, "format", "framerate", NULL);
 503
 504     if (self->info.width && self->info.height)
 505       gst_structure_set (s, "width", G_TYPE_INT, self->info.width, "height",
 506           G_TYPE_INT, self->info.height, NULL);
 507
 508     gst_structure_set (s, "framerate", GST_TYPE_FRACTION, 0, 1, NULL);
 509
 510     t = gst_structure_copy (s);
 511
 512     gst_structure_set (s, "format", G_TYPE_STRING, GST_VIDEO_NE (GRAY16), NULL);
 513     gst_structure_set (t, "format", G_TYPE_STRING, "GRAY8", NULL);
 514
 515     gst_caps_append_structure (tmp, t);
 516   }
 517   gst_caps_append (ret, tmp);
 518
 519   tmp = gst_pad_peer_get_caps (pad, NULL);
 520   GST_LOG_OBJECT (pad, "peer accepted caps: %" GST_PTR_FORMAT, tmp);
 521
 522   if (tmp) {
 523     GstCaps *intersection;
 524
 525     intersection = gst_caps_intersect (tmp, ret);
 526     gst_caps_unref (tmp);
 527     gst_caps_unref (ret);
 528     ret = intersection;
 529   }
 530
 531 done:
 532   gst_object_unref (self);
 533
 534   GST_LOG_OBJECT (pad, "Returning caps: %" GST_PTR_FORMAT, ret);
 535
 536   return ret;
 537 }
 538
 539 static GstCaps *
 540 gst_shape_wipe_src_getcaps (GstPad * pad, GstCaps * filter)
 541 {
 542   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
 543   GstCaps *ret, *tmp;
 544
 545   if (gst_pad_has_current_caps (pad))
 546     return gst_pad_get_current_caps (pad);
 547   else if (gst_pad_has_current_caps (self->video_sinkpad))
 548     return gst_pad_get_current_caps (self->video_sinkpad);
 549
 550   tmp = gst_pad_peer_get_caps (self->video_sinkpad, NULL);
 551   if (tmp) {
 552     ret =
 553         gst_caps_intersect (tmp,
 554         gst_pad_get_pad_template_caps (self->video_sinkpad));
 555     gst_caps_unref (tmp);
 556   } else {
 557     ret = gst_caps_copy (gst_pad_get_pad_template_caps (self->video_sinkpad));
 558   }
 559
 560   GST_LOG_OBJECT (pad, "video sink accepted caps: %" GST_PTR_FORMAT, ret);
 561
 562   if (gst_caps_is_empty (ret))
 563     goto done;
 564
 565   tmp = gst_pad_peer_get_caps (pad, NULL);
 566   GST_LOG_OBJECT (pad, "peer accepted caps: %" GST_PTR_FORMAT, ret);
 567   if (tmp) {
 568     GstCaps *intersection;
 569
 570     intersection = gst_caps_intersect (tmp, ret);
 571     gst_caps_unref (tmp);
 572     gst_caps_unref (ret);
 573     ret = intersection;
 574   }
 575
 576   GST_LOG_OBJECT (pad, "intersection: %" GST_PTR_FORMAT, ret);
 577
 578   if (gst_caps_is_empty (ret))
 579     goto done;
 580
 581   if (self->info.height && self->info.width) {
 582     guint i, n;
 583
 584     n = gst_caps_get_size (ret);
 585     for (i = 0; i < n; i++) {
 586       GstStructure *s = gst_caps_get_structure (ret, i);
 587
 588       gst_structure_set (s, "width", G_TYPE_INT, self->info.width, "height",
 589           G_TYPE_INT, self->info.height, NULL);
 590     }
 591   }
 592
 593   tmp = gst_pad_peer_get_caps (self->mask_sinkpad, NULL);
 594   GST_LOG_OBJECT (pad, "mask sink accepted caps: %" GST_PTR_FORMAT, ret);
 595   if (tmp) {
 596     GstCaps *intersection, *tmp2;
 597     guint i, n;
 598
 599     tmp = gst_caps_make_writable (tmp);
 600     tmp2 = gst_caps_copy (gst_pad_get_pad_template_caps (self->mask_sinkpad));
 601
 602     intersection = gst_caps_intersect (tmp, tmp2);
 603     gst_caps_unref (tmp);
 604     gst_caps_unref (tmp2);
 605
 606     tmp = intersection;
 607     n = gst_caps_get_size (tmp);
 608
 609     for (i = 0; i < n; i++) {
 610       GstStructure *s = gst_caps_get_structure (tmp, i);
 611
 612       gst_structure_remove_fields (s, "format", "framerate", NULL);
 613       gst_structure_set_name (s, "video/x-raw");
 614     }
 615
 616     intersection = gst_caps_intersect (tmp, ret);
 617     gst_caps_unref (tmp);
 618     gst_caps_unref (ret);
 619     ret = intersection;
 620   }
 621
 622 done:
 623
 624   gst_object_unref (self);
 625
 626   GST_LOG_OBJECT (pad, "Returning caps: %" GST_PTR_FORMAT, ret);
 627
 628   return ret;
 629 }
 630
 631 static gboolean
 632 gst_shape_wipe_video_sink_query (GstPad * pad, GstQuery * query)
 633 {
 634   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
 635   gboolean ret;
 636
 637   GST_LOG_OBJECT (pad, "Handling query of type '%s'",
 638       gst_query_type_get_name (GST_QUERY_TYPE (query)));
 639
 640   ret = gst_pad_peer_query (self->srcpad, query);
 641
 642   gst_object_unref (self);
 643   return ret;
 644 }
 645
 646 static gboolean
 647 gst_shape_wipe_src_query (GstPad * pad, GstQuery * query)
 648 {
 649   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
 650   gboolean ret;
 651
 652   GST_LOG_OBJECT (pad, "Handling query of type '%s'",
 653       gst_query_type_get_name (GST_QUERY_TYPE (query)));
 654
 655   ret = gst_pad_peer_query (self->video_sinkpad, query);
 656
 657   gst_object_unref (self);
 658   return ret;
 659 }
 660
 661 static void
 662 gst_shape_wipe_update_qos (GstShapeWipe * self, gdouble proportion,
 663     GstClockTimeDiff diff, GstClockTime timestamp)
 664 {
 665   GST_OBJECT_LOCK (self);
 666   self->proportion = proportion;
 667   if (G_LIKELY (timestamp != GST_CLOCK_TIME_NONE)) {
 668     if (G_UNLIKELY (diff > 0))
 669       self->earliest_time = timestamp + 2 * diff + self->frame_duration;
 670     else
 671       self->earliest_time = timestamp + diff;
 672   } else {
 673     self->earliest_time = GST_CLOCK_TIME_NONE;
 674   }
 675   GST_OBJECT_UNLOCK (self);
 676 }
 677
 678 static void
 679 gst_shape_wipe_reset_qos (GstShapeWipe * self)
 680 {
 681   gst_shape_wipe_update_qos (self, 0.5, 0, GST_CLOCK_TIME_NONE);
 682 }
 683
 684 static void
 685 gst_shape_wipe_read_qos (GstShapeWipe * self, gdouble * proportion,
 686     GstClockTime * time)
 687 {
 688   GST_OBJECT_LOCK (self);
 689   *proportion = self->proportion;
 690   *time = self->earliest_time;
 691   GST_OBJECT_UNLOCK (self);
 692 }
 693
 694 /* Perform qos calculations before processing the next frame. Returns TRUE if
 695  * the frame should be processed, FALSE if the frame can be dropped entirely */
 696 static gboolean
 697 gst_shape_wipe_do_qos (GstShapeWipe * self, GstClockTime timestamp)
 698 {
 699   GstClockTime qostime, earliest_time;
 700   gdouble proportion;
 701
 702   /* no timestamp, can't do QoS => process frame */
 703   if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (timestamp))) {
 704     GST_LOG_OBJECT (self, "invalid timestamp, can't do QoS, process frame");
 705     return TRUE;
 706   }
 707
 708   /* get latest QoS observation values */
 709   gst_shape_wipe_read_qos (self, &proportion, &earliest_time);
 710
 711   /* skip qos if we have no observation (yet) => process frame */
 712   if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (earliest_time))) {
 713     GST_LOG_OBJECT (self, "no observation yet, process frame");
 714     return TRUE;
 715   }
 716
 717   /* qos is done on running time */
 718   qostime = gst_segment_to_running_time (&self->segment, GST_FORMAT_TIME,
 719       timestamp);
 720
 721   /* see how our next timestamp relates to the latest qos timestamp */
 722   GST_LOG_OBJECT (self, "qostime %" GST_TIME_FORMAT ", earliest %"
 723       GST_TIME_FORMAT, GST_TIME_ARGS (qostime), GST_TIME_ARGS (earliest_time));
 724
 725   if (qostime != GST_CLOCK_TIME_NONE && qostime <= earliest_time) {
 726     GST_DEBUG_OBJECT (self, "we are late, drop frame");
 727     return FALSE;
 728   }
 729
 730   GST_LOG_OBJECT (self, "process frame");
 731   return TRUE;
 732 }
 733
 734 #define CREATE_ARGB_FUNCTIONS(depth, name, shift, a, r, g, b) \
 735 static void \
 736 gst_shape_wipe_blend_##name##_##depth (GstShapeWipe * self, GstVideoFrame * inframe, \
 737     GstVideoFrame * maskframe, GstVideoFrame * outframe) \
 738 { \
 739   const guint##depth *mask = (const guint##depth *) GST_VIDEO_FRAME_PLANE_DATA (maskframe, 0); \
 740   const guint8 *input = (const guint8 *) GST_VIDEO_FRAME_PLANE_DATA (inframe, 0); \
 741   guint8 *output = (guint8 *) GST_VIDEO_FRAME_PLANE_DATA (outframe, 0); \
 742   guint i, j; \
 743   guint mask_increment = ((depth == 16) ? GST_ROUND_UP_2 (self->info.width) : \
 744                            GST_ROUND_UP_4 (self->info.width)) - self->info.width; \
 745   gfloat position = self->mask_position; \
 746   gfloat low = position - (self->mask_border / 2.0f); \
 747   gfloat high = position + (self->mask_border / 2.0f); \
 748   guint32 low_i, high_i, round_i; \
 749   gint width = self->info.width, height = self->info.height; \
 750   \
 751   if (low < 0.0f) { \
 752     high = 0.0f; \
 753     low = 0.0f; \
 754   } \
 755   \
 756   if (high > 1.0f) { \
 757     low = 1.0f; \
 758     high = 1.0f; \
 759   } \
 760   \
 761   low_i = low * 65536; \
 762   high_i = high * 65536; \
 763   round_i = (high_i - low_i) >> 1; \
 764   \
 765   for (i = 0; i < height; i++) { \
 766     for (j = 0; j < width; j++) { \
 767       guint32 in = *mask << shift; \
 768       \
 769       if (in < low_i) { \
 770         output[a] = 0x00;       /* A */ \
 771         output[r] = input[r];   /* R */ \
 772         output[g] = input[g];   /* G */ \
 773         output[b] = input[b];   /* B */ \
 774       } else if (in >= high_i) { \
 775         output[a] = input[a];   /* A */ \
 776         output[r] = input[r];   /* R */ \
 777         output[g] = input[g];   /* G */ \
 778         output[b] = input[b];   /* B */ \
 779       } else { \
 780         guint32 val; \
 781         /* Note: This will never overflow or be larger than 255! */ \
 782         val = (((in - low_i) << 16) + round_i) / (high_i - low_i); \
 783         val = (val * input[a] + 32768) >> 16; \
 784         \
 785         output[a] = val;        /* A */ \
 786         output[r] = input[r];   /* R */ \
 787         output[g] = input[g];   /* G */ \
 788         output[b] = input[b];   /* B */ \
 789       } \
 790       \
 791       mask++; \
 792       input += 4; \
 793       output += 4; \
 794     } \
 795     mask += mask_increment; \
 796   } \
 797 }
 798
 799 CREATE_ARGB_FUNCTIONS (16, argb, 0, 0, 1, 2, 3);
 800 CREATE_ARGB_FUNCTIONS (8, argb, 8, 0, 1, 2, 3);
 801
 802 CREATE_ARGB_FUNCTIONS (16, bgra, 0, 3, 2, 1, 0);
 803 CREATE_ARGB_FUNCTIONS (8, bgra, 8, 3, 2, 1, 0);
 804
 805 static GstFlowReturn
 806 gst_shape_wipe_video_sink_chain (GstPad * pad, GstBuffer * buffer)
 807 {
 808   GstShapeWipe *self = GST_SHAPE_WIPE (GST_PAD_PARENT (pad));
 809   GstFlowReturn ret = GST_FLOW_OK;
 810   GstBuffer *mask = NULL, *outbuf = NULL;
 811   GstClockTime timestamp;
 812   gboolean new_outbuf = FALSE;
 813   GstVideoFrame inframe, outframe, maskframe;
 814
 815   if (G_UNLIKELY (GST_VIDEO_INFO_FORMAT (&self->info) ==
 816           GST_VIDEO_FORMAT_UNKNOWN))
 817     goto not_negotiated;
 818
 819   timestamp = GST_BUFFER_TIMESTAMP (buffer);
 820   timestamp =
 821       gst_segment_to_stream_time (&self->segment, GST_FORMAT_TIME, timestamp);
 822
 823   if (GST_CLOCK_TIME_IS_VALID (timestamp))
 824     gst_object_sync_values (G_OBJECT (self), timestamp);
 825
 826   GST_LOG_OBJECT (self,
 827       "Blending buffer with timestamp %" GST_TIME_FORMAT " at position %f",
 828       GST_TIME_ARGS (timestamp), self->mask_position);
 829
 830   g_mutex_lock (self->mask_mutex);
 831   if (self->shutdown)
 832     goto shutdown;
 833
 834   if (!self->mask)
 835     g_cond_wait (self->mask_cond, self->mask_mutex);
 836
 837   if (self->mask == NULL || self->shutdown) {
 838     goto shutdown;
 839   } else {
 840     mask = gst_buffer_ref (self->mask);
 841   }
 842   g_mutex_unlock (self->mask_mutex);
 843
 844   if (!gst_shape_wipe_do_qos (self, GST_BUFFER_TIMESTAMP (buffer)))
 845     goto qos;
 846
 847   /* Try to blend inplace, if it's not possible
 848    * get a new buffer from downstream. */
 849   if (!gst_buffer_is_writable (buffer)) {
 850     outbuf = gst_buffer_new_allocate (NULL, gst_buffer_get_size (buffer), 0);
 851     gst_buffer_copy_into (outbuf, buffer, GST_BUFFER_COPY_METADATA, 0, -1);
 852     new_outbuf = TRUE;
 853   } else {
 854     outbuf = buffer;
 855   }
 856
 857   gst_video_frame_map (&inframe, &self->info, buffer, GST_MAP_READ);
 858   gst_video_frame_map (&maskframe, &self->info, mask, GST_MAP_READ);
 859   gst_video_frame_map (&outframe, &self->info, outbuf, GST_MAP_WRITE);
 860
 861   switch (GST_VIDEO_INFO_FORMAT (&self->info)) {
 862     case GST_VIDEO_FORMAT_AYUV:
 863     case GST_VIDEO_FORMAT_ARGB:
 864     case GST_VIDEO_FORMAT_ABGR:
 865       if (self->mask_bpp == 16)
 866         gst_shape_wipe_blend_argb_16 (self, &inframe, &maskframe, &outframe);
 867       else
 868         gst_shape_wipe_blend_argb_8 (self, &inframe, &maskframe, &outframe);
 869       break;
 870     case GST_VIDEO_FORMAT_BGRA:
 871     case GST_VIDEO_FORMAT_RGBA:
 872       if (self->mask_bpp == 16)
 873         gst_shape_wipe_blend_bgra_16 (self, &inframe, &maskframe, &outframe);
 874       else
 875         gst_shape_wipe_blend_bgra_8 (self, &inframe, &maskframe, &outframe);
 876       break;
 877     default:
 878       g_assert_not_reached ();
 879       break;
 880   }
 881
 882   gst_video_frame_unmap (&outframe);
 883   gst_video_frame_unmap (&maskframe);
 884   gst_video_frame_unmap (&inframe);
 885
 886   gst_buffer_unref (mask);
 887   if (new_outbuf)
 888     gst_buffer_unref (buffer);
 889
 890   ret = gst_pad_push (self->srcpad, outbuf);
 891   if (G_UNLIKELY (ret != GST_FLOW_OK))
 892     goto push_failed;
 893
 894   return ret;
 895
 896   /* Errors */
 897 not_negotiated:
 898   {
 899     GST_ERROR_OBJECT (self, "No valid caps yet");
 900     gst_buffer_unref (buffer);
 901     return GST_FLOW_NOT_NEGOTIATED;
 902   }
 903 shutdown:
 904   {
 905     GST_DEBUG_OBJECT (self, "Shutting down");
 906     gst_buffer_unref (buffer);
 907     return GST_FLOW_WRONG_STATE;
 908   }
 909 qos:
 910   {
 911     GST_DEBUG_OBJECT (self, "Dropping buffer because of QoS");
 912     gst_buffer_unref (buffer);
 913     gst_buffer_unref (mask);
 914     return GST_FLOW_OK;
 915   }
 916 push_failed:
 917   {
 918     GST_ERROR_OBJECT (self, "Pushing buffer downstream failed: %s",
 919         gst_flow_get_name (ret));
 920     return ret;
 921   }
 922 }
 923
 924 static GstFlowReturn
 925 gst_shape_wipe_mask_sink_chain (GstPad * pad, GstBuffer * buffer)
 926 {
 927   GstShapeWipe *self = GST_SHAPE_WIPE (GST_PAD_PARENT (pad));
 928   GstFlowReturn ret = GST_FLOW_OK;
 929
 930   g_mutex_lock (self->mask_mutex);
 931   GST_DEBUG_OBJECT (self, "Setting new mask buffer: %" GST_PTR_FORMAT, buffer);
 932
 933   gst_buffer_replace (&self->mask, buffer);
 934   g_cond_signal (self->mask_cond);
 935   g_mutex_unlock (self->mask_mutex);
 936
 937   gst_buffer_unref (buffer);
 938
 939   return ret;
 940 }
 941
 942 static GstStateChangeReturn
 943 gst_shape_wipe_change_state (GstElement * element, GstStateChange transition)
 944 {
 945   GstShapeWipe *self = GST_SHAPE_WIPE (element);
 946   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 947
 948   switch (transition) {
 949     case GST_STATE_CHANGE_READY_TO_PAUSED:
 950       self->shutdown = FALSE;
 951       break;
 952     case GST_STATE_CHANGE_PAUSED_TO_READY:
 953       /* Unblock video sink chain function */
 954       g_mutex_lock (self->mask_mutex);
 955       self->shutdown = TRUE;
 956       g_cond_signal (self->mask_cond);
 957       g_mutex_unlock (self->mask_mutex);
 958       break;
 959     default:
 960       break;
 961   }
 962
 963   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 964     ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 965
 966   switch (transition) {
 967     case GST_STATE_CHANGE_PAUSED_TO_READY:
 968       gst_shape_wipe_reset (self);
 969       break;
 970     default:
 971       break;
 972   }
 973
 974   return ret;
 975 }
 976
 977 static gboolean
 978 gst_shape_wipe_video_sink_event (GstPad * pad, GstEvent * event)
 979 {
 980   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
 981   gboolean ret;
 982
 983   GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));
 984
 985   switch (GST_EVENT_TYPE (event)) {
 986     case GST_EVENT_CAPS:
 987     {
 988       GstCaps *caps;
 989
 990       gst_event_parse_caps (event, &caps);
 991       ret = gst_shape_wipe_video_sink_setcaps (self, caps);
 992       gst_event_unref (event);
 993       break;
 994     }
 995     case GST_EVENT_SEGMENT:
 996     {
 997       GstSegment seg;
 998
 999       gst_event_copy_segment (event, &seg);
1000       if (seg.format == GST_FORMAT_TIME) {
1001         GST_DEBUG_OBJECT (pad,
1002             "Got SEGMENT event in GST_FORMAT_TIME %" GST_PTR_FORMAT, &seg);
1003         self->segment = seg;
1004       } else {
1005         gst_segment_init (&self->segment, GST_FORMAT_TIME);
1006       }
1007     }
1008       /* fall through */
1009     case GST_EVENT_FLUSH_STOP:
1010       gst_shape_wipe_reset_qos (self);
1011       /* fall through */
1012     default:
1013       ret = gst_pad_push_event (self->srcpad, event);
1014       break;
1015   }
1016
1017   gst_object_unref (self);
1018   return ret;
1019 }
1020
1021 static gboolean
1022 gst_shape_wipe_mask_sink_event (GstPad * pad, GstEvent * event)
1023 {
1024   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
1025
1026   GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));
1027
1028   switch (GST_EVENT_TYPE (event)) {
1029     case GST_EVENT_CAPS:
1030     {
1031       GstCaps *caps;
1032
1033       gst_event_parse_caps (event, &caps);
1034       gst_shape_wipe_mask_sink_setcaps (self, caps);
1035       break;
1036     }
1037     case GST_EVENT_FLUSH_STOP:
1038       g_mutex_lock (self->mask_mutex);
1039       gst_buffer_replace (&self->mask, NULL);
1040       g_mutex_unlock (self->mask_mutex);
1041       break;
1042     default:
1043       break;
1044   }
1045
1046   /* Dropping all events here */
1047   gst_event_unref (event);
1048
1049   gst_object_unref (self);
1050   return TRUE;
1051 }
1052
1053 static gboolean
1054 gst_shape_wipe_src_event (GstPad * pad, GstEvent * event)
1055 {
1056   GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad));
1057   gboolean ret;
1058
1059   GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));
1060
1061   switch (GST_EVENT_TYPE (event)) {
1062     case GST_EVENT_QOS:{
1063       GstQOSType type;
1064       GstClockTimeDiff diff;
1065       GstClockTime timestamp;
1066       gdouble proportion;
1067
1068       gst_event_parse_qos (event, &type, &proportion, &diff, &timestamp);
1069
1070       gst_shape_wipe_update_qos (self, proportion, diff, timestamp);
1071     }
1072       /* fall through */
1073     default:
1074       ret = gst_pad_push_event (self->video_sinkpad, event);
1075       break;
1076   }
1077
1078   gst_object_unref (self);
1079   return ret;
1080 }
1081
1082 static gboolean
1083 plugin_init (GstPlugin * plugin)
1084 {
1085   GST_DEBUG_CATEGORY_INIT (gst_shape_wipe_debug, "shapewipe", 0,
1086       "shapewipe element");
1087
1088   gst_controller_init (NULL, NULL);
1089
1090   if (!gst_element_register (plugin, "shapewipe", GST_RANK_NONE,
1091           GST_TYPE_SHAPE_WIPE))
1092     return FALSE;
1093
1094   return TRUE;
1095 }
1096
1097 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1098     GST_VERSION_MINOR,
1099     "shapewipe",
1100     "Shape Wipe transition filter",
1101     plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)