diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlay.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlay.cpp new file mode 100644 index 0000000000..b0eba7cfd7 --- /dev/null +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlay.cpp @@ -0,0 +1,435 @@ +/* + * GStreamer + * Copyright (C) 2023 Seungha Yang + * + * 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:element-d3d11overlay + * @title: d3d11overlay + * + * Provides Direct3D11 render target view to an application so that + * the application overlay/blend application image on the render target view + * + * Since: 1.24 + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "gstd3d11overlay.h" +#include + +GST_DEBUG_CATEGORY_STATIC (gst_d3d11_overlay_debug); +#define GST_CAT_DEFAULT gst_d3d11_overlay_debug + +static GstStaticCaps template_caps = +GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES + (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY, "{ BGRA, RGBA }")); + +enum +{ + SIGNAL_DRAW, + SIGNAL_CAPS_CHANGED, + SIGNAL_LAST, +}; + +static guint gst_d3d11_overlay_signals[SIGNAL_LAST]; + +struct _GstD3D11Overlay +{ + GstD3D11BaseFilter parent; + + GstBufferPool *fallback_pool; +}; + +#define gst_d3d11_overlay_parent_class parent_class +G_DEFINE_TYPE (GstD3D11Overlay, gst_d3d11_overlay, GST_TYPE_D3D11_BASE_FILTER); + +static gboolean gst_d3d11_overlay_stop (GstBaseTransform * trans); +static gboolean gst_d3d11_overlay_propose_allocation (GstBaseTransform * trans, + GstQuery * decide_query, GstQuery * query); +static GstFlowReturn gst_d3d11_overlay_transform_ip (GstBaseTransform * trans, + GstBuffer * buf); +static gboolean gst_d3d11_overlay_set_info (GstD3D11BaseFilter * filter, + GstCaps * in_caps, GstVideoInfo * in_info, GstCaps * out_caps, + GstVideoInfo * out_info); + +static void +gst_d3d11_overlay_class_init (GstD3D11OverlayClass * klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstBaseTransformClass *trans_class = GST_BASE_TRANSFORM_CLASS (klass); + GstD3D11BaseFilterClass *filter_class = GST_D3D11_BASE_FILTER_CLASS (klass); + GstCaps *caps; + + /** + * GstD3D11Overlay::draw: + * @overlay: Overlay element emitting the signal + * @device: GstD3D11Device object + * @rtv: ID3D11RenderTargetView handle + * @timestamp: Timestamp (see #GstClockTime) of the current buffer + * @duration: Duration (see #GstClockTime) of the current buffer + * + * This signal is emitted when the overlay should be drawn with + * gst_d3d11_device_lock taken. + * + * Returns: %TRUE if rendering operation happend + * + * Since: 1.24 + */ + gst_d3d11_overlay_signals[SIGNAL_DRAW] = g_signal_new ("draw", + G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, nullptr, nullptr, + nullptr, G_TYPE_BOOLEAN, 4, GST_TYPE_OBJECT, G_TYPE_POINTER, + G_TYPE_UINT64, G_TYPE_UINT64); + + /** + * GstD3D11Overlay::caps-changed: + * @overlay: Overlay element emitting the signal + * @caps: #GstCaps of the element + + * This signal is emitted when the caps or associated GstD3D11Device + * of the element has changed + * + * Since: 1.24 + */ + gst_d3d11_overlay_signals[SIGNAL_CAPS_CHANGED] = g_signal_new ("caps-changed", + G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, nullptr, nullptr, + nullptr, G_TYPE_NONE, 1, GST_TYPE_CAPS); + + caps = gst_d3d11_get_updated_template_caps (&template_caps); + gst_element_class_add_pad_template (element_class, + gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps)); + + gst_element_class_add_pad_template (element_class, + gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, caps)); + gst_caps_unref (caps); + + gst_element_class_set_static_metadata (element_class, + "Direct3D11 Overlay", "Filter/Video", + "Provides application renderable Direct3D11 render target view", + "Seungha Yang "); + + trans_class->passthrough_on_same_caps = FALSE; + + trans_class->stop = GST_DEBUG_FUNCPTR (gst_d3d11_overlay_stop); + trans_class->propose_allocation = + GST_DEBUG_FUNCPTR (gst_d3d11_overlay_propose_allocation); + trans_class->transform_ip = + GST_DEBUG_FUNCPTR (gst_d3d11_overlay_transform_ip); + + filter_class->set_info = GST_DEBUG_FUNCPTR (gst_d3d11_overlay_set_info); + + GST_DEBUG_CATEGORY_INIT (gst_d3d11_overlay_debug, + "d3d11overlay", 0, "d3d11overlay"); +} + +static void +gst_d3d11_overlay_init (GstD3D11Overlay * download) +{ +} + +static gboolean +gst_d3d11_overlay_stop (GstBaseTransform * trans) +{ + GstD3D11Overlay *self = GST_D3D11_OVERLAY (trans); + + if (self->fallback_pool) { + gst_buffer_pool_set_active (self->fallback_pool, FALSE); + gst_clear_object (&self->fallback_pool); + } + + return GST_BASE_TRANSFORM_CLASS (parent_class)->stop (trans); +} + +static gboolean +gst_d3d11_overlay_propose_allocation (GstBaseTransform * trans, + GstQuery * decide_query, GstQuery * query) +{ + GstD3D11BaseFilter *filter = GST_D3D11_BASE_FILTER (trans); + GstVideoInfo info; + GstCaps *caps; + guint size; + GstBufferPool *pool = nullptr; + gboolean update_pool = FALSE; + guint min = 0; + guint max = 0; + GstStructure *config; + GstD3D11AllocationParams *params; + + if (!GST_BASE_TRANSFORM_CLASS (parent_class)->propose_allocation (trans, + decide_query, query)) + return FALSE; + + gst_query_parse_allocation (query, &caps, nullptr); + + if (!caps) { + GST_WARNING_OBJECT (filter, "Query without caps"); + return FALSE; + } + + if (!gst_video_info_from_caps (&info, caps)) { + GST_ERROR_OBJECT (filter, "Invalid caps %" GST_PTR_FORMAT, caps); + return FALSE; + } + + size = GST_VIDEO_INFO_SIZE (&info); + + if (gst_query_get_n_allocation_pools (query) > 0) { + gst_query_parse_nth_allocation_pool (query, 0, &pool, nullptr, &min, &max); + + if (pool) { + if (!GST_IS_D3D11_BUFFER_POOL (pool)) { + gst_clear_object (&pool); + } else { + GstD3D11BufferPool *dpool = GST_D3D11_BUFFER_POOL (pool); + if (dpool->device != filter->device) + gst_clear_object (&pool); + } + } + + update_pool = TRUE; + } + + if (!pool) + pool = gst_d3d11_buffer_pool_new (filter->device); + + config = gst_buffer_pool_get_config (pool); + + gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META); + gst_buffer_pool_config_set_params (config, caps, size, 0, 0); + + params = gst_buffer_pool_config_get_d3d11_allocation_params (config); + if (params) { + params->desc[0].BindFlags |= + (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET); + } else { + params = gst_d3d11_allocation_params_new (filter->device, &info, + GST_D3D11_ALLOCATION_FLAG_DEFAULT, + D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET, 0); + } + + gst_buffer_pool_config_set_d3d11_allocation_params (config, params); + gst_d3d11_allocation_params_free (params); + + if (!gst_buffer_pool_set_config (pool, config)) { + GST_ERROR_OBJECT (filter, "Couldn't set pool config"); + gst_object_unref (pool); + return FALSE; + } + + /* d3d11 buffer pool will update buffer size based on allocated texture, + * get size from config again */ + config = gst_buffer_pool_get_config (pool); + gst_buffer_pool_config_get_params (config, nullptr, &size, nullptr, nullptr); + gst_structure_free (config); + + 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_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, nullptr); + + return TRUE; +} + +static gboolean +gst_d3d11_overlay_copy_memory (GstD3D11Overlay * self, GstMemory * src, + GstMemory * dst) +{ + GstD3D11BaseFilter *filter = GST_D3D11_BASE_FILTER (self); + GstMapInfo src_map; + GstMapInfo dst_map; + ID3D11Resource *dst_texture, *src_texture; + ID3D11DeviceContext *context; + D3D11_TEXTURE2D_DESC src_desc, dst_desc; + D3D11_BOX src_box; + + context = gst_d3d11_device_get_device_context_handle (filter->device); + + if (!gst_memory_map (src, + &src_map, (GstMapFlags) (GST_MAP_READ | GST_MAP_D3D11))) { + GST_ERROR_OBJECT (self, "Couldn't map src memory"); + return FALSE; + } + + if (!gst_memory_map (dst, + &dst_map, (GstMapFlags) (GST_MAP_WRITE | GST_MAP_D3D11))) { + GST_ERROR_OBJECT (self, "Couldn't map dst memory"); + gst_memory_unmap (src, &src_map); + return FALSE; + } + + gst_d3d11_memory_get_texture_desc (GST_D3D11_MEMORY_CAST (src), &src_desc); + gst_d3d11_memory_get_texture_desc (GST_D3D11_MEMORY_CAST (dst), &dst_desc); + + src_texture = (ID3D11Texture2D *) src_map.data; + dst_texture = (ID3D11Texture2D *) dst_map.data; + + src_box.front = 0; + src_box.back = 1; + src_box.left = 0; + src_box.top = 0; + src_box.right = MIN (src_desc.Width, dst_desc.Width); + src_box.bottom = MIN (src_desc.Height, dst_desc.Height); + + context->CopySubresourceRegion (dst_texture, + 0, 0, 0, 0, src_texture, 0, &src_box); + + gst_memory_unmap (src, &src_map); + gst_memory_unmap (dst, &dst_map); + + return TRUE; +} + +static GstFlowReturn +gst_d3d11_overlay_transform_ip (GstBaseTransform * trans, GstBuffer * buf) +{ + GstD3D11BaseFilter *filter = GST_D3D11_BASE_FILTER (trans); + GstD3D11Overlay *self = GST_D3D11_OVERLAY (trans); + GstMemory *mem; + GstD3D11Memory *dmem; + ID3D11RenderTargetView *rtv; + GstBuffer *fallback_buf = nullptr; + GstMemory *fallback_mem = nullptr; + GstD3D11Memory *fallback_dmem = nullptr; + GstMemory *target_mem; + GstMapInfo map; + gboolean rendered = FALSE; + GstFlowReturn ret = GST_FLOW_OK; + + mem = gst_buffer_peek_memory (buf, 0); + if (!gst_is_d3d11_memory (mem)) { + GST_ERROR_OBJECT (self, "Not a d3d11 memory"); + return GST_FLOW_ERROR; + } + + dmem = GST_D3D11_MEMORY_CAST (mem); + rtv = gst_d3d11_memory_get_render_target_view (dmem, 0); + if (!rtv) { + GST_DEBUG_OBJECT (self, "RTV is unavailable"); + + gst_buffer_pool_acquire_buffer (self->fallback_pool, &fallback_buf, + nullptr); + if (!fallback_buf) { + GST_ERROR_OBJECT (self, "Couldn't allocate fallback buffer"); + return GST_FLOW_ERROR; + } + } + + GstD3D11DeviceLockGuard lk (filter->device); + if (fallback_buf) { + fallback_mem = gst_buffer_peek_memory (fallback_buf, 0); + + if (!gst_d3d11_overlay_copy_memory (self, mem, fallback_mem)) { + GST_ERROR_OBJECT (self, "Couldn't copy input memory to fallback"); + gst_buffer_unref (fallback_buf); + return GST_FLOW_ERROR; + } + + fallback_dmem = GST_D3D11_MEMORY_CAST (fallback_mem); + rtv = gst_d3d11_memory_get_render_target_view (fallback_dmem, 0); + if (!rtv) { + GST_ERROR_OBJECT (self, "RTV is unavailable"); + gst_buffer_unref (fallback_buf); + return GST_FLOW_ERROR; + } + + target_mem = fallback_mem; + } else { + target_mem = mem; + } + + if (!gst_memory_map (target_mem, &map, + (GstMapFlags) (GST_MAP_WRITE | GST_MAP_D3D11))) { + GST_ERROR_OBJECT (self, "Couldn't map render target memory"); + gst_clear_buffer (&fallback_buf); + return GST_FLOW_ERROR; + } + + g_signal_emit (self, gst_d3d11_overlay_signals[SIGNAL_DRAW], 0, + filter->device, rtv, GST_BUFFER_PTS (buf), GST_BUFFER_DURATION (buf), + &rendered); + + GST_LOG_OBJECT (self, "Draw signal return: %d", rendered); + + gst_memory_unmap (target_mem, &map); + + if (fallback_buf && rendered) { + if (!gst_d3d11_overlay_copy_memory (self, fallback_mem, mem)) { + GST_ERROR_OBJECT (self, "Couldn't copy back to input memory"); + ret = GST_FLOW_ERROR; + } + } + + gst_clear_buffer (&fallback_buf); + + return ret; +} + +static gboolean +gst_d3d11_overlay_set_info (GstD3D11BaseFilter * filter, GstCaps * in_caps, + GstVideoInfo * in_info, GstCaps * out_caps, GstVideoInfo * out_info) +{ + GstD3D11Overlay *self = GST_D3D11_OVERLAY (filter); + GstStructure *config; + GstD3D11AllocationParams *params; + + if (self->fallback_pool) { + gst_buffer_pool_set_active (self->fallback_pool, FALSE); + gst_object_unref (self->fallback_pool); + } + + self->fallback_pool = gst_d3d11_buffer_pool_new (filter->device); + config = gst_buffer_pool_get_config (self->fallback_pool); + + gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META); + + gst_buffer_pool_config_set_params (config, in_caps, + GST_VIDEO_INFO_SIZE (in_info), 0, 0); + + params = gst_d3d11_allocation_params_new (filter->device, in_info, + GST_D3D11_ALLOCATION_FLAG_DEFAULT, + D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET, 0); + + gst_buffer_pool_config_set_d3d11_allocation_params (config, params); + gst_d3d11_allocation_params_free (params); + + if (!gst_buffer_pool_set_config (self->fallback_pool, config)) { + GST_ERROR_OBJECT (self, "Couldn't set pool config"); + gst_clear_object (&self->fallback_pool); + return FALSE; + } + + if (!gst_buffer_pool_set_active (self->fallback_pool, TRUE)) { + GST_ERROR_OBJECT (self, "Couldn't activate pool"); + gst_clear_object (&self->fallback_pool); + return FALSE; + } + + GST_DEBUG_OBJECT (self, "New caps %" GST_PTR_FORMAT, in_caps); + + g_signal_emit (self, gst_d3d11_overlay_signals[SIGNAL_CAPS_CHANGED], 0, + in_caps); + + return TRUE; +} diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlay.h b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlay.h new file mode 100644 index 0000000000..51e7ddd2eb --- /dev/null +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlay.h @@ -0,0 +1,32 @@ +/* + * GStreamer + * Copyright (C) 2023 Seungha Yang + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include "gstd3d11basefilter.h" + +G_BEGIN_DECLS + +#define GST_TYPE_D3D11_OVERLAY (gst_d3d11_overlay_get_type()) +G_DECLARE_FINAL_TYPE (GstD3D11Overlay, + gst_d3d11_overlay, GST, D3D11_OVERLAY, GstD3D11BaseFilter); + +G_END_DECLS + diff --git a/subprojects/gst-plugins-bad/sys/d3d11/meson.build b/subprojects/gst-plugins-bad/sys/d3d11/meson.build index 4c4e0bfb10..bc3ea06959 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/meson.build +++ b/subprojects/gst-plugins-bad/sys/d3d11/meson.build @@ -9,6 +9,7 @@ d3d11_sources = [ 'gstd3d11h264dec.cpp', 'gstd3d11h265dec.cpp', 'gstd3d11mpeg2dec.cpp', + 'gstd3d11overlay.cpp', 'gstd3d11overlaycompositor.cpp', 'gstd3d11pluginutils.cpp', 'gstd3d11testsrc.cpp', diff --git a/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp b/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp index b5effbbf25..9d9963b32b 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp @@ -75,6 +75,7 @@ #include "gstd3d11av1dec.h" #include "gstd3d11deinterlace.h" #include "gstd3d11testsrc.h" +#include "gstd3d11overlay.h" #if !GST_D3D11_WINAPI_ONLY_APP #include "gstd3d11screencapturesrc.h" @@ -235,6 +236,8 @@ plugin_init (GstPlugin * plugin) "d3d11compositor", GST_RANK_SECONDARY, GST_TYPE_D3D11_COMPOSITOR); gst_element_register (plugin, "d3d11testsrc", GST_RANK_NONE, GST_TYPE_D3D11_TEST_SRC); + gst_element_register (plugin, + "d3d11overlay", GST_RANK_NONE, GST_TYPE_D3D11_OVERLAY); #if !GST_D3D11_WINAPI_ONLY_APP if (gst_d3d11_is_windows_8_or_greater ()) { diff --git a/subprojects/gst-plugins-bad/tests/examples/d3d11/d3d11overlay.cpp b/subprojects/gst-plugins-bad/tests/examples/d3d11/d3d11overlay.cpp new file mode 100644 index 0000000000..ba36b9bb84 --- /dev/null +++ b/subprojects/gst-plugins-bad/tests/examples/d3d11/d3d11overlay.cpp @@ -0,0 +1,341 @@ +/* + * GStreamer + * Copyright (C) 2023 Seungha Yang + * + * 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 +#include +#include +#include +#include +#include + +/* *INDENT-OFF* */ +using namespace Microsoft::WRL; + +struct OverlayContext +{ + GstElement *pipeline = nullptr; + + ID2D1Factory *d2d_factory = nullptr; + IDWriteFactory *dwrite_factory = nullptr; + + IDWriteTextFormat *format = nullptr; + IDWriteTextLayout *layout = nullptr; + + std::wstring text; + + FLOAT width; + FLOAT height; + FLOAT origin_y; + gint text_width; + gint last_position = 0; + + GMainLoop *loop = nullptr; +}; +/* *INDENT-ON* */ + +static gboolean +bus_msg (GstBus * bus, GstMessage * msg, OverlayContext * context) +{ + switch (GST_MESSAGE_TYPE (msg)) { + case GST_MESSAGE_ERROR:{ + GError *err; + gchar *dbg; + + gst_message_parse_error (msg, &err, &dbg); + gst_printerrln ("ERROR %s", err->message); + if (dbg) + gst_printerrln ("ERROR debug information: %s", dbg); + g_clear_error (&err); + g_free (dbg); + + g_main_loop_quit (context->loop); + break; + } + case GST_MESSAGE_EOS: + gst_println ("Got EOS"); + g_main_loop_quit (context->loop); + break; + default: + break; + } + + return TRUE; +} + +/* This callback will be called with gst_d3d11_device_lock() taken by + * d3d11overlay. We can perform GPU operation here safely */ +static gboolean +on_draw (GstElement * overlay, GstD3D11Device * device, + ID3D11RenderTargetView * rtv, GstClockTime pts, GstClockTime duration, + OverlayContext * context) +{ + ComPtr < ID3D11Resource > resource; + ComPtr < IDXGISurface > surface; + ComPtr < ID2D1RenderTarget > d2d_target; + ComPtr < ID2D1SolidColorBrush > text_brush; + ComPtr < ID2D1SolidColorBrush > bg_brush; + HRESULT hr; + ID2D1Factory *d2d_factory; + FLOAT position; + + rtv->GetResource (&resource); + hr = resource.As (&surface); + g_assert (SUCCEEDED (hr)); + + d2d_factory = context->d2d_factory; + D2D1_RENDER_TARGET_PROPERTIES props; + props.type = D2D1_RENDER_TARGET_TYPE_DEFAULT; + props.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM; + props.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED; + /* default DPI */ + props.dpiX = 0; + props.dpiY = 0; + props.usage = D2D1_RENDER_TARGET_USAGE_NONE; + props.minLevel = D2D1_FEATURE_LEVEL_DEFAULT; + + /* Creates D2D render target using swapchin's backbuffer */ + hr = d2d_factory->CreateDxgiSurfaceRenderTarget (surface.Get (), props, + &d2d_target); + g_assert (SUCCEEDED (hr)); + + hr = d2d_target->CreateSolidColorBrush (D2D1::ColorF (D2D1::ColorF::Black), + &bg_brush); + g_assert (SUCCEEDED (hr)); + + hr = d2d_target->CreateSolidColorBrush (D2D1::ColorF (D2D1::ColorF::White), + &text_brush); + g_assert (SUCCEEDED (hr)); + + d2d_target->BeginDraw (); + + /* Draw background */ + d2d_target->FillRectangle (D2D1::RectF (0, context->origin_y, context->width, + context->height), bg_brush.Get ()); + + /* Draw text */ + position = -context->last_position; + + do { + d2d_target->DrawTextLayout (D2D1::Point2F (position, context->origin_y), + context->layout, text_brush.Get (), + D2D1_DRAW_TEXT_OPTIONS_CLIP | D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT); + position = position + context->text_width; + } while (position < context->width); + + d2d_target->EndDraw (); + + context->last_position += 2; + if (context->last_position >= context->text_width) { + context->last_position %= context->text_width; + } + + return TRUE; +} + +gint +main (gint argc, gchar ** argv) +{ + GOptionContext *option_ctx; + GError *error = nullptr; + gboolean ret; + gchar *text = nullptr; + gint width = 1280; + gint height = 720; + GOptionEntry options[] = { + {"text", 0, 0, G_OPTION_ARG_STRING, &text, "Text to render", nullptr}, + {"width", 0, 0, G_OPTION_ARG_INT, &width, "Width of video stream", nullptr}, + {"height", 0, 0, G_OPTION_ARG_INT, &height, "Height of video stream", + nullptr}, + {nullptr} + }; + OverlayContext context; + GstStateChangeReturn sret; + HRESULT hr; + std::wstring text_wide; + std::string pipeline_str; + GstElement *overlay; + DWRITE_TEXT_METRICS metrics; + FLOAT font_size; + bool was_decreased = false; + DWRITE_TEXT_RANGE range; + FLOAT text_height; + gchar **win32_argv; + ComPtr < IDWriteTextFormat > text_format; + ComPtr < IDWriteTextLayout > text_layout; + + win32_argv = g_win32_get_command_line (); + + option_ctx = g_option_context_new ("d3d11overlay example"); + g_option_context_add_main_entries (option_ctx, options, nullptr); + g_option_context_add_group (option_ctx, gst_init_get_option_group ()); + ret = g_option_context_parse_strv (option_ctx, &win32_argv, &error); + g_option_context_free (option_ctx); + g_strfreev (win32_argv); + + if (!ret) { + gst_printerrln ("option parsing failed: %s", error->message); + g_clear_error (&error); + return 1; + } + + /* Prepare device independent D2D objects */ + hr = D2D1CreateFactory (D2D1_FACTORY_TYPE_MULTI_THREADED, + IID_PPV_ARGS (&context.d2d_factory)); + if (FAILED (hr)) { + gst_printerrln ("Couldn't create D2D factory"); + return 1; + } + + hr = DWriteCreateFactory (DWRITE_FACTORY_TYPE_SHARED, + __uuidof (context.dwrite_factory), + reinterpret_cast < IUnknown ** >(&context.dwrite_factory)); + if (FAILED (hr)) { + gst_printerrln ("Couldn't create DirectWrite factory"); + return 1; + } + + hr = context.dwrite_factory->CreateTextFormat (L"Arial", nullptr, + DWRITE_FONT_WEIGHT_BOLD, DWRITE_FONT_STYLE_NORMAL, + DWRITE_FONT_STRETCH_NORMAL, 12.0f, L"en-us", &text_format); + if (FAILED (hr)) { + gst_printerrln ("Couldn't create IDWriteTextFormat"); + return 1; + } + + text_format->SetTextAlignment (DWRITE_TEXT_ALIGNMENT_LEADING); + text_format->SetParagraphAlignment (DWRITE_PARAGRAPH_ALIGNMENT_CENTER); + text_format->SetWordWrapping (DWRITE_WORD_WRAPPING_NO_WRAP); + + if (text && text[0] != '\0') { + std::wstring_convert < std::codecvt_utf8_utf16 < wchar_t >>converter; + text_wide = converter.from_bytes (text); + } else { + /* *INDENT-OFF* */ + text_wide = + std::wstring (L"Hello GStreamer! ๐Ÿ˜Š ์•ˆ๋…•ํ•˜์„ธ์š” GStreamer! ๐Ÿ˜‰ ") + + std::wstring (L"เคจเคฎเคธเฅเคคเฅ‡ GStreamer! โค๏ธ Bonjour GStreamer! ๐Ÿ˜ ") + + std::wstring (L"Hallo GStreamer! ๐Ÿ˜Ž Hola GStreamer! ๐Ÿ˜ ") + + std::wstring (L"ใ“ใ‚“ใซใกใฏ GStreamer! โœŒ๏ธ ไฝ ๅฅฝ GStreamer! ๐Ÿ‘"); + /* *INDENT-ON* */ + } + + text_height = (FLOAT) height / 10.0f; + + hr = context.dwrite_factory->CreateTextLayout (text_wide.c_str (), + text_wide.length (), text_format.Get (), G_MAXFLOAT, G_MAXFLOAT, + &text_layout); + if (FAILED (hr)) { + gst_printerrln ("Couldn't create IDWriteTextLayout"); + return 1; + } + + /* Calculate best font size */ + range.startPosition = 0; + range.length = text_wide.length (); + + do { + hr = text_layout->GetMetrics (&metrics); + g_assert (SUCCEEDED (hr)); + + text_layout->GetFontSize (0, &font_size); + if (metrics.height >= (FLOAT) text_height) { + if (font_size > 1.0f) { + font_size -= 0.5f; + was_decreased = true; + hr = text_layout->SetFontSize (font_size, range); + g_assert (SUCCEEDED (hr)); + continue; + } + + break; + } + + if (was_decreased) + break; + + if (metrics.height < text_height) { + if (metrics.height >= text_height * 0.9) + break; + + font_size += 0.5f; + hr = text_layout->SetFontSize (font_size, range); + g_assert (SUCCEEDED (hr)); + continue; + } + } while (true); + + gst_println ("Calculated font size %lf", font_size); + + /* 10 pixels padding per loop */ + text_layout->SetMaxWidth (metrics.widthIncludingTrailingWhitespace + 10); + text_layout->SetMaxHeight (metrics.height); + + context.text = text_wide; + context.origin_y = (FLOAT) height - text_height; + context.width = width; + context.height = height; + context.text_width = metrics.widthIncludingTrailingWhitespace + 10; + context.layout = text_layout.Detach (); + + context.loop = g_main_loop_new (nullptr, FALSE); + + pipeline_str = + "d3d11testsrc ! video/x-raw(memory:D3D11Memory),format=BGRA,width=" + + std::to_string (width) + ",height=" + std::to_string (height) + + ",framerate=60/1 ! d3d11overlay name=overlay ! queue ! d3d11videosink"; + + context.pipeline = gst_parse_launch (pipeline_str.c_str (), nullptr); + g_assert (context.pipeline); + + overlay = gst_bin_get_by_name (GST_BIN (context.pipeline), "overlay"); + g_assert (overlay); + + g_signal_connect (overlay, "draw", G_CALLBACK (on_draw), &context); + gst_object_unref (overlay); + + gst_bus_add_watch (GST_ELEMENT_BUS (context.pipeline), + (GstBusFunc) bus_msg, &context); + + sret = gst_element_set_state (context.pipeline, GST_STATE_PLAYING); + g_assert (sret != GST_STATE_CHANGE_FAILURE); + + g_main_loop_run (context.loop); + + gst_element_set_state (context.pipeline, GST_STATE_NULL); + gst_bus_remove_watch (GST_ELEMENT_BUS (context.pipeline)); + gst_object_unref (context.pipeline); + + context.format->Release (); + context.layout->Release (); + context.d2d_factory->Release (); + context.dwrite_factory->Release (); + + g_main_loop_unref (context.loop); + g_free (text); + + return 0; +} diff --git a/subprojects/gst-plugins-bad/tests/examples/d3d11/meson.build b/subprojects/gst-plugins-bad/tests/examples/d3d11/meson.build index 43ee19b0ef..a8f9d1b8d6 100644 --- a/subprojects/gst-plugins-bad/tests/examples/d3d11/meson.build +++ b/subprojects/gst-plugins-bad/tests/examples/d3d11/meson.build @@ -78,6 +78,14 @@ if d3d11_lib.found() and dxgi_lib.found() and d3dcompiler_lib.found() and have_d dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, gstd3d11_dep, d2d_dep, dwrite_dep], install: false, ) + + executable('d3d11overlay', ['d3d11overlay.cpp'], + c_args : gst_plugins_bad_args + ['-DGST_USE_UNSTABLE_API'], + cpp_args : gst_plugins_bad_args + ['-DGST_USE_UNSTABLE_API'], + include_directories : [configinc, libsinc], + dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, gstd3d11_dep, d2d_dep, dwrite_dep], + install: false, + ) endif endif