From 293ad6203552f1df440f9fa86ec6b4bbd86a7cad Mon Sep 17 00:00:00 2001 From: Matthew Waters Date: Thu, 22 Dec 2022 18:11:19 +1100 Subject: [PATCH] qt6: add qml6glsrc element Same functionality as qmlglsrc (Qt5) but for Qt6. Part-of: --- .../gst-plugins-good/ext/qt6/gstplugin.cc | 1 + .../gst-plugins-good/ext/qt6/gstqml6glsrc.cc | 593 ++++++++++++++++++ .../gst-plugins-good/ext/qt6/gstqml6glsrc.h | 62 ++ .../gst-plugins-good/ext/qt6/gstqt6elements.h | 1 + .../gst-plugins-good/ext/qt6/meson.build | 3 + .../gst-plugins-good/ext/qt6/qt6glwindow.cc | 470 ++++++++++++++ .../gst-plugins-good/ext/qt6/qt6glwindow.h | 69 ++ .../tests/examples/qt6/meson.build | 1 + .../tests/examples/qt6/qmlsrc/grabqml.pro | 20 + .../tests/examples/qt6/qmlsrc/main.cpp | 82 +++ .../tests/examples/qt6/qmlsrc/main.qml | 64 ++ .../tests/examples/qt6/qmlsrc/meson.build | 11 + .../tests/examples/qt6/qmlsrc/qmlsrc.qrc | 5 + 13 files changed, 1382 insertions(+) create mode 100644 subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.cc create mode 100644 subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.h create mode 100644 subprojects/gst-plugins-good/ext/qt6/qt6glwindow.cc create mode 100644 subprojects/gst-plugins-good/ext/qt6/qt6glwindow.h create mode 100644 subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/grabqml.pro create mode 100644 subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.cpp create mode 100644 subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.qml create mode 100644 subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/meson.build create mode 100644 subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/qmlsrc.qrc diff --git a/subprojects/gst-plugins-good/ext/qt6/gstplugin.cc b/subprojects/gst-plugins-good/ext/qt6/gstplugin.cc index 3ab792578f..b24cf22051 100644 --- a/subprojects/gst-plugins-good/ext/qt6/gstplugin.cc +++ b/subprojects/gst-plugins-good/ext/qt6/gstplugin.cc @@ -30,6 +30,7 @@ plugin_init (GstPlugin * plugin) gboolean ret = FALSE; ret |= GST_ELEMENT_REGISTER (qml6glsink, plugin); + ret |= GST_ELEMENT_REGISTER (qml6glsrc, plugin); return ret; } diff --git a/subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.cc b/subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.cc new file mode 100644 index 0000000000..327bec86b2 --- /dev/null +++ b/subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.cc @@ -0,0 +1,593 @@ +/* + * GStreamer + * Copyright (C) 2016 Freescale Semiconductor, Inc. All rights reserved. + * Copyright (C) 2022 Matthew Waters + * + * 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. + */ + +/** + * SECTION:qml6glsrc + * + * Since: 1.24 + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstqt6elements.h" +#include "gstqml6glsrc.h" +#include + +#define GST_CAT_DEFAULT gst_debug_qml6_gl_src +GST_DEBUG_CATEGORY (GST_CAT_DEFAULT); + +#define DEFAULT_IS_LIVE TRUE + +static void gst_qml6_gl_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_qml6_gl_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static void gst_qml6_gl_src_finalize (GObject * object); + +static gboolean gst_qml6_gl_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps); +static GstCaps *gst_qml6_gl_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter); +static gboolean gst_qml6_gl_src_query (GstBaseSrc * bsrc, GstQuery * query); + +static gboolean gst_qml6_gl_src_decide_allocation (GstBaseSrc * bsrc, + GstQuery * query); +static GstFlowReturn gst_qml6_gl_src_create (GstPushSrc * psrc, GstBuffer ** buffer); +static gboolean gst_qml6_gl_src_unlock(GstBaseSrc * bsrc); +static gboolean gst_qml6_gl_src_unlock_stop (GstBaseSrc * bsrc); +static GstStateChangeReturn gst_qml6_gl_src_change_state (GstElement * element, + GstStateChange transition); +static gboolean gst_qml6_gl_src_start (GstBaseSrc * basesrc); +static gboolean gst_qml6_gl_src_stop (GstBaseSrc * basesrc); + +static GstStaticPadTemplate gst_qml6_gl_src_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_GL_MEMORY "), " + "format = (string) RGBA, " + "width = " GST_VIDEO_SIZE_RANGE ", " + "height = " GST_VIDEO_SIZE_RANGE ", " + "framerate = " GST_VIDEO_FPS_RANGE ", " + "texture-target = (string) 2D")); + +enum +{ + ARG_0, + PROP_WINDOW, + PROP_DEFAULT_FBO +}; + +#define gst_qml6_gl_src_parent_class parent_class +G_DEFINE_TYPE_WITH_CODE (GstQml6GLSrc, gst_qml6_gl_src, + GST_TYPE_PUSH_SRC, GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, + "qml6glsrc", 0, "Qt6 Qml Video Src")); +GST_ELEMENT_REGISTER_DEFINE_WITH_CODE (qml6glsrc, "qml6glsrc", + GST_RANK_NONE, GST_TYPE_QML6_GL_SRC, qt6_element_init (plugin)); + +static const gfloat vertical_flip_matrix[] = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, -1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 1.0f, +}; + +static void +gst_qml6_gl_src_class_init (GstQml6GLSrcClass * klass) +{ + GObjectClass *gobject_class = (GObjectClass *) klass; + GstElementClass *gstelement_class = (GstElementClass *) klass; + GstBaseSrcClass *gstbasesrc_class = (GstBaseSrcClass *) klass; + GstPushSrcClass *gstpushsrc_class = (GstPushSrcClass *) klass; + + gobject_class->set_property = gst_qml6_gl_src_set_property; + gobject_class->get_property = gst_qml6_gl_src_get_property; + gobject_class->finalize = gst_qml6_gl_src_finalize; + + gst_element_class_set_metadata (gstelement_class, "Qt Video Source", + "Source/Video", "A video src that captures a window from a QML view", + "Multimedia Team "); + + g_object_class_install_property (gobject_class, PROP_WINDOW, + g_param_spec_pointer ("window", "QQuickWindow", + "The QQuickWindow to place in the object hierarchy", + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_DEFAULT_FBO, + g_param_spec_boolean ("use-default-fbo", + "Whether to use default FBO", + "When set it will not create a new FBO for the QML render thread", + FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + gst_element_class_add_pad_template (gstelement_class, + gst_static_pad_template_get (&gst_qml6_gl_src_template)); + + gstelement_class->change_state = gst_qml6_gl_src_change_state; + gstbasesrc_class->set_caps = gst_qml6_gl_src_setcaps; + gstbasesrc_class->get_caps = gst_qml6_gl_src_get_caps; + gstbasesrc_class->query = gst_qml6_gl_src_query; + gstbasesrc_class->start = gst_qml6_gl_src_start; + gstbasesrc_class->stop = gst_qml6_gl_src_stop; + gstbasesrc_class->decide_allocation = gst_qml6_gl_src_decide_allocation; + gstbasesrc_class->unlock = gst_qml6_gl_src_unlock; + gstbasesrc_class->unlock_stop = gst_qml6_gl_src_unlock_stop; + + gstpushsrc_class->create = gst_qml6_gl_src_create; +} + +static void +gst_qml6_gl_src_init (GstQml6GLSrc * src) +{ + gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME); + gst_base_src_set_live (GST_BASE_SRC (src), DEFAULT_IS_LIVE); + src->default_fbo = FALSE; + src->pending_image_orientation = TRUE; +} + +static void +gst_qml6_gl_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (object); + + switch (prop_id) { + case PROP_WINDOW:{ + qt_src->qwindow = + static_cast < QQuickWindow * >(g_value_get_pointer (value)); + + if (qt_src->window) { + delete qt_src->window; + qt_src->window = NULL; + } + + if (qt_src->qwindow) + qt_src->window = new Qt6GLWindow (NULL, qt_src->qwindow); + + break; + } + case PROP_DEFAULT_FBO: + qt_src->default_fbo = g_value_get_boolean (value); + if (qt_src->window) + qt6_gl_window_use_default_fbo (qt_src->window, qt_src->default_fbo); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_qml6_gl_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (object); + + switch (prop_id) { + case PROP_WINDOW: + g_value_set_pointer (value, qt_src->qwindow); + break; + case PROP_DEFAULT_FBO: + g_value_set_boolean (value, qt_src->default_fbo); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_qml6_gl_src_finalize (GObject * object) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (object); + + GST_DEBUG ("qmlglsrc finalize"); + if (qt_src->context) + gst_object_unref (qt_src->context); + qt_src->context = NULL; + + if (qt_src->qt_context) + gst_object_unref (qt_src->qt_context); + qt_src->qt_context = NULL; + + if (qt_src->display) + gst_object_unref (qt_src->display); + qt_src->display = NULL; + + if (qt_src->window) + delete qt_src->window; + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static gboolean +gst_qml6_gl_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (bsrc); + + GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps); + + if (!gst_video_info_from_caps (&qt_src->v_info, caps)) + return FALSE; + + return TRUE; +} + +static GstCaps * +gst_qml6_gl_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter) +{ + GstCaps *caps = NULL, *temp = NULL; + GstPadTemplate *pad_template; + GstBaseSrcClass *bclass = GST_BASE_SRC_GET_CLASS (bsrc); + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (bsrc); + guint i; + gint width, height; + + if (qt_src->window) { + qt_src->window->getGeometry (&width, &height); + } + + pad_template = + gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "src"); + if (pad_template != NULL) + caps = gst_pad_template_get_caps (pad_template); + + if (qt_src->window) { + temp = gst_caps_copy (caps); + guint n_caps = gst_caps_get_size (caps); + + for (i = 0; i < n_caps; i++) { + GstStructure *s = gst_caps_get_structure (temp, i); + gst_structure_set (s, "width", G_TYPE_INT, width, NULL); + gst_structure_set (s, "height", G_TYPE_INT, height, NULL); + /* because the framerate is unknown */ + gst_structure_set (s, "framerate", GST_TYPE_FRACTION, 0, 1, NULL); + gst_structure_set (s, "pixel-aspect-ratio", + GST_TYPE_FRACTION, 1, 1, NULL); + } + + gst_caps_unref (caps); + caps = temp; + } + + if (filter) { + GstCaps *intersection; + + intersection = + gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); + gst_caps_unref (caps); + caps = intersection; + } + + return caps; +} + +static gboolean +gst_qml6_gl_src_query (GstBaseSrc * bsrc, GstQuery * query) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (bsrc); + gboolean res = FALSE; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_CONTEXT: + { + if (!qt6_gl_window_is_scenegraph_initialized (qt_src->window)) + return FALSE; + + if (!qt_src->display && !qt_src->qt_context) { + if (!qt_src->display) + qt_src->display = qt6_gl_window_get_display (qt_src->window); + if (!qt_src->qt_context) + qt_src->qt_context = qt6_gl_window_get_qt_context (qt_src->window); + if (!qt_src->context) + qt_src->context = qt6_gl_window_get_context (qt_src->window); + } + + if (gst_gl_handle_context_query ((GstElement *) qt_src, query, + qt_src->display, qt_src->context, qt_src->qt_context)) + return TRUE; + + /* fallthrough */ + } + default: + res = GST_BASE_SRC_CLASS (parent_class)->query (bsrc, query); + break; + } + + return res; +} + +static gboolean +_find_local_gl_context (GstQml6GLSrc * qt_src) +{ + if (gst_gl_query_local_gl_context (GST_ELEMENT (qt_src), GST_PAD_SRC, + &qt_src->context)) + return TRUE; + return FALSE; +} + +static gboolean +gst_qml6_gl_src_decide_allocation (GstBaseSrc * bsrc, GstQuery * query) +{ + GstBufferPool *pool = NULL; + GstStructure *config; + GstCaps *caps; + guint min, max, size, n, i; + gboolean update_pool, update_allocator; + GstAllocator *allocator; + GstAllocationParams params; + GstGLVideoAllocationParams *glparams; + GstVideoInfo vinfo; + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (bsrc); + + if (gst_query_find_allocation_meta (query, + GST_VIDEO_AFFINE_TRANSFORMATION_META_API_TYPE, NULL)) { + qt_src->downstream_supports_affine_meta = TRUE; + } else { + qt_src->downstream_supports_affine_meta = FALSE; + } + + gst_query_parse_allocation (query, &caps, NULL); + if (!caps) + return FALSE; + + gst_video_info_from_caps (&vinfo, caps); + + n = gst_query_get_n_allocation_pools (query); + if (n > 0) { + update_pool = TRUE; + for (i = 0; i < n; i++) { + gst_query_parse_nth_allocation_pool (query, i, &pool, &size, &min, &max); + + if (!pool || !GST_IS_GL_BUFFER_POOL (pool)) { + if (pool) + gst_object_unref (pool); + pool = NULL; + } + } + } + + if (!pool) { + size = vinfo.size; + min = max = 0; + update_pool = FALSE; + } + + if (!qt_src->context && !_find_local_gl_context (qt_src)) + return FALSE; + + if (!qt6_gl_window_set_context (qt_src->window, qt_src->context)) + return FALSE; + + if (!pool) { + if (!qt_src->context || !GST_IS_GL_CONTEXT (qt_src->context)) + return FALSE; + + pool = gst_gl_buffer_pool_new (qt_src->context); + GST_INFO_OBJECT (qt_src, "No pool, create one ourself %p", pool); + } + + config = gst_buffer_pool_get_config (pool); + + gst_buffer_pool_config_set_params (config, caps, size, min, max); + gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META); + if (gst_query_find_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, NULL)) + gst_buffer_pool_config_add_option (config, + GST_BUFFER_POOL_OPTION_GL_SYNC_META); + + if (gst_query_get_n_allocation_params (query) > 0) { + gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms); + gst_buffer_pool_config_set_allocator (config, allocator, ¶ms); + GST_INFO_OBJECT (qt_src, "got allocator %p", allocator); + update_allocator = TRUE; + } else { + allocator = NULL; + gst_allocation_params_init (¶ms); + update_allocator = FALSE; + } + + glparams = + gst_gl_video_allocation_params_new (qt_src->context, ¶ms, &vinfo, 0, + NULL, GST_GL_TEXTURE_TARGET_2D, GST_GL_RGBA); + gst_buffer_pool_config_set_gl_allocation_params (config, + (GstGLAllocationParams *) glparams); + gst_gl_allocation_params_free ((GstGLAllocationParams *) glparams); + + if (!gst_buffer_pool_set_config (pool, config)) + GST_WARNING_OBJECT (qt_src, "Failed to set buffer pool config"); + + if (update_allocator) + gst_query_set_nth_allocation_param (query, 0, allocator, ¶ms); + else + gst_query_add_allocation_param (query, allocator, ¶ms); + if (allocator) + gst_object_unref (allocator); + + if (update_pool) + gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max); + else + gst_query_add_allocation_pool (query, pool, size, min, max); + gst_object_unref (pool); + + GST_INFO_OBJECT (qt_src, "successfully decide_allocation"); + return TRUE; +} + +static GstFlowReturn +gst_qml6_gl_src_create (GstPushSrc * psrc, GstBuffer ** buffer) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (psrc); + GstCaps *updated_caps = NULL; + + *buffer = qt6_gl_window_take_buffer (qt_src->window, &updated_caps); + GST_DEBUG_OBJECT (qt_src, "produced buffer %p", *buffer); + if (!*buffer) + return GST_FLOW_FLUSHING; + + if (updated_caps) { + GST_DEBUG_OBJECT (qt_src, "new_caps %" GST_PTR_FORMAT, updated_caps); + gst_base_src_set_caps (GST_BASE_SRC (qt_src), updated_caps); + } + gst_clear_caps (&updated_caps); + + if (!qt_src->downstream_supports_affine_meta) { + if (qt_src->pending_image_orientation) { + /* let downstream know the image orientation is vertical filp */ + GstTagList *image_orientation_tag = + gst_tag_list_new (GST_TAG_IMAGE_ORIENTATION, "flip-rotate-180", NULL); + + gst_pad_push_event (GST_BASE_SRC_PAD (psrc), + gst_event_new_tag (image_orientation_tag)); + + qt_src->pending_image_orientation = FALSE; + } + } else { + GstVideoAffineTransformationMeta *trans_meta; + trans_meta = gst_buffer_add_video_affine_transformation_meta (*buffer); + gst_video_affine_transformation_meta_apply_matrix (trans_meta, + vertical_flip_matrix); + } + + GST_DEBUG_OBJECT (qt_src, "buffer create done %p", *buffer); + + return GST_FLOW_OK; +} + +static gboolean +gst_qml6_gl_src_unlock (GstBaseSrc * bsrc) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (bsrc); + + if (!qt_src->window) + return TRUE; + + qt6_gl_window_unlock (qt_src->window); + + return TRUE; +} + +static gboolean +gst_qml6_gl_src_unlock_stop (GstBaseSrc * bsrc) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (bsrc); + + if (!qt_src->window) + return TRUE; + + qt6_gl_window_unlock_stop (qt_src->window); + + return TRUE; +} + +static GstStateChangeReturn +gst_qml6_gl_src_change_state (GstElement * element, GstStateChange transition) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (element); + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; + QGuiApplication *app; + + GST_DEBUG ("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: + app = static_cast < QGuiApplication * >(QCoreApplication::instance ()); + if (!app) { + GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND, + ("%s", "Failed to connect to Qt"), + ("%s", "Could not retrieve QGuiApplication instance")); + return GST_STATE_CHANGE_FAILURE; + } + + if (!qt_src->window) { + GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND, + ("%s", "Required property \'window\' not set"), (NULL)); + return GST_STATE_CHANGE_FAILURE; + } + + if (!qt6_gl_window_is_scenegraph_initialized (qt_src->window)) { + GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND, + ("%s", "Could not initialize window system"), (NULL)); + return GST_STATE_CHANGE_FAILURE; + } + + qt6_gl_window_use_default_fbo (qt_src->window, qt_src->default_fbo); + + break; + case GST_STATE_CHANGE_READY_TO_PAUSED: + break; + case GST_STATE_CHANGE_PAUSED_TO_PLAYING: + break; + default: + break; + } + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + if (ret == GST_STATE_CHANGE_FAILURE) + return ret; + + switch (transition) { + case GST_STATE_CHANGE_PLAYING_TO_PAUSED: + break; + case GST_STATE_CHANGE_PAUSED_TO_READY: + break; + case GST_STATE_CHANGE_READY_TO_NULL: + break; + default: + break; + } + + return ret; +} + +static gboolean +gst_qml6_gl_src_start (GstBaseSrc * basesrc) +{ + GstQml6GLSrc *qt_src = GST_QML6_GL_SRC (basesrc); + + /* already has get OpenGL configuration from qt */ + if (qt_src->display && qt_src->qt_context) + return TRUE; + + if (!qt6_gl_window_is_scenegraph_initialized (qt_src->window)) + return FALSE; + + qt_src->display = qt6_gl_window_get_display (qt_src->window); + qt_src->qt_context = qt6_gl_window_get_qt_context (qt_src->window); + qt_src->context = qt6_gl_window_get_context (qt_src->window); + + if (!qt_src->display || !qt_src->qt_context) { + GST_ERROR_OBJECT (qt_src, + "Could not retrieve window system OpenGL configuration"); + return FALSE; + } + + GST_DEBUG_OBJECT (qt_src, "Got qt display %p and qt gl context %p", + qt_src->display, qt_src->qt_context); + return TRUE; +} + +static gboolean +gst_qml6_gl_src_stop (GstBaseSrc * basesrc) +{ + return TRUE; +} diff --git a/subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.h b/subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.h new file mode 100644 index 0000000000..96ad503f17 --- /dev/null +++ b/subprojects/gst-plugins-good/ext/qt6/gstqml6glsrc.h @@ -0,0 +1,62 @@ +/* + * GStreamer + * Copyright (C) 2016 Freescale Semiconductor, Inc. All rights reserved. + * + * 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_QML6_GL_SRC_H__ +#define __GST_QML6_GL_SRC_H__ + +#include +#include +#include +#include +#include "qt6glwindow.h" + +G_BEGIN_DECLS + +#define GST_TYPE_QML6_GL_SRC (gst_qml6_gl_src_get_type()) +G_DECLARE_FINAL_TYPE (GstQml6GLSrc, gst_qml6_gl_src, GST, QML6_GL_SRC, GstPushSrc) +#define GST_QML6_GL_SRC_CAST(obj) ((GstQml6GLSrc*)(obj)) + +/** + * GstQml6GLSrc: + * + * Opaque #GstQml6GLSrc object + */ +struct _GstQml6GLSrc +{ + /* */ + GstPushSrc parent; + + QQuickWindow *qwindow; + Qt6GLWindow *window; + + GstVideoInfo v_info; + + GstGLDisplay *display; + GstGLContext *context; + GstGLContext *qt_context; + + gboolean default_fbo; + gboolean downstream_supports_affine_meta; + gboolean pending_image_orientation; +}; + +G_END_DECLS + +#endif /* __GST_QML6_GL_SRC_H__ */ diff --git a/subprojects/gst-plugins-good/ext/qt6/gstqt6elements.h b/subprojects/gst-plugins-good/ext/qt6/gstqt6elements.h index 7b18455ba9..7b53659581 100644 --- a/subprojects/gst-plugins-good/ext/qt6/gstqt6elements.h +++ b/subprojects/gst-plugins-good/ext/qt6/gstqt6elements.h @@ -27,6 +27,7 @@ G_BEGIN_DECLS void qt6_element_init (GstPlugin * plugin); GST_ELEMENT_REGISTER_DECLARE (qml6glsink); +GST_ELEMENT_REGISTER_DECLARE (qml6glsrc); G_END_DECLS diff --git a/subprojects/gst-plugins-good/ext/qt6/meson.build b/subprojects/gst-plugins-good/ext/qt6/meson.build index 150b0b9f22..bb9f757fa1 100644 --- a/subprojects/gst-plugins-good/ext/qt6/meson.build +++ b/subprojects/gst-plugins-good/ext/qt6/meson.build @@ -4,12 +4,15 @@ sources = [ 'gstqsg6glnode.cc', 'gstqt6glutility.cc', 'gstqml6glsink.cc', + 'gstqml6glsrc.cc', 'qt6glitem.cc', + 'qt6glwindow.cc', ] moc_headers = [ 'qt6glitem.h', 'gstqsg6glnode.h', + 'qt6glwindow.h', ] qt6qml_dep = dependency('', required: false) diff --git a/subprojects/gst-plugins-good/ext/qt6/qt6glwindow.cc b/subprojects/gst-plugins-good/ext/qt6/qt6glwindow.cc new file mode 100644 index 0000000000..7c7cdcff3c --- /dev/null +++ b/subprojects/gst-plugins-good/ext/qt6/qt6glwindow.cc @@ -0,0 +1,470 @@ +/* + * GStreamer + * Copyright (C) 2016 Freescale Semiconductor, Inc. All rights reserved. + * Copyright (C) 2022 Matthew Waters + * + * 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 + +#include +#include +#include "qt6glwindow.h" +#include "gstqt6glutility.h" + +#include +#include +#include +#include + +/* compatibility definitions... */ +#ifndef GL_READ_FRAMEBUFFER +#define GL_READ_FRAMEBUFFER 0x8CA8 +#endif +#ifndef GL_DRAW_FRAMEBUFFER +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#endif + +/** + * SECTION: + * + * #Qt6GLWindow is an #QQuickWindow that grab QtQuick view to GStreamer OpenGL video buffers. + */ + +GST_DEBUG_CATEGORY_STATIC (qt6_gl_window_debug); +#define GST_CAT_DEFAULT qt6_gl_window_debug + +struct _Qt6GLWindowPrivate +{ + GMutex lock; + GCond update_cond; + + GstBuffer *buffer; + GstVideoInfo v_info; + GstVideoFrame mapped_frame; + GstGLBaseMemoryAllocator *gl_allocator; + GstGLAllocationParams *gl_params; + + gboolean initted; + gboolean updated; + gboolean quit; + gboolean result; + gboolean useDefaultFbo; + + GstGLDisplay *display; + GstGLContext *other_context; + GstGLContext *context; + + guint fbo; + + gboolean new_caps; + GstBuffer *produced_buffer; +}; + +Qt6GLWindow::Qt6GLWindow (QWindow * parent, QQuickWindow *src) + : QQuickWindow( parent ), source (src) +{ + QGuiApplication *app = static_cast (QCoreApplication::instance ()); + static gsize _debug; + + g_assert (app != NULL); + + if (g_once_init_enter (&_debug)) { + GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "qt6glwindow", 0, "Qt6 GL QuickWindow"); + g_once_init_leave (&_debug, 1); + } + + this->priv = g_new0 (Qt6GLWindowPrivate, 1); + + g_mutex_init (&this->priv->lock); + g_cond_init (&this->priv->update_cond); + + this->priv->display = gst_qml6_get_gl_display(FALSE); + this->priv->result = TRUE; + + connect (source, SIGNAL(beforeRendering()), this, SLOT(beforeRendering()), Qt::DirectConnection); + connect (source, SIGNAL(afterRendering()), this, SLOT(afterRendering()), Qt::DirectConnection); + if (source->isSceneGraphInitialized()) + source->scheduleRenderJob(new RenderJob(std::bind(&Qt6GLWindow::onSceneGraphInitialized, this)), QQuickWindow::BeforeSynchronizingStage); + else + connect (source, SIGNAL(sceneGraphInitialized()), this, SLOT(onSceneGraphInitialized()), Qt::DirectConnection); + + connect (source, SIGNAL(sceneGraphInvalidated()), this, SLOT(onSceneGraphInvalidated()), Qt::DirectConnection); + + GST_DEBUG ("%p init Qt Window", this->priv->display); +} + +Qt6GLWindow::~Qt6GLWindow() +{ + GST_DEBUG ("deinit Qt Window"); + g_mutex_clear (&this->priv->lock); + g_cond_clear (&this->priv->update_cond); + gst_clear_object (&this->priv->other_context); + gst_clear_buffer (&this->priv->buffer); + gst_clear_buffer (&this->priv->produced_buffer); + gst_clear_object (&this->priv->display); + gst_clear_object (&this->priv->context); + gst_clear_object (&this->priv->gl_allocator); + + if (this->priv->gl_params) + gst_gl_allocation_params_free (this->priv->gl_params); + this->priv->gl_params = NULL; + + g_free (this->priv); + this->priv = NULL; +} + +void +Qt6GLWindow::beforeRendering() +{ + g_mutex_lock (&this->priv->lock); + + if (!this->priv->context) { + GST_LOG ("no GStreamer GL context set yet, skipping frame"); + g_mutex_unlock (&this->priv->lock); + return; + } + + QSize size = source->size(); + + if (!this->priv->gl_allocator) + this->priv->gl_allocator = + (GstGLBaseMemoryAllocator *) gst_gl_memory_allocator_get_default (this->priv->context); + + if (GST_VIDEO_INFO_WIDTH (&this->priv->v_info) != size.width() + || GST_VIDEO_INFO_HEIGHT (&this->priv->v_info) != size.height()) { + this->priv->new_caps = TRUE; + + gst_video_info_set_format (&this->priv->v_info, GST_VIDEO_FORMAT_RGBA, + size.width(), size.height()); + + if (this->priv->gl_params) { + GstGLVideoAllocationParams *gl_vid_params = (GstGLVideoAllocationParams *) this->priv->gl_params; + if (GST_VIDEO_INFO_WIDTH (gl_vid_params->v_info) != source->width() + || GST_VIDEO_INFO_HEIGHT (gl_vid_params->v_info) != source->height()) + this->priv->gl_params = NULL; + gst_clear_buffer (&this->priv->buffer); + } + } + + if (!this->priv->gl_params) { + this->priv->gl_params = (GstGLAllocationParams *) + gst_gl_video_allocation_params_new (this->priv->context, NULL, + &this->priv->v_info, 0, NULL, GST_GL_TEXTURE_TARGET_2D, GST_GL_RGBA); + } + + if (!this->priv->buffer) { + GstGLMemory *gl_mem = + (GstGLMemory *) gst_gl_base_memory_alloc (this->priv->gl_allocator, + this->priv->gl_params); + this->priv->buffer = gst_buffer_new (); + gst_buffer_append_memory (this->priv->buffer, (GstMemory *) gl_mem); + } + + if (!gst_video_frame_map (&this->priv->mapped_frame, &this->priv->v_info, + this->priv->buffer, (GstMapFlags) (GST_MAP_WRITE | GST_MAP_GL))) { + GST_WARNING ("failed map video frame"); + gst_clear_buffer (&this->priv->buffer); + return; + } + + if (!this->priv->useDefaultFbo) { + guint tex_id = *(guint *) this->priv->mapped_frame.data[0]; + + source->setRenderTarget(QQuickRenderTarget::fromOpenGLTexture(tex_id, source->size())); + } else if (this->priv->useDefaultFbo) { + GST_DEBUG ("use default fbo for render target"); + source->setRenderTarget(QQuickRenderTarget()); + } + + g_mutex_unlock (&this->priv->lock); +} + +void +Qt6GLWindow::afterRendering() +{ + gboolean ret; + guint width, height; + const GstGLFuncs *gl; + GstGLSyncMeta *sync_meta; + + g_mutex_lock (&this->priv->lock); + + if (!this->priv->buffer) { + GST_LOG ("no buffer created in beforeRendering(), skipping"); + g_mutex_unlock (&this->priv->lock); + return; + } + + width = GST_VIDEO_INFO_WIDTH (&this->priv->v_info); + height = GST_VIDEO_INFO_HEIGHT (&this->priv->v_info); + + gst_gl_context_activate (this->priv->other_context, TRUE); + gl = this->priv->other_context->gl_vtable; + + if (!this->priv->useDefaultFbo) { + gst_video_frame_unmap (&this->priv->mapped_frame); + ret = TRUE; + } else { + gl->BindFramebuffer (GL_READ_FRAMEBUFFER, 0); + + ret = gst_gl_context_check_framebuffer_status (this->priv->other_context, GL_READ_FRAMEBUFFER); + if (!ret) { + GST_ERROR ("FBO errors"); + goto errors; + } + + guint dst_tex = *(guint *) this->priv->mapped_frame.data[0]; + gl->BindTexture (GL_TEXTURE_2D, dst_tex); + if (gl->BlitFramebuffer) { + gl->BindFramebuffer (GL_DRAW_FRAMEBUFFER, this->priv->fbo); + gl->FramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_TEXTURE_2D, dst_tex, 0); + + ret = gst_gl_context_check_framebuffer_status (this->priv->other_context, GL_DRAW_FRAMEBUFFER); + if (!ret) { + GST_ERROR ("FBO errors"); + goto errors; + } + gl->ReadBuffer (GL_BACK); + gl->BlitFramebuffer (0, 0, width, height, + 0, 0, width, height, + GL_COLOR_BUFFER_BIT, GL_LINEAR); + } else { + gl->CopyTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, width, height, 0); + } + } + + gst_video_frame_unmap (&this->priv->mapped_frame); + gl->BindFramebuffer (GL_FRAMEBUFFER, 0); + + if (this->priv->context) { + sync_meta = gst_buffer_get_gl_sync_meta (this->priv->buffer); + if (!sync_meta) { + sync_meta = gst_buffer_add_gl_sync_meta (this->priv->context, this->priv->buffer); + } + gst_gl_sync_meta_set_sync_point (sync_meta, this->priv->other_context); + } + + GST_DEBUG ("rendering finished"); + +done: + gst_gl_context_activate (this->priv->other_context, FALSE); + + this->priv->result = ret; + this->priv->produced_buffer = this->priv->buffer; + this->priv->buffer = NULL; + this->priv->updated = TRUE; + g_cond_signal (&this->priv->update_cond); + g_mutex_unlock (&this->priv->lock); + return; + +errors: + gl->BindFramebuffer (GL_FRAMEBUFFER, 0); + gst_video_frame_unmap (&this->priv->mapped_frame); + goto done; +} + +void +Qt6GLWindow::onSceneGraphInitialized() +{ + QSGRendererInterface *renderer = source->rendererInterface(); + if (!renderer) + return; + + if (renderer->graphicsApi() != QSGRendererInterface::GraphicsApi::OpenGL) { + GST_WARNING ("%p scene graph initialized with a non-OpenGL renderer interface", this); + return; + } + + this->priv->initted = gst_qml6_get_gl_wrapcontext (this->priv->display, + &this->priv->other_context, &this->priv->context); + + if (this->priv->initted && this->priv->other_context) { + const GstGLFuncs *gl; + + gst_gl_context_activate (this->priv->other_context, TRUE); + gl = this->priv->other_context->gl_vtable; + + gl->GenFramebuffers (1, &this->priv->fbo); + + gst_gl_context_activate (this->priv->other_context, FALSE); + } + + GST_DEBUG ("%p created wrapped GL context %" GST_PTR_FORMAT, this, + this->priv->other_context); +} + +void +Qt6GLWindow::onSceneGraphInvalidated() +{ + GST_DEBUG ("scene graph invalidated"); + + if (this->priv->fbo && this->priv->other_context) { + const GstGLFuncs *gl; + + gst_gl_context_activate (this->priv->other_context, TRUE); + gl = this->priv->other_context->gl_vtable; + + gl->DeleteFramebuffers (1, &this->priv->fbo); + + gst_gl_context_activate (this->priv->other_context, FALSE); + } + + gst_clear_buffer (&this->priv->buffer); + gst_clear_buffer (&this->priv->produced_buffer); +} + +bool +Qt6GLWindow::getGeometry(int * width, int * height) +{ + if (width == NULL || height == NULL) + return FALSE; + + *width = this->source->width(); + *height = this->source->height(); + + return TRUE; +} + +GstGLContext * +qt6_gl_window_get_qt_context (Qt6GLWindow * qt6_gl_window) +{ + g_return_val_if_fail (qt6_gl_window != NULL, NULL); + + if (!qt6_gl_window->priv->other_context) + return NULL; + + return (GstGLContext *) gst_object_ref (qt6_gl_window->priv->other_context); +} + +GstGLDisplay * +qt6_gl_window_get_display (Qt6GLWindow * qt6_gl_window) +{ + g_return_val_if_fail (qt6_gl_window != NULL, NULL); + + if (!qt6_gl_window->priv->display) + return NULL; + + return (GstGLDisplay *) gst_object_ref (qt6_gl_window->priv->display); +} + +GstGLContext * +qt6_gl_window_get_context (Qt6GLWindow * qt6_gl_window) +{ + g_return_val_if_fail (qt6_gl_window != NULL, NULL); + + if (!qt6_gl_window->priv->context) + return NULL; + + return (GstGLContext *) gst_object_ref (qt6_gl_window->priv->context); +} + +gboolean +qt6_gl_window_set_context (Qt6GLWindow * qt6_gl_window, GstGLContext * context) +{ + g_return_val_if_fail (qt6_gl_window != NULL, FALSE); + + if (qt6_gl_window->priv->context && qt6_gl_window->priv->context != context) + return FALSE; + + gst_object_replace ((GstObject **) &qt6_gl_window->priv->context, (GstObject *) context); + + return TRUE; +} + +gboolean +qt6_gl_window_is_scenegraph_initialized (Qt6GLWindow * qt6_gl_window) +{ + g_return_val_if_fail (qt6_gl_window != NULL, FALSE); + + return qt6_gl_window->priv->initted; +} + +GstBuffer * +qt6_gl_window_take_buffer (Qt6GLWindow * qt6_gl_window, GstCaps ** updated_caps) +{ + g_return_val_if_fail (qt6_gl_window != NULL, FALSE); + g_return_val_if_fail (qt6_gl_window->priv->initted, FALSE); + GstBuffer *ret; + + g_mutex_lock (&qt6_gl_window->priv->lock); + + if (qt6_gl_window->priv->quit){ + GST_DEBUG("about to quit, drop this buffer"); + g_mutex_unlock (&qt6_gl_window->priv->lock); + return NULL; + } + + while (!qt6_gl_window->priv->produced_buffer && qt6_gl_window->priv->result) + g_cond_wait (&qt6_gl_window->priv->update_cond, &qt6_gl_window->priv->lock); + + ret = qt6_gl_window->priv->produced_buffer; + qt6_gl_window->priv->produced_buffer = NULL; + + if (qt6_gl_window->priv->new_caps) { + *updated_caps = gst_video_info_to_caps (&qt6_gl_window->priv->v_info); + gst_caps_set_features (*updated_caps, 0, + gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_GL_MEMORY)); + qt6_gl_window->priv->new_caps = FALSE; + } + + g_mutex_unlock (&qt6_gl_window->priv->lock); + + return ret; +} + +void +qt6_gl_window_use_default_fbo (Qt6GLWindow * qt6_gl_window, gboolean useDefaultFbo) +{ + g_return_if_fail (qt6_gl_window != NULL); + + g_mutex_lock (&qt6_gl_window->priv->lock); + + GST_DEBUG ("set to use default fbo %d", useDefaultFbo); + qt6_gl_window->priv->useDefaultFbo = useDefaultFbo; + + g_mutex_unlock (&qt6_gl_window->priv->lock); +} + +void +qt6_gl_window_unlock(Qt6GLWindow* qt6_gl_window) +{ + g_mutex_lock(&qt6_gl_window->priv->lock); + + GST_DEBUG("unlock window"); + qt6_gl_window->priv->result = FALSE; + g_cond_signal(&qt6_gl_window->priv->update_cond); + + g_mutex_unlock(&qt6_gl_window->priv->lock); +} + +void +qt6_gl_window_unlock_stop(Qt6GLWindow* qt6_gl_window) +{ + g_mutex_lock(&qt6_gl_window->priv->lock); + + GST_DEBUG("unlock stop window"); + qt6_gl_window->priv->result = TRUE; + g_cond_signal(&qt6_gl_window->priv->update_cond); + + g_mutex_unlock(&qt6_gl_window->priv->lock); +} diff --git a/subprojects/gst-plugins-good/ext/qt6/qt6glwindow.h b/subprojects/gst-plugins-good/ext/qt6/qt6glwindow.h new file mode 100644 index 0000000000..c964da23b0 --- /dev/null +++ b/subprojects/gst-plugins-good/ext/qt6/qt6glwindow.h @@ -0,0 +1,69 @@ +/* + * GStreamer + * Copyright (C) 2016 Freescale Semiconductor, Inc. All rights reserved. + * Copyright (C) 2022 Matthew Waters + * + * 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 __QT6_GL_WINDOW_H__ +#define __QT6_GL_WINDOW_H__ + +#include +#include + +#include "gstqt6gl.h" +#include +#include +#include + +typedef struct _Qt6GLWindowPrivate Qt6GLWindowPrivate; + +class Qt6GLWindow : public QQuickWindow, protected QOpenGLFunctions +{ + Q_OBJECT +public: + Qt6GLWindow (QWindow * parent = NULL, QQuickWindow *source = NULL); + ~Qt6GLWindow (); + bool getGeometry (int * width, int * height); + + /* private for C interface ... */ + Qt6GLWindowPrivate *priv; + +private Q_SLOTS: + void beforeRendering (); + void afterRendering (); + void onSceneGraphInitialized (); + void onSceneGraphInvalidated (); + +private: + QQuickWindow * source; +}; + +extern "C" +{ +GstBuffer * qt6_gl_window_take_buffer (Qt6GLWindow * qt6_window, GstCaps ** updated_caps); +GstGLContext * qt6_gl_window_get_qt_context (Qt6GLWindow * qt6_window); +GstGLContext * qt6_gl_window_get_context (Qt6GLWindow * qt6_window); +gboolean qt6_gl_window_set_context (Qt6GLWindow * qt6_window, GstGLContext * context); +GstGLDisplay * qt6_gl_window_get_display (Qt6GLWindow * qt6_window); +gboolean qt6_gl_window_is_scenegraph_initialized (Qt6GLWindow * qt6_window); +void qt6_gl_window_use_default_fbo (Qt6GLWindow * qt6_window, gboolean useDefaultFbo); +void qt6_gl_window_unlock(Qt6GLWindow* qt6_window); +void qt6_gl_window_unlock_stop(Qt6GLWindow* qt6_window); +} + +#endif /* __QT6_GL_WINDOW_H__ */ diff --git a/subprojects/gst-plugins-good/tests/examples/qt6/meson.build b/subprojects/gst-plugins-good/tests/examples/qt6/meson.build index 23d3fb6c5d..e04df6784f 100644 --- a/subprojects/gst-plugins-good/tests/examples/qt6/meson.build +++ b/subprojects/gst-plugins-good/tests/examples/qt6/meson.build @@ -15,3 +15,4 @@ if not qt6qml_example_deps.found() endif subdir('qmlsink') +subdir('qmlsrc') diff --git a/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/grabqml.pro b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/grabqml.pro new file mode 100644 index 0000000000..9c97c670a4 --- /dev/null +++ b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/grabqml.pro @@ -0,0 +1,20 @@ +TEMPLATE = app + +QT += qml quick widgets + +QT_CONFIG -= no-pkg-config +CONFIG += link_pkgconfig debug +PKGCONFIG = \ + gstreamer-1.0 \ + gstreamer-video-1.0 + +DEFINES += GST_USE_UNSTABLE_API + +INCLUDEPATH += ../lib + +SOURCES += main.cpp + +RESOURCES += qmlsrc.qrc + +# Additional import path used to resolve QML modules in Qt Creator's code model +QML_IMPORT_PATH = diff --git a/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.cpp b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.cpp new file mode 100644 index 0000000000..9ceb648627 --- /dev/null +++ b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.cpp @@ -0,0 +1,82 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +class SetPlaying : public QRunnable +{ +public: + SetPlaying(GstElement *); + ~SetPlaying(); + + void run (); + +private: + GstElement * pipeline_; +}; + +SetPlaying::SetPlaying (GstElement * pipeline) +{ + this->pipeline_ = pipeline ? static_cast (gst_object_ref (pipeline)) : NULL; +} + +SetPlaying::~SetPlaying () +{ + if (this->pipeline_) + gst_object_unref (this->pipeline_); + +} + +void +SetPlaying::run () +{ + if (this->pipeline_) + gst_element_set_state (this->pipeline_, GST_STATE_PLAYING); +} + +int main(int argc, char *argv[]) +{ + int ret; + + QGuiApplication app(argc, argv); + gst_init (&argc, &argv); + + QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL); + + GstElement *pipeline = gst_pipeline_new (NULL); + GstElement *src = gst_element_factory_make ("qml6glsrc", NULL); + GstElement *sink = gst_element_factory_make ("glimagesink", NULL); + + g_assert (src && sink); + + gst_bin_add_many (GST_BIN (pipeline), src, sink, NULL); + gst_element_link_many (src, sink, NULL); + + QQmlApplicationEngine engine; + engine.load(QUrl(QStringLiteral("qrc:/main.qml"))); + + QQuickWindow *rootObject; + + /* find and set the QQuickWindow on the src */ + rootObject = static_cast (engine.rootObjects().first()); + g_object_set(src, "window", rootObject, NULL); + g_object_set(src, "use-default-fbo", TRUE, NULL); + /* output buffer of qmlglsrc is vertical flip, get the image orientation tag */ + g_object_set(sink, "rotate-method", 8, NULL); + + rootObject->scheduleRenderJob (new SetPlaying (pipeline), + QQuickWindow::BeforeSynchronizingStage); + + ret = app.exec(); + + gst_element_set_state (pipeline, GST_STATE_NULL); + gst_object_unref (pipeline); + + gst_deinit (); + + return ret; +} diff --git a/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.qml b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.qml new file mode 100644 index 0000000000..11b7047faf --- /dev/null +++ b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/main.qml @@ -0,0 +1,64 @@ +import QtQuick 6.0 +import QtQuick.Controls 6.0 +import QtQuick.Dialogs 6.0 +import QtQuick.Window 6.0 + +ApplicationWindow { + id: window + visible: true + width: 640 + height: 480 + x: 30 + y: 30 + color: "dodgerblue" + + Item { + anchors.fill: parent + + Rectangle { + color: Qt.rgba(1, 1, 1, 0.7) + border.width: 1 + border.color: "white" + anchors.bottomMargin: 15 + anchors.horizontalCenter: parent.horizontalCenter + width : parent.width - 30 + height: parent.height - 30 + radius: 8 + + Text { + id: text1 + anchors.centerIn: parent + text: "Hello World!" + font.pointSize: 24 + visible: timer.tex1_visible + } + + Text { + id: text2 + anchors.centerIn: parent + text: "This is qmlglsrc demo!" + font.pointSize: 24 + visible: timer.tex2_visible + } + + Timer { + id: timer + property int count: 0 + property int tex1_visible: 1 + property int tex2_visible: 0 + interval: 30; running: true; repeat: true + onTriggered: { + count++; + if (count%2 == 0) { + tex1_visible = 1; + tex2_visible = 0; + } + else { + tex1_visible = 0; + tex2_visible = 1; + } + } + } + } + } +} diff --git a/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/meson.build b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/meson.build new file mode 100644 index 0000000000..11ba53372c --- /dev/null +++ b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/meson.build @@ -0,0 +1,11 @@ +sources = [ + 'main.cpp', +] + +qt_preprocessed = qt6_mod.preprocess(qresources : 'qmlsrc.qrc') +executable('qml6src', sources, qt_preprocessed, + dependencies : [gst_dep, qt6qml_example_deps], + override_options : ['cpp_std=c++17'], + c_args : gst_plugins_good_args, + include_directories : [configinc], + install: false) diff --git a/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/qmlsrc.qrc b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/qmlsrc.qrc new file mode 100644 index 0000000000..5f6483ac33 --- /dev/null +++ b/subprojects/gst-plugins-good/tests/examples/qt6/qmlsrc/qmlsrc.qrc @@ -0,0 +1,5 @@ + + + main.qml + +