From 062638a639f21e52230c8724fb57b89c14180b35 Mon Sep 17 00:00:00 2001 From: Robert Mader Date: Thu, 30 Jun 2022 11:48:45 +0200 Subject: [PATCH] waylandsink: Rename occurrences of GstWaylandSink to 'self' Rename all occurrences to `self`, making it consintent with `GstWl*` and `GstGtkWaylandsink`. Part-of: --- .../ext/wayland/gstwaylandsink.c | 492 +++++++++--------- 1 file changed, 244 insertions(+), 248 deletions(-) diff --git a/subprojects/gst-plugins-bad/ext/wayland/gstwaylandsink.c b/subprojects/gst-plugins-bad/ext/wayland/gstwaylandsink.c index 87ed2b88c6..2fc88e3386 100644 --- a/subprojects/gst-plugins-bad/ext/wayland/gstwaylandsink.c +++ b/subprojects/gst-plugins-bad/ext/wayland/gstwaylandsink.c @@ -91,13 +91,13 @@ static GstStateChangeReturn gst_wayland_sink_change_state (GstElement * element, static void gst_wayland_sink_set_context (GstElement * element, GstContext * context); -static gboolean gst_wayland_sink_event (GstBaseSink * sink, GstEvent * event); +static gboolean gst_wayland_sink_event (GstBaseSink * bsink, GstEvent * event); 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 GstFlowReturn gst_wayland_sink_show_frame (GstVideoSink * bsink, +static GstFlowReturn gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer); /* VideoOverlay interface */ @@ -189,82 +189,82 @@ gst_wayland_sink_class_init (GstWaylandSinkClass * klass) } static void -gst_wayland_sink_init (GstWaylandSink * sink) +gst_wayland_sink_init (GstWaylandSink * self) { - g_mutex_init (&sink->display_lock); - g_mutex_init (&sink->render_lock); + g_mutex_init (&self->display_lock); + g_mutex_init (&self->render_lock); } static void -gst_wayland_sink_set_fullscreen (GstWaylandSink * sink, gboolean fullscreen) +gst_wayland_sink_set_fullscreen (GstWaylandSink * self, gboolean fullscreen) { - if (fullscreen == sink->fullscreen) + if (fullscreen == self->fullscreen) return; - g_mutex_lock (&sink->render_lock); - sink->fullscreen = fullscreen; - gst_wl_window_ensure_fullscreen (sink->window, fullscreen); - g_mutex_unlock (&sink->render_lock); + g_mutex_lock (&self->render_lock); + self->fullscreen = fullscreen; + gst_wl_window_ensure_fullscreen (self->window, fullscreen); + g_mutex_unlock (&self->render_lock); } static void -gst_wayland_sink_set_rotate_method (GstWaylandSink * sink, +gst_wayland_sink_set_rotate_method (GstWaylandSink * self, GstVideoOrientationMethod method, gboolean from_tag) { GstVideoOrientationMethod new_method; if (method == GST_VIDEO_ORIENTATION_CUSTOM) { - GST_WARNING_OBJECT (sink, "unsupported custom orientation"); + GST_WARNING_OBJECT (self, "unsupported custom orientation"); return; } - GST_OBJECT_LOCK (sink); + GST_OBJECT_LOCK (self); if (from_tag) - sink->tag_rotate_method = method; + self->tag_rotate_method = method; else - sink->sink_rotate_method = method; + self->sink_rotate_method = method; - if (sink->sink_rotate_method == GST_VIDEO_ORIENTATION_AUTO) - new_method = sink->tag_rotate_method; + if (self->sink_rotate_method == GST_VIDEO_ORIENTATION_AUTO) + new_method = self->tag_rotate_method; else - new_method = sink->sink_rotate_method; + new_method = self->sink_rotate_method; - if (new_method != sink->current_rotate_method) { - GST_DEBUG_OBJECT (sink, "Changing method from %d to %d", - sink->current_rotate_method, new_method); + if (new_method != self->current_rotate_method) { + GST_DEBUG_OBJECT (self, "Changing method from %d to %d", + self->current_rotate_method, new_method); - if (sink->window) { - g_mutex_lock (&sink->render_lock); - gst_wl_window_set_rotate_method (sink->window, new_method); - g_mutex_unlock (&sink->render_lock); + if (self->window) { + g_mutex_lock (&self->render_lock); + gst_wl_window_set_rotate_method (self->window, new_method); + g_mutex_unlock (&self->render_lock); } - sink->current_rotate_method = new_method; + self->current_rotate_method = new_method; } - GST_OBJECT_UNLOCK (sink); + GST_OBJECT_UNLOCK (self); } static void gst_wayland_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { - GstWaylandSink *sink = GST_WAYLAND_SINK (object); + GstWaylandSink *self = 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); + GST_OBJECT_LOCK (self); + g_value_set_string (value, self->display_name); + GST_OBJECT_UNLOCK (self); break; case PROP_FULLSCREEN: - GST_OBJECT_LOCK (sink); - g_value_set_boolean (value, sink->fullscreen); - GST_OBJECT_UNLOCK (sink); + GST_OBJECT_LOCK (self); + g_value_set_boolean (value, self->fullscreen); + GST_OBJECT_UNLOCK (self); break; case PROP_ROTATE_METHOD: - GST_OBJECT_LOCK (sink); - g_value_set_enum (value, sink->current_rotate_method); - GST_OBJECT_UNLOCK (sink); + GST_OBJECT_LOCK (self); + g_value_set_enum (value, self->current_rotate_method); + GST_OBJECT_UNLOCK (self); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -276,21 +276,21 @@ static void gst_wayland_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { - GstWaylandSink *sink = GST_WAYLAND_SINK (object); + GstWaylandSink *self = 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); + GST_OBJECT_LOCK (self); + self->display_name = g_value_dup_string (value); + GST_OBJECT_UNLOCK (self); break; case PROP_FULLSCREEN: - GST_OBJECT_LOCK (sink); - gst_wayland_sink_set_fullscreen (sink, g_value_get_boolean (value)); - GST_OBJECT_UNLOCK (sink); + GST_OBJECT_LOCK (self); + gst_wayland_sink_set_fullscreen (self, g_value_get_boolean (value)); + GST_OBJECT_UNLOCK (self); break; case PROP_ROTATE_METHOD: - gst_wayland_sink_set_rotate_method (sink, g_value_get_enum (value), + gst_wayland_sink_set_rotate_method (self, g_value_get_enum (value), FALSE); break; default: @@ -302,40 +302,40 @@ gst_wayland_sink_set_property (GObject * object, static void gst_wayland_sink_finalize (GObject * object) { - GstWaylandSink *sink = GST_WAYLAND_SINK (object); + GstWaylandSink *self = GST_WAYLAND_SINK (object); - GST_DEBUG_OBJECT (sink, "Finalizing the sink.."); + GST_DEBUG_OBJECT (self, "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); + if (self->last_buffer) + gst_buffer_unref (self->last_buffer); + if (self->display) + g_object_unref (self->display); + if (self->window) + g_object_unref (self->window); + if (self->pool) + gst_object_unref (self->pool); - g_free (sink->display_name); + g_free (self->display_name); - g_mutex_clear (&sink->display_lock); - g_mutex_clear (&sink->render_lock); + g_mutex_clear (&self->display_lock); + g_mutex_clear (&self->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, +gst_wayland_sink_set_display_from_context (GstWaylandSink * self, GstContext * context) { struct wl_display *display; GError *error = NULL; display = gst_wl_display_handle_context_get_handle (context); - sink->display = gst_wl_display_new_existing (display, FALSE, &error); + self->display = gst_wl_display_new_existing (display, FALSE, &error); if (error) { - GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE, + GST_ELEMENT_WARNING (self, RESOURCE, OPEN_READ_WRITE, ("Could not set display handle"), ("Failed to use the external wayland display: '%s'", error->message)); g_error_free (error); @@ -343,7 +343,7 @@ gst_wayland_sink_set_display_from_context (GstWaylandSink * sink, } static gboolean -gst_wayland_sink_find_display (GstWaylandSink * sink) +gst_wayland_sink_find_display (GstWaylandSink * self) { GstQuery *query; GstMessage *msg; @@ -351,36 +351,36 @@ gst_wayland_sink_find_display (GstWaylandSink * sink) GError *error = NULL; gboolean ret = TRUE; - g_mutex_lock (&sink->display_lock); + g_mutex_lock (&self->display_lock); - if (!sink->display) { + if (!self->display) { /* first query upstream for the needed display handle */ query = gst_query_new_context (GST_WL_DISPLAY_HANDLE_CONTEXT_TYPE); - if (gst_pad_peer_query (GST_VIDEO_SINK_PAD (sink), query)) { + if (gst_pad_peer_query (GST_VIDEO_SINK_PAD (self), query)) { gst_query_parse_context (query, &context); - gst_wayland_sink_set_display_from_context (sink, context); + gst_wayland_sink_set_display_from_context (self, context); } gst_query_unref (query); - if (G_LIKELY (!sink->display)) { + if (G_LIKELY (!self->display)) { /* now ask the application to set the display handle */ - msg = gst_message_new_need_context (GST_OBJECT_CAST (sink), + msg = gst_message_new_need_context (GST_OBJECT_CAST (self), GST_WL_DISPLAY_HANDLE_CONTEXT_TYPE); - g_mutex_unlock (&sink->display_lock); - gst_element_post_message (GST_ELEMENT_CAST (sink), msg); + g_mutex_unlock (&self->display_lock); + gst_element_post_message (GST_ELEMENT_CAST (self), msg); /* at this point we expect gst_wayland_sink_set_context - * to get called and fill sink->display */ - g_mutex_lock (&sink->display_lock); + * to get called and fill self->display */ + g_mutex_lock (&self->display_lock); - if (!sink->display) { + if (!self->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); + GST_OBJECT_LOCK (self); + self->display = gst_wl_display_new (self->display_name, &error); + GST_OBJECT_UNLOCK (self); if (error) { - GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE, + GST_ELEMENT_WARNING (self, RESOURCE, OPEN_READ_WRITE, ("Could not initialise Wayland output"), ("Failed to create GstWlDisplay: '%s'", error->message)); g_error_free (error); @@ -390,7 +390,7 @@ gst_wayland_sink_find_display (GstWaylandSink * sink) } } - g_mutex_unlock (&sink->display_lock); + g_mutex_unlock (&self->display_lock); return ret; } @@ -398,12 +398,12 @@ gst_wayland_sink_find_display (GstWaylandSink * sink) static GstStateChangeReturn gst_wayland_sink_change_state (GstElement * element, GstStateChange transition) { - GstWaylandSink *sink = GST_WAYLAND_SINK (element); + GstWaylandSink *self = 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)) + if (!gst_wayland_sink_find_display (self)) return GST_STATE_CHANGE_FAILURE; break; default: @@ -416,26 +416,26 @@ gst_wayland_sink_change_state (GstElement * element, GstStateChange transition) 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); + gst_buffer_replace (&self->last_buffer, NULL); + if (self->window) { + if (gst_wl_window_is_toplevel (self->window)) { + g_clear_object (&self->window); } else { /* remove buffer from surface, show nothing */ - gst_wl_window_render (sink->window, NULL, NULL); + gst_wl_window_render (self->window, NULL, NULL); } } - g_mutex_lock (&sink->render_lock); - if (sink->callback) { - wl_callback_destroy (sink->callback); - sink->callback = NULL; + g_mutex_lock (&self->render_lock); + if (self->callback) { + wl_callback_destroy (self->callback); + self->callback = NULL; } - sink->redraw_pending = FALSE; - g_mutex_unlock (&sink->render_lock); + self->redraw_pending = FALSE; + g_mutex_unlock (&self->render_lock); break; case GST_STATE_CHANGE_READY_TO_NULL: - g_mutex_lock (&sink->display_lock); + g_mutex_lock (&self->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 @@ -446,11 +446,11 @@ gst_wayland_sink_change_state (GstElement * element, GstStateChange transition) * 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); + if (self->display && !self->window) /* -> the window was toplevel */ + g_clear_object (&self->display); - g_mutex_unlock (&sink->display_lock); - g_clear_object (&sink->pool); + g_mutex_unlock (&self->display_lock); + g_clear_object (&self->pool); break; default: break; @@ -462,19 +462,19 @@ gst_wayland_sink_change_state (GstElement * element, GstStateChange transition) static void gst_wayland_sink_set_context (GstElement * element, GstContext * context) { - GstWaylandSink *sink = GST_WAYLAND_SINK (element); + GstWaylandSink *self = GST_WAYLAND_SINK (element); if (gst_context_has_context_type (context, GST_WL_DISPLAY_HANDLE_CONTEXT_TYPE)) { - g_mutex_lock (&sink->display_lock); - if (G_LIKELY (!sink->display)) { - gst_wayland_sink_set_display_from_context (sink, context); + g_mutex_lock (&self->display_lock); + if (G_LIKELY (!self->display)) { + gst_wayland_sink_set_display_from_context (self, context); } else { GST_WARNING_OBJECT (element, "changing display handle is not supported"); - g_mutex_unlock (&sink->display_lock); + g_mutex_unlock (&self->display_lock); return; } - g_mutex_unlock (&sink->display_lock); + g_mutex_unlock (&self->display_lock); } if (GST_ELEMENT_CLASS (parent_class)->set_context) @@ -484,19 +484,19 @@ gst_wayland_sink_set_context (GstElement * element, GstContext * context) static gboolean gst_wayland_sink_event (GstBaseSink * bsink, GstEvent * event) { - GstWaylandSink *sink = GST_WAYLAND_SINK (bsink); + GstWaylandSink *self = GST_WAYLAND_SINK (bsink); GstTagList *taglist; GstVideoOrientationMethod method; gboolean ret; - GST_DEBUG_OBJECT (sink, "handling %s event", GST_EVENT_TYPE_NAME (event)); + GST_DEBUG_OBJECT (self, "handling %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_TAG: gst_event_parse_tag (event, &taglist); if (gst_video_orientation_from_tag (taglist, &method)) { - gst_wayland_sink_set_rotate_method (sink, method, TRUE); + gst_wayland_sink_set_rotate_method (self, method, TRUE); } break; @@ -512,17 +512,15 @@ gst_wayland_sink_event (GstBaseSink * bsink, GstEvent * event) static GstCaps * gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) { - GstWaylandSink *sink; + GstWaylandSink *self = GST_WAYLAND_SINK (bsink);; GstCaps *caps; - sink = GST_WAYLAND_SINK (bsink); - - caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (sink)); + caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (self)); caps = gst_caps_make_writable (caps); - g_mutex_lock (&sink->display_lock); + g_mutex_lock (&self->display_lock); - if (sink->display) { + if (self->display) { GValue shm_list = G_VALUE_INIT, dmabuf_list = G_VALUE_INIT; GValue value = G_VALUE_INIT; GArray *formats; @@ -534,7 +532,7 @@ gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) g_value_init (&dmabuf_list, GST_TYPE_LIST); /* Add corresponding shm formats */ - formats = gst_wl_display_get_shm_formats (sink->display); + formats = gst_wl_display_get_shm_formats (self->display); for (i = 0; i < formats->len; i++) { fmt = g_array_index (formats, uint32_t, i); gfmt = gst_wl_shm_format_to_video_format (fmt); @@ -549,7 +547,7 @@ gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) &shm_list); /* Add corresponding dmabuf formats */ - formats = gst_wl_display_get_dmabuf_formats (sink->display); + formats = gst_wl_display_get_dmabuf_formats (self->display); for (i = 0; i < formats->len; i++) { fmt = g_array_index (formats, uint32_t, i); gfmt = gst_wl_dmabuf_format_to_video_format (fmt); @@ -563,10 +561,10 @@ gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) gst_structure_take_value (gst_caps_get_structure (caps, 1), "format", &dmabuf_list); - GST_DEBUG_OBJECT (sink, "display caps: %" GST_PTR_FORMAT, caps); + GST_DEBUG_OBJECT (self, "display caps: %" GST_PTR_FORMAT, caps); } - g_mutex_unlock (&sink->display_lock); + g_mutex_unlock (&self->display_lock); if (filter) { GstCaps *intersection; @@ -581,11 +579,11 @@ gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) } static GstBufferPool * -gst_wayland_create_pool (GstWaylandSink * sink, GstCaps * caps) +gst_wayland_create_pool (GstWaylandSink * self, GstCaps * caps) { GstBufferPool *pool = NULL; GstStructure *structure; - gsize size = sink->video_info.size; + gsize size = self->video_info.size; GstAllocator *alloc; pool = gst_wl_video_buffer_pool_new (); @@ -607,50 +605,48 @@ gst_wayland_create_pool (GstWaylandSink * sink, GstCaps * caps) static gboolean gst_wayland_sink_set_caps (GstBaseSink * bsink, GstCaps * caps) { - GstWaylandSink *sink; + GstWaylandSink *self = GST_WAYLAND_SINK (bsink);; gboolean use_dmabuf; GstVideoFormat format; - sink = GST_WAYLAND_SINK (bsink); - - GST_DEBUG_OBJECT (sink, "set caps %" GST_PTR_FORMAT, caps); + GST_DEBUG_OBJECT (self, "set caps %" GST_PTR_FORMAT, caps); /* extract info from caps */ - if (!gst_video_info_from_caps (&sink->video_info, caps)) + if (!gst_video_info_from_caps (&self->video_info, caps)) goto invalid_format; - format = GST_VIDEO_INFO_FORMAT (&sink->video_info); - sink->video_info_changed = TRUE; + format = GST_VIDEO_INFO_FORMAT (&self->video_info); + self->video_info_changed = TRUE; /* create a new pool for the new caps */ - if (sink->pool) - gst_object_unref (sink->pool); - sink->pool = gst_wayland_create_pool (sink, caps); + if (self->pool) + gst_object_unref (self->pool); + self->pool = gst_wayland_create_pool (self, caps); use_dmabuf = gst_caps_features_contains (gst_caps_get_features (caps, 0), GST_CAPS_FEATURE_MEMORY_DMABUF); /* validate the format base on the memory type. */ if (use_dmabuf) { - if (!gst_wl_display_check_format_for_dmabuf (sink->display, format)) + if (!gst_wl_display_check_format_for_dmabuf (self->display, format)) goto unsupported_format; - } else if (!gst_wl_display_check_format_for_shm (sink->display, format)) { + } else if (!gst_wl_display_check_format_for_shm (self->display, format)) { goto unsupported_format; } - sink->use_dmabuf = use_dmabuf; + self->use_dmabuf = use_dmabuf; return TRUE; invalid_format: { - GST_ERROR_OBJECT (sink, + GST_ERROR_OBJECT (self, "Could not locate image format from caps %" GST_PTR_FORMAT, caps); return FALSE; } unsupported_format: { - GST_ERROR_OBJECT (sink, "Format %s is not available on the display", + GST_ERROR_OBJECT (self, "Format %s is not available on the display", gst_video_format_to_string (format)); return FALSE; } @@ -659,7 +655,7 @@ unsupported_format: static gboolean gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query) { - GstWaylandSink *sink = GST_WAYLAND_SINK (bsink); + GstWaylandSink *self = GST_WAYLAND_SINK (bsink); GstCaps *caps; GstBufferPool *pool = NULL; gboolean need_pool; @@ -668,9 +664,9 @@ gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query) gst_query_parse_allocation (query, &caps, &need_pool); if (need_pool) - pool = gst_wayland_create_pool (sink, caps); + pool = gst_wayland_create_pool (self, caps); - gst_query_add_allocation_pool (query, pool, sink->video_info.size, 2, 0); + gst_query_add_allocation_pool (query, pool, self->video_info.size, 2, 0); if (pool) g_object_unref (pool); @@ -685,18 +681,18 @@ gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query) static void frame_redraw_callback (void *data, struct wl_callback *callback, uint32_t time) { - GstWaylandSink *sink = data; + GstWaylandSink *self = data; GST_LOG ("frame_redraw_cb"); - g_mutex_lock (&sink->render_lock); - sink->redraw_pending = FALSE; + g_mutex_lock (&self->render_lock); + self->redraw_pending = FALSE; - if (sink->callback) { + if (self->callback) { wl_callback_destroy (callback); - sink->callback = NULL; + self->callback = NULL; } - g_mutex_unlock (&sink->render_lock); + g_mutex_unlock (&self->render_lock); } static const struct wl_callback_listener frame_callback_listener = { @@ -705,42 +701,42 @@ static const struct wl_callback_listener frame_callback_listener = { /* must be called with the render lock */ static void -render_last_buffer (GstWaylandSink * sink, gboolean redraw) +render_last_buffer (GstWaylandSink * self, gboolean redraw) { GstWlBuffer *wlbuffer; const GstVideoInfo *info = NULL; struct wl_surface *surface; struct wl_callback *callback; - wlbuffer = gst_buffer_get_wl_buffer (sink->display, sink->last_buffer); - surface = gst_wl_window_get_wl_surface (sink->window); + wlbuffer = gst_buffer_get_wl_buffer (self->display, self->last_buffer); + surface = gst_wl_window_get_wl_surface (self->window); - sink->redraw_pending = TRUE; + self->redraw_pending = TRUE; callback = wl_surface_frame (surface); - sink->callback = callback; - wl_callback_add_listener (callback, &frame_callback_listener, sink); + self->callback = callback; + wl_callback_add_listener (callback, &frame_callback_listener, self); - if (G_UNLIKELY (sink->video_info_changed && !redraw)) { - info = &sink->video_info; - sink->video_info_changed = FALSE; + if (G_UNLIKELY (self->video_info_changed && !redraw)) { + info = &self->video_info; + self->video_info_changed = FALSE; } - gst_wl_window_render (sink->window, wlbuffer, info); + gst_wl_window_render (self->window, wlbuffer, info); } static void on_window_closed (GstWlWindow * window, gpointer user_data) { - GstWaylandSink *sink = GST_WAYLAND_SINK (user_data); + GstWaylandSink *self = GST_WAYLAND_SINK (user_data); /* Handle window closure by posting an error on the bus */ - GST_ELEMENT_ERROR (sink, RESOURCE, NOT_FOUND, + GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, ("Output window was closed"), (NULL)); } static GstFlowReturn gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer) { - GstWaylandSink *sink = GST_WAYLAND_SINK (vsink); + GstWaylandSink *self = GST_WAYLAND_SINK (vsink); GstBuffer *to_render; GstWlBuffer *wlbuffer; GstVideoMeta *vmeta; @@ -751,43 +747,43 @@ gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer) GstFlowReturn ret = GST_FLOW_OK; - g_mutex_lock (&sink->render_lock); + g_mutex_lock (&self->render_lock); - GST_LOG_OBJECT (sink, "render buffer %p", buffer); + GST_LOG_OBJECT (self, "render buffer %p", buffer); - if (G_UNLIKELY (!sink->window)) { + if (G_UNLIKELY (!self->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); + g_mutex_unlock (&self->render_lock); + gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (self)); + g_mutex_lock (&self->render_lock); - if (!sink->window) { + if (!self->window) { /* if we were not provided a window, create one ourselves */ - sink->window = gst_wl_window_new_toplevel (sink->display, - &sink->video_info, sink->fullscreen, &sink->render_lock); - g_signal_connect_object (sink->window, "closed", - G_CALLBACK (on_window_closed), sink, 0); - gst_wl_window_set_rotate_method (sink->window, - sink->current_rotate_method); + self->window = gst_wl_window_new_toplevel (self->display, + &self->video_info, self->fullscreen, &self->render_lock); + g_signal_connect_object (self->window, "closed", + G_CALLBACK (on_window_closed), self, 0); + gst_wl_window_set_rotate_method (self->window, + self->current_rotate_method); } } /* drop buffers until we get a frame callback */ - if (sink->redraw_pending) { - GST_LOG_OBJECT (sink, "buffer %p dropped (redraw pending)", buffer); + if (self->redraw_pending) { + GST_LOG_OBJECT (self, "buffer %p dropped (redraw pending)", buffer); goto done; } /* make sure that the application has called set_render_rectangle() */ - if (G_UNLIKELY (gst_wl_window_get_render_rectangle (sink->window)->w == 0)) + if (G_UNLIKELY (gst_wl_window_get_render_rectangle (self->window)->w == 0)) goto no_window_size; - wlbuffer = gst_buffer_get_wl_buffer (sink->display, buffer); + wlbuffer = gst_buffer_get_wl_buffer (self->display, buffer); if (G_LIKELY (wlbuffer && - gst_wl_buffer_get_display (wlbuffer) == sink->display)) { - GST_LOG_OBJECT (sink, "buffer %p has a wl_buffer from our display, " + gst_wl_buffer_get_display (wlbuffer) == self->display)) { + GST_LOG_OBJECT (self, "buffer %p has a wl_buffer from our display, " "writing directly", buffer); to_render = buffer; goto render; @@ -796,23 +792,23 @@ gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer) /* update video info from video meta */ mem = gst_buffer_peek_memory (buffer, 0); - old_vinfo = sink->video_info; + old_vinfo = self->video_info; vmeta = gst_buffer_get_video_meta (buffer); if (vmeta) { gint i; for (i = 0; i < vmeta->n_planes; i++) { - sink->video_info.offset[i] = vmeta->offset[i]; - sink->video_info.stride[i] = vmeta->stride[i]; + self->video_info.offset[i] = vmeta->offset[i]; + self->video_info.stride[i] = vmeta->stride[i]; } - sink->video_info.size = gst_buffer_get_size (buffer); + self->video_info.size = gst_buffer_get_size (buffer); } - GST_LOG_OBJECT (sink, "buffer %p does not have a wl_buffer from our " + GST_LOG_OBJECT (self, "buffer %p does not have a wl_buffer from our " "display, creating it", buffer); - format = GST_VIDEO_INFO_FORMAT (&sink->video_info); - if (gst_wl_display_check_format_for_dmabuf (sink->display, format)) { + format = GST_VIDEO_INFO_FORMAT (&self->video_info); + if (gst_wl_display_check_format_for_dmabuf (self->display, format)) { guint i, nb_dmabuf = 0; for (i = 0; i < gst_buffer_n_memory (buffer); i++) @@ -820,69 +816,69 @@ gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer) nb_dmabuf++; if (nb_dmabuf && (nb_dmabuf == gst_buffer_n_memory (buffer))) - wbuf = gst_wl_linux_dmabuf_construct_wl_buffer (buffer, sink->display, - &sink->video_info); + wbuf = gst_wl_linux_dmabuf_construct_wl_buffer (buffer, self->display, + &self->video_info); } - if (!wbuf && gst_wl_display_check_format_for_shm (sink->display, format)) { + if (!wbuf && gst_wl_display_check_format_for_shm (self->display, format)) { if (gst_buffer_n_memory (buffer) == 1 && gst_is_fd_memory (mem)) - wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display, - &sink->video_info); + wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, self->display, + &self->video_info); /* If nothing worked, copy into our internal pool */ if (!wbuf) { GstVideoFrame src, dst; - GstVideoInfo src_info = sink->video_info; + GstVideoInfo src_info = self->video_info; /* rollback video info changes */ - sink->video_info = old_vinfo; + self->video_info = old_vinfo; /* we don't know how to create a wl_buffer directly from the provided * memory, so we have to copy the data to shm memory that we know how * to handle... */ - GST_LOG_OBJECT (sink, "buffer %p cannot have a wl_buffer, " + GST_LOG_OBJECT (self, "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 + /* self->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)) { + if (!gst_buffer_pool_is_active (self->pool)) { GstStructure *config; GstCaps *caps; - config = gst_buffer_pool_get_config (sink->pool); + config = gst_buffer_pool_get_config (self->pool); gst_buffer_pool_config_get_params (config, &caps, NULL, NULL, NULL); /* revert back to default strides and offsets */ - gst_video_info_from_caps (&sink->video_info, caps); - gst_buffer_pool_config_set_params (config, caps, sink->video_info.size, + gst_video_info_from_caps (&self->video_info, caps); + gst_buffer_pool_config_set_params (config, caps, self->video_info.size, 2, 0); /* This is a video pool, it should not fail with basic settings */ - if (!gst_buffer_pool_set_config (sink->pool, config) || - !gst_buffer_pool_set_active (sink->pool, TRUE)) + if (!gst_buffer_pool_set_config (self->pool, config) || + !gst_buffer_pool_set_active (self->pool, TRUE)) goto activate_failed; } - ret = gst_buffer_pool_acquire_buffer (sink->pool, &to_render, NULL); + ret = gst_buffer_pool_acquire_buffer (self->pool, &to_render, NULL); if (ret != GST_FLOW_OK) goto no_buffer; - wlbuffer = gst_buffer_get_wl_buffer (sink->display, to_render); + wlbuffer = gst_buffer_get_wl_buffer (self->display, to_render); /* attach a wl_buffer if there isn't one yet */ 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); + wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, self->display, + &self->video_info); if (G_UNLIKELY (!wbuf)) goto no_wl_buffer_shm; - wlbuffer = gst_buffer_add_wl_buffer (to_render, wbuf, sink->display); + wlbuffer = gst_buffer_add_wl_buffer (to_render, wbuf, self->display); } - if (!gst_video_frame_map (&dst, &sink->video_info, to_render, + if (!gst_video_frame_map (&dst, &self->video_info, to_render, GST_MAP_WRITE)) goto dst_map_failed; @@ -903,19 +899,19 @@ gst_wayland_sink_show_frame (GstVideoSink * vsink, GstBuffer * buffer) if (!wbuf) goto no_wl_buffer; - wlbuffer = gst_buffer_add_wl_buffer (buffer, wbuf, sink->display); + wlbuffer = gst_buffer_add_wl_buffer (buffer, wbuf, self->display); to_render = buffer; render: /* drop double rendering */ if (G_UNLIKELY (wlbuffer == - gst_buffer_get_wl_buffer (sink->display, sink->last_buffer))) { - GST_LOG_OBJECT (sink, "Buffer already being rendered"); + gst_buffer_get_wl_buffer (self->display, self->last_buffer))) { + GST_LOG_OBJECT (self, "Buffer already being rendered"); goto done; } - gst_buffer_replace (&sink->last_buffer, to_render); - render_last_buffer (sink, FALSE); + gst_buffer_replace (&self->last_buffer, to_render); + render_last_buffer (self, FALSE); if (buffer != to_render) gst_buffer_unref (to_render); @@ -923,7 +919,7 @@ render: no_window_size: { - GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, + GST_ELEMENT_ERROR (self, RESOURCE, WRITE, ("Window has no size set"), ("Make sure you set the size after calling set_window_handle")); ret = GST_FLOW_ERROR; @@ -931,44 +927,44 @@ no_window_size: } no_buffer: { - GST_WARNING_OBJECT (sink, "could not create buffer"); + GST_WARNING_OBJECT (self, "could not create buffer"); goto done; } no_wl_buffer_shm: { - GST_ERROR_OBJECT (sink, "could not create wl_buffer out of wl_shm memory"); + GST_ERROR_OBJECT (self, "could not create wl_buffer out of wl_shm memory"); ret = GST_FLOW_ERROR; goto done; } no_wl_buffer: { - GST_ERROR_OBJECT (sink, "buffer %p cannot have a wl_buffer", buffer); + GST_ERROR_OBJECT (self, "buffer %p cannot have a wl_buffer", buffer); ret = GST_FLOW_ERROR; goto done; } activate_failed: { - GST_ERROR_OBJECT (sink, "failed to activate bufferpool."); + GST_ERROR_OBJECT (self, "failed to activate bufferpool."); ret = GST_FLOW_ERROR; goto done; } src_map_failed: { - GST_ELEMENT_ERROR (sink, RESOURCE, READ, + GST_ELEMENT_ERROR (self, RESOURCE, READ, ("Video memory can not be read from userspace."), (NULL)); ret = GST_FLOW_ERROR; goto done; } dst_map_failed: { - GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, + GST_ELEMENT_ERROR (self, RESOURCE, WRITE, ("Video memory can not be written from userspace."), (NULL)); ret = GST_FLOW_ERROR; goto done; } done: { - g_mutex_unlock (&sink->render_lock); + g_mutex_unlock (&self->render_lock); return ret; } } @@ -984,85 +980,85 @@ gst_wayland_sink_videooverlay_init (GstVideoOverlayInterface * iface) static void gst_wayland_sink_set_window_handle (GstVideoOverlay * overlay, guintptr handle) { - GstWaylandSink *sink = GST_WAYLAND_SINK (overlay); + GstWaylandSink *self = GST_WAYLAND_SINK (overlay); struct wl_surface *surface = (struct wl_surface *) handle; - g_return_if_fail (sink != NULL); + g_return_if_fail (self != NULL); - if (sink->window != NULL) { - GST_WARNING_OBJECT (sink, "changing window handle is not supported"); + if (self->window != NULL) { + GST_WARNING_OBJECT (self, "changing window handle is not supported"); return; } - g_mutex_lock (&sink->render_lock); + g_mutex_lock (&self->render_lock); - GST_DEBUG_OBJECT (sink, "Setting window handle %" GST_PTR_FORMAT, + GST_DEBUG_OBJECT (self, "Setting window handle %" GST_PTR_FORMAT, (void *) handle); - g_clear_object (&sink->window); + g_clear_object (&self->window); if (handle) { - if (G_LIKELY (gst_wayland_sink_find_display (sink))) { + if (G_LIKELY (gst_wayland_sink_find_display (self))) { /* we cannot use our own display with an external window handle */ - if (G_UNLIKELY (gst_wl_display_has_own_display (sink->display))) { - GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_READ_WRITE, + if (G_UNLIKELY (gst_wl_display_has_own_display (self->display))) { + GST_ELEMENT_ERROR (self, 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, - &sink->render_lock); - gst_wl_window_set_rotate_method (sink->window, - sink->current_rotate_method); + self->window = gst_wl_window_new_in_surface (self->display, surface, + &self->render_lock); + gst_wl_window_set_rotate_method (self->window, + self->current_rotate_method); } } else { - GST_ERROR_OBJECT (sink, "Failed to find display handle, " + GST_ERROR_OBJECT (self, "Failed to find display handle, " "ignoring window handle"); } } - g_mutex_unlock (&sink->render_lock); + g_mutex_unlock (&self->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); + GstWaylandSink *self = GST_WAYLAND_SINK (overlay); - g_return_if_fail (sink != NULL); + g_return_if_fail (self != NULL); - g_mutex_lock (&sink->render_lock); - if (!sink->window) { - g_mutex_unlock (&sink->render_lock); - GST_WARNING_OBJECT (sink, + g_mutex_lock (&self->render_lock); + if (!self->window) { + g_mutex_unlock (&self->render_lock); + GST_WARNING_OBJECT (self, "set_render_rectangle called without window, ignoring"); return; } - GST_DEBUG_OBJECT (sink, "window geometry changed to (%d, %d) %d x %d", + GST_DEBUG_OBJECT (self, "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); + gst_wl_window_set_render_rectangle (self->window, x, y, w, h); - g_mutex_unlock (&sink->render_lock); + g_mutex_unlock (&self->render_lock); } static void gst_wayland_sink_expose (GstVideoOverlay * overlay) { - GstWaylandSink *sink = GST_WAYLAND_SINK (overlay); + GstWaylandSink *self = GST_WAYLAND_SINK (overlay); - g_return_if_fail (sink != NULL); + g_return_if_fail (self != NULL); - GST_DEBUG_OBJECT (sink, "expose"); + GST_DEBUG_OBJECT (self, "expose"); - g_mutex_lock (&sink->render_lock); - if (sink->last_buffer && !sink->redraw_pending) { - GST_DEBUG_OBJECT (sink, "redrawing last buffer"); - render_last_buffer (sink, TRUE); + g_mutex_lock (&self->render_lock); + if (self->last_buffer && !self->redraw_pending) { + GST_DEBUG_OBJECT (self, "redrawing last buffer"); + render_last_buffer (self, TRUE); } - g_mutex_unlock (&sink->render_lock); + g_mutex_unlock (&self->render_lock); } static gboolean