gst/videomixer/videomixer.c

   1 /* Generic video mixer plugin
   2  * Copyright (C) 2004 Wim Taymans <wim@fluendo.com>
   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 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <gst/gst.h>
  25 #include <string.h>
  26
  27 GST_DEBUG_CATEGORY_STATIC (gst_videomixer_debug);
  28 #define GST_CAT_DEFAULT gst_videomixer_debug
  29
  30 #define GST_TYPE_VIDEO_MIXER_PAD (gst_videomixer_pad_get_type())
  31 #define GST_VIDEO_MIXER_PAD(obj) \
  32         (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_MIXER_PAD, GstVideoMixerPad))
  33 #define GST_VIDEO_MIXER_PAD_CLASS(klass) \
  34         (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_MIXER_PAD, GstVideoMixerPadiClass))
  35 #define GST_IS_VIDEO_MIXER_PAD(obj) \
  36         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_MIXER_PAD))
  37 #define GST_IS_VIDEO_MIXER_PAD_CLASS(obj) \
  38         (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_MIXER_PAD))
  39
  40 typedef struct _GstVideoMixerPad GstVideoMixerPad;
  41 typedef struct _GstVideoMixerPadClass GstVideoMixerPadClass;
  42
  43 #define GST_TYPE_VIDEO_MIXER (gst_videomixer_get_type())
  44 #define GST_VIDEO_MIXER(obj) \
  45         (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_MIXER, GstVideoMixer))
  46 #define GST_VIDEO_MIXER_CLASS(klass) \
  47         (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_MIXER, GstVideoMixerClass))
  48 #define GST_IS_VIDEO_MIXER(obj) \
  49         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_MIXER))
  50 #define GST_IS_VIDEO_MIXER_CLASS(obj) \
  51         (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_MIXER))
  52
  53 static GType gst_videomixer_get_type (void);
  54
  55 typedef struct _GstVideoMixer GstVideoMixer;
  56 typedef struct _GstVideoMixerClass GstVideoMixerClass;
  57
  58 static void gst_videomixer_pad_base_init (gpointer g_class);
  59 static void gst_videomixer_pad_class_init (GstVideoMixerPadClass * klass);
  60 static void gst_videomixer_pad_init (GstVideoMixerPad * mixerpad);
  61
  62 static void gst_videomixer_pad_get_property (GObject * object, guint prop_id,
  63     GValue * value, GParamSpec * pspec);
  64 static void gst_videomixer_pad_set_property (GObject * object, guint prop_id,
  65     const GValue * value, GParamSpec * pspec);
  66
  67 static void gst_videomixer_sort_pads (GstVideoMixer * mix);
  68
  69 #define DEFAULT_PAD_ZORDER 0
  70 #define DEFAULT_PAD_XPOS   0
  71 #define DEFAULT_PAD_YPOS   0
  72 #define DEFAULT_PAD_ALPHA  1.0
  73 enum
  74 {
  75   ARG_PAD_0,
  76   ARG_PAD_ZORDER,
  77   ARG_PAD_XPOS,
  78   ARG_PAD_YPOS,
  79   ARG_PAD_ALPHA,
  80 };
  81
  82 /* all information needed for one video stream */
  83 struct _GstVideoMixerPad
  84 {
  85   GstRealPad parent;            /* subclass the pad */
  86
  87   GstBuffer *buffer;            /* the queued buffer for this pad */
  88   gboolean eos;
  89
  90   gint64 queued;
  91
  92   guint in_width, in_height;
  93   gdouble in_framerate;
  94
  95   gint xpos, ypos;
  96   guint zorder;
  97   gint blend_mode;
  98   gdouble alpha;
  99 };
 100
 101 struct _GstVideoMixerPadClass
 102 {
 103   GstRealPadClass parent_class;
 104 };
 105
 106 static GType
 107 gst_videomixer_pad_get_type (void)
 108 {
 109   static GType videomixer_pad_type = 0;
 110
 111   if (!videomixer_pad_type) {
 112     static const GTypeInfo videomixer_pad_info = {
 113       sizeof (GstVideoMixerPadClass),
 114       gst_videomixer_pad_base_init,
 115       NULL,
 116       (GClassInitFunc) gst_videomixer_pad_class_init,
 117       NULL,
 118       NULL,
 119       sizeof (GstVideoMixerPad),
 120       0,
 121       (GInstanceInitFunc) gst_videomixer_pad_init,
 122     };
 123
 124     videomixer_pad_type =
 125         g_type_register_static (GST_TYPE_REAL_PAD,
 126         "GstVideoMixerPad", &videomixer_pad_info, 0);
 127   }
 128   return videomixer_pad_type;
 129 }
 130
 131 static void
 132 gst_videomixer_pad_base_init (gpointer g_class)
 133 {
 134 }
 135
 136 static void
 137 gst_videomixer_pad_class_init (GstVideoMixerPadClass * klass)
 138 {
 139   GObjectClass *gobject_class;
 140
 141   gobject_class = (GObjectClass *) klass;
 142
 143   gobject_class->set_property =
 144       GST_DEBUG_FUNCPTR (gst_videomixer_pad_set_property);
 145   gobject_class->get_property =
 146       GST_DEBUG_FUNCPTR (gst_videomixer_pad_get_property);
 147
 148   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PAD_ZORDER,
 149       g_param_spec_uint ("zorder", "Z-Order", "Z Order of the picture",
 150           0, 10000, DEFAULT_PAD_ZORDER, G_PARAM_READWRITE));
 151   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PAD_XPOS,
 152       g_param_spec_int ("xpos", "X Position", "X Position of the picture",
 153           G_MININT, G_MAXINT, DEFAULT_PAD_XPOS, G_PARAM_READWRITE));
 154   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PAD_YPOS,
 155       g_param_spec_int ("ypos", "Y Position", "Y Position of the picture",
 156           G_MININT, G_MAXINT, DEFAULT_PAD_YPOS, G_PARAM_READWRITE));
 157   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PAD_ALPHA,
 158       g_param_spec_double ("alpha", "Alpha", "Alpha of the picture",
 159           0.0, 1.0, DEFAULT_PAD_ALPHA, G_PARAM_READWRITE));
 160 }
 161
 162 static const GstEventMask *
 163 gst_videomixer_pad_get_sink_event_masks (GstPad * pad)
 164 {
 165   static const GstEventMask gst_videomixer_sink_event_masks[] = {
 166     {GST_EVENT_EOS, 0},
 167     {0,}
 168   };
 169
 170   return gst_videomixer_sink_event_masks;
 171 }
 172
 173 static void
 174 gst_videomixer_pad_get_property (GObject * object, guint prop_id,
 175     GValue * value, GParamSpec * pspec)
 176 {
 177   GstVideoMixerPad *pad;
 178
 179   g_return_if_fail (GST_IS_VIDEO_MIXER_PAD (object));
 180
 181   pad = GST_VIDEO_MIXER_PAD (object);
 182
 183   switch (prop_id) {
 184     case ARG_PAD_ZORDER:
 185       g_value_set_uint (value, pad->zorder);
 186       break;
 187     case ARG_PAD_XPOS:
 188       g_value_set_int (value, pad->xpos);
 189       break;
 190     case ARG_PAD_YPOS:
 191       g_value_set_int (value, pad->ypos);
 192       break;
 193     case ARG_PAD_ALPHA:
 194       g_value_set_double (value, pad->alpha);
 195       break;
 196     default:
 197       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 198       break;
 199   }
 200 }
 201
 202 static void
 203 gst_videomixer_pad_set_property (GObject * object, guint prop_id,
 204     const GValue * value, GParamSpec * pspec)
 205 {
 206   GstVideoMixerPad *pad;
 207   GstVideoMixer *mix;
 208
 209   g_return_if_fail (GST_IS_PAD (object));
 210
 211   pad = GST_VIDEO_MIXER_PAD (object);
 212   mix = GST_VIDEO_MIXER (gst_pad_get_parent (GST_PAD (pad)));
 213
 214   switch (prop_id) {
 215     case ARG_PAD_ZORDER:
 216       pad->zorder = g_value_get_uint (value);
 217       gst_videomixer_sort_pads (mix);
 218       break;
 219     case ARG_PAD_XPOS:
 220       pad->xpos = g_value_get_int (value);
 221       break;
 222     case ARG_PAD_YPOS:
 223       pad->ypos = g_value_get_int (value);
 224       break;
 225     case ARG_PAD_ALPHA:
 226       pad->alpha = g_value_get_double (value);
 227       break;
 228     default:
 229       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 230       break;
 231   }
 232 }
 233
 234 typedef enum
 235 {
 236   VIDEO_MIXER_BACKGROUND_CHECKER,
 237   VIDEO_MIXER_BACKGROUND_BLACK,
 238   VIDEO_MIXER_BACKGROUND_WHITE,
 239 }
 240 GstVideoMixerBackground;
 241
 242 struct _GstVideoMixer
 243 {
 244   GstElement element;
 245
 246   /* pad */
 247   GstPad *srcpad;
 248
 249   /* sinkpads, a GSList of GstVideoMixerPads */
 250   GSList *sinkpads;
 251   gint numpads;
 252
 253   /* the master pad */
 254   GstVideoMixerPad *master;
 255
 256   gint in_width, in_height;
 257   gint out_width, out_height;
 258
 259   GstVideoMixerBackground background;
 260
 261   gdouble in_framerate;
 262 };
 263
 264 struct _GstVideoMixerClass
 265 {
 266   GstElementClass parent_class;
 267 };
 268
 269 static GstPadLinkReturn
 270 gst_videomixer_pad_sinkconnect (GstPad * pad, const GstCaps * vscaps)
 271 {
 272   GstVideoMixer *mix;
 273   GstVideoMixerPad *mixpad;
 274   GstStructure *structure;
 275
 276   mix = GST_VIDEO_MIXER (gst_pad_get_parent (pad));
 277   mixpad = GST_VIDEO_MIXER_PAD (pad);
 278
 279   GST_DEBUG ("videomixer: sinkconnect triggered on %s", gst_pad_get_name (pad));
 280
 281   structure = gst_caps_get_structure (vscaps, 0);
 282
 283   gst_structure_get_int (structure, "width", &mixpad->in_width);
 284   gst_structure_get_int (structure, "height", &mixpad->in_height);
 285   gst_structure_get_double (structure, "framerate", &mixpad->in_framerate);
 286
 287   mixpad->xpos = 0;
 288   mixpad->ypos = 0;
 289
 290   mix->in_width = MAX (mix->in_width, mixpad->in_width);
 291   mix->in_height = MAX (mix->in_height, mixpad->in_height);
 292   if (mix->in_framerate < mixpad->in_framerate) {
 293     mix->in_framerate = mixpad->in_framerate;
 294     mix->master = mixpad;
 295   }
 296
 297   return GST_PAD_LINK_OK;
 298 }
 299
 300 static void
 301 gst_videomixer_pad_link (GstPad * pad, GstPad * peer, gpointer data)
 302 {
 303   //GstVideoMixer *videomixer = GST_VIDEO_MIXER (data);
 304
 305   GST_DEBUG ("pad '%s' connected", gst_pad_get_name (pad));
 306 }
 307
 308 static void
 309 gst_videomixer_pad_unlink (GstPad * pad, GstPad * peer, gpointer data)
 310 {
 311   //GstVideoMixer *videomixer = GST_VIDEO_MIXER (data);
 312
 313   GST_DEBUG ("pad '%s' unlinked", gst_pad_get_name (pad));
 314 }
 315
 316 static void
 317 gst_videomixer_pad_init (GstVideoMixerPad * mixerpad)
 318 {
 319   g_signal_connect (mixerpad, "linked",
 320       G_CALLBACK (gst_videomixer_pad_link), (gpointer) mixerpad);
 321   g_signal_connect (mixerpad, "unlinked",
 322       G_CALLBACK (gst_videomixer_pad_unlink), (gpointer) mixerpad);
 323
 324   /* setup some pad functions */
 325   gst_pad_set_link_function (GST_PAD (mixerpad),
 326       gst_videomixer_pad_sinkconnect);
 327   gst_pad_set_event_mask_function (GST_PAD (mixerpad),
 328       gst_videomixer_pad_get_sink_event_masks);
 329
 330   mixerpad->zorder = DEFAULT_PAD_ZORDER;
 331   mixerpad->xpos = DEFAULT_PAD_XPOS;
 332   mixerpad->ypos = DEFAULT_PAD_YPOS;
 333   mixerpad->alpha = DEFAULT_PAD_ALPHA;
 334 }
 335
 336
 337
 338 /* elementfactory information */
 339 static GstElementDetails gst_videomixer_details =
 340 GST_ELEMENT_DETAILS ("video mixer",
 341     "Filter/Editor/Video",
 342     "Mix multiple video streams",
 343     "Wim Taymans <wim@fluendo.com>");
 344
 345 /* VideoMixer signals and args */
 346 enum
 347 {
 348   /* FILL ME */
 349   LAST_SIGNAL
 350 };
 351
 352 #define DEFAULT_BACKGROUND VIDEO_MIXER_BACKGROUND_CHECKER
 353 enum
 354 {
 355   ARG_0,
 356   ARG_BACKGROUND,
 357 };
 358
 359 #define GST_TYPE_VIDEO_MIXER_BACKGROUND (gst_video_mixer_background_get_type())
 360 static GType
 361 gst_video_mixer_background_get_type (void)
 362 {
 363   static GType video_mixer_background_type = 0;
 364   static GEnumValue video_mixer_background[] = {
 365     {VIDEO_MIXER_BACKGROUND_CHECKER, "0", "Checker pattern"},
 366     {VIDEO_MIXER_BACKGROUND_BLACK, "1", "Black"},
 367     {VIDEO_MIXER_BACKGROUND_WHITE, "2", "White"},
 368     {0, NULL, NULL},
 369   };
 370
 371   if (!video_mixer_background_type) {
 372     video_mixer_background_type =
 373         g_enum_register_static ("GstVideoMixerBackground",
 374         video_mixer_background);
 375   }
 376   return video_mixer_background_type;
 377 }
 378
 379 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
 380     GST_PAD_SRC,
 381     GST_PAD_ALWAYS,
 382     GST_STATIC_CAPS ("video/x-raw-yuv,"
 383         "format = (fourcc) I420,"
 384         "width = (int) [ 16, 4096 ],"
 385         "height = (int) [ 16, 4096 ]," "framerate = (double) [ 0, max ]")
 386     );
 387
 388 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink_%d",
 389     GST_PAD_SINK,
 390     GST_PAD_REQUEST,
 391     GST_STATIC_CAPS ("video/x-raw-yuv,"
 392         "format = (fourcc) AYUV,"
 393         "width = (int) [ 16, 4096 ],"
 394         "height = (int) [ 16, 4096 ]," "framerate = (double) [ 0, max ]")
 395     );
 396
 397 static void gst_videomixer_base_init (gpointer g_class);
 398 static void gst_videomixer_class_init (GstVideoMixerClass * klass);
 399 static void gst_videomixer_init (GstVideoMixer * videomixer);
 400
 401 static GstCaps *gst_videomixer_getcaps (GstPad * pad);
 402
 403 static void gst_videomixer_loop (GstElement * element);
 404 static gboolean gst_videomixer_handle_src_event (GstPad * pad,
 405     GstEvent * event);
 406 static GstPad *gst_videomixer_request_new_pad (GstElement * element,
 407     GstPadTemplate * templ, const gchar * name);
 408 static void gst_videomixer_set_property (GObject * object, guint prop_id,
 409     const GValue * value, GParamSpec * pspec);
 410 static void gst_videomixer_get_property (GObject * object, guint prop_id,
 411     GValue * value, GParamSpec * pspec);
 412 static GstElementStateReturn gst_videomixer_change_state (GstElement * element);
 413
 414 static GstElementClass *parent_class = NULL;
 415
 416 /*static guint gst_videomixer_signals[LAST_SIGNAL] = { 0 }; */
 417
 418 static GType
 419 gst_videomixer_get_type (void)
 420 {
 421   static GType videomixer_type = 0;
 422
 423   if (!videomixer_type) {
 424     static const GTypeInfo videomixer_info = {
 425       sizeof (GstVideoMixerClass),
 426       gst_videomixer_base_init,
 427       NULL,
 428       (GClassInitFunc) gst_videomixer_class_init,
 429       NULL,
 430       NULL,
 431       sizeof (GstVideoMixer),
 432       0,
 433       (GInstanceInitFunc) gst_videomixer_init,
 434     };
 435
 436     videomixer_type =
 437         g_type_register_static (GST_TYPE_ELEMENT, "GstVideoMixer",
 438         &videomixer_info, 0);
 439   }
 440   return videomixer_type;
 441 }
 442
 443 static void
 444 gst_videomixer_base_init (gpointer g_class)
 445 {
 446   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 447
 448   gst_element_class_add_pad_template (element_class,
 449       gst_static_pad_template_get (&src_factory));
 450   gst_element_class_add_pad_template (element_class,
 451       gst_static_pad_template_get (&sink_factory));
 452
 453   gst_element_class_set_details (element_class, &gst_videomixer_details);
 454 }
 455
 456 static void
 457 gst_videomixer_class_init (GstVideoMixerClass * klass)
 458 {
 459   GObjectClass *gobject_class;
 460   GstElementClass *gstelement_class;
 461
 462   gobject_class = (GObjectClass *) klass;
 463   gstelement_class = (GstElementClass *) klass;
 464
 465   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 466
 467   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BACKGROUND,
 468       g_param_spec_enum ("background", "Background", "Background type",
 469           GST_TYPE_VIDEO_MIXER_BACKGROUND,
 470           DEFAULT_BACKGROUND, G_PARAM_READWRITE));
 471
 472   gstelement_class->request_new_pad = gst_videomixer_request_new_pad;
 473
 474   gstelement_class->change_state = gst_videomixer_change_state;
 475
 476   gstelement_class->get_property = gst_videomixer_get_property;
 477   gstelement_class->set_property = gst_videomixer_set_property;
 478 }
 479
 480 static void
 481 gst_videomixer_init (GstVideoMixer * mix)
 482 {
 483   GstElementClass *klass = GST_ELEMENT_GET_CLASS (mix);
 484
 485   mix->srcpad =
 486       gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
 487           "src"), "src");
 488   gst_pad_set_getcaps_function (GST_PAD (mix->srcpad), gst_videomixer_getcaps);
 489   gst_pad_set_event_function (mix->srcpad, gst_videomixer_handle_src_event);
 490   gst_element_add_pad (GST_ELEMENT (mix), mix->srcpad);
 491
 492   GST_FLAG_SET (GST_ELEMENT (mix), GST_ELEMENT_EVENT_AWARE);
 493
 494   mix->sinkpads = NULL;
 495   mix->background = DEFAULT_BACKGROUND;
 496   mix->in_width = 0;
 497   mix->in_height = 0;
 498   mix->out_width = 0;
 499   mix->out_height = 0;
 500
 501   gst_element_set_loop_function (GST_ELEMENT (mix), gst_videomixer_loop);
 502 }
 503
 504 static GstCaps *
 505 gst_videomixer_getcaps (GstPad * pad)
 506 {
 507   GstVideoMixer *mix;
 508   GstCaps *caps;
 509   GstPadTemplate *src_pad_template;
 510   GstStructure *structure;
 511
 512
 513   mix = GST_VIDEO_MIXER (gst_pad_get_parent (pad));
 514   src_pad_template = gst_static_pad_template_get (&src_factory);
 515   caps = gst_caps_copy (gst_pad_template_get_caps (src_pad_template));
 516
 517   structure = gst_caps_get_structure (caps, 0);
 518
 519   if (mix->out_width != 0) {
 520     gst_structure_set (structure, "width", G_TYPE_INT, mix->out_width, NULL);
 521   }
 522   if (mix->out_height != 0) {
 523     gst_structure_set (structure, "height", G_TYPE_INT, mix->out_height, NULL);
 524   }
 525   if (mix->in_framerate != 0) {
 526     gst_structure_set (structure,
 527         "framerate", G_TYPE_DOUBLE, mix->in_framerate, NULL);
 528   }
 529
 530   return caps;
 531 }
 532
 533 static GstPad *
 534 gst_videomixer_request_new_pad (GstElement * element,
 535     GstPadTemplate * templ, const gchar * req_name)
 536 {
 537   GstVideoMixer *mix;
 538   GstPad *newpad;
 539   GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
 540
 541   g_return_val_if_fail (templ != NULL, NULL);
 542
 543   if (templ->direction != GST_PAD_SINK) {
 544     g_warning ("videomixer: request pad that is not a SINK pad\n");
 545     return NULL;
 546   }
 547
 548   g_return_val_if_fail (GST_IS_VIDEO_MIXER (element), NULL);
 549
 550   mix = GST_VIDEO_MIXER (element);
 551
 552   if (templ == gst_element_class_get_pad_template (klass, "sink_%d")) {
 553     gchar *name;
 554     GstVideoMixerPad *mixpad;
 555
 556     /* create new pad with the name */
 557     name = g_strdup_printf ("sink_%02d", mix->numpads);
 558     newpad =
 559         gst_pad_custom_new_from_template (GST_TYPE_VIDEO_MIXER_PAD, templ,
 560         name);
 561     g_free (name);
 562
 563     mixpad = GST_VIDEO_MIXER_PAD (newpad);
 564
 565     mixpad->zorder = mix->numpads;
 566     mix->numpads++;
 567     mix->sinkpads = g_slist_append (mix->sinkpads, newpad);
 568   } else {
 569     g_warning ("videomixer: this is not our template!\n");
 570     return NULL;
 571   }
 572
 573   /* dd the pad to the element */
 574   gst_element_add_pad (element, newpad);
 575
 576   return newpad;
 577 }
 578
 579 /* handle events */
 580 static gboolean
 581 gst_videomixer_handle_src_event (GstPad * pad, GstEvent * event)
 582 {
 583   GstVideoMixer *mix;
 584   GstEventType type;
 585
 586   mix = GST_VIDEO_MIXER (gst_pad_get_parent (pad));
 587
 588   type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
 589
 590   switch (type) {
 591     case GST_EVENT_SEEK:
 592       /* disable seeking for now */
 593       return FALSE;
 594     default:
 595       break;
 596   }
 597
 598   return gst_pad_event_default (pad, event);
 599 }
 600
 601 #define BLEND_NORMAL(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)     \
 602         Y = ((Y1*(255-alpha))+(Y2*alpha))>>8;           \
 603         U = ((U1*(255-alpha))+(U2*alpha))>>8;           \
 604         V = ((V1*(255-alpha))+(V2*alpha))>>8;
 605
 606 #define BLEND_ADD(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)                \
 607         Y = Y1+((Y2*alpha)>>8);                                 \
 608         U = U1+(((127*(255-alpha)+(U2*alpha)))>>8)-127;         \
 609         V = V1+(((127*(255-alpha)+(V2*alpha)))>>8)-127;         \
 610         if (Y>255) {                                            \
 611           gint mult = MAX (0, 288-Y);                           \
 612           U = ((U*mult) + (127*(32-mult)))>>5;                  \
 613           V = ((V*mult) + (127*(32-mult)))>>5;                  \
 614           Y = 255;                                              \
 615         }                                                       \
 616         U = MIN (U,255);                                        \
 617         V = MIN (V,255);
 618
 619 #define BLEND_SUBTRACT(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)           \
 620         Y = Y1-((Y2*alpha)>>8);                                 \
 621         U = U1+(((127*(255-alpha)+(U2*alpha)))>>8)-127;         \
 622         V = V1+(((127*(255-alpha)+(V2*alpha)))>>8)-127;         \
 623         if (Y<0) {                                              \
 624           gint mult = MIN (32, -Y);                             \
 625           U = ((U*(32-mult)) + (127*mult))>>5;                  \
 626           V = ((V*(32-mult)) + (127*mult))>>5;                  \
 627           Y = 0;                                                \
 628         }
 629
 630 #define BLEND_DARKEN(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)     \
 631         if (Y1 < Y2) {                                  \
 632           Y = Y1; U = U1; V = V1;                       \
 633         }                                               \
 634         else {                                          \
 635           Y = ((Y1*(255-alpha))+(Y2*alpha))>>8;         \
 636           U = ((U1*(255-alpha))+(U2*alpha))>>8;         \
 637           V = ((V1*(255-alpha))+(V2*alpha))>>8;         \
 638         }
 639
 640 #define BLEND_LIGHTEN(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)    \
 641         if (Y1 > Y2) {                                  \
 642           Y = Y1; U = U1; V = V1;                       \
 643         }                                               \
 644         else {                                          \
 645           Y = ((Y1*(255-alpha))+(Y2*alpha))>>8;         \
 646           U = ((U1*(255-alpha))+(U2*alpha))>>8;         \
 647           V = ((V1*(255-alpha))+(V2*alpha))>>8;         \
 648         }
 649
 650 #define BLEND_MULTIPLY(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)                   \
 651         Y = (Y1*(256*(255-alpha) +(Y2*alpha)))>>16;                     \
 652         U = ((U1*(255-alpha)*256)+(alpha*(U1*Y2+128*(256-Y2))))>>16;    \
 653         V = ((V1*(255-alpha)*256)+(alpha*(V1*Y2+128*(256-Y2))))>>16;
 654
 655 #define BLEND_DIFFERENCE(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)         \
 656         Y = ABS((gint)Y1-(gint)Y2)+127;                         \
 657         U = ABS((gint)U1-(gint)U2)+127;                         \
 658         V = ABS((gint)V1-(gint)V2)+127;                         \
 659         Y = ((Y*alpha)+(Y1*(255-alpha)))>>8;                    \
 660         U = ((U*alpha)+(U1*(255-alpha)))>>8;                    \
 661         V = ((V*alpha)+(V1*(255-alpha)))>>8;                    \
 662         if (Y>255) {                                            \
 663           gint mult = MAX (0, 288-Y);                           \
 664           U = ((U*mult) + (127*(32-mult)))>>5;                  \
 665           V = ((V*mult) + (127*(32-mult)))>>5;                  \
 666           Y = 255;                                              \
 667         } else if (Y<0) {                                       \
 668           gint mult = MIN (32, -Y);                             \
 669           U = ((U*(32-mult)) + (127*mult))>>5;                  \
 670           V = ((V*(32-mult)) + (127*mult))>>5;                  \
 671           Y = 0;                                                \
 672         }                                                       \
 673         U = CLAMP(U, 0, 255);                                   \
 674         V = CLAMP(V, 0, 255);
 675
 676 #define BLEND_EXCLUSION(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)          \
 677         Y = ((gint)(Y1^0xff)*Y2+(gint)(Y2^0xff)*Y1)>>8;         \
 678         U = ((gint)(U1^0xff)*Y2+(gint)(Y2^0xff)*U1)>>8;         \
 679         V = ((gint)(V1^0xff)*Y2+(gint)(Y2^0xff)*V1)>>8;         \
 680         Y = ((Y*alpha)+(Y1*(255-alpha)))>>8;                    \
 681         U = ((U*alpha)+(U1*(255-alpha)))>>8;                    \
 682         V = ((V*alpha)+(V1*(255-alpha)))>>8;                    \
 683         if (Y>255) {                                            \
 684           gint mult = MAX (0, 288-Y);                           \
 685           U = ((U*mult) + (127*(32-mult)))>>5;                  \
 686           V = ((V*mult) + (127*(32-mult)))>>5;                  \
 687           Y = 255;                                              \
 688         } else if (Y<0) {                                       \
 689           gint mult = MIN (32, -Y);                             \
 690           U = ((U*(32-mult)) + (127*mult))>>5;                  \
 691           V = ((V*(32-mult)) + (127*mult))>>5;                  \
 692           Y = 0;                                                \
 693         }                                                       \
 694         U = CLAMP(U, 0, 255);                                   \
 695         V = CLAMP(V, 0, 255);
 696
 697 #define BLEND_SOFTLIGHT(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)          \
 698         Y = (gint)Y1+(gint)Y2 - 127;                            \
 699         U = (gint)U1+(gint)U2 - 127;                            \
 700         V = (gint)V1+(gint)V2 - 127;                            \
 701         Y = ((Y*alpha)+(Y1*(255-alpha)))>>8;                    \
 702         U = ((U*alpha)+(U1*(255-alpha)))>>8;                    \
 703         V = ((V*alpha)+(V1*(255-alpha)))>>8;                    \
 704         if (Y>255) {                                            \
 705           gint mult = MAX (0, 288-Y);                           \
 706           U = ((U*mult) + (127*(32-mult)))>>5;                  \
 707           V = ((V*mult) + (127*(32-mult)))>>5;                  \
 708           Y = 255;                                              \
 709         } else if (Y<0) {                                       \
 710           gint mult = MIN (32, -Y);                             \
 711           U = ((U*(32-mult)) + (127*mult))>>5;                  \
 712           V = ((V*(32-mult)) + (127*mult))>>5;                  \
 713           Y = 0;                                                \
 714         }                                                       \
 715
 716 #define BLEND_HARDLIGHT(Y1,U1,V1,Y2,U2,V2,alpha,Y,U,V)          \
 717         Y = (gint)Y1+(gint)Y2*2 - 255;                          \
 718         U = (gint)U1+(gint)U2 - 127;                            \
 719         V = (gint)V1+(gint)V2 - 127;                            \
 720         Y = ((Y*alpha)+(Y1*(255-alpha)))>>8;                    \
 721         U = ((U*alpha)+(U1*(255-alpha)))>>8;                    \
 722         V = ((V*alpha)+(V1*(255-alpha)))>>8;                    \
 723         if (Y>255) {                                            \
 724           gint mult = MAX (0, 288-Y);                           \
 725           U = ((U*mult) + (127*(32-mult)))>>5;                  \
 726           V = ((V*mult) + (127*(32-mult)))>>5;                  \
 727           Y = 255;                                              \
 728         } else if (Y<0) {                                       \
 729           gint mult = MIN (32, -Y);                             \
 730           U = ((U*(32-mult)) + (127*mult))>>5;                  \
 731           V = ((V*(32-mult)) + (127*mult))>>5;                  \
 732           Y = 0;                                                \
 733         }                                                       \
 734
 735 #define BLEND_MODE BLEND_NORMAL
 736 #if 0
 737 #define BLEND_MODE BLEND_NORMAL
 738 #define BLEND_MODE BLEND_ADD
 739 #define BLEND_MODE BLEND_SUBTRACT
 740 #define BLEND_MODE BLEND_LIGHTEN
 741 #define BLEND_MODE BLEND_DARKEN
 742 #define BLEND_MODE BLEND_MULTIPLY
 743 #define BLEND_MODE BLEND_DIFFERENCE
 744 #define BLEND_MODE BLEND_EXCLUSION
 745 #define BLEND_MODE BLEND_SOFTLIGHT
 746 #define BLEND_MODE BLEND_HARDLIGHT
 747 #endif
 748
 749 #define ROUND_UP_2(x) (((x) + 1) & ~1)
 750 #define ROUND_UP_4(x) (((x) + 3) & ~3)
 751 #define ROUND_UP_8(x) (((x) + 7) & ~7)
 752
 753 /* note that this function does packing conversion and blending at the
 754  * same time */
 755 static void
 756 gst_videomixer_blend_ayuv_i420 (guint8 * src, gint xpos, gint ypos,
 757     gint src_width, gint src_height, gdouble src_alpha,
 758     guint8 * dest, gint dest_width, gint dest_height)
 759 {
 760   gint dest_size, dest_size2;
 761   gint alpha, b_alpha;
 762   guint8 *destY1, *destY2, *destU, *destV;
 763   gint accumU;
 764   gint accumV;
 765   gint i, j;
 766   gint src_stride;
 767   gint src_add, destY_add, destC_add;
 768   guint8 *src1, *src2;
 769   gint Y, U, V;
 770   gint dest_stride, dest_stride2;
 771
 772   src_stride = ROUND_UP_2 (src_width) * 4;
 773
 774   dest_stride = ROUND_UP_4 (dest_width);
 775   dest_size = dest_stride * ROUND_UP_2 (dest_height);
 776   dest_stride2 = ROUND_UP_8 (dest_width) / 2;
 777   dest_size2 = dest_stride2 * ROUND_UP_2 (dest_height) / 2;
 778
 779   b_alpha = (gint) (src_alpha * 255);
 780
 781   /* adjust src pointers for negative sizes */
 782   if (xpos < 0) {
 783     src += -xpos * 4;
 784     src_width -= -xpos;
 785     xpos = 0;
 786   }
 787   if (ypos < 0) {
 788     src += -ypos * src_stride;
 789     src_height -= -ypos;
 790     ypos = 0;
 791   }
 792   /* adjust width/height if the src is bigger than dest */
 793   if (xpos + src_width > dest_width) {
 794     src_width = dest_width - xpos;
 795   }
 796   if (ypos + src_height > dest_height) {
 797     src_height = dest_height - ypos;
 798   }
 799
 800   src_add = 2 * src_stride - (8 * ROUND_UP_2 (src_width) / 2);
 801   destY_add = 2 * dest_stride - (2 * (ROUND_UP_2 (src_width) / 2));
 802   destC_add = dest_stride2 - (ROUND_UP_2 (src_width) / 2);
 803
 804   destY1 = dest + xpos + (ypos * dest_stride);
 805   destY2 = destY1 + dest_stride;
 806   destU = dest + dest_size + (xpos / 2) + ((ypos / 2) * dest_stride2);
 807   destV = destU + dest_size2;
 808
 809   src1 = src;
 810   src2 = src + src_stride;
 811
 812   /* we convert a square of 2x2 samples to generate 4 Luma and 2 chroma samples */
 813   for (i = 0; i < ROUND_UP_2 (src_height) / 2; i++) {
 814     for (j = 0; j < ROUND_UP_2 (src_width) / 2; j++) {
 815       alpha = (src1[0] * b_alpha) >> 8;
 816       BLEND_MODE (destY1[0], destU[0], destV[0], src1[1], src1[2], src1[3],
 817           alpha, Y, U, V);
 818       destY1[0] = Y;
 819       accumU = U;
 820       accumV = V;
 821       alpha = (src1[4] * b_alpha) >> 8;
 822       BLEND_MODE (destY1[1], destU[0], destV[0], src1[5], src1[6], src1[7],
 823           alpha, Y, U, V);
 824       destY1[1] = Y;
 825       accumU += U;
 826       accumV += V;
 827       alpha = (src2[0] * b_alpha) >> 8;
 828       BLEND_MODE (destY2[0], destU[0], destV[0], src2[1], src2[2], src2[3],
 829           alpha, Y, U, V);
 830       destY2[0] = Y;
 831       accumU += U;
 832       accumV += V;
 833       alpha = (src2[4] * b_alpha) >> 8;
 834       BLEND_MODE (destY2[1], destU[0], destV[0], src2[5], src2[6], src2[7],
 835           alpha, Y, U, V);
 836       destY2[1] = Y;
 837       accumU += U;
 838       accumV += V;
 839
 840       /* take the average of the 4 chroma samples to get the final value */
 841       destU[0] = (accumU + 2) >> 2;
 842       destV[0] = (accumV + 2) >> 2;
 843
 844       src1 += 8;
 845       src2 += 8;
 846       destY1 += 2;
 847       destY2 += 2;
 848       destU += 1;
 849       destV += 1;
 850     }
 851     src1 += src_add;
 852     src2 += src_add;
 853     destY1 += destY_add;
 854     destY2 += destY_add;
 855     destU += destC_add;
 856     destV += destC_add;
 857   }
 858 }
 859
 860 #undef BLEND_MODE
 861
 862 static int
 863 pad_zorder_compare (const GstVideoMixerPad * pad1,
 864     const GstVideoMixerPad * pad2)
 865 {
 866   return pad1->zorder - pad2->zorder;
 867 }
 868
 869 static void
 870 gst_videomixer_sort_pads (GstVideoMixer * mix)
 871 {
 872   mix->sinkpads = g_slist_sort (mix->sinkpads,
 873       (GCompareFunc) pad_zorder_compare);
 874 }
 875
 876 /* fill a buffer with a checkerboard pattern */
 877 static void
 878 gst_videomixer_fill_checker (guint8 * dest, gint width, gint height)
 879 {
 880   gint size, size2;
 881   gint stride;
 882   gint i, j;
 883   static int tab[] = { 80, 160, 80, 160 };
 884
 885   stride = ROUND_UP_4 (width);
 886   size = stride * height;
 887   size2 = ROUND_UP_4 ((width + 1) >> 1) * ((height + 1) >> 1);
 888
 889   for (i = 0; i < height; i++) {
 890     for (j = 0; j < stride; j++) {
 891       *dest++ = tab[((i & 0x8) >> 3) + ((j & 0x8) >> 3)];
 892     }
 893   }
 894   memset (dest, 128, 2 * size2);
 895 }
 896
 897 static void
 898 gst_videomixer_fill_color (guint8 * dest, gint width, gint height,
 899     gint colY, gint colU, gint colV)
 900 {
 901   gint size, size2;
 902
 903   size = ROUND_UP_4 (width) * height;
 904   size2 = ROUND_UP_4 ((width + 1) >> 1) * ((height + 1) >> 1);
 905
 906   memset (dest, colY, size);
 907   memset (dest + size, colU, size2);
 908   memset (dest + size + size2, colV, size2);
 909 }
 910
 911 /* try to get a buffer on all pads. As long as the queued value is
 912  * negative, we skip buffers */
 913 static gboolean
 914 gst_videomixer_fill_queues (GstVideoMixer * mix)
 915 {
 916   GSList *walk;
 917   gboolean eos = TRUE;
 918
 919   /* loop over all pads and fill it with a buffer */
 920   walk = mix->sinkpads;
 921   while (walk) {
 922     GstVideoMixerPad *pad = GST_VIDEO_MIXER_PAD (walk->data);
 923
 924     walk = g_slist_next (walk);
 925
 926     GST_DEBUG ("looking at pad %s", gst_pad_get_name (GST_PAD (pad)));
 927
 928     /* don't care about eos pads */
 929     if (pad->eos) {
 930       GST_DEBUG ("pad %s in eos, skipping", gst_pad_get_name (GST_PAD (pad)));
 931       continue;
 932     }
 933
 934     GST_DEBUG ("pad %s: buffer %p, queued %lld  ",
 935         gst_pad_get_name (GST_PAD (pad)), pad->buffer, pad->queued);
 936
 937     /* this pad is in need of a new buffer */
 938     if (pad->buffer == NULL) {
 939       GstData *data;
 940       GstBuffer *buffer;
 941
 942       /* as long as not enough buffers have been queued */
 943       while (pad->queued <= 0 && !pad->eos) {
 944         data = gst_pad_pull (GST_PAD (pad));
 945         if (GST_IS_EVENT (data)) {
 946           GstEvent *event = GST_EVENT (data);
 947
 948           switch (GST_EVENT_TYPE (event)) {
 949             case GST_EVENT_EOS:
 950               GST_DEBUG ("videomixer: EOS on pad %s",
 951                   gst_pad_get_name (GST_PAD (pad)));
 952               /* mark pad eos */
 953               pad->eos = TRUE;
 954               gst_event_unref (event);
 955               break;
 956             default:
 957               gst_pad_event_default (GST_PAD (pad), GST_EVENT (data));
 958           }
 959         } else {
 960           guint64 duration;
 961
 962           buffer = GST_BUFFER (data);
 963           duration = GST_BUFFER_DURATION (buffer);
 964           /* no duration on the buffer, use the framerate */
 965           if (duration == -1) {
 966             if (pad->in_framerate == 0.0) {
 967               duration = G_MAXINT64;
 968             } else {
 969               duration = GST_SECOND / pad->in_framerate;
 970             }
 971           }
 972           pad->queued += duration;
 973           /* this buffer will need to be mixed */
 974           if (pad->queued > 0) {
 975             pad->buffer = buffer;
 976           } else {
 977             /* skip buffer, it's too old */
 978             gst_buffer_unref (buffer);
 979           }
 980         }
 981         GST_DEBUG ("pad %s: in loop, buffer %p, queued %lld  ",
 982             gst_pad_get_name (GST_PAD (pad)), pad->buffer, pad->queued);
 983       }
 984     }
 985     if (pad->buffer != NULL) {
 986       /* got a buffer somewhere so were not eos */
 987       eos = FALSE;
 988     }
 989   }
 990   return eos;
 991 }
 992
 993 /* blend all buffers present on the pads */
 994 static void
 995 gst_videomixer_blend_buffers (GstVideoMixer * mix, GstBuffer * outbuf)
 996 {
 997   GSList *walk;
 998
 999   walk = mix->sinkpads;
1000   while (walk) {
1001     GstVideoMixerPad *pad = GST_VIDEO_MIXER_PAD (walk->data);
1002
1003     walk = g_slist_next (walk);
1004
1005     if (pad->buffer != NULL) {
1006       gst_videomixer_blend_ayuv_i420 (GST_BUFFER_DATA (pad->buffer),
1007           pad->xpos, pad->ypos,
1008           pad->in_width, pad->in_height,
1009           pad->alpha,
1010           GST_BUFFER_DATA (outbuf), mix->out_width, mix->out_height);
1011       if (pad == mix->master) {
1012         GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (pad->buffer);
1013         GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (pad->buffer);
1014       }
1015     }
1016   }
1017 }
1018
1019 /* remove buffers from the queue that were expired in the
1020  * interval of the master, we also prepare the queued value
1021  * in the pad so that we can skip and fill buffers later on */
1022 static void
1023 gst_videomixer_update_queues (GstVideoMixer * mix)
1024 {
1025   GSList *walk;
1026   guint64 interval;
1027
1028   interval = mix->master->queued;
1029   if (interval <= 0) {
1030     if (mix->in_framerate == 0.0) {
1031       interval = G_MAXINT64;
1032     } else {
1033       interval = GST_SECOND / mix->in_framerate;
1034     }
1035   }
1036
1037   walk = mix->sinkpads;
1038   while (walk) {
1039     GstVideoMixerPad *pad = GST_VIDEO_MIXER_PAD (walk->data);
1040
1041     walk = g_slist_next (walk);
1042
1043     if (pad->buffer != NULL) {
1044       pad->queued -= interval;
1045       GST_DEBUG ("queued now %s %lld", gst_pad_get_name (GST_PAD (pad)),
1046           pad->queued);
1047       if (pad->queued <= 0) {
1048         gst_buffer_unref (pad->buffer);
1049         pad->buffer = NULL;
1050       }
1051     }
1052   }
1053 }
1054
1055 /*
1056  * The basic idea is to get a buffer on all pads and mix them together.
1057  * Based on the framerate, buffers are removed from the queues to make room
1058  * for a new buffer.
1059  */
1060 static void
1061 gst_videomixer_loop (GstElement * element)
1062 {
1063   GstVideoMixer *mix;
1064   GstBuffer *outbuf;
1065   gint outsize;
1066   gint new_width, new_height;
1067   gboolean eos;
1068
1069   mix = GST_VIDEO_MIXER (element);
1070
1071   eos = gst_videomixer_fill_queues (mix);
1072   if (eos) {
1073     gst_pad_push (mix->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
1074     gst_element_set_eos (GST_ELEMENT (mix));
1075     return;
1076   }
1077
1078   new_width = mix->in_width;
1079   new_height = mix->in_height;
1080
1081   if (new_width != mix->out_width ||
1082       new_height != mix->out_height || !GST_PAD_CAPS (mix->srcpad)) {
1083     GstCaps *newcaps;
1084
1085     newcaps =
1086         gst_caps_copy (gst_pad_get_negotiated_caps (GST_PAD (mix->master)));
1087     gst_caps_set_simple (newcaps, "format", GST_TYPE_FOURCC,
1088         GST_STR_FOURCC ("I420"), "width", G_TYPE_INT, new_width, "height",
1089         G_TYPE_INT, new_height, NULL);
1090
1091     if (GST_PAD_LINK_FAILED (gst_pad_try_set_caps (mix->srcpad, newcaps))) {
1092       GST_ELEMENT_ERROR (mix, CORE, NEGOTIATION, (NULL), (NULL));
1093       return;
1094     }
1095
1096     mix->out_width = new_width;
1097     mix->out_height = new_height;
1098   }
1099
1100   outsize = ROUND_UP_4 (mix->out_width) * ROUND_UP_2 (mix->out_height) +
1101       2 * ROUND_UP_8 (mix->out_width) / 2 * ROUND_UP_2 (mix->out_height);
1102
1103   outbuf = gst_pad_alloc_buffer (mix->srcpad, GST_BUFFER_OFFSET_NONE, outsize);
1104   switch (mix->background) {
1105     case VIDEO_MIXER_BACKGROUND_CHECKER:
1106       gst_videomixer_fill_checker (GST_BUFFER_DATA (outbuf),
1107           new_width, new_height);
1108       break;
1109     case VIDEO_MIXER_BACKGROUND_BLACK:
1110       gst_videomixer_fill_color (GST_BUFFER_DATA (outbuf),
1111           new_width, new_height, 16, 128, 128);
1112       break;
1113     case VIDEO_MIXER_BACKGROUND_WHITE:
1114       gst_videomixer_fill_color (GST_BUFFER_DATA (outbuf),
1115           new_width, new_height, 240, 128, 128);
1116       break;
1117   }
1118
1119   gst_videomixer_blend_buffers (mix, outbuf);
1120
1121   gst_videomixer_update_queues (mix);
1122
1123   gst_pad_push (mix->srcpad, GST_DATA (outbuf));
1124 }
1125
1126 static void
1127 gst_videomixer_get_property (GObject * object,
1128     guint prop_id, GValue * value, GParamSpec * pspec)
1129 {
1130   GstVideoMixer *mix = GST_VIDEO_MIXER (object);
1131
1132   switch (prop_id) {
1133     case ARG_BACKGROUND:
1134       g_value_set_enum (value, mix->background);
1135       break;
1136     default:
1137       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1138       break;
1139   }
1140 }
1141
1142 static void
1143 gst_videomixer_set_property (GObject * object,
1144     guint prop_id, const GValue * value, GParamSpec * pspec)
1145 {
1146   GstVideoMixer *mix = GST_VIDEO_MIXER (object);
1147
1148   switch (prop_id) {
1149     case ARG_BACKGROUND:
1150       mix->background = g_value_get_enum (value);
1151       break;
1152     default:
1153       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1154       break;
1155   }
1156 }
1157
1158 static GstElementStateReturn
1159 gst_videomixer_change_state (GstElement * element)
1160 {
1161   GstVideoMixer *mix;
1162   gint transition = GST_STATE_TRANSITION (element);
1163
1164   g_return_val_if_fail (GST_IS_VIDEO_MIXER (element), GST_STATE_FAILURE);
1165
1166   mix = GST_VIDEO_MIXER (element);
1167
1168   switch (transition) {
1169     case GST_STATE_NULL_TO_READY:
1170     case GST_STATE_READY_TO_PAUSED:
1171       break;
1172     case GST_STATE_PAUSED_TO_PLAYING:
1173     case GST_STATE_PLAYING_TO_PAUSED:
1174     case GST_STATE_PAUSED_TO_READY:
1175     case GST_STATE_READY_TO_NULL:
1176       break;
1177   }
1178
1179   if (GST_ELEMENT_CLASS (parent_class)->change_state)
1180     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
1181
1182   return GST_STATE_SUCCESS;
1183 }
1184
1185 static gboolean
1186 plugin_init (GstPlugin * plugin)
1187 {
1188   GST_DEBUG_CATEGORY_INIT (gst_videomixer_debug, "videomixer", 0,
1189       "video mixer");
1190
1191   return gst_element_register (plugin, "videomixer", GST_RANK_PRIMARY,
1192       GST_TYPE_VIDEO_MIXER);
1193 }
1194
1195 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1196     GST_VERSION_MINOR,
1197     "videomixer",
1198     "Video mixer", plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN)