lib: Introduce Clapper playback library

An easy to use media playback library (libclapper) as a GstPlayer replacement.

Previously we tried to use upstream `gstplayer` library to control playback and
pass all events from multiple threads GStreamer uses into an app main thread.
Since this caused some thread racy problems and we needed additional ABI breaking
changes to better suit our needs, we ended up with a modified fork of said library
renamed to `gstclapper` as a temporary solution.

This new library simply named `clapper` replaces our previous `gstclapper` solution
and is written completely from scratch by myself. The aim here is to have an easy to
use playback library better suited to work with (but not limited to) GTK and GObject
properties bindings by relying on "notify" signals.

Major differences include:
* Operates on a playback queue (inherits `GListModel` interface) instead of a single URI
* Uses "notify" signals for property changes always dispatched to app thread
* Time is passed/read as decimal number in seconds instead of int64 in nanoseconds
* Integrates `GstDiscoverer` to figure out media info (such as title) before playback
* Easy to use MPRIS support as part of library
* Optional playback remote controls with WebSocket messages

The new library will be distributed with Clapper player. This includes public headers
and GObject Introspection support.

Licensed under LGPL-2.1-or-later.

Enjoy

src/lib/gst/plugin/gstclappercontexthandler.c

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclappercontexthandler.h"
+
+#define parent_class gst_clapper_context_handler_parent_class
+G_DEFINE_TYPE (GstClapperContextHandler, gst_clapper_context_handler, GST_TYPE_OBJECT);
+
+static gboolean
+_default_handle_context_query (GstClapperContextHandler *self,
+    GstBaseSink *bsink, GstQuery *query)
+{
+  GST_FIXME_OBJECT (self, "Need to handle context query");
+
+  return FALSE;
+}
+
+static void
+gst_clapper_context_handler_init (GstClapperContextHandler *self)
+{
+}
+
+static void
+gst_clapper_context_handler_finalize (GObject *object)
+{
+  GstClapperContextHandler *self = GST_CLAPPER_CONTEXT_HANDLER_CAST (object);
+
+  GST_TRACE_OBJECT (self, "Finalize");
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_context_handler_class_init (GstClapperContextHandlerClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+  GstClapperContextHandlerClass *handler_class = (GstClapperContextHandlerClass *) klass;
+
+  gobject_class->finalize = gst_clapper_context_handler_finalize;
+
+  handler_class->handle_context_query = _default_handle_context_query;
+}
+
+gboolean
+gst_clapper_context_handler_handle_context_query (GstClapperContextHandler *self,
+    GstBaseSink *bsink, GstQuery *query)
+{
+  GstClapperContextHandlerClass *handler_class = GST_CLAPPER_CONTEXT_HANDLER_GET_CLASS (self);
+
+  return handler_class->handle_context_query (self, bsink, query);
+}
+
+GstClapperContextHandler *
+gst_clapper_context_handler_obtain_with_type (GPtrArray *context_handlers, GType type)
+{
+  guint i;
+
+  for (i = 0; i < context_handlers->len; i++) {
+    GstClapperContextHandler *handler = g_ptr_array_index (context_handlers, i);
+
+    if (G_TYPE_CHECK_INSTANCE_TYPE (handler, type))
+      return gst_object_ref (handler);
+  }
+
+  return NULL;
+}

src/lib/gst/plugin/gstclappercontexthandler.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <gst/gst.h>
+#include <gst/base/gstbasesink.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_CONTEXT_HANDLER               (gst_clapper_context_handler_get_type())
+#define GST_IS_CLAPPER_CONTEXT_HANDLER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_CLAPPER_CONTEXT_HANDLER))
+#define GST_IS_CLAPPER_CONTEXT_HANDLER_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_CLAPPER_CONTEXT_HANDLER))
+#define GST_CLAPPER_CONTEXT_HANDLER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_CLAPPER_CONTEXT_HANDLER, GstClapperContextHandlerClass))
+#define GST_CLAPPER_CONTEXT_HANDLER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_CLAPPER_CONTEXT_HANDLER, GstClapperContextHandler))
+#define GST_CLAPPER_CONTEXT_HANDLER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_CLAPPER_CONTEXT_HANDLER, GstClapperContextHandlerClass))
+#define GST_CLAPPER_CONTEXT_HANDLER_CAST(obj)          ((GstClapperContextHandler *)(obj))
+
+typedef struct _GstClapperContextHandler GstClapperContextHandler;
+typedef struct _GstClapperContextHandlerClass GstClapperContextHandlerClass;
+
+#ifdef G_DEFINE_AUTOPTR_CLEANUP_FUNC
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GstClapperContextHandler, gst_object_unref)
+#endif
+
+struct _GstClapperContextHandler
+{
+  GstObject parent;
+};
+
+struct _GstClapperContextHandlerClass
+{
+  GstObjectClass parent_class;
+
+  gboolean (* handle_context_query) (GstClapperContextHandler *handler,
+                                     GstBaseSink              *bsink,
+                                     GstQuery                 *query);
+};
+
+GType                      gst_clapper_context_handler_get_type              (void);
+
+gboolean                   gst_clapper_context_handler_handle_context_query  (GstClapperContextHandler *handler, GstBaseSink *bsink, GstQuery *query);
+
+GstClapperContextHandler * gst_clapper_context_handler_obtain_with_type      (GPtrArray *context_handlers, GType type);
+
+G_END_DECLS

src/lib/gst/plugin/gstclapperimporter.c

@@ -0,0 +1,427 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclapperimporter.h"
+#include "gstgtkutils.h"
+
+#define GST_CAT_DEFAULT gst_clapper_importer_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define parent_class gst_clapper_importer_parent_class
+G_DEFINE_TYPE (GstClapperImporter, gst_clapper_importer, GST_TYPE_OBJECT);
+
+typedef struct
+{
+  GdkTexture *texture;
+  GstVideoOverlayRectangle *rectangle;
+
+  gint x, y;
+  guint width, height;
+
+  gint index;
+  gatomicrefcount ref_count;
+} GstClapperGdkOverlay;
+
+static GstClapperGdkOverlay *
+gst_clapper_gdk_overlay_new (GdkTexture *texture, GstVideoOverlayRectangle *rectangle,
+    gint x, gint y, guint width, guint height, guint index)
+{
+  GstClapperGdkOverlay *overlay = g_slice_new (GstClapperGdkOverlay);
+
+  overlay->texture = g_object_ref (texture);
+  overlay->rectangle = gst_video_overlay_rectangle_ref (rectangle);
+  overlay->x = x;
+  overlay->y = y;
+  overlay->width = width;
+  overlay->height = height;
+  overlay->index = index;
+
+  g_atomic_ref_count_init (&overlay->ref_count);
+
+  return overlay;
+}
+
+static GstClapperGdkOverlay *
+gst_clapper_gdk_overlay_ref (GstClapperGdkOverlay *overlay)
+{
+  g_atomic_ref_count_inc (&overlay->ref_count);
+
+  return overlay;
+}
+
+static void
+gst_clapper_gdk_overlay_unref (GstClapperGdkOverlay *overlay)
+{
+  if (g_atomic_ref_count_dec (&overlay->ref_count)) {
+    GST_TRACE ("Freeing overlay: %" GST_PTR_FORMAT, overlay);
+
+    g_object_unref (overlay->texture);
+    gst_video_overlay_rectangle_unref (overlay->rectangle);
+    g_slice_free (GstClapperGdkOverlay, overlay);
+  }
+}
+
+static GstBufferPool *
+_default_create_pool (GstClapperImporter *self, GstStructure **config)
+{
+  GST_FIXME_OBJECT (self, "Need to create buffer pool");
+
+  return NULL;
+}
+
+static void
+_default_add_allocation_metas (GstClapperImporter *importer, GstQuery *query)
+{
+  /* Importer base class handles GstVideoOverlayCompositionMeta */
+  gst_query_add_allocation_meta (query, GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL);
+  gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
+}
+
+static GdkTexture *
+_default_generate_texture (GstClapperImporter *self,
+    GstBuffer *buffer, GstVideoInfo *v_info)
+{
+  GST_FIXME_OBJECT (self, "GdkTexture generation not implemented");
+
+  return NULL;
+}
+
+static void
+gst_clapper_importer_init (GstClapperImporter *self)
+{
+  gst_video_info_init (&self->pending_v_info);
+  gst_video_info_init (&self->v_info);
+
+  self->pending_overlays = g_ptr_array_new_with_free_func (
+      (GDestroyNotify) gst_clapper_gdk_overlay_unref);
+  self->overlays = g_ptr_array_new_with_free_func (
+      (GDestroyNotify) gst_clapper_gdk_overlay_unref);
+
+  gdk_rgba_parse (&self->bg, "black");
+}
+
+static void
+gst_clapper_importer_finalize (GObject *object)
+{
+  GstClapperImporter *self = GST_CLAPPER_IMPORTER_CAST (object);
+
+  GST_TRACE ("Finalize");
+
+  gst_clear_caps (&self->pending_caps);
+
+  gst_clear_buffer (&self->pending_buffer);
+  gst_clear_buffer (&self->buffer);
+
+  g_ptr_array_unref (self->pending_overlays);
+  g_ptr_array_unref (self->overlays);
+
+  g_clear_object (&self->texture);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_importer_class_init (GstClapperImporterClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+  GstClapperImporterClass *importer_class = (GstClapperImporterClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperimporter", 0,
+      "Clapper Importer");
+
+  gobject_class->finalize = gst_clapper_importer_finalize;
+
+  importer_class->create_pool = _default_create_pool;
+  importer_class->add_allocation_metas = _default_add_allocation_metas;
+  importer_class->generate_texture = _default_generate_texture;
+}
+
+static GstClapperGdkOverlay *
+_get_cached_overlay (GPtrArray *overlays, GstVideoOverlayRectangle *rectangle)
+{
+  guint i;
+
+  for (i = 0; i < overlays->len; i++) {
+    GstClapperGdkOverlay *overlay = g_ptr_array_index (overlays, i);
+
+    if (overlay->rectangle == rectangle)
+      return overlay;
+  }
+
+  return NULL;
+}
+
+static gint
+_sort_overlays_cb (gconstpointer a, gconstpointer b)
+{
+  GstClapperGdkOverlay *overlay_a, *overlay_b;
+
+  overlay_a = *((GstClapperGdkOverlay **) a);
+  overlay_b = *((GstClapperGdkOverlay **) b);
+
+  return (overlay_a->index - overlay_b->index);
+}
+
+/*
+ * Prepares overlays to show with the next rendered buffer.
+ *
+ * In order for overlays caching to work correctly, this should be called for
+ * every received buffer (even if its going to be disgarded), also must be
+ * called together with pending buffer replacement within a single importer
+ * locking, to make sure prepared overlays always match the pending buffer.
+ */
+static void
+gst_clapper_importer_prepare_overlays_locked (GstClapperImporter *self)
+{
+  GstVideoOverlayCompositionMeta *comp_meta;
+  guint num_overlays, i;
+
+  if (G_UNLIKELY (!self->pending_buffer)
+      || !(comp_meta = gst_buffer_get_video_overlay_composition_meta (self->pending_buffer))) {
+    guint n_pending = self->pending_overlays->len;
+
+    /* Remove all cached overlays if new buffer does not have any */
+    if (n_pending > 0) {
+      GST_TRACE ("No overlays in buffer, removing all cached ones");
+      g_ptr_array_remove_range (self->pending_overlays, 0, n_pending);
+    }
+
+    return;
+  }
+
+  GST_LOG_OBJECT (self, "Preparing overlays...");
+
+  /* Mark all old overlays as unused by giving them negative index */
+  for (i = 0; i < self->pending_overlays->len; i++) {
+    GstClapperGdkOverlay *overlay = g_ptr_array_index (self->pending_overlays, i);
+    overlay->index = -1;
+  }
+
+  num_overlays = gst_video_overlay_composition_n_rectangles (comp_meta->overlay);
+
+  for (i = 0; i < num_overlays; i++) {
+    GdkTexture *texture;
+    GstBuffer *comp_buffer;
+    GstVideoFrame comp_frame;
+    GstVideoMeta *v_meta;
+    GstVideoInfo v_info;
+    GstVideoOverlayRectangle *rectangle;
+    GstClapperGdkOverlay *overlay;
+    GstVideoOverlayFormatFlags flags, alpha_flags = 0;
+    gint comp_x, comp_y;
+    guint comp_width, comp_height;
+
+    rectangle = gst_video_overlay_composition_get_rectangle (comp_meta->overlay, i);
+
+    if ((overlay = _get_cached_overlay (self->pending_overlays, rectangle))) {
+      overlay->index = i;
+
+      GST_TRACE ("Reusing cached overlay: %" GST_PTR_FORMAT, overlay);
+      continue;
+    }
+
+    if (G_UNLIKELY (!gst_video_overlay_rectangle_get_render_rectangle (rectangle,
+        &comp_x, &comp_y, &comp_width, &comp_height))) {
+      GST_WARNING ("Invalid overlay rectangle dimensions: %" GST_PTR_FORMAT, rectangle);
+      continue;
+    }
+
+    flags = gst_video_overlay_rectangle_get_flags (rectangle);
+
+    if (flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
+      alpha_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA;
+
+    comp_buffer = gst_video_overlay_rectangle_get_pixels_unscaled_argb (rectangle, alpha_flags);
+
+    /* Update overlay video info from video meta */
+    if ((v_meta = gst_buffer_get_video_meta (comp_buffer))) {
+      gst_video_info_set_format (&v_info, v_meta->format, v_meta->width, v_meta->height);
+      v_info.stride[0] = v_meta->stride[0];
+
+      if (alpha_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
+        v_info.flags |= GST_VIDEO_FLAG_PREMULTIPLIED_ALPHA;
+    }
+
+    if (G_UNLIKELY (!gst_video_frame_map (&comp_frame, &v_info, comp_buffer, GST_MAP_READ)))
+      return;
+
+    if ((texture = gst_video_frame_into_gdk_texture (&comp_frame))) {
+      overlay = gst_clapper_gdk_overlay_new (texture, rectangle, comp_x, comp_y,
+          comp_width, comp_height, i);
+      g_object_unref (texture);
+
+      GST_TRACE_OBJECT (self, "Created overlay: %"
+          GST_PTR_FORMAT ", x: %i, y: %i, width: %u, height: %u",
+          overlay, overlay->x, overlay->y, overlay->width, overlay->height);
+
+      g_ptr_array_insert (self->pending_overlays, i, overlay);
+    }
+
+    gst_video_frame_unmap (&comp_frame);
+  }
+
+  /* Remove all overlays that are not going to be used */
+  for (i = self->pending_overlays->len; i > 0; i--) {
+    GstClapperGdkOverlay *overlay = g_ptr_array_index (self->pending_overlays, i - 1);
+
+    if (overlay->index < 0) {
+      GST_TRACE ("Removing unused cached overlay: %" GST_PTR_FORMAT, overlay);
+      g_ptr_array_remove (self->pending_overlays, overlay);
+    }
+  }
+
+  /* Sort remaining overlays */
+  if (self->pending_overlays->len > 1) {
+    GST_LOG_OBJECT (self, "Sorting overlays");
+    g_ptr_array_sort (self->pending_overlays, (GCompareFunc) _sort_overlays_cb);
+  }
+
+  if (G_UNLIKELY (num_overlays != self->pending_overlays->len)) {
+    GST_WARNING_OBJECT (self, "Some overlays could not be prepared, %u != %u",
+        num_overlays, self->pending_overlays->len);
+  }
+
+  GST_LOG_OBJECT (self, "Prepared overlays: %u", self->pending_overlays->len);
+}
+
+void
+gst_clapper_importer_set_caps (GstClapperImporter *self, GstCaps *caps)
+{
+  GstClapperImporterClass *importer_class = GST_CLAPPER_IMPORTER_GET_CLASS (self);
+
+  GST_OBJECT_LOCK (self);
+  gst_caps_replace (&self->pending_caps, caps);
+  GST_OBJECT_UNLOCK (self);
+
+  if (importer_class->set_caps)
+    importer_class->set_caps (self, caps);
+}
+
+void
+gst_clapper_importer_set_buffer (GstClapperImporter *self, GstBuffer *buffer)
+{
+  GST_OBJECT_LOCK (self);
+
+  /* Pending v_info, buffer and overlays must be
+   * set within a single importer locking */
+  if (self->pending_caps) {
+    self->has_pending_v_info = gst_video_info_from_caps (&self->pending_v_info, self->pending_caps);
+    gst_clear_caps (&self->pending_caps);
+  }
+  gst_buffer_replace (&self->pending_buffer, buffer);
+  gst_clapper_importer_prepare_overlays_locked (self);
+
+  GST_OBJECT_UNLOCK (self);
+}
+
+GstBufferPool *
+gst_clapper_importer_create_pool (GstClapperImporter *self, GstStructure **config)
+{
+  GstClapperImporterClass *importer_class = GST_CLAPPER_IMPORTER_GET_CLASS (self);
+
+  return importer_class->create_pool (self, config);
+}
+
+void
+gst_clapper_importer_add_allocation_metas (GstClapperImporter *self, GstQuery *query)
+{
+  GstClapperImporterClass *importer_class = GST_CLAPPER_IMPORTER_GET_CLASS (self);
+
+  importer_class->add_allocation_metas (self, query);
+}
+
+void
+gst_clapper_importer_snapshot (GstClapperImporter *self, GdkSnapshot *snapshot,
+    gdouble width, gdouble height)
+{
+  guint i;
+  gboolean buffer_changed;
+
+  /* Collect all data that we need to snapshot pending buffer,
+   * lock ourselves to make sure everything matches */
+  GST_OBJECT_LOCK (self);
+
+  if (self->has_pending_v_info) {
+    self->v_info = self->pending_v_info;
+    self->has_pending_v_info = FALSE;
+  }
+
+  buffer_changed = gst_buffer_replace (&self->buffer, self->pending_buffer);
+
+  /* Ref overlays associated with current buffer */
+  for (i = 0; i < self->pending_overlays->len; i++) {
+    GstClapperGdkOverlay *overlay = g_ptr_array_index (self->pending_overlays, i);
+
+    g_ptr_array_insert (self->overlays, i, gst_clapper_gdk_overlay_ref (overlay));
+  }
+
+  GST_OBJECT_UNLOCK (self);
+
+  /* Draw black BG when no buffer or imported format has alpha */
+  if (!self->buffer || GST_VIDEO_INFO_HAS_ALPHA (&self->v_info))
+    gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (0, 0, width, height));
+
+  if (self->buffer) {
+    if (buffer_changed || !self->texture) {
+      GstClapperImporterClass *importer_class = GST_CLAPPER_IMPORTER_GET_CLASS (self);
+
+      GST_TRACE_OBJECT (self, "Importing %" GST_PTR_FORMAT, self->buffer);
+
+      g_clear_object (&self->texture);
+      self->texture = importer_class->generate_texture (self, self->buffer, &self->v_info);
+    } else {
+      GST_TRACE_OBJECT (self, "Reusing texture from %" GST_PTR_FORMAT, self->buffer);
+    }
+
+    if (G_LIKELY (self->texture)) {
+      gtk_snapshot_append_texture (snapshot, self->texture, &GRAPHENE_RECT_INIT (0, 0, width, height));
+
+      if (self->overlays->len > 0) {
+        gfloat scale_x, scale_y;
+
+        /* FIXME: GStreamer scales subtitles without considering pixel aspect ratio.
+         * See: https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/issues/20 */
+        scale_x = (gfloat) width / GST_VIDEO_INFO_WIDTH (&self->v_info);
+        scale_y = (gfloat) height / GST_VIDEO_INFO_HEIGHT (&self->v_info);
+
+        for (i = 0; i < self->overlays->len; i++) {
+          GstClapperGdkOverlay *overlay = g_ptr_array_index (self->overlays, i);
+
+          gtk_snapshot_append_texture (snapshot, overlay->texture,
+              &GRAPHENE_RECT_INIT (overlay->x * scale_x, overlay->y * scale_y,
+                  overlay->width * scale_x, overlay->height * scale_y));
+        }
+      }
+    } else {
+      GST_ERROR_OBJECT (self, "Failed import of %" GST_PTR_FORMAT, self->buffer);
+
+      /* Draw black instead of texture on failure if not drawn already */
+      if (!GST_VIDEO_INFO_HAS_ALPHA (&self->v_info))
+        gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (0, 0, width, height));
+    }
+  }
+
+  /* Unref all used overlays */
+  if (self->overlays->len > 0)
+    g_ptr_array_remove_range (self->overlays, 0, self->overlays->len);
+}

src/lib/gst/plugin/gstclapperimporter.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <gst/gst.h>
+#include <gst/video/video.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_IMPORTER               (gst_clapper_importer_get_type())
+#define GST_IS_CLAPPER_IMPORTER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_CLAPPER_IMPORTER))
+#define GST_IS_CLAPPER_IMPORTER_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_CLAPPER_IMPORTER))
+#define GST_CLAPPER_IMPORTER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_CLAPPER_IMPORTER, GstClapperImporterClass))
+#define GST_CLAPPER_IMPORTER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_CLAPPER_IMPORTER, GstClapperImporter))
+#define GST_CLAPPER_IMPORTER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_CLAPPER_IMPORTER, GstClapperImporterClass))
+#define GST_CLAPPER_IMPORTER_CAST(obj)          ((GstClapperImporter *)(obj))
+
+#define GST_CLAPPER_IMPORTER_DEFINE(camel,lower,type)                            \
+G_DEFINE_TYPE (camel, lower, type)                                               \
+G_MODULE_EXPORT GstClapperImporter *make_importer (GPtrArray *context_handlers); \
+G_MODULE_EXPORT GstCaps *make_caps (gboolean is_template,                        \
+    GstRank *rank, GPtrArray *context_handlers);
+
+typedef struct _GstClapperImporter GstClapperImporter;
+typedef struct _GstClapperImporterClass GstClapperImporterClass;
+
+#ifdef G_DEFINE_AUTOPTR_CLEANUP_FUNC
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GstClapperImporter, gst_object_unref)
+#endif
+
+struct _GstClapperImporter
+{
+  GstObject parent;
+
+  GstCaps *pending_caps;
+  GstBuffer *pending_buffer, *buffer;
+  GPtrArray *pending_overlays, *overlays;
+  GstVideoInfo pending_v_info, v_info;
+  gboolean has_pending_v_info;
+
+  GdkTexture *texture;
+
+  GdkRGBA bg;
+};
+
+struct _GstClapperImporterClass
+{
+  GstObjectClass parent_class;
+
+  void (* set_caps) (GstClapperImporter *importer,
+                     GstCaps            *caps);
+
+  GstBufferPool * (* create_pool) (GstClapperImporter *importer,
+                                   GstStructure      **config);
+
+  void (* add_allocation_metas) (GstClapperImporter *importer,
+                                 GstQuery           *query);
+
+  GdkTexture * (* generate_texture) (GstClapperImporter *importer,
+                                     GstBuffer          *buffer,
+                                     GstVideoInfo       *v_info);
+};
+
+GType           gst_clapper_importer_get_type                (void);
+
+GstBufferPool * gst_clapper_importer_create_pool             (GstClapperImporter *importer, GstStructure **config);
+void            gst_clapper_importer_add_allocation_metas    (GstClapperImporter *importer, GstQuery *query);
+
+void            gst_clapper_importer_set_caps                (GstClapperImporter *importer, GstCaps *caps);
+void            gst_clapper_importer_set_buffer              (GstClapperImporter *importer, GstBuffer *buffer);
+
+void            gst_clapper_importer_snapshot                (GstClapperImporter *importer, GdkSnapshot *snapshot, gdouble width, gdouble height);
+
+G_END_DECLS

src/lib/gst/plugin/gstclapperimporterloader.c

@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gmodule.h>
+
+#include "gstclapperimporterloader.h"
+#include "gstclapperimporter.h"
+#include "gstclappercontexthandler.h"
+
+#define GST_CAT_DEFAULT gst_clapper_importer_loader_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define parent_class gst_clapper_importer_loader_parent_class
+G_DEFINE_TYPE (GstClapperImporterLoader, gst_clapper_importer_loader, GST_TYPE_OBJECT);
+
+typedef GstClapperImporter* (* MakeImporter) (GPtrArray *context_handlers);
+typedef GstCaps* (* MakeCaps) (gboolean is_template, GstRank *rank, GPtrArray *context_handlers);
+
+typedef struct
+{
+  GModule *module;
+  GstCaps *caps;
+  GstRank rank;
+} GstClapperImporterData;
+
+static void
+gst_clapper_importer_data_free (GstClapperImporterData *data)
+{
+  GST_TRACE ("Freeing importer data: %" GST_PTR_FORMAT, data);
+
+  gst_clear_caps (&data->caps);
+  g_free (data);
+}
+
+static GstClapperImporterData *
+_obtain_importer_data (GModule *module, gboolean is_template, GPtrArray *context_handlers)
+{
+  MakeCaps make_caps;
+  GstClapperImporterData *data;
+
+  GST_DEBUG ("Found importer: %s", g_module_name (module));
+
+  if (!g_module_symbol (module, "make_caps", (gpointer *) &make_caps)
+      || make_caps == NULL) {
+    GST_WARNING ("Make caps function missing in importer");
+    return NULL;
+  }
+
+  data = g_new0 (GstClapperImporterData, 1);
+  data->module = module;
+  data->caps = make_caps (is_template, &data->rank, context_handlers);
+
+  GST_TRACE ("Created importer data: %" GST_PTR_FORMAT, data);
+
+  if (G_UNLIKELY (!data->caps)) {
+    if (!is_template) {
+      GST_ERROR ("Invalid importer without caps: %s",
+          g_module_name (data->module));
+    } else {
+      /* When importer cannot be actually used, due to e.g. unsupported HW */
+      GST_DEBUG ("No actual caps returned from importer");
+    }
+    gst_clapper_importer_data_free (data);
+
+    return NULL;
+  }
+
+  GST_DEBUG ("Importer caps: %" GST_PTR_FORMAT, data->caps);
+
+  return data;
+}
+
+static GstClapperImporter *
+_obtain_importer_internal (GModule *module, GPtrArray *context_handlers)
+{
+  MakeImporter make_importer;
+  GstClapperImporter *importer;
+
+  if (!g_module_symbol (module, "make_importer", (gpointer *) &make_importer)
+      || make_importer == NULL) {
+    GST_WARNING ("Make function missing in importer");
+    return NULL;
+  }
+
+  importer = make_importer (context_handlers);
+  GST_TRACE ("Created importer: %" GST_PTR_FORMAT, importer);
+
+  return importer;
+}
+
+static gpointer
+_obtain_available_modules_once (G_GNUC_UNUSED gpointer data)
+{
+  GPtrArray *modules;
+  GFile *dir;
+  GFileEnumerator *dir_enum;
+  GError *error = NULL;
+
+  GST_INFO ("Preparing modules");
+
+  modules = g_ptr_array_new ();
+  dir = g_file_new_for_path (CLAPPER_SINK_IMPORTER_PATH);
+
+  if ((dir_enum = g_file_enumerate_children (dir,
+      G_FILE_ATTRIBUTE_STANDARD_NAME,
+      G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &error))) {
+    while (TRUE) {
+      GFileInfo *info = NULL;
+      GModule *module;
+      gchar *module_path;
+      const gchar *module_name;
+
+      if (!g_file_enumerator_iterate (dir_enum, &info,
+          NULL, NULL, &error) || !info)
+        break;
+
+      module_name = g_file_info_get_name (info);
+
+      if (!g_str_has_suffix (module_name, G_MODULE_SUFFIX))
+        continue;
+
+      module_path = g_module_build_path (CLAPPER_SINK_IMPORTER_PATH, module_name);
+      module = g_module_open (module_path, G_MODULE_BIND_LAZY);
+      g_free (module_path);
+
+      if (!module) {
+        GST_WARNING ("Could not read module: %s, reason: %s",
+            module_name, g_module_error ());
+        continue;
+      }
+
+      GST_INFO ("Found module: %s", module_name);
+      g_ptr_array_add (modules, module);
+    }
+
+    g_object_unref (dir_enum);
+  }
+
+  g_object_unref (dir);
+
+  if (error) {
+    GST_ERROR ("Could not load module, reason: %s",
+        (error->message) ? error->message : "unknown");
+    g_error_free (error);
+  }
+
+  return modules;
+}
+
+static const GPtrArray *
+gst_clapper_importer_loader_get_available_modules (void)
+{
+  static GOnce once = G_ONCE_INIT;
+
+  g_once (&once, _obtain_available_modules_once, NULL);
+  return (const GPtrArray *) once.retval;
+}
+
+static gint
+_sort_importers_cb (gconstpointer a, gconstpointer b)
+{
+  GstClapperImporterData *data_a, *data_b;
+
+  data_a = *((GstClapperImporterData **) a);
+  data_b = *((GstClapperImporterData **) b);
+
+  return (data_b->rank - data_a->rank);
+}
+
+static GPtrArray *
+_obtain_importers (gboolean is_template, GPtrArray *context_handlers)
+{
+  const GPtrArray *modules;
+  GPtrArray *importers;
+  guint i;
+
+  GST_DEBUG ("Checking %s importers",
+      (is_template) ? "available" : "usable");
+
+  modules = gst_clapper_importer_loader_get_available_modules ();
+  importers = g_ptr_array_new_with_free_func (
+      (GDestroyNotify) gst_clapper_importer_data_free);
+
+  for (i = 0; i < modules->len; i++) {
+    GModule *module = g_ptr_array_index (modules, i);
+    GstClapperImporterData *data;
+
+    if ((data = _obtain_importer_data (module, is_template, context_handlers)))
+      g_ptr_array_add (importers, data);
+  }
+
+  g_ptr_array_sort (importers, (GCompareFunc) _sort_importers_cb);
+
+  GST_DEBUG ("Found %i %s importers", importers->len,
+      (is_template) ? "available" : "usable");
+
+  return importers;
+}
+
+GstClapperImporterLoader *
+gst_clapper_importer_loader_new (void)
+{
+  return g_object_new (GST_TYPE_CLAPPER_IMPORTER_LOADER, NULL);
+}
+
+static GstCaps *
+_make_caps_for_importers (const GPtrArray *importers)
+{
+  GstCaps *caps = gst_caps_new_empty ();
+  guint i;
+
+  for (i = 0; i < importers->len; i++) {
+    GstClapperImporterData *data = g_ptr_array_index (importers, i);
+
+    gst_caps_append (caps, gst_caps_ref (data->caps));
+  }
+
+  return caps;
+}
+
+GstPadTemplate *
+gst_clapper_importer_loader_make_sink_pad_template (void)
+{
+  GPtrArray *importers;
+  GstCaps *caps;
+  GstPadTemplate *templ;
+
+  /* This is only called once from sink class init function */
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperimporterloader", 0,
+      "Clapper Importer Loader");
+
+  GST_DEBUG ("Making sink pad template");
+
+  importers = _obtain_importers (TRUE, NULL);
+  caps = _make_caps_for_importers (importers);
+  g_ptr_array_unref (importers);
+
+  if (G_UNLIKELY (gst_caps_is_empty (caps)))
+    gst_caps_append (caps, gst_caps_new_any ());
+
+  templ = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps);
+  gst_caps_unref (caps);
+
+  GST_TRACE ("Created sink pad template");
+
+  return templ;
+}
+
+GstCaps *
+gst_clapper_importer_loader_make_actual_caps (GstClapperImporterLoader *self)
+{
+  return _make_caps_for_importers (self->importers);
+}
+
+gboolean
+gst_clapper_importer_loader_handle_context_query (GstClapperImporterLoader *self,
+    GstBaseSink *bsink, GstQuery *query)
+{
+  guint i;
+
+  for (i = 0; i < self->context_handlers->len; i++) {
+    GstClapperContextHandler *handler = g_ptr_array_index (self->context_handlers, i);
+
+    if (gst_clapper_context_handler_handle_context_query (handler, bsink, query))
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
+static const GstClapperImporterData *
+_get_importer_data_for_caps (const GPtrArray *importers, const GstCaps *caps)
+{
+  guint i;
+
+  for (i = 0; i < importers->len; i++) {
+    GstClapperImporterData *data = g_ptr_array_index (importers, i);
+
+    if (!gst_caps_is_always_compatible (caps, data->caps))
+      continue;
+
+    return data;
+  }
+
+  return NULL;
+}
+
+gboolean
+gst_clapper_importer_loader_find_importer_for_caps (GstClapperImporterLoader *self,
+    GstCaps *caps, GstClapperImporter **importer)
+{
+  const GstClapperImporterData *data = NULL;
+  GstClapperImporter *found_importer = NULL;
+
+  GST_OBJECT_LOCK (self);
+
+  GST_DEBUG_OBJECT (self, "Requested importer for caps: %" GST_PTR_FORMAT, caps);
+  data = _get_importer_data_for_caps (self->importers, caps);
+
+  GST_LOG_OBJECT (self, "Old importer path: %s, new path: %s",
+      (self->last_module) ? g_module_name (self->last_module) : NULL,
+      (data) ? g_module_name (data->module) : NULL);
+
+  if (G_UNLIKELY (!data)) {
+    gst_clear_object (importer);
+    goto finish;
+  }
+
+  if (*importer && (self->last_module == data->module)) {
+    GST_DEBUG_OBJECT (self, "No importer change");
+
+    gst_clapper_importer_set_caps (*importer, caps);
+    goto finish;
+  }
+
+  found_importer = _obtain_importer_internal (data->module, self->context_handlers);
+  gst_clear_object (importer);
+
+  if (!found_importer)
+    goto finish;
+
+  gst_clapper_importer_set_caps (found_importer, caps);
+
+  *importer = found_importer;
+
+finish:
+  self->last_module = (*importer && data)
+      ? data->module
+      : NULL;
+
+  GST_OBJECT_UNLOCK (self);
+
+  return (*importer != NULL);
+}
+
+static void
+gst_clapper_importer_loader_init (GstClapperImporterLoader *self)
+{
+  self->context_handlers = g_ptr_array_new_with_free_func (
+      (GDestroyNotify) gst_object_unref);
+  self->importers = _obtain_importers (FALSE, self->context_handlers);
+}
+
+static void
+gst_clapper_importer_loader_finalize (GObject *object)
+{
+  GstClapperImporterLoader *self = GST_CLAPPER_IMPORTER_LOADER_CAST (object);
+
+  GST_TRACE ("Finalize");
+
+  if (self->importers)
+    g_ptr_array_unref (self->importers);
+
+  g_ptr_array_unref (self->context_handlers);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_importer_loader_class_init (GstClapperImporterLoaderClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+
+  gobject_class->finalize = gst_clapper_importer_loader_finalize;
+}

src/lib/gst/plugin/gstclapperimporterloader.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <gst/gst.h>
+#include <gst/base/gstbasesink.h>
+
+#include "gstclapperimporter.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_IMPORTER_LOADER (gst_clapper_importer_loader_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperImporterLoader, gst_clapper_importer_loader, GST, CLAPPER_IMPORTER_LOADER, GstObject)
+
+#define GST_CLAPPER_IMPORTER_LOADER_CAST(obj)        ((GstClapperImporterLoader *)(obj))
+
+struct _GstClapperImporterLoader
+{
+  GstObject parent;
+
+  GModule *last_module;
+
+  GPtrArray *importers;
+  GPtrArray *context_handlers;
+};
+
+GstClapperImporterLoader * gst_clapper_importer_loader_new                             (void);
+
+GstPadTemplate *           gst_clapper_importer_loader_make_sink_pad_template          (void);
+
+GstCaps *                  gst_clapper_importer_loader_make_actual_caps                (GstClapperImporterLoader *loader);
+
+gboolean                   gst_clapper_importer_loader_handle_context_query            (GstClapperImporterLoader *loader, GstBaseSink *bsink, GstQuery *query);
+
+gboolean                   gst_clapper_importer_loader_find_importer_for_caps          (GstClapperImporterLoader *loader, GstCaps *caps, GstClapperImporter **importer);
+
+G_END_DECLS

src/lib/gst/plugin/gstclapperpaintable.c

@@ -0,0 +1,530 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclapperpaintable.h"
+
+#include "gstgtkutils.h"
+
+#define DEFAULT_PAR_N               1
+#define DEFAULT_PAR_D               1
+
+#define GST_CAT_DEFAULT gst_clapper_paintable_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+static void gst_clapper_paintable_iface_init (GdkPaintableInterface *iface);
+static void gst_clapper_paintable_dispose (GObject *object);
+static void gst_clapper_paintable_finalize (GObject *object);
+
+#define parent_class gst_clapper_paintable_parent_class
+G_DEFINE_TYPE_WITH_CODE (GstClapperPaintable, gst_clapper_paintable, G_TYPE_OBJECT,
+    G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+        gst_clapper_paintable_iface_init));
+
+static void
+gst_clapper_paintable_class_init (GstClapperPaintableClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperpaintable", 0,
+      "Clapper Paintable");
+
+  gobject_class->dispose = gst_clapper_paintable_dispose;
+  gobject_class->finalize = gst_clapper_paintable_finalize;
+}
+
+static void
+gst_clapper_paintable_init (GstClapperPaintable *self)
+{
+  self->display_width = 1;
+  self->display_height = 1;
+  self->display_aspect_ratio = 1.0;
+
+  self->rotation = GST_VIDEO_ORIENTATION_IDENTITY;
+
+  self->par_n = DEFAULT_PAR_N;
+  self->par_d = DEFAULT_PAR_D;
+
+  g_mutex_init (&self->lock);
+  g_mutex_init (&self->importer_lock);
+
+  gst_video_info_init (&self->v_info);
+  g_weak_ref_init (&self->widget, NULL);
+
+  gdk_rgba_parse (&self->bg, "black");
+}
+
+static void
+gst_clapper_paintable_dispose (GObject *object)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE (object);
+
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  if (self->draw_id > 0) {
+    g_source_remove (self->draw_id);
+    self->draw_id = 0;
+  }
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+  GST_CLAPPER_PAINTABLE_IMPORTER_LOCK (self);
+  gst_clear_object (&self->importer);
+  GST_CLAPPER_PAINTABLE_IMPORTER_UNLOCK (self);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
+}
+
+static void
+gst_clapper_paintable_finalize (GObject *object)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE (object);
+
+  GST_TRACE ("Finalize");
+
+  g_weak_ref_clear (&self->widget);
+
+  g_mutex_clear (&self->lock);
+  g_mutex_clear (&self->importer_lock);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static gboolean
+calculate_display_par (GstClapperPaintable *self, const GstVideoInfo *info)
+{
+  gint width, height, par_n, par_d, req_par_n, req_par_d;
+  gboolean success;
+
+  gst_gtk_get_width_height_for_rotation (GST_VIDEO_INFO_WIDTH (info),
+      GST_VIDEO_INFO_HEIGHT (info), &width, &height, self->rotation);
+
+  /* Cannot apply aspect ratio if there is no video */
+  if (width == 0 || height == 0)
+    return FALSE;
+
+  par_n = GST_VIDEO_INFO_PAR_N (info);
+  par_d = GST_VIDEO_INFO_PAR_D (info);
+
+  req_par_n = self->par_n;
+  req_par_d = self->par_d;
+
+  if (par_n == 0)
+    par_n = 1;
+
+  /* Use defaults if user set zero */
+  if (req_par_n == 0 || req_par_d == 0) {
+    req_par_n = DEFAULT_PAR_N;
+    req_par_d = DEFAULT_PAR_D;
+  }
+
+  GST_LOG_OBJECT (self, "PAR: %u/%u, DAR: %u/%u", par_n, par_d, req_par_n, req_par_d);
+
+  if (!(success = gst_video_calculate_display_ratio (&self->display_ratio_num,
+      &self->display_ratio_den, width, height, par_n, par_d,
+      req_par_n, req_par_d))) {
+    GST_ERROR_OBJECT (self, "Could not calculate display ratio values");
+  }
+
+  return success;
+}
+
+static void
+invalidate_paintable_size_internal (GstClapperPaintable *self)
+{
+  gint video_width, video_height;
+  guint display_ratio_num, display_ratio_den;
+
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  gst_gtk_get_width_height_for_rotation (GST_VIDEO_INFO_WIDTH (&self->v_info),
+      GST_VIDEO_INFO_HEIGHT (&self->v_info), &video_height, &video_width,
+      self->rotation);
+
+  display_ratio_num = self->display_ratio_num;
+  display_ratio_den = self->display_ratio_den;
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+  if (video_height % display_ratio_den == 0) {
+    GST_LOG ("Keeping video height");
+
+    self->display_width = (guint)
+        gst_util_uint64_scale_int (video_height, display_ratio_num, display_ratio_den);
+    self->display_height = video_height;
+  } else if (video_width % display_ratio_num == 0) {
+    GST_LOG ("Keeping video width");
+
+    self->display_width = video_width;
+    self->display_height = (guint)
+        gst_util_uint64_scale_int (video_width, display_ratio_den, display_ratio_num);
+  } else {
+    GST_LOG ("Approximating while keeping video height");
+
+    self->display_width = (guint)
+        gst_util_uint64_scale_int (video_height, display_ratio_num, display_ratio_den);
+    self->display_height = video_height;
+  }
+
+  self->display_aspect_ratio = ((gdouble) self->display_width
+      / (gdouble) self->display_height);
+
+  GST_DEBUG_OBJECT (self, "Invalidate paintable size, display: %dx%d",
+      self->display_width, self->display_height);
+  gdk_paintable_invalidate_size ((GdkPaintable *) self);
+}
+
+static gboolean
+invalidate_paintable_size_on_main_cb (GstClapperPaintable *self)
+{
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+  self->draw_id = 0;
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+  invalidate_paintable_size_internal (self);
+
+  return G_SOURCE_REMOVE;
+}
+
+static gboolean
+update_paintable_on_main_cb (GstClapperPaintable *self)
+{
+  gboolean size_changed;
+
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  /* Check if we will need to invalidate size */
+  if ((size_changed = self->pending_resize))
+    self->pending_resize = FALSE;
+
+  self->draw_id = 0;
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+  if (size_changed)
+    invalidate_paintable_size_internal (self);
+
+  GST_LOG_OBJECT (self, "Invalidate paintable contents");
+  gdk_paintable_invalidate_contents ((GdkPaintable *) self);
+
+  return G_SOURCE_REMOVE;
+}
+
+GstClapperPaintable *
+gst_clapper_paintable_new (void)
+{
+  return g_object_new (GST_TYPE_CLAPPER_PAINTABLE, NULL);
+}
+
+void
+gst_clapper_paintable_set_widget (GstClapperPaintable *self, GtkWidget *widget)
+{
+  g_weak_ref_set (&self->widget, widget);
+}
+
+void
+gst_clapper_paintable_set_importer (GstClapperPaintable *self, GstClapperImporter *importer)
+{
+  GST_CLAPPER_PAINTABLE_IMPORTER_LOCK (self);
+  gst_object_replace ((GstObject **) &self->importer, GST_OBJECT_CAST (importer));
+  GST_CLAPPER_PAINTABLE_IMPORTER_UNLOCK (self);
+}
+
+void
+gst_clapper_paintable_queue_draw (GstClapperPaintable *self)
+{
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  if (self->draw_id > 0) {
+    GST_CLAPPER_PAINTABLE_UNLOCK (self);
+    GST_TRACE ("Already have pending draw");
+
+    return;
+  }
+
+  self->draw_id = g_idle_add_full (G_PRIORITY_DEFAULT,
+      (GSourceFunc) update_paintable_on_main_cb, self, NULL);
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+}
+
+gboolean
+gst_clapper_paintable_set_video_info (GstClapperPaintable *self, const GstVideoInfo *v_info)
+{
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  if (gst_video_info_is_equal (&self->v_info, v_info)) {
+    GST_CLAPPER_PAINTABLE_UNLOCK (self);
+    return TRUE;
+  }
+
+  /* Reject info if values would cause integer overflow */
+  if (G_UNLIKELY (!calculate_display_par (self, v_info))) {
+    GST_CLAPPER_PAINTABLE_UNLOCK (self);
+    return FALSE;
+  }
+
+  self->pending_resize = TRUE;
+  self->v_info = *v_info;
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+  return TRUE;
+}
+
+void
+gst_clapper_paintable_set_pixel_aspect_ratio (GstClapperPaintable *self,
+    gint par_n, gint par_d)
+{
+  gboolean success;
+
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  /* No change */
+  if (self->par_n == par_n && self->par_d == par_d) {
+    GST_CLAPPER_PAINTABLE_UNLOCK (self);
+    return;
+  }
+
+  self->par_n = par_n;
+  self->par_d = par_d;
+
+  /* Check if we can accept new values. This will update
+   * display `ratio_num` and `ratio_den` only when successful */
+  success = calculate_display_par (self, &self->v_info);
+
+  /* If paintable update is queued, wait for it, otherwise invalidate
+   * size only for change to be applied even when paused */
+  if (!success || self->draw_id > 0) {
+    self->pending_resize = success;
+    GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+    return;
+  }
+
+  self->draw_id = g_idle_add_full (G_PRIORITY_DEFAULT,
+      (GSourceFunc) invalidate_paintable_size_on_main_cb, self, NULL);
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+}
+
+void
+gst_clapper_paintable_set_rotation (GstClapperPaintable *self,
+    GstVideoOrientationMethod rotation)
+{
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  self->rotation = rotation;
+
+  if (G_UNLIKELY (!calculate_display_par (self, &self->v_info))) {
+    GST_CLAPPER_PAINTABLE_UNLOCK (self);
+    return;
+  }
+
+  self->pending_resize = TRUE;
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+}
+
+GstVideoOrientationMethod
+gst_clapper_paintable_get_rotation (GstClapperPaintable *self)
+{
+  GstVideoOrientationMethod rotation;
+
+  GST_CLAPPER_PAINTABLE_LOCK (self);
+
+  rotation = self->rotation;
+
+  GST_CLAPPER_PAINTABLE_UNLOCK (self);
+
+  return rotation;
+}
+
+/*
+ * GdkPaintableInterface
+ */
+static void
+gst_clapper_paintable_snapshot_internal (GstClapperPaintable *self,
+    GdkSnapshot *snapshot, gdouble width, gdouble height,
+    gint widget_width, gint widget_height)
+{
+  gfloat scale_x, scale_y;
+  gdouble snapshot_width, snapshot_height;
+  GskTransform *transform = NULL;
+
+  GST_LOG_OBJECT (self, "Snapshot");
+
+  scale_x = (gfloat) width / self->display_width;
+  scale_y = (gfloat) height / self->display_height;
+
+  /* Apply black borders when keeping aspect ratio */
+  if (scale_x == scale_y || abs (scale_x - scale_y) <= FLT_EPSILON) {
+    if (widget_height - height > 0) {
+      /* XXX: Top uses integer to work with GTK rounding (not going offscreen) */
+      gint top_bar_height = (widget_height - height) / 2;
+      gdouble bottom_bar_height = (widget_height - top_bar_height - height);
+
+      gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (0, 0, width, -top_bar_height));
+      gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (0, height, width, bottom_bar_height));
+    } else if (widget_width - width > 0) {
+      gint left_bar_width = (widget_width - width) / 2;
+      gdouble right_bar_width = (widget_width - left_bar_width - width);
+
+      gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (0, 0, -left_bar_width, height));
+      gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (width, 0, right_bar_width, height));
+    }
+  }
+
+  GST_CLAPPER_PAINTABLE_IMPORTER_LOCK (self);
+
+  if (self->importer) {
+    switch (self->rotation) {
+      case GST_VIDEO_ORIENTATION_IDENTITY:
+      default:
+        snapshot_width = width;
+        snapshot_height = height;
+        break;
+      case GST_VIDEO_ORIENTATION_90R:
+        transform = gsk_transform_rotate (transform, 90);
+        transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (0, -width));
+        snapshot_width = height;
+        snapshot_height = width;
+        break;
+      case GST_VIDEO_ORIENTATION_180:
+        transform = gsk_transform_rotate (transform, 180);
+        transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (-width, -height));
+        snapshot_width = width;
+        snapshot_height = height;
+        break;
+      case GST_VIDEO_ORIENTATION_90L:
+        transform = gsk_transform_rotate (transform, 270);
+        transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (-height, 0));
+        snapshot_width = height;
+        snapshot_height = width;
+        break;
+      case GST_VIDEO_ORIENTATION_HORIZ:
+        transform = gsk_transform_rotate_3d (transform, 180, graphene_vec3_y_axis ());
+        transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (-width, 0));
+        snapshot_width = width;
+        snapshot_height = height;
+        break;
+      case GST_VIDEO_ORIENTATION_VERT:
+        transform = gsk_transform_rotate_3d (transform, 180, graphene_vec3_x_axis ());
+        transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (0, -height));
+        snapshot_width = width;
+        snapshot_height = height;
+        break;
+      case GST_VIDEO_ORIENTATION_UL_LR:
+        transform = gsk_transform_rotate (transform, 90);
+        transform = gsk_transform_rotate_3d (transform, 180, graphene_vec3_x_axis ());
+        snapshot_width = height;
+        snapshot_height = width;
+        break;
+      case GST_VIDEO_ORIENTATION_UR_LL:
+        transform = gsk_transform_rotate (transform, 90);
+        transform = gsk_transform_rotate_3d (transform, 180, graphene_vec3_y_axis ());
+        transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (-height, -width));
+        snapshot_width = height;
+        snapshot_height = width;
+        break;
+    }
+
+    if (transform) {
+      gtk_snapshot_transform (snapshot, transform);
+      gsk_transform_unref (transform);
+    }
+
+    gst_clapper_importer_snapshot (self->importer, snapshot, snapshot_width, snapshot_height);
+  } else {
+    GST_LOG_OBJECT (self, "No texture importer, drawing black");
+    gtk_snapshot_append_color (snapshot, &self->bg, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  }
+
+  GST_CLAPPER_PAINTABLE_IMPORTER_UNLOCK (self);
+}
+
+static void
+gst_clapper_paintable_snapshot (GdkPaintable *paintable,
+    GdkSnapshot *snapshot, gdouble width, gdouble height)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE_CAST (paintable);
+  GtkWidget *widget;
+  gint widget_width = 0, widget_height = 0;
+
+  if ((widget = g_weak_ref_get (&self->widget))) {
+    widget_width = gtk_widget_get_width (widget);
+    widget_height = gtk_widget_get_height (widget);
+
+    g_object_unref (widget);
+  }
+
+  gst_clapper_paintable_snapshot_internal (self, snapshot,
+      width, height, widget_width, widget_height);
+}
+
+static GdkPaintable *
+gst_clapper_paintable_get_current_image (GdkPaintable *paintable)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE_CAST (paintable);
+  GtkSnapshot *snapshot = gtk_snapshot_new ();
+
+  /* Snapshot without widget size in order to get
+   * paintable without black borders */
+  gst_clapper_paintable_snapshot_internal (self, snapshot,
+      self->display_width, self->display_height, 0, 0);
+
+  return gtk_snapshot_free_to_paintable (snapshot, NULL);
+}
+
+static gint
+gst_clapper_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE_CAST (paintable);
+
+  return self->display_width;
+}
+
+static gint
+gst_clapper_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE_CAST (paintable);
+
+  return self->display_height;
+}
+
+static gdouble
+gst_clapper_paintable_get_intrinsic_aspect_ratio (GdkPaintable *paintable)
+{
+  GstClapperPaintable *self = GST_CLAPPER_PAINTABLE_CAST (paintable);
+
+  return self->display_aspect_ratio;
+}
+
+static void
+gst_clapper_paintable_iface_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = gst_clapper_paintable_snapshot;
+  iface->get_current_image = gst_clapper_paintable_get_current_image;
+  iface->get_intrinsic_width = gst_clapper_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gst_clapper_paintable_get_intrinsic_height;
+  iface->get_intrinsic_aspect_ratio = gst_clapper_paintable_get_intrinsic_aspect_ratio;
+}

src/lib/gst/plugin/gstclapperpaintable.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <gst/gst.h>
+#include <gst/video/video.h>
+
+#include "gstclapperimporter.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_PAINTABLE (gst_clapper_paintable_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperPaintable, gst_clapper_paintable, GST, CLAPPER_PAINTABLE, GObject)
+
+#define GST_CLAPPER_PAINTABLE_CAST(obj)          ((GstClapperPaintable *)(obj))
+
+#define GST_CLAPPER_PAINTABLE_GET_LOCK(obj)      (&GST_CLAPPER_PAINTABLE_CAST(obj)->lock)
+#define GST_CLAPPER_PAINTABLE_LOCK(obj)          g_mutex_lock (GST_CLAPPER_PAINTABLE_GET_LOCK(obj))
+#define GST_CLAPPER_PAINTABLE_UNLOCK(obj)        g_mutex_unlock (GST_CLAPPER_PAINTABLE_GET_LOCK(obj))
+
+#define GST_CLAPPER_PAINTABLE_IMPORTER_GET_LOCK(obj)      (&GST_CLAPPER_PAINTABLE_CAST(obj)->importer_lock)
+#define GST_CLAPPER_PAINTABLE_IMPORTER_LOCK(obj)          g_mutex_lock (GST_CLAPPER_PAINTABLE_IMPORTER_GET_LOCK(obj))
+#define GST_CLAPPER_PAINTABLE_IMPORTER_UNLOCK(obj)        g_mutex_unlock (GST_CLAPPER_PAINTABLE_IMPORTER_GET_LOCK(obj))
+
+struct _GstClapperPaintable
+{
+  GObject parent;
+
+  GMutex lock;
+  GMutex importer_lock;
+
+  GstVideoInfo v_info;
+
+  GdkRGBA bg;
+
+  GWeakRef widget;
+  GstClapperImporter *importer;
+
+  /* Sink properties */
+  gint par_n, par_d;
+  GstVideoOrientationMethod rotation;
+
+  /* Resize */
+  gboolean pending_resize;
+  guint display_ratio_num;
+  guint display_ratio_den;
+
+  /* GdkPaintableInterface */
+  gint display_width;
+  gint display_height;
+  gdouble display_aspect_ratio;
+
+  /* Pending draw signal id */
+  guint draw_id;
+};
+
+GstClapperPaintable *      gst_clapper_paintable_new                    (void);
+void                       gst_clapper_paintable_queue_draw             (GstClapperPaintable *paintable);
+void                       gst_clapper_paintable_set_widget             (GstClapperPaintable *paintable, GtkWidget *widget);
+void                       gst_clapper_paintable_set_importer           (GstClapperPaintable *paintable, GstClapperImporter *importer);
+gboolean                   gst_clapper_paintable_set_video_info         (GstClapperPaintable *paintable, const GstVideoInfo *v_info);
+void                       gst_clapper_paintable_set_pixel_aspect_ratio (GstClapperPaintable *paintable, gint par_n, gint par_d);
+void                       gst_clapper_paintable_set_rotation           (GstClapperPaintable *paintable, GstVideoOrientationMethod rotation);
+GstVideoOrientationMethod  gst_clapper_paintable_get_rotation           (GstClapperPaintable *paintable);
+
+G_END_DECLS

src/lib/gst/plugin/gstclappersink.c

@@ -0,0 +1,957 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclappersink.h"
+#include "gstgtkutils.h"
+
+#define DEFAULT_FORCE_ASPECT_RATIO  TRUE
+#define DEFAULT_PAR_N               1
+#define DEFAULT_PAR_D               1
+#define DEFAULT_KEEP_LAST_FRAME     FALSE
+#define DEFAULT_ROTATION            GST_VIDEO_ORIENTATION_AUTO
+
+#define WINDOW_CSS_CLASS_NAME       "clappersinkwindow"
+
+enum
+{
+  PROP_0,
+  PROP_WIDGET,
+  PROP_FORCE_ASPECT_RATIO,
+  PROP_PIXEL_ASPECT_RATIO,
+  PROP_KEEP_LAST_FRAME,
+  PROP_ROTATE_METHOD,
+  PROP_LAST
+};
+
+#define GST_CAT_DEFAULT gst_clapper_sink_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+static void gst_clapper_sink_navigation_interface_init (
+    GstNavigationInterface *iface);
+
+#define parent_class gst_clapper_sink_parent_class
+G_DEFINE_TYPE_WITH_CODE (GstClapperSink, gst_clapper_sink, GST_TYPE_VIDEO_SINK,
+    G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
+        gst_clapper_sink_navigation_interface_init));
+GST_ELEMENT_REGISTER_DEFINE (clappersink, "clappersink", GST_RANK_NONE,
+    GST_TYPE_CLAPPER_SINK);
+
+static void
+window_clear_no_lock (GstClapperSink *self)
+{
+  if (!self->window)
+    return;
+
+  GST_TRACE_OBJECT (self, "Window clear");
+
+  if (self->window_destroy_id) {
+    g_signal_handler_disconnect (self->window, self->window_destroy_id);
+    self->window_destroy_id = 0;
+  }
+  self->window = NULL;
+}
+
+static void
+widget_clear_no_lock (GstClapperSink *self)
+{
+  if (!self->widget)
+    return;
+
+  GST_TRACE_OBJECT (self, "Widget clear");
+
+  if (self->widget_destroy_id) {
+    g_signal_handler_disconnect (self->widget, self->widget_destroy_id);
+    self->widget_destroy_id = 0;
+  }
+  g_clear_object (&self->widget);
+}
+
+static void
+widget_destroy_cb (GtkWidget *widget, GstClapperSink *self)
+{
+  GST_CLAPPER_SINK_LOCK (self);
+  widget_clear_no_lock (self);
+  GST_CLAPPER_SINK_UNLOCK (self);
+}
+
+static void
+window_destroy_cb (GtkWidget *window, GstClapperSink *self)
+{
+  GST_DEBUG_OBJECT (self, "Window destroy");
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  widget_clear_no_lock (self);
+  window_clear_no_lock (self);
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+}
+
+static void
+calculate_stream_coords (GstClapperSink *self, GtkWidget *widget,
+    gdouble x, gdouble y, gdouble *stream_x, gdouble *stream_y)
+{
+  GstVideoRectangle result;
+  gint scaled_width, scaled_height, scale_factor;
+  gint video_width, video_height;
+  gboolean force_aspect_ratio;
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  gst_gtk_get_width_height_for_rotation (GST_VIDEO_INFO_WIDTH (&self->v_info),
+      GST_VIDEO_INFO_HEIGHT (&self->v_info), &video_height, &video_width,
+      gst_clapper_paintable_get_rotation (self->paintable));
+  force_aspect_ratio = self->force_aspect_ratio;
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  scale_factor = gtk_widget_get_scale_factor (widget);
+  scaled_width = gtk_widget_get_width (widget) * scale_factor;
+  scaled_height = gtk_widget_get_height (widget) * scale_factor;
+
+  if (force_aspect_ratio) {
+    GstVideoRectangle src, dst;
+
+    src.x = 0;
+    src.y = 0;
+    src.w = gdk_paintable_get_intrinsic_width ((GdkPaintable *) self->paintable);
+    src.h = gdk_paintable_get_intrinsic_height ((GdkPaintable *) self->paintable);
+
+    dst.x = 0;
+    dst.y = 0;
+    dst.w = scaled_width;
+    dst.h = scaled_height;
+
+    gst_video_center_rect (&src, &dst, &result, TRUE);
+  } else {
+    result.x = 0;
+    result.y = 0;
+    result.w = scaled_width;
+    result.h = scaled_height;
+  }
+
+  /* Display coordinates to stream coordinates */
+  *stream_x = (result.w > 0)
+      ? (x - result.x) / result.w * video_width
+      : 0;
+  *stream_y = (result.h > 0)
+      ? (y - result.y) / result.h * video_height
+      : 0;
+
+  /* Clip to stream size */
+  *stream_x = CLAMP (*stream_x, 0, video_width);
+  *stream_y = CLAMP (*stream_y, 0, video_height);
+
+  GST_LOG ("Transform coords %fx%f => %fx%f", x, y, *stream_x, *stream_y);
+}
+
+static void
+gst_clapper_sink_widget_motion_event (GtkEventControllerMotion *motion,
+    gdouble x, gdouble y, GstClapperSink *self)
+{
+  GtkWidget *widget;
+  gdouble stream_x, stream_y;
+  gboolean is_inactive;
+
+  if (x == self->last_pos_x && y == self->last_pos_y)
+    return;
+
+  GST_OBJECT_LOCK (self);
+  is_inactive = (GST_STATE (self) < GST_STATE_PLAYING);
+  GST_OBJECT_UNLOCK (self);
+
+  if (is_inactive)
+    return;
+
+  self->last_pos_x = x;
+  self->last_pos_y = y;
+
+  widget = gtk_event_controller_get_widget ((GtkEventController *) motion);
+  calculate_stream_coords (self, widget, x, y, &stream_x, &stream_y);
+  GST_LOG ("Event \"mouse-move\", x: %f, y: %f", stream_x, stream_y);
+
+  gst_navigation_send_mouse_event ((GstNavigation *) self, "mouse-move",
+      0, stream_x, stream_y);
+}
+
+static void
+gst_clapper_sink_widget_button_event (GtkGestureClick *click,
+    gint n_press, gdouble x, gdouble y, GstClapperSink *self)
+{
+  GtkWidget *widget;
+  GdkEvent *event;
+  GdkEventType event_type;
+  const gchar *event_name;
+  gdouble stream_x, stream_y;
+  gboolean is_inactive;
+
+  GST_OBJECT_LOCK (self);
+  is_inactive = (GST_STATE (self) < GST_STATE_PLAYING);
+  GST_OBJECT_UNLOCK (self);
+
+  if (is_inactive)
+    return;
+
+  event = gtk_event_controller_get_current_event ((GtkEventController *) click);
+  event_type = gdk_event_get_event_type (event);
+
+  /* FIXME: Touchscreen handling should probably use new touch events from GStreamer 1.22 */
+  event_name = (event_type == GDK_BUTTON_PRESS || event_type == GDK_TOUCH_BEGIN)
+      ? "mouse-button-press"
+      : (event_type == GDK_BUTTON_RELEASE || event_type == GDK_TOUCH_END)
+      ? "mouse-button-release"
+      : NULL;
+
+  /* Can be NULL on touch */
+  if (!event_name)
+    return;
+
+  widget = gtk_event_controller_get_widget ((GtkEventController *) click);
+  calculate_stream_coords (self, widget, x, y, &stream_x, &stream_y);
+  GST_LOG ("Event \"%s\", x: %f, y: %f", event_name, stream_x, stream_y);
+
+  /* Gesture is set to handle only primary button, so we do not have to check */
+  gst_navigation_send_mouse_event ((GstNavigation *) self, event_name,
+      1, stream_x, stream_y);
+}
+
+/* Must call from main thread only with a lock */
+static GtkWidget *
+gst_clapper_sink_get_widget (GstClapperSink *self)
+{
+  if (G_UNLIKELY (!self->widget)) {
+    GtkEventController *controller;
+    GtkGesture *gesture;
+
+    /* Make sure GTK is initialized */
+    if (!gtk_init_check ()) {
+      GST_ERROR_OBJECT (self, "Could not ensure GTK initialization");
+      return NULL;
+    }
+
+    self->widget = gtk_picture_new ();
+
+    /* Otherwise widget in grid will appear as a 1x1px
+     * video which might be misleading for users */
+    gtk_widget_set_hexpand (self->widget, TRUE);
+    gtk_widget_set_vexpand (self->widget, TRUE);
+
+    gtk_widget_set_focusable (self->widget, TRUE);
+    gtk_widget_set_can_focus (self->widget, TRUE);
+
+    controller = gtk_event_controller_motion_new ();
+    g_signal_connect (controller, "motion",
+        G_CALLBACK (gst_clapper_sink_widget_motion_event), self);
+    gtk_widget_add_controller (self->widget, controller);
+
+    gesture = gtk_gesture_click_new ();
+    gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 1);
+    g_signal_connect (gesture, "pressed",
+        G_CALLBACK (gst_clapper_sink_widget_button_event), self);
+    g_signal_connect (gesture, "released",
+        G_CALLBACK (gst_clapper_sink_widget_button_event), self);
+    gtk_widget_add_controller (self->widget, GTK_EVENT_CONTROLLER (gesture));
+
+    /* TODO: Implement touch events once we depend on GStreamer 1.22 */
+
+    /* Take floating ref */
+    g_object_ref_sink (self->widget);
+
+    /* Set widget back pointer */
+    gst_clapper_paintable_set_widget (self->paintable, self->widget);
+
+    /* Set earlier remembered property */
+#if GTK_CHECK_VERSION(4,8,0)
+    if (self->force_aspect_ratio)
+      gtk_picture_set_content_fit (GTK_PICTURE (self->widget), GTK_CONTENT_FIT_CONTAIN);
+    else
+      gtk_picture_set_content_fit (GTK_PICTURE (self->widget), GTK_CONTENT_FIT_FILL);
+#else
+    gtk_picture_set_keep_aspect_ratio (GTK_PICTURE (self->widget),
+        self->force_aspect_ratio);
+#endif
+
+    gtk_picture_set_paintable (GTK_PICTURE (self->widget), GDK_PAINTABLE (self->paintable));
+
+    self->widget_destroy_id = g_signal_connect (self->widget,
+        "destroy", G_CALLBACK (widget_destroy_cb), self);
+  }
+
+  return self->widget;
+}
+
+static GtkWidget *
+gst_clapper_sink_obtain_widget (GstClapperSink *self)
+{
+  GtkWidget *widget;
+
+  GST_CLAPPER_SINK_LOCK (self);
+  widget = gst_clapper_sink_get_widget (self);
+  if (widget)
+    g_object_ref (widget);
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  return widget;
+}
+
+static void
+gst_clapper_sink_get_property (GObject *object, guint prop_id,
+    GValue *value, GParamSpec *pspec)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (object);
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  switch (prop_id) {
+    case PROP_WIDGET:
+      if (self->widget) {
+        g_value_set_object (value, self->widget);
+      } else {
+        GtkWidget *widget;
+
+        GST_CLAPPER_SINK_UNLOCK (self);
+        widget = gst_gtk_invoke_on_main ((GThreadFunc) gst_clapper_sink_obtain_widget, self);
+        GST_CLAPPER_SINK_LOCK (self);
+
+        g_value_set_object (value, widget);
+        g_object_unref (widget);
+      }
+      break;
+    case PROP_FORCE_ASPECT_RATIO:
+      g_value_set_boolean (value, self->force_aspect_ratio);
+      break;
+    case PROP_PIXEL_ASPECT_RATIO:
+      gst_value_set_fraction (value, self->par_n, self->par_d);
+      break;
+    case PROP_KEEP_LAST_FRAME:
+      g_value_set_boolean (value, self->keep_last_frame);
+      break;
+    case PROP_ROTATE_METHOD:
+      g_value_set_enum (value, self->rotation_mode);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+}
+
+static void
+gst_clapper_sink_set_property (GObject *object, guint prop_id,
+    const GValue *value, GParamSpec *pspec)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (object);
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  switch (prop_id) {
+    case PROP_FORCE_ASPECT_RATIO:
+      self->force_aspect_ratio = g_value_get_boolean (value);
+
+      if (self->widget) {
+#if GTK_CHECK_VERSION(4,8,0)
+        if (self->force_aspect_ratio)
+          gtk_picture_set_content_fit (GTK_PICTURE (self->widget), GTK_CONTENT_FIT_CONTAIN);
+        else
+          gtk_picture_set_content_fit (GTK_PICTURE (self->widget), GTK_CONTENT_FIT_FILL);
+#else
+        gtk_picture_set_keep_aspect_ratio (GTK_PICTURE (self->widget),
+            self->force_aspect_ratio);
+#endif
+      }
+      break;
+    case PROP_PIXEL_ASPECT_RATIO:
+      self->par_n = gst_value_get_fraction_numerator (value);
+      self->par_d = gst_value_get_fraction_denominator (value);
+
+      gst_clapper_paintable_set_pixel_aspect_ratio (self->paintable,
+          self->par_n, self->par_d);
+      break;
+    case PROP_KEEP_LAST_FRAME:
+      self->keep_last_frame = g_value_get_boolean (value);
+      break;
+    case PROP_ROTATE_METHOD:
+      self->rotation_mode = g_value_get_enum (value);
+
+      gst_clapper_paintable_set_rotation (self->paintable,
+          (self->rotation_mode == GST_VIDEO_ORIENTATION_AUTO) ?
+              self->stream_orientation : self->rotation_mode);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+}
+
+static void
+gst_clapper_sink_navigation_send_event (GstNavigation *navigation,
+    GstStructure *structure)
+{
+  GstClapperSink *sink = GST_CLAPPER_SINK_CAST (navigation);
+  GstEvent *event;
+
+  GST_TRACE_OBJECT (sink, "Navigation event: %" GST_PTR_FORMAT, structure);
+  event = gst_event_new_navigation (structure);
+
+  if (G_LIKELY (event)) {
+    GstPad *pad;
+
+    pad = gst_pad_get_peer (GST_VIDEO_SINK_PAD (sink));
+
+    if (G_LIKELY (pad)) {
+      if (!gst_pad_send_event (pad, gst_event_ref (event))) {
+        /* If upstream didn't handle the event we'll post a message with it
+         * for the application in case it wants to do something with it */
+        gst_element_post_message (GST_ELEMENT_CAST (sink),
+            gst_navigation_message_new_event (GST_OBJECT_CAST (sink), event));
+      }
+      gst_object_unref (pad);
+    }
+    gst_event_unref (event);
+  }
+}
+
+static gboolean
+gst_clapper_sink_propose_allocation (GstBaseSink *bsink, GstQuery *query)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+  GstClapperImporter *importer = NULL;
+  GstCaps *caps;
+  GstVideoInfo info;
+  guint size, min_buffers;
+  gboolean need_pool;
+
+  gst_query_parse_allocation (query, &caps, &need_pool);
+
+  if (!caps) {
+    GST_DEBUG_OBJECT (self, "No caps specified");
+    return FALSE;
+  }
+
+  if (!gst_video_info_from_caps (&info, caps)) {
+    GST_DEBUG_OBJECT (self, "Invalid caps specified");
+    return FALSE;
+  }
+
+  GST_CLAPPER_SINK_LOCK (self);
+  if (self->importer)
+    importer = gst_object_ref (self->importer);
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  if (!importer) {
+    GST_DEBUG_OBJECT (self, "No importer to propose allocation");
+    return FALSE;
+  }
+
+  /* Normal size of a frame */
+  size = GST_VIDEO_INFO_SIZE (&info);
+
+  /* We keep around current buffer and a pending one */
+  min_buffers = 3;
+
+  if (need_pool) {
+    GstBufferPool *pool;
+    GstStructure *config = NULL;
+
+    GST_DEBUG_OBJECT (self, "Need to create buffer pool");
+    pool = gst_clapper_importer_create_pool (importer, &config);
+
+    if (pool) {
+      /* If we did not get config, use default one */
+      if (!config)
+        config = gst_buffer_pool_get_config (pool);
+
+      gst_buffer_pool_config_set_params (config, caps, size, min_buffers, 0);
+
+      if (!gst_buffer_pool_set_config (pool, config)) {
+        gst_object_unref (pool);
+        gst_object_unref (importer);
+
+        GST_ERROR_OBJECT (self, "Failed to set config");
+        return FALSE;
+      }
+
+      gst_query_add_allocation_pool (query, pool, size, min_buffers, 0);
+      gst_object_unref (pool);
+    } else if (config) {
+      GST_WARNING_OBJECT (self, "Got config without a pool to apply it");
+      gst_structure_free (config);
+    }
+  }
+
+  gst_clapper_importer_add_allocation_metas (importer, query);
+  gst_object_unref (importer);
+
+  return TRUE;
+}
+
+static gboolean
+gst_clapper_sink_query (GstBaseSink *bsink, GstQuery *query)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+  gboolean res = FALSE;
+
+  if (GST_QUERY_TYPE (query) == GST_QUERY_CONTEXT) {
+    GST_CLAPPER_SINK_LOCK (self);
+    res = gst_clapper_importer_loader_handle_context_query (self->loader, bsink, query);
+    GST_CLAPPER_SINK_UNLOCK (self);
+  }
+
+  if (res)
+    return TRUE;
+
+  return GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
+}
+
+static gboolean
+gst_clapper_sink_start_on_main (GstClapperSink *self)
+{
+  GtkWidget *widget;
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  /* Make sure widget is created */
+  if (!(widget = gst_clapper_sink_get_widget (self))) {
+    GST_CLAPPER_SINK_UNLOCK (self);
+
+    return FALSE;
+  }
+
+  /* When no toplevel window, make our own */
+  if (G_UNLIKELY (!gtk_widget_get_root (widget) && !self->window)) {
+    GtkWidget *toplevel, *parent;
+    GtkCssProvider *provider;
+    gchar *win_title;
+
+    if ((parent = gtk_widget_get_parent (widget))) {
+      GtkWidget *temp_parent;
+
+      while ((temp_parent = gtk_widget_get_parent (parent)))
+        parent = temp_parent;
+    }
+    toplevel = (parent) ? parent : widget;
+
+    self->window = (GtkWindow *) gtk_window_new ();
+    gtk_widget_add_css_class (GTK_WIDGET (self->window), WINDOW_CSS_CLASS_NAME);
+
+    provider = gtk_css_provider_new ();
+    gtk_css_provider_load_from_data (provider,
+        "." WINDOW_CSS_CLASS_NAME " { background: none; }", -1);
+    gtk_style_context_add_provider_for_display (
+        gdk_display_get_default (), GTK_STYLE_PROVIDER (provider),
+        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+    g_object_unref (provider);
+
+    win_title = g_strdup_printf ("Clapper Sink - GTK %u.%u.%u Window",
+        gtk_get_major_version (),
+        gtk_get_minor_version (),
+        gtk_get_micro_version ());
+
+    /* Set some common default size, adding stock headerbar height
+     * to it in order to display 4:3 aspect video widget */
+    gtk_window_set_default_size (self->window, 640, 480 + 37);
+    gtk_window_set_title (self->window, win_title);
+    gtk_window_set_child (self->window, toplevel);
+
+    g_free (win_title);
+
+    self->window_destroy_id = g_signal_connect (self->window,
+        "destroy", G_CALLBACK (window_destroy_cb), self);
+
+    GST_INFO_OBJECT (self, "Presenting window");
+    gtk_window_present (self->window);
+  }
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  return TRUE;
+}
+
+static gboolean
+gst_clapper_sink_start (GstBaseSink *bsink)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+
+  GST_INFO_OBJECT (self, "Start");
+
+  if (G_UNLIKELY (!(! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
+      gst_clapper_sink_start_on_main, self)))) {
+    GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
+        ("GtkWidget could not be created"), (NULL));
+
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+static gboolean
+gst_clapper_sink_stop_on_main (GstClapperSink *self)
+{
+  GtkWindow *window = NULL;
+
+  GST_CLAPPER_SINK_LOCK (self);
+  if (self->window)
+    window = g_object_ref (self->window);
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  if (window) {
+    gtk_window_destroy (window);
+    g_object_unref (window);
+  }
+
+  return TRUE;
+}
+
+static gboolean
+gst_clapper_sink_stop (GstBaseSink *bsink)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+  gboolean has_window;
+
+  GST_INFO_OBJECT (self, "Stop");
+
+  GST_CLAPPER_SINK_LOCK (self);
+  has_window = (self->window != NULL);
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  if (G_UNLIKELY (has_window)) {
+    return (! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
+        gst_clapper_sink_stop_on_main, self));
+  }
+
+  return TRUE;
+}
+
+static gboolean
+gst_clapper_sink_event (GstBaseSink *bsink, GstEvent *event)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+  GstTagList *taglist;
+  GstVideoOrientationMethod orientation;
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_TAG:
+      gst_event_parse_tag (event, &taglist);
+
+      if (gst_video_orientation_from_tag (taglist, &orientation)) {
+        GST_CLAPPER_SINK_LOCK (self);
+        self->stream_orientation = orientation;
+        if (self->rotation_mode == GST_VIDEO_ORIENTATION_AUTO)
+          gst_clapper_paintable_set_rotation (self->paintable, orientation);
+        GST_CLAPPER_SINK_UNLOCK (self);
+      }
+      break;
+    default:
+      break;
+  }
+
+  return GST_BASE_SINK_CLASS (parent_class)->event (bsink, event);
+}
+
+static GstStateChangeReturn
+gst_clapper_sink_change_state (GstElement *element, GstStateChange transition)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (element);
+
+  GST_DEBUG_OBJECT (self, "Changing state: %s => %s",
+      gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
+      gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      /* Reset stream_orientation */
+      GST_CLAPPER_SINK_LOCK (self);
+      self->stream_orientation = GST_VIDEO_ORIENTATION_IDENTITY;
+      if (self->rotation_mode == GST_VIDEO_ORIENTATION_AUTO)
+        gst_clapper_paintable_set_rotation (self->paintable, self->stream_orientation);
+      GST_CLAPPER_SINK_UNLOCK (self);
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      GST_CLAPPER_SINK_LOCK (self);
+      if (!self->keep_last_frame && self->importer) {
+        gst_clapper_importer_set_buffer (self->importer, NULL);
+        gst_clapper_paintable_queue_draw (self->paintable);
+      }
+      GST_CLAPPER_SINK_UNLOCK (self);
+      break;
+    default:
+      break;
+  }
+
+  return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+}
+
+static void
+gst_clapper_sink_get_times (GstBaseSink *bsink, GstBuffer *buffer,
+    GstClockTime *start, GstClockTime *end)
+{
+  if (!GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
+    return;
+
+  *start = GST_BUFFER_TIMESTAMP (buffer);
+
+  if (GST_BUFFER_DURATION_IS_VALID (buffer)) {
+    *end = *start + GST_BUFFER_DURATION (buffer);
+  } else {
+    GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+    gint fps_n, fps_d;
+
+    GST_CLAPPER_SINK_LOCK (self);
+    fps_n = GST_VIDEO_INFO_FPS_N (&self->v_info);
+    fps_d = GST_VIDEO_INFO_FPS_D (&self->v_info);
+    GST_CLAPPER_SINK_UNLOCK (self);
+
+    if (fps_n > 0)
+      *end = *start + gst_util_uint64_scale_int (GST_SECOND, fps_d, fps_n);
+  }
+}
+
+static GstCaps *
+gst_clapper_sink_get_caps (GstBaseSink *bsink, GstCaps *filter)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+  GstCaps *result, *tmp;
+
+  tmp = gst_clapper_importer_loader_make_actual_caps (self->loader);
+
+  if (filter) {
+    GST_DEBUG ("Intersecting with filter caps: %" GST_PTR_FORMAT, filter);
+    result = gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
+    gst_caps_unref (tmp);
+  } else {
+    result = tmp;
+  }
+  GST_DEBUG ("Returning caps: %" GST_PTR_FORMAT, result);
+
+  return result;
+}
+
+static gboolean
+gst_clapper_sink_set_caps (GstBaseSink *bsink, GstCaps *caps)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+
+  GST_INFO_OBJECT (self, "Set caps: %" GST_PTR_FORMAT, caps);
+  GST_CLAPPER_SINK_LOCK (self);
+
+  if (G_UNLIKELY (!self->widget)) {
+    GST_CLAPPER_SINK_UNLOCK (self);
+    GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
+        ("Output widget was destroyed"), (NULL));
+
+    return FALSE;
+  }
+
+  if (!gst_clapper_importer_loader_find_importer_for_caps (self->loader, caps, &self->importer)) {
+    GST_CLAPPER_SINK_UNLOCK (self);
+    GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
+        ("No importer for given caps found"), (NULL));
+
+    return FALSE;
+  }
+  gst_clapper_paintable_set_importer (self->paintable, self->importer);
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  return GST_BASE_SINK_CLASS (parent_class)->set_caps (bsink, caps);
+}
+
+static gboolean
+gst_clapper_sink_set_info (GstVideoSink *vsink, GstCaps *caps, const GstVideoInfo *info)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (vsink);
+  gboolean res;
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  self->v_info = *info;
+  GST_DEBUG_OBJECT (self, "Video info changed");
+
+  res = gst_clapper_paintable_set_video_info (self->paintable, info);
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  return res;
+}
+
+static GstFlowReturn
+gst_clapper_sink_show_frame (GstVideoSink *vsink, GstBuffer *buffer)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (vsink);
+
+  GST_TRACE ("Got %" GST_PTR_FORMAT, buffer);
+  GST_CLAPPER_SINK_LOCK (self);
+
+  if (G_UNLIKELY (!self->widget)) {
+    GST_CLAPPER_SINK_UNLOCK (self);
+    GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
+        ("Output widget was destroyed"), (NULL));
+
+    return GST_FLOW_ERROR;
+  }
+
+  gst_clapper_importer_set_buffer (self->importer, buffer);
+  gst_clapper_paintable_queue_draw (self->paintable);
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  return GST_FLOW_OK;
+}
+
+static void
+gst_clapper_sink_init (GstClapperSink *self)
+{
+  GObjectClass *gobject_class;
+
+  gobject_class = (GObjectClass *) GST_CLAPPER_SINK_GET_CLASS (self);
+
+  /* HACK: install here instead of class init to avoid GStreamer
+   * plugin scanner GObject type conflicts with older GTK versions */
+  if (!g_object_class_find_property (gobject_class, "widget")) {
+    g_object_class_install_property (gobject_class, PROP_WIDGET,
+        g_param_spec_object ("widget", "GTK Widget",
+            "The GtkWidget to place in the widget hierarchy",
+            GTK_TYPE_WIDGET, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+  }
+
+  self->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
+  self->par_n = DEFAULT_PAR_N;
+  self->par_d = DEFAULT_PAR_D;
+  self->keep_last_frame = DEFAULT_KEEP_LAST_FRAME;
+  self->rotation_mode = DEFAULT_ROTATION;
+
+  g_mutex_init (&self->lock);
+  gst_video_info_init (&self->v_info);
+
+  self->paintable = gst_clapper_paintable_new ();
+  self->loader = gst_clapper_importer_loader_new ();
+}
+
+static void
+gst_clapper_sink_dispose (GObject *object)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (object);
+
+  GST_CLAPPER_SINK_LOCK (self);
+
+  window_clear_no_lock (self);
+  widget_clear_no_lock (self);
+
+  g_clear_object (&self->paintable);
+  gst_clear_object (&self->importer);
+
+  GST_CLAPPER_SINK_UNLOCK (self);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
+}
+
+static void
+gst_clapper_sink_finalize (GObject *object)
+{
+  GstClapperSink *self = GST_CLAPPER_SINK_CAST (object);
+
+  GST_TRACE ("Finalize");
+
+  gst_clear_object (&self->loader);
+  g_mutex_clear (&self->lock);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_sink_class_init (GstClapperSinkClass *klass)
+{
+  GstPadTemplate *sink_pad_templ;
+
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+  GstElementClass *gstelement_class = (GstElementClass *) klass;
+  GstBaseSinkClass *gstbasesink_class = (GstBaseSinkClass *) klass;
+  GstVideoSinkClass *gstvideosink_class = (GstVideoSinkClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clappersink", 0,
+      "Clapper Sink");
+
+  gobject_class->get_property = gst_clapper_sink_get_property;
+  gobject_class->set_property = gst_clapper_sink_set_property;
+  gobject_class->dispose = gst_clapper_sink_dispose;
+  gobject_class->finalize = gst_clapper_sink_finalize;
+
+  g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,
+      g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio",
+          "When enabled, scaling will respect original aspect ratio",
+          DEFAULT_FORCE_ASPECT_RATIO,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (gobject_class, PROP_PIXEL_ASPECT_RATIO,
+      gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",
+          "The pixel aspect ratio of the device",
+          DEFAULT_PAR_N, DEFAULT_PAR_D,
+          G_MAXINT, 1, 1, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (gobject_class, PROP_KEEP_LAST_FRAME,
+      g_param_spec_boolean ("keep-last-frame", "Keep last frame",
+          "Keep showing last video frame after playback instead of black screen",
+          DEFAULT_KEEP_LAST_FRAME,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (gobject_class, PROP_ROTATE_METHOD,
+      g_param_spec_enum ("rotate-method", "Rotate Method",
+          "Rotate method to use",
+          GST_TYPE_VIDEO_ORIENTATION_METHOD, DEFAULT_ROTATION,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  gstelement_class->change_state = gst_clapper_sink_change_state;
+
+  gstbasesink_class->get_caps = gst_clapper_sink_get_caps;
+  gstbasesink_class->set_caps = gst_clapper_sink_set_caps;
+  gstbasesink_class->get_times = gst_clapper_sink_get_times;
+  gstbasesink_class->propose_allocation = gst_clapper_sink_propose_allocation;
+  gstbasesink_class->query = gst_clapper_sink_query;
+  gstbasesink_class->start = gst_clapper_sink_start;
+  gstbasesink_class->stop = gst_clapper_sink_stop;
+  gstbasesink_class->event = gst_clapper_sink_event;
+
+  gstvideosink_class->set_info = gst_clapper_sink_set_info;
+  gstvideosink_class->show_frame = gst_clapper_sink_show_frame;
+
+  gst_element_class_set_static_metadata (gstelement_class,
+      "Clapper video sink",
+      "Sink/Video", "A GTK4 video sink used by Clapper media player",
+      "Rafał Dzięgiel <rafostar.github@gmail.com>");
+
+  sink_pad_templ = gst_clapper_importer_loader_make_sink_pad_template ();
+  gst_element_class_add_pad_template (gstelement_class, sink_pad_templ);
+}
+
+/*
+ * GstNavigationInterface
+ */
+static void
+gst_clapper_sink_navigation_interface_init (GstNavigationInterface *iface)
+{
+  /* TODO: Port to "send_event_simple" once we depend on GStreamer 1.22 */
+  iface->send_event = gst_clapper_sink_navigation_send_event;
+}

src/lib/gst/plugin/gstclappersink.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <gst/gst.h>
+#include <gst/video/gstvideosink.h>
+#include <gst/video/video.h>
+
+#include "gstclapperpaintable.h"
+#include "gstclapperimporterloader.h"
+#include "gstclapperimporter.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_SINK (gst_clapper_sink_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperSink, gst_clapper_sink, GST, CLAPPER_SINK, GstVideoSink)
+
+#define GST_CLAPPER_SINK_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_CLAPPER_SINK, GstClapperSinkClass))
+#define GST_CLAPPER_SINK_CAST(obj)          ((GstClapperSink *)(obj))
+
+#define GST_CLAPPER_SINK_GET_LOCK(obj)      (&GST_CLAPPER_SINK_CAST(obj)->lock)
+#define GST_CLAPPER_SINK_LOCK(obj)          g_mutex_lock (GST_CLAPPER_SINK_GET_LOCK(obj))
+#define GST_CLAPPER_SINK_UNLOCK(obj)        g_mutex_unlock (GST_CLAPPER_SINK_GET_LOCK(obj))
+
+struct _GstClapperSink
+{
+  GstVideoSink parent;
+
+  GMutex lock;
+
+  GstClapperPaintable *paintable;
+  GstClapperImporterLoader *loader;
+  GstClapperImporter *importer;
+  GstVideoInfo v_info;
+  GstVideoOrientationMethod stream_orientation;
+
+  GtkWidget *widget;
+  GtkWindow *window;
+
+  /* Properties */
+  gboolean force_aspect_ratio;
+  gint par_n, par_d;
+  gboolean keep_last_frame;
+  GstVideoOrientationMethod rotation_mode;
+
+  /* Position coords */
+  gdouble last_pos_x;
+  gdouble last_pos_y;
+
+  gulong widget_destroy_id;
+  gulong window_destroy_id;
+};
+
+GST_ELEMENT_REGISTER_DECLARE (clappersink);
+
+G_END_DECLS

src/lib/gst/plugin/gstgdkformats.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <glib.h>
+
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+#define GST_GDK_MEMORY_ENDIAN_FORMATS      "RGBA64_LE"
+#define GST_GDK_GL_TEXTURE_ENDIAN_FORMATS  "RGBA64_LE"
+#elif G_BYTE_ORDER == G_BIG_ENDIAN
+#define GST_GDK_MEMORY_ENDIAN_FORMATS      "RGBA64_BE"
+#define GST_GDK_GL_TEXTURE_ENDIAN_FORMATS  "RGBA64_BE"
+#endif
+
+#define GST_GDK_MEMORY_FORMATS                       \
+    GST_GDK_MEMORY_ENDIAN_FORMATS ", "               \
+    "ABGR, BGRA, ARGB, RGBA, BGRx, RGBx, BGR, RGB"
+
+/* Formats that `GdkGLTexture` supports */
+#define GST_GDK_GL_TEXTURE_FORMATS                   \
+    GST_GDK_GL_TEXTURE_ENDIAN_FORMATS ", "           \
+    "RGBA, RGBx, RGB"

src/lib/gst/plugin/gstgtkutils.c

@@ -0,0 +1,162 @@
+/*
+ * GStreamer
+ * Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
+ * Copyright (C) 2015 Thibault Saunier <tsaunier@gnome.org>
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "gstgtkutils.h"
+
+#define _IS_FRAME_PREMULTIPLIED(f) (GST_VIDEO_INFO_FLAG_IS_SET (&(f)->info, GST_VIDEO_FLAG_PREMULTIPLIED_ALPHA))
+
+struct invoke_context
+{
+  GThreadFunc func;
+  gpointer data;
+  GMutex lock;
+  GCond cond;
+  gboolean fired;
+
+  gpointer res;
+};
+
+static gboolean
+gst_gtk_invoke_func (struct invoke_context *info)
+{
+  g_mutex_lock (&info->lock);
+  info->res = info->func (info->data);
+  info->fired = TRUE;
+  g_cond_signal (&info->cond);
+  g_mutex_unlock (&info->lock);
+
+  return G_SOURCE_REMOVE;
+}
+
+gpointer
+gst_gtk_invoke_on_main (GThreadFunc func, gpointer data)
+{
+  GMainContext *main_context = g_main_context_default ();
+  struct invoke_context info;
+
+  g_mutex_init (&info.lock);
+  g_cond_init (&info.cond);
+  info.fired = FALSE;
+  info.func = func;
+  info.data = data;
+
+  g_main_context_invoke (main_context, (GSourceFunc) gst_gtk_invoke_func,
+      &info);
+
+  g_mutex_lock (&info.lock);
+  while (!info.fired)
+    g_cond_wait (&info.cond, &info.lock);
+  g_mutex_unlock (&info.lock);
+
+  g_mutex_clear (&info.lock);
+  g_cond_clear (&info.cond);
+
+  return info.res;
+}
+
+static GdkMemoryFormat
+gst_gdk_memory_format_from_frame (GstVideoFrame *frame)
+{
+  switch (GST_VIDEO_FRAME_FORMAT (frame)) {
+    case GST_VIDEO_FORMAT_RGBA64_LE:
+    case GST_VIDEO_FORMAT_RGBA64_BE:
+      return (_IS_FRAME_PREMULTIPLIED (frame))
+          ? GDK_MEMORY_R16G16B16A16_PREMULTIPLIED
+          : GDK_MEMORY_R16G16B16A16;
+    case GST_VIDEO_FORMAT_RGBA:
+      return (_IS_FRAME_PREMULTIPLIED (frame))
+          ? GDK_MEMORY_R8G8B8A8_PREMULTIPLIED
+          : GDK_MEMORY_R8G8B8A8;
+    case GST_VIDEO_FORMAT_BGRA:
+      return (_IS_FRAME_PREMULTIPLIED (frame))
+          ? GDK_MEMORY_B8G8R8A8_PREMULTIPLIED
+          : GDK_MEMORY_B8G8R8A8;
+    case GST_VIDEO_FORMAT_ARGB:
+      return (_IS_FRAME_PREMULTIPLIED (frame))
+          ? GDK_MEMORY_A8R8G8B8_PREMULTIPLIED
+          : GDK_MEMORY_A8R8G8B8;
+    case GST_VIDEO_FORMAT_ABGR:
+      /* GTK is missing premultiplied ABGR support */
+      return GDK_MEMORY_A8B8G8R8;
+    case GST_VIDEO_FORMAT_RGBx:
+      return GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
+    case GST_VIDEO_FORMAT_BGRx:
+      return GDK_MEMORY_B8G8R8A8_PREMULTIPLIED;
+    case GST_VIDEO_FORMAT_RGB:
+      return GDK_MEMORY_R8G8B8;
+    case GST_VIDEO_FORMAT_BGR:
+      return GDK_MEMORY_B8G8R8;
+    default:
+      break;
+  }
+
+  /* This should never happen as long as above switch statement
+   * is updated when new formats are added to caps */
+  g_assert_not_reached ();
+
+  /* Fallback format */
+  return GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
+}
+
+GdkTexture *
+gst_video_frame_into_gdk_texture (GstVideoFrame *frame)
+{
+  GdkTexture *texture;
+  GBytes *bytes;
+
+  bytes = g_bytes_new_with_free_func (
+      GST_VIDEO_FRAME_PLANE_DATA (frame, 0),
+      GST_VIDEO_FRAME_HEIGHT (frame) * GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0),
+      (GDestroyNotify) gst_buffer_unref,
+      gst_buffer_ref (frame->buffer));
+
+  texture = gdk_memory_texture_new (
+      GST_VIDEO_FRAME_WIDTH (frame),
+      GST_VIDEO_FRAME_HEIGHT (frame),
+      gst_gdk_memory_format_from_frame (frame),
+      bytes,
+      GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0));
+
+  g_bytes_unref (bytes);
+
+  return texture;
+}
+
+void
+gst_gtk_get_width_height_for_rotation (gint width, gint height,
+    gint *out_width, gint *out_height,
+    GstVideoOrientationMethod rotation)
+{
+  switch (rotation) {
+    case GST_VIDEO_ORIENTATION_90R:
+    case GST_VIDEO_ORIENTATION_90L:
+    case GST_VIDEO_ORIENTATION_UL_LR:
+    case GST_VIDEO_ORIENTATION_UR_LL:
+      *out_width = height;
+      *out_height = width;
+      break;
+    default:
+      *out_width = width;
+      *out_height = height;
+      break;
+  }
+}

src/lib/gst/plugin/gstgtkutils.h

@@ -0,0 +1,39 @@
+/*
+ * GStreamer
+ * Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
+ * Copyright (C) 2015 Thibault Saunier <tsaunier@gnome.org>
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <gst/video/video.h>
+
+G_BEGIN_DECLS
+
+gpointer        gst_gtk_invoke_on_main                (GThreadFunc func, gpointer data);
+
+GdkTexture *    gst_video_frame_into_gdk_texture      (GstVideoFrame *frame);
+
+void            gst_gtk_get_width_height_for_rotation (gint width, gint height,
+                                                       gint *out_width, gint *out_height,
+                                                       GstVideoOrientationMethod rotation);
+
+G_END_DECLS

src/lib/gst/plugin/gstplugin.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gmodule.h>
+
+#include "gstclappersink.h"
+
+static gboolean
+plugin_init (GstPlugin *plugin)
+{
+  if (!g_module_supported ())
+    return FALSE;
+
+  gst_plugin_add_dependency_simple (plugin,
+      NULL, CLAPPER_SINK_IMPORTER_PATH, NULL,
+      GST_PLUGIN_DEPENDENCY_FLAG_NONE);
+
+  return GST_ELEMENT_REGISTER (clappersink, plugin);
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR,
+    clapper, "Clapper elements", plugin_init, VERSION, "LGPL",
+    GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)

src/lib/gst/plugin/handlers/gl/gstclapperglcontexthandler.c

@@ -0,0 +1,583 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclapperglcontexthandler.h"
+#include "gst/plugin/gstgdkformats.h"
+#include "gst/plugin/gstgtkutils.h"
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WAYLAND
+#include <gdk/wayland/gdkwayland.h>
+#include <gst/gl/wayland/gstgldisplay_wayland.h>
+#endif
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11
+#include <gdk/x11/gdkx.h>
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_GLX
+#include <gst/gl/x11/gstgldisplay_x11.h>
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_EGL || GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_EGL
+#include <gst/gl/egl/gstgldisplay_egl.h>
+#endif
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32
+#include <gdk/win32/gdkwin32.h>
+#endif
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_MACOS
+#include <gdk/macos/gdkmacos.h>
+#endif
+
+#define GST_CAT_DEFAULT gst_clapper_gl_context_handler_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define parent_class gst_clapper_gl_context_handler_parent_class
+G_DEFINE_TYPE (GstClapperGLContextHandler, gst_clapper_gl_context_handler, GST_TYPE_OBJECT);
+
+static GstGLContext *
+_wrap_current_gl (GstGLDisplay *display, GdkGLAPI gdk_gl_api, GstGLPlatform platform)
+{
+  GstGLAPI gst_gl_api = GST_GL_API_NONE;
+
+  switch (gdk_gl_api) {
+    case GDK_GL_API_GL:
+      gst_gl_api = GST_GL_API_OPENGL | GST_GL_API_OPENGL3;
+      break;
+    case GDK_GL_API_GLES:
+      gst_gl_api = GST_GL_API_GLES2;
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+
+  if (gst_gl_api != GST_GL_API_NONE) {
+    guintptr gl_handle;
+
+    gst_gl_display_filter_gl_api (display, gst_gl_api);
+
+    if ((gl_handle = gst_gl_context_get_current_gl_context (platform)))
+      return gst_gl_context_new_wrapped (display, gl_handle, platform, gst_gl_api);
+  }
+
+  return NULL;
+}
+
+static gboolean
+_realize_gdk_context_with_api (GdkGLContext *gdk_context, GdkGLAPI api, gint maj, gint min)
+{
+  GError *error = NULL;
+  gboolean success;
+
+  gdk_gl_context_set_allowed_apis (gdk_context, api);
+  gdk_gl_context_set_required_version (gdk_context, maj, min);
+
+  GST_DEBUG ("Trying to realize %s context, min ver: %i.%i",
+      (api & GDK_GL_API_GL) ? "GL" : "GLES", maj, min);
+
+  if (!(success = gdk_gl_context_realize (gdk_context, &error))) {
+    GST_DEBUG ("Could not realize Gdk context with %s: %s",
+        (api & GDK_GL_API_GL) ? "GL" : "GLES", error->message);
+    g_clear_error (&error);
+  }
+
+  return success;
+}
+
+static gboolean
+_gl_context_handler_context_realize (GstClapperGLContextHandler *self, GdkGLContext *gdk_context)
+{
+  GdkGLAPI preferred_api = GDK_GL_API_GL;
+  GdkDisplay *gdk_display;
+  const gchar *gl_env;
+  gboolean success;
+
+  GST_DEBUG_OBJECT (self, "Realizing GdkGLContext with default implementation");
+
+  /* Use single "GST_GL_API" env to also influence Gdk GL selection */
+  if ((gl_env = g_getenv ("GST_GL_API"))) {
+    preferred_api = (g_str_has_prefix (gl_env, "gles"))
+        ? GDK_GL_API_GLES
+        : g_str_has_prefix (gl_env, "opengl")
+        ? GDK_GL_API_GL
+        : GDK_GL_API_GL | GDK_GL_API_GLES;
+
+    /* With requested by user API, we either use it or give up */
+    return _realize_gdk_context_with_api (gdk_context, preferred_api, 0, 0);
+  }
+
+  gdk_display = gdk_gl_context_get_display (gdk_context);
+  GST_DEBUG_OBJECT (self, "Auto selecting GL API for display: %s",
+      gdk_display_get_name (gdk_display));
+
+  /* Apple decoder uses rectangle texture-target, which GLES does not support.
+   * For Linux we prefer EGL + GLES in order to get direct HW colorspace conversion.
+   * Windows will try EGL + GLES setup first and auto fallback to WGL. */
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WAYLAND
+  if (GDK_IS_WAYLAND_DISPLAY (gdk_display))
+    preferred_api = GDK_GL_API_GLES;
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_EGL
+  if (GDK_IS_X11_DISPLAY (gdk_display) && gdk_x11_display_get_egl_display (gdk_display))
+    preferred_api = GDK_GL_API_GLES;
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_EGL
+  if (GDK_IS_WIN32_DISPLAY (gdk_display) && gdk_win32_display_get_egl_display (gdk_display))
+    preferred_api = GDK_GL_API_GLES;
+#endif
+
+  /* FIXME: Remove once GStreamer can handle DRM modifiers. This tries to avoid
+   * "scrambled" image on Linux with Intel GPUs that are mostly used together with
+   * x86 CPUs at the expense of using slightly slower non-direct DMABuf import.
+   * See: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/issues/1236 */
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WAYLAND || GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_EGL
+#if !defined(HAVE_GST_PATCHES) && (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64))
+  preferred_api = GDK_GL_API_GL;
+#endif
+#endif
+
+  /* Continue with GLES only if it should have "GL_EXT_texture_norm16"
+   * extension, as we need it to handle P010_10LE, etc. */
+  if ((preferred_api == GDK_GL_API_GLES)
+      && _realize_gdk_context_with_api (gdk_context, GDK_GL_API_GLES, 3, 1))
+    return TRUE;
+
+  /* If not using GLES 3.1, try with core GL 3.2 that GTK4 defaults to */
+  if (_realize_gdk_context_with_api (gdk_context, GDK_GL_API_GL, 3, 2))
+    return TRUE;
+
+  /* Try with what we normally prefer first, otherwise use fallback */
+  if (!(success = _realize_gdk_context_with_api (gdk_context, preferred_api, 0, 0))) {
+    GdkGLAPI fallback_api;
+
+    fallback_api = (GDK_GL_API_GL | GDK_GL_API_GLES);
+    fallback_api &= ~preferred_api;
+
+    success = _realize_gdk_context_with_api (gdk_context, fallback_api, 0, 0);
+  }
+
+  return success;
+}
+
+static gboolean
+_retrieve_gl_context_on_main (GstClapperGLContextHandler *self)
+{
+  GdkDisplay *gdk_display;
+  GdkGLContext *gdk_context;
+  GError *error = NULL;
+  GdkGLAPI gdk_gl_api;
+  GstGLPlatform platform = GST_GL_PLATFORM_NONE;
+  gint gl_major = 0, gl_minor = 0;
+
+  if (!gtk_init_check ()) {
+    GST_ERROR_OBJECT (self, "Could not ensure GTK initialization");
+    return FALSE;
+  }
+
+  gdk_display = gdk_display_get_default ();
+
+  if (G_UNLIKELY (!gdk_display)) {
+    GST_ERROR_OBJECT (self, "Could not retrieve Gdk display");
+    return FALSE;
+  }
+
+  if (!(gdk_context = gdk_display_create_gl_context (gdk_display, &error))) {
+    GST_ERROR_OBJECT (self, "Error creating Gdk GL context: %s",
+        error ? error->message : "No error set by Gdk");
+    g_clear_error (&error);
+
+    return FALSE;
+  }
+
+  if (!_gl_context_handler_context_realize (self, gdk_context)) {
+    GST_ERROR_OBJECT (self, "Could not realize Gdk context: %" GST_PTR_FORMAT,
+        gdk_context);
+    g_object_unref (gdk_context);
+
+    return FALSE;
+  }
+  gdk_gl_api = gdk_gl_context_get_api (gdk_context);
+
+  GST_OBJECT_LOCK (self);
+
+  self->gdk_context = gdk_context;
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WAYLAND
+  if (GDK_IS_WAYLAND_DISPLAY (gdk_display)) {
+    struct wl_display *wayland_display =
+        gdk_wayland_display_get_wl_display (gdk_display);
+    self->gst_display = (GstGLDisplay *)
+        gst_gl_display_wayland_new_with_display (wayland_display);
+  }
+#endif
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11
+  if (GDK_IS_X11_DISPLAY (gdk_display)) {
+    gpointer display_ptr;
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_EGL
+    display_ptr = gdk_x11_display_get_egl_display (gdk_display);
+    if (display_ptr) {
+      self->gst_display = (GstGLDisplay *)
+          gst_gl_display_egl_new_with_egl_display (display_ptr);
+    }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_GLX
+    if (!self->gst_display) {
+      display_ptr = gdk_x11_display_get_xdisplay (gdk_display);
+      self->gst_display = (GstGLDisplay *)
+          gst_gl_display_x11_new_with_display (display_ptr);
+    }
+  }
+#endif
+#endif
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32
+  if (GDK_IS_WIN32_DISPLAY (gdk_display)) {
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_EGL
+    gpointer display_ptr = gdk_win32_display_get_egl_display (gdk_display);
+    if (display_ptr) {
+      self->gst_display = (GstGLDisplay *)
+          gst_gl_display_egl_new_with_egl_display (display_ptr);
+    }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_WGL
+    if (!self->gst_display) {
+      self->gst_display =
+          gst_gl_display_new_with_type (GST_GL_DISPLAY_TYPE_WIN32);
+    }
+  }
+#endif
+#endif
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_MACOS
+  if (GDK_IS_MACOS_DISPLAY (gdk_display)) {
+    self->gst_display =
+        gst_gl_display_new_with_type (GST_GL_DISPLAY_TYPE_COCOA);
+  }
+#endif
+
+  /* Fallback to generic display */
+  if (G_UNLIKELY (!self->gst_display)) {
+    GST_WARNING_OBJECT (self, "Unknown Gdk display!");
+    self->gst_display = gst_gl_display_new ();
+  }
+
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WAYLAND
+  if (GST_IS_GL_DISPLAY_WAYLAND (self->gst_display)) {
+    platform = GST_GL_PLATFORM_EGL;
+    GST_INFO_OBJECT (self, "Using EGL on Wayland");
+    goto have_display;
+  }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_EGL
+  if (GST_IS_GL_DISPLAY_EGL (self->gst_display)
+      && GDK_IS_X11_DISPLAY (gdk_display)) {
+    platform = GST_GL_PLATFORM_EGL;
+    GST_INFO_OBJECT (self, "Using EGL on x11");
+    goto have_display;
+  }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_GLX
+  if (GST_IS_GL_DISPLAY_X11 (self->gst_display)) {
+    platform = GST_GL_PLATFORM_GLX;
+    GST_INFO_OBJECT (self, "Using GLX on x11");
+    goto have_display;
+  }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_EGL
+  if (GST_IS_GL_DISPLAY_EGL (self->gst_display)
+      && GDK_IS_WIN32_DISPLAY (gdk_display)) {
+    platform = GST_GL_PLATFORM_EGL;
+    GST_INFO_OBJECT (self, "Using EGL on Win32");
+    goto have_display;
+  }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_WGL
+  if (gst_gl_display_get_handle_type (self->gst_display) == GST_GL_DISPLAY_TYPE_WIN32) {
+    platform = GST_GL_PLATFORM_WGL;
+    GST_INFO_OBJECT (self, "Using WGL on Win32");
+    goto have_display;
+  }
+#endif
+#if GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_MACOS
+  if (gst_gl_display_get_handle_type (self->gst_display) == GST_GL_DISPLAY_TYPE_COCOA) {
+    platform = GST_GL_PLATFORM_CGL;
+    GST_INFO_OBJECT (self, "Using CGL on macOS");
+    goto have_display;
+  }
+#endif
+
+  g_clear_object (&self->gdk_context);
+  gst_clear_object (&self->gst_display);
+
+  GST_OBJECT_UNLOCK (self);
+
+  GST_ERROR_OBJECT (self, "Unsupported GL platform");
+  return FALSE;
+
+have_display:
+  gdk_gl_context_make_current (self->gdk_context);
+
+  self->wrapped_context = _wrap_current_gl (self->gst_display, gdk_gl_api, platform);
+  if (!self->wrapped_context) {
+    GST_ERROR ("Could not retrieve Gdk OpenGL context");
+    gdk_gl_context_clear_current ();
+
+    g_clear_object (&self->gdk_context);
+    gst_clear_object (&self->gst_display);
+
+    GST_OBJECT_UNLOCK (self);
+
+    return FALSE;
+  }
+
+  GST_INFO ("Retrieved Gdk OpenGL context %" GST_PTR_FORMAT, self->wrapped_context);
+  gst_gl_context_activate (self->wrapped_context, TRUE);
+
+  if (!gst_gl_context_fill_info (self->wrapped_context, &error)) {
+    GST_ERROR ("Failed to fill Gdk context info: %s", error->message);
+    g_clear_error (&error);
+
+    gst_gl_context_activate (self->wrapped_context, FALSE);
+
+    gst_clear_object (&self->wrapped_context);
+    g_clear_object (&self->gdk_context);
+    gst_clear_object (&self->gst_display);
+
+    GST_OBJECT_UNLOCK (self);
+
+    return FALSE;
+  }
+
+  gst_gl_context_get_gl_version (self->wrapped_context, &gl_major, &gl_minor);
+  GST_INFO ("Using OpenGL%s %i.%i", (gdk_gl_api == GDK_GL_API_GLES) ? " ES" : "",
+      gl_major, gl_minor);
+
+  /* Deactivate in both places */
+  gst_gl_context_activate (self->wrapped_context, FALSE);
+  gdk_gl_context_clear_current ();
+
+  GST_OBJECT_UNLOCK (self);
+
+  return TRUE;
+}
+
+static gboolean
+_retrieve_gst_context (GstClapperGLContextHandler *self)
+{
+  GstGLDisplay *gst_display = NULL;
+  GstGLContext *gst_context = NULL;
+  GError *error = NULL;
+
+  GST_OBJECT_LOCK (self);
+
+  gst_display = gst_object_ref (self->gst_display);
+  GST_TRACE_OBJECT (self, "Creating new GstGLContext");
+
+  /* GstGLDisplay operations require display object lock to be held */
+  GST_OBJECT_LOCK (gst_display);
+
+  if (!gst_gl_display_create_context (gst_display, self->wrapped_context,
+      &self->gst_context, &error)) {
+    GST_WARNING ("Could not create OpenGL context: %s",
+        error ? error->message : "Unknown");
+    g_clear_error (&error);
+
+    GST_OBJECT_UNLOCK (gst_display);
+    GST_OBJECT_UNLOCK (self);
+
+    return FALSE;
+  }
+
+  gst_context = gst_object_ref (self->gst_context);
+
+  GST_OBJECT_UNLOCK (self);
+
+  gst_gl_display_add_context (gst_display, gst_context);
+
+  GST_OBJECT_UNLOCK (gst_display);
+
+  gst_object_unref (gst_display);
+  gst_object_unref (gst_context);
+
+  return TRUE;
+}
+
+static gboolean
+gst_clapper_gl_context_handler_handle_context_query (GstClapperContextHandler *handler,
+    GstBaseSink *bsink, GstQuery *query)
+{
+  GstClapperGLContextHandler *self = GST_CLAPPER_GL_CONTEXT_HANDLER_CAST (handler);
+  gboolean res;
+
+  GST_OBJECT_LOCK (self);
+  res = gst_gl_handle_context_query (GST_ELEMENT_CAST (bsink), query,
+      self->gst_display, self->gst_context, self->wrapped_context);
+  GST_OBJECT_UNLOCK (self);
+
+  return res;
+}
+
+static void
+gst_clapper_gl_context_handler_init (GstClapperGLContextHandler *self)
+{
+}
+
+static void
+gst_clapper_gl_context_handler_constructed (GObject *object)
+{
+  GstClapperGLContextHandler *self = GST_CLAPPER_GL_CONTEXT_HANDLER_CAST (object);
+
+  if (! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
+      _retrieve_gl_context_on_main, self)) {
+    _retrieve_gst_context (self);
+  }
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, constructed, (object));
+}
+
+static void
+gst_clapper_gl_context_handler_finalize (GObject *object)
+{
+  GstClapperGLContextHandler *self = GST_CLAPPER_GL_CONTEXT_HANDLER_CAST (object);
+
+  GST_TRACE ("Finalize");
+
+  g_clear_object (&self->gdk_context);
+
+  gst_clear_object (&self->gst_display);
+  gst_clear_object (&self->wrapped_context);
+  gst_clear_object (&self->gst_context);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_gl_context_handler_class_init (GstClapperGLContextHandlerClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+  GstClapperContextHandlerClass *handler_class = (GstClapperContextHandlerClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperglcontexthandler", 0,
+      "Clapper GL Context Handler");
+
+  gobject_class->constructed = gst_clapper_gl_context_handler_constructed;
+  gobject_class->finalize = gst_clapper_gl_context_handler_finalize;
+
+  handler_class->handle_context_query = gst_clapper_gl_context_handler_handle_context_query;
+}
+
+void
+gst_clapper_gl_context_handler_add_handler (GPtrArray *context_handlers)
+{
+  guint i;
+  gboolean found = FALSE;
+
+  for (i = 0; i < context_handlers->len; i++) {
+    GstClapperContextHandler *handler = g_ptr_array_index (context_handlers, i);
+
+    if ((found = GST_IS_CLAPPER_GL_CONTEXT_HANDLER (handler)))
+      break;
+  }
+
+  if (!found) {
+    GstClapperGLContextHandler *handler = g_object_new (
+        GST_TYPE_CLAPPER_GL_CONTEXT_HANDLER, NULL);
+
+    g_ptr_array_add (context_handlers, handler);
+    GST_DEBUG ("Added GL context handler to handlers array");
+  }
+}
+
+GstCaps *
+gst_clapper_gl_context_handler_make_gdk_gl_caps (const gchar *features, gboolean only_2d)
+{
+  GstCaps *caps, *tmp;
+
+  if (only_2d) {
+    tmp = gst_caps_from_string (GST_VIDEO_CAPS_MAKE (
+        "{ " GST_GDK_GL_TEXTURE_FORMATS " }") ", "
+        "texture-target = (string) { " GST_GL_TEXTURE_TARGET_2D_STR " }");
+  } else {
+    tmp = gst_caps_from_string (GST_VIDEO_CAPS_MAKE (
+        "{ " GST_GDK_GL_TEXTURE_FORMATS " }"));
+  }
+
+  caps = gst_caps_copy (tmp);
+
+  gst_caps_set_features_simple (tmp, gst_caps_features_new (
+      features, NULL));
+  gst_caps_set_features_simple (caps, gst_caps_features_new (
+      features, GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, NULL));
+
+  gst_caps_append (caps, tmp);
+
+  return caps;
+}
+
+GdkTexture *
+gst_clapper_gl_context_handler_make_gl_texture (GstClapperGLContextHandler *self,
+    GstBuffer *buffer, GstVideoInfo *v_info)
+{
+  GdkTexture *texture;
+  GstGLSyncMeta *sync_meta;
+  GstVideoFrame frame;
+
+  if (G_UNLIKELY (!gst_video_frame_map (&frame, v_info, buffer, GST_MAP_READ | GST_MAP_GL))) {
+    GST_ERROR_OBJECT (self, "Could not map input buffer for reading");
+    return NULL;
+  }
+
+  GST_OBJECT_LOCK (self);
+
+  /* Must have context active here for both sync meta
+   * and Gdk texture format auto-detection to work */
+  gdk_gl_context_make_current (self->gdk_context);
+  gst_gl_context_activate (self->wrapped_context, TRUE);
+
+  sync_meta = gst_buffer_get_gl_sync_meta (buffer);
+
+  /* Wait for all previous OpenGL commands to complete,
+   * before we start using the input texture */
+  if (sync_meta) {
+    gst_gl_sync_meta_set_sync_point (sync_meta, self->gst_context);
+    gst_gl_sync_meta_wait (sync_meta, self->wrapped_context);
+  }
+
+  texture = gdk_gl_texture_new (
+      self->gdk_context,
+      *(guint *) GST_VIDEO_FRAME_PLANE_DATA (&frame, 0),
+      GST_VIDEO_FRAME_WIDTH (&frame),
+      GST_VIDEO_FRAME_HEIGHT (&frame),
+      (GDestroyNotify) gst_buffer_unref,
+      gst_buffer_ref (buffer));
+
+  gst_gl_context_activate (self->wrapped_context, FALSE);
+  gdk_gl_context_clear_current ();
+
+  GST_OBJECT_UNLOCK (self);
+
+  gst_video_frame_unmap (&frame);
+
+  return texture;
+}

src/lib/gst/plugin/handlers/gl/gstclapperglcontexthandler.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include <gst/gl/gl.h>
+#include <gst/gl/gstglfuncs.h>
+
+#include <gtk/gtk.h>
+
+#include "gst/plugin/gstclappercontexthandler.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_GL_CONTEXT_HANDLER (gst_clapper_gl_context_handler_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperGLContextHandler, gst_clapper_gl_context_handler, GST, CLAPPER_GL_CONTEXT_HANDLER, GstClapperContextHandler)
+
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_CAST(obj)        ((GstClapperGLContextHandler *)(obj))
+
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WAYLAND     (GST_GL_HAVE_WINDOW_WAYLAND && defined (GDK_WINDOWING_WAYLAND))
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11         (GST_GL_HAVE_WINDOW_X11 && defined (GDK_WINDOWING_X11))
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_GLX     (GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11 && GST_GL_HAVE_PLATFORM_GLX)
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11_EGL     (GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_X11 && GST_GL_HAVE_PLATFORM_EGL)
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32       (GST_GL_HAVE_WINDOW_WIN32 && defined (GDK_WINDOWING_WIN32))
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_WGL   (GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32 && GST_GL_HAVE_PLATFORM_WGL)
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32_EGL   (GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_WIN32 && GST_GL_HAVE_PLATFORM_EGL)
+#define GST_CLAPPER_GL_CONTEXT_HANDLER_HAVE_MACOS       (GST_GL_HAVE_WINDOW_COCOA && defined (GDK_WINDOWING_MACOS) && GST_GL_HAVE_PLATFORM_CGL)
+
+struct _GstClapperGLContextHandler
+{
+  GstClapperContextHandler parent;
+
+  GdkGLContext *gdk_context;
+
+  GstGLDisplay *gst_display;
+  GstGLContext *wrapped_context;
+  GstGLContext *gst_context;
+};
+
+void         gst_clapper_gl_context_handler_add_handler            (GPtrArray *context_handlers);
+
+GstCaps *    gst_clapper_gl_context_handler_make_gdk_gl_caps       (const gchar *features, gboolean only_2d);
+
+GdkTexture * gst_clapper_gl_context_handler_make_gl_texture        (GstClapperGLContextHandler *handler, GstBuffer *buffer, GstVideoInfo *v_info);
+
+G_END_DECLS

src/lib/gst/plugin/handlers/gl/meson.build

@@ -0,0 +1,140 @@
+gst_clapper_gl_ch_dep = dependency('', required: false)
+
+build_gl_ch = (
+  not get_option('glimporter').disabled()
+  or not get_option('gluploader').disabled()
+)
+gl_support_required = (
+  get_option('glimporter').enabled()
+  or get_option('gluploader').enabled()
+)
+
+# GStreamer OpenGL
+gst_gl_dep = dependency('gstreamer-gl-1.0',
+  version: gst_req,
+  fallback: ['gst-plugins-base'],
+  required: false,
+)
+gst_gl_x11_dep = dependency('', required: false)
+gst_gl_wayland_dep = dependency('', required: false)
+gst_gl_egl_dep = dependency('', required: false)
+
+gst_gl_apis = gst_gl_dep.get_variable('gl_apis').split()
+gst_gl_winsys = gst_gl_dep.get_variable('gl_winsys').split()
+gst_gl_platforms = gst_gl_dep.get_variable('gl_platforms').split()
+
+message('GStreamer OpenGL window systems: @0@'.format(' '.join(gst_gl_winsys)))
+message('GStreamer OpenGL platforms: @0@'.format(' '.join(gst_gl_platforms)))
+message('GStreamer OpenGL apis: @0@'.format(' '.join(gst_gl_apis)))
+
+foreach ws : ['x11', 'wayland', 'android', 'cocoa', 'eagl', 'win32', 'dispmanx', 'viv_fb']
+  set_variable('gst_gl_have_window_@0@'.format(ws), gst_gl_winsys.contains(ws))
+endforeach
+
+foreach p : ['glx', 'egl', 'cgl', 'eagl', 'wgl']
+  set_variable('gst_gl_have_platform_@0@'.format(p), gst_gl_platforms.contains(p))
+endforeach
+
+foreach api : ['gl', 'gles2']
+  set_variable('gst_gl_have_api_@0@'.format(api), gst_gl_apis.contains(api))
+endforeach
+
+gst_gl_proto_dep = dependency('gstreamer-gl-prototypes-1.0',
+  version: gst_req,
+  fallback: ['gst-plugins-base'],
+  required: true
+)
+if gst_gl_have_window_x11
+  gst_gl_x11_dep = dependency('gstreamer-gl-x11-1.0',
+    version: gst_req,
+    fallback: ['gst-plugins-base'],
+    required: true,
+)
+endif
+if gst_gl_have_window_wayland
+  gst_gl_wayland_dep = dependency('gstreamer-gl-wayland-1.0',
+    version: gst_req,
+    fallback: ['gst-plugins-base'],
+    required: true,
+)
+endif
+if gst_gl_have_platform_egl
+  gst_gl_egl_dep = dependency('gstreamer-gl-egl-1.0',
+    version: gst_req,
+    fallback: ['gst-plugins-base'],
+    required: true,
+)
+endif
+
+gst_plugin_gl_ch_deps = [gst_clapper_sink_dep, gst_gl_dep, gst_gl_proto_dep]
+have_gtk_gl_windowing = false
+
+if gst_gl_have_window_x11 and (gst_gl_have_platform_egl or gst_gl_have_platform_glx)
+  gtk_x11_dep = dependency('gtk4-x11', required: false)
+  if gtk_x11_dep.found()
+    gst_plugin_gl_ch_deps += gtk_x11_dep
+    if gst_gl_have_platform_glx
+      gst_plugin_gl_ch_deps += gst_gl_x11_dep
+    endif
+    have_gtk_gl_windowing = true
+  endif
+endif
+
+if gst_gl_have_window_wayland and gst_gl_have_platform_egl
+  gtk_wayland_dep = dependency('gtk4-wayland', required: false)
+  if gtk_wayland_dep.found()
+    gst_plugin_gl_ch_deps += [gtk_wayland_dep, gst_gl_wayland_dep]
+    have_gtk_gl_windowing = true
+  endif
+endif
+
+if gst_gl_have_window_win32 and (gst_gl_have_platform_egl or gst_gl_have_platform_wgl)
+  gtk_win32_dep = dependency('gtk4-win32', required: false)
+  if gtk_win32_dep.found()
+    gst_plugin_gl_ch_deps += gtk_win32_dep
+    have_gtk_gl_windowing = true
+  endif
+endif
+
+if gst_gl_have_window_cocoa and gst_gl_have_platform_cgl
+  gtk_macos_dep = dependency('gtk4-macos', required: false)
+  if gtk_macos_dep.found()
+    gst_plugin_gl_ch_deps += gtk_macos_dep
+    have_gtk_gl_windowing = true
+  endif
+endif
+
+if not have_gtk_gl_windowing
+  if gl_support_required
+    error('GL-based importer was enabled, but support for current GL windowing is missing')
+  endif
+  build_gl_ch = false
+endif
+
+if gst_gl_have_platform_egl
+  gst_plugin_gl_ch_deps += gst_gl_egl_dep
+endif
+
+foreach dep : gst_plugin_gl_ch_deps
+  if not dep.found()
+    if gl_support_required
+      error('GL-based importer was enabled, but required dependencies were not found')
+    endif
+    build_gl_ch = false
+  endif
+endforeach
+
+if build_gl_ch
+  gst_clapper_gl_ch_dep = declare_dependency(
+    link_with: library('gstclapperglcontexthandler',
+      'gstclapperglcontexthandler.c',
+      c_args: gst_clapper_plugin_args,
+      include_directories: gst_plugin_conf_inc,
+      dependencies: gst_plugin_gl_ch_deps,
+      version: meson.project_version(),
+      install: true,
+    ),
+    include_directories: gst_plugin_conf_inc,
+    dependencies: gst_plugin_gl_ch_deps,
+  )
+endif

src/lib/gst/plugin/handlers/meson.build

@@ -0,0 +1 @@
+subdir('gl')

src/lib/gst/plugin/importers/gstclapperglimporter.c

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclapperglimporter.h"
+
+#define GST_CAT_DEFAULT gst_clapper_gl_importer_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define parent_class gst_clapper_gl_importer_parent_class
+GST_CLAPPER_IMPORTER_DEFINE (GstClapperGLImporter, gst_clapper_gl_importer, GST_TYPE_CLAPPER_IMPORTER);
+
+static GstBufferPool *
+gst_clapper_gl_importer_create_pool (GstClapperImporter *importer, GstStructure **config)
+{
+  GstClapperGLImporter *self = GST_CLAPPER_GL_IMPORTER_CAST (importer);
+  GstBufferPool *pool;
+
+  GST_DEBUG_OBJECT (self, "Creating new GL buffer pool");
+
+  pool = gst_gl_buffer_pool_new (self->gl_handler->gst_context);
+  *config = gst_buffer_pool_get_config (pool);
+
+  gst_buffer_pool_config_add_option (*config, GST_BUFFER_POOL_OPTION_VIDEO_META);
+  gst_buffer_pool_config_add_option (*config, GST_BUFFER_POOL_OPTION_GL_SYNC_META);
+
+  return pool;
+}
+
+static void
+gst_clapper_gl_importer_add_allocation_metas (GstClapperImporter *importer, GstQuery *query)
+{
+  GstClapperGLImporter *self = GST_CLAPPER_GL_IMPORTER_CAST (importer);
+
+  /* We can support GL sync meta */
+  if (self->gl_handler->gst_context->gl_vtable->FenceSync)
+    gst_query_add_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, NULL);
+
+  /* Also add base importer class supported meta */
+  GST_CLAPPER_IMPORTER_CLASS (parent_class)->add_allocation_metas (importer, query);
+}
+
+static GdkTexture *
+gst_clapper_gl_importer_generate_texture (GstClapperImporter *importer,
+    GstBuffer *buffer, GstVideoInfo *v_info)
+{
+  GstClapperGLImporter *self = GST_CLAPPER_GL_IMPORTER_CAST (importer);
+
+  return gst_clapper_gl_context_handler_make_gl_texture (self->gl_handler, buffer, v_info);
+}
+
+static void
+gst_clapper_gl_importer_init (GstClapperGLImporter *self)
+{
+}
+
+static void
+gst_clapper_gl_importer_finalize (GObject *object)
+{
+  GstClapperGLImporter *self = GST_CLAPPER_GL_IMPORTER_CAST (object);
+
+  gst_clear_object (&self->gl_handler);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_gl_importer_class_init (GstClapperGLImporterClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+  GstClapperImporterClass *importer_class = (GstClapperImporterClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperglimporter", 0,
+      "Clapper GL Importer");
+
+  gobject_class->finalize = gst_clapper_gl_importer_finalize;
+
+  importer_class->create_pool = gst_clapper_gl_importer_create_pool;
+  importer_class->add_allocation_metas = gst_clapper_gl_importer_add_allocation_metas;
+  importer_class->generate_texture = gst_clapper_gl_importer_generate_texture;
+}
+
+GstClapperImporter *
+make_importer (GPtrArray *context_handlers)
+{
+  GstClapperGLImporter *self;
+  GstClapperContextHandler *handler;
+
+  handler = gst_clapper_context_handler_obtain_with_type (context_handlers,
+      GST_TYPE_CLAPPER_GL_CONTEXT_HANDLER);
+
+  if (G_UNLIKELY (!handler))
+    return NULL;
+
+  self = g_object_new (GST_TYPE_CLAPPER_GL_IMPORTER, NULL);
+  self->gl_handler = GST_CLAPPER_GL_CONTEXT_HANDLER_CAST (handler);
+
+  return GST_CLAPPER_IMPORTER_CAST (self);
+}
+
+GstCaps *
+make_caps (gboolean is_template, GstRank *rank, GPtrArray *context_handlers)
+{
+  *rank = GST_RANK_SECONDARY;
+
+  if (!is_template && context_handlers)
+    gst_clapper_gl_context_handler_add_handler (context_handlers);
+
+  return gst_clapper_gl_context_handler_make_gdk_gl_caps (
+      GST_CAPS_FEATURE_MEMORY_GL_MEMORY, TRUE);
+}

src/lib/gst/plugin/importers/gstclapperglimporter.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "gst/plugin/gstclapperimporter.h"
+#include "gst/plugin/handlers/gl/gstclapperglcontexthandler.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_GL_IMPORTER (gst_clapper_gl_importer_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperGLImporter, gst_clapper_gl_importer, GST, CLAPPER_GL_IMPORTER, GstClapperImporter)
+
+#define GST_CLAPPER_GL_IMPORTER_CAST(obj)        ((GstClapperGLImporter *)(obj))
+
+struct _GstClapperGLImporter
+{
+  GstClapperImporter parent;
+
+  GstClapperGLContextHandler *gl_handler;
+};
+
+G_END_DECLS

src/lib/gst/plugin/importers/gstclappergluploader.c

@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclappergluploader.h"
+
+#define GST_CAT_DEFAULT gst_clapper_gl_uploader_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define parent_class gst_clapper_gl_uploader_parent_class
+GST_CLAPPER_IMPORTER_DEFINE (GstClapperGLUploader, gst_clapper_gl_uploader, GST_TYPE_CLAPPER_IMPORTER);
+
+static void
+_update_elements_caps_locked (GstClapperGLUploader *self, GstCaps *upload_sink_caps)
+{
+  GstGLContext *gst_context;
+  GstCaps *upload_src_caps, *color_sink_caps, *color_src_caps, *gdk_sink_caps;
+
+  gst_context = self->gl_handler->gst_context;
+
+  GST_INFO_OBJECT (self, "Input caps: %" GST_PTR_FORMAT, upload_sink_caps);
+
+  upload_src_caps = gst_gl_upload_transform_caps (self->upload, gst_context,
+      GST_PAD_SINK, upload_sink_caps, NULL);
+  upload_src_caps = gst_caps_fixate (upload_src_caps);
+
+  GST_INFO_OBJECT (self, "GLUpload caps: %" GST_PTR_FORMAT, upload_src_caps);
+  gst_gl_upload_set_caps (self->upload, upload_sink_caps, upload_src_caps);
+
+  gdk_sink_caps = gst_clapper_gl_context_handler_make_gdk_gl_caps (
+      GST_CAPS_FEATURE_MEMORY_GL_MEMORY, TRUE);
+  color_sink_caps = gst_gl_color_convert_transform_caps (gst_context,
+      GST_PAD_SRC, upload_src_caps, gdk_sink_caps);
+  gst_caps_unref (gdk_sink_caps);
+
+  /* Second caps arg is transfer-full */
+  color_src_caps = gst_gl_color_convert_fixate_caps (gst_context,
+      GST_PAD_SINK, upload_src_caps, color_sink_caps);
+
+  GST_INFO_OBJECT (self, "GLColorConvert caps: %" GST_PTR_FORMAT, color_src_caps);
+  gst_gl_color_convert_set_caps (self->color_convert, upload_src_caps, color_src_caps);
+
+  self->has_pending_v_info = gst_video_info_from_caps (&self->pending_v_info, color_src_caps);
+
+  gst_caps_unref (upload_src_caps);
+  gst_caps_unref (color_src_caps);
+}
+
+static void
+gst_clapper_gl_uploader_set_caps (GstClapperImporter *importer, GstCaps *caps)
+{
+  GstClapperGLUploader *self = GST_CLAPPER_GL_UPLOADER_CAST (importer);
+
+  GST_CLAPPER_GL_UPLOADER_LOCK (self);
+  _update_elements_caps_locked (self, caps);
+  GST_CLAPPER_GL_UPLOADER_UNLOCK (self);
+}
+
+static void
+_uploader_reconfigure_locked (GstClapperGLUploader *self)
+{
+  GstCaps *in_caps = NULL;
+
+  GST_DEBUG_OBJECT (self, "Reconfiguring upload");
+
+  gst_gl_upload_get_caps (self->upload, &in_caps, NULL);
+
+  if (G_LIKELY (in_caps)) {
+    _update_elements_caps_locked (self, in_caps);
+    gst_caps_unref (in_caps);
+  }
+}
+
+static GstBuffer *
+_upload_perform_locked (GstClapperGLUploader *self, GstBuffer *buffer)
+{
+  GstBuffer *upload_buf = NULL;
+  GstGLUploadReturn ret;
+
+  ret = gst_gl_upload_perform_with_buffer (self->upload, buffer, &upload_buf);
+
+  if (G_UNLIKELY (ret != GST_GL_UPLOAD_DONE)) {
+    switch (ret) {
+      case GST_GL_UPLOAD_RECONFIGURE:
+        _uploader_reconfigure_locked (self);
+        /* Retry with the same buffer after reconfiguring */
+        return _upload_perform_locked (self, buffer);
+      default:
+        GST_ERROR_OBJECT (self, "Could not upload input buffer, returned: %i", ret);
+        break;
+    }
+  }
+
+  return upload_buf;
+}
+
+static GstBufferPool *
+gst_clapper_gl_uploader_create_pool (GstClapperImporter *importer, GstStructure **config)
+{
+  /* Since GLUpload API provides a ready to use propose_allocation method,
+   * we will use it with our query in add_allocation_metas instead of
+   * making pool here ourselves */
+  return NULL;
+}
+
+static void
+gst_clapper_gl_uploader_add_allocation_metas (GstClapperImporter *importer, GstQuery *query)
+{
+  GstClapperGLUploader *self = GST_CLAPPER_GL_UPLOADER_CAST (importer);
+  GstGLUpload *upload;
+
+  GST_CLAPPER_GL_UPLOADER_LOCK (self);
+  upload = gst_object_ref (self->upload);
+  GST_CLAPPER_GL_UPLOADER_UNLOCK (self);
+
+  /* Add glupload supported meta */
+  gst_gl_upload_propose_allocation (upload, NULL, query);
+  gst_object_unref (upload);
+
+  /* We can support GL sync meta */
+  if (self->gl_handler->gst_context->gl_vtable->FenceSync)
+    gst_query_add_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, NULL);
+
+  /* Also add base importer class supported meta */
+  GST_CLAPPER_IMPORTER_CLASS (parent_class)->add_allocation_metas (importer, query);
+}
+
+static GdkTexture *
+gst_clapper_gl_uploader_generate_texture (GstClapperImporter *importer,
+    GstBuffer *buffer, GstVideoInfo *v_info)
+{
+  GstClapperGLUploader *self = GST_CLAPPER_GL_UPLOADER_CAST (importer);
+  GstBuffer *upload_buf, *color_buf;
+  GdkTexture *texture;
+
+  /* XXX: We both upload and perform color conversion here, thus we skip
+   * upload for buffers that are not going to be shown and gain more free
+   * CPU time to prepare the next one. Improves performance on weak HW. */
+
+  GST_LOG_OBJECT (self, "Uploading %" GST_PTR_FORMAT, buffer);
+
+  GST_CLAPPER_GL_UPLOADER_LOCK (self);
+
+  upload_buf = _upload_perform_locked (self, buffer);
+
+  if (G_UNLIKELY (!upload_buf)) {
+    GST_ERROR_OBJECT (self, "Could not perform upload on input buffer");
+    GST_CLAPPER_GL_UPLOADER_UNLOCK (self);
+
+    return NULL;
+  }
+  GST_LOG_OBJECT (self, "Uploaded into %" GST_PTR_FORMAT, upload_buf);
+
+  color_buf = gst_gl_color_convert_perform (self->color_convert, upload_buf);
+  gst_buffer_unref (upload_buf);
+
+  /* Use video info associated with converted buffer */
+  if (self->has_pending_v_info) {
+    self->v_info = self->pending_v_info;
+    self->has_pending_v_info = FALSE;
+  }
+
+  GST_CLAPPER_GL_UPLOADER_UNLOCK (self);
+
+  if (G_UNLIKELY (!color_buf)) {
+    GST_ERROR_OBJECT (self, "Could not perform color conversion on input buffer");
+    return NULL;
+  }
+  GST_LOG_OBJECT (self, "Color converted into %" GST_PTR_FORMAT, color_buf);
+
+  texture = gst_clapper_gl_context_handler_make_gl_texture (self->gl_handler, color_buf, &self->v_info);
+  gst_buffer_unref (color_buf);
+
+  return texture;
+}
+
+static void
+gst_clapper_gl_uploader_init (GstClapperGLUploader *self)
+{
+  g_mutex_init (&self->lock);
+
+  gst_video_info_init (&self->pending_v_info);
+  gst_video_info_init (&self->v_info);
+}
+
+static void
+gst_clapper_gl_uploader_finalize (GObject *object)
+{
+  GstClapperGLUploader *self = GST_CLAPPER_GL_UPLOADER_CAST (object);
+
+  gst_clear_object (&self->upload);
+  gst_clear_object (&self->color_convert);
+
+  gst_clear_object (&self->gl_handler);
+
+  g_mutex_clear (&self->lock);
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+gst_clapper_gl_uploader_class_init (GstClapperGLUploaderClass *klass)
+{
+  GObjectClass *gobject_class = (GObjectClass *) klass;
+  GstClapperImporterClass *importer_class = (GstClapperImporterClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clappergluploader", 0,
+      "Clapper GL Uploader");
+
+  gobject_class->finalize = gst_clapper_gl_uploader_finalize;
+
+  importer_class->set_caps = gst_clapper_gl_uploader_set_caps;
+  importer_class->create_pool = gst_clapper_gl_uploader_create_pool;
+  importer_class->add_allocation_metas = gst_clapper_gl_uploader_add_allocation_metas;
+  importer_class->generate_texture = gst_clapper_gl_uploader_generate_texture;
+}
+
+GstClapperImporter *
+make_importer (GPtrArray *context_handlers)
+{
+  GstClapperGLUploader *self;
+  GstClapperContextHandler *handler;
+
+  handler = gst_clapper_context_handler_obtain_with_type (context_handlers,
+      GST_TYPE_CLAPPER_GL_CONTEXT_HANDLER);
+
+  if (G_UNLIKELY (!handler))
+    return NULL;
+
+  self = g_object_new (GST_TYPE_CLAPPER_GL_UPLOADER, NULL);
+  self->gl_handler = GST_CLAPPER_GL_CONTEXT_HANDLER_CAST (handler);
+  self->upload = gst_gl_upload_new (self->gl_handler->gst_context);
+  self->color_convert = gst_gl_color_convert_new (self->gl_handler->gst_context);
+
+  return GST_CLAPPER_IMPORTER_CAST (self);
+}
+
+static GstCaps *
+_make_actual_caps (GstClapperGLContextHandler *gl_handler)
+{
+  GstGLUpload *upload;
+  GstCaps *gdk_sink_caps, *color_sink_caps, *upload_sink_caps, *actual;
+  guint i;
+
+  /* Having "gst_context" means we also have all other contexts and
+   * display as they are used to create it, so no need to check */
+  if (!gl_handler->gst_context)
+    return NULL;
+
+  gdk_sink_caps = gst_clapper_gl_context_handler_make_gdk_gl_caps (
+      GST_CAPS_FEATURE_MEMORY_GL_MEMORY, TRUE);
+
+  color_sink_caps = gst_gl_color_convert_transform_caps (gl_handler->gst_context,
+      GST_PAD_SRC, gdk_sink_caps, NULL);
+  gst_caps_unref (gdk_sink_caps);
+
+  upload = gst_gl_upload_new (NULL);
+
+  upload_sink_caps = gst_gl_upload_transform_caps (upload, gl_handler->gst_context,
+      GST_PAD_SRC, color_sink_caps, NULL);
+  gst_caps_unref (color_sink_caps);
+
+  gst_object_unref (upload);
+
+  /* Check for existence and remove duplicated structures,
+   * they may contain unsupported by our GL context formats */
+  actual = gst_caps_new_empty ();
+  for (i = 0; i < gst_caps_get_size (upload_sink_caps); i++) {
+    GstCaps *tmp = gst_caps_copy_nth (upload_sink_caps, i);
+
+    if (!gst_caps_can_intersect (actual, tmp))
+      gst_caps_append (actual, tmp);
+    else
+      gst_caps_unref (tmp);
+  }
+  gst_caps_unref (upload_sink_caps);
+
+  if (G_UNLIKELY (gst_caps_is_empty (actual)))
+    gst_clear_caps (&actual);
+
+  return actual;
+}
+
+GstCaps *
+make_caps (gboolean is_template, GstRank *rank, GPtrArray *context_handlers)
+{
+  GstCaps *caps = NULL;
+
+  if (is_template) {
+    caps = gst_gl_upload_get_input_template_caps ();
+  } else if (context_handlers) {
+    GstClapperGLContextHandler *gl_handler;
+
+    /* Add GL context handler if not already present */
+    gst_clapper_gl_context_handler_add_handler (context_handlers);
+
+    if ((gl_handler = GST_CLAPPER_GL_CONTEXT_HANDLER_CAST (
+        gst_clapper_context_handler_obtain_with_type (context_handlers,
+            GST_TYPE_CLAPPER_GL_CONTEXT_HANDLER)))) {
+      caps = _make_actual_caps (gl_handler);
+      gst_object_unref (gl_handler);
+    }
+  }
+
+  if (caps)
+    *rank = GST_RANK_MARGINAL + 1;
+
+  return caps;
+}

src/lib/gst/plugin/importers/gstclappergluploader.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "gst/plugin/gstclapperimporter.h"
+#include "gst/plugin/handlers/gl/gstclapperglcontexthandler.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_GL_UPLOADER (gst_clapper_gl_uploader_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperGLUploader, gst_clapper_gl_uploader, GST, CLAPPER_GL_UPLOADER, GstClapperImporter)
+
+#define GST_CLAPPER_GL_UPLOADER_CAST(obj)        ((GstClapperGLUploader *)(obj))
+
+#define GST_CLAPPER_GL_UPLOADER_GET_LOCK(obj)    (&GST_CLAPPER_GL_UPLOADER_CAST(obj)->lock)
+#define GST_CLAPPER_GL_UPLOADER_LOCK(obj)        g_mutex_lock (GST_CLAPPER_GL_UPLOADER_GET_LOCK(obj))
+#define GST_CLAPPER_GL_UPLOADER_UNLOCK(obj)      g_mutex_unlock (GST_CLAPPER_GL_UPLOADER_GET_LOCK(obj))
+
+struct _GstClapperGLUploader
+{
+  GstClapperImporter parent;
+
+  GMutex lock;
+
+  GstClapperGLContextHandler *gl_handler;
+
+  GstGLUpload *upload;
+  GstGLColorConvert *color_convert;
+
+  GstVideoInfo pending_v_info, v_info;
+  gboolean has_pending_v_info;
+};
+
+G_END_DECLS

src/lib/gst/plugin/importers/gstclapperrawimporter.c

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstclapperrawimporter.h"
+#include "gst/plugin/gstgtkutils.h"
+#include "gst/plugin/gstgdkformats.h"
+
+#define GST_CAT_DEFAULT gst_clapper_raw_importer_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define parent_class gst_clapper_raw_importer_parent_class
+GST_CLAPPER_IMPORTER_DEFINE (GstClapperRawImporter, gst_clapper_raw_importer, GST_TYPE_CLAPPER_IMPORTER);
+
+static GstBufferPool *
+gst_clapper_raw_importer_create_pool (GstClapperImporter *importer, GstStructure **config)
+{
+  GstClapperRawImporter *self = GST_CLAPPER_RAW_IMPORTER_CAST (importer);
+  GstBufferPool *pool;
+
+  GST_DEBUG_OBJECT (self, "Creating new buffer pool");
+
+  pool = gst_video_buffer_pool_new ();
+  *config = gst_buffer_pool_get_config (pool);
+
+  gst_buffer_pool_config_add_option (*config, GST_BUFFER_POOL_OPTION_VIDEO_META);
+
+  return pool;
+}
+
+static GdkTexture *
+gst_clapper_raw_importer_generate_texture (GstClapperImporter *importer,
+    GstBuffer *buffer, GstVideoInfo *v_info)
+{
+  GdkTexture *texture;
+  GstVideoFrame frame;
+
+  if (G_UNLIKELY (!gst_video_frame_map (&frame, v_info, buffer, GST_MAP_READ))) {
+    GST_ERROR_OBJECT (importer, "Could not map input buffer for reading");
+    return NULL;
+  }
+
+  texture = gst_video_frame_into_gdk_texture (&frame);
+  gst_video_frame_unmap (&frame);
+
+  return texture;
+}
+
+static void
+gst_clapper_raw_importer_init (GstClapperRawImporter *self)
+{
+}
+
+static void
+gst_clapper_raw_importer_class_init (GstClapperRawImporterClass *klass)
+{
+  GstClapperImporterClass *importer_class = (GstClapperImporterClass *) klass;
+
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperrawimporter", 0,
+      "Clapper RAW Importer");
+
+  importer_class->create_pool = gst_clapper_raw_importer_create_pool;
+  importer_class->generate_texture = gst_clapper_raw_importer_generate_texture;
+}
+
+GstClapperImporter *
+make_importer (GPtrArray *context_handlers)
+{
+  return g_object_new (GST_TYPE_CLAPPER_RAW_IMPORTER, NULL);
+}
+
+GstCaps *
+make_caps (gboolean is_template, GstRank *rank, GPtrArray *context_handlers)
+{
+  *rank = GST_RANK_MARGINAL;
+
+  return gst_caps_from_string (
+      GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY ", "
+          GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
+          "{ " GST_GDK_MEMORY_FORMATS " }")
+      "; "
+      GST_VIDEO_CAPS_MAKE (
+          "{ " GST_GDK_MEMORY_FORMATS " }"));
+}

src/lib/gst/plugin/importers/gstclapperrawimporter.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2022 Rafał Dzięgiel <rafostar.github@gmail.com>
+ *
+ * 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 St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "gst/plugin/gstclapperimporter.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_CLAPPER_RAW_IMPORTER (gst_clapper_raw_importer_get_type())
+G_DECLARE_FINAL_TYPE (GstClapperRawImporter, gst_clapper_raw_importer, GST, CLAPPER_RAW_IMPORTER, GstClapperImporter)
+
+#define GST_CLAPPER_RAW_IMPORTER_CAST(obj)        ((GstClapperRawImporter *)(obj))
+
+struct _GstClapperRawImporter
+{
+  GstClapperImporter parent;
+};
+
+G_END_DECLS

src/lib/gst/plugin/importers/meson.build

@@ -0,0 +1,67 @@
+all_importers = [
+  'glimporter',
+  'gluploader',
+  'rawimporter',
+]
+
+# We cannot build any importers without sink that they depend on
+if not gst_clapper_sink_dep.found()
+  foreach imp : all_importers
+    if get_option(imp).enabled()
+      error('"@0@" option was enabled, but it requires building gstreamer plugin'.format(imp))
+    endif
+  endforeach
+endif
+
+build_glimporter = (
+  not get_option('glimporter').disabled()
+  and gst_clapper_gl_ch_dep.found()
+)
+
+if build_glimporter
+  library(
+    'gstclapperglimporter',
+    'gstclapperglimporter.c',
+    dependencies: gst_clapper_gl_ch_dep,
+    include_directories: gst_plugin_conf_inc,
+    c_args: gst_clapper_plugin_args,
+    install: true,
+    install_dir: gst_clapper_importers_libdir,
+  )
+endif
+
+build_gluploader = (
+  not get_option('gluploader').disabled()
+  and gst_clapper_gl_ch_dep.found()
+)
+
+if build_gluploader
+  library(
+    'gstclappergluploader',
+    'gstclappergluploader.c',
+    dependencies: gst_clapper_gl_ch_dep,
+    include_directories: gst_plugin_conf_inc,
+    c_args: gst_clapper_plugin_args,
+    install: true,
+    install_dir: gst_clapper_importers_libdir,
+  )
+endif
+
+# No need to auto build rawimporter if we are building gluploader
+build_rawimporter = (
+  not get_option('rawimporter').disabled()
+  and (not build_gluploader or get_option('rawimporter').enabled())
+  and gst_clapper_sink_dep.found()
+)
+
+if build_rawimporter
+  library(
+    'gstclapperrawimporter',
+    'gstclapperrawimporter.c',
+    dependencies: gst_clapper_sink_dep,
+    include_directories: gst_plugin_conf_inc,
+    c_args: gst_clapper_plugin_args,
+    install: true,
+    install_dir: gst_clapper_importers_libdir,
+  )
+endif

src/lib/gst/plugin/meson.build

@@ -0,0 +1,81 @@
+gst_clapper_sink_dep = dependency('', required: false)
+
+gst_plugins_libdir = join_paths(prefix, libdir, 'gstreamer-1.0')
+gst_clapper_importers_libdir = join_paths(clapper_libdir, 'gst', 'plugin', 'importers')
+
+gst_clapper_plugin_deps = [
+  gtk4_dep,
+  gst_dep,
+  gst_base_dep,
+  gst_video_dep,
+  gmodule_dep,
+]
+
+build_gst_plugin = not get_option('gst-plugin').disabled()
+foreach dep : gst_clapper_plugin_deps
+  if not dep.found()
+    if get_option('gst-plugin').enabled()
+      error('GStreamer plugin was enabled, but required dependencies were not found')
+    endif
+    build_gst_plugin = false
+  endif
+endforeach
+
+gst_clapper_plugin_args = [
+  '-DHAVE_CONFIG_H',
+  '-DGST_USE_UNSTABLE_API',
+]
+
+if get_option('default_library') == 'static'
+  gst_clapper_plugin_args += ['-DGST_STATIC_COMPILATION']
+endif
+
+cdata = configuration_data()
+
+cdata.set_quoted('PACKAGE', meson.project_name())
+cdata.set_quoted('VERSION', meson.project_version())
+cdata.set_quoted('PACKAGE_VERSION', meson.project_version())
+
+cdata.set_quoted('GST_PACKAGE_NAME', 'gst-plugin-clapper')
+cdata.set_quoted('GST_PACKAGE_ORIGIN', 'https://github.com/Rafostar/clapper')
+cdata.set_quoted('GST_LICENSE', 'LGPL')
+
+cdata.set_quoted('CLAPPER_SINK_IMPORTER_PATH', gst_clapper_importers_libdir)
+
+configure_file(
+  output: 'config.h',
+  configuration: cdata,
+)
+gst_plugin_conf_inc = [
+  include_directories('.'),
+  include_directories('..'),
+  include_directories('../..'),
+]
+
+gst_clapper_plugin_sources = [
+  'gstclappersink.c',
+  'gstclapperpaintable.c',
+  'gstgtkutils.c',
+  'gstplugin.c',
+  'gstclappercontexthandler.c',
+  'gstclapperimporter.c',
+  'gstclapperimporterloader.c',
+]
+
+if build_gst_plugin
+  gst_clapper_sink_dep = declare_dependency(
+    link_with: library('gstclapper',
+      gst_clapper_plugin_sources,
+      c_args: gst_clapper_plugin_args,
+      include_directories: gst_plugin_conf_inc,
+      dependencies: gst_clapper_plugin_deps,
+      install: true,
+      install_dir: gst_plugins_libdir,
+    ),
+    include_directories: gst_plugin_conf_inc,
+    dependencies: gst_clapper_plugin_deps,
+  )
+endif
+
+subdir('handlers')
+subdir('importers')