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