/* GStreamer Wayland video sink * * Copyright (C) 2011 Intel Corporation * Copyright (C) 2011 Sreerenj Balachandran * Copyright (C) 2012 Wim Taymans * Copyright (C) 2014 Collabora Ltd. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301 USA. */ /** * SECTION:element-waylandsink * * The waylandsink is creating its own window and render the decoded video frames to that. * Setup the Wayland environment as described in * Wayland home page. * The current implementaion is based on weston compositor. * * * Example pipelines * |[ * gst-launch-1.0 -v videotestsrc ! waylandsink * ]| test the video rendering in wayland * */ #ifdef HAVE_CONFIG_H #include #endif #include "gstwaylandsink.h" #include "wlvideoformat.h" #include "wlbuffer.h" #include "wlshmallocator.h" #include #include /* signals */ enum { SIGNAL_0, LAST_SIGNAL }; /* Properties */ enum { PROP_0, PROP_DISPLAY }; GST_DEBUG_CATEGORY (gstwayland_debug); #define GST_CAT_DEFAULT gstwayland_debug static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ BGRx, BGRA, RGBx, xBGR, xRGB, RGBA, ABGR, ARGB, RGB, BGR, " "RGB16, BGR16, YUY2, YVYU, UYVY, AYUV, NV12, NV21, NV16, " "YUV9, YVU9, Y41B, I420, YV12, Y42B, v308 }")) ); static void gst_wayland_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void gst_wayland_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_wayland_sink_finalize (GObject * object); static GstStateChangeReturn gst_wayland_sink_change_state (GstElement * element, GstStateChange transition); static void gst_wayland_sink_set_context (GstElement * element, GstContext * context); static GstCaps *gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter); static gboolean gst_wayland_sink_set_caps (GstBaseSink * bsink, GstCaps * caps); static gboolean gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query); static gboolean gst_wayland_sink_show_frame (GstVideoSink * bsink, GstBuffer * buffer); /* VideoOverlay interface */ static void gst_wayland_sink_videooverlay_init (GstVideoOverlayInterface * iface); static void gst_wayland_sink_set_window_handle (GstVideoOverlay * overlay, guintptr handle); static void gst_wayland_sink_set_render_rectangle (GstVideoOverlay * overlay, gint x, gint y, gint w, gint h); static void gst_wayland_sink_expose (GstVideoOverlay * overlay); /* WaylandVideo interface */ static void gst_wayland_sink_waylandvideo_init (GstWaylandVideoInterface * iface); static void gst_wayland_sink_begin_geometry_change (GstWaylandVideo * video); static void gst_wayland_sink_end_geometry_change (GstWaylandVideo * video); #define gst_wayland_sink_parent_class parent_class G_DEFINE_TYPE_WITH_CODE (GstWaylandSink, gst_wayland_sink, GST_TYPE_VIDEO_SINK, G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY, gst_wayland_sink_videooverlay_init) G_IMPLEMENT_INTERFACE (GST_TYPE_WAYLAND_VIDEO, gst_wayland_sink_waylandvideo_init)); static void gst_wayland_sink_class_init (GstWaylandSinkClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseSinkClass *gstbasesink_class; GstVideoSinkClass *gstvideosink_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; gstbasesink_class = (GstBaseSinkClass *) klass; gstvideosink_class = (GstVideoSinkClass *) klass; gobject_class->set_property = gst_wayland_sink_set_property; gobject_class->get_property = gst_wayland_sink_get_property; gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_wayland_sink_finalize); gst_element_class_add_static_pad_template (gstelement_class, &sink_template); gst_element_class_set_static_metadata (gstelement_class, "wayland video sink", "Sink/Video", "Output to wayland surface", "Sreerenj Balachandran , " "George Kiagiadakis "); gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_wayland_sink_change_state); gstelement_class->set_context = GST_DEBUG_FUNCPTR (gst_wayland_sink_set_context); gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_wayland_sink_get_caps); gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_wayland_sink_set_caps); gstbasesink_class->propose_allocation = GST_DEBUG_FUNCPTR (gst_wayland_sink_propose_allocation); gstvideosink_class->show_frame = GST_DEBUG_FUNCPTR (gst_wayland_sink_show_frame); g_object_class_install_property (gobject_class, PROP_DISPLAY, g_param_spec_string ("display", "Wayland Display name", "Wayland " "display name to connect to, if not supplied via the GstContext", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } static void gst_wayland_sink_init (GstWaylandSink * sink) { g_mutex_init (&sink->display_lock); g_mutex_init (&sink->render_lock); } static void gst_wayland_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstWaylandSink *sink = GST_WAYLAND_SINK (object); switch (prop_id) { case PROP_DISPLAY: GST_OBJECT_LOCK (sink); g_value_set_string (value, sink->display_name); GST_OBJECT_UNLOCK (sink); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_wayland_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstWaylandSink *sink = GST_WAYLAND_SINK (object); switch (prop_id) { case PROP_DISPLAY: GST_OBJECT_LOCK (sink); sink->display_name = g_value_dup_string (value); GST_OBJECT_UNLOCK (sink); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_wayland_sink_finalize (GObject * object) { GstWaylandSink *sink = GST_WAYLAND_SINK (object); GST_DEBUG_OBJECT (sink, "Finalizing the sink.."); if (sink->last_buffer) gst_buffer_unref (sink->last_buffer); if (sink->display) g_object_unref (sink->display); if (sink->window) g_object_unref (sink->window); if (sink->pool) gst_object_unref (sink->pool); g_free (sink->display_name); g_mutex_clear (&sink->display_lock); g_mutex_clear (&sink->render_lock); G_OBJECT_CLASS (parent_class)->finalize (object); } /* must be called with the display_lock */ static void gst_wayland_sink_set_display_from_context (GstWaylandSink * sink, GstContext * context) { struct wl_display *display; GError *error = NULL; display = gst_wayland_display_handle_context_get_handle (context); sink->display = gst_wl_display_new_existing (display, FALSE, &error); if (error) { GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE, ("Could not set display handle"), ("Failed to use the external wayland display: '%s'", error->message)); g_error_free (error); } } static gboolean gst_wayland_sink_find_display (GstWaylandSink * sink) { GstQuery *query; GstMessage *msg; GstContext *context = NULL; GError *error = NULL; gboolean ret = TRUE; g_mutex_lock (&sink->display_lock); if (!sink->display) { /* first query upstream for the needed display handle */ query = gst_query_new_context (GST_WAYLAND_DISPLAY_HANDLE_CONTEXT_TYPE); if (gst_pad_peer_query (GST_VIDEO_SINK_PAD (sink), query)) { gst_query_parse_context (query, &context); gst_wayland_sink_set_display_from_context (sink, context); } gst_query_unref (query); if (G_LIKELY (!sink->display)) { /* now ask the application to set the display handle */ msg = gst_message_new_need_context (GST_OBJECT_CAST (sink), GST_WAYLAND_DISPLAY_HANDLE_CONTEXT_TYPE); g_mutex_unlock (&sink->display_lock); gst_element_post_message (GST_ELEMENT_CAST (sink), msg); /* at this point we expect gst_wayland_sink_set_context * to get called and fill sink->display */ g_mutex_lock (&sink->display_lock); if (!sink->display) { /* if the application didn't set a display, let's create it ourselves */ GST_OBJECT_LOCK (sink); sink->display = gst_wl_display_new (sink->display_name, &error); GST_OBJECT_UNLOCK (sink); if (error) { GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE, ("Could not initialise Wayland output"), ("Failed to create GstWlDisplay: '%s'", error->message)); g_error_free (error); ret = FALSE; } } } } g_mutex_unlock (&sink->display_lock); return ret; } static GstStateChangeReturn gst_wayland_sink_change_state (GstElement * element, GstStateChange transition) { GstWaylandSink *sink = GST_WAYLAND_SINK (element); GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: if (!gst_wayland_sink_find_display (sink)) return GST_STATE_CHANGE_FAILURE; break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: gst_buffer_replace (&sink->last_buffer, NULL); if (sink->window) { if (gst_wl_window_is_toplevel (sink->window)) { g_clear_object (&sink->window); } else { /* remove buffer from surface, show nothing */ gst_wl_window_render (sink->window, NULL, NULL); } } break; case GST_STATE_CHANGE_READY_TO_NULL: g_mutex_lock (&sink->display_lock); /* If we had a toplevel window, we most likely have our own connection * to the display too, and it is a good idea to disconnect and allow * potentially the application to embed us with GstVideoOverlay * (which requires to re-use the same display connection as the parent * surface). If we didn't have a toplevel window, then the display * connection that we have is definitely shared with the application * and it's better to keep it around (together with the window handle) * to avoid requesting them again from the application if/when we are * restarted (GstVideoOverlay behaves like that in other sinks) */ if (sink->display && !sink->window) { /* -> the window was toplevel */ g_clear_object (&sink->display); } g_mutex_unlock (&sink->display_lock); g_clear_object (&sink->pool); break; default: break; } return ret; } static void gst_wayland_sink_set_context (GstElement * element, GstContext * context) { GstWaylandSink *sink = GST_WAYLAND_SINK (element); if (gst_context_has_context_type (context, GST_WAYLAND_DISPLAY_HANDLE_CONTEXT_TYPE)) { g_mutex_lock (&sink->display_lock); if (G_LIKELY (!sink->display)) { gst_wayland_sink_set_display_from_context (sink, context); } else { GST_WARNING_OBJECT (element, "changing display handle is not supported"); g_mutex_unlock (&sink->display_lock); return; } g_mutex_unlock (&sink->display_lock); } if (GST_ELEMENT_CLASS (parent_class)->set_context) GST_ELEMENT_CLASS (parent_class)->set_context (element, context); } static GstCaps * gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) { GstWaylandSink *sink; GstCaps *caps; sink = GST_WAYLAND_SINK (bsink); caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (sink)); g_mutex_lock (&sink->display_lock); if (sink->display) { GValue list = G_VALUE_INIT; GValue value = G_VALUE_INIT; GArray *formats; gint i; enum wl_shm_format fmt; g_value_init (&list, GST_TYPE_LIST); g_value_init (&value, G_TYPE_STRING); formats = sink->display->shm_formats; for (i = 0; i < formats->len; i++) { fmt = g_array_index (formats, uint32_t, i); g_value_set_string (&value, gst_wl_shm_format_to_string (fmt)); gst_value_list_append_value (&list, &value); } caps = gst_caps_make_writable (caps); gst_structure_set_value (gst_caps_get_structure (caps, 0), "format", &list); GST_DEBUG_OBJECT (sink, "display caps: %" GST_PTR_FORMAT, caps); } g_mutex_unlock (&sink->display_lock); if (filter) { GstCaps *intersection; intersection = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (caps); caps = intersection; } return caps; } static gboolean gst_wayland_sink_set_caps (GstBaseSink * bsink, GstCaps * caps) { GstWaylandSink *sink; GstBufferPool *newpool; GstVideoInfo info; enum wl_shm_format format; GArray *formats; gint i; GstStructure *structure; sink = GST_WAYLAND_SINK (bsink); GST_DEBUG_OBJECT (sink, "set caps %" GST_PTR_FORMAT, caps); /* extract info from caps */ if (!gst_video_info_from_caps (&info, caps)) goto invalid_format; format = gst_video_format_to_wl_shm_format (GST_VIDEO_INFO_FORMAT (&info)); if ((gint) format == -1) goto invalid_format; /* verify we support the requested format */ formats = sink->display->shm_formats; for (i = 0; i < formats->len; i++) { if (g_array_index (formats, uint32_t, i) == format) break; } if (i >= formats->len) goto unsupported_format; /* create a new pool for the new configuration */ newpool = gst_video_buffer_pool_new (); if (!newpool) goto pool_failed; structure = gst_buffer_pool_get_config (newpool); gst_buffer_pool_config_set_params (structure, caps, info.size, 2, 0); gst_buffer_pool_config_set_allocator (structure, gst_wl_shm_allocator_get (), NULL); if (!gst_buffer_pool_set_config (newpool, structure)) goto config_failed; /* store the video info */ sink->video_info = info; sink->video_info_changed = TRUE; gst_object_replace ((GstObject **) & sink->pool, (GstObject *) newpool); gst_object_unref (newpool); return TRUE; invalid_format: { GST_DEBUG_OBJECT (sink, "Could not locate image format from caps %" GST_PTR_FORMAT, caps); return FALSE; } unsupported_format: { GST_DEBUG_OBJECT (sink, "Format %s is not available on the display", gst_wl_shm_format_to_string (format)); return FALSE; } pool_failed: { GST_DEBUG_OBJECT (sink, "Failed to create new pool"); return FALSE; } config_failed: { GST_DEBUG_OBJECT (bsink, "failed setting config"); gst_object_unref (newpool); return FALSE; } } static gboolean gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query) { GstWaylandSink *sink = GST_WAYLAND_SINK (bsink); GstStructure *config; guint size, min_bufs, max_bufs; config = gst_buffer_pool_get_config (sink->pool); gst_buffer_pool_config_get_params (config, NULL, &size, &min_bufs, &max_bufs); /* we do have a pool for sure (created in set_caps), * so let's propose it anyway, but also propose the allocator on its own */ gst_query_add_allocation_pool (query, sink->pool, size, min_bufs, max_bufs); gst_query_add_allocation_param (query, gst_wl_shm_allocator_get (), NULL); gst_structure_free (config); return TRUE; } static void frame_redraw_callback (void *data, struct wl_callback *callback, uint32_t time) { GstWaylandSink *sink = data; GST_LOG ("frame_redraw_cb"); g_atomic_int_set (&sink->redraw_pending, FALSE); wl_callback_destroy (callback); } static const struct wl_callback_listener frame_callback_listener = { frame_redraw_callback }; /* must be called with the render lock */ static void render_last_buffer (GstWaylandSink * sink) { GstWlBuffer *wlbuffer; const GstVideoInfo *info = NULL; struct wl_surface *surface; struct wl_callback *callback; wlbuffer = gst_buffer_get_wl_buffer (sink->last_buffer); surface = gst_wl_window_get_wl_surface (sink->window); g_atomic_int_set (&sink->redraw_pending, TRUE); callback = wl_surface_frame (surface); wl_callback_add_listener (callback, &frame_callback_listener, sink); if (G_UNLIKELY (sink->video_info_changed)) { info = &sink->video_info; sink->video_info_changed = FALSE; } gst_wl_window_render (sink->window, wlbuffer, info); } static GstFlowReturn gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer) { GstWaylandSink *sink = GST_WAYLAND_SINK (vsink); GstBuffer *to_render; GstWlBuffer *wlbuffer; GstFlowReturn ret = GST_FLOW_OK; g_mutex_lock (&sink->render_lock); GST_LOG_OBJECT (sink, "render buffer %p", buffer); if (G_UNLIKELY (!sink->window)) { /* ask for window handle. Unlock render_lock while doing that because * set_window_handle & friends will lock it in this context */ g_mutex_unlock (&sink->render_lock); gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (sink)); g_mutex_lock (&sink->render_lock); if (!sink->window) { /* if we were not provided a window, create one ourselves */ sink->window = gst_wl_window_new_toplevel (sink->display, &sink->video_info); } } /* drop buffers until we get a frame callback */ if (g_atomic_int_get (&sink->redraw_pending) == TRUE) goto done; /* make sure that the application has called set_render_rectangle() */ if (G_UNLIKELY (sink->window->render_rectangle.w == 0)) goto no_window_size; wlbuffer = gst_buffer_get_wl_buffer (buffer); if (G_LIKELY (wlbuffer && wlbuffer->display == sink->display)) { GST_LOG_OBJECT (sink, "buffer %p has a wl_buffer from our display, " "writing directly", buffer); to_render = buffer; } else { GstMemory *mem; struct wl_buffer *wbuf = NULL; GST_LOG_OBJECT (sink, "buffer %p does not have a wl_buffer from our " "display, creating it", buffer); mem = gst_buffer_peek_memory (buffer, 0); if (gst_is_wl_shm_memory (mem)) { wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display, &sink->video_info); } if (wbuf) { gst_buffer_add_wl_buffer (buffer, wbuf, sink->display); to_render = buffer; } else { GstMapInfo src; /* we don't know how to create a wl_buffer directly from the provided * memory, so we have to copy the data to a memory that we know how * to handle... */ GST_LOG_OBJECT (sink, "buffer %p cannot have a wl_buffer, " "copying to wl_shm memory", buffer); /* sink->pool always exists (created in set_caps), but it may not * be active if upstream is not using it */ if (!gst_buffer_pool_is_active (sink->pool) && !gst_buffer_pool_set_active (sink->pool, TRUE)) goto activate_failed; ret = gst_buffer_pool_acquire_buffer (sink->pool, &to_render, NULL); if (ret != GST_FLOW_OK) goto no_buffer; /* the first time we acquire a buffer, * we need to attach a wl_buffer on it */ wlbuffer = gst_buffer_get_wl_buffer (to_render); if (G_UNLIKELY (!wlbuffer)) { mem = gst_buffer_peek_memory (to_render, 0); wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display, &sink->video_info); if (G_UNLIKELY (!wbuf)) goto no_wl_buffer; gst_buffer_add_wl_buffer (to_render, wbuf, sink->display); } gst_buffer_map (buffer, &src, GST_MAP_READ); gst_buffer_fill (to_render, 0, src.data, src.size); gst_buffer_unmap (buffer, &src); } } /* drop double rendering */ if (G_UNLIKELY (to_render == sink->last_buffer)) { GST_LOG_OBJECT (sink, "Buffer already being rendered"); goto done; } gst_buffer_replace (&sink->last_buffer, to_render); render_last_buffer (sink); if (buffer != to_render) gst_buffer_unref (to_render); goto done; no_window_size: { GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, ("Window has no size set"), ("Make sure you set the size after calling set_window_handle")); ret = GST_FLOW_ERROR; goto done; } no_buffer: { GST_WARNING_OBJECT (sink, "could not create buffer"); goto done; } no_wl_buffer: { GST_ERROR_OBJECT (sink, "could not create wl_buffer out of wl_shm memory"); ret = GST_FLOW_ERROR; goto done; } activate_failed: { GST_ERROR_OBJECT (sink, "failed to activate bufferpool."); ret = GST_FLOW_ERROR; goto done; } done: { g_mutex_unlock (&sink->render_lock); return ret; } } static void gst_wayland_sink_videooverlay_init (GstVideoOverlayInterface * iface) { iface->set_window_handle = gst_wayland_sink_set_window_handle; iface->set_render_rectangle = gst_wayland_sink_set_render_rectangle; iface->expose = gst_wayland_sink_expose; } static void gst_wayland_sink_set_window_handle (GstVideoOverlay * overlay, guintptr handle) { GstWaylandSink *sink = GST_WAYLAND_SINK (overlay); struct wl_surface *surface = (struct wl_surface *) handle; g_return_if_fail (sink != NULL); if (sink->window != NULL) { GST_WARNING_OBJECT (sink, "changing window handle is not supported"); return; } g_mutex_lock (&sink->render_lock); GST_DEBUG_OBJECT (sink, "Setting window handle %" GST_PTR_FORMAT, (void *) handle); g_clear_object (&sink->window); if (handle) { if (G_LIKELY (gst_wayland_sink_find_display (sink))) { /* we cannot use our own display with an external window handle */ if (G_UNLIKELY (sink->display->own_display)) { GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_READ_WRITE, ("Application did not provide a wayland display handle"), ("waylandsink cannot use an externally-supplied surface without " "an externally-supplied display handle. Consider providing a " "display handle from your application with GstContext")); } else { sink->window = gst_wl_window_new_in_surface (sink->display, surface); } } else { GST_ERROR_OBJECT (sink, "Failed to find display handle, " "ignoring window handle"); } } g_mutex_unlock (&sink->render_lock); } static void gst_wayland_sink_set_render_rectangle (GstVideoOverlay * overlay, gint x, gint y, gint w, gint h) { GstWaylandSink *sink = GST_WAYLAND_SINK (overlay); g_return_if_fail (sink != NULL); g_mutex_lock (&sink->render_lock); if (!sink->window) { g_mutex_unlock (&sink->render_lock); GST_WARNING_OBJECT (sink, "set_render_rectangle called without window, ignoring"); return; } GST_DEBUG_OBJECT (sink, "window geometry changed to (%d, %d) %d x %d", x, y, w, h); gst_wl_window_set_render_rectangle (sink->window, x, y, w, h); g_mutex_unlock (&sink->render_lock); } static void gst_wayland_sink_expose (GstVideoOverlay * overlay) { GstWaylandSink *sink = GST_WAYLAND_SINK (overlay); g_return_if_fail (sink != NULL); GST_DEBUG_OBJECT (sink, "expose"); g_mutex_lock (&sink->render_lock); if (sink->last_buffer && g_atomic_int_get (&sink->redraw_pending) == FALSE) { GST_DEBUG_OBJECT (sink, "redrawing last buffer"); render_last_buffer (sink); } g_mutex_unlock (&sink->render_lock); } static void gst_wayland_sink_waylandvideo_init (GstWaylandVideoInterface * iface) { iface->begin_geometry_change = gst_wayland_sink_begin_geometry_change; iface->end_geometry_change = gst_wayland_sink_end_geometry_change; } static void gst_wayland_sink_begin_geometry_change (GstWaylandVideo * video) { GstWaylandSink *sink = GST_WAYLAND_SINK (video); g_return_if_fail (sink != NULL); g_mutex_lock (&sink->render_lock); if (!sink->window || !sink->window->area_subsurface) { g_mutex_unlock (&sink->render_lock); GST_INFO_OBJECT (sink, "begin_geometry_change called without window, ignoring"); return; } wl_subsurface_set_sync (sink->window->area_subsurface); g_mutex_unlock (&sink->render_lock); } static void gst_wayland_sink_end_geometry_change (GstWaylandVideo * video) { GstWaylandSink *sink = GST_WAYLAND_SINK (video); g_return_if_fail (sink != NULL); g_mutex_lock (&sink->render_lock); if (!sink->window || !sink->window->area_subsurface) { g_mutex_unlock (&sink->render_lock); GST_INFO_OBJECT (sink, "end_geometry_change called without window, ignoring"); return; } wl_subsurface_set_desync (sink->window->area_subsurface); g_mutex_unlock (&sink->render_lock); } static gboolean plugin_init (GstPlugin * plugin) { GST_DEBUG_CATEGORY_INIT (gstwayland_debug, "waylandsink", 0, " wayland video sink"); gst_wl_shm_allocator_register (); return gst_element_register (plugin, "waylandsink", GST_RANK_MARGINAL, GST_TYPE_WAYLAND_SINK); } GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, waylandsink, "Wayland Video Sink", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)