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
gst_gl_image_sink_bin_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * param_spec)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
gst_gl_image_sink_bin_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * param_spec)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
_on_client_reshape(GstGLImageSink * sink,GstGLContext * context,guint width,guint height,gpointer data)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
_on_client_draw(GstGLImageSink * sink,GstGLContext * context,GstSample * sample,gpointer data)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
gst_gl_rotate_method_get_type(void)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
gst_gl_image_sink_bin_init(GstGLImageSinkBin * self)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
gst_gl_image_sink_bin_class_init(GstGLImageSinkBinClass * klass)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
_display_size_to_stream_size(GstGLImageSink * gl_sink,gdouble x,gdouble y,gdouble * stream_x,gdouble * stream_y)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
_display_scroll_value_to_stream_scroll_value(GstGLImageSink * gl_sink,gdouble delta_x,gdouble delta_y,gdouble * stream_delta_x,gdouble * stream_delta_y)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
gst_glimage_sink_set_rotate_method(GstGLImageSink * gl_sink,GstVideoOrientationMethod method,gboolean from_tag)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
gst_glimage_sink_navigation_send_event(GstNavigation * navigation,GstStructure * structure)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
gst_glimage_sink_navigation_interface_init(GstNavigationInterface * iface)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
gst_glimage_sink_class_init(GstGLImageSinkClass * klass)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
gst_glimage_sink_init(GstGLImageSink * glimage_sink)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
gst_glimage_sink_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)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
gst_glimage_sink_finalize(GObject * object)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
gst_glimage_sink_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)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
gst_glimage_sink_key_event_cb(GstGLWindow * window,char * event_name,char * key_string,GstGLImageSink * gl_sink)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
gst_glimage_sink_mouse_event_cb(GstGLWindow * window,char * event_name,int button,double posx,double posy,GstGLImageSink * gl_sink)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
gst_glimage_sink_mouse_scroll_event_cb(GstGLWindow * window,double posx,double posy,double delta_x,double delta_y,GstGLImageSink * gl_sink)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
_set_context(GstGLImageSink * gl_sink,GstGLContext * context)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
_set_other_context(GstGLImageSink * gl_sink,GstGLContext * other_context)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
_set_display(GstGLImageSink * gl_sink,GstGLDisplay * display)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
_ensure_gl_setup(GstGLImageSink * gl_sink)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
gst_glimage_sink_event(GstBaseSink * sink,GstEvent * event)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
gst_glimage_sink_query(GstBaseSink * bsink,GstQuery * query)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
gst_glimage_sink_set_context(GstElement * element,GstContext * context)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
gst_glimage_sink_change_state(GstElement * element,GstStateChange transition)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
gst_glimage_sink_get_times(GstBaseSink * bsink,GstBuffer * buf,GstClockTime * start,GstClockTime * end)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 *
gst_glimage_sink_get_caps(GstBaseSink * bsink,GstCaps * filter)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
configure_display_from_info(GstGLImageSink * glimage_sink,const GstVideoInfo * vinfo)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
_mview_modes_are_equal(GstVideoMultiviewMode a,GstVideoMultiviewMode b)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
update_output_format(GstGLImageSink * glimage_sink)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
gst_glimage_sink_set_caps(GstBaseSink * bsink,GstCaps * caps)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
prepare_next_buffer(GstGLImageSink * glimage_sink)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
gst_glimage_sink_prepare(GstBaseSink * bsink,GstBuffer * buf)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
gst_glimage_sink_show_frame(GstVideoSink * vsink,GstBuffer * buf)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
gst_glimage_sink_video_overlay_init(GstVideoOverlayInterface * iface)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
gst_glimage_sink_set_window_handle(GstVideoOverlay * overlay,guintptr id)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
gst_glimage_sink_expose(GstVideoOverlay * overlay)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
gst_glimage_sink_handle_events(GstVideoOverlay * overlay,gboolean handle_events)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
gst_glimage_sink_set_render_rectangle(GstVideoOverlay * overlay,gint x,gint y,gint width,gint height)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
gst_glimage_sink_propose_allocation(GstBaseSink * bsink,GstQuery * query)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
_bind_buffer(GstGLImageSink * gl_sink)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
_unbind_buffer(GstGLImageSink * gl_sink)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
gst_glimage_sink_thread_init_redisplay(GstGLImageSink * gl_sink)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
gst_glimage_sink_cleanup_glthread(GstGLImageSink * gl_sink)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
gst_glimage_sink_on_resize(GstGLImageSink * gl_sink,gint width,gint height)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
gst_glimage_sink_on_draw(GstGLImageSink * gl_sink)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 (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 (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
gst_glimage_sink_on_close(GstGLImageSink * gl_sink)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
gst_glimage_sink_redisplay(GstGLImageSink * gl_sink)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 }
2555