ext/gtk/gtkgstglwidget.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 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <stdio.h>
  26
  27 #include "gtkgstglwidget.h"
  28 #include <gst/video/video.h>
  29
  30 #if GST_GL_HAVE_WINDOW_X11 && defined (GDK_WINDOWING_X11)
  31 #include <gdk/gdkx.h>
  32 #include <gst/gl/x11/gstgldisplay_x11.h>
  33 #include <gst/gl/x11/gstglcontext_glx.h>
  34 #endif
  35
  36 #if GST_GL_HAVE_WINDOW_WAYLAND && defined (GDK_WINDOWING_WAYLAND)
  37 #include <gdk/gdkwayland.h>
  38 #include <gst/gl/wayland/gstgldisplay_wayland.h>
  39 #endif
  40
  41 /**
  42  * SECTION:gtkgstglwidget
  43  * @short_description: a #GtkGLArea that renders GStreamer video #GstBuffers
  44  * @see_also: #GtkGLArea, #GstBuffer
  45  *
  46  * #GtkGstGLWidget is an #GtkWidget that renders GStreamer video buffers.
  47  */
  48
  49 #define GST_CAT_DEFAULT gtk_gst_gl_widget_debug
  50 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
  51
  52 G_DEFINE_TYPE_WITH_CODE (GtkGstGLWidget, gtk_gst_gl_widget, GTK_TYPE_GL_AREA,
  53     GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "gtkgstglwidget", 0,
  54         "Gtk Gst GL Widget"););
  55
  56 #define GTK_GST_GL_WIDGET_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
  57     GTK_TYPE_GST_GL_WIDGET, GtkGstGLWidgetPrivate))
  58
  59 #define DEFAULT_FORCE_ASPECT_RATIO  TRUE
  60 #define DEFAULT_PAR_N               0
  61 #define DEFAULT_PAR_D               1
  62 #define DEFAULT_IGNORE_ALPHA        TRUE
  63
  64 enum
  65 {
  66   PROP_0,
  67   PROP_FORCE_ASPECT_RATIO,
  68   PROP_PIXEL_ASPECT_RATIO,
  69   PROP_IGNORE_ALPHA,
  70 };
  71
  72 struct _GtkGstGLWidgetPrivate
  73 {
  74   GMutex lock;
  75
  76   /* properties */
  77   gboolean force_aspect_ratio;
  78   gint par_n, par_d;
  79   gboolean ignore_alpha;
  80
  81   gint display_width;
  82   gint display_height;
  83
  84   gboolean negotiated;
  85   GstBuffer *buffer;
  86   GstCaps *gl_caps;
  87   GstCaps *caps;
  88   GstVideoInfo v_info;
  89   gboolean new_buffer;
  90
  91   gboolean initted;
  92   GstGLDisplay *display;
  93   GdkGLContext *gdk_context;
  94   GstGLContext *other_context;
  95   GstGLContext *context;
  96   GstGLUpload *upload;
  97   GstGLShader *shader;
  98   GLuint vao;
  99   GLuint vertex_buffer;
 100   GLint attr_position;
 101   GLint attr_texture;
 102   GLuint current_tex;
 103 };
 104
 105 static void
 106 gtk_gst_gl_widget_get_preferred_width (GtkWidget * widget, gint * min,
 107     gint * natural)
 108 {
 109   GtkGstGLWidget *gst_widget = (GtkGstGLWidget *) widget;
 110   gint video_width = gst_widget->priv->display_width;
 111
 112   if (!gst_widget->priv->negotiated)
 113     video_width = 10;
 114
 115   if (min)
 116     *min = 1;
 117   if (natural)
 118     *natural = video_width;
 119 }
 120
 121 static void
 122 gtk_gst_gl_widget_get_preferred_height (GtkWidget * widget, gint * min,
 123     gint * natural)
 124 {
 125   GtkGstGLWidget *gst_widget = (GtkGstGLWidget *) widget;
 126   gint video_height = gst_widget->priv->display_height;
 127
 128   if (!gst_widget->priv->negotiated)
 129     video_height = 10;
 130
 131   if (min)
 132     *min = 1;
 133   if (natural)
 134     *natural = video_height;
 135 }
 136
 137 static const GLfloat vertices[] = {
 138   1.0f, 1.0f, 0.0f, 1.0f, 0.0f,
 139   -1.0f, 1.0f, 0.0f, 0.0f, 0.0f,
 140   -1.0f, -1.0f, 0.0f, 0.0f, 1.0f,
 141   1.0f, -1.0f, 0.0f, 1.0f, 1.0f
 142 };
 143
 144 static void
 145 gtk_gst_gl_widget_bind_buffer (GtkGstGLWidget * gst_widget)
 146 {
 147   const GstGLFuncs *gl = gst_widget->priv->context->gl_vtable;
 148
 149   gl->BindBuffer (GL_ARRAY_BUFFER, gst_widget->priv->vertex_buffer);
 150
 151   /* Load the vertex position */
 152   gl->VertexAttribPointer (gst_widget->priv->attr_position, 3, GL_FLOAT,
 153       GL_FALSE, 5 * sizeof (GLfloat), (void *) 0);
 154
 155   /* Load the texture coordinate */
 156   gl->VertexAttribPointer (gst_widget->priv->attr_texture, 2, GL_FLOAT,
 157       GL_FALSE, 5 * sizeof (GLfloat), (void *) (3 * sizeof (GLfloat)));
 158
 159   gl->EnableVertexAttribArray (gst_widget->priv->attr_position);
 160   gl->EnableVertexAttribArray (gst_widget->priv->attr_texture);
 161 }
 162
 163 static void
 164 gtk_gst_gl_widget_unbind_buffer (GtkGstGLWidget * gst_widget)
 165 {
 166   const GstGLFuncs *gl = gst_widget->priv->context->gl_vtable;
 167
 168   gl->BindBuffer (GL_ARRAY_BUFFER, 0);
 169
 170   gl->DisableVertexAttribArray (gst_widget->priv->attr_position);
 171   gl->DisableVertexAttribArray (gst_widget->priv->attr_texture);
 172 }
 173
 174 static void
 175 gtk_gst_gl_widget_init_redisplay (GtkGstGLWidget * gst_widget)
 176 {
 177   const GstGLFuncs *gl = gst_widget->priv->context->gl_vtable;
 178
 179   gst_widget->priv->shader = gst_gl_shader_new (gst_widget->priv->context);
 180
 181   gst_gl_shader_compile_with_default_vf_and_check
 182       (gst_widget->priv->shader, &gst_widget->priv->attr_position,
 183       &gst_widget->priv->attr_texture);
 184
 185   if (gl->GenVertexArrays) {
 186     gl->GenVertexArrays (1, &gst_widget->priv->vao);
 187     gl->BindVertexArray (gst_widget->priv->vao);
 188   }
 189
 190   gl->GenBuffers (1, &gst_widget->priv->vertex_buffer);
 191   gl->BindBuffer (GL_ARRAY_BUFFER, gst_widget->priv->vertex_buffer);
 192   gl->BufferData (GL_ARRAY_BUFFER, 4 * 5 * sizeof (GLfloat), vertices,
 193       GL_STATIC_DRAW);
 194
 195   if (gl->GenVertexArrays) {
 196     gtk_gst_gl_widget_bind_buffer (gst_widget);
 197     gl->BindVertexArray (0);
 198   }
 199
 200   gl->BindBuffer (GL_ARRAY_BUFFER, 0);
 201
 202   gst_widget->priv->initted = TRUE;
 203 }
 204
 205 static void
 206 _redraw_texture (GtkGstGLWidget * gst_widget, guint tex)
 207 {
 208   const GstGLFuncs *gl = gst_widget->priv->context->gl_vtable;
 209   GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
 210
 211   if (gst_widget->priv->force_aspect_ratio) {
 212     GstVideoRectangle src, dst, result;
 213     gint widget_width, widget_height, widget_scale;
 214
 215     gl->ClearColor (0.0, 0.0, 0.0, 0.0);
 216     gl->Clear (GL_COLOR_BUFFER_BIT);
 217
 218     widget_scale = gtk_widget_get_scale_factor ((GtkWidget *) gst_widget);
 219     widget_width = gtk_widget_get_allocated_width ((GtkWidget *) gst_widget);
 220     widget_height = gtk_widget_get_allocated_height ((GtkWidget *) gst_widget);
 221
 222     src.x = 0;
 223     src.y = 0;
 224     src.w = gst_widget->priv->display_width;
 225     src.h = gst_widget->priv->display_height;
 226
 227     dst.x = 0;
 228     dst.y = 0;
 229     dst.w = widget_width * widget_scale;
 230     dst.h = widget_height * widget_scale;
 231
 232     gst_video_sink_center_rect (src, dst, &result, TRUE);
 233
 234     gl->Viewport (result.x, result.y, result.w, result.h);
 235   }
 236
 237   gst_gl_shader_use (gst_widget->priv->shader);
 238
 239   if (gl->BindVertexArray)
 240     gl->BindVertexArray (gst_widget->priv->vao);
 241   else
 242     gtk_gst_gl_widget_bind_buffer (gst_widget);
 243
 244   gl->ActiveTexture (GL_TEXTURE0);
 245   gl->BindTexture (GL_TEXTURE_2D, tex);
 246   gst_gl_shader_set_uniform_1i (gst_widget->priv->shader, "tex", 0);
 247
 248   gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
 249
 250   if (gl->BindVertexArray)
 251     gl->BindVertexArray (0);
 252   else
 253     gtk_gst_gl_widget_unbind_buffer (gst_widget);
 254
 255   gl->BindTexture (GL_TEXTURE_2D, 0);
 256 }
 257
 258 static gboolean
 259 gtk_gst_gl_widget_render (GtkGLArea * widget, GdkGLContext * context)
 260 {
 261   GtkGstGLWidget *gst_widget = (GtkGstGLWidget *) widget;
 262
 263   g_mutex_lock (&gst_widget->priv->lock);
 264
 265   if (!gst_widget->priv->initted && gst_widget->priv->context)
 266     gtk_gst_gl_widget_init_redisplay (gst_widget);
 267
 268   if (gst_widget->priv->initted && gst_widget->priv->negotiated
 269       && gst_widget->priv->buffer) {
 270     GST_DEBUG ("rendering buffer %p with gdk context %p",
 271         gst_widget->priv->buffer, context);
 272
 273     gst_gl_context_activate (gst_widget->priv->other_context, TRUE);
 274
 275     if (gst_widget->priv->new_buffer || gst_widget->priv->current_tex == 0) {
 276       GstVideoFrame gl_frame;
 277       GstGLSyncMeta *sync_meta;
 278
 279       if (!gst_video_frame_map (&gl_frame, &gst_widget->priv->v_info,
 280               gst_widget->priv->buffer, GST_MAP_READ | GST_MAP_GL)) {
 281         goto error;
 282       }
 283
 284       sync_meta = gst_buffer_get_gl_sync_meta (gst_widget->priv->buffer);
 285       if (sync_meta) {
 286         gst_gl_sync_meta_set_sync_point (sync_meta, gst_widget->priv->context);
 287         gst_gl_sync_meta_wait (sync_meta, gst_widget->priv->other_context);
 288       }
 289
 290       gst_widget->priv->current_tex = *(guint *) gl_frame.data[0];
 291
 292       gst_video_frame_unmap (&gl_frame);
 293     }
 294
 295     _redraw_texture (gst_widget, gst_widget->priv->current_tex);
 296     gst_widget->priv->new_buffer = FALSE;
 297   } else {
 298   error:
 299     /* FIXME: nothing to display */
 300     glClearColor (0.0, 0.0, 0.0, 0.0);
 301     glClear (GL_COLOR_BUFFER_BIT);
 302   }
 303
 304   if (gst_widget->priv->other_context)
 305     gst_gl_context_activate (gst_widget->priv->other_context, FALSE);
 306
 307   g_mutex_unlock (&gst_widget->priv->lock);
 308   return FALSE;
 309 }
 310
 311 typedef void (*ThreadFunc) (gpointer data);
 312
 313 struct invoke_context
 314 {
 315   ThreadFunc func;
 316   gpointer data;
 317   GMutex lock;
 318   GCond cond;
 319   gboolean fired;
 320 };
 321
 322 static gboolean
 323 _invoke_func (struct invoke_context *info)
 324 {
 325   g_mutex_lock (&info->lock);
 326   info->func (info->data);
 327   info->fired = TRUE;
 328   g_cond_signal (&info->cond);
 329   g_mutex_unlock (&info->lock);
 330
 331   return G_SOURCE_REMOVE;
 332 }
 333
 334 static void
 335 _invoke_on_main (ThreadFunc func, gpointer data)
 336 {
 337   GMainContext *main_context = g_main_context_default ();
 338   struct invoke_context info;
 339
 340   g_mutex_init (&info.lock);
 341   g_cond_init (&info.cond);
 342   info.fired = FALSE;
 343   info.func = func;
 344   info.data = data;
 345
 346   g_main_context_invoke (main_context, (GSourceFunc) _invoke_func, &info);
 347
 348   g_mutex_lock (&info.lock);
 349   while (!info.fired)
 350     g_cond_wait (&info.cond, &info.lock);
 351   g_mutex_unlock (&info.lock);
 352
 353   g_mutex_clear (&info.lock);
 354   g_cond_clear (&info.cond);
 355 }
 356
 357 static void
 358 _reset_gl (GtkGstGLWidget * gst_widget)
 359 {
 360   const GstGLFuncs *gl = gst_widget->priv->other_context->gl_vtable;
 361
 362   if (!gst_widget->priv->gdk_context)
 363     gst_widget->priv->gdk_context =
 364         gtk_gl_area_get_context (GTK_GL_AREA (gst_widget));
 365   if (gst_widget->priv->gdk_context == NULL)
 366     return;
 367
 368   gdk_gl_context_make_current (gst_widget->priv->gdk_context);
 369   gst_gl_context_activate (gst_widget->priv->other_context, TRUE);
 370
 371   if (gst_widget->priv->vao) {
 372     gl->DeleteVertexArrays (1, &gst_widget->priv->vao);
 373     gst_widget->priv->vao = 0;
 374   }
 375
 376   if (gst_widget->priv->vertex_buffer) {
 377     gl->DeleteBuffers (1, &gst_widget->priv->vertex_buffer);
 378     gst_widget->priv->vertex_buffer = 0;
 379   }
 380
 381   if (gst_widget->priv->upload) {
 382     gst_object_unref (gst_widget->priv->upload);
 383     gst_widget->priv->upload = NULL;
 384   }
 385
 386   if (gst_widget->priv->shader) {
 387     gst_object_unref (gst_widget->priv->shader);
 388     gst_widget->priv->shader = NULL;
 389   }
 390
 391   gst_gl_context_activate (gst_widget->priv->other_context, FALSE);
 392
 393   gst_object_unref (gst_widget->priv->other_context);
 394   gst_widget->priv->other_context = NULL;
 395
 396   gdk_gl_context_clear_current ();
 397
 398   g_object_unref (gst_widget->priv->gdk_context);
 399   gst_widget->priv->gdk_context = NULL;
 400 }
 401
 402 static void
 403 _reset (GtkGstGLWidget * gst_widget)
 404 {
 405   gst_buffer_replace (&gst_widget->priv->buffer, NULL);
 406
 407   gst_caps_replace (&gst_widget->priv->caps, NULL);
 408   gst_caps_replace (&gst_widget->priv->gl_caps, NULL);
 409
 410   gst_widget->priv->negotiated = FALSE;
 411   gst_widget->priv->initted = FALSE;
 412   gst_widget->priv->vao = 0;
 413   gst_widget->priv->vertex_buffer = 0;
 414   gst_widget->priv->attr_position = 0;
 415   gst_widget->priv->attr_texture = 0;
 416   gst_widget->priv->current_tex = 0;
 417   gst_widget->priv->new_buffer = TRUE;
 418 }
 419
 420 static void
 421 gtk_gst_gl_widget_finalize (GObject * object)
 422 {
 423   GtkGstGLWidget *widget = GTK_GST_GL_WIDGET_CAST (object);
 424
 425   g_mutex_clear (&widget->priv->lock);
 426
 427   _reset (widget);
 428
 429   if (widget->priv->other_context) {
 430     _invoke_on_main ((ThreadFunc) _reset_gl, widget);
 431   }
 432
 433   if (widget->priv->context) {
 434     gst_object_unref (widget->priv->context);
 435     widget->priv->context = NULL;
 436   }
 437
 438   if (widget->priv->display) {
 439     gst_object_unref (widget->priv->display);
 440     widget->priv->display = NULL;
 441   }
 442
 443   G_OBJECT_CLASS (gtk_gst_gl_widget_parent_class)->finalize (object);
 444 }
 445
 446 static void
 447 gtk_gst_gl_widget_set_property (GObject * object, guint prop_id,
 448     const GValue * value, GParamSpec * pspec)
 449 {
 450   GtkGstGLWidget *gtk_widget = GTK_GST_GL_WIDGET (object);
 451
 452   switch (prop_id) {
 453     case PROP_FORCE_ASPECT_RATIO:
 454       gtk_widget->priv->force_aspect_ratio = g_value_get_boolean (value);
 455       break;
 456     case PROP_PIXEL_ASPECT_RATIO:
 457       gtk_widget->priv->par_n = gst_value_get_fraction_numerator (value);
 458       gtk_widget->priv->par_d = gst_value_get_fraction_denominator (value);
 459       break;
 460     case PROP_IGNORE_ALPHA:
 461       gtk_widget->priv->ignore_alpha = g_value_get_boolean (value);
 462       gtk_gl_area_set_has_alpha ((GtkGLArea *) gtk_widget,
 463           !gtk_widget->priv->ignore_alpha);
 464       break;
 465     default:
 466       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 467       break;
 468   }
 469 }
 470
 471 static void
 472 gtk_gst_gl_widget_get_property (GObject * object, guint prop_id, GValue * value,
 473     GParamSpec * pspec)
 474 {
 475   GtkGstGLWidget *gtk_widget = GTK_GST_GL_WIDGET (object);
 476
 477   switch (prop_id) {
 478     case PROP_FORCE_ASPECT_RATIO:
 479       g_value_set_boolean (value, gtk_widget->priv->force_aspect_ratio);
 480       break;
 481     case PROP_PIXEL_ASPECT_RATIO:
 482       gst_value_set_fraction (value, gtk_widget->priv->par_n,
 483           gtk_widget->priv->par_d);
 484       break;
 485     case PROP_IGNORE_ALPHA:
 486       g_value_set_boolean (value, gtk_widget->priv->ignore_alpha);
 487       break;
 488     default:
 489       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 490       break;
 491   }
 492 }
 493
 494 static void
 495 gtk_gst_gl_widget_class_init (GtkGstGLWidgetClass * klass)
 496 {
 497   GObjectClass *gobject_klass = (GObjectClass *) klass;
 498   GtkWidgetClass *widget_klass = (GtkWidgetClass *) klass;
 499   GtkGLAreaClass *gl_widget_klass = (GtkGLAreaClass *) klass;
 500
 501   g_type_class_add_private (klass, sizeof (GtkGstGLWidgetPrivate));
 502
 503   gobject_klass->set_property = gtk_gst_gl_widget_set_property;
 504   gobject_klass->get_property = gtk_gst_gl_widget_get_property;
 505   gobject_klass->finalize = gtk_gst_gl_widget_finalize;
 506
 507   g_object_class_install_property (gobject_klass, PROP_FORCE_ASPECT_RATIO,
 508       g_param_spec_boolean ("force-aspect-ratio",
 509           "Force aspect ratio",
 510           "When enabled, scaling will respect original aspect ratio",
 511           DEFAULT_FORCE_ASPECT_RATIO,
 512           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 513
 514   g_object_class_install_property (gobject_klass, PROP_PIXEL_ASPECT_RATIO,
 515       gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",
 516           "The pixel aspect ratio of the device", DEFAULT_PAR_N, DEFAULT_PAR_D,
 517           G_MAXINT, 1, 1, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 518
 519   g_object_class_install_property (gobject_klass, PROP_IGNORE_ALPHA,
 520       g_param_spec_boolean ("ignore-alpha", "Ignore Alpha",
 521           "When enabled, alpha will be ignored and converted to black",
 522           DEFAULT_IGNORE_ALPHA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 523
 524   gl_widget_klass->render = gtk_gst_gl_widget_render;
 525
 526   widget_klass->get_preferred_width = gtk_gst_gl_widget_get_preferred_width;
 527   widget_klass->get_preferred_height = gtk_gst_gl_widget_get_preferred_height;
 528 }
 529
 530 static void
 531 gtk_gst_gl_widget_init (GtkGstGLWidget * widget)
 532 {
 533   GdkDisplay *display;
 534
 535   widget->priv = GTK_GST_GL_WIDGET_GET_PRIVATE (widget);
 536
 537   widget->priv->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
 538   widget->priv->par_n = DEFAULT_PAR_N;
 539   widget->priv->par_d = DEFAULT_PAR_D;
 540   widget->priv->ignore_alpha = DEFAULT_IGNORE_ALPHA;
 541
 542   g_mutex_init (&widget->priv->lock);
 543
 544   display = gdk_display_get_default ();
 545
 546 #if GST_GL_HAVE_WINDOW_X11 && defined (GDK_WINDOWING_X11)
 547   if (GDK_IS_X11_DISPLAY (display))
 548     widget->priv->display = (GstGLDisplay *)
 549         gst_gl_display_x11_new_with_display (gdk_x11_display_get_xdisplay
 550         (display));
 551 #endif
 552 #if GST_GL_HAVE_WINDOW_WAYLAND && defined (GDK_WINDOWING_WAYLAND)
 553   if (GDK_IS_WAYLAND_DISPLAY (display)) {
 554     struct wl_display *wayland_display =
 555         gdk_wayland_display_get_wl_display (display);
 556     widget->priv->display = (GstGLDisplay *)
 557         gst_gl_display_wayland_new_with_display (wayland_display);
 558   }
 559 #endif
 560
 561   (void) display;
 562
 563   if (!widget->priv->display)
 564     widget->priv->display = gst_gl_display_new ();
 565
 566   gtk_gl_area_set_has_alpha ((GtkGLArea *) widget, !widget->priv->ignore_alpha);
 567 }
 568
 569 GtkWidget *
 570 gtk_gst_gl_widget_new (void)
 571 {
 572   return (GtkWidget *) g_object_new (GTK_TYPE_GST_GL_WIDGET, NULL);
 573 }
 574
 575 static gboolean
 576 _queue_draw (GtkGstGLWidget * widget)
 577 {
 578   gtk_widget_queue_draw (GTK_WIDGET (widget));
 579
 580   return G_SOURCE_REMOVE;
 581 }
 582
 583 void
 584 gtk_gst_gl_widget_set_buffer (GtkGstGLWidget * widget, GstBuffer * buffer)
 585 {
 586   GMainContext *main_context = g_main_context_default ();
 587
 588   g_return_if_fail (GTK_IS_GST_GL_WIDGET (widget));
 589   g_return_if_fail (widget->priv->negotiated);
 590
 591   g_mutex_lock (&widget->priv->lock);
 592
 593   gst_buffer_replace (&widget->priv->buffer, buffer);
 594   widget->priv->new_buffer = TRUE;
 595
 596   g_mutex_unlock (&widget->priv->lock);
 597
 598   g_main_context_invoke (main_context, (GSourceFunc) _queue_draw, widget);
 599 }
 600
 601 static void
 602 _get_gl_context (GtkGstGLWidget * gst_widget)
 603 {
 604   GstGLPlatform platform;
 605   GstGLAPI gl_api;
 606   guintptr gl_handle;
 607
 608   gtk_widget_realize (GTK_WIDGET (gst_widget));
 609
 610   if (gst_widget->priv->gdk_context)
 611     g_object_unref (gst_widget->priv->gdk_context);
 612   gst_widget->priv->gdk_context =
 613       gtk_gl_area_get_context (GTK_GL_AREA (gst_widget));
 614   if (gst_widget->priv->gdk_context == NULL) {
 615     g_assert_not_reached ();
 616     return;
 617   }
 618
 619   g_object_ref (gst_widget->priv->gdk_context);
 620
 621   gdk_gl_context_make_current (gst_widget->priv->gdk_context);
 622
 623 #if GST_GL_HAVE_WINDOW_X11 && defined (GDK_WINDOWING_X11)
 624   if (GST_IS_GL_DISPLAY_X11 (gst_widget->priv->display)) {
 625     platform = GST_GL_PLATFORM_GLX;
 626     gl_api = gst_gl_context_get_current_gl_api (NULL, NULL);
 627     gl_handle = gst_gl_context_get_current_gl_context (platform);
 628     if (gl_handle)
 629       gst_widget->priv->other_context =
 630           gst_gl_context_new_wrapped (gst_widget->priv->display, gl_handle,
 631           platform, gl_api);
 632   }
 633 #endif
 634 #if GST_GL_HAVE_WINDOW_WAYLAND && defined (GDK_WINDOWING_WAYLAND)
 635   if (GST_IS_GL_DISPLAY_WAYLAND (gst_widget->priv->display)) {
 636     platform = GST_GL_PLATFORM_EGL;
 637     gl_api = gst_gl_context_get_current_gl_api (NULL, NULL);
 638     gl_handle = gst_gl_context_get_current_gl_context (platform);
 639     if (gl_handle)
 640       gst_widget->priv->other_context =
 641           gst_gl_context_new_wrapped (gst_widget->priv->display, gl_handle,
 642           platform, gl_api);
 643   }
 644 #endif
 645
 646   (void) platform;
 647   (void) gl_api;
 648   (void) gl_handle;
 649
 650   if (gst_widget->priv->other_context) {
 651     GError *error = NULL;
 652
 653     gst_gl_context_activate (gst_widget->priv->other_context, TRUE);
 654     if (!gst_gl_context_fill_info (gst_widget->priv->other_context, &error)) {
 655       GST_ERROR ("failed to retreive gdk context info: %s", error->message);
 656       g_object_unref (gst_widget->priv->other_context);
 657       gst_widget->priv->other_context = NULL;
 658     } else {
 659       gst_gl_context_activate (gst_widget->priv->other_context, FALSE);
 660     }
 661   }
 662 }
 663
 664 static gboolean
 665 _queue_resize (GtkGstGLWidget * widget)
 666 {
 667   gtk_widget_queue_resize (GTK_WIDGET (widget));
 668
 669   return G_SOURCE_REMOVE;
 670 }
 671
 672 gboolean
 673 gtk_gst_gl_widget_init_winsys (GtkGstGLWidget * widget)
 674 {
 675   g_return_val_if_fail (GTK_IS_GST_GL_WIDGET (widget), FALSE);
 676
 677   g_mutex_lock (&widget->priv->lock);
 678
 679   if (widget->priv->display && widget->priv->gdk_context
 680       && widget->priv->other_context) {
 681     g_mutex_unlock (&widget->priv->lock);
 682     return TRUE;
 683   }
 684
 685   if (!widget->priv->other_context) {
 686     _invoke_on_main ((ThreadFunc) _get_gl_context, widget);
 687   }
 688
 689   if (!GST_GL_IS_CONTEXT (widget->priv->other_context)) {
 690     g_mutex_unlock (&widget->priv->lock);
 691     return FALSE;
 692   }
 693
 694   widget->priv->context = gst_gl_context_new (widget->priv->display);
 695
 696   if (!widget->priv->context) {
 697     g_mutex_unlock (&widget->priv->lock);
 698     return FALSE;
 699   }
 700
 701   gst_gl_context_create (widget->priv->context, widget->priv->other_context,
 702       NULL);
 703
 704   g_mutex_unlock (&widget->priv->lock);
 705   return TRUE;
 706 }
 707
 708 static gboolean
 709 _calculate_par (GtkGstGLWidget * widget, GstVideoInfo * info)
 710 {
 711   gboolean ok;
 712   gint width, height;
 713   gint par_n, par_d;
 714   gint display_par_n, display_par_d;
 715   guint display_ratio_num, display_ratio_den;
 716
 717   width = GST_VIDEO_INFO_WIDTH (info);
 718   height = GST_VIDEO_INFO_HEIGHT (info);
 719
 720   par_n = GST_VIDEO_INFO_PAR_N (info);
 721   par_d = GST_VIDEO_INFO_PAR_D (info);
 722
 723   if (!par_n)
 724     par_n = 1;
 725
 726   /* get display's PAR */
 727   if (widget->priv->par_n != 0 && widget->priv->par_d != 0) {
 728     display_par_n = widget->priv->par_n;
 729     display_par_d = widget->priv->par_d;
 730   } else {
 731     display_par_n = 1;
 732     display_par_d = 1;
 733   }
 734
 735   ok = gst_video_calculate_display_ratio (&display_ratio_num,
 736       &display_ratio_den, width, height, par_n, par_d, display_par_n,
 737       display_par_d);
 738
 739   if (!ok)
 740     return FALSE;
 741
 742   GST_LOG ("PAR: %u/%u DAR:%u/%u", par_n, par_d, display_par_n, display_par_d);
 743
 744   if (height % display_ratio_den == 0) {
 745     GST_DEBUG ("keeping video height");
 746     widget->priv->display_width = (guint)
 747         gst_util_uint64_scale_int (height, display_ratio_num,
 748         display_ratio_den);
 749     widget->priv->display_height = height;
 750   } else if (width % display_ratio_num == 0) {
 751     GST_DEBUG ("keeping video width");
 752     widget->priv->display_width = width;
 753     widget->priv->display_height = (guint)
 754         gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num);
 755   } else {
 756     GST_DEBUG ("approximating while keeping video height");
 757     widget->priv->display_width = (guint)
 758         gst_util_uint64_scale_int (height, display_ratio_num,
 759         display_ratio_den);
 760     widget->priv->display_height = height;
 761   }
 762   GST_DEBUG ("scaling to %dx%d", widget->priv->display_width,
 763       widget->priv->display_height);
 764
 765   return TRUE;
 766 }
 767
 768 gboolean
 769 gtk_gst_gl_widget_set_caps (GtkGstGLWidget * widget, GstCaps * caps)
 770 {
 771   GMainContext *main_context = g_main_context_default ();
 772   GstVideoInfo v_info;
 773
 774   g_return_val_if_fail (GTK_IS_GST_GL_WIDGET (widget), FALSE);
 775   g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
 776   g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE);
 777
 778   if (widget->priv->caps && gst_caps_is_equal_fixed (widget->priv->caps, caps))
 779     return TRUE;
 780
 781   if (!gst_video_info_from_caps (&v_info, caps))
 782     return FALSE;
 783
 784   g_mutex_lock (&widget->priv->lock);
 785
 786   _reset (widget);
 787
 788   gst_caps_replace (&widget->priv->caps, caps);
 789
 790   widget->priv->gl_caps = gst_video_info_to_caps (&v_info);
 791   gst_caps_set_features (widget->priv->gl_caps, 0,
 792       gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_GL_MEMORY));
 793
 794   if (!_calculate_par (widget, &v_info)) {
 795     g_mutex_unlock (&widget->priv->lock);
 796     return FALSE;
 797   }
 798
 799   widget->priv->v_info = v_info;
 800   widget->priv->negotiated = TRUE;
 801
 802   g_mutex_unlock (&widget->priv->lock);
 803
 804   g_main_context_invoke (main_context, (GSourceFunc) _queue_resize, widget);
 805
 806   return TRUE;
 807 }
 808
 809 GstGLContext *
 810 gtk_gst_gl_widget_get_gtk_context (GtkGstGLWidget * gst_widget)
 811 {
 812   if (!gst_widget->priv->other_context)
 813     return NULL;
 814
 815   return gst_object_ref (gst_widget->priv->other_context);
 816 }
 817
 818 GstGLContext *
 819 gtk_gst_gl_widget_get_context (GtkGstGLWidget * gst_widget)
 820 {
 821   if (!gst_widget->priv->context)
 822     return NULL;
 823
 824   return gst_object_ref (gst_widget->priv->context);
 825 }
 826
 827 GstGLDisplay *
 828 gtk_gst_gl_widget_get_display (GtkGstGLWidget * gst_widget)
 829 {
 830   if (!gst_widget->priv->display)
 831     return NULL;
 832
 833   return gst_object_ref (gst_widget->priv->display);
 834 }