mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-14 05:12:09 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/d3d12/gstd3d12videosink.cpp
Seungha Yang 69ea20b739 d3d12videosink: Present on GstVideoOverlay::expose() 
... so that updated backbuffer can be swapped and presented

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7079>
2024-06-24 08:46:24 +00:00

1629 lines
53 KiB
C++
Raw Blame History

/* GStreamer
* Copyright (C) 2023 Seungha Yang <seungha@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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstd3d12videosink.h"
#include "gstd3d12pluginutils.h"
#include "gstd3d12window.h"
#include <mutex>
#include <atomic>
#include <string>
/**
* GstD3D12VideoSinkDisplayFormat:
*
* Swapchain display format
*
* Since: 1.26
*/
#define GST_TYPE_D3D12_VIDEO_SINK_DISPLAY_FORMAT (gst_d3d12_video_sink_display_format_type())
static GType
gst_d3d12_video_sink_display_format_type (void)
{
static GType format_type = 0;
GST_D3D12_CALL_ONCE_BEGIN {
static const GEnumValue format_types[] = {
/**
* GstD3D12VideoSinkDisplayFormat::unknown:
*
* Since: 1.26
*/
{DXGI_FORMAT_UNKNOWN, "DXGI_FORMAT_UNKNOWN", "unknown"},
/**
* GstD3D12VideoSinkDisplayFormat::r10g10b10a2-unorm:
*
* Since: 1.26
*/
{DXGI_FORMAT_R10G10B10A2_UNORM,
"DXGI_FORMAT_R10G10B10A2_UNORM", "r10g10b10a2-unorm"},
/**
* GstD3D12VideoSinkDisplayFormat::r8g8b8a8-unorm:
*
* Since: 1.26
*/
{DXGI_FORMAT_R8G8B8A8_UNORM,
"DXGI_FORMAT_R8G8B8A8_UNORM", "r8g8b8a8-unorm"},
/**
* GstD3D12VideoSinkDisplayFormat::b8g8r8a8-unorm:
*
* Since: 1.26
*/
{DXGI_FORMAT_B8G8R8A8_UNORM,
"DXGI_FORMAT_B8G8R8A8_UNORM", "b8g8r8a8-unorm"},
{0, nullptr, nullptr},
};
format_type = g_enum_register_static ("GstD3D12VideoSinkDisplayFormat",
format_types);
} GST_D3D12_CALL_ONCE_END;
return format_type;
}
enum
{
PROP_0,
PROP_ADAPTER,
PROP_FORCE_ASPECT_RATIO,
PROP_ENABLE_NAVIGATION_EVENTS,
PROP_ROTATE_METHOD,
PROP_FULLSCREEN_ON_ALT_ENTER,
PROP_FULLSCREEN,
PROP_MSAA,
PROP_REDRAW_ON_UPDATE,
PROP_FOV,
PROP_ORTHO,
PROP_ROTATION_X,
PROP_ROTATION_Y,
PROP_ROTATION_Z,
PROP_SCALE_X,
PROP_SCALE_Y,
PROP_SAMPLING_METHOD,
PROP_GAMMA_MODE,
PROP_PRIMARIES_MODE,
PROP_OVERLAY_MODE,
PROP_DISPLAY_FORMAT,
PROP_ERROR_ON_CLOSED,
PROP_EXTERNAL_WINDOW_ONLY,
PROP_DIRECT_SWAPCHAIN,
};
#define DEFAULT_ADAPTER -1
#define DEFAULT_FORCE_ASPECT_RATIO TRUE
#define DEFAULT_ENABLE_NAVIGATION_EVENTS TRUE
#define DEFAULT_ROTATE_METHOD GST_VIDEO_ORIENTATION_IDENTITY
#define DEFAULT_FULLSCREEN_ON_ALT_ENTER FALSE
#define DEFAULT_FULLSCREEN FALSE
#define DEFAULT_MSAA GST_D3D12_MSAA_DISABLED
#define DEFAULT_REDROW_ON_UPDATE TRUE
#define DEFAULT_ROTATION 0.0f
#define DEFAULT_SCALE 1.0f
#define DEFAULT_FOV 90.0f
#define DEFAULT_ORTHO FALSE
#define DEFAULT_SAMPLING_METHOD GST_D3D12_SAMPLING_METHOD_BILINEAR
#define DEFAULT_GAMMA_MODE GST_VIDEO_GAMMA_MODE_NONE
#define DEFAULT_PRIMARIES_MODE GST_VIDEO_PRIMARIES_MODE_NONE
#define DEFAULT_OVERLAY_MODE GST_D3D12_WINDOW_OVERLAY_NONE
#define DEFAULT_DISPLAY_FORMAT DXGI_FORMAT_UNKNOWN
#define DEFAULT_ERROR_ON_CLOSED TRUE
#define DEFAULT_EXTERNAL_WINDOW_ONLY FALSE
#define DEFAULT_DIRECT_SWAPCHAIN FALSE
enum
{
SIGNAL_OVERLAY,
SIGNAL_LAST
};
static guint d3d12_video_sink_signals[SIGNAL_LAST] = { 0, };
static GstStaticPadTemplate sink_template =
GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
(GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY, GST_D3D12_ALL_FORMATS) "; "
GST_VIDEO_CAPS_MAKE_WITH_FEATURES
(GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY ","
GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
GST_D3D12_ALL_FORMATS) ";"
GST_VIDEO_CAPS_MAKE (GST_D3D12_ALL_FORMATS) "; "
GST_VIDEO_CAPS_MAKE_WITH_FEATURES
(GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY ","
GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
GST_D3D12_ALL_FORMATS)));
GST_DEBUG_CATEGORY_STATIC (gst_d3d12_video_sink_debug);
#define GST_CAT_DEFAULT gst_d3d12_video_sink_debug
/* *INDENT-OFF* */
struct GstD3D12VideoSinkPrivate
{
GstD3D12VideoSinkPrivate ()
{
window = gst_d3d12_window_new ();
convert_config = gst_structure_new_empty ("convert-config");
}
~GstD3D12VideoSinkPrivate ()
{
gst_structure_free (convert_config);
gst_clear_caps (&caps);
gst_clear_object (&window);
if (pool) {
gst_buffer_pool_set_active (pool, FALSE);
gst_object_unref (pool);
}
}
GstD3D12Window *window;
guintptr window_handle = 0;
gboolean window_handle_updated = FALSE;
std::recursive_mutex context_lock;
GstVideoInfo info;
GstCaps *caps = nullptr;
gboolean update_window = FALSE;
GstBufferPool *pool = nullptr;
GstStructure *convert_config;
gboolean warn_closed_window = FALSE;
gboolean window_open_called = FALSE;
std::recursive_mutex lock;
/* properties */
std::atomic<gint> adapter = { DEFAULT_ADAPTER };
gboolean force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
gboolean enable_navigation = DEFAULT_ENABLE_NAVIGATION_EVENTS;
GstVideoOrientationMethod orientation = DEFAULT_ROTATE_METHOD;
GstVideoOrientationMethod orientation_from_tag = DEFAULT_ROTATE_METHOD;
GstVideoOrientationMethod orientation_selected = DEFAULT_ROTATE_METHOD;
gboolean fullscreen_on_alt_enter = DEFAULT_FULLSCREEN_ON_ALT_ENTER;
gboolean fullscreen = DEFAULT_FULLSCREEN;
GstD3D12MSAAMode msaa = DEFAULT_MSAA;
gboolean redraw_on_update = DEFAULT_REDROW_ON_UPDATE;
gfloat fov = DEFAULT_FOV;
gboolean ortho = DEFAULT_ORTHO;
gfloat rotation_x = DEFAULT_ROTATION;
gfloat rotation_y = DEFAULT_ROTATION;
gfloat rotation_z = DEFAULT_ROTATION;
gfloat scale_x = DEFAULT_SCALE;
gfloat scale_y = DEFAULT_SCALE;
GstVideoGammaMode gamma_mode = DEFAULT_GAMMA_MODE;
GstVideoPrimariesMode primaries_mode = DEFAULT_PRIMARIES_MODE;
GstD3D12SamplingMethod sampling_method = DEFAULT_SAMPLING_METHOD;
GstD3D12WindowOverlayMode overlay_mode = DEFAULT_OVERLAY_MODE;
DXGI_FORMAT display_format = DEFAULT_DISPLAY_FORMAT;
std::atomic<gboolean> error_on_closed = { DEFAULT_ERROR_ON_CLOSED };
gboolean external_only = DEFAULT_EXTERNAL_WINDOW_ONLY;
std::atomic<gboolean> direct_swapchain = { DEFAULT_DIRECT_SWAPCHAIN };
};
/* *INDENT-ON* */
struct _GstD3D12VideoSink
{
GstVideoSink parent;
GstD3D12Device *device;
GstD3D12VideoSinkPrivate *priv;
};
static void gst_d3d12_video_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_d3d12_video_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_d3d12_video_sink_dispose (GObject * object);
static void gst_d3d12_video_sink_finalize (GObject * object);
static void gst_d3d12_video_sink_set_context (GstElement * element,
GstContext * context);
static gboolean gst_d3d12_video_sink_start (GstBaseSink * sink);
static gboolean gst_d3d12_video_sink_stop (GstBaseSink * sink);
static gboolean gst_d3d12_video_sink_unlock (GstBaseSink * sink);
static gboolean gst_d3d12_video_sink_unlock_stop (GstBaseSink * sink);
static gboolean gst_d3d12_video_sink_propose_allocation (GstBaseSink * sink,
GstQuery * query);
static gboolean gst_d3d12_video_sink_query (GstBaseSink * sink,
GstQuery * query);
static GstFlowReturn gst_d3d12_video_sink_prepare (GstBaseSink * sink,
GstBuffer * buf);
static gboolean gst_d3d12_video_sink_event (GstBaseSink * sink,
GstEvent * event);
static gboolean gst_d3d12_video_sink_set_info (GstVideoSink * sink,
GstCaps * caps, const GstVideoInfo * info);
static GstFlowReturn gst_d3d12_video_sink_show_frame (GstVideoSink * sink,
GstBuffer * buf);
static void gst_d3d12_video_sink_set_orientation (GstD3D12VideoSink * self,
GstVideoOrientationMethod method, gboolean from_tag);
static void gst_d3d12_video_sink_key_event (GstD3D12Window * window,
const gchar * event, const gchar * key, GstD3D12VideoSink * self);
static void gst_d3d12_video_sink_mouse_event (GstD3D12Window * window,
const gchar * event, gint button, gdouble x, gdouble y, guint modifier,
GstD3D12VideoSink * self);
static void gst_d3d12_video_sink_on_fullscreen (GstD3D12Window * window,
gboolean is_fullscreen, GstD3D12VideoSink * self);
static void gst_d3d12_video_sink_on_overlay (GstD3D12Window * window,
gpointer command_queue, gpointer resource12, gpointer device11on12,
gpointer resource11, gpointer context2d, gpointer viewport,
GstD3D12VideoSink * self);
static void
gst_d3d12_video_sink_video_overlay_init (GstVideoOverlayInterface * iface);
static void
gst_d3d12_video_sink_navigation_init (GstNavigationInterface * iface);
#define gst_d3d12_video_sink_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstD3D12VideoSink, gst_d3d12_video_sink,
GST_TYPE_VIDEO_SINK,
G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
gst_d3d12_video_sink_video_overlay_init);
G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
gst_d3d12_video_sink_navigation_init);
GST_DEBUG_CATEGORY_INIT (gst_d3d12_video_sink_debug,
"d3d12videosink", 0, "d3d12videosink"));
static void
gst_d3d12_video_sink_class_init (GstD3D12VideoSinkClass * klass)
{
auto object_class = G_OBJECT_CLASS (klass);
auto element_class = GST_ELEMENT_CLASS (klass);
auto basesink_class = GST_BASE_SINK_CLASS (klass);
auto videosink_class = GST_VIDEO_SINK_CLASS (klass);
object_class->set_property = gst_d3d12_video_sink_set_property;
object_class->get_property = gst_d3d12_video_sink_get_property;
object_class->dispose = gst_d3d12_video_sink_dispose;
object_class->finalize = gst_d3d12_video_sink_finalize;
g_object_class_install_property (object_class, PROP_ADAPTER,
g_param_spec_int ("adapter", "Adapter",
"Adapter index for creating device (-1 for default)",
-1, G_MAXINT32, DEFAULT_ADAPTER,
(GParamFlags) (G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_FORCE_ASPECT_RATIO,
g_param_spec_boolean ("force-aspect-ratio",
"Force aspect ratio",
"When enabled, scaling will respect original aspect ratio",
DEFAULT_FORCE_ASPECT_RATIO,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_ENABLE_NAVIGATION_EVENTS,
g_param_spec_boolean ("enable-navigation-events",
"Enable navigation events",
"When enabled, navigation events are sent upstream",
DEFAULT_ENABLE_NAVIGATION_EVENTS,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_ROTATE_METHOD,
g_param_spec_enum ("rotate-method", "Rotate Method",
"Rotate method to use",
GST_TYPE_VIDEO_ORIENTATION_METHOD, GST_VIDEO_ORIENTATION_IDENTITY,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class,
PROP_FULLSCREEN_ON_ALT_ENTER,
g_param_spec_boolean ("fullscreen-on-alt-enter",
"Fullscreen on Alt Enter",
"Enable fullscreen toggle on alt+enter key input",
DEFAULT_FULLSCREEN_ON_ALT_ENTER,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_FULLSCREEN,
g_param_spec_boolean ("fullscreen", "Fullscreen",
"Fullscreen mode", DEFAULT_FULLSCREEN,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_MSAA,
g_param_spec_enum ("msaa", "MSAA",
"MSAA (Multi-Sampling Anti-Aliasing) level",
GST_TYPE_D3D12_MSAA_MODE, DEFAULT_MSAA,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_REDRAW_ON_UPDATE,
g_param_spec_boolean ("redraw-on-update",
"redraw-on-update",
"Immediately apply updated geometry related properties and redraw. "
"If disabled, properties will be applied on the next frame or "
"window resize", DEFAULT_REDROW_ON_UPDATE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_FOV,
g_param_spec_float ("fov", "Fov",
"Field of view angle in degrees",
0, G_MAXFLOAT, DEFAULT_FOV,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_ORTHO,
g_param_spec_boolean ("ortho", "Orthographic",
"Use orthographic projection", DEFAULT_ORTHO,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_ROTATION_X,
g_param_spec_float ("rotation-x", "Rotation X",
"x-axis rotation angle in degrees",
-G_MAXFLOAT, G_MAXFLOAT, DEFAULT_ROTATION,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_ROTATION_Y,
g_param_spec_float ("rotation-y", "Rotation Y",
"y-axis rotation angle in degrees",
-G_MAXFLOAT, G_MAXFLOAT, DEFAULT_ROTATION,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_ROTATION_Z,
g_param_spec_float ("rotation-z", "Rotation Z",
"z-axis rotation angle in degrees",
-G_MAXFLOAT, G_MAXFLOAT, DEFAULT_ROTATION,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_SCALE_X,
g_param_spec_float ("scale-x", "Scale X",
"Scale multiplier for x-axis",
-G_MAXFLOAT, G_MAXFLOAT, DEFAULT_SCALE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_SCALE_Y,
g_param_spec_float ("scale-y", "Scale Y",
"Scale multiplier for y-axis",
-G_MAXFLOAT, G_MAXFLOAT, DEFAULT_SCALE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_GAMMA_MODE,
g_param_spec_enum ("gamma-mode", "Gamma mode",
"Gamma conversion mode", GST_TYPE_VIDEO_GAMMA_MODE,
DEFAULT_GAMMA_MODE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_PRIMARIES_MODE,
g_param_spec_enum ("primaries-mode", "Primaries Mode",
"Primaries conversion mode", GST_TYPE_VIDEO_PRIMARIES_MODE,
DEFAULT_PRIMARIES_MODE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_SAMPLING_METHOD,
g_param_spec_enum ("sampling-method", "Sampling method",
"Sampler filter type to use", GST_TYPE_D3D12_SAMPLING_METHOD,
DEFAULT_SAMPLING_METHOD,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
/**
* GstD3D12VideoSink:overlay-mode:
*
* Overly signal type
*
* Since: 1.26
*/
g_object_class_install_property (object_class, PROP_OVERLAY_MODE,
g_param_spec_flags ("overlay-mode", "Overlay Mode",
"Overlay signal type to use", GST_TYPE_D3D12_WINDOW_OVERLAY_MODE,
DEFAULT_OVERLAY_MODE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
/**
* GstD3D12VideoSink:display-format:
*
* Swapchain display format
*
* Since: 1.26
*/
g_object_class_install_property (object_class, PROP_DISPLAY_FORMAT,
g_param_spec_enum ("display-format", "Display Format",
"Swapchain display format", GST_TYPE_D3D12_VIDEO_SINK_DISPLAY_FORMAT,
DEFAULT_DISPLAY_FORMAT, (GParamFlags) (G_PARAM_READWRITE |
GST_PARAM_MUTABLE_READY | G_PARAM_STATIC_STRINGS)));
/**
* GstD3D12VideoSink:error-on-closed:
*
* Posts error message if window got closed in playing or paused state
*
* Since: 1.26
*/
g_object_class_install_property (object_class, PROP_ERROR_ON_CLOSED,
g_param_spec_boolean ("error-on-closed", "Error On Closed",
"Posts error message and return flow error if window is closed "
"in playing or paused state", DEFAULT_ERROR_ON_CLOSED,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
/**
* GstD3D12VideoSink:external-window-only:
*
* If enabled and window handle is not set by user, videosink will report
* error instead of creating videosink's own window.
*
* Since: 1.26
*/
g_object_class_install_property (object_class, PROP_EXTERNAL_WINDOW_ONLY,
g_param_spec_boolean ("external-window-only", "External Window Only",
"Disallow creating videosink's own window when overlay handle is not set",
DEFAULT_EXTERNAL_WINDOW_ONLY,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
/**
* GstD3D12VideoSink:direct-swapchain:
*
* Attach DXGI swapchain to external window handle directly, instead of
* creating child window. Note that once direct swapchain is configured,
* GDI will no longer work with the given window handle.
*
* If enabled, GstVideoOverlay::set_render_rectangle() will be ignored,
* and application should handle window positioning.
*
* Since: 1.26
*/
g_object_class_install_property (object_class, PROP_DIRECT_SWAPCHAIN,
g_param_spec_boolean ("direct-swapchain", "Direct Swapchain",
"Attach DXGI swapchain to external window handle directly",
DEFAULT_DIRECT_SWAPCHAIN,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
/**
* GstD3D12VideoSink::overlay:
* @d3d12videosink: the d3d12videosink element that emitted the signal
* @command_queue: ID3D12CommandQueue
* @resource12: ID3D12Resource
* @device11on12: (nullable): ID3D11On12Device
* @resource11: (nullable): ID3D11Texture2D
* @context2d: (nullable): ID2D1DeviceContext2
* @viewport: (nullable): D3D12_RECT, d3d12videosink's current viewport
*
* Signal emitted with Direct3D12, Direct3D11 and Direct2D resources
* associated with swapchain backbuffer.
*
* This signal is emitted from the streaming thread if "overlay-mode" property
* includes GST_D3D12_WINDOW_OVERLAY_D3D12. The @resource12 is a render target
* backbuffer of the swapchain. The Resource state of @resource12 when this
* signal is emitted will be always D3D12_RESOURCE_STATE_RENDER_TARGET and
* signal handler should make sure the state is
* D3D12_RESOURCE_STATE_RENDER_TARGET when signal handler is returned,
* so that state change to final D3D12_RESOURCE_STATE_PRESENT can be
* processed by videosink.
*
* In addition to the d2d12 resources, if "overlay-mode" includes
* GST_D3D12_WINDOW_OVERLAY_D3D11 flag and d3d11on12 API is supported by
* system, @device11on12 and @resource11 will be valid handles.
* Singla handler should not assume the @device11on12 and @resource11
* are always valid handle since d3d11on12 API may not be supported.
* The @resource11 is wrapped resource created via
* ID3D11On12Device::CreateWrappedResource(). Thus, signal handler must follow
* required steps for d3d11on12 device, for example,
* ID3D11On12Device::AcquireWrappedResources() must be called before recoding
* GPU commands. Once GPU commands are recoded via d3d11 or d2d APIs,
* the resource should be released via
* ID3D11On12Device::ReleaseWrappedResources(), and then
* ID3D11DeviceContext::Flush() must be called in the signal handler.
*
* If "overlay-mode" is GST_D3D12_WINDOW_OVERLAY_D2D and d2d device is
* available, @context2d will be valid handle. When this signal is emitted,
* @context2d has configured render target already. The D2D render target
* is also a resource derived from @resource11 and it's swapchain's backbuffer.
* The same step for d3d11 resource (i.e., acquire, release, and flush)
* is required for d2d as well.
*
* Since the resource is swapchain's backbuffer, signal handler must not hold
* any derived resources such as ID3D11RenderTargetView, so that videosink
* can clear swapchain resources and resize anytime it's needed.
*
* Since: 1.26
*/
d3d12_video_sink_signals[SIGNAL_OVERLAY] =
g_signal_new_class_handler ("overlay", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, nullptr, nullptr, nullptr, nullptr,
G_TYPE_NONE, 6, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER,
G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
element_class->set_context =
GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_set_context);
gst_element_class_set_static_metadata (element_class,
"Direct3D12 Video Sink", "Sink/Video", "A Direct3D12 Video Sink",
"Seungha Yang <seungha@centricular.com>");
gst_element_class_add_static_pad_template (element_class, &sink_template);
basesink_class->start = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_start);
basesink_class->stop = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_stop);
basesink_class->unlock = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_unlock);
basesink_class->unlock_stop =
GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_unlock_stop);
basesink_class->propose_allocation =
GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_propose_allocation);
basesink_class->query = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_query);
basesink_class->prepare = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_prepare);
basesink_class->event = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_event);
videosink_class->set_info = GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_set_info);
videosink_class->show_frame =
GST_DEBUG_FUNCPTR (gst_d3d12_video_sink_show_frame);
gst_type_mark_as_plugin_api (GST_TYPE_D3D12_MSAA_MODE, (GstPluginAPIFlags) 0);
gst_type_mark_as_plugin_api (GST_TYPE_D3D12_SAMPLING_METHOD,
(GstPluginAPIFlags) 0);
}
static void
gst_d3d12_video_sink_init (GstD3D12VideoSink * self)
{
self->priv = new GstD3D12VideoSinkPrivate ();
auto priv = self->priv;
g_signal_connect (priv->window, "key-event",
G_CALLBACK (gst_d3d12_video_sink_key_event), self);
g_signal_connect (priv->window, "mouse-event",
G_CALLBACK (gst_d3d12_video_sink_mouse_event), self);
g_signal_connect (priv->window, "fullscreen",
G_CALLBACK (gst_d3d12_video_sink_on_fullscreen), self);
g_signal_connect (priv->window, "overlay",
G_CALLBACK (gst_d3d12_video_sink_on_overlay), self);
}
static void
gst_d3d12_video_sink_dispose (GObject * object)
{
auto self = GST_D3D12_VIDEO_SINK (object);
auto priv = self->priv;
gst_d3d12_window_invalidate (priv->window);
g_signal_handlers_disconnect_by_data (priv->window, self);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_d3d12_video_sink_finalize (GObject * object)
{
auto self = GST_D3D12_VIDEO_SINK (object);
delete self->priv;
gst_clear_object (&self->device);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_d3d12_video_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
auto self = GST_D3D12_VIDEO_SINK (object);
auto priv = self->priv;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
switch (prop_id) {
case PROP_ADAPTER:
priv->adapter = g_value_get_int (value);
break;
case PROP_FORCE_ASPECT_RATIO:
priv->force_aspect_ratio = g_value_get_boolean (value);
gst_d3d12_window_set_force_aspect_ratio (priv->window,
priv->force_aspect_ratio);
break;
case PROP_ENABLE_NAVIGATION_EVENTS:
priv->enable_navigation = g_value_get_boolean (value);
gst_d3d12_window_set_enable_navigation_events (priv->window,
priv->enable_navigation);
break;
case PROP_ROTATE_METHOD:
gst_d3d12_video_sink_set_orientation (self,
(GstVideoOrientationMethod) g_value_get_enum (value), FALSE);
break;
case PROP_FULLSCREEN_ON_ALT_ENTER:
priv->fullscreen_on_alt_enter = g_value_get_boolean (value);
gst_d3d12_window_enable_fullscreen_on_alt_enter (priv->window,
priv->fullscreen_on_alt_enter);
break;
case PROP_FULLSCREEN:
priv->fullscreen = g_value_get_boolean (value);
gst_d3d12_window_set_fullscreen (priv->window, priv->fullscreen);
break;
case PROP_MSAA:
priv->msaa = (GstD3D12MSAAMode) g_value_get_enum (value);
gst_d3d12_window_set_msaa (priv->window, priv->msaa);
break;
case PROP_REDRAW_ON_UPDATE:
priv->redraw_on_update = g_value_get_boolean (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_FOV:
priv->fov = g_value_get_float (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_ORTHO:
priv->ortho = g_value_get_boolean (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_ROTATION_X:
priv->rotation_x = g_value_get_float (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_ROTATION_Y:
priv->rotation_y = g_value_get_float (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_ROTATION_Z:
priv->rotation_z = g_value_get_float (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_SCALE_X:
priv->scale_x = g_value_get_float (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_SCALE_Y:
priv->scale_y = g_value_get_float (value);
gst_d3d12_video_sink_set_orientation (self, priv->orientation, FALSE);
break;
case PROP_GAMMA_MODE:
{
auto gamma_mode = (GstVideoGammaMode) g_value_get_enum (value);
if (priv->gamma_mode != gamma_mode) {
priv->gamma_mode = gamma_mode;
priv->update_window = TRUE;
}
break;
}
case PROP_PRIMARIES_MODE:
{
auto primaries_mode = (GstVideoPrimariesMode) g_value_get_enum (value);
if (priv->primaries_mode != primaries_mode) {
priv->primaries_mode = primaries_mode;
priv->update_window = TRUE;
}
break;
}
case PROP_SAMPLING_METHOD:
{
auto sampling_method = (GstD3D12SamplingMethod) g_value_get_enum (value);
if (priv->sampling_method != sampling_method) {
priv->sampling_method = sampling_method;
priv->update_window = TRUE;
}
break;
}
case PROP_OVERLAY_MODE:
priv->overlay_mode =
(GstD3D12WindowOverlayMode) g_value_get_flags (value);
gst_d3d12_window_set_overlay_mode (priv->window, priv->overlay_mode);
break;
case PROP_DISPLAY_FORMAT:
priv->display_format = (DXGI_FORMAT) g_value_get_enum (value);
break;
case PROP_ERROR_ON_CLOSED:
priv->error_on_closed = g_value_get_boolean (value);
break;
case PROP_EXTERNAL_WINDOW_ONLY:
priv->external_only = g_value_get_boolean (value);
break;
case PROP_DIRECT_SWAPCHAIN:
priv->direct_swapchain = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_d3d12_video_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
auto self = GST_D3D12_VIDEO_SINK (object);
auto priv = self->priv;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
switch (prop_id) {
case PROP_ADAPTER:
g_value_set_int (value, priv->adapter);
break;
case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, priv->force_aspect_ratio);
break;
case PROP_ENABLE_NAVIGATION_EVENTS:
g_value_set_boolean (value, priv->enable_navigation);
break;
case PROP_ROTATE_METHOD:
g_value_set_enum (value, priv->orientation);
break;
case PROP_FULLSCREEN_ON_ALT_ENTER:
g_value_set_boolean (value, priv->fullscreen_on_alt_enter);
break;
case PROP_FULLSCREEN:
g_value_set_boolean (value, priv->fullscreen);
break;
case PROP_MSAA:
g_value_set_enum (value, priv->msaa);
break;
case PROP_REDRAW_ON_UPDATE:
g_value_set_boolean (value, priv->redraw_on_update);
break;
case PROP_FOV:
g_value_set_float (value, priv->fov);
break;
case PROP_ORTHO:
g_value_set_boolean (value, priv->ortho);
break;
case PROP_ROTATION_X:
g_value_set_float (value, priv->rotation_x);
break;
case PROP_ROTATION_Y:
g_value_set_float (value, priv->rotation_x);
break;
case PROP_ROTATION_Z:
g_value_set_float (value, priv->rotation_z);
break;
case PROP_SCALE_X:
g_value_set_float (value, priv->scale_x);
break;
case PROP_SCALE_Y:
g_value_set_float (value, priv->scale_y);
break;
case PROP_GAMMA_MODE:
g_value_set_enum (value, priv->gamma_mode);
break;
case PROP_PRIMARIES_MODE:
g_value_set_enum (value, priv->primaries_mode);
break;
case PROP_SAMPLING_METHOD:
g_value_set_enum (value, priv->sampling_method);
break;
case PROP_OVERLAY_MODE:
g_value_set_flags (value, priv->overlay_mode);
break;
case PROP_DISPLAY_FORMAT:
g_value_set_enum (value, priv->display_format);
break;
case PROP_ERROR_ON_CLOSED:
g_value_set_boolean (value, priv->error_on_closed);
break;
case PROP_EXTERNAL_WINDOW_ONLY:
g_value_set_boolean (value, priv->external_only);
break;
case PROP_DIRECT_SWAPCHAIN:
g_value_set_boolean (value, priv->direct_swapchain);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_d3d12_video_sink_set_orientation (GstD3D12VideoSink * self,
GstVideoOrientationMethod orientation, gboolean from_tag)
{
auto priv = self->priv;
if (orientation == GST_VIDEO_ORIENTATION_CUSTOM) {
GST_WARNING_OBJECT (self, "Unsupported custom orientation");
return;
}
if (from_tag)
priv->orientation_from_tag = orientation;
else
priv->orientation = orientation;
if (priv->orientation == GST_VIDEO_ORIENTATION_AUTO)
priv->orientation_selected = priv->orientation_from_tag;
else
priv->orientation_selected = priv->orientation;
gst_d3d12_window_set_orientation (priv->window,
priv->redraw_on_update, priv->orientation_selected, priv->fov,
priv->ortho, priv->rotation_x, priv->rotation_y, priv->rotation_z,
priv->scale_x, priv->scale_y);
}
static void
gst_d3d12_video_sink_set_context (GstElement * element, GstContext * context)
{
auto self = GST_D3D12_VIDEO_SINK (element);
auto priv = self->priv;
{
std::lock_guard < std::recursive_mutex > lk (priv->context_lock);
gst_d3d12_handle_set_context (element,
context, priv->adapter, &self->device);
}
GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
}
static gboolean
gst_d3d12_video_sink_event (GstBaseSink * sink, GstEvent * event)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_TAG:{
GstTagList *taglist;
gchar *title = nullptr;
gst_event_parse_tag (event, &taglist);
gst_tag_list_get_string (taglist, GST_TAG_TITLE, &title);
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (title) {
const gchar *app_name = g_get_application_name ();
std::string title_string;
if (app_name) {
title_string = std::string (title) + " : " + std::string (app_name);
} else {
title_string = std::string (title);
}
gst_d3d12_window_set_title (priv->window, title_string.c_str ());
g_free (title);
}
GstVideoOrientationMethod orientation = GST_VIDEO_ORIENTATION_IDENTITY;
if (gst_video_orientation_from_tag (taglist, &orientation))
gst_d3d12_video_sink_set_orientation (self, orientation, TRUE);
break;
}
default:
break;
}
return GST_BASE_SINK_CLASS (parent_class)->event (sink, event);
}
static gboolean
gst_d3d12_video_sink_set_info (GstVideoSink * sink, GstCaps * caps,
const GstVideoInfo * info)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "set caps %" GST_PTR_FORMAT, caps);
std::lock_guard < std::recursive_mutex > lk (priv->lock);
gst_caps_replace (&priv->caps, caps);
priv->info = *info;
priv->update_window = TRUE;
auto video_width = GST_VIDEO_INFO_WIDTH (&priv->info);
auto video_height = GST_VIDEO_INFO_HEIGHT (&priv->info);
auto video_par_n = GST_VIDEO_INFO_PAR_N (&priv->info);
auto video_par_d = GST_VIDEO_INFO_PAR_D (&priv->info);
gint display_par_n = 1;
gint display_par_d = 1;
guint num, den;
if (!gst_video_calculate_display_ratio (&num, &den, video_width,
video_height, video_par_n, video_par_d, display_par_n,
display_par_d)) {
GST_ELEMENT_WARNING (self, CORE, NEGOTIATION, (nullptr),
("Error calculating the output display ratio of the video."));
GST_VIDEO_SINK_WIDTH (self) = video_width;
GST_VIDEO_SINK_HEIGHT (self) = video_height;
} else {
GST_DEBUG_OBJECT (self,
"video width/height: %dx%d, calculated display ratio: %d/%d format: %s",
video_width, video_height, num, den,
gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&priv->info)));
if (video_height % den == 0) {
GST_DEBUG_OBJECT (self, "keeping video height");
GST_VIDEO_SINK_WIDTH (self) = (guint)
gst_util_uint64_scale_int (video_height, num, den);
GST_VIDEO_SINK_HEIGHT (self) = video_height;
} else if (video_width % num == 0) {
GST_DEBUG_OBJECT (self, "keeping video width");
GST_VIDEO_SINK_WIDTH (self) = video_width;
GST_VIDEO_SINK_HEIGHT (self) = (guint)
gst_util_uint64_scale_int (video_width, den, num);
} else {
GST_DEBUG_OBJECT (self, "approximating while keeping video height");
GST_VIDEO_SINK_WIDTH (self) = (guint)
gst_util_uint64_scale_int (video_height, num, den);
GST_VIDEO_SINK_HEIGHT (self) = video_height;
}
}
if (GST_VIDEO_SINK_WIDTH (self) <= 0) {
GST_WARNING_OBJECT (self, "Invalid display width %d",
GST_VIDEO_SINK_WIDTH (self));
GST_VIDEO_SINK_WIDTH (self) = 8;
}
if (GST_VIDEO_SINK_HEIGHT (self) <= 0) {
GST_WARNING_OBJECT (self, "Invalid display height %d",
GST_VIDEO_SINK_HEIGHT (self));
GST_VIDEO_SINK_HEIGHT (self) = 8;
}
GST_DEBUG_OBJECT (self, "scaling to %dx%d",
GST_VIDEO_SINK_WIDTH (self), GST_VIDEO_SINK_HEIGHT (self));
if (priv->pool) {
gst_buffer_pool_set_active (priv->pool, FALSE);
gst_clear_object (&priv->pool);
}
priv->pool = gst_d3d12_buffer_pool_new (self->device);
auto config = gst_buffer_pool_get_config (priv->pool);
gst_buffer_pool_config_set_params (config, priv->caps, priv->info.size, 0, 0);
if (!gst_buffer_pool_set_config (priv->pool, config) ||
!gst_buffer_pool_set_active (priv->pool, TRUE)) {
GST_ELEMENT_ERROR (self, RESOURCE, FAILED, (nullptr),
("Couldn't setup buffer pool"));
gst_clear_object (&priv->pool);
return FALSE;
}
return TRUE;
}
static void
gst_d3d12_video_sink_key_event (GstD3D12Window * window, const gchar * event,
const gchar * key, GstD3D12VideoSink * self)
{
GstEvent *key_event;
GST_LOG_OBJECT (self, "send key event %s, key %s", event, key);
if (g_strcmp0 ("key-press", event) == 0) {
key_event = gst_navigation_event_new_key_press (key,
GST_NAVIGATION_MODIFIER_NONE);
} else if (g_strcmp0 ("key-release", event) == 0) {
key_event = gst_navigation_event_new_key_release (key,
GST_NAVIGATION_MODIFIER_NONE);
} else {
return;
}
gst_navigation_send_event_simple (GST_NAVIGATION (self), key_event);
}
static void
gst_d3d12_video_sink_mouse_event (GstD3D12Window * window, const gchar * event,
gint button, gdouble x, gdouble y, guint modifier, GstD3D12VideoSink * self)
{
GstEvent *mouse_event;
GST_LOG_OBJECT (self,
"send mouse event %s, button %d (%.1f, %.1f)", event, button, x, y);
if (g_strcmp0 ("mouse-button-press", event) == 0) {
mouse_event = gst_navigation_event_new_mouse_button_press (button, x, y,
(GstNavigationModifierType) modifier);
} else if (g_strcmp0 ("mouse-button-release", event) == 0) {
mouse_event = gst_navigation_event_new_mouse_button_release (button, x, y,
(GstNavigationModifierType) modifier);
} else if (g_strcmp0 ("mouse-move", event) == 0) {
mouse_event = gst_navigation_event_new_mouse_move (x, y,
(GstNavigationModifierType) modifier);
} else if (g_strcmp0 ("mouse-double-click", event) == 0) {
mouse_event = gst_navigation_event_new_mouse_double_click (button, x, y,
(GstNavigationModifierType) modifier);
} else {
return;
}
gst_navigation_send_event_simple (GST_NAVIGATION (self), mouse_event);
}
static void
gst_d3d12_video_sink_on_fullscreen (GstD3D12Window * window,
gboolean is_fullscreen, GstD3D12VideoSink * self)
{
auto priv = self->priv;
gboolean notify = FALSE;
{
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (priv->fullscreen != is_fullscreen) {
priv->fullscreen = is_fullscreen;
notify = TRUE;
}
}
if (notify)
g_object_notify (G_OBJECT (self), "fullscreen");
}
static gboolean
gst_d3d12_video_sink_foreach_meta (GstBuffer * buffer, GstMeta ** meta,
GstBuffer * uploaded)
{
if ((*meta)->info->api != GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE)
return TRUE;
auto cmeta = (GstVideoOverlayCompositionMeta *) (*meta);
if (!cmeta->overlay)
return TRUE;
if (gst_video_overlay_composition_n_rectangles (cmeta->overlay) == 0)
return TRUE;
gst_buffer_add_video_overlay_composition_meta (uploaded, cmeta->overlay);
return TRUE;
}
static GstFlowReturn
gst_d3d12_video_sink_set_buffer (GstD3D12VideoSink * self,
GstBuffer * buffer, gboolean is_prepare)
{
auto priv = self->priv;
GstFlowReturn ret = GST_FLOW_OK;
gboolean set_buffer = FALSE;
gboolean update_window = FALSE;
{
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (is_prepare) {
if (priv->update_window) {
set_buffer = FALSE;
update_window = FALSE;
} else {
set_buffer = TRUE;
update_window = FALSE;
}
} else {
if (priv->update_window) {
set_buffer = TRUE;
update_window = TRUE;
priv->update_window = FALSE;
} else {
set_buffer = FALSE;
update_window = FALSE;
}
}
}
if (update_window) {
gst_structure_set (priv->convert_config,
GST_D3D12_CONVERTER_OPT_GAMMA_MODE,
GST_TYPE_VIDEO_GAMMA_MODE, priv->gamma_mode,
GST_D3D12_CONVERTER_OPT_PRIMARIES_MODE,
GST_TYPE_VIDEO_PRIMARIES_MODE, priv->primaries_mode,
GST_D3D12_CONVERTER_OPT_SAMPLER_FILTER,
GST_TYPE_D3D12_CONVERTER_SAMPLER_FILTER,
gst_d3d12_sampling_method_to_native (priv->sampling_method),
GST_D3D12_CONVERTER_OPT_DEST_ALPHA_MODE,
GST_TYPE_D3D12_CONVERTER_ALPHA_MODE,
GST_VIDEO_INFO_HAS_ALPHA (&priv->info) ?
GST_D3D12_CONVERTER_ALPHA_MODE_PREMULTIPLIED :
GST_D3D12_CONVERTER_ALPHA_MODE_UNSPECIFIED, nullptr);
ret = gst_d3d12_window_prepare (priv->window, self->device,
GST_VIDEO_SINK_WIDTH (self), GST_VIDEO_SINK_HEIGHT (self), priv->caps,
priv->convert_config, priv->display_format);
if (ret != GST_FLOW_OK)
return ret;
}
if (!set_buffer)
return GST_FLOW_OK;
GstBuffer *upload = nullptr;
auto mem = gst_buffer_peek_memory (buffer, 0);
if (!gst_is_d3d12_memory (mem)) {
gst_buffer_pool_acquire_buffer (priv->pool, &upload, nullptr);
if (!upload) {
GST_ERROR_OBJECT (self, "Couldn't allocate upload buffer");
return GST_FLOW_ERROR;
}
GstVideoFrame in_frame, out_frame;
if (!gst_video_frame_map (&in_frame, &priv->info, buffer, GST_MAP_READ)) {
GST_ERROR_OBJECT (self, "Couldn't map input frame");
gst_buffer_unref (upload);
return GST_FLOW_ERROR;
}
if (!gst_video_frame_map (&out_frame, &priv->info, upload, GST_MAP_WRITE)) {
GST_ERROR_OBJECT (self, "Couldn't map upload frame");
gst_video_frame_unmap (&in_frame);
gst_buffer_unref (upload);
return GST_FLOW_ERROR;
}
auto copy_ret = gst_video_frame_copy (&out_frame, &in_frame);
gst_video_frame_unmap (&out_frame);
gst_video_frame_unmap (&in_frame);
if (!copy_ret) {
GST_ERROR_OBJECT (self, "Couldn't copy frame");
gst_buffer_unref (upload);
return GST_FLOW_ERROR;
}
gst_buffer_foreach_meta (buffer,
(GstBufferForeachMetaFunc) gst_d3d12_video_sink_foreach_meta, upload);
buffer = upload;
}
ret = gst_d3d12_window_set_buffer (priv->window, buffer);
if (upload)
gst_buffer_unref (upload);
return ret;
}
static gboolean
gst_d3d12_video_sink_start (GstBaseSink * sink)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "Start");
if (!gst_d3d12_ensure_element_data (GST_ELEMENT_CAST (self), priv->adapter,
&self->device)) {
GST_ERROR_OBJECT (sink, "Cannot create device");
return FALSE;
}
priv->warn_closed_window = TRUE;
priv->window_open_called = FALSE;
return TRUE;
}
static gboolean
gst_d3d12_video_sink_stop (GstBaseSink * sink)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "Stop");
priv->orientation_from_tag = GST_VIDEO_ORIENTATION_IDENTITY;
if (priv->pool) {
gst_buffer_pool_set_active (priv->pool, FALSE);
gst_clear_object (&priv->pool);
}
gst_d3d12_window_unprepare (priv->window);
gst_clear_object (&self->device);
return TRUE;
}
static gboolean
gst_d3d12_video_sink_unlock (GstBaseSink * sink)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "Unlock");
gst_d3d12_window_unlock (priv->window);
return TRUE;
}
static gboolean
gst_d3d12_video_sink_unlock_stop (GstBaseSink * sink)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "Unlock stop");
gst_d3d12_window_unlock_stop (priv->window);
return TRUE;
}
static gboolean
gst_d3d12_video_sink_propose_allocation (GstBaseSink * sink, GstQuery * query)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
GstCaps *caps;
GstBufferPool *pool = nullptr;
GstVideoInfo info;
guint size;
gboolean need_pool;
if (!self->device) {
GST_WARNING_OBJECT (self, "No configured device");
return FALSE;
}
gst_query_parse_allocation (query, &caps, &need_pool);
if (!caps) {
GST_WARNING_OBJECT (self, "no caps specified");
return FALSE;
}
if (!gst_video_info_from_caps (&info, caps)) {
GST_ERROR_OBJECT (self, "Invalid caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
size = info.size;
bool is_d3d12 = false;
auto features = gst_caps_get_features (caps, 0);
if (gst_caps_features_contains (features,
GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY)) {
is_d3d12 = true;
GST_DEBUG_OBJECT (self, "upstream support d3d12 memory");
}
if (need_pool) {
if (is_d3d12)
pool = gst_d3d12_buffer_pool_new (self->device);
else
pool = gst_video_buffer_pool_new ();
auto config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
if (!is_d3d12) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
}
gst_buffer_pool_config_set_params (config, caps, size, 2, 0);
if (!gst_buffer_pool_set_config (pool, config)) {
GST_ERROR_OBJECT (pool, "Couldn't set config");
gst_object_unref (pool);
return FALSE;
}
if (is_d3d12) {
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, nullptr, &size, nullptr,
nullptr);
gst_structure_free (config);
}
}
gst_query_add_allocation_pool (query, pool, size, 2, 0);
gst_clear_object (&pool);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, nullptr);
gst_query_add_allocation_meta (query,
GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, nullptr);
if (is_d3d12) {
gst_query_add_allocation_meta (query,
GST_VIDEO_CROP_META_API_TYPE, nullptr);
}
return TRUE;
}
static gboolean
gst_d3d12_video_sink_query (GstBaseSink * sink, GstQuery * query)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONTEXT:
{
std::lock_guard < std::recursive_mutex > lk (priv->context_lock);
if (gst_d3d12_handle_context_query (GST_ELEMENT (self), query,
self->device)) {
return TRUE;
}
break;
}
default:
break;
}
return GST_BASE_SINK_CLASS (parent_class)->query (sink, query);
}
static GstFlowReturn
gst_d3d12_video_sink_check_device_update (GstD3D12VideoSink * self,
GstBuffer * buf)
{
auto priv = self->priv;
auto mem = gst_buffer_peek_memory (buf, 0);
if (!gst_is_d3d12_memory (mem))
return GST_FLOW_OK;
auto dmem = GST_D3D12_MEMORY_CAST (mem);
if (gst_d3d12_device_is_equal (dmem->device, self->device))
return GST_FLOW_OK;
GST_INFO_OBJECT (self, "Updating device %" GST_PTR_FORMAT " -> %"
GST_PTR_FORMAT, self->device, dmem->device);
{
std::lock_guard < std::recursive_mutex > lk (priv->lock);
priv->update_window = TRUE;
}
std::lock_guard < std::recursive_mutex > lk (priv->context_lock);
gst_clear_object (&self->device);
self->device = (GstD3D12Device *) gst_object_ref (dmem->device);
if (priv->pool) {
gst_buffer_pool_set_active (priv->pool, FALSE);
gst_clear_object (&priv->pool);
}
priv->pool = gst_d3d12_buffer_pool_new (self->device);
auto config = gst_buffer_pool_get_config (priv->pool);
gst_buffer_pool_config_set_params (config, priv->caps, priv->info.size, 0, 0);
if (!gst_buffer_pool_set_config (priv->pool, config) ||
!gst_buffer_pool_set_active (priv->pool, TRUE)) {
GST_ELEMENT_ERROR (self, RESOURCE, FAILED, (nullptr),
("Couldn't setup buffer pool"));
gst_clear_object (&priv->pool);
return GST_FLOW_ERROR;
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d12_video_sink_open_window (GstD3D12VideoSink * self)
{
auto overlay = GST_VIDEO_OVERLAY (self);
auto priv = self->priv;
guintptr window_handle = 0;
auto is_closed = gst_d3d12_window_is_closed (priv->window);
gboolean need_open = FALSE;
{
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!priv->window_open_called) {
GST_DEBUG_OBJECT (self, "Open was not called, try open");
gst_video_overlay_prepare_window_handle (overlay);
need_open = TRUE;
} else if (priv->window_handle_updated) {
GST_DEBUG_OBJECT (self, "Set window handle was called, try open again");
need_open = TRUE;
} else if (is_closed) {
/* Request new window handle */
GST_LOG_OBJECT (self, "Window was closed, requesting new window handle");
gst_video_overlay_prepare_window_handle (overlay);
if (priv->window_handle_updated) {
GST_DEBUG_OBJECT (self, "Set window handle was called");
need_open = TRUE;
}
}
priv->window_handle_updated = FALSE;
if (!need_open) {
if (!is_closed)
return GST_FLOW_OK;
GST_WARNING_OBJECT (self, "Window was closed");
return GST_D3D12_WINDOW_FLOW_CLOSED;
}
window_handle = priv->window_handle;
if (!window_handle && priv->external_only) {
GST_WARNING_OBJECT (self,
"external-window-only mode but window handle is unavailable");
return GST_D3D12_WINDOW_FLOW_CLOSED;
}
}
priv->window_open_called = TRUE;
priv->warn_closed_window = TRUE;
auto ret = gst_d3d12_window_open (priv->window, self->device,
GST_VIDEO_SINK_WIDTH (self), GST_VIDEO_SINK_HEIGHT (self),
(HWND) window_handle, priv->direct_swapchain);
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (ret == GST_FLOW_OK) {
if (window_handle) {
GST_DEBUG_OBJECT (self, "Window created with HWND %p",
(void *) window_handle);
gst_video_overlay_got_window_handle (overlay, window_handle);
} else {
auto internal_hwnd = gst_d3d12_window_get_window_handle (priv->window);
GST_DEBUG_OBJECT (self, "Window created with internal HWND %p",
(void *) internal_hwnd);
gst_video_overlay_got_window_handle (overlay, internal_hwnd);
}
priv->update_window = TRUE;
}
return ret;
}
static GstFlowReturn
gst_d3d12_video_sink_prepare (GstBaseSink * sink, GstBuffer * buffer)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
auto ret = gst_d3d12_video_sink_check_device_update (self, buffer);
if (ret != GST_FLOW_OK)
goto out;
ret = gst_d3d12_video_sink_open_window (self);
if (ret != GST_FLOW_OK)
goto out;
ret = gst_d3d12_video_sink_set_buffer (self, buffer, TRUE);
out:
if (ret == GST_D3D12_WINDOW_FLOW_CLOSED) {
if (priv->error_on_closed) {
GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
("Output window was closed"), (nullptr));
return GST_FLOW_ERROR;
} else {
if (priv->warn_closed_window) {
GST_ELEMENT_WARNING (self, RESOURCE, NOT_FOUND,
("Output window was closed"), (nullptr));
priv->warn_closed_window = FALSE;
} else {
GST_WARNING_OBJECT (self, "Output window was closed");
}
ret = GST_FLOW_OK;
}
}
return ret;
}
static GstFlowReturn
gst_d3d12_video_sink_show_frame (GstVideoSink * sink, GstBuffer * buf)
{
auto self = GST_D3D12_VIDEO_SINK (sink);
auto priv = self->priv;
auto ret = gst_d3d12_video_sink_set_buffer (self, buf, FALSE);
if (ret != GST_FLOW_OK)
goto out;
ret = gst_d3d12_window_present (priv->window);
out:
if (ret == GST_D3D12_WINDOW_FLOW_CLOSED) {
if (priv->error_on_closed) {
GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
("Output window was closed"), (nullptr));
ret = GST_FLOW_ERROR;
} else {
if (priv->warn_closed_window) {
GST_ELEMENT_WARNING (self, RESOURCE, NOT_FOUND,
("Output window was closed"), (nullptr));
priv->warn_closed_window = FALSE;
} else {
GST_WARNING_OBJECT (self, "Output window was closed");
}
ret = GST_FLOW_OK;
}
}
return ret;
}
static void
gst_d3d12_video_sink_overlay_expose (GstVideoOverlay * overlay)
{
auto self = GST_D3D12_VIDEO_SINK (overlay);
auto priv = self->priv;
gst_d3d12_window_expose (priv->window);
}
static void
gst_d3d12_video_sink_overlay_handle_events (GstVideoOverlay * overlay,
gboolean handle_events)
{
auto self = GST_D3D12_VIDEO_SINK (overlay);
auto priv = self->priv;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
priv->enable_navigation = handle_events;
gst_d3d12_window_set_enable_navigation_events (priv->window, handle_events);
}
static void
gst_d3d12_video_sink_overlay_set_window_handle (GstVideoOverlay * overlay,
guintptr window_handle)
{
auto self = GST_D3D12_VIDEO_SINK (overlay);
auto priv = self->priv;
GST_DEBUG ("set window handle %" G_GUINTPTR_FORMAT, window_handle);
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (priv->window_handle != window_handle) {
priv->window_handle = window_handle;
priv->window_handle_updated = TRUE;
}
}
static void
gst_d3d12_video_sink_overlay_set_render_rectangle (GstVideoOverlay * overlay,
gint x, gint y, gint width, gint height)
{
auto self = GST_D3D12_VIDEO_SINK (overlay);
auto priv = self->priv;
GST_DEBUG_OBJECT (self,
"render rect x: %d, y: %d, width: %d, height %d", x, y, width, height);
GstVideoRectangle rect;
rect.x = x;
rect.y = y;
rect.w = width;
rect.h = height;
gst_d3d12_window_set_render_rect (priv->window, &rect);
}
static void
gst_d3d12_video_sink_video_overlay_init (GstVideoOverlayInterface * iface)
{
iface->expose = gst_d3d12_video_sink_overlay_expose;
iface->handle_events = gst_d3d12_video_sink_overlay_handle_events;
iface->set_window_handle = gst_d3d12_video_sink_overlay_set_window_handle;
iface->set_render_rectangle =
gst_d3d12_video_sink_overlay_set_render_rectangle;
}
static void
gst_d3d12_video_sink_navigation_send_event (GstNavigation * navigation,
GstEvent * event)
{
auto self = GST_D3D12_VIDEO_SINK (navigation);
if (event) {
gboolean handled;
gst_event_ref (event);
handled = gst_pad_push_event (GST_VIDEO_SINK_PAD (self), event);
if (!handled)
gst_element_post_message (GST_ELEMENT_CAST (self),
gst_navigation_message_new_event (GST_OBJECT_CAST (self), event));
gst_event_unref (event);
}
}
static void
gst_d3d12_video_sink_navigation_init (GstNavigationInterface * iface)
{
iface->send_event_simple = gst_d3d12_video_sink_navigation_send_event;
}
static void
gst_d3d12_video_sink_on_overlay (GstD3D12Window * window,
gpointer command_queue, gpointer resource12, gpointer device11on12,
gpointer resource11, gpointer context2d, gpointer viewport,
GstD3D12VideoSink * self)
{
g_signal_emit (self, d3d12_video_sink_signals[SIGNAL_OVERLAY], 0,
command_queue, resource12, device11on12, resource11, context2d, viewport);
}
Reference in a new issue View git blame Copy permalink