subprojects/gst-plugins-base/ext/gl/gstglimagesink.c

   1 /*
   2  * GStreamer
   3  * Copyright (C) 2003 Julien Moutte <julien@moutte.net>
   4  * Copyright (C) 2005,2006,2007 David A. Schleef <ds@schleef.org>
   5  * Copyright (C) 2008 Julien Isorce <julien.isorce@gmail.com>
   6  * Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 /**
  25  * SECTION:element-glimagesink
  26  * @title: glimagesink
  27  *
  28  * glimagesink renders video frames to a drawable on a local or remote
  29  * display using OpenGL. This element can receive a Window ID from the
  30  * application through the VideoOverlay interface and will then render video
  31  * frames in this drawable.
  32  * If no Window ID was provided by the application, the element will
  33  * create its own internal window and render into it.
  34  *
  35  * See the #GstGLDisplay documentation for a list of environment variables that
  36  * can override window/platform detection.
  37  *
  38  * ## Scaling
  39  *
  40  * Depends on the driver, OpenGL handles hardware accelerated
  41  * scaling of video frames. This means that the element will just accept
  42  * incoming video frames no matter their geometry and will then put them to the
  43  * drawable scaling them on the fly. Using the #GstGLImageSink:force-aspect-ratio
  44  * property it is possible to enforce scaling with a constant aspect ratio,
  45  * which means drawing black borders around the video frame.
  46  *
  47  * ## Events
  48  *
  49  * Through the gl thread, glimagesink handle some events coming from the drawable
  50  * to manage its appearance even when the data is not flowing (GST_STATE_PAUSED).
  51  * That means that even when the element is paused, it will receive expose events
  52  * from the drawable and draw the latest frame with correct borders/aspect-ratio.
  53  *
  54  * ## Examples
  55  * |[
  56  * gst-launch-1.0 -v videotestsrc ! video/x-raw ! glimagesink
  57  * ]| A pipeline to test hardware scaling.
  58  * No special opengl extension is used in this pipeline, that's why it should work
  59  * with OpenGL >= 1.1. That's the case if you are using the MESA3D driver v1.3.
  60  * |[
  61  * gst-launch-1.0 -v videotestsrc ! video/x-raw,format=I420 ! glimagesink
  62  * ]| A pipeline to test hardware scaling and hardware colorspace conversion.
  63  * When your driver supports GLSL (OpenGL Shading Language needs OpenGL >= 2.1),
  64  * the 4 following format YUY2, UYVY, I420, YV12 and AYUV are converted to RGB32
  65  * through some fragment shaders and using one framebuffer (FBO extension OpenGL >= 1.4).
  66  * If your driver does not support GLSL but supports MESA_YCbCr extension then
  67  * the you can use YUY2 and UYVY. In this case the colorspace conversion is automatically
  68  * made when loading the texture and therefore no framebuffer is used.
  69  * |[
  70  * gst-launch-1.0 -v gltestsrc ! glimagesink
  71  * ]| A pipeline 100% OpenGL.
  72  * No special opengl extension is used in this pipeline, that's why it should work
  73  * with OpenGL >= 1.1. That's the case if you are using the MESA3D driver v1.3.
  74  * |[
  75  * gst-plugins-bas/tests/examples/gl/generic/cube
  76  * ]| The graphic FPS scene can be greater than the input video FPS.
  77  * The graphic scene can be written from a client code through the
  78  * two glfilterapp properties.
  79  *
  80  */
  81
  82 #ifdef HAVE_CONFIG_H
  83 #include "config.h"
  84 #endif
  85
  86 #include <gst/video/videooverlay.h>
  87 #include <gst/video/navigation.h>
  88 #include <gst/video/gstvideoaffinetransformationmeta.h>
  89
  90 #include "gstglelements.h"
  91 #include "gstglimagesink.h"
  92 #include "gstglsinkbin.h"
  93 #include "gstglutils.h"
  94
  95 #include <gst/gl/gstglviewconvert.h>
  96
  97 GST_DEBUG_CATEGORY (gst_debug_glimage_sink);
  98 #define GST_CAT_DEFAULT gst_debug_glimage_sink
  99
 100 #define DEFAULT_SHOW_PREROLL_FRAME  TRUE
 101 #define DEFAULT_HANDLE_EVENTS       TRUE
 102 #define DEFAULT_FORCE_ASPECT_RATIO  TRUE
 103 #define DEFAULT_IGNORE_ALPHA        TRUE
 104
 105 #define DEFAULT_MULTIVIEW_MODE GST_VIDEO_MULTIVIEW_MODE_MONO
 106 #define DEFAULT_MULTIVIEW_FLAGS GST_VIDEO_MULTIVIEW_FLAGS_NONE
 107 #define DEFAULT_MULTIVIEW_DOWNMIX GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS
 108
 109 typedef GstGLSinkBin GstGLImageSinkBin;
 110 typedef GstGLSinkBinClass GstGLImageSinkBinClass;
 111
 112 G_DEFINE_TYPE (GstGLImageSinkBin, gst_gl_image_sink_bin, GST_TYPE_GL_SINK_BIN);
 113 GST_ELEMENT_REGISTER_DEFINE_WITH_CODE (glimagesink, "glimagesink",
 114     GST_RANK_SECONDARY, gst_gl_image_sink_bin_get_type (),
 115     gl_element_init (plugin));
 116
 117 enum
 118 {
 119   PROP_BIN_0,
 120   PROP_BIN_ROTATE_METHOD,
 121   PROP_BIN_FORCE_ASPECT_RATIO,
 122   PROP_BIN_PIXEL_ASPECT_RATIO,
 123   PROP_BIN_HANDLE_EVENTS,
 124   PROP_BIN_CONTEXT,
 125   PROP_BIN_IGNORE_ALPHA,
 126   PROP_BIN_SHOW_PREROLL_FRAME,
 127   PROP_BIN_OUTPUT_MULTIVIEW_LAYOUT,
 128   PROP_BIN_OUTPUT_MULTIVIEW_FLAGS,
 129   PROP_BIN_OUTPUT_MULTIVIEW_DOWNMIX_MODE,
 130   PROP_BIN_LAST
 131 };
 132
 133 enum
 134 {
 135   SIGNAL_BIN_0,
 136   SIGNAL_BIN_CLIENT_DRAW,
 137   SIGNAL_BIN_CLIENT_RESHAPE,
 138   SIGNAL_BIN_LAST,
 139 };
 140
 141 static guint gst_gl_image_sink_bin_signals[SIGNAL_BIN_LAST] = { 0 };
 142
 143 static void
 144 gst_gl_image_sink_bin_set_property (GObject * object, guint prop_id,
 145     const GValue * value, GParamSpec * param_spec)
 146 {
 147   g_object_set_property (G_OBJECT (GST_GL_SINK_BIN (object)->sink),
 148       param_spec->name, value);
 149 }
 150
 151 static void
 152 gst_gl_image_sink_bin_get_property (GObject * object, guint prop_id,
 153     GValue * value, GParamSpec * param_spec)
 154 {
 155   g_object_get_property (G_OBJECT (GST_GL_SINK_BIN (object)->sink),
 156       param_spec->name, value);
 157 }
 158
 159 static gboolean
 160 _on_client_reshape (GstGLImageSink * sink, GstGLContext * context,
 161     guint width, guint height, gpointer data)
 162 {
 163   gboolean ret;
 164
 165   g_signal_emit (data, gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_RESHAPE],
 166       0, context, width, height, &ret);
 167
 168   return ret;
 169 }
 170
 171 static gboolean
 172 _on_client_draw (GstGLImageSink * sink, GstGLContext * context,
 173     GstSample * sample, gpointer data)
 174 {
 175   gboolean ret;
 176
 177   g_signal_emit (data, gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_DRAW], 0,
 178       context, sample, &ret);
 179
 180   return ret;
 181 }
 182
 183 #define DEFAULT_ROTATE_METHOD GST_VIDEO_ORIENTATION_IDENTITY
 184
 185 #define GST_TYPE_GL_ROTATE_METHOD (gst_gl_rotate_method_get_type())
 186
 187 static const GEnumValue rotate_methods[] = {
 188   {GST_VIDEO_ORIENTATION_IDENTITY, "Identity (no rotation)", "none"},
 189   {GST_VIDEO_ORIENTATION_90R, "Rotate clockwise 90 degrees", "clockwise"},
 190   {GST_VIDEO_ORIENTATION_180, "Rotate 180 degrees", "rotate-180"},
 191   {GST_VIDEO_ORIENTATION_90L, "Rotate counter-clockwise 90 degrees",
 192       "counterclockwise"},
 193   {GST_VIDEO_ORIENTATION_HORIZ, "Flip horizontally", "horizontal-flip"},
 194   {GST_VIDEO_ORIENTATION_VERT, "Flip vertically", "vertical-flip"},
 195   {GST_VIDEO_ORIENTATION_UL_LR,
 196       "Flip across upper left/lower right diagonal", "upper-left-diagonal"},
 197   {GST_VIDEO_ORIENTATION_UR_LL,
 198       "Flip across upper right/lower left diagonal", "upper-right-diagonal"},
 199   {GST_VIDEO_ORIENTATION_AUTO,
 200       "Select rotate method based on image-orientation tag", "automatic"},
 201   {0, NULL, NULL},
 202 };
 203
 204 static GType
 205 gst_gl_rotate_method_get_type (void)
 206 {
 207   static GType rotate_method_type = 0;
 208
 209   if (!rotate_method_type) {
 210     rotate_method_type = g_enum_register_static ("GstGLRotateMethod",
 211         rotate_methods);
 212   }
 213   return rotate_method_type;
 214 }
 215
 216 static void
 217 gst_gl_image_sink_bin_init (GstGLImageSinkBin * self)
 218 {
 219   GstGLImageSink *sink = g_object_new (GST_TYPE_GLIMAGE_SINK, NULL);
 220
 221   g_signal_connect (sink, "client-reshape", (GCallback) _on_client_reshape,
 222       self);
 223   g_signal_connect (sink, "client-draw", (GCallback) _on_client_draw, self);
 224
 225   gst_gl_sink_bin_finish_init_with_element (GST_GL_SINK_BIN (self),
 226       GST_ELEMENT (sink));
 227 }
 228
 229 static void
 230 gst_gl_image_sink_bin_class_init (GstGLImageSinkBinClass * klass)
 231 {
 232   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 233
 234   gobject_class->get_property = gst_gl_image_sink_bin_get_property;
 235   gobject_class->set_property = gst_gl_image_sink_bin_set_property;
 236
 237   /* gl sink */
 238   g_object_class_install_property (gobject_class, PROP_BIN_ROTATE_METHOD,
 239       g_param_spec_enum ("rotate-method",
 240           "rotate method",
 241           "rotate method",
 242           GST_TYPE_GL_ROTATE_METHOD, DEFAULT_ROTATE_METHOD,
 243           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 244   g_object_class_install_property (gobject_class, PROP_BIN_FORCE_ASPECT_RATIO,
 245       g_param_spec_boolean ("force-aspect-ratio",
 246           "Force aspect ratio",
 247           "When enabled, scaling will respect original aspect ratio",
 248           DEFAULT_FORCE_ASPECT_RATIO,
 249           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 250   g_object_class_install_property (gobject_class, PROP_BIN_HANDLE_EVENTS,
 251       g_param_spec_boolean ("handle-events", "Handle XEvents",
 252           "When enabled, XEvents will be selected and handled",
 253           DEFAULT_HANDLE_EVENTS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 254   g_object_class_install_property (gobject_class, PROP_BIN_IGNORE_ALPHA,
 255       g_param_spec_boolean ("ignore-alpha", "Ignore Alpha",
 256           "When enabled, alpha will be ignored and converted to black",
 257           DEFAULT_IGNORE_ALPHA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 258   g_object_class_install_property (gobject_class, PROP_BIN_CONTEXT,
 259       g_param_spec_object ("context", "OpenGL context", "Get OpenGL context",
 260           GST_TYPE_GL_CONTEXT, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 261   g_object_class_install_property (gobject_class, PROP_BIN_PIXEL_ASPECT_RATIO,
 262       gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",
 263           "The pixel aspect ratio of the device", 0, 1, G_MAXINT, 1, 1, 1,
 264           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 265
 266   /* video sink */
 267   g_object_class_install_property (gobject_class, PROP_BIN_SHOW_PREROLL_FRAME,
 268       g_param_spec_boolean ("show-preroll-frame", "Show preroll frame",
 269           "Whether to render video frames during preroll",
 270           DEFAULT_SHOW_PREROLL_FRAME,
 271           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 272
 273   g_object_class_install_property (gobject_class,
 274       PROP_BIN_OUTPUT_MULTIVIEW_LAYOUT,
 275       g_param_spec_enum ("output-multiview-mode", "Output Multiview Mode",
 276           "Choose output mode for multiview/3D video",
 277           GST_TYPE_VIDEO_MULTIVIEW_MODE, DEFAULT_MULTIVIEW_MODE,
 278           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 279   g_object_class_install_property (gobject_class,
 280       PROP_BIN_OUTPUT_MULTIVIEW_FLAGS,
 281       g_param_spec_flags ("output-multiview-flags", "Output Multiview Flags",
 282           "Output multiview layout modifier flags",
 283           GST_TYPE_VIDEO_MULTIVIEW_FLAGS, DEFAULT_MULTIVIEW_FLAGS,
 284           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 285   g_object_class_install_property (gobject_class,
 286       PROP_BIN_OUTPUT_MULTIVIEW_DOWNMIX_MODE,
 287       g_param_spec_enum ("output-multiview-downmix-mode",
 288           "Mode for mono downmixed output",
 289           "Output anaglyph type to generate when downmixing to mono",
 290           GST_TYPE_GL_STEREO_DOWNMIX, DEFAULT_MULTIVIEW_DOWNMIX,
 291           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 292
 293   gst_video_overlay_install_properties (gobject_class, PROP_BIN_LAST);
 294
 295   gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_DRAW] =
 296       g_signal_new ("client-draw", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 297       0, NULL, NULL, NULL, G_TYPE_BOOLEAN, 2, GST_TYPE_GL_CONTEXT,
 298       GST_TYPE_SAMPLE);
 299
 300   gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_RESHAPE] =
 301       g_signal_new ("client-reshape", G_TYPE_FROM_CLASS (klass),
 302       G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_BOOLEAN, 3,
 303       GST_TYPE_GL_CONTEXT, G_TYPE_UINT, G_TYPE_UINT);
 304
 305   gst_type_mark_as_plugin_api (GST_TYPE_GL_ROTATE_METHOD, 0);
 306 }
 307
 308 #define GST_GLIMAGE_SINK_GET_LOCK(glsink) \
 309   (GST_GLIMAGE_SINK(glsink)->drawing_lock)
 310 #define GST_GLIMAGE_SINK_LOCK(glsink) \
 311   (g_mutex_lock(&GST_GLIMAGE_SINK_GET_LOCK (glsink)))
 312 #define GST_GLIMAGE_SINK_UNLOCK(glsink) \
 313   (g_mutex_unlock(&GST_GLIMAGE_SINK_GET_LOCK (glsink)))
 314
 315 #define USING_OPENGL(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL, 1, 0))
 316 #define USING_OPENGL3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL3, 3, 1))
 317 #define USING_GLES(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES, 1, 0))
 318 #define USING_GLES2(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 2, 0))
 319 #define USING_GLES3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 3, 0))
 320
 321 #define SUPPORTED_GL_APIS GST_GL_API_OPENGL | GST_GL_API_GLES2 | GST_GL_API_OPENGL3
 322
 323 static void gst_glimage_sink_thread_init_redisplay (GstGLImageSink * gl_sink);
 324 static void gst_glimage_sink_cleanup_glthread (GstGLImageSink * gl_sink);
 325 static void gst_glimage_sink_on_close (GstGLImageSink * gl_sink);
 326 static void gst_glimage_sink_on_resize (GstGLImageSink * gl_sink,
 327     gint width, gint height);
 328 static void gst_glimage_sink_on_draw (GstGLImageSink * gl_sink);
 329 static gboolean gst_glimage_sink_redisplay (GstGLImageSink * gl_sink);
 330
 331 static void gst_glimage_sink_finalize (GObject * object);
 332 static void gst_glimage_sink_set_property (GObject * object, guint prop_id,
 333     const GValue * value, GParamSpec * param_spec);
 334 static void gst_glimage_sink_get_property (GObject * object, guint prop_id,
 335     GValue * value, GParamSpec * param_spec);
 336
 337 static gboolean gst_glimage_sink_event (GstBaseSink * sink, GstEvent * event);
 338 static gboolean gst_glimage_sink_query (GstBaseSink * bsink, GstQuery * query);
 339 static void gst_glimage_sink_set_context (GstElement * element,
 340     GstContext * context);
 341
 342 static GstStateChangeReturn
 343 gst_glimage_sink_change_state (GstElement * element, GstStateChange transition);
 344
 345 static void gst_glimage_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
 346     GstClockTime * start, GstClockTime * end);
 347 static gboolean gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps);
 348 static GstCaps *gst_glimage_sink_get_caps (GstBaseSink * bsink,
 349     GstCaps * filter);
 350 static GstFlowReturn gst_glimage_sink_prepare (GstBaseSink * bsink,
 351     GstBuffer * buf);
 352 static GstFlowReturn gst_glimage_sink_show_frame (GstVideoSink * bsink,
 353     GstBuffer * buf);
 354 static gboolean gst_glimage_sink_propose_allocation (GstBaseSink * bsink,
 355     GstQuery * query);
 356
 357 static void gst_glimage_sink_video_overlay_init (GstVideoOverlayInterface *
 358     iface);
 359 static void gst_glimage_sink_set_window_handle (GstVideoOverlay * overlay,
 360     guintptr id);
 361 static void gst_glimage_sink_expose (GstVideoOverlay * overlay);
 362 static void gst_glimage_sink_set_render_rectangle (GstVideoOverlay * overlay,
 363     gint x, gint y, gint width, gint height);
 364 static void gst_glimage_sink_handle_events (GstVideoOverlay * overlay,
 365     gboolean handle_events);
 366 static gboolean update_output_format (GstGLImageSink * glimage_sink);
 367
 368 #define GST_GL_SINK_CAPS \
 369     "video/x-raw(" GST_CAPS_FEATURE_MEMORY_GL_MEMORY "), "              \
 370     "format = (string) RGBA, "                                          \
 371     "width = " GST_VIDEO_SIZE_RANGE ", "                                \
 372     "height = " GST_VIDEO_SIZE_RANGE ", "                               \
 373     "framerate = " GST_VIDEO_FPS_RANGE ", "                             \
 374     "texture-target = (string) { 2D, external-oes } "                   \
 375     " ; "                                                               \
 376     "video/x-raw(" GST_CAPS_FEATURE_MEMORY_GL_MEMORY ","                \
 377     GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION "), "           \
 378     "format = (string) RGBA, "                                          \
 379     "width = " GST_VIDEO_SIZE_RANGE ", "                                \
 380     "height = " GST_VIDEO_SIZE_RANGE ", "                               \
 381     "framerate = " GST_VIDEO_FPS_RANGE ", "                             \
 382     "texture-target = (string) { 2D, external-oes } "
 383
 384 static GstStaticPadTemplate gst_glimage_sink_template =
 385 GST_STATIC_PAD_TEMPLATE ("sink",
 386     GST_PAD_SINK,
 387     GST_PAD_ALWAYS,
 388     GST_STATIC_CAPS (GST_GL_SINK_CAPS));
 389
 390 enum
 391 {
 392   ARG_0,
 393   ARG_DISPLAY,
 394   PROP_ROTATE_METHOD,
 395   PROP_FORCE_ASPECT_RATIO,
 396   PROP_PIXEL_ASPECT_RATIO,
 397   PROP_CONTEXT,
 398   PROP_HANDLE_EVENTS,
 399   PROP_IGNORE_ALPHA,
 400   PROP_OUTPUT_MULTIVIEW_LAYOUT,
 401   PROP_OUTPUT_MULTIVIEW_FLAGS,
 402   PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE,
 403   PROP_LAST
 404 };
 405
 406 enum
 407 {
 408   SIGNAL_0,
 409   CLIENT_DRAW_SIGNAL,
 410   CLIENT_RESHAPE_SIGNAL,
 411   LAST_SIGNAL
 412 };
 413
 414 static guint gst_glimage_sink_signals[LAST_SIGNAL] = { 0 };
 415
 416 static void
 417 _display_size_to_stream_size (GstGLImageSink * gl_sink, gdouble x,
 418     gdouble y, gdouble * stream_x, gdouble * stream_y)
 419 {
 420   gdouble stream_width, stream_height;
 421
 422   stream_width = (gdouble) GST_VIDEO_INFO_WIDTH (&gl_sink->out_info);
 423   stream_height = (gdouble) GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info);
 424
 425   /* from display coordinates to stream coordinates */
 426   if (gl_sink->display_rect.w > 0)
 427     *stream_x =
 428         (x - gl_sink->display_rect.x) / gl_sink->display_rect.w * stream_width;
 429   else
 430     *stream_x = 0.;
 431
 432   /* clip to stream size */
 433   if (*stream_x < 0.)
 434     *stream_x = 0.;
 435   if (*stream_x > GST_VIDEO_INFO_WIDTH (&gl_sink->out_info))
 436     *stream_x = GST_VIDEO_INFO_WIDTH (&gl_sink->out_info);
 437
 438   /* same for y-axis */
 439   if (gl_sink->display_rect.h > 0)
 440     *stream_y =
 441         (y - gl_sink->display_rect.y) / gl_sink->display_rect.h * stream_height;
 442   else
 443     *stream_y = 0.;
 444
 445   if (*stream_y < 0.)
 446     *stream_y = 0.;
 447   if (*stream_y > GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info))
 448     *stream_y = GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info);
 449
 450   GST_TRACE ("transform %fx%f into %fx%f", x, y, *stream_x, *stream_y);
 451 }
 452
 453 static void
 454 _display_scroll_value_to_stream_scroll_value (GstGLImageSink * gl_sink,
 455     gdouble delta_x, gdouble delta_y, gdouble * stream_delta_x,
 456     gdouble * stream_delta_y)
 457 {
 458   gdouble stream_width, stream_height;
 459
 460   stream_width = (gdouble) GST_VIDEO_INFO_WIDTH (&gl_sink->out_info);
 461   stream_height = (gdouble) GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info);
 462
 463   if (delta_x != 0 && gl_sink->display_rect.w > 0)
 464     *stream_delta_x = delta_x * (stream_width / gl_sink->display_rect.w);
 465   else
 466     *stream_delta_x = delta_x;
 467
 468   if (delta_y != 0 && gl_sink->display_rect.h > 0)
 469     *stream_delta_y = delta_y * (stream_height / gl_sink->display_rect.h);
 470   else
 471     *stream_delta_y = delta_y;
 472
 473   GST_TRACE_OBJECT (gl_sink, "transform %fx%f into %fx%f", delta_x, delta_y,
 474       *stream_delta_x, *stream_delta_y);
 475 }
 476
 477 /* rotate 90 */
 478 static const gfloat clockwise_matrix[] = {
 479   0.0f, -1.0f, 0.0f, 0.0f,
 480   1.0f, 0.0f, 0.0f, 0.0f,
 481   0.0f, 0.0f, 1.0f, 0.0f,
 482   0.0f, 0.0f, 0.0f, 1.0f,
 483 };
 484
 485 /* rotate 180 */
 486 static const gfloat clockwise_180_matrix[] = {
 487   -1.0f, 0.0f, 0.0f, 0.0f,
 488   0.0f, -1.0f, 0.0f, 0.0f,
 489   0.0f, 0.0f, 1.0f, 0.0f,
 490   0.0f, 0.0f, 0.0f, 1.0f,
 491 };
 492
 493 /* rotate 270 */
 494 static const gfloat counterclockwise_matrix[] = {
 495   0.0f, 1.0f, 0.0f, 0.0f,
 496   -1.0f, 0.0f, 0.0f, 0.0f,
 497   0.0f, 0.0f, 1.0f, 0.0f,
 498   0.0f, 0.0f, 0.0f, 1.0f,
 499 };
 500
 501 /* horizontal-flip */
 502 static const gfloat horizontal_flip_matrix[] = {
 503   -1.0f, 0.0f, 0.0f, 0.0f,
 504   0.0f, 1.0f, 0.0f, 0.0f,
 505   0.0f, 0.0f, 1.0f, 0.0f,
 506   0.0f, 0.0f, 0.0f, 1.0f,
 507 };
 508
 509 /* vertical-flip */
 510 static const gfloat vertical_flip_matrix[] = {
 511   1.0f, 0.0f, 0.0f, 0.0f,
 512   0.0f, -1.0f, 0.0f, 0.0f,
 513   0.0f, 0.0f, 1.0f, 0.0f,
 514   0.0f, 0.0f, 0.0f, 1.0f,
 515 };
 516
 517 /* upper-left-diagonal */
 518 static const gfloat upper_left_matrix[] = {
 519   0.0f, -1.0f, 0.0f, 0.0f,
 520   -1.0f, 0.0f, 0.0f, 0.0f,
 521   0.0f, 0.0f, 1.0f, 0.0f,
 522   0.0f, 0.0f, 0.0f, 1.0f,
 523 };
 524
 525 /* upper-right-diagonal */
 526 static const gfloat upper_right_matrix[] = {
 527   0.0f, 1.0f, 0.0f, 0.0f,
 528   1.0f, 0.0f, 0.0f, 0.0f,
 529   0.0f, 0.0f, 1.0f, 0.0f,
 530   0.0f, 0.0f, 0.0f, 1.0f,
 531 };
 532
 533 static void
 534 gst_glimage_sink_set_rotate_method (GstGLImageSink * gl_sink,
 535     GstVideoOrientationMethod method, gboolean from_tag)
 536 {
 537   GstVideoOrientationMethod tag_method = DEFAULT_ROTATE_METHOD;
 538   GST_GLIMAGE_SINK_LOCK (gl_sink);
 539   if (from_tag)
 540     tag_method = method;
 541   else
 542     gl_sink->rotate_method = method;
 543
 544   if (gl_sink->rotate_method == GST_VIDEO_ORIENTATION_AUTO)
 545     method = tag_method;
 546   else
 547     method = gl_sink->rotate_method;
 548
 549   if (method != gl_sink->current_rotate_method) {
 550     GST_DEBUG_OBJECT (gl_sink, "Changing method from %s to %s",
 551         rotate_methods[gl_sink->current_rotate_method].value_nick,
 552         rotate_methods[method].value_nick);
 553
 554     switch (method) {
 555       case GST_VIDEO_ORIENTATION_IDENTITY:
 556         gl_sink->transform_matrix = NULL;
 557         gl_sink->output_mode_changed = TRUE;
 558         break;
 559       case GST_VIDEO_ORIENTATION_90R:
 560         gl_sink->transform_matrix = clockwise_matrix;
 561         gl_sink->output_mode_changed = TRUE;
 562         break;
 563       case GST_VIDEO_ORIENTATION_180:
 564         gl_sink->transform_matrix = clockwise_180_matrix;
 565         gl_sink->output_mode_changed = TRUE;
 566         break;
 567       case GST_VIDEO_ORIENTATION_90L:
 568         gl_sink->transform_matrix = counterclockwise_matrix;
 569         gl_sink->output_mode_changed = TRUE;
 570         break;
 571       case GST_VIDEO_ORIENTATION_HORIZ:
 572         gl_sink->transform_matrix = horizontal_flip_matrix;
 573         gl_sink->output_mode_changed = TRUE;
 574         break;
 575       case GST_VIDEO_ORIENTATION_VERT:
 576         gl_sink->transform_matrix = vertical_flip_matrix;
 577         gl_sink->output_mode_changed = TRUE;
 578         break;
 579       case GST_VIDEO_ORIENTATION_UL_LR:
 580         gl_sink->transform_matrix = upper_left_matrix;
 581         gl_sink->output_mode_changed = TRUE;
 582         break;
 583       case GST_VIDEO_ORIENTATION_UR_LL:
 584         gl_sink->transform_matrix = upper_right_matrix;
 585         gl_sink->output_mode_changed = TRUE;
 586         break;
 587       default:
 588         g_assert_not_reached ();
 589         break;
 590     }
 591
 592     gl_sink->current_rotate_method = method;
 593   }
 594   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
 595 }
 596
 597 static void
 598 gst_glimage_sink_navigation_send_event (GstNavigation * navigation, GstStructure
 599     * structure)
 600 {
 601   GstGLImageSink *sink = GST_GLIMAGE_SINK (navigation);
 602   gboolean handled = FALSE;
 603   GstEvent *event = NULL;
 604   GstGLWindow *window;
 605   guint width, height;
 606   gdouble x, y;
 607
 608   if (!sink->context) {
 609     gst_structure_free (structure);
 610     return;
 611   }
 612
 613   window = gst_gl_context_get_window (sink->context);
 614   g_return_if_fail (GST_IS_GL_WINDOW (window));
 615
 616   width = GST_VIDEO_SINK_WIDTH (sink);
 617   height = GST_VIDEO_SINK_HEIGHT (sink);
 618   gst_gl_window_get_surface_dimensions (window, &width, &height);
 619
 620   /* Converting pointer coordinates to the non scaled geometry */
 621   if (width != 0 && gst_structure_get_double (structure, "pointer_x", &x)
 622       && height != 0 && gst_structure_get_double (structure, "pointer_y", &y)) {
 623     gdouble stream_x, stream_y;
 624
 625     _display_size_to_stream_size (sink, x, y, &stream_x, &stream_y);
 626
 627     gst_structure_set (structure, "pointer_x", G_TYPE_DOUBLE,
 628         stream_x, "pointer_y", G_TYPE_DOUBLE, stream_y, NULL);
 629   }
 630
 631   /* Converting pointer scroll coordinates to the non scaled geometry */
 632   if (width != 0 && gst_structure_get_double (structure, "delta_pointer_x", &x)
 633       && height != 0
 634       && gst_structure_get_double (structure, "delta_pointer_y", &y)) {
 635     gdouble stream_x, stream_y;
 636
 637     _display_scroll_value_to_stream_scroll_value (sink, x, y, &stream_x,
 638         &stream_y);
 639
 640     gst_structure_set (structure, "delta_pointer_x", G_TYPE_DOUBLE,
 641         stream_x, "delta_pointer_y", G_TYPE_DOUBLE, stream_y, NULL);
 642   }
 643
 644   event = gst_event_new_navigation (structure);
 645   if (event) {
 646     gst_event_ref (event);
 647     handled = gst_pad_push_event (GST_VIDEO_SINK_PAD (sink), event);
 648
 649     if (!handled)
 650       gst_element_post_message ((GstElement *) sink,
 651           gst_navigation_message_new_event ((GstObject *) sink, event));
 652
 653     gst_event_unref (event);
 654   }
 655   gst_object_unref (window);
 656 }
 657
 658 static void
 659 gst_glimage_sink_navigation_interface_init (GstNavigationInterface * iface)
 660 {
 661   iface->send_event = gst_glimage_sink_navigation_send_event;
 662 }
 663
 664 #define gst_glimage_sink_parent_class parent_class
 665 G_DEFINE_TYPE_WITH_CODE (GstGLImageSink, gst_glimage_sink,
 666     GST_TYPE_VIDEO_SINK, G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
 667         gst_glimage_sink_video_overlay_init);
 668     G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
 669         gst_glimage_sink_navigation_interface_init);
 670     GST_DEBUG_CATEGORY_INIT (gst_debug_glimage_sink, "glimagesink", 0,
 671         "OpenGL Video Sink"));
 672 GST_ELEMENT_REGISTER_DEFINE_WITH_CODE (glimagesinkelement, "glimagesinkelement",
 673     GST_RANK_NONE, gst_glimage_sink_get_type (), gl_element_init (plugin));
 674
 675 static void
 676 gst_glimage_sink_class_init (GstGLImageSinkClass * klass)
 677 {
 678   GObjectClass *gobject_class;
 679   GstElementClass *gstelement_class;
 680   GstBaseSinkClass *gstbasesink_class;
 681   GstVideoSinkClass *gstvideosink_class;
 682   GstElementClass *element_class;
 683
 684   gobject_class = (GObjectClass *) klass;
 685   gstelement_class = (GstElementClass *) klass;
 686   gstbasesink_class = (GstBaseSinkClass *) klass;
 687   gstvideosink_class = (GstVideoSinkClass *) klass;
 688   element_class = GST_ELEMENT_CLASS (klass);
 689
 690   gobject_class->set_property = gst_glimage_sink_set_property;
 691   gobject_class->get_property = gst_glimage_sink_get_property;
 692
 693   g_object_class_install_property (gobject_class, PROP_ROTATE_METHOD,
 694       g_param_spec_enum ("rotate-method",
 695           "rotate method",
 696           "rotate method",
 697           GST_TYPE_GL_ROTATE_METHOD, DEFAULT_ROTATE_METHOD,
 698           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 699
 700   g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,
 701       g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio",
 702           "When enabled, scaling will respect original aspect ratio",
 703           DEFAULT_FORCE_ASPECT_RATIO,
 704           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 705
 706   g_object_class_install_property (gobject_class, PROP_PIXEL_ASPECT_RATIO,
 707       gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",
 708           "The pixel aspect ratio of the device", 0, 1, G_MAXINT, 1, 1, 1,
 709           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 710
 711   g_object_class_install_property (gobject_class, PROP_CONTEXT,
 712       g_param_spec_object ("context", "OpenGL context", "Get OpenGL context",
 713           GST_TYPE_GL_CONTEXT, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 714
 715   g_object_class_install_property (gobject_class, PROP_HANDLE_EVENTS,
 716       g_param_spec_boolean ("handle-events", "Handle XEvents",
 717           "When enabled, XEvents will be selected and handled",
 718           DEFAULT_HANDLE_EVENTS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 719
 720   g_object_class_install_property (gobject_class, PROP_IGNORE_ALPHA,
 721       g_param_spec_boolean ("ignore-alpha", "Ignore Alpha",
 722           "When enabled, alpha will be ignored and converted to black",
 723           DEFAULT_IGNORE_ALPHA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 724
 725   g_object_class_install_property (gobject_class, PROP_OUTPUT_MULTIVIEW_LAYOUT,
 726       g_param_spec_enum ("output-multiview-mode",
 727           "Output Multiview Mode",
 728           "Choose output mode for multiview/3D video",
 729           GST_TYPE_VIDEO_MULTIVIEW_MODE, DEFAULT_MULTIVIEW_MODE,
 730           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 731   g_object_class_install_property (gobject_class, PROP_OUTPUT_MULTIVIEW_FLAGS,
 732       g_param_spec_flags ("output-multiview-flags",
 733           "Output Multiview Flags",
 734           "Output multiview layout modifier flags",
 735           GST_TYPE_VIDEO_MULTIVIEW_FLAGS, DEFAULT_MULTIVIEW_FLAGS,
 736           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 737   g_object_class_install_property (gobject_class,
 738       PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE,
 739       g_param_spec_enum ("output-multiview-downmix-mode",
 740           "Mode for mono downmixed output",
 741           "Output anaglyph type to generate when downmixing to mono",
 742           GST_TYPE_GL_STEREO_DOWNMIX, DEFAULT_MULTIVIEW_DOWNMIX,
 743           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 744
 745   gst_video_overlay_install_properties (gobject_class, PROP_LAST);
 746
 747   gst_element_class_set_metadata (element_class, "OpenGL video sink",
 748       "Sink/Video", "A videosink based on OpenGL",
 749       "Julien Isorce <julien.isorce@gmail.com>");
 750
 751   /**
 752    * GstGLImageSink::client-draw:
 753    * @object: the #GstGLImageSink
 754    * @context: the #GstGLContext
 755    * @sample: the #GstSample
 756    *
 757    * Will be emitted before actually drawing the texture.  The client should
 758    * redraw the surface/contents of @sample and return %TRUE.
 759    *
 760    * Returns: whether the texture was redrawn by the signal.  If not, a
 761    *          default redraw will occur.
 762    */
 763   gst_glimage_sink_signals[CLIENT_DRAW_SIGNAL] =
 764       g_signal_new ("client-draw", G_TYPE_FROM_CLASS (klass),
 765       G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_BOOLEAN, 2,
 766       GST_TYPE_GL_CONTEXT, GST_TYPE_SAMPLE);
 767
 768   /**
 769    * GstGLImageSink::client-reshape:
 770    * @object: the #GstGLImageSink
 771    * @context: the #GstGLContext
 772    * @width: the #guint width of the texture.
 773    * @height: the #guint height of the texture.
 774    *
 775    * The client should resize the surface/window/viewport with the @width and
 776    * @height and return %TRUE.
 777    *
 778    * Returns: whether the content area was resized by the signal.  If not, a
 779    *          default viewport resize will occur.
 780    */
 781   gst_glimage_sink_signals[CLIENT_RESHAPE_SIGNAL] =
 782       g_signal_new ("client-reshape", G_TYPE_FROM_CLASS (klass),
 783       G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_BOOLEAN, 3,
 784       GST_TYPE_GL_CONTEXT, G_TYPE_UINT, G_TYPE_UINT);
 785
 786   gst_element_class_add_static_pad_template (element_class,
 787       &gst_glimage_sink_template);
 788
 789   gobject_class->finalize = gst_glimage_sink_finalize;
 790
 791   gstelement_class->change_state = gst_glimage_sink_change_state;
 792   gstelement_class->set_context = gst_glimage_sink_set_context;
 793   gstbasesink_class->event = gst_glimage_sink_event;
 794   gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_glimage_sink_query);
 795   gstbasesink_class->set_caps = gst_glimage_sink_set_caps;
 796   gstbasesink_class->get_caps = gst_glimage_sink_get_caps;
 797   gstbasesink_class->get_times = gst_glimage_sink_get_times;
 798   gstbasesink_class->prepare = gst_glimage_sink_prepare;
 799   gstbasesink_class->propose_allocation = gst_glimage_sink_propose_allocation;
 800
 801   gstvideosink_class->show_frame =
 802       GST_DEBUG_FUNCPTR (gst_glimage_sink_show_frame);
 803 }
 804
 805 static void
 806 gst_glimage_sink_init (GstGLImageSink * glimage_sink)
 807 {
 808   glimage_sink->window_id = 0;
 809   glimage_sink->new_window_id = 0;
 810   glimage_sink->display = NULL;
 811   glimage_sink->keep_aspect_ratio = TRUE;
 812   glimage_sink->par_n = 0;
 813   glimage_sink->par_d = 1;
 814   glimage_sink->redisplay_texture = 0;
 815   glimage_sink->handle_events = TRUE;
 816   glimage_sink->ignore_alpha = TRUE;
 817   glimage_sink->overlay_compositor = NULL;
 818
 819   glimage_sink->mview_output_mode = DEFAULT_MULTIVIEW_MODE;
 820   glimage_sink->mview_output_flags = DEFAULT_MULTIVIEW_FLAGS;
 821   glimage_sink->mview_downmix_mode = DEFAULT_MULTIVIEW_DOWNMIX;
 822
 823   glimage_sink->current_rotate_method = DEFAULT_ROTATE_METHOD;
 824   glimage_sink->transform_matrix = NULL;
 825
 826   g_mutex_init (&glimage_sink->drawing_lock);
 827 }
 828
 829 static void
 830 gst_glimage_sink_set_property (GObject * object, guint prop_id,
 831     const GValue * value, GParamSpec * pspec)
 832 {
 833   GstGLImageSink *glimage_sink;
 834
 835   g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
 836
 837   glimage_sink = GST_GLIMAGE_SINK (object);
 838
 839   switch (prop_id) {
 840     case PROP_ROTATE_METHOD:
 841       gst_glimage_sink_set_rotate_method (glimage_sink,
 842           g_value_get_enum (value), FALSE);
 843       break;
 844     case PROP_FORCE_ASPECT_RATIO:
 845     {
 846       glimage_sink->keep_aspect_ratio = g_value_get_boolean (value);
 847       break;
 848     }
 849     case PROP_PIXEL_ASPECT_RATIO:
 850     {
 851       glimage_sink->par_n = gst_value_get_fraction_numerator (value);
 852       glimage_sink->par_d = gst_value_get_fraction_denominator (value);
 853       break;
 854     }
 855     case PROP_HANDLE_EVENTS:
 856       gst_glimage_sink_handle_events (GST_VIDEO_OVERLAY (glimage_sink),
 857           g_value_get_boolean (value));
 858       break;
 859     case PROP_IGNORE_ALPHA:
 860       glimage_sink->ignore_alpha = g_value_get_boolean (value);
 861       break;
 862     case PROP_OUTPUT_MULTIVIEW_LAYOUT:
 863       GST_GLIMAGE_SINK_LOCK (glimage_sink);
 864       glimage_sink->mview_output_mode = g_value_get_enum (value);
 865       glimage_sink->output_mode_changed = TRUE;
 866       GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
 867       break;
 868     case PROP_OUTPUT_MULTIVIEW_FLAGS:
 869       GST_GLIMAGE_SINK_LOCK (glimage_sink);
 870       glimage_sink->mview_output_flags = g_value_get_flags (value);
 871       glimage_sink->output_mode_changed = TRUE;
 872       GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
 873       break;
 874     case PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE:
 875       GST_GLIMAGE_SINK_LOCK (glimage_sink);
 876       glimage_sink->mview_downmix_mode = g_value_get_enum (value);
 877       glimage_sink->output_mode_changed = TRUE;
 878       GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
 879       break;
 880     default:
 881       if (!gst_video_overlay_set_property (object, PROP_LAST, prop_id, value))
 882         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 883       break;
 884   }
 885 }
 886
 887 static void
 888 gst_glimage_sink_finalize (GObject * object)
 889 {
 890   GstGLImageSink *glimage_sink;
 891
 892   g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
 893
 894   glimage_sink = GST_GLIMAGE_SINK (object);
 895   g_mutex_clear (&glimage_sink->drawing_lock);
 896
 897   GST_DEBUG ("finalized");
 898   G_OBJECT_CLASS (parent_class)->finalize (object);
 899 }
 900
 901 static void
 902 gst_glimage_sink_get_property (GObject * object, guint prop_id,
 903     GValue * value, GParamSpec * pspec)
 904 {
 905   GstGLImageSink *glimage_sink;
 906
 907   g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
 908
 909   glimage_sink = GST_GLIMAGE_SINK (object);
 910
 911   switch (prop_id) {
 912     case PROP_ROTATE_METHOD:
 913       g_value_set_enum (value, glimage_sink->current_rotate_method);
 914       break;
 915     case PROP_FORCE_ASPECT_RATIO:
 916       g_value_set_boolean (value, glimage_sink->keep_aspect_ratio);
 917       break;
 918     case PROP_PIXEL_ASPECT_RATIO:
 919       gst_value_set_fraction (value, glimage_sink->par_n, glimage_sink->par_d);
 920       break;
 921     case PROP_CONTEXT:
 922       g_value_set_object (value, glimage_sink->context);
 923       break;
 924     case PROP_HANDLE_EVENTS:
 925       g_value_set_boolean (value, glimage_sink->handle_events);
 926       break;
 927     case PROP_IGNORE_ALPHA:
 928       g_value_set_boolean (value, glimage_sink->ignore_alpha);
 929       break;
 930     case PROP_OUTPUT_MULTIVIEW_LAYOUT:
 931       g_value_set_enum (value, glimage_sink->mview_output_mode);
 932       break;
 933     case PROP_OUTPUT_MULTIVIEW_FLAGS:
 934       g_value_set_flags (value, glimage_sink->mview_output_flags);
 935       break;
 936     case PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE:
 937       g_value_set_enum (value, glimage_sink->mview_downmix_mode);
 938       break;
 939     default:
 940       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 941       break;
 942   }
 943 }
 944
 945 static void
 946 gst_glimage_sink_key_event_cb (GstGLWindow * window, char *event_name, char
 947     *key_string, GstGLImageSink * gl_sink)
 948 {
 949   GST_DEBUG_OBJECT (gl_sink, "event %s key %s pressed", event_name, key_string);
 950   gst_navigation_send_key_event (GST_NAVIGATION (gl_sink),
 951       event_name, key_string);
 952 }
 953
 954 static void
 955 gst_glimage_sink_mouse_event_cb (GstGLWindow * window, char *event_name,
 956     int button, double posx, double posy, GstGLImageSink * gl_sink)
 957 {
 958   GST_DEBUG_OBJECT (gl_sink, "event %s at %g, %g", event_name, posx, posy);
 959   gst_navigation_send_mouse_event (GST_NAVIGATION (gl_sink),
 960       event_name, button, posx, posy);
 961 }
 962
 963
 964 static void
 965 gst_glimage_sink_mouse_scroll_event_cb (GstGLWindow * window,
 966     double posx, double posy, double delta_x, double delta_y,
 967     GstGLImageSink * gl_sink)
 968 {
 969   GST_DEBUG_OBJECT (gl_sink, "event scroll at %g, %g", posx, posy);
 970   gst_navigation_send_mouse_scroll_event (GST_NAVIGATION (gl_sink),
 971       posx, posy, delta_x, delta_y);
 972 }
 973
 974 static void
 975 _set_context (GstGLImageSink * gl_sink, GstGLContext * context)
 976 {
 977   GST_GLIMAGE_SINK_LOCK (gl_sink);
 978   if (gl_sink->context)
 979     gst_object_unref (gl_sink->context);
 980
 981   gl_sink->context = context;
 982   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
 983 }
 984
 985 static void
 986 _set_other_context (GstGLImageSink * gl_sink, GstGLContext * other_context)
 987 {
 988   GST_GLIMAGE_SINK_LOCK (gl_sink);
 989   if (gl_sink->other_context)
 990     gst_object_unref (gl_sink->other_context);
 991
 992   gl_sink->other_context = other_context;
 993   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
 994 }
 995
 996 static void
 997 _set_display (GstGLImageSink * gl_sink, GstGLDisplay * display)
 998 {
 999   GST_GLIMAGE_SINK_LOCK (gl_sink);
1000   if (gl_sink->display)
1001     gst_object_unref (gl_sink->display);
1002
1003   gl_sink->display = display;
1004   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
1005 }
1006
1007 static gboolean
1008 _ensure_gl_setup (GstGLImageSink * gl_sink)
1009 {
1010   GError *error = NULL;
1011
1012   GST_TRACE_OBJECT (gl_sink, "Ensuring setup");
1013
1014   if (!gl_sink->context) {
1015     GST_OBJECT_LOCK (gl_sink->display);
1016     do {
1017       GstGLContext *other_context = NULL;
1018       GstGLContext *context = NULL;
1019       GstGLWindow *window = NULL;
1020
1021       _set_context (gl_sink, NULL);
1022
1023       GST_DEBUG_OBJECT (gl_sink,
1024           "No current context, creating one for %" GST_PTR_FORMAT,
1025           gl_sink->display);
1026
1027       if (gl_sink->other_context) {
1028         other_context = gst_object_ref (gl_sink->other_context);
1029       } else {
1030         other_context =
1031             gst_gl_display_get_gl_context_for_thread (gl_sink->display, NULL);
1032       }
1033
1034       if (!gst_gl_display_create_context (gl_sink->display,
1035               other_context, &context, &error)) {
1036         if (other_context)
1037           gst_object_unref (other_context);
1038         GST_OBJECT_UNLOCK (gl_sink->display);
1039         goto context_error;
1040       }
1041       _set_context (gl_sink, context);
1042       context = NULL;
1043
1044       GST_DEBUG_OBJECT (gl_sink,
1045           "created context %" GST_PTR_FORMAT " from other context %"
1046           GST_PTR_FORMAT, gl_sink->context, gl_sink->other_context);
1047
1048       window = gst_gl_context_get_window (gl_sink->context);
1049
1050       GST_DEBUG_OBJECT (gl_sink, "got window %" GST_PTR_FORMAT, window);
1051
1052       if (!gl_sink->window_id && !gl_sink->new_window_id)
1053         gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (gl_sink));
1054
1055       GST_DEBUG_OBJECT (gl_sink,
1056           "window_id : %" G_GUINTPTR_FORMAT " , new_window_id : %"
1057           G_GUINTPTR_FORMAT, gl_sink->window_id, gl_sink->new_window_id);
1058
1059       if (gl_sink->window_id != gl_sink->new_window_id) {
1060         gl_sink->window_id = gl_sink->new_window_id;
1061         GST_DEBUG_OBJECT (gl_sink, "Setting window handle on gl window");
1062         gst_gl_window_set_window_handle (window, gl_sink->window_id);
1063       }
1064
1065       gst_gl_window_handle_events (window, gl_sink->handle_events);
1066
1067       /* setup callbacks */
1068       gst_gl_window_set_resize_callback (window,
1069           GST_GL_WINDOW_RESIZE_CB (gst_glimage_sink_on_resize),
1070           gst_object_ref (gl_sink), (GDestroyNotify) gst_object_unref);
1071       gst_gl_window_set_draw_callback (window,
1072           GST_GL_WINDOW_CB (gst_glimage_sink_on_draw),
1073           gst_object_ref (gl_sink), (GDestroyNotify) gst_object_unref);
1074       gst_gl_window_set_close_callback (window,
1075           GST_GL_WINDOW_CB (gst_glimage_sink_on_close),
1076           gst_object_ref (gl_sink), (GDestroyNotify) gst_object_unref);
1077       gl_sink->key_sig_id = g_signal_connect (window, "key-event", G_CALLBACK
1078           (gst_glimage_sink_key_event_cb), gl_sink);
1079       gl_sink->mouse_sig_id =
1080           g_signal_connect (window, "mouse-event",
1081           G_CALLBACK (gst_glimage_sink_mouse_event_cb), gl_sink);
1082       gl_sink->mouse_scroll_sig_id =
1083           g_signal_connect (window, "scroll-event",
1084           G_CALLBACK (gst_glimage_sink_mouse_scroll_event_cb), gl_sink);
1085
1086       gst_gl_window_set_render_rectangle (window, gl_sink->x, gl_sink->y,
1087           gl_sink->width, gl_sink->height);
1088
1089       if (other_context)
1090         gst_object_unref (other_context);
1091       gst_object_unref (window);
1092     } while (!gst_gl_display_add_context (gl_sink->display, gl_sink->context));
1093     GST_OBJECT_UNLOCK (gl_sink->display);
1094   } else
1095     GST_TRACE_OBJECT (gl_sink, "Already have a context");
1096
1097   return TRUE;
1098
1099 context_error:
1100   {
1101     GST_ELEMENT_ERROR (gl_sink, RESOURCE, NOT_FOUND, ("%s", error->message),
1102         (NULL));
1103
1104     _set_context (gl_sink, NULL);
1105
1106     g_clear_error (&error);
1107
1108     return FALSE;
1109   }
1110 }
1111
1112 static gboolean
1113 gst_glimage_sink_event (GstBaseSink * sink, GstEvent * event)
1114 {
1115   GstGLImageSink *gl_sink = GST_GLIMAGE_SINK (sink);
1116   GstTagList *taglist;
1117   GstVideoOrientationMethod method;
1118   gboolean ret;
1119
1120   GST_DEBUG_OBJECT (gl_sink, "handling %s event", GST_EVENT_TYPE_NAME (event));
1121
1122   switch (GST_EVENT_TYPE (event)) {
1123     case GST_EVENT_TAG:
1124       gst_event_parse_tag (event, &taglist);
1125
1126       if (gst_video_orientation_from_tag (taglist, &method))
1127         gst_glimage_sink_set_rotate_method (gl_sink, method, TRUE);
1128
1129       break;
1130     default:
1131       break;
1132   }
1133
1134   ret = GST_BASE_SINK_CLASS (parent_class)->event (sink, event);
1135
1136   return ret;
1137 }
1138
1139 static gboolean
1140 gst_glimage_sink_query (GstBaseSink * bsink, GstQuery * query)
1141 {
1142   GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (bsink);
1143   gboolean res = FALSE;
1144
1145   switch (GST_QUERY_TYPE (query)) {
1146     case GST_QUERY_CONTEXT:
1147     {
1148       GstGLContext *context = NULL;
1149       GstGLContext *other_context = NULL;
1150       GstGLDisplay *display = NULL;
1151
1152       GST_GLIMAGE_SINK_LOCK (bsink);
1153       if (glimage_sink->context)
1154         context = gst_object_ref (glimage_sink->context);
1155       if (glimage_sink->other_context)
1156         other_context = gst_object_ref (glimage_sink->other_context);
1157       if (glimage_sink->display)
1158         display = gst_object_ref (glimage_sink->display);
1159       GST_GLIMAGE_SINK_UNLOCK (bsink);
1160
1161       res = gst_gl_handle_context_query ((GstElement *) glimage_sink, query,
1162           display, context, other_context);
1163
1164       if (context)
1165         gst_object_unref (context);
1166       if (other_context)
1167         gst_object_unref (other_context);
1168       if (display)
1169         gst_object_unref (display);
1170       if (res)
1171         return res;
1172       break;
1173     }
1174     case GST_QUERY_DRAIN:
1175     {
1176       GstBuffer *buf[2];
1177
1178       GST_GLIMAGE_SINK_LOCK (glimage_sink);
1179       glimage_sink->redisplay_texture = 0;
1180       buf[0] = glimage_sink->stored_buffer[0];
1181       buf[1] = glimage_sink->stored_buffer[1];
1182       glimage_sink->stored_buffer[0] = glimage_sink->stored_buffer[1] = NULL;
1183       glimage_sink->stored_sync_meta = glimage_sink->next_sync_meta = NULL;
1184       GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1185
1186       gst_buffer_replace (buf, NULL);
1187       gst_buffer_replace (buf + 1, NULL);
1188
1189       gst_buffer_replace (&glimage_sink->input_buffer, NULL);
1190       gst_buffer_replace (&glimage_sink->input_buffer2, NULL);
1191       gst_buffer_replace (&glimage_sink->next_buffer, NULL);
1192       gst_buffer_replace (&glimage_sink->next_buffer2, NULL);
1193       gst_buffer_replace (&glimage_sink->next_sync, NULL);
1194
1195       res = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
1196       break;
1197     }
1198     default:
1199       res = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
1200       break;
1201   }
1202
1203   return res;
1204 }
1205
1206 static void
1207 gst_glimage_sink_set_context (GstElement * element, GstContext * context)
1208 {
1209   GstGLImageSink *gl_sink = GST_GLIMAGE_SINK (element);
1210   GstGLContext *other_context = NULL;
1211   GstGLDisplay *display = NULL;
1212
1213   gst_gl_handle_set_context (element, context, &display, &other_context);
1214   _set_other_context (gl_sink, other_context);
1215   _set_display (gl_sink, display);
1216
1217   if (gl_sink->display)
1218     gst_gl_display_filter_gl_api (gl_sink->display, SUPPORTED_GL_APIS);
1219
1220   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
1221 }
1222
1223 static GstStateChangeReturn
1224 gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
1225 {
1226   GstGLImageSink *glimage_sink;
1227   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1228   GstGLContext *context;
1229
1230   GST_DEBUG ("changing state: %s => %s",
1231       gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
1232       gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
1233
1234   glimage_sink = GST_GLIMAGE_SINK (element);
1235
1236   switch (transition) {
1237     case GST_STATE_CHANGE_NULL_TO_READY:
1238       if (!gst_gl_ensure_element_data (glimage_sink, &glimage_sink->display,
1239               &glimage_sink->other_context))
1240         return GST_STATE_CHANGE_FAILURE;
1241
1242       gst_gl_display_filter_gl_api (glimage_sink->display, SUPPORTED_GL_APIS);
1243
1244       if (!_ensure_gl_setup (glimage_sink))
1245         return GST_STATE_CHANGE_FAILURE;
1246       break;
1247     case GST_STATE_CHANGE_READY_TO_PAUSED:
1248       g_atomic_int_set (&glimage_sink->to_quit, 0);
1249       break;
1250     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1251       break;
1252     default:
1253       break;
1254   }
1255
1256   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1257   if (ret == GST_STATE_CHANGE_FAILURE)
1258     return ret;
1259
1260   switch (transition) {
1261     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1262       break;
1263     case GST_STATE_CHANGE_PAUSED_TO_READY:
1264     {
1265       GstBuffer *buf[2];
1266
1267       GST_GLIMAGE_SINK_LOCK (glimage_sink);
1268       /* mark the redisplay_texture as unavailable (=0)
1269        * to avoid drawing
1270        */
1271       glimage_sink->redisplay_texture = 0;
1272       buf[0] = glimage_sink->stored_buffer[0];
1273       buf[1] = glimage_sink->stored_buffer[1];
1274       glimage_sink->stored_buffer[0] = glimage_sink->stored_buffer[1] = NULL;
1275       glimage_sink->stored_sync_meta = glimage_sink->next_sync_meta = NULL;
1276
1277       if (glimage_sink->stored_sync)
1278         gst_buffer_unref (glimage_sink->stored_sync);
1279       glimage_sink->stored_sync = NULL;
1280
1281       GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1282
1283       gst_buffer_replace (buf, NULL);
1284       gst_buffer_replace (buf + 1, NULL);
1285
1286       gst_object_replace ((GstObject **) & glimage_sink->convert_views, NULL);
1287       gst_buffer_replace (&glimage_sink->input_buffer, NULL);
1288       gst_buffer_replace (&glimage_sink->input_buffer2, NULL);
1289       gst_buffer_replace (&glimage_sink->next_buffer, NULL);
1290       gst_buffer_replace (&glimage_sink->next_buffer2, NULL);
1291       gst_buffer_replace (&glimage_sink->next_sync, NULL);
1292
1293       glimage_sink->window_id = 0;
1294       /* but do not reset glimage_sink->new_window_id */
1295
1296       GST_VIDEO_SINK_WIDTH (glimage_sink) = 1;
1297       GST_VIDEO_SINK_HEIGHT (glimage_sink) = 1;
1298       /* Clear cached caps */
1299       if (glimage_sink->out_caps) {
1300         gst_caps_unref (glimage_sink->out_caps);
1301         glimage_sink->out_caps = NULL;
1302       }
1303       if (glimage_sink->in_caps) {
1304         gst_caps_unref (glimage_sink->in_caps);
1305         glimage_sink->in_caps = NULL;
1306       }
1307       break;
1308     }
1309     case GST_STATE_CHANGE_READY_TO_NULL:
1310       if (glimage_sink->overlay_compositor) {
1311         gst_object_unref (glimage_sink->overlay_compositor);
1312         glimage_sink->overlay_compositor = NULL;
1313       }
1314
1315       context = NULL;
1316       GST_GLIMAGE_SINK_LOCK (glimage_sink);
1317       if (glimage_sink->context)
1318         context = gst_object_ref (glimage_sink->context);
1319       GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1320
1321       if (context) {
1322         GstGLWindow *window = gst_gl_context_get_window (context);
1323
1324         gst_gl_window_send_message (window,
1325             GST_GL_WINDOW_CB (gst_glimage_sink_cleanup_glthread), glimage_sink);
1326
1327         gst_gl_window_set_resize_callback (window, NULL, NULL, NULL);
1328         gst_gl_window_set_draw_callback (window, NULL, NULL, NULL);
1329         gst_gl_window_set_close_callback (window, NULL, NULL, NULL);
1330
1331         if (glimage_sink->key_sig_id)
1332           g_signal_handler_disconnect (window, glimage_sink->key_sig_id);
1333         glimage_sink->key_sig_id = 0;
1334         if (glimage_sink->mouse_sig_id)
1335           g_signal_handler_disconnect (window, glimage_sink->mouse_sig_id);
1336         glimage_sink->mouse_sig_id = 0;
1337         if (glimage_sink->mouse_scroll_sig_id)
1338           g_signal_handler_disconnect (window,
1339               glimage_sink->mouse_scroll_sig_id);
1340         glimage_sink->mouse_scroll_sig_id = 0;
1341
1342         gst_object_unref (window);
1343         _set_context (glimage_sink, NULL);
1344
1345         gst_object_unref (context);
1346       }
1347
1348       glimage_sink->window_id = 0;
1349
1350       _set_other_context (glimage_sink, NULL);
1351       _set_display (glimage_sink, NULL);
1352       break;
1353     default:
1354       break;
1355   }
1356
1357   return ret;
1358 }
1359
1360 static void
1361 gst_glimage_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
1362     GstClockTime * start, GstClockTime * end)
1363 {
1364   GstGLImageSink *glimagesink;
1365
1366   glimagesink = GST_GLIMAGE_SINK (bsink);
1367
1368   if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
1369     *start = GST_BUFFER_TIMESTAMP (buf);
1370     if (GST_BUFFER_DURATION_IS_VALID (buf))
1371       *end = *start + GST_BUFFER_DURATION (buf);
1372     else {
1373       if (GST_VIDEO_INFO_FPS_N (&glimagesink->out_info) > 0) {
1374         *end = *start +
1375             gst_util_uint64_scale_int (GST_SECOND,
1376             GST_VIDEO_INFO_FPS_D (&glimagesink->out_info),
1377             GST_VIDEO_INFO_FPS_N (&glimagesink->out_info));
1378       }
1379     }
1380   }
1381 }
1382
1383 static GstCaps *
1384 gst_glimage_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
1385 {
1386   GstCaps *tmp = NULL;
1387   GstCaps *result = NULL;
1388
1389   tmp = gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD (bsink));
1390
1391   if (filter) {
1392     GST_DEBUG_OBJECT (bsink, "intersecting with filter caps %" GST_PTR_FORMAT,
1393         filter);
1394
1395     result = gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
1396     gst_caps_unref (tmp);
1397   } else {
1398     result = tmp;
1399   }
1400
1401   result = gst_gl_overlay_compositor_add_caps (result);
1402
1403   GST_DEBUG_OBJECT (bsink, "returning caps: %" GST_PTR_FORMAT, result);
1404
1405   return result;
1406 }
1407
1408 static gboolean
1409 configure_display_from_info (GstGLImageSink * glimage_sink,
1410     const GstVideoInfo * vinfo)
1411 {
1412   gint width;
1413   gint height;
1414   gboolean ok;
1415   gint par_n, par_d;
1416   gint display_par_n, display_par_d;
1417   guint display_ratio_num, display_ratio_den;
1418
1419   width = GST_VIDEO_INFO_WIDTH (vinfo);
1420   height = GST_VIDEO_INFO_HEIGHT (vinfo);
1421
1422   par_n = GST_VIDEO_INFO_PAR_N (vinfo);
1423   par_d = GST_VIDEO_INFO_PAR_D (vinfo);
1424
1425   if (!par_n)
1426     par_n = 1;
1427
1428   /* get display's PAR */
1429   if (glimage_sink->par_n != 0 && glimage_sink->par_d != 0) {
1430     display_par_n = glimage_sink->par_n;
1431     display_par_d = glimage_sink->par_d;
1432   } else {
1433     display_par_n = 1;
1434     display_par_d = 1;
1435   }
1436
1437   ok = gst_video_calculate_display_ratio (&display_ratio_num,
1438       &display_ratio_den, width, height, par_n, par_d, display_par_n,
1439       display_par_d);
1440
1441   if (!ok)
1442     return FALSE;
1443
1444   GST_TRACE ("PAR: %u/%u DAR:%u/%u", par_n, par_d, display_par_n,
1445       display_par_d);
1446
1447   if (height % display_ratio_den == 0) {
1448     GST_DEBUG ("keeping video height");
1449     GST_VIDEO_SINK_WIDTH (glimage_sink) = (guint)
1450         gst_util_uint64_scale_int (height, display_ratio_num,
1451         display_ratio_den);
1452     GST_VIDEO_SINK_HEIGHT (glimage_sink) = height;
1453   } else if (width % display_ratio_num == 0) {
1454     GST_DEBUG ("keeping video width");
1455     GST_VIDEO_SINK_WIDTH (glimage_sink) = width;
1456     GST_VIDEO_SINK_HEIGHT (glimage_sink) = (guint)
1457         gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num);
1458   } else {
1459     GST_DEBUG ("approximating while keeping video height");
1460     GST_VIDEO_SINK_WIDTH (glimage_sink) = (guint)
1461         gst_util_uint64_scale_int (height, display_ratio_num,
1462         display_ratio_den);
1463     GST_VIDEO_SINK_HEIGHT (glimage_sink) = height;
1464   }
1465   GST_DEBUG ("scaling to %dx%d", GST_VIDEO_SINK_WIDTH (glimage_sink),
1466       GST_VIDEO_SINK_HEIGHT (glimage_sink));
1467
1468   return TRUE;
1469 }
1470
1471 static gboolean
1472 _mview_modes_are_equal (GstVideoMultiviewMode a, GstVideoMultiviewMode b)
1473 {
1474   if (a == b)
1475     return TRUE;
1476   if (a == GST_VIDEO_MULTIVIEW_MODE_NONE && b == GST_VIDEO_MULTIVIEW_MODE_MONO)
1477     return TRUE;
1478   if (a == GST_VIDEO_MULTIVIEW_MODE_MONO && b == GST_VIDEO_MULTIVIEW_MODE_NONE)
1479     return TRUE;
1480
1481   return FALSE;
1482 }
1483
1484 /* Called with GST_GLIMAGE_SINK lock held, to
1485  * copy in_info to out_info and update out_caps */
1486 static gboolean
1487 update_output_format (GstGLImageSink * glimage_sink)
1488 {
1489   GstVideoInfo *out_info = &glimage_sink->out_info;
1490   GstVideoMultiviewMode mv_mode;
1491   GstGLWindow *window = NULL;
1492   GstGLTextureTarget previous_target;
1493   GstStructure *s;
1494   const gchar *target_str;
1495   GstCaps *out_caps;
1496   gboolean ret;
1497
1498   *out_info = glimage_sink->in_info;
1499   previous_target = glimage_sink->texture_target;
1500
1501   mv_mode = GST_VIDEO_INFO_MULTIVIEW_MODE (&glimage_sink->in_info);
1502
1503   if (!_mview_modes_are_equal (glimage_sink->mview_output_mode, mv_mode)) {
1504     /* Input is multiview, and output wants a conversion - configure 3d converter now,
1505      * otherwise defer it until either the caps or the 3D output mode changes */
1506     gst_video_multiview_video_info_change_mode (out_info,
1507         glimage_sink->mview_output_mode, glimage_sink->mview_output_flags);
1508
1509     if (glimage_sink->convert_views == NULL) {
1510       glimage_sink->convert_views = gst_gl_view_convert_new ();
1511       gst_gl_view_convert_set_context (glimage_sink->convert_views,
1512           glimage_sink->context);
1513     }
1514   } else {
1515     if (glimage_sink->convert_views) {
1516       gst_object_unref (glimage_sink->convert_views);
1517       glimage_sink->convert_views = NULL;
1518     }
1519   }
1520
1521   ret = configure_display_from_info (glimage_sink, out_info);
1522
1523   if (glimage_sink->convert_views) {
1524     gint new_w, new_h;
1525     gint par_n, par_d;
1526
1527     /* Match actual output window size for pixel-aligned output,
1528      * even though we can't necessarily match the starting left/right
1529      * view parity properly for line-by-line modes, because that
1530      * depends on the window being placed correctly.
1531      * FIXME: Should this rescaling be configurable? */
1532     if (glimage_sink->display_rect.w > 0 && glimage_sink->display_rect.h > 0) {
1533       new_w = glimage_sink->display_rect.w;
1534       new_h = glimage_sink->display_rect.h;
1535       if (new_w != out_info->width || new_h != out_info->height) {
1536         /* Recalculate PAR if rescaling */
1537         gint from_dar_n, from_dar_d;
1538         if (!gst_util_fraction_multiply (out_info->width, out_info->height,
1539                 out_info->par_n, out_info->par_d, &from_dar_n,
1540                 &from_dar_d) ||
1541             !gst_util_fraction_multiply (from_dar_n, from_dar_d, new_h, new_w,
1542                 &par_n, &par_d)) {
1543           par_n = glimage_sink->par_n;
1544           par_d = glimage_sink->par_d;
1545         }
1546         out_info->par_n = par_n;
1547         out_info->par_d = par_d;
1548         out_info->width = new_w;
1549         out_info->height = new_h;
1550       }
1551
1552       GST_LOG_OBJECT (glimage_sink, "Set 3D output scale to %dx%d PAR %d/%d",
1553           out_info->width, out_info->height, out_info->par_n, out_info->par_d);
1554     }
1555   }
1556
1557   s = gst_caps_get_structure (glimage_sink->in_caps, 0);
1558   target_str = gst_structure_get_string (s, "texture-target");
1559
1560   if (!target_str)
1561     target_str = GST_GL_TEXTURE_TARGET_2D_STR;
1562
1563   glimage_sink->texture_target = gst_gl_texture_target_from_string (target_str);
1564   if (!glimage_sink->texture_target)
1565     return FALSE;
1566
1567   out_caps = gst_video_info_to_caps (out_info);
1568   gst_caps_set_features (out_caps, 0,
1569       gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_GL_MEMORY));
1570   gst_caps_set_simple (out_caps, "texture-target", G_TYPE_STRING,
1571       target_str, NULL);
1572
1573   if (glimage_sink->convert_views) {
1574     gst_caps_set_simple (out_caps, "texture-target", G_TYPE_STRING,
1575         GST_GL_TEXTURE_TARGET_2D_STR, NULL);
1576
1577     glimage_sink->texture_target = GST_GL_TEXTURE_TARGET_2D;
1578
1579     GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1580     gst_gl_view_convert_set_caps (glimage_sink->convert_views,
1581         glimage_sink->in_caps, out_caps);
1582     g_object_set (glimage_sink->convert_views, "downmix-mode",
1583         glimage_sink->mview_downmix_mode, NULL);
1584     GST_GLIMAGE_SINK_LOCK (glimage_sink);
1585   }
1586
1587   if (glimage_sink->out_caps)
1588     gst_caps_unref (glimage_sink->out_caps);
1589   glimage_sink->out_caps = out_caps;
1590
1591   if (previous_target != GST_GL_TEXTURE_TARGET_NONE &&
1592       glimage_sink->texture_target != previous_target) {
1593     /* regenerate the shader for the changed target */
1594     GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context);
1595     gst_gl_window_send_message (window,
1596         GST_GL_WINDOW_CB (gst_glimage_sink_cleanup_glthread), glimage_sink);
1597     gst_object_unref (window);
1598   }
1599
1600   glimage_sink->output_mode_changed = FALSE;
1601
1602   if (glimage_sink->context)
1603     window = gst_gl_context_get_window (glimage_sink->context);
1604   if (window) {
1605     gst_gl_window_queue_resize (window);
1606     gst_object_unref (window);
1607   }
1608
1609   return ret;
1610 }
1611
1612 static gboolean
1613 gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
1614 {
1615   GstGLImageSink *glimage_sink;
1616   gboolean ok;
1617   GstVideoInfo vinfo;
1618
1619   GST_DEBUG_OBJECT (bsink, "set caps with %" GST_PTR_FORMAT, caps);
1620
1621   glimage_sink = GST_GLIMAGE_SINK (bsink);
1622
1623   ok = gst_video_info_from_caps (&vinfo, caps);
1624   if (!ok)
1625     return FALSE;
1626
1627   if (!_ensure_gl_setup (glimage_sink))
1628     return FALSE;
1629
1630   GST_GLIMAGE_SINK_LOCK (glimage_sink);
1631   if (glimage_sink->in_caps)
1632     gst_caps_unref (glimage_sink->in_caps);
1633   glimage_sink->in_caps = gst_caps_ref (caps);
1634   glimage_sink->in_info = vinfo;
1635   ok = update_output_format (glimage_sink);
1636
1637   GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1638
1639   return ok;
1640 }
1641
1642 /* Take the input_buffer and run it through 3D conversion if needed.
1643  * Called with glimagesink lock, but might drop it temporarily */
1644 static gboolean
1645 prepare_next_buffer (GstGLImageSink * glimage_sink)
1646 {
1647   GstBuffer *in_buffer, *next_buffer, *old_buffer;
1648   GstBuffer *in_buffer2 = NULL, *next_buffer2 = NULL, *old_buffer2;
1649   GstBuffer *next_sync = NULL, *old_sync;
1650   GstGLSyncMeta *sync_meta;
1651   GstVideoFrame gl_frame;
1652   GstGLViewConvert *convert_views = NULL;
1653   GstVideoInfo *info;
1654
1655   if (glimage_sink->input_buffer == NULL)
1656     return TRUE;                /* No input buffer to process */
1657
1658   if (GST_VIDEO_INFO_MULTIVIEW_MODE (&glimage_sink->in_info) ==
1659       GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME) {
1660     if (glimage_sink->input_buffer2 == NULL)
1661       return TRUE;              /* Need 2nd input buffer to process */
1662     in_buffer2 = gst_buffer_ref (glimage_sink->input_buffer2);
1663   }
1664
1665   in_buffer = gst_buffer_ref (glimage_sink->input_buffer);
1666   if (glimage_sink->convert_views &&
1667       (GST_VIDEO_INFO_MULTIVIEW_MODE (&glimage_sink->in_info) !=
1668           GST_VIDEO_INFO_MULTIVIEW_MODE (&glimage_sink->out_info) ||
1669           GST_VIDEO_INFO_MULTIVIEW_FLAGS (&glimage_sink->in_info) !=
1670           GST_VIDEO_INFO_MULTIVIEW_FLAGS (&glimage_sink->out_info)))
1671     convert_views = gst_object_ref (glimage_sink->convert_views);
1672
1673   GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1674
1675   if (convert_views) {
1676     info = &glimage_sink->out_info;
1677
1678     if (gst_gl_view_convert_submit_input_buffer (glimage_sink->convert_views,
1679             GST_BUFFER_IS_DISCONT (in_buffer), in_buffer) != GST_FLOW_OK) {
1680       gst_buffer_replace (&in_buffer2, NULL);
1681       goto fail;
1682     }
1683     if (in_buffer2) {
1684       if (gst_gl_view_convert_submit_input_buffer (glimage_sink->convert_views,
1685               GST_BUFFER_IS_DISCONT (in_buffer2), in_buffer2) != GST_FLOW_OK) {
1686         goto fail;
1687       }
1688     }
1689
1690     if (gst_gl_view_convert_get_output (glimage_sink->convert_views,
1691             &next_buffer) != GST_FLOW_OK)
1692       goto fail;
1693     if (GST_VIDEO_INFO_MULTIVIEW_MODE (info) ==
1694         GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME) {
1695       if (gst_gl_view_convert_get_output (glimage_sink->convert_views,
1696               &next_buffer2) != GST_FLOW_OK)
1697         goto fail;
1698     }
1699     gst_object_unref (convert_views);
1700     convert_views = NULL;
1701
1702     if (next_buffer == NULL) {
1703       /* Not ready to paint a buffer yet */
1704       GST_GLIMAGE_SINK_LOCK (glimage_sink);
1705       return TRUE;
1706     }
1707   } else {
1708     next_buffer = in_buffer;
1709     info = &glimage_sink->in_info;
1710   }
1711
1712   if (!glimage_sink->overlay_compositor) {
1713     if (!(glimage_sink->overlay_compositor =
1714             gst_gl_overlay_compositor_new (glimage_sink->context))) {
1715       gst_buffer_unref (next_buffer);
1716       goto fail;
1717     }
1718   }
1719
1720   gst_gl_overlay_compositor_upload_overlays (glimage_sink->overlay_compositor,
1721       next_buffer);
1722
1723   sync_meta = gst_buffer_get_gl_sync_meta (next_buffer);
1724
1725   if (!sync_meta) {
1726     next_sync = gst_buffer_new ();
1727     sync_meta = gst_buffer_add_gl_sync_meta (glimage_sink->context, next_sync);
1728     gst_gl_sync_meta_set_sync_point (sync_meta, glimage_sink->context);
1729   }
1730
1731   /* in_buffer invalid now */
1732   if (!gst_video_frame_map (&gl_frame, info, next_buffer,
1733           GST_MAP_READ | GST_MAP_GL)) {
1734     gst_buffer_unref (next_buffer);
1735     GST_ERROR ("Failed to map video frame.");
1736     goto fail;
1737   }
1738
1739   GST_GLIMAGE_SINK_LOCK (glimage_sink);
1740   glimage_sink->next_tex = *(guint *) gl_frame.data[0];
1741
1742   old_buffer = glimage_sink->next_buffer;
1743   glimage_sink->next_buffer = next_buffer;
1744   old_buffer2 = glimage_sink->next_buffer2;
1745   glimage_sink->next_buffer2 = next_buffer2;
1746
1747   old_sync = glimage_sink->next_sync;
1748   glimage_sink->next_sync = next_sync;
1749   glimage_sink->next_sync_meta = sync_meta;
1750
1751   /* Need to drop the lock again, to avoid a deadlock if we're
1752    * dropping the last ref on this buffer and it goes back to our
1753    * allocator */
1754   GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1755
1756   if (old_buffer)
1757     gst_buffer_unref (old_buffer);
1758   if (old_buffer2)
1759     gst_buffer_unref (old_buffer2);
1760   if (old_sync)
1761     gst_buffer_unref (old_sync);
1762   gst_video_frame_unmap (&gl_frame);
1763
1764   GST_GLIMAGE_SINK_LOCK (glimage_sink);
1765
1766   return TRUE;
1767
1768 fail:
1769   if (convert_views)
1770     gst_object_unref (convert_views);
1771   GST_GLIMAGE_SINK_LOCK (glimage_sink);
1772   return FALSE;
1773 }
1774
1775 static GstFlowReturn
1776 gst_glimage_sink_prepare (GstBaseSink * bsink, GstBuffer * buf)
1777 {
1778   GstGLImageSink *glimage_sink;
1779   GstGLSyncMeta *sync_meta;
1780   GstBuffer **target;
1781   GstBuffer *old_input;
1782
1783   glimage_sink = GST_GLIMAGE_SINK (bsink);
1784
1785   GST_TRACE ("preparing buffer:%p", buf);
1786
1787   if (GST_VIDEO_SINK_WIDTH (glimage_sink) < 1 ||
1788       GST_VIDEO_SINK_HEIGHT (glimage_sink) < 1) {
1789     return GST_FLOW_NOT_NEGOTIATED;
1790   }
1791
1792   if (!_ensure_gl_setup (glimage_sink))
1793     return GST_FLOW_NOT_NEGOTIATED;
1794
1795   sync_meta = gst_buffer_get_gl_sync_meta (buf);
1796   if (sync_meta)
1797     gst_gl_sync_meta_wait (sync_meta, glimage_sink->context);
1798
1799   GST_GLIMAGE_SINK_LOCK (glimage_sink);
1800   if (glimage_sink->window_resized) {
1801     glimage_sink->window_resized = FALSE;
1802     GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1803     GST_DEBUG_OBJECT (glimage_sink, "Sending reconfigure event on sinkpad.");
1804     gst_pad_push_event (GST_BASE_SINK (glimage_sink)->sinkpad,
1805         gst_event_new_reconfigure ());
1806     GST_GLIMAGE_SINK_LOCK (glimage_sink);
1807   }
1808
1809   target = &glimage_sink->input_buffer;
1810   if (GST_VIDEO_INFO_MULTIVIEW_MODE (&glimage_sink->in_info) ==
1811       GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME &&
1812       !GST_BUFFER_FLAG_IS_SET (buf, GST_VIDEO_BUFFER_FLAG_FIRST_IN_BUNDLE)) {
1813     target = &glimage_sink->input_buffer2;
1814   }
1815   old_input = *target;
1816   *target = gst_buffer_ref (buf);
1817
1818   if (glimage_sink->output_mode_changed)
1819     update_output_format (glimage_sink);
1820
1821   if (!prepare_next_buffer (glimage_sink)) {
1822     GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1823     if (old_input)
1824       gst_buffer_unref (old_input);
1825     goto convert_views_failed;
1826   }
1827   GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1828
1829   if (old_input)
1830     gst_buffer_unref (old_input);
1831
1832   if (glimage_sink->window_id != glimage_sink->new_window_id) {
1833     GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context);
1834
1835     glimage_sink->window_id = glimage_sink->new_window_id;
1836     gst_gl_window_set_window_handle (window, glimage_sink->window_id);
1837
1838     gst_object_unref (window);
1839   }
1840
1841   return GST_FLOW_OK;
1842 convert_views_failed:
1843   {
1844     GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
1845         ("%s", "Failed to convert multiview video buffer"), (NULL));
1846     return GST_FLOW_ERROR;
1847   }
1848 }
1849
1850 static GstFlowReturn
1851 gst_glimage_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
1852 {
1853   GstGLImageSink *glimage_sink;
1854
1855   GST_TRACE ("rendering buffer:%p", buf);
1856
1857   glimage_sink = GST_GLIMAGE_SINK (vsink);
1858
1859   GST_TRACE ("redisplay texture:%u of size:%ux%u, window size:%ux%u",
1860       glimage_sink->next_tex, GST_VIDEO_INFO_WIDTH (&glimage_sink->out_info),
1861       GST_VIDEO_INFO_HEIGHT (&glimage_sink->out_info),
1862       GST_VIDEO_SINK_WIDTH (glimage_sink),
1863       GST_VIDEO_SINK_HEIGHT (glimage_sink));
1864
1865   /* Ask the underlying window to redraw its content */
1866   if (!gst_glimage_sink_redisplay (glimage_sink))
1867     goto redisplay_failed;
1868
1869   GST_TRACE ("post redisplay");
1870
1871   if (g_atomic_int_get (&glimage_sink->to_quit) != 0) {
1872     GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
1873         ("%s", "Quit requested"), (NULL));
1874     return GST_FLOW_ERROR;
1875   }
1876
1877   return GST_FLOW_OK;
1878
1879 /* ERRORS */
1880 redisplay_failed:
1881   {
1882     GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
1883         ("%s", "Window redisplay failed"), (NULL));
1884     return GST_FLOW_ERROR;
1885   }
1886 }
1887
1888 static void
1889 gst_glimage_sink_video_overlay_init (GstVideoOverlayInterface * iface)
1890 {
1891   iface->set_window_handle = gst_glimage_sink_set_window_handle;
1892   iface->set_render_rectangle = gst_glimage_sink_set_render_rectangle;
1893   iface->handle_events = gst_glimage_sink_handle_events;
1894   iface->expose = gst_glimage_sink_expose;
1895 }
1896
1897 static void
1898 gst_glimage_sink_set_window_handle (GstVideoOverlay * overlay, guintptr id)
1899 {
1900   GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (overlay);
1901   guintptr window_id = (guintptr) id;
1902
1903   g_return_if_fail (GST_IS_GLIMAGE_SINK (overlay));
1904
1905   GST_DEBUG ("set_xwindow_id %" G_GUINT64_FORMAT, (guint64) window_id);
1906
1907   glimage_sink->new_window_id = window_id;
1908 }
1909
1910
1911 static void
1912 gst_glimage_sink_expose (GstVideoOverlay * overlay)
1913 {
1914   GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (overlay);
1915
1916   /* redisplay opengl scene */
1917   if (glimage_sink->display) {
1918     if (glimage_sink->window_id
1919         && glimage_sink->window_id != glimage_sink->new_window_id) {
1920       GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context);
1921
1922       glimage_sink->window_id = glimage_sink->new_window_id;
1923       gst_gl_window_set_window_handle (window, glimage_sink->window_id);
1924
1925       gst_object_unref (window);
1926     }
1927
1928     gst_glimage_sink_redisplay (glimage_sink);
1929   }
1930 }
1931
1932 static void
1933 gst_glimage_sink_handle_events (GstVideoOverlay * overlay,
1934     gboolean handle_events)
1935 {
1936   GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (overlay);
1937
1938   glimage_sink->handle_events = handle_events;
1939   if (G_LIKELY (glimage_sink->context)) {
1940     GstGLWindow *window;
1941     window = gst_gl_context_get_window (glimage_sink->context);
1942     gst_gl_window_handle_events (window, handle_events);
1943     gst_object_unref (window);
1944   }
1945 }
1946
1947 static void
1948 gst_glimage_sink_set_render_rectangle (GstVideoOverlay * overlay,
1949     gint x, gint y, gint width, gint height)
1950 {
1951   GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (overlay);
1952
1953   if (G_LIKELY (glimage_sink->context)) {
1954     GstGLWindow *window;
1955     window = gst_gl_context_get_window (glimage_sink->context);
1956     gst_gl_window_set_render_rectangle (window, x, y, width, height);
1957     gst_object_unref (window);
1958   }
1959
1960   glimage_sink->x = x;
1961   glimage_sink->y = y;
1962   glimage_sink->width = width;
1963   glimage_sink->height = height;
1964 }
1965
1966 static gboolean
1967 gst_glimage_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
1968 {
1969   GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (bsink);
1970   GstStructure *config;
1971   GstCaps *caps;
1972   GstBufferPool *pool = NULL;
1973   GstVideoInfo info;
1974   guint size;
1975   gboolean need_pool;
1976   GstStructure *allocation_meta = NULL;
1977   GstGLContext *context = NULL;
1978
1979   if (!_ensure_gl_setup (glimage_sink))
1980     return FALSE;
1981
1982   GST_GLIMAGE_SINK_LOCK (glimage_sink);
1983   if (glimage_sink->context)
1984     context = gst_object_ref (glimage_sink->context);
1985   GST_GLIMAGE_SINK_UNLOCK (glimage_sink);
1986
1987   if (!context)
1988     return FALSE;
1989
1990   gst_query_parse_allocation (query, &caps, &need_pool);
1991
1992   if (caps == NULL)
1993     goto no_caps;
1994
1995   if (!gst_video_info_from_caps (&info, caps))
1996     goto invalid_caps;
1997
1998   /* the normal size of a frame */
1999   size = info.size;
2000
2001   if (need_pool) {
2002     GST_DEBUG_OBJECT (glimage_sink, "create new pool");
2003
2004     pool = gst_gl_buffer_pool_new (context);
2005     config = gst_buffer_pool_get_config (pool);
2006     gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
2007     gst_buffer_pool_config_add_option (config,
2008         GST_BUFFER_POOL_OPTION_GL_SYNC_META);
2009
2010     if (!gst_buffer_pool_set_config (pool, config)) {
2011       g_object_unref (pool);
2012       goto config_failed;
2013     }
2014   }
2015
2016   /* we need at least 2 buffer because we hold on to the last one */
2017   gst_query_add_allocation_pool (query, pool, size, 2, 0);
2018   if (pool)
2019     g_object_unref (pool);
2020
2021   if (context->gl_vtable->FenceSync)
2022     gst_query_add_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, 0);
2023
2024   if (glimage_sink->window_width != 0 && glimage_sink->window_height != 0) {
2025     allocation_meta =
2026         gst_structure_new ("GstVideoOverlayCompositionMeta",
2027         "width", G_TYPE_UINT, glimage_sink->window_width,
2028         "height", G_TYPE_UINT, glimage_sink->window_height, NULL);
2029     GST_DEBUG ("sending alloc query with size %dx%d",
2030         glimage_sink->window_width, glimage_sink->window_height);
2031   }
2032
2033   gst_query_add_allocation_meta (query,
2034       GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, allocation_meta);
2035   gst_query_add_allocation_meta (query,
2036       GST_VIDEO_AFFINE_TRANSFORMATION_META_API_TYPE, 0);
2037
2038   if (allocation_meta)
2039     gst_structure_free (allocation_meta);
2040
2041   gst_object_unref (context);
2042   return TRUE;
2043
2044   /* ERRORS */
2045 no_caps:
2046   {
2047     gst_object_unref (context);
2048     GST_WARNING_OBJECT (bsink, "no caps specified");
2049     return FALSE;
2050   }
2051 invalid_caps:
2052   {
2053     gst_object_unref (context);
2054     GST_WARNING_OBJECT (bsink, "invalid caps specified");
2055     return FALSE;
2056   }
2057 config_failed:
2058   {
2059     gst_object_unref (context);
2060     GST_WARNING_OBJECT (bsink, "failed setting config");
2061     return FALSE;
2062   }
2063 }
2064
2065 /* *INDENT-OFF* */
2066 static const GLfloat vertices[] = {
2067      1.0f,  1.0f, 0.0f, 1.0f, 0.0f,
2068     -1.0f,  1.0f, 0.0f, 0.0f, 0.0f,
2069     -1.0f, -1.0f, 0.0f, 0.0f, 1.0f,
2070      1.0f, -1.0f, 0.0f, 1.0f, 1.0f
2071 };
2072
2073 static const GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
2074 /* *INDENT-ON* */
2075
2076 static void
2077 _bind_buffer (GstGLImageSink * gl_sink)
2078 {
2079   const GstGLFuncs *gl = gl_sink->context->gl_vtable;
2080
2081   gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, gl_sink->vbo_indices);
2082   gl->BindBuffer (GL_ARRAY_BUFFER, gl_sink->vertex_buffer);
2083
2084   /* Load the vertex position */
2085   gl->VertexAttribPointer (gl_sink->attr_position, 3, GL_FLOAT, GL_FALSE,
2086       5 * sizeof (GLfloat), (void *) 0);
2087
2088   /* Load the texture coordinate */
2089   gl->VertexAttribPointer (gl_sink->attr_texture, 2, GL_FLOAT, GL_FALSE,
2090       5 * sizeof (GLfloat), (void *) (3 * sizeof (GLfloat)));
2091
2092   gl->EnableVertexAttribArray (gl_sink->attr_position);
2093   gl->EnableVertexAttribArray (gl_sink->attr_texture);
2094 }
2095
2096 static void
2097 _unbind_buffer (GstGLImageSink * gl_sink)
2098 {
2099   const GstGLFuncs *gl = gl_sink->context->gl_vtable;
2100
2101   gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
2102   gl->BindBuffer (GL_ARRAY_BUFFER, 0);
2103
2104   gl->DisableVertexAttribArray (gl_sink->attr_position);
2105   gl->DisableVertexAttribArray (gl_sink->attr_texture);
2106 }
2107
2108 /* Called in the gl thread */
2109 static void
2110 gst_glimage_sink_thread_init_redisplay (GstGLImageSink * gl_sink)
2111 {
2112   const GstGLFuncs *gl = gl_sink->context->gl_vtable;
2113   GError *error = NULL;
2114   GstGLSLStage *frag_stage, *vert_stage;
2115
2116   vert_stage = gst_glsl_stage_new_with_string (gl_sink->context,
2117       GL_VERTEX_SHADER, GST_GLSL_VERSION_NONE,
2118       GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY,
2119       gst_gl_shader_string_vertex_mat4_vertex_transform);
2120   if (gl_sink->texture_target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES) {
2121     gchar *frag_str;
2122     frag_str =
2123         gst_gl_shader_string_fragment_external_oes_get_default
2124         (gl_sink->context, GST_GLSL_VERSION_NONE,
2125         GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY);
2126
2127     frag_stage = gst_glsl_stage_new_with_string (gl_sink->context,
2128         GL_FRAGMENT_SHADER, GST_GLSL_VERSION_NONE,
2129         GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, frag_str);
2130
2131     g_free (frag_str);
2132   } else {
2133     frag_stage = gst_glsl_stage_new_default_fragment (gl_sink->context);
2134   }
2135   if (!vert_stage || !frag_stage) {
2136     GST_ERROR_OBJECT (gl_sink, "Failed to retrieve fragment shader for "
2137         "texture target");
2138     if (vert_stage)
2139       gst_object_unref (vert_stage);
2140     if (frag_stage)
2141       gst_object_unref (frag_stage);
2142     gst_glimage_sink_cleanup_glthread (gl_sink);
2143     return;
2144   }
2145
2146   if (!(gl_sink->redisplay_shader =
2147           gst_gl_shader_new_link_with_stages (gl_sink->context, &error,
2148               vert_stage, frag_stage, NULL))) {
2149     GST_ERROR_OBJECT (gl_sink, "Failed to link shader: %s", error->message);
2150     gst_glimage_sink_cleanup_glthread (gl_sink);
2151     return;
2152   }
2153
2154   gl_sink->attr_position =
2155       gst_gl_shader_get_attribute_location (gl_sink->redisplay_shader,
2156       "a_position");
2157   gl_sink->attr_texture =
2158       gst_gl_shader_get_attribute_location (gl_sink->redisplay_shader,
2159       "a_texcoord");
2160
2161   if (gl->GenVertexArrays) {
2162     gl->GenVertexArrays (1, &gl_sink->vao);
2163     gl->BindVertexArray (gl_sink->vao);
2164   }
2165
2166   if (!gl_sink->vertex_buffer) {
2167     gl->GenBuffers (1, &gl_sink->vertex_buffer);
2168     gl->BindBuffer (GL_ARRAY_BUFFER, gl_sink->vertex_buffer);
2169     gl->BufferData (GL_ARRAY_BUFFER, 4 * 5 * sizeof (GLfloat), vertices,
2170         GL_STATIC_DRAW);
2171   }
2172
2173   if (!gl_sink->vbo_indices) {
2174     gl->GenBuffers (1, &gl_sink->vbo_indices);
2175     gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, gl_sink->vbo_indices);
2176     gl->BufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices,
2177         GL_STATIC_DRAW);
2178   }
2179
2180   if (gl->GenVertexArrays) {
2181     _bind_buffer (gl_sink);
2182     gl->BindVertexArray (0);
2183   }
2184
2185   gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
2186   gl->BindBuffer (GL_ARRAY_BUFFER, 0);
2187 }
2188
2189 static void
2190 gst_glimage_sink_cleanup_glthread (GstGLImageSink * gl_sink)
2191 {
2192   const GstGLFuncs *gl = gl_sink->context->gl_vtable;
2193
2194   if (gl_sink->redisplay_shader) {
2195     gst_object_unref (gl_sink->redisplay_shader);
2196     gl_sink->redisplay_shader = NULL;
2197   }
2198
2199   if (gl_sink->vao) {
2200     gl->DeleteVertexArrays (1, &gl_sink->vao);
2201     gl_sink->vao = 0;
2202   }
2203
2204   if (gl_sink->vertex_buffer) {
2205     gl->DeleteBuffers (1, &gl_sink->vertex_buffer);
2206     gl_sink->vertex_buffer = 0;
2207   }
2208
2209   if (gl_sink->vbo_indices) {
2210     gl->DeleteBuffers (1, &gl_sink->vbo_indices);
2211     gl_sink->vbo_indices = 0;
2212   }
2213
2214   if (gl_sink->overlay_compositor)
2215     gst_gl_overlay_compositor_free_overlays (gl_sink->overlay_compositor);
2216 }
2217
2218 /* Called with object lock held */
2219 static void
2220 gst_glimage_sink_on_resize (GstGLImageSink * gl_sink, gint width, gint height)
2221 {
2222   /* Here gl_sink members (ex:gl_sink->out_info) have a life time of set_caps.
2223    * It means that they cannot change between two set_caps
2224    */
2225   const GstGLFuncs *gl;
2226   gboolean do_reshape;
2227
2228   GST_DEBUG_OBJECT (gl_sink, "GL Window resized to %ux%u", width, height);
2229
2230   /* check if a client reshape callback is registered */
2231   g_signal_emit (gl_sink, gst_glimage_sink_signals[CLIENT_RESHAPE_SIGNAL], 0,
2232       gl_sink->context, width, height, &do_reshape);
2233   GST_GLIMAGE_SINK_LOCK (gl_sink);
2234
2235   gl = gl_sink->context->gl_vtable;
2236   width = MAX (1, width);
2237   height = MAX (1, height);
2238
2239   /* Check if we would suggest a different width/height now */
2240   gl_sink->window_resized = ((gl_sink->window_width != width)
2241       || (gl_sink->window_height != height))
2242       && (gl_sink->window_width != 0)
2243       && (gl_sink->window_height != 0);
2244
2245   gl_sink->window_width = width;
2246   gl_sink->window_height = height;
2247
2248   gst_gl_insert_debug_marker (gl_sink->context, "%s window resize to %ix%i",
2249       GST_OBJECT_NAME (gl_sink), width, height);
2250
2251   /* default reshape */
2252   if (!do_reshape) {
2253     if (gl_sink->keep_aspect_ratio) {
2254       GstVideoRectangle src, dst, result;
2255
2256       src.x = 0;
2257       src.y = 0;
2258       if (gl_sink->current_rotate_method == GST_VIDEO_ORIENTATION_90R
2259           || gl_sink->current_rotate_method == GST_VIDEO_ORIENTATION_90L
2260           || gl_sink->current_rotate_method == GST_VIDEO_ORIENTATION_UL_LR
2261           || gl_sink->current_rotate_method == GST_VIDEO_ORIENTATION_UR_LL) {
2262         src.h = GST_VIDEO_SINK_WIDTH (gl_sink);
2263         src.w = GST_VIDEO_SINK_HEIGHT (gl_sink);
2264       } else {
2265         src.w = GST_VIDEO_SINK_WIDTH (gl_sink);
2266         src.h = GST_VIDEO_SINK_HEIGHT (gl_sink);
2267       }
2268
2269       dst.x = 0;
2270       dst.y = 0;
2271       dst.w = width;
2272       dst.h = height;
2273
2274       gst_video_sink_center_rect (src, dst, &result, TRUE);
2275       gl_sink->output_mode_changed |= (result.w != gl_sink->display_rect.w);
2276       gl_sink->output_mode_changed |= (result.h != gl_sink->display_rect.h);
2277       gl_sink->display_rect = result;
2278     } else {
2279       gl_sink->output_mode_changed |= (width != gl_sink->display_rect.w);
2280       gl_sink->output_mode_changed |= (height != gl_sink->display_rect.h);
2281
2282       gl_sink->display_rect.x = 0;
2283       gl_sink->display_rect.y = 0;
2284       gl_sink->display_rect.w = width;
2285       gl_sink->display_rect.h = height;
2286     }
2287
2288     gl->Viewport (gl_sink->display_rect.x, gl_sink->display_rect.y,
2289         gl_sink->display_rect.w, gl_sink->display_rect.h);
2290     GST_DEBUG_OBJECT (gl_sink, "GL output area now %u,%u %ux%u",
2291         gl_sink->display_rect.x, gl_sink->display_rect.y,
2292         gl_sink->display_rect.w, gl_sink->display_rect.h);
2293   } else {
2294     gint viewport_dims[4];
2295
2296     /* save the viewport for use later */
2297     gl->GetIntegerv (GL_VIEWPORT, viewport_dims);
2298
2299     gl_sink->display_rect.x = viewport_dims[0];
2300     gl_sink->display_rect.y = viewport_dims[1];
2301     gl_sink->display_rect.w = viewport_dims[2];
2302     gl_sink->display_rect.h = viewport_dims[3];
2303   }
2304   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
2305 }
2306
2307 static void
2308 gst_glimage_sink_on_draw (GstGLImageSink * gl_sink)
2309 {
2310   /* Here gl_sink members (ex:gl_sink->out_info) have a life time of set_caps.
2311    * It means that they cannot not change between two set_caps as well as
2312    * for the redisplay_texture size.
2313    * Whereas redisplay_texture id changes every sink_render
2314    */
2315
2316   const GstGLFuncs *gl = NULL;
2317   GstGLWindow *window = NULL;
2318   gboolean do_redisplay = FALSE;
2319   GstSample *sample = NULL;
2320   guint gl_target = gst_gl_texture_target_to_gl (gl_sink->texture_target);
2321
2322   g_return_if_fail (GST_IS_GLIMAGE_SINK (gl_sink));
2323
2324   GST_GLIMAGE_SINK_LOCK (gl_sink);
2325
2326   gl = gl_sink->context->gl_vtable;
2327
2328   /* check if texture is ready for being drawn */
2329   if (!gl_sink->redisplay_texture) {
2330     GST_GLIMAGE_SINK_UNLOCK (gl_sink);
2331     return;
2332   }
2333
2334   window = gst_gl_context_get_window (gl_sink->context);
2335   window->is_drawing = TRUE;
2336
2337   /* opengl scene */
2338   gst_gl_insert_debug_marker (gl_sink->context, "%s element drawing texture %u",
2339       GST_OBJECT_NAME (gl_sink), gl_sink->redisplay_texture);
2340   GST_TRACE ("redrawing texture:%u", gl_sink->redisplay_texture);
2341
2342   if (gl_sink->stored_sync_meta)
2343     gst_gl_sync_meta_wait (gl_sink->stored_sync_meta,
2344         gst_gl_context_get_current ());
2345
2346   /* make sure that the environment is clean */
2347   gst_gl_context_clear_shader (gl_sink->context);
2348   gl->BindTexture (gl_target, 0);
2349
2350   if (!gst_gl_window_controls_viewport (window)) {
2351     gl->Viewport (gl_sink->display_rect.x, gl_sink->display_rect.y,
2352         gl_sink->display_rect.w, gl_sink->display_rect.h);
2353     GST_DEBUG_OBJECT (gl_sink, "GL output area now %u,%u %ux%u",
2354         gl_sink->display_rect.x, gl_sink->display_rect.y,
2355         gl_sink->display_rect.w, gl_sink->display_rect.h);
2356   }
2357
2358   sample = gst_sample_new (gl_sink->stored_buffer[0],
2359       gl_sink->out_caps, &GST_BASE_SINK (gl_sink)->segment, NULL);
2360   g_signal_emit (gl_sink, gst_glimage_sink_signals[CLIENT_DRAW_SIGNAL], 0,
2361       gl_sink->context, sample, &do_redisplay);
2362   gst_sample_unref (sample);
2363
2364   if (gl_sink->stored_buffer[1]) {
2365     sample = gst_sample_new (gl_sink->stored_buffer[1],
2366         gl_sink->out_caps, &GST_BASE_SINK (gl_sink)->segment, NULL);
2367     g_signal_emit (gl_sink, gst_glimage_sink_signals[CLIENT_DRAW_SIGNAL], 0,
2368         gl_sink->context, sample, &do_redisplay);
2369     gst_sample_unref (sample);
2370   }
2371
2372   if (!do_redisplay) {
2373     gfloat alpha = gl_sink->ignore_alpha ? 1.0f : 0.0f;
2374
2375     gl->ClearColor (0.0, 0.0, 0.0, alpha);
2376     gl->Clear (GL_COLOR_BUFFER_BIT);
2377
2378     if (gl_sink->ignore_alpha) {
2379       gl->BlendColor (0.0, 0.0, 0.0, alpha);
2380       if (gl->BlendFuncSeparate) {
2381         gl->BlendFuncSeparate (GL_SRC_ALPHA, GL_CONSTANT_COLOR, GL_ONE,
2382             GL_ONE_MINUS_SRC_ALPHA);
2383       } else {
2384         /* we don't have separate blend modes, perform something close to
2385          * correct instead */
2386         gl->BlendFunc (GL_SRC_ALPHA, GL_CONSTANT_COLOR);
2387       }
2388       gl->BlendEquation (GL_FUNC_ADD);
2389       gl->Enable (GL_BLEND);
2390     }
2391
2392     gst_gl_shader_use (gl_sink->redisplay_shader);
2393
2394     if (gl->GenVertexArrays)
2395       gl->BindVertexArray (gl_sink->vao);
2396     _bind_buffer (gl_sink);
2397
2398     gl->ActiveTexture (GL_TEXTURE0);
2399     gl->BindTexture (gl_target, gl_sink->redisplay_texture);
2400     gst_gl_shader_set_uniform_1i (gl_sink->redisplay_shader, "tex", 0);
2401     {
2402       GstVideoAffineTransformationMeta *af_meta;
2403       gfloat matrix[16];
2404
2405       af_meta =
2406           gst_buffer_get_video_affine_transformation_meta
2407           (gl_sink->stored_buffer[0]);
2408
2409       if (gl_sink->transform_matrix) {
2410         gfloat tmp[16];
2411
2412         gst_gl_get_affine_transformation_meta_as_ndc_ext (af_meta, tmp);
2413         gst_gl_multiply_matrix4 (tmp, gl_sink->transform_matrix, matrix);
2414       } else {
2415         gst_gl_get_affine_transformation_meta_as_ndc_ext (af_meta, matrix);
2416       }
2417
2418       gst_gl_shader_set_uniform_matrix_4fv (gl_sink->redisplay_shader,
2419           "u_transformation", 1, FALSE, matrix);
2420     }
2421
2422     gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
2423
2424     gl->BindTexture (gl_target, 0);
2425     gst_gl_context_clear_shader (gl_sink->context);
2426
2427     if (gl->GenVertexArrays)
2428       gl->BindVertexArray (0);
2429     else
2430       _unbind_buffer (gl_sink);
2431
2432     if (gl_sink->ignore_alpha)
2433       gl->Disable (GL_BLEND);
2434
2435     gst_gl_overlay_compositor_draw_overlays (gl_sink->overlay_compositor);
2436   }
2437   /* end default opengl scene */
2438   window->is_drawing = FALSE;
2439   gst_object_unref (window);
2440
2441   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
2442 }
2443
2444 static void
2445 gst_glimage_sink_on_close (GstGLImageSink * gl_sink)
2446 {
2447   GstGLWindow *window;
2448
2449   GST_WARNING_OBJECT (gl_sink, "Output window was closed");
2450
2451   window = gst_gl_context_get_window (gl_sink->context);
2452
2453   if (gl_sink->key_sig_id)
2454     g_signal_handler_disconnect (window, gl_sink->key_sig_id);
2455   gl_sink->key_sig_id = 0;
2456   if (gl_sink->mouse_sig_id)
2457     g_signal_handler_disconnect (window, gl_sink->mouse_sig_id);
2458   gl_sink->mouse_sig_id = 0;
2459   if (gl_sink->mouse_scroll_sig_id)
2460     g_signal_handler_disconnect (window, gl_sink->mouse_scroll_sig_id);
2461   gl_sink->mouse_scroll_sig_id = 0;
2462
2463   g_atomic_int_set (&gl_sink->to_quit, 1);
2464
2465   gst_object_unref (window);
2466 }
2467
2468 static gboolean
2469 gst_glimage_sink_redisplay (GstGLImageSink * gl_sink)
2470 {
2471   GstGLWindow *window;
2472   GstBuffer *old_stored_buffer[2], *old_sync;
2473   gulong handler_id;
2474
2475   window = gst_gl_context_get_window (gl_sink->context);
2476   if (!window)
2477     return FALSE;
2478
2479   handler_id =
2480       g_signal_handler_find (GST_ELEMENT_PARENT (gl_sink), G_SIGNAL_MATCH_ID,
2481       gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_DRAW], 0,
2482       NULL, NULL, NULL);
2483
2484   if (G_UNLIKELY (!gl_sink->redisplay_shader) && (!handler_id
2485           || !gl_sink->other_context)) {
2486     gst_gl_window_send_message (window,
2487         GST_GL_WINDOW_CB (gst_glimage_sink_thread_init_redisplay), gl_sink);
2488
2489     /* if the shader is still null it means it failed to be useable */
2490     if (G_UNLIKELY (!gl_sink->redisplay_shader)) {
2491       gst_object_unref (window);
2492       return FALSE;
2493     }
2494
2495     gst_gl_window_set_preferred_size (window, GST_VIDEO_SINK_WIDTH (gl_sink),
2496         GST_VIDEO_SINK_HEIGHT (gl_sink));
2497     gst_gl_window_show (window);
2498   }
2499
2500   /* Recreate the output texture if needed */
2501   GST_GLIMAGE_SINK_LOCK (gl_sink);
2502   if (gl_sink->window_resized) {
2503     gl_sink->window_resized = FALSE;
2504     GST_GLIMAGE_SINK_UNLOCK (gl_sink);
2505     GST_DEBUG_OBJECT (gl_sink, "Sending reconfigure event on sinkpad.");
2506     gst_pad_push_event (GST_BASE_SINK (gl_sink)->sinkpad,
2507         gst_event_new_reconfigure ());
2508     GST_GLIMAGE_SINK_LOCK (gl_sink);
2509   }
2510
2511   if (gl_sink->output_mode_changed && gl_sink->input_buffer != NULL) {
2512     GST_DEBUG ("Recreating output after mode/size change");
2513     update_output_format (gl_sink);
2514     prepare_next_buffer (gl_sink);
2515   }
2516
2517   if (gl_sink->next_buffer == NULL) {
2518     /* Nothing to display yet */
2519     GST_GLIMAGE_SINK_UNLOCK (gl_sink);
2520     gst_object_unref (window);
2521     return TRUE;
2522   }
2523
2524   /* Avoid to release the texture while drawing */
2525   gl_sink->redisplay_texture = gl_sink->next_tex;
2526   old_stored_buffer[0] = gl_sink->stored_buffer[0];
2527   old_stored_buffer[1] = gl_sink->stored_buffer[1];
2528   gl_sink->stored_buffer[0] = gst_buffer_ref (gl_sink->next_buffer);
2529   if (gl_sink->next_buffer2)
2530     gl_sink->stored_buffer[1] = gst_buffer_ref (gl_sink->next_buffer2);
2531   else
2532     gl_sink->stored_buffer[1] = NULL;
2533
2534   old_sync = gl_sink->stored_sync;
2535   if (gl_sink->next_sync)
2536     gl_sink->stored_sync = gst_buffer_ref (gl_sink->next_sync);
2537   else
2538     gl_sink->stored_sync = NULL;
2539   gl_sink->stored_sync_meta = gl_sink->next_sync_meta;
2540   GST_GLIMAGE_SINK_UNLOCK (gl_sink);
2541
2542   gst_buffer_replace (old_stored_buffer, NULL);
2543   gst_buffer_replace (old_stored_buffer + 1, NULL);
2544   if (old_sync)
2545     gst_buffer_unref (old_sync);
2546
2547   /* Drawing is asynchronous: gst_gl_window_draw is not blocking
2548    * It means that it does not wait for stuff to be executed in other threads
2549    */
2550   gst_gl_window_draw (window);
2551   gst_object_unref (window);
2552
2553   return TRUE;
2554 }