subprojects/gst-plugins-good/ext/gtk/gstgtkglsink.c

   1 /*
   2  * GStreamer
   3  * Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-gtkglsink
  23  * @title: gtkglsink
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <gst/gl/gstglfuncs.h>
  31 #include <gst/video/gstvideoaffinetransformationmeta.h>
  32
  33 #include "gstgtkglsink.h"
  34 #include "gtkgstglwidget.h"
  35
  36 GST_DEBUG_CATEGORY (gst_debug_gtk_gl_sink);
  37 #define GST_CAT_DEFAULT gst_debug_gtk_gl_sink
  38
  39 static void gst_gtk_gl_sink_set_property (GObject * object, guint prop_id,
  40     const GValue * value, GParamSpec * pspec);
  41 static void gst_gtk_gl_sink_get_property (GObject * object, guint prop_id,
  42     GValue * value, GParamSpec * pspec);
  43
  44 static gboolean gst_gtk_gl_sink_start (GstBaseSink * bsink);
  45 static gboolean gst_gtk_gl_sink_stop (GstBaseSink * bsink);
  46 static gboolean gst_gtk_gl_sink_query (GstBaseSink * bsink, GstQuery * query);
  47 static gboolean gst_gtk_gl_sink_propose_allocation (GstBaseSink * bsink,
  48     GstQuery * query);
  49 static GstCaps *gst_gtk_gl_sink_get_caps (GstBaseSink * bsink,
  50     GstCaps * filter);
  51 static gboolean gst_gtk_gl_sink_event (GstBaseSink * sink, GstEvent * event);
  52
  53 static void gst_gtk_gl_sink_finalize (GObject * object);
  54
  55 static GstStaticPadTemplate gst_gtk_gl_sink_template =
  56     GST_STATIC_PAD_TEMPLATE ("sink",
  57     GST_PAD_SINK,
  58     GST_PAD_ALWAYS,
  59     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  60         (GST_CAPS_FEATURE_MEMORY_GL_MEMORY, "RGBA") "; "
  61         GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  62         (GST_CAPS_FEATURE_MEMORY_GL_MEMORY ", "
  63             GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, "RGBA")));
  64
  65 #define gst_gtk_gl_sink_parent_class parent_class
  66 G_DEFINE_TYPE_WITH_CODE (GstGtkGLSink, gst_gtk_gl_sink,
  67     GST_TYPE_GTK_BASE_SINK, GST_DEBUG_CATEGORY_INIT (gst_debug_gtk_gl_sink,
  68         "gtkglsink", 0, "Gtk GL Video Sink"));
  69 GST_ELEMENT_REGISTER_DEFINE (gtkglsink, "gtkglsink", GST_RANK_NONE,
  70     GST_TYPE_GTK_GL_SINK);
  71
  72
  73 enum
  74 {
  75   PROP_0,
  76   PROP_ROTATE_METHOD,
  77 };
  78
  79 static void
  80 gst_gtk_gl_sink_class_init (GstGtkGLSinkClass * klass)
  81 {
  82   GObjectClass *gobject_class;
  83   GstElementClass *gstelement_class;
  84   GstBaseSinkClass *gstbasesink_class;
  85   GstGtkBaseSinkClass *gstgtkbasesink_class;
  86
  87   gobject_class = (GObjectClass *) klass;
  88   gstelement_class = (GstElementClass *) klass;
  89   gstbasesink_class = (GstBaseSinkClass *) klass;
  90   gstgtkbasesink_class = (GstGtkBaseSinkClass *) klass;
  91
  92   gobject_class->set_property = gst_gtk_gl_sink_set_property;
  93   gobject_class->get_property = gst_gtk_gl_sink_get_property;
  94   gobject_class->finalize = gst_gtk_gl_sink_finalize;
  95
  96   gstbasesink_class->query = gst_gtk_gl_sink_query;
  97   gstbasesink_class->propose_allocation = gst_gtk_gl_sink_propose_allocation;
  98   gstbasesink_class->start = gst_gtk_gl_sink_start;
  99   gstbasesink_class->stop = gst_gtk_gl_sink_stop;
 100   gstbasesink_class->get_caps = gst_gtk_gl_sink_get_caps;
 101   gstbasesink_class->event = gst_gtk_gl_sink_event;
 102
 103   gstgtkbasesink_class->create_widget = gtk_gst_gl_widget_new;
 104   gstgtkbasesink_class->window_title = "Gtk+ GL renderer";
 105
 106   /**
 107    * gtkglsink:rotate-method:
 108    *
 109    * Rotation method #GstVideoOrientationMethod used to render the media
 110    *
 111    * Since: 1.20
 112    */
 113   g_object_class_install_property (gobject_class, PROP_ROTATE_METHOD,
 114       g_param_spec_enum ("rotate-method",
 115           "rotate method",
 116           "rotate method",
 117           GST_TYPE_VIDEO_ORIENTATION_METHOD, GST_VIDEO_ORIENTATION_IDENTITY,
 118           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 119
 120   gst_element_class_set_metadata (gstelement_class, "Gtk GL Video Sink",
 121       "Sink/Video", "A video sink that renders to a GtkWidget using OpenGL",
 122       "Matthew Waters <matthew@centricular.com>");
 123
 124   gst_element_class_add_static_pad_template (gstelement_class,
 125       &gst_gtk_gl_sink_template);
 126 }
 127
 128 static void
 129 gst_gtk_gl_sink_init (GstGtkGLSink * gtk_sink)
 130 {
 131 }
 132
 133 static void
 134 gst_gtk_gl_sink_set_property (GObject * object, guint prop_id,
 135     const GValue * value, GParamSpec * pspec)
 136 {
 137   switch (prop_id) {
 138     case PROP_ROTATE_METHOD:
 139       gtk_gst_gl_widget_set_rotate_method (GTK_GST_GL_WIDGET
 140           (gst_gtk_base_sink_acquire_widget (GST_GTK_BASE_SINK (object))),
 141           g_value_get_enum (value), FALSE);
 142       break;
 143
 144     default:
 145       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 146       break;
 147   }
 148 }
 149
 150
 151 static void
 152 gst_gtk_gl_sink_get_property (GObject * object, guint prop_id,
 153     GValue * value, GParamSpec * pspec)
 154 {
 155   switch (prop_id) {
 156     case PROP_ROTATE_METHOD:
 157       g_value_set_enum (value,
 158           gtk_gst_gl_widget_get_rotate_method (GTK_GST_GL_WIDGET
 159               (gst_gtk_base_sink_acquire_widget (GST_GTK_BASE_SINK (object)))));
 160       break;
 161
 162     default:
 163       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 164       break;
 165   }
 166 }
 167
 168 static gboolean
 169 gst_gtk_gl_sink_query (GstBaseSink * bsink, GstQuery * query)
 170 {
 171   GstGtkGLSink *gtk_sink = GST_GTK_GL_SINK (bsink);
 172   gboolean res = FALSE;
 173
 174   switch (GST_QUERY_TYPE (query)) {
 175     case GST_QUERY_CONTEXT:
 176     {
 177       if (gst_gl_handle_context_query ((GstElement *) gtk_sink, query,
 178               gtk_sink->display, gtk_sink->context, gtk_sink->gtk_context))
 179         return TRUE;
 180       break;
 181     }
 182     default:
 183       res = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
 184       break;
 185   }
 186
 187   return res;
 188 }
 189
 190 static void
 191 _size_changed_cb (GtkWidget * widget, GdkRectangle * rectangle,
 192     GstGtkGLSink * gtk_sink)
 193 {
 194   gint scale_factor, width, height;
 195   gboolean reconfigure;
 196
 197   scale_factor = gtk_widget_get_scale_factor (widget);
 198   width = scale_factor * gtk_widget_get_allocated_width (widget);
 199   height = scale_factor * gtk_widget_get_allocated_height (widget);
 200
 201   GST_OBJECT_LOCK (gtk_sink);
 202   reconfigure =
 203       (width != gtk_sink->display_width || height != gtk_sink->display_height);
 204   gtk_sink->display_width = width;
 205   gtk_sink->display_height = height;
 206   GST_OBJECT_UNLOCK (gtk_sink);
 207
 208   if (reconfigure) {
 209     GST_DEBUG_OBJECT (gtk_sink, "Sending reconfigure event on sinkpad.");
 210     gst_pad_push_event (GST_BASE_SINK (gtk_sink)->sinkpad,
 211         gst_event_new_reconfigure ());
 212   }
 213 }
 214
 215 static void
 216 destroy_cb (GtkWidget * widget, GstGtkGLSink * gtk_sink)
 217 {
 218   if (gtk_sink->size_allocate_sig_handler) {
 219     g_signal_handler_disconnect (widget, gtk_sink->size_allocate_sig_handler);
 220     gtk_sink->size_allocate_sig_handler = 0;
 221   }
 222
 223   if (gtk_sink->widget_destroy_sig_handler) {
 224     g_signal_handler_disconnect (widget, gtk_sink->widget_destroy_sig_handler);
 225     gtk_sink->widget_destroy_sig_handler = 0;
 226   }
 227 }
 228
 229 static gboolean
 230 gst_gtk_gl_sink_start (GstBaseSink * bsink)
 231 {
 232   GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (bsink);
 233   GstGtkGLSink *gtk_sink = GST_GTK_GL_SINK (bsink);
 234   GtkGstGLWidget *gst_widget;
 235
 236   if (!GST_BASE_SINK_CLASS (parent_class)->start (bsink))
 237     return FALSE;
 238
 239   /* After this point, gtk_sink->widget will always be set */
 240   gst_widget = GTK_GST_GL_WIDGET (base_sink->widget);
 241
 242   /* Track the allocation size */
 243   gtk_sink->size_allocate_sig_handler =
 244       g_signal_connect (gst_widget, "size-allocate",
 245       G_CALLBACK (_size_changed_cb), gtk_sink);
 246
 247   gtk_sink->widget_destroy_sig_handler =
 248       g_signal_connect (gst_widget, "destroy", G_CALLBACK (destroy_cb),
 249       gtk_sink);
 250
 251   _size_changed_cb (GTK_WIDGET (gst_widget), NULL, gtk_sink);
 252
 253   if (!gtk_gst_gl_widget_init_winsys (gst_widget)) {
 254     GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s",
 255             "Failed to initialize OpenGL with Gtk"), (NULL));
 256     return FALSE;
 257   }
 258
 259   gtk_sink->display = gtk_gst_gl_widget_get_display (gst_widget);
 260   gtk_sink->context = gtk_gst_gl_widget_get_context (gst_widget);
 261   gtk_sink->gtk_context = gtk_gst_gl_widget_get_gtk_context (gst_widget);
 262
 263   if (!gtk_sink->display || !gtk_sink->context || !gtk_sink->gtk_context) {
 264     GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s",
 265             "Failed to retrieve OpenGL context from Gtk"), (NULL));
 266     return FALSE;
 267   }
 268
 269   gst_gl_element_propagate_display_context (GST_ELEMENT (bsink),
 270       gtk_sink->display);
 271
 272   return TRUE;
 273 }
 274
 275 static gboolean
 276 gst_gtk_gl_sink_stop (GstBaseSink * bsink)
 277 {
 278   GstGtkGLSink *gtk_sink = GST_GTK_GL_SINK (bsink);
 279
 280   if (gtk_sink->display) {
 281     gst_object_unref (gtk_sink->display);
 282     gtk_sink->display = NULL;
 283   }
 284
 285   if (gtk_sink->context) {
 286     gst_object_unref (gtk_sink->context);
 287     gtk_sink->context = NULL;
 288   }
 289
 290   if (gtk_sink->gtk_context) {
 291     gst_object_unref (gtk_sink->gtk_context);
 292     gtk_sink->gtk_context = NULL;
 293   }
 294
 295   return GST_BASE_SINK_CLASS (parent_class)->stop (bsink);
 296 }
 297
 298 static gboolean
 299 gst_gtk_gl_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
 300 {
 301   GstGtkGLSink *gtk_sink = GST_GTK_GL_SINK (bsink);
 302   GstBufferPool *pool = NULL;
 303   GstStructure *config;
 304   GstCaps *caps;
 305   GstVideoInfo info;
 306   guint size;
 307   gboolean need_pool;
 308   GstStructure *allocation_meta = NULL;
 309   gint display_width, display_height;
 310
 311   if (!gtk_sink->display || !gtk_sink->context)
 312     return FALSE;
 313
 314   gst_query_parse_allocation (query, &caps, &need_pool);
 315
 316   if (caps == NULL)
 317     goto no_caps;
 318
 319   if (!gst_video_info_from_caps (&info, caps))
 320     goto invalid_caps;
 321
 322   /* the normal size of a frame */
 323   size = info.size;
 324
 325   if (need_pool) {
 326     GST_DEBUG_OBJECT (gtk_sink, "create new pool");
 327     pool = gst_gl_buffer_pool_new (gtk_sink->context);
 328
 329     config = gst_buffer_pool_get_config (pool);
 330     gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
 331     gst_buffer_pool_config_add_option (config,
 332         GST_BUFFER_POOL_OPTION_GL_SYNC_META);
 333
 334     if (!gst_buffer_pool_set_config (pool, config))
 335       goto config_failed;
 336   }
 337
 338   /* we need at least 2 buffer because we hold on to the last one */
 339   gst_query_add_allocation_pool (query, pool, size, 2, 0);
 340   if (pool)
 341     gst_object_unref (pool);
 342
 343   GST_OBJECT_LOCK (gtk_sink);
 344   display_width = gtk_sink->display_width;
 345   display_height = gtk_sink->display_height;
 346   GST_OBJECT_UNLOCK (gtk_sink);
 347
 348   if (display_width != 0 && display_height != 0) {
 349     GST_DEBUG_OBJECT (gtk_sink, "sending alloc query with size %dx%d",
 350         display_width, display_height);
 351     allocation_meta = gst_structure_new ("GstVideoOverlayCompositionMeta",
 352         "width", G_TYPE_UINT, display_width,
 353         "height", G_TYPE_UINT, display_height, NULL);
 354   }
 355
 356   gst_query_add_allocation_meta (query,
 357       GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, allocation_meta);
 358
 359   if (allocation_meta)
 360     gst_structure_free (allocation_meta);
 361
 362   /* we also support various metadata */
 363   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, 0);
 364   gst_query_add_allocation_meta (query,
 365       GST_VIDEO_AFFINE_TRANSFORMATION_META_API_TYPE, 0);
 366
 367   if (gtk_sink->context->gl_vtable->FenceSync)
 368     gst_query_add_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, 0);
 369
 370   return TRUE;
 371
 372   /* ERRORS */
 373 no_caps:
 374   {
 375     GST_DEBUG_OBJECT (bsink, "no caps specified");
 376     return FALSE;
 377   }
 378 invalid_caps:
 379   {
 380     GST_DEBUG_OBJECT (bsink, "invalid caps specified");
 381     return FALSE;
 382   }
 383 config_failed:
 384   {
 385     GST_DEBUG_OBJECT (bsink, "failed setting config");
 386     return FALSE;
 387   }
 388 }
 389
 390 static GstCaps *
 391 gst_gtk_gl_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
 392 {
 393   GstCaps *tmp = NULL;
 394   GstCaps *result = NULL;
 395
 396   tmp = gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD (bsink));
 397
 398   if (filter) {
 399     GST_DEBUG_OBJECT (bsink, "intersecting with filter caps %" GST_PTR_FORMAT,
 400         filter);
 401
 402     result = gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
 403     gst_caps_unref (tmp);
 404   } else {
 405     result = tmp;
 406   }
 407
 408   result = gst_gl_overlay_compositor_add_caps (result);
 409
 410   GST_DEBUG_OBJECT (bsink, "returning caps: %" GST_PTR_FORMAT, result);
 411
 412   return result;
 413 }
 414
 415 static void
 416 gst_gtk_gl_sink_finalize (GObject * object)
 417 {
 418   GstGtkGLSink *gtk_sink = GST_GTK_GL_SINK (object);
 419   GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (object);
 420
 421   if (gtk_sink->size_allocate_sig_handler) {
 422     g_signal_handler_disconnect (base_sink->widget,
 423         gtk_sink->size_allocate_sig_handler);
 424     gtk_sink->size_allocate_sig_handler = 0;
 425   }
 426
 427   if (gtk_sink->widget_destroy_sig_handler) {
 428     g_signal_handler_disconnect (base_sink->widget,
 429         gtk_sink->widget_destroy_sig_handler);
 430     gtk_sink->widget_destroy_sig_handler = 0;
 431   }
 432
 433   G_OBJECT_CLASS (parent_class)->finalize (object);
 434 }
 435
 436
 437 static gboolean
 438 gst_gtk_gl_sink_event (GstBaseSink * sink, GstEvent * event)
 439 {
 440   GstTagList *taglist;
 441   GstVideoOrientationMethod orientation;
 442   gboolean ret;
 443   GtkGstGLWidget *widget;
 444
 445   GST_DEBUG_OBJECT (sink, "handling %s event", GST_EVENT_TYPE_NAME (event));
 446
 447   switch (GST_EVENT_TYPE (event)) {
 448     case GST_EVENT_TAG:
 449       gst_event_parse_tag (event, &taglist);
 450
 451       if (gst_video_orientation_from_tag (taglist, &orientation)) {
 452
 453         widget = GTK_GST_GL_WIDGET
 454             (gst_gtk_base_sink_acquire_widget (GST_GTK_BASE_SINK (sink)));
 455
 456         gtk_gst_gl_widget_set_rotate_method (widget, orientation, TRUE);
 457       }
 458       break;
 459     default:
 460       break;
 461   }
 462
 463   ret = GST_BASE_SINK_CLASS (parent_class)->event (sink, event);
 464
 465   return ret;
 466 }