libempathy-gtk/empathy-video-widget.c

   1 /*
   2  * empathy-gst-gtk-widget.c - Source for EmpathyVideoWidget
   3  * Copyright (C) 2008 Collabora Ltd.
   4  * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <gdk/gdkx.h>
  26 #include <gst/interfaces/xoverlay.h>
  27 #include <gst/farsight/fs-element-added-notifier.h>
  28
  29 #include "empathy-video-widget.h"
  30
  31 G_DEFINE_TYPE(EmpathyVideoWidget, empathy_video_widget,
  32   GTK_TYPE_DRAWING_AREA)
  33
  34 static void empathy_video_widget_element_added_cb (
  35   FsElementAddedNotifier *notifier, GstBin *bin, GstElement *element,
  36   EmpathyVideoWidget *self);
  37
  38 static void empathy_video_widget_sync_message_cb (
  39   GstBus *bus, GstMessage *message, EmpathyVideoWidget *self);
  40
  41 /* signal enum */
  42 #if 0
  43 enum
  44 {
  45     LAST_SIGNAL
  46 };
  47
  48 static guint signals[LAST_SIGNAL] = {0};
  49 #endif
  50
  51 enum {
  52   PROP_GST_ELEMENT = 1,
  53   PROP_GST_BUS,
  54   PROP_MIN_WIDTH,
  55   PROP_MIN_HEIGHT,
  56   PROP_SYNC,
  57   PROP_ASYNC,
  58 };
  59
  60 /* private structure */
  61 typedef struct _EmpathyVideoWidgetPriv EmpathyVideoWidgetPriv;
  62
  63 struct _EmpathyVideoWidgetPriv
  64 {
  65   gboolean dispose_has_run;
  66   GstBus *bus;
  67   GstElement *videosink;
  68   GstPad *sink_pad;
  69   GstElement *overlay;
  70   FsElementAddedNotifier *notifier;
  71   gint min_width;
  72   gint min_height;
  73   gboolean sync;
  74   gboolean async;
  75
  76   GMutex *lock;
  77 };
  78
  79 #define GET_PRIV(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
  80   EMPATHY_TYPE_VIDEO_WIDGET, EmpathyVideoWidgetPriv))
  81
  82 static void
  83 empathy_video_widget_init (EmpathyVideoWidget *obj)
  84 {
  85   EmpathyVideoWidgetPriv *priv = GET_PRIV (obj);
  86   GdkColor black;
  87
  88   priv->lock = g_mutex_new ();
  89
  90   priv->notifier = fs_element_added_notifier_new ();
  91   g_signal_connect (priv->notifier, "element-added",
  92     G_CALLBACK (empathy_video_widget_element_added_cb),
  93     obj);
  94
  95   if (gdk_color_parse ("Black", &black))
  96     gtk_widget_modify_bg (GTK_WIDGET (obj), GTK_STATE_NORMAL,
  97       &black);
  98
  99   gtk_widget_set_double_buffered (GTK_WIDGET (obj), FALSE);
 100 }
 101
 102 static void
 103 empathy_video_widget_realized (GtkWidget *widget, gpointer user_data)
 104 {
 105   /* requesting the XID forces the GdkWindow to be native in GTK+ 2.18
 106    * onwards, requesting the native window in a thread causes a BadWindowID,
 107    * so we need to request it now. We could call gdk_window_ensure_native(),
 108    * but that would mean we require GTK+ 2.18, so instead we call this */
 109   GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (widget)));
 110 }
 111
 112 static void
 113 empathy_video_widget_constructed (GObject *object)
 114 {
 115   EmpathyVideoWidgetPriv *priv = GET_PRIV (object);
 116   GstElement *colorspace, *videoscale, *sink;
 117   GstPad *pad;
 118
 119   g_signal_connect (object, "realize",
 120       G_CALLBACK (empathy_video_widget_realized), NULL);
 121
 122   priv->videosink = gst_bin_new (NULL);
 123
 124   gst_object_ref (priv->videosink);
 125   gst_object_sink (priv->videosink);
 126
 127   priv->sink_pad = gst_element_get_static_pad (priv->videosink, "sink");
 128
 129   sink = gst_element_factory_make ("gconfvideosink", NULL);
 130   g_assert (sink != NULL);
 131
 132   videoscale = gst_element_factory_make ("videoscale", NULL);
 133   g_assert (videoscale != NULL);
 134
 135   g_object_set (videoscale, "qos", FALSE, NULL);
 136
 137   colorspace = gst_element_factory_make ("ffmpegcolorspace", NULL);
 138   g_assert (colorspace != NULL);
 139
 140   g_object_set (colorspace, "qos", FALSE, NULL);
 141
 142   gst_bin_add_many (GST_BIN (priv->videosink), colorspace, videoscale,
 143     sink, NULL);
 144
 145   if (!gst_element_link (colorspace, videoscale))
 146     g_error ("Failed to link ffmpegcolorspace and videoscale");
 147
 148   if (!gst_element_link (videoscale, sink))
 149     g_error ("Failed to link videoscale and gconfvideosink");
 150
 151   pad = gst_element_get_static_pad (colorspace, "sink");
 152   g_assert (pad != NULL);
 153
 154   priv->sink_pad = gst_ghost_pad_new ("sink", pad);
 155   if (!gst_element_add_pad  (priv->videosink, priv->sink_pad))
 156     g_error ("Couldn't add sink ghostpad to the bin");
 157
 158   gst_object_unref (pad);
 159
 160   fs_element_added_notifier_add (priv->notifier, GST_BIN (priv->videosink));
 161   gst_bus_enable_sync_message_emission (priv->bus);
 162
 163   g_signal_connect (priv->bus, "sync-message",
 164     G_CALLBACK (empathy_video_widget_sync_message_cb), object);
 165
 166   gtk_widget_set_size_request (GTK_WIDGET (object), priv->min_width,
 167     priv->min_height);
 168 }
 169
 170 static void empathy_video_widget_dispose (GObject *object);
 171 static void empathy_video_widget_finalize (GObject *object);
 172
 173
 174 static gboolean empathy_video_widget_draw (GtkWidget *widget,
 175   cairo_t *cr);
 176
 177 static void
 178 empathy_video_widget_element_set_sink_properties (EmpathyVideoWidget *self);
 179
 180 static void
 181 empathy_video_widget_set_property (GObject *object,
 182   guint property_id, const GValue *value, GParamSpec *pspec)
 183 {
 184   EmpathyVideoWidgetPriv *priv = GET_PRIV (object);
 185
 186   switch (property_id)
 187     {
 188       case PROP_GST_BUS:
 189         priv->bus = g_value_dup_object (value);
 190         break;
 191       case PROP_MIN_WIDTH:
 192         priv->min_width = g_value_get_int (value);
 193         break;
 194       case PROP_MIN_HEIGHT:
 195         priv->min_height = g_value_get_int (value);
 196         break;
 197       case PROP_SYNC:
 198         priv->sync = g_value_get_boolean (value);
 199         empathy_video_widget_element_set_sink_properties (
 200           EMPATHY_VIDEO_WIDGET (object));
 201         break;
 202       case PROP_ASYNC:
 203         priv->async = g_value_get_boolean (value);
 204         empathy_video_widget_element_set_sink_properties (
 205           EMPATHY_VIDEO_WIDGET (object));
 206         break;
 207       default:
 208         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 209     }
 210 }
 211
 212 static void
 213 empathy_video_widget_get_property (GObject *object,
 214   guint property_id, GValue *value, GParamSpec *pspec)
 215 {
 216   EmpathyVideoWidgetPriv *priv = GET_PRIV (object);
 217
 218   switch (property_id)
 219     {
 220       case PROP_GST_ELEMENT:
 221         g_value_set_object (value, priv->videosink);
 222         break;
 223       case PROP_GST_BUS:
 224         g_value_set_object (value, priv->bus);
 225         break;
 226       case PROP_MIN_WIDTH:
 227         g_value_set_int (value, priv->min_width);
 228         break;
 229       case PROP_MIN_HEIGHT:
 230         g_value_set_int (value, priv->min_height);
 231         break;
 232       case PROP_SYNC:
 233         g_value_set_boolean (value, priv->sync);
 234         break;
 235       case PROP_ASYNC:
 236         g_value_set_boolean (value, priv->async);
 237         break;
 238       default:
 239         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 240     }
 241 }
 242
 243
 244 static void
 245 empathy_video_widget_class_init (
 246   EmpathyVideoWidgetClass *empathy_video_widget_class)
 247 {
 248   GObjectClass *object_class = G_OBJECT_CLASS (empathy_video_widget_class);
 249   GtkWidgetClass *widget_class =
 250     GTK_WIDGET_CLASS (empathy_video_widget_class);
 251   GParamSpec *param_spec;
 252
 253   g_type_class_add_private (empathy_video_widget_class,
 254     sizeof (EmpathyVideoWidgetPriv));
 255
 256   object_class->dispose = empathy_video_widget_dispose;
 257   object_class->finalize = empathy_video_widget_finalize;
 258   object_class->constructed = empathy_video_widget_constructed;
 259
 260   object_class->set_property = empathy_video_widget_set_property;
 261   object_class->get_property = empathy_video_widget_get_property;
 262
 263   widget_class->draw = empathy_video_widget_draw;
 264
 265   param_spec = g_param_spec_object ("gst-element",
 266     "gst-element", "The underlaying gstreamer element",
 267     GST_TYPE_ELEMENT,
 268     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 269   g_object_class_install_property (object_class, PROP_GST_ELEMENT, param_spec);
 270
 271   param_spec = g_param_spec_object ("gst-bus",
 272     "gst-bus",
 273     "The toplevel bus from the pipeline in which this bin will be added",
 274     GST_TYPE_BUS,
 275     G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 276   g_object_class_install_property (object_class, PROP_GST_BUS, param_spec);
 277
 278   param_spec = g_param_spec_int ("min-width",
 279     "min-width",
 280     "Minimal width of the widget",
 281     0, G_MAXINT, EMPATHY_VIDEO_WIDGET_DEFAULT_WIDTH,
 282     G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 283   g_object_class_install_property (object_class, PROP_MIN_WIDTH, param_spec);
 284
 285   param_spec = g_param_spec_int ("min-height",
 286     "min-height",
 287     "Minimal height of the widget",
 288     0, G_MAXINT, EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT,
 289     G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 290   g_object_class_install_property (object_class, PROP_MIN_HEIGHT, param_spec);
 291
 292   param_spec = g_param_spec_boolean ("sync",
 293     "sync",
 294     "Whether the underlying sink should be sync or not",
 295     TRUE,
 296     G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 297   g_object_class_install_property (object_class, PROP_SYNC, param_spec);
 298
 299   param_spec = g_param_spec_boolean ("async",
 300     "async",
 301     "Whether the underlying sink should be async or not",
 302     TRUE,
 303     G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 304   g_object_class_install_property (object_class, PROP_ASYNC, param_spec);
 305 }
 306
 307 void
 308 empathy_video_widget_dispose (GObject *object)
 309 {
 310   EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (object);
 311   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 312
 313   if (priv->dispose_has_run)
 314     return;
 315
 316   priv->dispose_has_run = TRUE;
 317
 318   g_signal_handlers_disconnect_by_func (priv->bus,
 319     empathy_video_widget_sync_message_cb, object);
 320
 321   if (priv->bus != NULL)
 322     g_object_unref (priv->bus);
 323
 324   priv->bus = NULL;
 325
 326   if (priv->videosink != NULL)
 327     g_object_unref (priv->videosink);
 328
 329   priv->videosink = NULL;
 330
 331
 332   /* release any references held by the object here */
 333
 334   if (G_OBJECT_CLASS (empathy_video_widget_parent_class)->dispose)
 335     G_OBJECT_CLASS (empathy_video_widget_parent_class)->dispose (object);
 336 }
 337
 338 void
 339 empathy_video_widget_finalize (GObject *object)
 340 {
 341   EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (object);
 342   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 343
 344   /* free any data held directly by the object here */
 345   g_mutex_free (priv->lock);
 346
 347   G_OBJECT_CLASS (empathy_video_widget_parent_class)->finalize (object);
 348 }
 349
 350
 351 static void
 352 empathy_video_widget_element_set_sink_properties_unlocked (
 353   EmpathyVideoWidget *self)
 354 {
 355   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 356
 357   if (priv->overlay == NULL)
 358     return;
 359
 360   if (g_object_class_find_property (G_OBJECT_GET_CLASS (priv->overlay),
 361       "force-aspect-ratio"))
 362     g_object_set (G_OBJECT (priv->overlay), "force-aspect-ratio", TRUE, NULL);
 363
 364   if (g_object_class_find_property (
 365       G_OBJECT_GET_CLASS (priv->overlay), "sync"))
 366     g_object_set (G_OBJECT (priv->overlay), "sync", priv->sync, NULL);
 367
 368   if (g_object_class_find_property (G_OBJECT_GET_CLASS (priv->overlay),
 369       "async"))
 370     g_object_set (G_OBJECT (priv->overlay), "async", priv->async, NULL);
 371 }
 372
 373 static void
 374 empathy_video_widget_element_set_sink_properties (EmpathyVideoWidget *self)
 375 {
 376   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 377
 378   g_mutex_lock (priv->lock);
 379   empathy_video_widget_element_set_sink_properties_unlocked (self);
 380   g_mutex_unlock (priv->lock);
 381 }
 382
 383 static void
 384 empathy_video_widget_element_added_cb (FsElementAddedNotifier *notifier,
 385   GstBin *bin, GstElement *element, EmpathyVideoWidget *self)
 386 {
 387   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 388
 389   /* We assume the overlay is the sink */
 390   g_mutex_lock (priv->lock);
 391   if (priv->overlay == NULL && GST_IS_X_OVERLAY (element))
 392     {
 393       priv->overlay = element;
 394       g_object_add_weak_pointer (G_OBJECT (element),
 395         (gpointer) &priv->overlay);
 396       empathy_video_widget_element_set_sink_properties_unlocked (self);
 397       gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay));
 398     }
 399   g_mutex_unlock (priv->lock);
 400 }
 401
 402 static void
 403 empathy_video_widget_sync_message_cb (GstBus *bus, GstMessage *message,
 404   EmpathyVideoWidget *self)
 405 {
 406   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 407   const GstStructure *s;
 408
 409   if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)
 410     return;
 411
 412   if (GST_MESSAGE_SRC (message) != (GstObject *) priv->overlay)
 413     return;
 414
 415   s = gst_message_get_structure (message);
 416
 417   if (gst_structure_has_name (s, "prepare-xwindow-id"))
 418     {
 419       g_assert (gtk_widget_get_realized (GTK_WIDGET (self)));
 420       gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),
 421         GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (self))));
 422     }
 423 }
 424
 425 static gboolean
 426 empathy_video_widget_draw (GtkWidget *widget,
 427     cairo_t *cr)
 428 {
 429   EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (widget);
 430   EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
 431   GtkAllocation allocation;
 432
 433   if (priv->overlay == NULL)
 434     {
 435       gtk_widget_get_allocation (widget, &allocation);
 436
 437       gtk_paint_flat_box (gtk_widget_get_style (widget), cr,
 438           GTK_STATE_NORMAL, GTK_SHADOW_NONE, widget, NULL,
 439           0, 0,
 440           gtk_widget_get_allocated_width (widget),
 441           gtk_widget_get_allocated_height (widget));
 442       return TRUE;
 443     }
 444
 445   gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),
 446     GDK_WINDOW_XID (gtk_widget_get_window (widget)));
 447
 448   gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay));
 449
 450   return TRUE;
 451 }
 452
 453 GtkWidget *
 454 empathy_video_widget_new_with_size (GstBus *bus, gint width, gint height)
 455 {
 456   g_return_val_if_fail (bus != NULL, NULL);
 457
 458   return GTK_WIDGET (g_object_new (EMPATHY_TYPE_VIDEO_WIDGET,
 459     "gst-bus", bus,
 460     "min-width", width,
 461     "min-height", height,
 462     NULL));
 463 }
 464
 465 GtkWidget *
 466 empathy_video_widget_new (GstBus *bus)
 467 {
 468   g_return_val_if_fail (bus != NULL, NULL);
 469
 470   return GTK_WIDGET (g_object_new (EMPATHY_TYPE_VIDEO_WIDGET,
 471     "gst-bus", bus,
 472     NULL));
 473 }
 474
 475 GstPad *
 476 empathy_video_widget_get_sink (EmpathyVideoWidget *widget)
 477 {
 478   EmpathyVideoWidgetPriv *priv = GET_PRIV (widget);
 479
 480   return priv->sink_pad;
 481 }
 482
 483 GstElement *
 484 empathy_video_widget_get_element (EmpathyVideoWidget *widget)
 485 {
 486   EmpathyVideoWidgetPriv *priv = GET_PRIV (widget);
 487
 488   return priv->videosink;
 489 }