dany/clapper
1
0
Fork 0
mirror of https://github.com/Rafostar/clapper.git synced 2025-08-30 16:02:00 +02:00
Code Issues Packages Projects Releases Wiki Activity

Sink: rename into GstClapperGLSink

Browse Source 
The customized GTK4 sink version has few differences from the one shipped as part of GStreamer. Rename custom sink to GstClapperGLSink to avoid confusion.
This commit is contained in:
Rafał Dzięgiel
2021-03-06 00:24:31 +01:00
parent e3c9b112e2
commit 9c12afbf80
8 changed files with 642 additions and 648 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/gst/clapper/gstclapper-gtk4-plugin.c
View File

@@ -30,7 +30,7 @@
#endif #endif
#include "gstclapper-gtk4-plugin.h" #include "gstclapper-gtk4-plugin.h"
#include "gtk4/gstgtkbasesink.h" #include "gtk4/gstclapperglsink.h"
enum enum
{ {
@@ -78,7 +78,7 @@ gst_clapper_gtk4_plugin_constructed (GObject * object)
GstClapperGtk4Plugin *self = GST_CLAPPER_GTK4_PLUGIN (object); GstClapperGtk4Plugin *self = GST_CLAPPER_GTK4_PLUGIN (object);
if (!self->video_sink) if (!self->video_sink)
self->video_sink = g_object_new (GST_TYPE_GTK_BASE_SINK, NULL); self->video_sink = g_object_new (GST_TYPE_CLAPPER_GL_SINK, NULL);
gst_object_ref_sink (self->video_sink); gst_object_ref_sink (self->video_sink);

398
lib/gst/clapper/gtk4/gstgtkbasesink.c → lib/gst/clapper/gtk4/gstclapperglsink.c
View File

@@ -20,8 +20,8 @@
*/ */
/** /**
* SECTION:gtkgstsink * SECTION:gstclapperglsink
* @title: GstGtkBaseSink * @title: GstClapperGLSink
* *
*/ */
@@ -31,18 +31,18 @@
#include <gst/gl/gstglfuncs.h> #include <gst/gl/gstglfuncs.h>
#include "gstgtkbasesink.h" #include "gstclapperglsink.h"
#include "gstgtkutils.h" #include "gstgtkutils.h"
GST_DEBUG_CATEGORY (gst_debug_gtk_base_sink); GST_DEBUG_CATEGORY (gst_debug_clapper_gl_sink);
#define GST_CAT_DEFAULT gst_debug_gtk_base_sink #define GST_CAT_DEFAULT gst_debug_clapper_gl_sink
#define DEFAULT_FORCE_ASPECT_RATIO TRUE #define DEFAULT_FORCE_ASPECT_RATIO TRUE
#define DEFAULT_PAR_N 0 #define DEFAULT_PAR_N 0
#define DEFAULT_PAR_D 1 #define DEFAULT_PAR_D 1
#define DEFAULT_IGNORE_TEXTURES FALSE #define DEFAULT_IGNORE_TEXTURES FALSE
static GstStaticPadTemplate gst_gtk_base_sink_template = static GstStaticPadTemplate gst_clapper_gl_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink", GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK, GST_PAD_SINK,
GST_PAD_ALWAYS, GST_PAD_ALWAYS,
@@ -52,33 +52,33 @@ static GstStaticPadTemplate gst_gtk_base_sink_template =
(GST_CAPS_FEATURE_MEMORY_GL_MEMORY ", " (GST_CAPS_FEATURE_MEMORY_GL_MEMORY ", "
GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, "RGBA"))); GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, "RGBA")));
static void gst_gtk_base_sink_finalize (GObject * object); static void gst_clapper_gl_sink_finalize (GObject * object);
static void gst_gtk_base_sink_set_property (GObject * object, guint prop_id, static void gst_clapper_gl_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * param_spec); const GValue * value, GParamSpec * param_spec);
static void gst_gtk_base_sink_get_property (GObject * object, guint prop_id, static void gst_clapper_gl_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * param_spec); GValue * value, GParamSpec * param_spec);
static gboolean gst_gtk_base_sink_propose_allocation (GstBaseSink * bsink, static gboolean gst_clapper_gl_sink_propose_allocation (GstBaseSink * bsink,
GstQuery * query); GstQuery * query);
static gboolean gst_gtk_base_sink_query (GstBaseSink * bsink, GstQuery * query); static gboolean gst_clapper_gl_sink_query (GstBaseSink * bsink, GstQuery * query);
static gboolean gst_gtk_base_sink_start (GstBaseSink * bsink); static gboolean gst_clapper_gl_sink_start (GstBaseSink * bsink);
static gboolean gst_gtk_base_sink_stop (GstBaseSink * bsink); static gboolean gst_clapper_gl_sink_stop (GstBaseSink * bsink);
static GstStateChangeReturn static GstStateChangeReturn
gst_gtk_base_sink_change_state (GstElement * element, gst_clapper_gl_sink_change_state (GstElement * element,
GstStateChange transition); GstStateChange transition);
static void gst_gtk_base_sink_get_times (GstBaseSink * bsink, GstBuffer * buf, static void gst_clapper_gl_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
GstClockTime * start, GstClockTime * end); GstClockTime * start, GstClockTime * end);
static GstCaps *gst_gtk_base_sink_get_caps (GstBaseSink * bsink, static GstCaps *gst_clapper_gl_sink_get_caps (GstBaseSink * bsink,
GstCaps * filter); GstCaps * filter);
static gboolean gst_gtk_base_sink_set_caps (GstBaseSink * bsink, static gboolean gst_clapper_gl_sink_set_caps (GstBaseSink * bsink,
GstCaps * caps); GstCaps * caps);
static GstFlowReturn gst_gtk_base_sink_show_frame (GstVideoSink * bsink, static GstFlowReturn gst_clapper_gl_sink_show_frame (GstVideoSink * bsink,
GstBuffer * buf); GstBuffer * buf);
static void static void
gst_gtk_base_sink_navigation_interface_init (GstNavigationInterface * iface); gst_clapper_gl_sink_navigation_interface_init (GstNavigationInterface * iface);
enum enum
{ {
@@ -89,31 +89,31 @@ enum
PROP_IGNORE_TEXTURES, PROP_IGNORE_TEXTURES,
}; };
#define gst_gtk_base_sink_parent_class parent_class #define gst_clapper_gl_sink_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstGtkBaseSink, gst_gtk_base_sink, G_DEFINE_TYPE_WITH_CODE (GstClapperGLSink, gst_clapper_gl_sink,
GST_TYPE_VIDEO_SINK, GST_TYPE_VIDEO_SINK,
G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION, G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
gst_gtk_base_sink_navigation_interface_init); gst_clapper_gl_sink_navigation_interface_init);
GST_DEBUG_CATEGORY_INIT (gst_debug_gtk_base_sink, GST_DEBUG_CATEGORY_INIT (gst_debug_clapper_gl_sink,
"gtkbasesink", 0, "GTK Video Sink base class")); "clapperglsink", 0, "Clapper GL Sink"));
static void static void
gst_gtk_base_sink_class_init (GstGtkBaseSinkClass * klass) gst_clapper_gl_sink_class_init (GstClapperGLSinkClass * klass)
{ {
GObjectClass *gobject_class; GObjectClass *gobject_class;
GstElementClass *gstelement_class; GstElementClass *gstelement_class;
GstBaseSinkClass *gstbasesink_class; GstBaseSinkClass *gstbasesink_class;
GstVideoSinkClass *gstvideosink_class; GstVideoSinkClass *gstvideosink_class;
GstGtkBaseSinkClass *gstgtkbasesink_class; GstClapperGLSinkClass *gstclapperglsink_class;
gobject_class = (GObjectClass *) klass; gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass; gstelement_class = (GstElementClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass; gstbasesink_class = (GstBaseSinkClass *) klass;
gstvideosink_class = (GstVideoSinkClass *) klass; gstvideosink_class = (GstVideoSinkClass *) klass;
gstgtkbasesink_class = (GstGtkBaseSinkClass *) klass; gstclapperglsink_class = (GstClapperGLSinkClass *) klass;
gobject_class->set_property = gst_gtk_base_sink_set_property; gobject_class->set_property = gst_clapper_gl_sink_set_property;
gobject_class->get_property = gst_gtk_base_sink_get_property; gobject_class->get_property = gst_clapper_gl_sink_get_property;
g_object_class_install_property (gobject_class, PROP_WIDGET, g_object_class_install_property (gobject_class, PROP_WIDGET,
g_param_spec_object ("widget", "GTK Widget", g_param_spec_object ("widget", "GTK Widget",
@@ -138,22 +138,22 @@ gst_gtk_base_sink_class_init (GstGtkBaseSinkClass * klass)
"When enabled, textures will be ignored and not drawn", "When enabled, textures will be ignored and not drawn",
DEFAULT_IGNORE_TEXTURES, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); DEFAULT_IGNORE_TEXTURES, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
gobject_class->finalize = gst_gtk_base_sink_finalize; gobject_class->finalize = gst_clapper_gl_sink_finalize;
gstelement_class->change_state = gst_gtk_base_sink_change_state; gstelement_class->change_state = gst_clapper_gl_sink_change_state;
gstbasesink_class->get_caps = gst_gtk_base_sink_get_caps; gstbasesink_class->get_caps = gst_clapper_gl_sink_get_caps;
gstbasesink_class->set_caps = gst_gtk_base_sink_set_caps; gstbasesink_class->set_caps = gst_clapper_gl_sink_set_caps;
gstbasesink_class->get_times = gst_gtk_base_sink_get_times; gstbasesink_class->get_times = gst_clapper_gl_sink_get_times;
gstbasesink_class->propose_allocation = gst_gtk_base_sink_propose_allocation; gstbasesink_class->propose_allocation = gst_clapper_gl_sink_propose_allocation;
gstbasesink_class->query = gst_gtk_base_sink_query; gstbasesink_class->query = gst_clapper_gl_sink_query;
gstbasesink_class->start = gst_gtk_base_sink_start; gstbasesink_class->start = gst_clapper_gl_sink_start;
gstbasesink_class->stop = gst_gtk_base_sink_stop; gstbasesink_class->stop = gst_clapper_gl_sink_stop;
gstvideosink_class->show_frame = gst_gtk_base_sink_show_frame; gstvideosink_class->show_frame = gst_clapper_gl_sink_show_frame;
gstgtkbasesink_class->create_widget = gtk_gst_base_widget_new; gstclapperglsink_class->create_widget = gtk_clapper_gl_widget_new;
gstgtkbasesink_class->window_title = "GTK4 GL Renderer"; gstclapperglsink_class->window_title = "GTK4 GL Renderer";
gst_element_class_set_metadata (gstelement_class, gst_element_class_set_metadata (gstelement_class,
"GTK4 GL Video Sink", "GTK4 GL Video Sink",
@@ -162,136 +162,136 @@ gst_gtk_base_sink_class_init (GstGtkBaseSinkClass * klass)
"Rafał Dzięgiel <rafostar.github@gmail.com>"); "Rafał Dzięgiel <rafostar.github@gmail.com>");
gst_element_class_add_static_pad_template (gstelement_class, gst_element_class_add_static_pad_template (gstelement_class,
&gst_gtk_base_sink_template); &gst_clapper_gl_sink_template);
gst_type_mark_as_plugin_api (GST_TYPE_GTK_BASE_SINK, 0); gst_type_mark_as_plugin_api (GST_TYPE_CLAPPER_GL_SINK, 0);
} }
static void static void
gst_gtk_base_sink_init (GstGtkBaseSink * gtk_sink) gst_clapper_gl_sink_init (GstClapperGLSink * clapper_sink)
{ {
gtk_sink->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO; clapper_sink->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
gtk_sink->par_n = DEFAULT_PAR_N; clapper_sink->par_n = DEFAULT_PAR_N;
gtk_sink->par_d = DEFAULT_PAR_D; clapper_sink->par_d = DEFAULT_PAR_D;
gtk_sink->ignore_textures = DEFAULT_IGNORE_TEXTURES; clapper_sink->ignore_textures = DEFAULT_IGNORE_TEXTURES;
} }
static void static void
gst_gtk_base_sink_finalize (GObject * object) gst_clapper_gl_sink_finalize (GObject * object)
{ {
GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (object); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (object);
GST_DEBUG ("finalizing base sink"); GST_DEBUG ("Finalizing Clapper GL sink");
GST_OBJECT_LOCK (base_sink); GST_OBJECT_LOCK (clapper_sink);
if (base_sink->window && base_sink->window_destroy_id) if (clapper_sink->window && clapper_sink->window_destroy_id)
g_signal_handler_disconnect (base_sink->window, base_sink->window_destroy_id); g_signal_handler_disconnect (clapper_sink->window, clapper_sink->window_destroy_id);
if (base_sink->widget && base_sink->widget_destroy_id) if (clapper_sink->widget && clapper_sink->widget_destroy_id)
g_signal_handler_disconnect (base_sink->widget, base_sink->widget_destroy_id); g_signal_handler_disconnect (clapper_sink->widget, clapper_sink->widget_destroy_id);
g_clear_object (&base_sink->widget); g_clear_object (&clapper_sink->widget);
GST_OBJECT_UNLOCK (base_sink); GST_OBJECT_UNLOCK (clapper_sink);
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }
static void static void
widget_destroy_cb (GtkWidget * widget, GstGtkBaseSink * gtk_sink) widget_destroy_cb (GtkWidget * widget, GstClapperGLSink * clapper_sink)
{ {
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
g_clear_object (&gtk_sink->widget); g_clear_object (&clapper_sink->widget);
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
} }
static void static void
window_destroy_cb (GtkWidget * widget, GstGtkBaseSink * gtk_sink) window_destroy_cb (GtkWidget * widget, GstClapperGLSink * clapper_sink)
{ {
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
if (gtk_sink->widget) { if (clapper_sink->widget) {
if (gtk_sink->widget_destroy_id) { if (clapper_sink->widget_destroy_id) {
g_signal_handler_disconnect (gtk_sink->widget, g_signal_handler_disconnect (clapper_sink->widget,
gtk_sink->widget_destroy_id); clapper_sink->widget_destroy_id);
gtk_sink->widget_destroy_id = 0; clapper_sink->widget_destroy_id = 0;
} }
g_clear_object (&gtk_sink->widget); g_clear_object (&clapper_sink->widget);
} }
gtk_sink->window = NULL; clapper_sink->window = NULL;
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
} }
static GtkGstBaseWidget * static GtkClapperGLWidget *
gst_gtk_base_sink_get_widget (GstGtkBaseSink * gtk_sink) gst_clapper_gl_sink_get_widget (GstClapperGLSink * clapper_sink)
{ {
if (gtk_sink->widget != NULL) if (clapper_sink->widget != NULL)
return gtk_sink->widget; return clapper_sink->widget;
/* Ensure GTK is initialized, this has no side effect if it was already /* Ensure GTK is initialized, this has no side effect if it was already
* initialized. Also, we do that lazily, so the application can be first */ * initialized. Also, we do that lazily, so the application can be first */
if (!gtk_init_check ()) { if (!gtk_init_check ()) {
GST_ERROR_OBJECT (gtk_sink, "Could not ensure GTK initialization."); GST_ERROR_OBJECT (clapper_sink, "Could not ensure GTK initialization.");
return NULL; return NULL;
} }
g_assert (GST_GTK_BASE_SINK_GET_CLASS (gtk_sink)->create_widget); g_assert (GST_CLAPPER_GL_SINK_GET_CLASS (clapper_sink)->create_widget);
gtk_sink->widget = (GtkGstBaseWidget *) clapper_sink->widget = (GtkClapperGLWidget *)
GST_GTK_BASE_SINK_GET_CLASS (gtk_sink)->create_widget (); GST_CLAPPER_GL_SINK_GET_CLASS (clapper_sink)->create_widget ();
gtk_sink->bind_aspect_ratio = clapper_sink->bind_aspect_ratio =
g_object_bind_property (gtk_sink, "force-aspect-ratio", gtk_sink->widget, g_object_bind_property (clapper_sink, "force-aspect-ratio", clapper_sink->widget,
"force-aspect-ratio", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); "force-aspect-ratio", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
gtk_sink->bind_pixel_aspect_ratio = clapper_sink->bind_pixel_aspect_ratio =
g_object_bind_property (gtk_sink, "pixel-aspect-ratio", gtk_sink->widget, g_object_bind_property (clapper_sink, "pixel-aspect-ratio", clapper_sink->widget,
"pixel-aspect-ratio", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); "pixel-aspect-ratio", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
gtk_sink->bind_ignore_textures = clapper_sink->bind_ignore_textures =
g_object_bind_property (gtk_sink, "ignore-textures", gtk_sink->widget, g_object_bind_property (clapper_sink, "ignore-textures", clapper_sink->widget,
"ignore-textures", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); "ignore-textures", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
/* Take the floating ref, other wise the destruction of the container will /* Take the floating ref, other wise the destruction of the container will
* make this widget disappear possibly before we are done. */ * make this widget disappear possibly before we are done. */
gst_object_ref_sink (gtk_sink->widget); gst_object_ref_sink (clapper_sink->widget);
gtk_sink->widget_destroy_id = g_signal_connect (gtk_sink->widget, "destroy", clapper_sink->widget_destroy_id = g_signal_connect (clapper_sink->widget, "destroy",
G_CALLBACK (widget_destroy_cb), gtk_sink); G_CALLBACK (widget_destroy_cb), clapper_sink);
/* back pointer */ /* back pointer */
gtk_gst_base_widget_set_element (GTK_GST_BASE_WIDGET (gtk_sink->widget), gtk_clapper_gl_widget_set_element (GTK_CLAPPER_GL_WIDGET (clapper_sink->widget),
GST_ELEMENT (gtk_sink)); GST_ELEMENT (clapper_sink));
return gtk_sink->widget; return clapper_sink->widget;
} }
static void static void
gst_gtk_base_sink_get_property (GObject * object, guint prop_id, gst_clapper_gl_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GstGtkBaseSink *gtk_sink = GST_GTK_BASE_SINK (object); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (object);
switch (prop_id) { switch (prop_id) {
case PROP_WIDGET: case PROP_WIDGET:
{ {
GObject *widget = NULL; GObject *widget = NULL;
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
if (gtk_sink->widget != NULL) if (clapper_sink->widget != NULL)
widget = G_OBJECT (gtk_sink->widget); widget = G_OBJECT (clapper_sink->widget);
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
if (!widget) if (!widget)
widget = widget =
gst_gtk_invoke_on_main ((GThreadFunc) gst_gtk_base_sink_get_widget, gst_gtk_invoke_on_main ((GThreadFunc) gst_clapper_gl_sink_get_widget,
gtk_sink); clapper_sink);
g_value_set_object (value, widget); g_value_set_object (value, widget);
break; break;
} }
case PROP_FORCE_ASPECT_RATIO: case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, gtk_sink->force_aspect_ratio); g_value_set_boolean (value, clapper_sink->force_aspect_ratio);
break; break;
case PROP_PIXEL_ASPECT_RATIO: case PROP_PIXEL_ASPECT_RATIO:
gst_value_set_fraction (value, gtk_sink->par_n, gtk_sink->par_d); gst_value_set_fraction (value, clapper_sink->par_n, clapper_sink->par_d);
break; break;
case PROP_IGNORE_TEXTURES: case PROP_IGNORE_TEXTURES:
g_value_set_boolean (value, gtk_sink->ignore_textures); g_value_set_boolean (value, clapper_sink->ignore_textures);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -300,21 +300,21 @@ gst_gtk_base_sink_get_property (GObject * object, guint prop_id,
} }
static void static void
gst_gtk_base_sink_set_property (GObject * object, guint prop_id, gst_clapper_gl_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
{ {
GstGtkBaseSink *gtk_sink = GST_GTK_BASE_SINK (object); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (object);
switch (prop_id) { switch (prop_id) {
case PROP_FORCE_ASPECT_RATIO: case PROP_FORCE_ASPECT_RATIO:
gtk_sink->force_aspect_ratio = g_value_get_boolean (value); clapper_sink->force_aspect_ratio = g_value_get_boolean (value);
break; break;
case PROP_PIXEL_ASPECT_RATIO: case PROP_PIXEL_ASPECT_RATIO:
gtk_sink->par_n = gst_value_get_fraction_numerator (value); clapper_sink->par_n = gst_value_get_fraction_numerator (value);
gtk_sink->par_d = gst_value_get_fraction_denominator (value); clapper_sink->par_d = gst_value_get_fraction_denominator (value);
break; break;
case PROP_IGNORE_TEXTURES: case PROP_IGNORE_TEXTURES:
gtk_sink->ignore_textures = g_value_get_boolean (value); clapper_sink->ignore_textures = g_value_get_boolean (value);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -323,10 +323,10 @@ gst_gtk_base_sink_set_property (GObject * object, guint prop_id,
} }
static void static void
gst_gtk_base_sink_navigation_send_event (GstNavigation * navigation, gst_clapper_gl_sink_navigation_send_event (GstNavigation * navigation,
GstStructure * structure) GstStructure * structure)
{ {
GstGtkBaseSink *sink = GST_GTK_BASE_SINK (navigation); GstClapperGLSink *sink = GST_CLAPPER_GL_SINK (navigation);
GstEvent *event; GstEvent *event;
GstPad *pad; GstPad *pad;
@@ -348,15 +348,15 @@ gst_gtk_base_sink_navigation_send_event (GstNavigation * navigation,
} }
static void static void
gst_gtk_base_sink_navigation_interface_init (GstNavigationInterface * iface) gst_clapper_gl_sink_navigation_interface_init (GstNavigationInterface * iface)
{ {
iface->send_event = gst_gtk_base_sink_navigation_send_event; iface->send_event = gst_clapper_gl_sink_navigation_send_event;
} }
static gboolean static gboolean
gst_gtk_base_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query) gst_clapper_gl_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{ {
GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (bsink);
GstBufferPool *pool = NULL; GstBufferPool *pool = NULL;
GstStructure *config; GstStructure *config;
GstCaps *caps; GstCaps *caps;
@@ -366,7 +366,7 @@ gst_gtk_base_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
GstStructure *allocation_meta = NULL; GstStructure *allocation_meta = NULL;
gint display_width, display_height; gint display_width, display_height;
if (!base_sink->display || !base_sink->context) if (!clapper_sink->display || !clapper_sink->context)
return FALSE; return FALSE;
gst_query_parse_allocation (query, &caps, &need_pool); gst_query_parse_allocation (query, &caps, &need_pool);
@@ -381,8 +381,8 @@ gst_gtk_base_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
size = info.size; size = info.size;
if (need_pool) { if (need_pool) {
GST_DEBUG_OBJECT (base_sink, "create new pool"); GST_DEBUG_OBJECT (clapper_sink, "create new pool");
pool = gst_gl_buffer_pool_new (base_sink->context); pool = gst_gl_buffer_pool_new (clapper_sink->context);
config = gst_buffer_pool_get_config (pool); config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, 0, 0); gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
@@ -398,13 +398,13 @@ gst_gtk_base_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
if (pool) if (pool)
gst_object_unref (pool); gst_object_unref (pool);
GST_OBJECT_LOCK (base_sink); GST_OBJECT_LOCK (clapper_sink);
display_width = base_sink->display_width; display_width = clapper_sink->display_width;
display_height = base_sink->display_height; display_height = clapper_sink->display_height;
GST_OBJECT_UNLOCK (base_sink); GST_OBJECT_UNLOCK (clapper_sink);
if (display_width != 0 && display_height != 0) { if (display_width != 0 && display_height != 0) {
GST_DEBUG_OBJECT (base_sink, "sending alloc query with size %dx%d", GST_DEBUG_OBJECT (clapper_sink, "sending alloc query with size %dx%d",
display_width, display_height); display_width, display_height);
allocation_meta = gst_structure_new ("GstVideoOverlayCompositionMeta", allocation_meta = gst_structure_new ("GstVideoOverlayCompositionMeta",
"width", G_TYPE_UINT, display_width, "width", G_TYPE_UINT, display_width,
@@ -420,7 +420,7 @@ gst_gtk_base_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
/* we also support various metadata */ /* we also support various metadata */
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, 0); gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, 0);
if (base_sink->context->gl_vtable->FenceSync) if (clapper_sink->context->gl_vtable->FenceSync)
gst_query_add_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, 0); gst_query_add_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, 0);
return TRUE; return TRUE;
@@ -444,16 +444,16 @@ config_failed:
} }
static gboolean static gboolean
gst_gtk_base_sink_query (GstBaseSink * bsink, GstQuery * query) gst_clapper_gl_sink_query (GstBaseSink * bsink, GstQuery * query)
{ {
GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (bsink);
gboolean res = FALSE; gboolean res = FALSE;
switch (GST_QUERY_TYPE (query)) { switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONTEXT: case GST_QUERY_CONTEXT:
{ {
if (gst_gl_handle_context_query ((GstElement *) base_sink, query, if (gst_gl_handle_context_query ((GstElement *) clapper_sink, query,
base_sink->display, base_sink->context, base_sink->gtk_context)) clapper_sink->display, clapper_sink->context, clapper_sink->gtk_context))
return TRUE; return TRUE;
break; break;
} }
@@ -466,17 +466,17 @@ gst_gtk_base_sink_query (GstBaseSink * bsink, GstQuery * query)
} }
static gboolean static gboolean
gst_gtk_base_sink_start_on_main (GstBaseSink * bsink) gst_clapper_gl_sink_start_on_main (GstBaseSink * bsink)
{ {
GstGtkBaseSink *gst_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *gst_sink = GST_CLAPPER_GL_SINK (bsink);
GstGtkBaseSinkClass *klass = GST_GTK_BASE_SINK_GET_CLASS (bsink); GstClapperGLSinkClass *klass = GST_CLAPPER_GL_SINK_GET_CLASS (bsink);
GtkWidget *toplevel; GtkWidget *toplevel;
GtkRoot *root; GtkRoot *root;
if (gst_gtk_base_sink_get_widget (gst_sink) == NULL) if (gst_clapper_gl_sink_get_widget (gst_sink) == NULL)
return FALSE; return FALSE;
/* After this point, base_sink->widget will always be set */ /* After this point, clapper_sink->widget will always be set */
root = gtk_widget_get_root (GTK_WIDGET (gst_sink->widget)); root = gtk_widget_get_root (GTK_WIDGET (gst_sink->widget));
if (!GTK_IS_ROOT (root)) { if (!GTK_IS_ROOT (root)) {
@@ -507,47 +507,47 @@ gst_gtk_base_sink_start_on_main (GstBaseSink * bsink)
} }
static gboolean static gboolean
gst_gtk_base_sink_start (GstBaseSink * bsink) gst_clapper_gl_sink_start (GstBaseSink * bsink)
{ {
GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (bsink);
GtkGstBaseWidget *base_widget; GtkClapperGLWidget *clapper_widget;
if (!(! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) if (!(! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
gst_gtk_base_sink_start_on_main, bsink))) gst_clapper_gl_sink_start_on_main, bsink)))
return FALSE; return FALSE;
/* After this point, base_sink->widget will always be set */ /* After this point, clapper_sink->widget will always be set */
base_widget = GTK_GST_BASE_WIDGET (base_sink->widget); clapper_widget = GTK_CLAPPER_GL_WIDGET (clapper_sink->widget);
if (!gtk_gst_base_widget_init_winsys (base_widget)) { if (!gtk_clapper_gl_widget_init_winsys (clapper_widget)) {
GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s", GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s",
"Failed to initialize OpenGL with GTK"), (NULL)); "Failed to initialize OpenGL with GTK"), (NULL));
return FALSE; return FALSE;
} }
if (!base_sink->display) if (!clapper_sink->display)
base_sink->display = gtk_gst_base_widget_get_display (base_widget); clapper_sink->display = gtk_clapper_gl_widget_get_display (clapper_widget);
if (!base_sink->context) if (!clapper_sink->context)
base_sink->context = gtk_gst_base_widget_get_context (base_widget); clapper_sink->context = gtk_clapper_gl_widget_get_context (clapper_widget);
if (!base_sink->gtk_context) if (!clapper_sink->gtk_context)
base_sink->gtk_context = gtk_gst_base_widget_get_gtk_context (base_widget); clapper_sink->gtk_context = gtk_clapper_gl_widget_get_gtk_context (clapper_widget);
if (!base_sink->display || !base_sink->context || !base_sink->gtk_context) { if (!clapper_sink->display || !clapper_sink->context || !clapper_sink->gtk_context) {
GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s", GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s",
"Failed to retrieve OpenGL context from GTK"), (NULL)); "Failed to retrieve OpenGL context from GTK"), (NULL));
return FALSE; return FALSE;
} }
gst_gl_element_propagate_display_context (GST_ELEMENT (bsink), gst_gl_element_propagate_display_context (GST_ELEMENT (bsink),
base_sink->display); clapper_sink->display);
return TRUE; return TRUE;
} }
static gboolean static gboolean
gst_gtk_base_sink_stop_on_main (GstBaseSink * bsink) gst_clapper_gl_sink_stop_on_main (GstBaseSink * bsink)
{ {
GstGtkBaseSink *gst_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *gst_sink = GST_CLAPPER_GL_SINK (bsink);
if (gst_sink->window) { if (gst_sink->window) {
gtk_window_destroy (GTK_WINDOW (gst_sink->window)); gtk_window_destroy (GTK_WINDOW (gst_sink->window));
@@ -559,25 +559,25 @@ gst_gtk_base_sink_stop_on_main (GstBaseSink * bsink)
} }
static gboolean static gboolean
gst_gtk_base_sink_stop (GstBaseSink * bsink) gst_clapper_gl_sink_stop (GstBaseSink * bsink)
{ {
GstGtkBaseSink *base_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (bsink);
if (base_sink->display) { if (clapper_sink->display) {
gst_object_unref (base_sink->display); gst_object_unref (clapper_sink->display);
base_sink->display = NULL; clapper_sink->display = NULL;
} }
if (base_sink->context) { if (clapper_sink->context) {
gst_object_unref (base_sink->context); gst_object_unref (clapper_sink->context);
base_sink->context = NULL; clapper_sink->context = NULL;
} }
if (base_sink->gtk_context) { if (clapper_sink->gtk_context) {
gst_object_unref (base_sink->gtk_context); gst_object_unref (clapper_sink->gtk_context);
base_sink->gtk_context = NULL; clapper_sink->gtk_context = NULL;
} }
if (base_sink->window) if (clapper_sink->window)
return ! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) return ! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
gst_gtk_base_sink_stop_on_main, bsink); gst_clapper_gl_sink_stop_on_main, bsink);
return TRUE; return TRUE;
} }
@@ -590,9 +590,9 @@ gst_gtk_window_show_all_and_unref (GtkWidget * window)
} }
static GstStateChangeReturn static GstStateChangeReturn
gst_gtk_base_sink_change_state (GstElement * element, GstStateChange transition) gst_clapper_gl_sink_change_state (GstElement * element, GstStateChange transition)
{ {
GstGtkBaseSink *gtk_sink = GST_GTK_BASE_SINK (element); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (element);
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GST_DEBUG_OBJECT (element, "changing state: %s => %s", GST_DEBUG_OBJECT (element, "changing state: %s => %s",
@@ -608,10 +608,10 @@ gst_gtk_base_sink_change_state (GstElement * element, GstStateChange transition)
{ {
GtkWindow *window = NULL; GtkWindow *window = NULL;
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
if (gtk_sink->window) if (clapper_sink->window)
window = g_object_ref (GTK_WINDOW (gtk_sink->window)); window = g_object_ref (GTK_WINDOW (clapper_sink->window));
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
if (window) { if (window) {
gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
@@ -620,10 +620,10 @@ gst_gtk_base_sink_change_state (GstElement * element, GstStateChange transition)
break; break;
} }
case GST_STATE_CHANGE_PAUSED_TO_READY: case GST_STATE_CHANGE_PAUSED_TO_READY:
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
if (gtk_sink->widget) if (clapper_sink->widget)
gtk_gst_base_widget_set_buffer (gtk_sink->widget, NULL); gtk_clapper_gl_widget_set_buffer (clapper_sink->widget, NULL);
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
break; break;
default: default:
break; break;
@@ -633,30 +633,28 @@ gst_gtk_base_sink_change_state (GstElement * element, GstStateChange transition)
} }
static void static void
gst_gtk_base_sink_get_times (GstBaseSink * bsink, GstBuffer * buf, gst_clapper_gl_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
GstClockTime * start, GstClockTime * end) GstClockTime * start, GstClockTime * end)
{ {
GstGtkBaseSink *gtk_sink; GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (bsink);
gtk_sink = GST_GTK_BASE_SINK (bsink);
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) { if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
*start = GST_BUFFER_TIMESTAMP (buf); *start = GST_BUFFER_TIMESTAMP (buf);
if (GST_BUFFER_DURATION_IS_VALID (buf)) if (GST_BUFFER_DURATION_IS_VALID (buf))
*end = *start + GST_BUFFER_DURATION (buf); *end = *start + GST_BUFFER_DURATION (buf);
else { else {
if (GST_VIDEO_INFO_FPS_N (&gtk_sink->v_info) > 0) { if (GST_VIDEO_INFO_FPS_N (&clapper_sink->v_info) > 0) {
*end = *start + *end = *start +
gst_util_uint64_scale_int (GST_SECOND, gst_util_uint64_scale_int (GST_SECOND,
GST_VIDEO_INFO_FPS_D (&gtk_sink->v_info), GST_VIDEO_INFO_FPS_D (&clapper_sink->v_info),
GST_VIDEO_INFO_FPS_N (&gtk_sink->v_info)); GST_VIDEO_INFO_FPS_N (&clapper_sink->v_info));
} }
} }
} }
} }
static GstCaps * static GstCaps *
gst_gtk_base_sink_get_caps (GstBaseSink * bsink, GstCaps * filter) gst_clapper_gl_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
{ {
GstCaps *tmp = NULL; GstCaps *tmp = NULL;
GstCaps *result = NULL; GstCaps *result = NULL;
@@ -681,54 +679,54 @@ gst_gtk_base_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
} }
static gboolean static gboolean
gst_gtk_base_sink_set_caps (GstBaseSink * bsink, GstCaps * caps) gst_clapper_gl_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
{ {
GstGtkBaseSink *gtk_sink = GST_GTK_BASE_SINK (bsink); GstClapperGLSink *clapper_sink = GST_CLAPPER_GL_SINK (bsink);
GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps); GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps);
if (!gst_video_info_from_caps (&gtk_sink->v_info, caps)) if (!gst_video_info_from_caps (&clapper_sink->v_info, caps))
return FALSE; return FALSE;
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
if (gtk_sink->widget == NULL) { if (clapper_sink->widget == NULL) {
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
GST_ELEMENT_ERROR (gtk_sink, RESOURCE, NOT_FOUND, GST_ELEMENT_ERROR (clapper_sink, RESOURCE, NOT_FOUND,
("%s", "Output widget was destroyed"), (NULL)); ("%s", "Output widget was destroyed"), (NULL));
return FALSE; return FALSE;
} }
if (!gtk_gst_base_widget_set_format (gtk_sink->widget, &gtk_sink->v_info)) { if (!gtk_clapper_gl_widget_set_format (clapper_sink->widget, &clapper_sink->v_info)) {
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
return FALSE; return FALSE;
} }
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
return TRUE; return TRUE;
} }
static GstFlowReturn static GstFlowReturn
gst_gtk_base_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf) gst_clapper_gl_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
{ {
GstGtkBaseSink *gtk_sink; GstClapperGLSink *clapper_sink;
GST_TRACE ("rendering buffer:%p", buf); GST_TRACE ("rendering buffer:%p", buf);
gtk_sink = GST_GTK_BASE_SINK (vsink); clapper_sink = GST_CLAPPER_GL_SINK (vsink);
GST_OBJECT_LOCK (gtk_sink); GST_OBJECT_LOCK (clapper_sink);
if (gtk_sink->widget == NULL) { if (clapper_sink->widget == NULL) {
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
GST_ELEMENT_ERROR (gtk_sink, RESOURCE, NOT_FOUND, GST_ELEMENT_ERROR (clapper_sink, RESOURCE, NOT_FOUND,
("%s", "Output widget was destroyed"), (NULL)); ("%s", "Output widget was destroyed"), (NULL));
return GST_FLOW_ERROR; return GST_FLOW_ERROR;
} }
gtk_gst_base_widget_set_buffer (gtk_sink->widget, buf); gtk_clapper_gl_widget_set_buffer (clapper_sink->widget, buf);
GST_OBJECT_UNLOCK (gtk_sink); GST_OBJECT_UNLOCK (clapper_sink);
return GST_FLOW_OK; return GST_FLOW_OK;
} }

106
lib/gst/clapper/gtk4/gstclapperglsink.h Normal file
View File

@@ -0,0 +1,106 @@
/*
* GStreamer
* Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
* Copyright (C) 2020 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.
*/
#ifndef __GST_CLAPPER_GL_SINK_H__
#define __GST_CLAPPER_GL_SINK_H__
#include <gtk/gtk.h>
#include <gst/gst.h>
#include <gst/video/gstvideosink.h>
#include <gst/video/video.h>
#include <gst/gl/gl.h>
#include "gtkclapperglwidget.h"
#define GST_TYPE_CLAPPER_GL_SINK (gst_clapper_gl_sink_get_type())
#define GST_CLAPPER_GL_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CLAPPER_GL_SINK,GstClapperGLSink))
#define GST_CLAPPER_GL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CLAPPER_GL_SINK,GstClapperGLClass))
#define GST_CLAPPER_GL_SINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_CLAPPER_GL_SINK, GstClapperGLSinkClass))
#define GST_IS_CLAPPER_GL_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CLAPPER_GL_SINK))
#define GST_IS_CLAPPER_GL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CLAPPER_GL_SINK))
#define GST_CLAPPER_GL_SINK_CAST(obj) ((GstClapperGLSink*)(obj))
G_BEGIN_DECLS
typedef struct _GstClapperGLSink GstClapperGLSink;
typedef struct _GstClapperGLSinkClass GstClapperGLSinkClass;
GType gst_clapper_gl_sink_get_type (void);
/**
* GstClapperGLSink:
*
* Opaque #GstClapperGLSink object
*/
struct _GstClapperGLSink
{
/* <private> */
GstVideoSink parent;
GstVideoInfo v_info;
GtkClapperGLWidget *widget;
/* properties */
gboolean force_aspect_ratio;
GBinding *bind_aspect_ratio;
gint par_n, par_d;
GBinding *bind_pixel_aspect_ratio;
gboolean ignore_textures;
GBinding *bind_ignore_textures;
GtkWidget *window;
gulong widget_destroy_id;
gulong window_destroy_id;
GstGLDisplay *display;
GstGLContext *context;
GstGLContext *gtk_context;
GstGLUpload *upload;
GstBuffer *uploaded_buffer;
/* read/write with object lock */
gint display_width, display_height;
};
/**
* GstClapperGLSinkClass:
*
* The #GstClapperGLSinkClass struct only contains private data
*/
struct _GstClapperGLSinkClass
{
GstVideoSinkClass object_class;
/* metadata */
const gchar *window_title;
/* virtuals */
GtkWidget* (*create_widget) (void);
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GstClapperGLSink, gst_object_unref)
G_END_DECLS
#endif /* __GST_CLAPPER_GL_SINK_H__ */

107
lib/gst/clapper/gtk4/gstgtkbasesink.h
View File

@@ -1,107 +0,0 @@
/*
* GStreamer
* Copyright (C) 2015 Matthew Waters <matthew@centricular.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.
*/
#ifndef __GST_GTK_BASE_SINK_H__
#define __GST_GTK_BASE_SINK_H__
#include <gtk/gtk.h>
#include <gst/gst.h>
#include <gst/video/gstvideosink.h>
#include <gst/video/video.h>
#include <gst/gl/gl.h>
#include "gtkgstbasewidget.h"
#define GST_TYPE_GTK_BASE_SINK (gst_gtk_base_sink_get_type())
#define GST_GTK_BASE_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GTK_BASE_SINK,GstGtkBaseSink))
#define GST_GTK_BASE_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GTK_BASE_SINK,GstGtkBaseSinkClass))
#define GST_GTK_BASE_SINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_GTK_BASE_SINK, GstGtkBaseSinkClass))
#define GST_IS_GTK_BASE_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GTK_BASE_SINK))
#define GST_IS_GTK_BASE_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GTK_BASE_SINK))
#define GST_GTK_BASE_SINK_CAST(obj) ((GstGtkBaseSink*)(obj))
G_BEGIN_DECLS
typedef struct _GstGtkBaseSink GstGtkBaseSink;
typedef struct _GstGtkBaseSinkClass GstGtkBaseSinkClass;
GType gst_gtk_base_sink_get_type (void);
/**
* GstGtkBaseSink:
*
* Opaque #GstGtkBaseSink object
*/
struct _GstGtkBaseSink
{
/* <private> */
GstVideoSink parent;
GstVideoInfo v_info;
GtkGstBaseWidget *widget;
/* properties */
gboolean force_aspect_ratio;
GBinding *bind_aspect_ratio;
gint par_n;
gint par_d;
GBinding *bind_pixel_aspect_ratio;
gboolean ignore_textures;
GBinding *bind_ignore_textures;
GtkWidget *window;
gulong widget_destroy_id;
gulong window_destroy_id;
GstGLDisplay *display;
GstGLContext *context;
GstGLContext *gtk_context;
GstGLUpload *upload;
GstBuffer *uploaded_buffer;
/* read/write with object lock */
gint display_width;
gint display_height;
};
/**
* GstGtkBaseSinkClass:
*
* The #GstGtkBaseSinkClass struct only contains private data
*/
struct _GstGtkBaseSinkClass
{
GstVideoSinkClass object_class;
/* metadata */
const gchar *window_title;
/* virtuals */
GtkWidget* (*create_widget) (void);
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GstGtkBaseSink, gst_object_unref)
G_END_DECLS
#endif /* __GST_GTK_BASE_SINK_H__ */

457
lib/gst/clapper/gtk4/gtkgstbasewidget.c → lib/gst/clapper/gtk4/gtkclapperglwidget.c
View File

@@ -27,7 +27,7 @@
#include <gst/gl/gstglfuncs.h> #include <gst/gl/gstglfuncs.h>
#include <gst/video/video.h> #include <gst/video/video.h>
#include "gtkgstbasewidget.h" #include "gtkclapperglwidget.h"
#include "gstgtkutils.h" #include "gstgtkutils.h"
#if GST_GL_HAVE_WINDOW_X11 && defined (GDK_WINDOWING_X11) #if GST_GL_HAVE_WINDOW_X11 && defined (GDK_WINDOWING_X11)
@@ -41,23 +41,23 @@
#endif #endif
/** /**
* SECTION:gtkgstbasewidget * SECTION:gtkclapperglwidget
* @title: GtkGstBaseWidget * @title: GtkClapperGLWidget
* @short_description: a #GtkGLArea that renders GStreamer video #GstBuffers * @short_description: a #GtkGLArea that renders GStreamer video #GstBuffers
* @see_also: #GtkGLArea, #GstBuffer * @see_also: #GtkGLArea, #GstBuffer
* *
* #GtkGstBaseWidget is an #GtkWidget that renders GStreamer video buffers. * #GtkClapperGLWidget is a #GtkWidget that renders GStreamer video buffers.
*/ */
GST_DEBUG_CATEGORY (gst_debug_gtk_base_widget); GST_DEBUG_CATEGORY (gst_debug_clapper_gl_widget);
#define GST_CAT_DEFAULT gst_debug_gtk_base_widget #define GST_CAT_DEFAULT gst_debug_clapper_gl_widget
#define DEFAULT_FORCE_ASPECT_RATIO TRUE #define DEFAULT_FORCE_ASPECT_RATIO TRUE
#define DEFAULT_PAR_N 0 #define DEFAULT_PAR_N 0
#define DEFAULT_PAR_D 1 #define DEFAULT_PAR_D 1
#define DEFAULT_IGNORE_TEXTURES FALSE #define DEFAULT_IGNORE_TEXTURES FALSE
struct _GtkGstBaseWidgetPrivate struct _GtkClapperGLWidgetPrivate
{ {
gboolean initiated; gboolean initiated;
GstGLDisplay *display; GstGLDisplay *display;
@@ -85,10 +85,10 @@ static const GLushort indices[] = {
0, 1, 2, 0, 2, 3 0, 1, 2, 0, 2, 3
}; };
G_DEFINE_TYPE_WITH_CODE (GtkGstBaseWidget, gtk_gst_base_widget, GTK_TYPE_GL_AREA, G_DEFINE_TYPE_WITH_CODE (GtkClapperGLWidget, gtk_clapper_gl_widget, GTK_TYPE_GL_AREA,
G_ADD_PRIVATE (GtkGstBaseWidget) G_ADD_PRIVATE (GtkClapperGLWidget)
GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "gtkgstbasewidget", 0, GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "gtkclapperglwidget", 0,
"GTK Gst Base Widget")); "GTK Clapper GL Widget"));
enum enum
{ {
@@ -99,13 +99,13 @@ enum
}; };
static void static void
gtk_gst_base_widget_get_preferred_width (GtkWidget * widget, gint * min, gtk_clapper_gl_widget_get_preferred_width (GtkWidget * widget, gint * min,
gint * natural) gint * natural)
{ {
GtkGstBaseWidget *base_widget = (GtkGstBaseWidget *) widget; GtkClapperGLWidget *clapper_widget = (GtkClapperGLWidget *) widget;
gint video_width = base_widget->display_width; gint video_width = clapper_widget->display_width;
if (!base_widget->negotiated) if (!clapper_widget->negotiated)
video_width = 10; video_width = 10;
if (min) if (min)
@@ -115,13 +115,13 @@ gtk_gst_base_widget_get_preferred_width (GtkWidget * widget, gint * min,
} }
static void static void
gtk_gst_base_widget_get_preferred_height (GtkWidget * widget, gint * min, gtk_clapper_gl_widget_get_preferred_height (GtkWidget * widget, gint * min,
gint * natural) gint * natural)
{ {
GtkGstBaseWidget *base_widget = (GtkGstBaseWidget *) widget; GtkClapperGLWidget *clapper_widget = (GtkClapperGLWidget *) widget;
gint video_height = base_widget->display_height; gint video_height = clapper_widget->display_height;
if (!base_widget->negotiated) if (!clapper_widget->negotiated)
video_height = 10; video_height = 10;
if (min) if (min)
@@ -131,52 +131,52 @@ gtk_gst_base_widget_get_preferred_height (GtkWidget * widget, gint * min,
} }
static void static void
gtk_gst_base_widget_measure (GtkWidget * widget, GtkOrientation orientation, gtk_clapper_gl_widget_measure (GtkWidget * widget, GtkOrientation orientation,
gint for_size, gint * min, gint * natural, gint for_size, gint * min, gint * natural,
gint * minimum_baseline, gint * natural_baseline) gint * minimum_baseline, gint * natural_baseline)
{ {
if (orientation == GTK_ORIENTATION_HORIZONTAL) if (orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_gst_base_widget_get_preferred_width (widget, min, natural); gtk_clapper_gl_widget_get_preferred_width (widget, min, natural);
else else
gtk_gst_base_widget_get_preferred_height (widget, min, natural); gtk_clapper_gl_widget_get_preferred_height (widget, min, natural);
*minimum_baseline = -1; *minimum_baseline = -1;
*natural_baseline = -1; *natural_baseline = -1;
} }
static void static void
gtk_gst_base_widget_size_allocate (GtkWidget * widget, gtk_clapper_gl_widget_size_allocate (GtkWidget * widget,
gint width, gint height, gint baseline) gint width, gint height, gint baseline)
{ {
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (widget);
gint scale_factor = gtk_widget_get_scale_factor (widget); gint scale_factor = gtk_widget_get_scale_factor (widget);
GTK_GST_BASE_WIDGET_LOCK (base_widget); GTK_CLAPPER_GL_WIDGET_LOCK (clapper_widget);
base_widget->scaled_width = width * scale_factor; clapper_widget->scaled_width = width * scale_factor;
base_widget->scaled_height = height * scale_factor; clapper_widget->scaled_height = height * scale_factor;
GTK_GST_BASE_WIDGET_UNLOCK (base_widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
gtk_gl_area_queue_render (GTK_GL_AREA (widget)); gtk_gl_area_queue_render (GTK_GL_AREA (widget));
} }
static void static void
gtk_gst_base_widget_set_property (GObject * object, guint prop_id, gtk_clapper_gl_widget_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
{ {
GtkGstBaseWidget *gtk_widget = GTK_GST_BASE_WIDGET (object); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (object);
switch (prop_id) { switch (prop_id) {
case PROP_FORCE_ASPECT_RATIO: case PROP_FORCE_ASPECT_RATIO:
gtk_widget->force_aspect_ratio = g_value_get_boolean (value); clapper_widget->force_aspect_ratio = g_value_get_boolean (value);
break; break;
case PROP_PIXEL_ASPECT_RATIO: case PROP_PIXEL_ASPECT_RATIO:
gtk_widget->par_n = gst_value_get_fraction_numerator (value); clapper_widget->par_n = gst_value_get_fraction_numerator (value);
gtk_widget->par_d = gst_value_get_fraction_denominator (value); clapper_widget->par_d = gst_value_get_fraction_denominator (value);
break; break;
case PROP_IGNORE_TEXTURES: case PROP_IGNORE_TEXTURES:
gtk_widget->ignore_textures = g_value_get_boolean (value); clapper_widget->ignore_textures = g_value_get_boolean (value);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -185,20 +185,20 @@ gtk_gst_base_widget_set_property (GObject * object, guint prop_id,
} }
static void static void
gtk_gst_base_widget_get_property (GObject * object, guint prop_id, gtk_clapper_gl_widget_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GtkGstBaseWidget *gtk_widget = GTK_GST_BASE_WIDGET (object); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (object);
switch (prop_id) { switch (prop_id) {
case PROP_FORCE_ASPECT_RATIO: case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, gtk_widget->force_aspect_ratio); g_value_set_boolean (value, clapper_widget->force_aspect_ratio);
break; break;
case PROP_PIXEL_ASPECT_RATIO: case PROP_PIXEL_ASPECT_RATIO:
gst_value_set_fraction (value, gtk_widget->par_n, gtk_widget->par_d); gst_value_set_fraction (value, clapper_widget->par_n, clapper_widget->par_d);
break; break;
case PROP_IGNORE_TEXTURES: case PROP_IGNORE_TEXTURES:
g_value_set_boolean (value, gtk_widget->ignore_textures); g_value_set_boolean (value, clapper_widget->ignore_textures);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -207,7 +207,7 @@ gtk_gst_base_widget_get_property (GObject * object, guint prop_id,
} }
static gboolean static gboolean
_calculate_par (GtkGstBaseWidget * widget, GstVideoInfo * info) _calculate_par (GtkClapperGLWidget * clapper_widget, GstVideoInfo * info)
{ {
gboolean ok; gboolean ok;
gint width, height; gint width, height;
@@ -224,16 +224,16 @@ _calculate_par (GtkGstBaseWidget * widget, GstVideoInfo * info)
par_n = 1; par_n = 1;
/* get display's PAR */ /* get display's PAR */
if (widget->par_n != 0 && widget->par_d != 0) { if (clapper_widget->par_n != 0 && clapper_widget->par_d != 0) {
display_par_n = widget->par_n; display_par_n = clapper_widget->par_n;
display_par_d = widget->par_d; display_par_d = clapper_widget->par_d;
} else { } else {
display_par_n = 1; display_par_n = 1;
display_par_d = 1; display_par_d = 1;
} }
ok = gst_video_calculate_display_ratio (&widget->display_ratio_num, ok = gst_video_calculate_display_ratio (&clapper_widget->display_ratio_num,
&widget->display_ratio_den, width, height, par_n, par_d, display_par_n, &clapper_widget->display_ratio_den, width, height, par_n, par_d, display_par_n,
display_par_d); display_par_d);
if (ok) { if (ok) {
@@ -246,59 +246,59 @@ _calculate_par (GtkGstBaseWidget * widget, GstVideoInfo * info)
} }
static void static void
_apply_par (GtkGstBaseWidget * widget) _apply_par (GtkClapperGLWidget * clapper_widget)
{ {
guint display_ratio_num, display_ratio_den; guint display_ratio_num, display_ratio_den;
gint width, height; gint width, height;
width = GST_VIDEO_INFO_WIDTH (&widget->v_info); width = GST_VIDEO_INFO_WIDTH (&clapper_widget->v_info);
height = GST_VIDEO_INFO_HEIGHT (&widget->v_info); height = GST_VIDEO_INFO_HEIGHT (&clapper_widget->v_info);
display_ratio_num = widget->display_ratio_num; display_ratio_num = clapper_widget->display_ratio_num;
display_ratio_den = widget->display_ratio_den; display_ratio_den = clapper_widget->display_ratio_den;
if (height % display_ratio_den == 0) { if (height % display_ratio_den == 0) {
GST_DEBUG ("keeping video height"); GST_DEBUG ("keeping video height");
widget->display_width = (guint) clapper_widget->display_width = (guint)
gst_util_uint64_scale_int (height, display_ratio_num, gst_util_uint64_scale_int (height, display_ratio_num,
display_ratio_den); display_ratio_den);
widget->display_height = height; clapper_widget->display_height = height;
} else if (width % display_ratio_num == 0) { } else if (width % display_ratio_num == 0) {
GST_DEBUG ("keeping video width"); GST_DEBUG ("keeping video width");
widget->display_width = width; clapper_widget->display_width = width;
widget->display_height = (guint) clapper_widget->display_height = (guint)
gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num); gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num);
} else { } else {
GST_DEBUG ("approximating while keeping video height"); GST_DEBUG ("approximating while keeping video height");
widget->display_width = (guint) clapper_widget->display_width = (guint)
gst_util_uint64_scale_int (height, display_ratio_num, gst_util_uint64_scale_int (height, display_ratio_num,
display_ratio_den); display_ratio_den);
widget->display_height = height; clapper_widget->display_height = height;
} }
GST_DEBUG ("scaling to %dx%d", widget->display_width, widget->display_height); GST_DEBUG ("scaling to %dx%d", clapper_widget->display_width, clapper_widget->display_height);
} }
static gboolean static gboolean
_queue_draw (GtkGstBaseWidget * widget) _queue_draw (GtkClapperGLWidget * clapper_widget)
{ {
GTK_GST_BASE_WIDGET_LOCK (widget); GTK_CLAPPER_GL_WIDGET_LOCK (clapper_widget);
widget->draw_id = 0; clapper_widget->draw_id = 0;
if (widget->pending_resize) { if (clapper_widget->pending_resize) {
widget->pending_resize = FALSE; clapper_widget->pending_resize = FALSE;
widget->v_info = widget->pending_v_info; clapper_widget->v_info = clapper_widget->pending_v_info;
widget->negotiated = TRUE; clapper_widget->negotiated = TRUE;
_apply_par (widget); _apply_par (clapper_widget);
gtk_widget_queue_resize (GTK_WIDGET (widget)); gtk_widget_queue_resize (GTK_WIDGET (clapper_widget));
} else { } else {
gtk_gl_area_queue_render (GTK_GL_AREA (widget)); gtk_gl_area_queue_render (GTK_GL_AREA (clapper_widget));
} }
GTK_GST_BASE_WIDGET_UNLOCK (widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return G_SOURCE_REMOVE; return G_SOURCE_REMOVE;
} }
@@ -322,15 +322,15 @@ _gdk_key_to_navigation_string (guint keyval)
} }
static gboolean static gboolean
gtk_gst_base_widget_key_event (GtkEventControllerKey * key_controller, gtk_clapper_gl_widget_key_event (GtkEventControllerKey * key_controller,
guint keyval, guint keycode, GdkModifierType state) guint keyval, guint keycode, GdkModifierType state)
{ {
GtkEventController *controller = GTK_EVENT_CONTROLLER (key_controller); GtkEventController *controller = GTK_EVENT_CONTROLLER (key_controller);
GtkWidget *widget = gtk_event_controller_get_widget (controller); GtkWidget *widget = gtk_event_controller_get_widget (controller);
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (widget);
GstElement *element; GstElement *element;
if ((element = g_weak_ref_get (&base_widget->element))) { if ((element = g_weak_ref_get (&clapper_widget->element))) {
if (GST_IS_NAVIGATION (element)) { if (GST_IS_NAVIGATION (element)) {
GdkEvent *event = gtk_event_controller_get_current_event (controller); GdkEvent *event = gtk_event_controller_get_current_event (controller);
const gchar *str = _gdk_key_to_navigation_string (keyval); const gchar *str = _gdk_key_to_navigation_string (keyval);
@@ -349,41 +349,41 @@ gtk_gst_base_widget_key_event (GtkEventControllerKey * key_controller,
} }
static void static void
_fit_stream_to_allocated_size (GtkGstBaseWidget * base_widget, GstVideoRectangle * result) _fit_stream_to_allocated_size (GtkClapperGLWidget * clapper_widget, GstVideoRectangle * result)
{ {
if (base_widget->force_aspect_ratio) { if (clapper_widget->force_aspect_ratio) {
GstVideoRectangle src, dst; GstVideoRectangle src, dst;
src.x = 0; src.x = 0;
src.y = 0; src.y = 0;
src.w = base_widget->display_width; src.w = clapper_widget->display_width;
src.h = base_widget->display_height; src.h = clapper_widget->display_height;
dst.x = 0; dst.x = 0;
dst.y = 0; dst.y = 0;
dst.w = base_widget->scaled_width; dst.w = clapper_widget->scaled_width;
dst.h = base_widget->scaled_height; dst.h = clapper_widget->scaled_height;
gst_video_sink_center_rect (src, dst, result, TRUE); gst_video_sink_center_rect (src, dst, result, TRUE);
} else { } else {
result->x = 0; result->x = 0;
result->y = 0; result->y = 0;
result->w = base_widget->scaled_width; result->w = clapper_widget->scaled_width;
result->h = base_widget->scaled_height; result->h = clapper_widget->scaled_height;
} }
} }
static void static void
_display_size_to_stream_size (GtkGstBaseWidget * base_widget, gdouble x, _display_size_to_stream_size (GtkClapperGLWidget * clapper_widget, gdouble x,
gdouble y, gdouble * stream_x, gdouble * stream_y) gdouble y, gdouble * stream_x, gdouble * stream_y)
{ {
gdouble stream_width, stream_height; gdouble stream_width, stream_height;
GstVideoRectangle result; GstVideoRectangle result;
_fit_stream_to_allocated_size (base_widget, &result); _fit_stream_to_allocated_size (clapper_widget, &result);
stream_width = (gdouble) GST_VIDEO_INFO_WIDTH (&base_widget->v_info); stream_width = (gdouble) GST_VIDEO_INFO_WIDTH (&clapper_widget->v_info);
stream_height = (gdouble) GST_VIDEO_INFO_HEIGHT (&base_widget->v_info); stream_height = (gdouble) GST_VIDEO_INFO_HEIGHT (&clapper_widget->v_info);
/* from display coordinates to stream coordinates */ /* from display coordinates to stream coordinates */
if (result.w > 0) if (result.w > 0)
@@ -394,8 +394,8 @@ _display_size_to_stream_size (GtkGstBaseWidget * base_widget, gdouble x,
/* clip to stream size */ /* clip to stream size */
if (*stream_x < 0.) if (*stream_x < 0.)
*stream_x = 0.; *stream_x = 0.;
if (*stream_x > GST_VIDEO_INFO_WIDTH (&base_widget->v_info)) if (*stream_x > GST_VIDEO_INFO_WIDTH (&clapper_widget->v_info))
*stream_x = GST_VIDEO_INFO_WIDTH (&base_widget->v_info); *stream_x = GST_VIDEO_INFO_WIDTH (&clapper_widget->v_info);
/* same for y-axis */ /* same for y-axis */
if (result.h > 0) if (result.h > 0)
@@ -405,22 +405,22 @@ _display_size_to_stream_size (GtkGstBaseWidget * base_widget, gdouble x,
if (*stream_y < 0.) if (*stream_y < 0.)
*stream_y = 0.; *stream_y = 0.;
if (*stream_y > GST_VIDEO_INFO_HEIGHT (&base_widget->v_info)) if (*stream_y > GST_VIDEO_INFO_HEIGHT (&clapper_widget->v_info))
*stream_y = GST_VIDEO_INFO_HEIGHT (&base_widget->v_info); *stream_y = GST_VIDEO_INFO_HEIGHT (&clapper_widget->v_info);
GST_TRACE ("transform %fx%f into %fx%f", x, y, *stream_x, *stream_y); GST_TRACE ("transform %fx%f into %fx%f", x, y, *stream_x, *stream_y);
} }
static gboolean static gboolean
gtk_gst_base_widget_button_event (GtkGestureClick * gesture, gtk_clapper_gl_widget_button_event (GtkGestureClick * gesture,
gint n_press, gdouble x, gdouble y) gint n_press, gdouble x, gdouble y)
{ {
GtkEventController *controller = GTK_EVENT_CONTROLLER (gesture); GtkEventController *controller = GTK_EVENT_CONTROLLER (gesture);
GtkWidget *widget = gtk_event_controller_get_widget (controller); GtkWidget *widget = gtk_event_controller_get_widget (controller);
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (widget);
GstElement *element; GstElement *element;
if ((element = g_weak_ref_get (&base_widget->element))) { if ((element = g_weak_ref_get (&clapper_widget->element))) {
if (GST_IS_NAVIGATION (element)) { if (GST_IS_NAVIGATION (element)) {
GdkEvent *event = gtk_event_controller_get_current_event (controller); GdkEvent *event = gtk_event_controller_get_current_event (controller);
const gchar *key_type = const gchar *key_type =
@@ -428,7 +428,7 @@ gtk_gst_base_widget_button_event (GtkGestureClick * gesture,
? "mouse-button-press" : "mouse-button-release"; ? "mouse-button-press" : "mouse-button-release";
gdouble stream_x, stream_y; gdouble stream_x, stream_y;
_display_size_to_stream_size (base_widget, x, y, &stream_x, &stream_y); _display_size_to_stream_size (clapper_widget, x, y, &stream_x, &stream_y);
gst_navigation_send_mouse_event (GST_NAVIGATION (element), key_type, gst_navigation_send_mouse_event (GST_NAVIGATION (element), key_type,
/* Gesture is set to ignore other buttons so we do not have to check */ /* Gesture is set to ignore other buttons so we do not have to check */
@@ -442,19 +442,19 @@ gtk_gst_base_widget_button_event (GtkGestureClick * gesture,
} }
static gboolean static gboolean
gtk_gst_base_widget_motion_event (GtkEventControllerMotion * motion_controller, gtk_clapper_gl_widget_motion_event (GtkEventControllerMotion * motion_controller,
gdouble x, gdouble y) gdouble x, gdouble y)
{ {
GtkEventController *controller = GTK_EVENT_CONTROLLER (motion_controller); GtkEventController *controller = GTK_EVENT_CONTROLLER (motion_controller);
GtkWidget *widget = gtk_event_controller_get_widget (controller); GtkWidget *widget = gtk_event_controller_get_widget (controller);
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (widget);
GstElement *element; GstElement *element;
if ((element = g_weak_ref_get (&base_widget->element))) { if ((element = g_weak_ref_get (&clapper_widget->element))) {
if (GST_IS_NAVIGATION (element)) { if (GST_IS_NAVIGATION (element)) {
gdouble stream_x, stream_y; gdouble stream_x, stream_y;
_display_size_to_stream_size (base_widget, x, y, &stream_x, &stream_y); _display_size_to_stream_size (clapper_widget, x, y, &stream_x, &stream_y);
gst_navigation_send_mouse_event (GST_NAVIGATION (element), "mouse-move", gst_navigation_send_mouse_event (GST_NAVIGATION (element), "mouse-move",
0, stream_x, stream_y); 0, stream_x, stream_y);
@@ -466,9 +466,9 @@ gtk_gst_base_widget_motion_event (GtkEventControllerMotion * motion_controller,
} }
static void static void
gtk_gst_base_widget_bind_buffer (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_bind_buffer (GtkClapperGLWidget * clapper_widget)
{ {
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
const GstGLFuncs *gl = priv->context->gl_vtable; const GstGLFuncs *gl = priv->context->gl_vtable;
gl->BindBuffer (GL_ARRAY_BUFFER, priv->vertex_buffer); gl->BindBuffer (GL_ARRAY_BUFFER, priv->vertex_buffer);
@@ -486,9 +486,9 @@ gtk_gst_base_widget_bind_buffer (GtkGstBaseWidget * base_widget)
} }
static void static void
gtk_gst_base_widget_unbind_buffer (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_unbind_buffer (GtkClapperGLWidget * clapper_widget)
{ {
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
const GstGLFuncs *gl = priv->context->gl_vtable; const GstGLFuncs *gl = priv->context->gl_vtable;
gl->BindBuffer (GL_ARRAY_BUFFER, 0); gl->BindBuffer (GL_ARRAY_BUFFER, 0);
@@ -498,9 +498,9 @@ gtk_gst_base_widget_unbind_buffer (GtkGstBaseWidget * base_widget)
} }
static void static void
gtk_gst_base_widget_init_redisplay (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_init_redisplay (GtkClapperGLWidget * clapper_widget)
{ {
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
const GstGLFuncs *gl = priv->context->gl_vtable; const GstGLFuncs *gl = priv->context->gl_vtable;
GError *error = NULL; GError *error = NULL;
@@ -526,7 +526,7 @@ gtk_gst_base_widget_init_redisplay (GtkGstBaseWidget * base_widget)
GL_STATIC_DRAW); GL_STATIC_DRAW);
if (gl->GenVertexArrays) { if (gl->GenVertexArrays) {
gtk_gst_base_widget_bind_buffer (base_widget); gtk_clapper_gl_widget_bind_buffer (clapper_widget);
gl->BindVertexArray (0); gl->BindVertexArray (0);
} }
@@ -557,39 +557,39 @@ _draw_black_with_gdk (GdkGLContext * gdk_context)
} }
static gboolean static gboolean
gtk_gst_base_widget_render (GtkGLArea * widget, GdkGLContext * context) gtk_clapper_gl_widget_render (GtkGLArea * widget, GdkGLContext * context)
{ {
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (widget);
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
const GstGLFuncs *gl; const GstGLFuncs *gl;
GTK_GST_BASE_WIDGET_LOCK (widget); GTK_CLAPPER_GL_WIDGET_LOCK (widget);
/* Draw black with GDK context when priv is not available yet. /* Draw black with GDK context when priv is not available yet.
GTK calls render with GDK context already active. */ GTK calls render with GDK context already active. */
if (!priv->context || !priv->other_context || base_widget->ignore_textures) { if (!priv->context || !priv->other_context || clapper_widget->ignore_textures) {
_draw_black_with_gdk (context); _draw_black_with_gdk (context);
goto done; goto done;
} }
gst_gl_context_activate (priv->other_context, TRUE); gst_gl_context_activate (priv->other_context, TRUE);
if (!priv->initiated || !base_widget->negotiated) { if (!priv->initiated || !clapper_widget->negotiated) {
if (!priv->initiated) if (!priv->initiated)
gtk_gst_base_widget_init_redisplay (base_widget); gtk_clapper_gl_widget_init_redisplay (clapper_widget);
_draw_black (priv->other_context); _draw_black (priv->other_context);
goto done; goto done;
} }
/* Upload latest buffer */ /* Upload latest buffer */
if (base_widget->pending_buffer) { if (clapper_widget->pending_buffer) {
GstBuffer *buffer = base_widget->pending_buffer; GstBuffer *buffer = clapper_widget->pending_buffer;
GstVideoFrame gl_frame; GstVideoFrame gl_frame;
GstGLSyncMeta *sync_meta; GstGLSyncMeta *sync_meta;
if (!gst_video_frame_map (&gl_frame, &base_widget->v_info, buffer, if (!gst_video_frame_map (&gl_frame, &clapper_widget->v_info, buffer,
GST_MAP_READ | GST_MAP_GL)) { GST_MAP_READ | GST_MAP_GL)) {
_draw_black (priv->other_context); _draw_black (priv->other_context);
goto done; goto done;
@@ -608,21 +608,21 @@ gtk_gst_base_widget_render (GtkGLArea * widget, GdkGLContext * context)
gst_video_frame_unmap (&gl_frame); gst_video_frame_unmap (&gl_frame);
if (base_widget->buffer) if (clapper_widget->buffer)
gst_buffer_unref (base_widget->buffer); gst_buffer_unref (clapper_widget->buffer);
/* Keep the buffer to ensure current_tex stay valid */ /* Keep the buffer to ensure current_tex stay valid */
base_widget->buffer = buffer; clapper_widget->buffer = buffer;
base_widget->pending_buffer = NULL; clapper_widget->pending_buffer = NULL;
} }
GST_DEBUG ("rendering buffer %p with gdk context %p", GST_DEBUG ("rendering buffer %p with gdk context %p",
base_widget->buffer, context); clapper_widget->buffer, context);
/* Draw texture */ /* Draw texture */
gl = priv->context->gl_vtable; gl = priv->context->gl_vtable;
if (base_widget->force_aspect_ratio) { if (clapper_widget->force_aspect_ratio) {
GstVideoRectangle src, dst, result; GstVideoRectangle src, dst, result;
gl->ClearColor (0.0, 0.0, 0.0, 1.0); gl->ClearColor (0.0, 0.0, 0.0, 1.0);
@@ -630,13 +630,13 @@ gtk_gst_base_widget_render (GtkGLArea * widget, GdkGLContext * context)
src.x = 0; src.x = 0;
src.y = 0; src.y = 0;
src.w = base_widget->display_width; src.w = clapper_widget->display_width;
src.h = base_widget->display_height; src.h = clapper_widget->display_height;
dst.x = 0; dst.x = 0;
dst.y = 0; dst.y = 0;
dst.w = base_widget->scaled_width; dst.w = clapper_widget->scaled_width;
dst.h = base_widget->scaled_height; dst.h = clapper_widget->scaled_height;
gst_video_sink_center_rect (src, dst, &result, TRUE); gst_video_sink_center_rect (src, dst, &result, TRUE);
@@ -648,7 +648,7 @@ gtk_gst_base_widget_render (GtkGLArea * widget, GdkGLContext * context)
if (gl->BindVertexArray) if (gl->BindVertexArray)
gl->BindVertexArray (priv->vao); gl->BindVertexArray (priv->vao);
gtk_gst_base_widget_bind_buffer (base_widget); gtk_clapper_gl_widget_bind_buffer (clapper_widget);
gl->ActiveTexture (GL_TEXTURE0); gl->ActiveTexture (GL_TEXTURE0);
gl->BindTexture (GL_TEXTURE_2D, priv->current_tex); gl->BindTexture (GL_TEXTURE_2D, priv->current_tex);
@@ -659,7 +659,7 @@ gtk_gst_base_widget_render (GtkGLArea * widget, GdkGLContext * context)
if (gl->BindVertexArray) if (gl->BindVertexArray)
gl->BindVertexArray (0); gl->BindVertexArray (0);
else else
gtk_gst_base_widget_unbind_buffer (base_widget); gtk_clapper_gl_widget_unbind_buffer (clapper_widget);
gl->BindTexture (GL_TEXTURE_2D, 0); gl->BindTexture (GL_TEXTURE_2D, 0);
@@ -670,18 +670,18 @@ done:
if (priv->other_context) if (priv->other_context)
gst_gl_context_activate (priv->other_context, FALSE); gst_gl_context_activate (priv->other_context, FALSE);
GTK_GST_BASE_WIDGET_UNLOCK (widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (widget);
return FALSE; return FALSE;
} }
static void static void
_reset_gl (GtkGstBaseWidget * base_widget) _reset_gl (GtkClapperGLWidget * clapper_widget)
{ {
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
const GstGLFuncs *gl = priv->other_context->gl_vtable; const GstGLFuncs *gl = priv->other_context->gl_vtable;
if (!priv->gdk_context) if (!priv->gdk_context)
priv->gdk_context = gtk_gl_area_get_context (GTK_GL_AREA (base_widget)); priv->gdk_context = gtk_gl_area_get_context (GTK_GL_AREA (clapper_widget));
if (priv->gdk_context == NULL) if (priv->gdk_context == NULL)
return; return;
@@ -724,13 +724,13 @@ _reset_gl (GtkGstBaseWidget * base_widget)
} }
static void static void
gtk_gst_base_widget_finalize (GObject * object) gtk_clapper_gl_widget_finalize (GObject * object)
{ {
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (object); GtkClapperGLWidget *clapper_widget = GTK_CLAPPER_GL_WIDGET (object);
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
if (priv->other_context) if (priv->other_context)
gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) _reset_gl, base_widget); gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) _reset_gl, clapper_widget);
if (priv->context) if (priv->context)
gst_object_unref (priv->context); gst_object_unref (priv->context);
@@ -738,75 +738,75 @@ gtk_gst_base_widget_finalize (GObject * object)
if (priv->display) if (priv->display)
gst_object_unref (priv->display); gst_object_unref (priv->display);
if (base_widget->draw_id) if (clapper_widget->draw_id)
g_source_remove (base_widget->draw_id); g_source_remove (clapper_widget->draw_id);
gst_buffer_replace (&base_widget->pending_buffer, NULL); gst_buffer_replace (&clapper_widget->pending_buffer, NULL);
gst_buffer_replace (&base_widget->buffer, NULL); gst_buffer_replace (&clapper_widget->buffer, NULL);
g_mutex_clear (&base_widget->lock); g_mutex_clear (&clapper_widget->lock);
g_weak_ref_clear (&base_widget->element); g_weak_ref_clear (&clapper_widget->element);
G_OBJECT_CLASS (gtk_gst_base_widget_parent_class)->finalize (object); G_OBJECT_CLASS (gtk_clapper_gl_widget_parent_class)->finalize (object);
} }
void void
gtk_gst_base_widget_set_element (GtkGstBaseWidget * widget, gtk_clapper_gl_widget_set_element (GtkClapperGLWidget * clapper_widget,
GstElement * element) GstElement * element)
{ {
g_weak_ref_set (&widget->element, element); g_weak_ref_set (&clapper_widget->element, element);
} }
gboolean gboolean
gtk_gst_base_widget_set_format (GtkGstBaseWidget * widget, gtk_clapper_gl_widget_set_format (GtkClapperGLWidget * clapper_widget,
GstVideoInfo * v_info) GstVideoInfo * v_info)
{ {
GTK_GST_BASE_WIDGET_LOCK (widget); GTK_CLAPPER_GL_WIDGET_LOCK (clapper_widget);
if (gst_video_info_is_equal (&widget->pending_v_info, v_info)) { if (gst_video_info_is_equal (&clapper_widget->pending_v_info, v_info)) {
GTK_GST_BASE_WIDGET_UNLOCK (widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return TRUE; return TRUE;
} }
if (!_calculate_par (widget, v_info)) { if (!_calculate_par (clapper_widget, v_info)) {
GTK_GST_BASE_WIDGET_UNLOCK (widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return FALSE; return FALSE;
} }
widget->pending_resize = TRUE; clapper_widget->pending_resize = TRUE;
widget->pending_v_info = *v_info; clapper_widget->pending_v_info = *v_info;
GTK_GST_BASE_WIDGET_UNLOCK (widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return TRUE; return TRUE;
} }
void void
gtk_gst_base_widget_set_buffer (GtkGstBaseWidget * widget, GstBuffer * buffer) gtk_clapper_gl_widget_set_buffer (GtkClapperGLWidget * clapper_widget,
GstBuffer * buffer)
{ {
/* As we have no type, this is better then no check */ g_return_if_fail (GTK_IS_CLAPPER_GL_WIDGET (clapper_widget));
g_return_if_fail (GTK_IS_WIDGET (widget));
GTK_GST_BASE_WIDGET_LOCK (widget); GTK_CLAPPER_GL_WIDGET_LOCK (clapper_widget);
gst_buffer_replace (&widget->pending_buffer, buffer); gst_buffer_replace (&clapper_widget->pending_buffer, buffer);
if (!widget->draw_id) { if (!clapper_widget->draw_id) {
widget->draw_id = g_idle_add_full (G_PRIORITY_DEFAULT, clapper_widget->draw_id = g_idle_add_full (G_PRIORITY_DEFAULT,
(GSourceFunc) _queue_draw, widget, NULL); (GSourceFunc) _queue_draw, clapper_widget, NULL);
} }
GTK_GST_BASE_WIDGET_UNLOCK (widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
} }
static void static void
_get_gl_context (GtkGstBaseWidget * base_widget) _get_gl_context (GtkClapperGLWidget * clapper_widget)
{ {
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
GstGLPlatform platform = GST_GL_PLATFORM_NONE; GstGLPlatform platform = GST_GL_PLATFORM_NONE;
GstGLAPI gl_api = GST_GL_API_NONE; GstGLAPI gl_api = GST_GL_API_NONE;
guintptr gl_handle = 0; guintptr gl_handle = 0;
gtk_widget_realize (GTK_WIDGET (base_widget)); gtk_widget_realize (GTK_WIDGET (clapper_widget));
if (priv->other_context) if (priv->other_context)
gst_object_unref (priv->other_context); gst_object_unref (priv->other_context);
@@ -815,11 +815,11 @@ _get_gl_context (GtkGstBaseWidget * base_widget)
if (priv->gdk_context) if (priv->gdk_context)
g_object_unref (priv->gdk_context); g_object_unref (priv->gdk_context);
priv->gdk_context = gtk_gl_area_get_context (GTK_GL_AREA (base_widget)); priv->gdk_context = gtk_gl_area_get_context (GTK_GL_AREA (clapper_widget));
if (priv->gdk_context == NULL) { if (priv->gdk_context == NULL) {
GError *error = gtk_gl_area_get_error (GTK_GL_AREA (base_widget)); GError *error = gtk_gl_area_get_error (GTK_GL_AREA (clapper_widget));
GST_ERROR_OBJECT (base_widget, "Error creating GdkGLContext : %s", GST_ERROR_OBJECT (clapper_widget, "Error creating GdkGLContext : %s",
error ? error->message : "No error set by Gdk"); error ? error->message : "No error set by Gdk");
g_clear_error (&error); g_clear_error (&error);
return; return;
@@ -889,15 +889,15 @@ _get_gl_context (GtkGstBaseWidget * base_widget)
} }
static void static void
gtk_gst_base_widget_class_init (GtkGstBaseWidgetClass * klass) gtk_clapper_gl_widget_class_init (GtkClapperGLWidgetClass * klass)
{ {
GObjectClass *gobject_klass = (GObjectClass *) klass; GObjectClass *gobject_klass = (GObjectClass *) klass;
GtkWidgetClass *widget_klass = (GtkWidgetClass *) klass; GtkWidgetClass *widget_klass = (GtkWidgetClass *) klass;
GtkGLAreaClass *gl_area_klass = (GtkGLAreaClass *) klass; GtkGLAreaClass *gl_area_klass = (GtkGLAreaClass *) klass;
gobject_klass->set_property = gtk_gst_base_widget_set_property; gobject_klass->set_property = gtk_clapper_gl_widget_set_property;
gobject_klass->get_property = gtk_gst_base_widget_get_property; gobject_klass->get_property = gtk_clapper_gl_widget_get_property;
gobject_klass->finalize = gtk_gst_base_widget_finalize; gobject_klass->finalize = gtk_clapper_gl_widget_finalize;
g_object_class_install_property (gobject_klass, PROP_FORCE_ASPECT_RATIO, g_object_class_install_property (gobject_klass, PROP_FORCE_ASPECT_RATIO,
g_param_spec_boolean ("force-aspect-ratio", g_param_spec_boolean ("force-aspect-ratio",
@@ -916,65 +916,62 @@ gtk_gst_base_widget_class_init (GtkGstBaseWidgetClass * klass)
"When enabled, textures will be ignored and not drawn", "When enabled, textures will be ignored and not drawn",
DEFAULT_IGNORE_TEXTURES, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); DEFAULT_IGNORE_TEXTURES, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
widget_klass->measure = gtk_gst_base_widget_measure; widget_klass->measure = gtk_clapper_gl_widget_measure;
widget_klass->size_allocate = gtk_gst_base_widget_size_allocate; widget_klass->size_allocate = gtk_clapper_gl_widget_size_allocate;
gl_area_klass->render = gtk_gst_base_widget_render; gl_area_klass->render = gtk_clapper_gl_widget_render;
GST_DEBUG_CATEGORY_INIT (gst_debug_gtk_base_widget, "gtkbasewidget", 0,
"GTK Video Base Widget");
} }
static void static void
gtk_gst_base_widget_init (GtkGstBaseWidget * widget) gtk_clapper_gl_widget_init (GtkClapperGLWidget * clapper_widget)
{ {
GdkDisplay *display; GdkDisplay *display;
GtkGstBaseWidgetPrivate *priv; GtkClapperGLWidgetPrivate *priv;
GtkWidget *widget = GTK_WIDGET (clapper_widget);
widget->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO; clapper_widget->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
widget->par_n = DEFAULT_PAR_N; clapper_widget->par_n = DEFAULT_PAR_N;
widget->par_d = DEFAULT_PAR_D; clapper_widget->par_d = DEFAULT_PAR_D;
widget->ignore_textures = DEFAULT_IGNORE_TEXTURES; clapper_widget->ignore_textures = DEFAULT_IGNORE_TEXTURES;
gst_video_info_init (&widget->v_info); gst_video_info_init (&clapper_widget->v_info);
gst_video_info_init (&widget->pending_v_info); gst_video_info_init (&clapper_widget->pending_v_info);
g_weak_ref_init (&widget->element, NULL); g_weak_ref_init (&clapper_widget->element, NULL);
g_mutex_init (&widget->lock); g_mutex_init (&clapper_widget->lock);
widget->key_controller = gtk_event_controller_key_new (); clapper_widget->key_controller = gtk_event_controller_key_new ();
g_signal_connect (widget->key_controller, "key-pressed", g_signal_connect (clapper_widget->key_controller, "key-pressed",
G_CALLBACK (gtk_gst_base_widget_key_event), NULL); G_CALLBACK (gtk_clapper_gl_widget_key_event), NULL);
g_signal_connect (widget->key_controller, "key-released", g_signal_connect (clapper_widget->key_controller, "key-released",
G_CALLBACK (gtk_gst_base_widget_key_event), NULL); G_CALLBACK (gtk_clapper_gl_widget_key_event), NULL);
widget->motion_controller = gtk_event_controller_motion_new (); clapper_widget->motion_controller = gtk_event_controller_motion_new ();
g_signal_connect (widget->motion_controller, "motion", g_signal_connect (clapper_widget->motion_controller, "motion",
G_CALLBACK (gtk_gst_base_widget_motion_event), NULL); G_CALLBACK (gtk_clapper_gl_widget_motion_event), NULL);
widget->click_gesture = gtk_gesture_click_new (); clapper_widget->click_gesture = gtk_gesture_click_new ();
g_signal_connect (widget->click_gesture, "pressed", g_signal_connect (clapper_widget->click_gesture, "pressed",
G_CALLBACK (gtk_gst_base_widget_button_event), NULL); G_CALLBACK (gtk_clapper_gl_widget_button_event), NULL);
g_signal_connect (widget->click_gesture, "released", g_signal_connect (clapper_widget->click_gesture, "released",
G_CALLBACK (gtk_gst_base_widget_button_event), NULL); G_CALLBACK (gtk_clapper_gl_widget_button_event), NULL);
/* Otherwise widget in grid will appear as a 1x1px /* Otherwise widget in grid will appear as a 1x1px
* video which might be misleading for users */ * video which might be misleading for users */
gtk_widget_set_hexpand (GTK_WIDGET (widget), TRUE); gtk_widget_set_hexpand (widget, TRUE);
gtk_widget_set_vexpand (GTK_WIDGET (widget), TRUE); gtk_widget_set_vexpand (widget, TRUE);
gtk_widget_set_focusable (GTK_WIDGET (widget), TRUE); gtk_widget_set_focusable (widget, TRUE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (widget->click_gesture), gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (clapper_widget->click_gesture),
GDK_BUTTON_PRIMARY); GDK_BUTTON_PRIMARY);
gtk_widget_add_controller (GTK_WIDGET (widget), widget->key_controller); gtk_widget_add_controller (widget, clapper_widget->key_controller);
gtk_widget_add_controller (GTK_WIDGET (widget), widget->motion_controller); gtk_widget_add_controller (widget, clapper_widget->motion_controller);
gtk_widget_add_controller (GTK_WIDGET (widget), gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (clapper_widget->click_gesture));
GTK_EVENT_CONTROLLER (widget->click_gesture));
gtk_widget_set_can_focus (GTK_WIDGET (widget), TRUE); gtk_widget_set_can_focus (widget, TRUE);
widget->priv = priv = gtk_gst_base_widget_get_instance_private (widget); clapper_widget->priv = priv = gtk_clapper_gl_widget_get_instance_private (clapper_widget);
display = gdk_display_get_default (); display = gdk_display_get_default ();
@@ -1005,37 +1002,37 @@ gtk_gst_base_widget_init (GtkGstBaseWidget * widget)
} }
GtkWidget * GtkWidget *
gtk_gst_base_widget_new (void) gtk_clapper_gl_widget_new (void)
{ {
return (GtkWidget *) g_object_new (GTK_TYPE_GST_BASE_WIDGET, NULL); return (GtkWidget *) g_object_new (GTK_TYPE_CLAPPER_GL_WIDGET, NULL);
} }
gboolean gboolean
gtk_gst_base_widget_init_winsys (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_init_winsys (GtkClapperGLWidget * clapper_widget)
{ {
GtkGstBaseWidgetPrivate *priv = base_widget->priv; GtkClapperGLWidgetPrivate *priv = clapper_widget->priv;
GError *error = NULL; GError *error = NULL;
g_return_val_if_fail (GTK_IS_GST_BASE_WIDGET (base_widget), FALSE); g_return_val_if_fail (GTK_IS_CLAPPER_GL_WIDGET (clapper_widget), FALSE);
g_return_val_if_fail (priv->display != NULL, FALSE); g_return_val_if_fail (priv->display != NULL, FALSE);
GTK_GST_BASE_WIDGET_LOCK (base_widget); GTK_CLAPPER_GL_WIDGET_LOCK (clapper_widget);
if (priv->display && priv->gdk_context && priv->other_context) { if (priv->display && priv->gdk_context && priv->other_context) {
GST_TRACE ("have already initialized contexts"); GST_TRACE ("have already initialized contexts");
GTK_GST_BASE_WIDGET_UNLOCK (base_widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return TRUE; return TRUE;
} }
if (!priv->other_context) { if (!priv->other_context) {
GTK_GST_BASE_WIDGET_UNLOCK (base_widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) _get_gl_context, base_widget); gst_gtk_invoke_on_main ((GThreadFunc) (GCallback) _get_gl_context, clapper_widget);
GTK_GST_BASE_WIDGET_LOCK (base_widget); GTK_CLAPPER_GL_WIDGET_LOCK (clapper_widget);
} }
if (!GST_IS_GL_CONTEXT (priv->other_context)) { if (!GST_IS_GL_CONTEXT (priv->other_context)) {
GST_FIXME ("Could not retrieve Gdk OpenGL context"); GST_FIXME ("Could not retrieve Gdk OpenGL context");
GTK_GST_BASE_WIDGET_UNLOCK (base_widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return FALSE; return FALSE;
} }
@@ -1046,39 +1043,39 @@ gtk_gst_base_widget_init_winsys (GtkGstBaseWidget * base_widget)
error ? error->message : "Unknown"); error ? error->message : "Unknown");
g_clear_error (&error); g_clear_error (&error);
GST_OBJECT_UNLOCK (priv->display); GST_OBJECT_UNLOCK (priv->display);
GTK_GST_BASE_WIDGET_UNLOCK (base_widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return FALSE; return FALSE;
} }
gst_gl_display_add_context (priv->display, priv->context); gst_gl_display_add_context (priv->display, priv->context);
GST_OBJECT_UNLOCK (priv->display); GST_OBJECT_UNLOCK (priv->display);
GTK_GST_BASE_WIDGET_UNLOCK (base_widget); GTK_CLAPPER_GL_WIDGET_UNLOCK (clapper_widget);
return TRUE; return TRUE;
} }
GstGLContext * GstGLContext *
gtk_gst_base_widget_get_gtk_context (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_get_gtk_context (GtkClapperGLWidget * clapper_widget)
{ {
if (!base_widget->priv->other_context) if (!clapper_widget->priv->other_context)
return NULL; return NULL;
return gst_object_ref (base_widget->priv->other_context); return gst_object_ref (clapper_widget->priv->other_context);
} }
GstGLContext * GstGLContext *
gtk_gst_base_widget_get_context (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_get_context (GtkClapperGLWidget * clapper_widget)
{ {
if (!base_widget->priv->context) if (!clapper_widget->priv->context)
return NULL; return NULL;
return gst_object_ref (base_widget->priv->context); return gst_object_ref (clapper_widget->priv->context);
} }
GstGLDisplay * GstGLDisplay *
gtk_gst_base_widget_get_display (GtkGstBaseWidget * base_widget) gtk_clapper_gl_widget_get_display (GtkClapperGLWidget * clapper_widget)
{ {
if (!base_widget->priv->display) if (!clapper_widget->priv->display)
return NULL; return NULL;
return gst_object_ref (base_widget->priv->display); return gst_object_ref (clapper_widget->priv->display);
} }

107
lib/gst/clapper/gtk4/gtkclapperglwidget.h Normal file
View File

@@ -0,0 +1,107 @@
/*
* GStreamer
* Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
* Copyright (C) 2020 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.
*/
#ifndef __GTK_CLAPPER_GL_WIDGET_H__
#define __GTK_CLAPPER_GL_WIDGET_H__
#include <gtk/gtk.h>
#include <gst/gst.h>
#include <gst/video/video.h>
#include <gst/gl/gl.h>
G_BEGIN_DECLS
GType gtk_clapper_gl_widget_get_type (void);
#define GTK_TYPE_CLAPPER_GL_WIDGET (gtk_clapper_gl_widget_get_type())
#define GTK_CLAPPER_GL_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GTK_TYPE_CLAPPER_GL_WIDGET,GtkClapperGLWidget))
#define GTK_CLAPPER_GL_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GTK_TYPE_CLAPPER_GL_WIDGET,GtkClapperGLWidgetClass))
#define GTK_IS_CLAPPER_GL_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GTK_TYPE_CLAPPER_GL_WIDGET))
#define GTK_IS_CLAPPER_GL_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GTK_TYPE_CLAPPER_GL_WIDGET))
#define GTK_CLAPPER_GL_WIDGET_CAST(obj) ((GtkClapperGLWidget*)(obj))
#define GTK_CLAPPER_GL_WIDGET_LOCK(w) g_mutex_lock(&((GtkClapperGLWidget*)(w))->lock)
#define GTK_CLAPPER_GL_WIDGET_UNLOCK(w) g_mutex_unlock(&((GtkClapperGLWidget*)(w))->lock)
typedef struct _GtkClapperGLWidget GtkClapperGLWidget;
typedef struct _GtkClapperGLWidgetClass GtkClapperGLWidgetClass;
typedef struct _GtkClapperGLWidgetPrivate GtkClapperGLWidgetPrivate;
struct _GtkClapperGLWidget
{
/* <private> */
GtkGLArea parent;
GtkClapperGLWidgetPrivate *priv;
/* properties */
gboolean force_aspect_ratio;
gint par_n, par_d;
gboolean ignore_textures;
gint display_width;
gint display_height;
/* Widget dimensions */
gint scaled_width;
gint scaled_height;
gboolean negotiated;
GstBuffer *pending_buffer;
GstBuffer *buffer;
GstVideoInfo v_info;
/* resize */
gboolean pending_resize;
GstVideoInfo pending_v_info;
guint display_ratio_num;
guint display_ratio_den;
/*< private >*/
GMutex lock;
GWeakRef element;
/* event controllers */
GtkEventController *key_controller;
GtkEventController *motion_controller;
GtkGesture *click_gesture;
/* Pending draw idles callback */
guint draw_id;
};
struct _GtkClapperGLWidgetClass
{
GtkGLAreaClass parent_class;
};
/* API */
gboolean gtk_clapper_gl_widget_set_format (GtkClapperGLWidget * widget, GstVideoInfo * v_info);
void gtk_clapper_gl_widget_set_buffer (GtkClapperGLWidget * widget, GstBuffer * buffer);
void gtk_clapper_gl_widget_set_element (GtkClapperGLWidget * widget, GstElement * element);
GtkWidget * gtk_clapper_gl_widget_new (void);
gboolean gtk_clapper_gl_widget_init_winsys (GtkClapperGLWidget * widget);
GstGLDisplay * gtk_clapper_gl_widget_get_display (GtkClapperGLWidget * widget);
GstGLContext * gtk_clapper_gl_widget_get_context (GtkClapperGLWidget * widget);
GstGLContext * gtk_clapper_gl_widget_get_gtk_context (GtkClapperGLWidget * widget);
G_END_DECLS
#endif /* __GTK_CLAPPER_GL_WIDGET_H__ */

107
lib/gst/clapper/gtk4/gtkgstbasewidget.h
View File

@@ -1,107 +0,0 @@
/*
* GStreamer
* Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
* Copyright (C) 2020 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.
*/
#ifndef __GTK_GST_BASE_WIDGET_H__
#define __GTK_GST_BASE_WIDGET_H__
#include <gtk/gtk.h>
#include <gst/gst.h>
#include <gst/video/video.h>
#include <gst/gl/gl.h>
G_BEGIN_DECLS
GType gtk_gst_base_widget_get_type (void);
#define GTK_TYPE_GST_BASE_WIDGET (gtk_gst_base_widget_get_type())
#define GTK_GST_BASE_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GTK_TYPE_GST_BASE_WIDGET,GtkGstBaseWidget))
#define GTK_GST_BASE_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GTK_TYPE_GST_BASE_WIDGET,GtkGstBaseWidgetClass))
#define GTK_IS_GST_BASE_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GTK_TYPE_GST_BASE_WIDGET))
#define GTK_IS_GST_BASE_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GTK_TYPE_GST_BASE_WIDGET))
#define GTK_GST_BASE_WIDGET_CAST(obj) ((GtkGstBaseWidget*)(obj))
#define GTK_GST_BASE_WIDGET_LOCK(w) g_mutex_lock(&((GtkGstBaseWidget*)(w))->lock)
#define GTK_GST_BASE_WIDGET_UNLOCK(w) g_mutex_unlock(&((GtkGstBaseWidget*)(w))->lock)
typedef struct _GtkGstBaseWidget GtkGstBaseWidget;
typedef struct _GtkGstBaseWidgetClass GtkGstBaseWidgetClass;
typedef struct _GtkGstBaseWidgetPrivate GtkGstBaseWidgetPrivate;
struct _GtkGstBaseWidget
{
/* <private> */
GtkGLArea parent;
GtkGstBaseWidgetPrivate *priv;
/* properties */
gboolean force_aspect_ratio;
gint par_n, par_d;
gboolean ignore_textures;
gint display_width;
gint display_height;
/* Widget dimensions */
gint scaled_width;
gint scaled_height;
gboolean negotiated;
GstBuffer *pending_buffer;
GstBuffer *buffer;
GstVideoInfo v_info;
/* resize */
gboolean pending_resize;
GstVideoInfo pending_v_info;
guint display_ratio_num;
guint display_ratio_den;
/*< private >*/
GMutex lock;
GWeakRef element;
/* event controllers */
GtkEventController *key_controller;
GtkEventController *motion_controller;
GtkGesture *click_gesture;
/* Pending draw idles callback */
guint draw_id;
};
struct _GtkGstBaseWidgetClass
{
GtkGLAreaClass parent_class;
};
/* API */
gboolean gtk_gst_base_widget_set_format (GtkGstBaseWidget * widget, GstVideoInfo * v_info);
void gtk_gst_base_widget_set_buffer (GtkGstBaseWidget * widget, GstBuffer * buffer);
void gtk_gst_base_widget_set_element (GtkGstBaseWidget * widget, GstElement * element);
GtkWidget * gtk_gst_base_widget_new (void);
gboolean gtk_gst_base_widget_init_winsys (GtkGstBaseWidget * widget);
GstGLDisplay * gtk_gst_base_widget_get_display (GtkGstBaseWidget * widget);
GstGLContext * gtk_gst_base_widget_get_context (GtkGstBaseWidget * widget);
GstGLContext * gtk_gst_base_widget_get_gtk_context (GtkGstBaseWidget * widget);
G_END_DECLS
#endif /* __GTK_GST_BASE_WIDGET_H__ */

4
lib/gst/clapper/meson.build
View File

@@ -8,9 +8,9 @@ gstclapper_sources = [
'gstclapper-visualization.c', 'gstclapper-visualization.c',
'gstclapper-gtk4-plugin.c', 'gstclapper-gtk4-plugin.c',
'gtk4/gstgtkbasesink.c', 'gtk4/gstclapperglsink.c',
'gtk4/gstgtkutils.c', 'gtk4/gstgtkutils.c',
'gtk4/gtkgstbasewidget.c', 'gtk4/gtkclapperglwidget.c',
] ]
gstclapper_headers = [ gstclapper_headers = [
'clapper.h', 'clapper.h',