mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-15 04:46:32 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/d3d12/gstd3d12swapchainsink.cpp
Seungha Yang 43fc9525ca d3d12swapchainsink: Fix error when the sink is reused 
Release backbuffer just before releasing swapchain

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7867>
2024-11-12 12:03:18 +00:00

1466 lines
48 KiB
C++
Raw Blame History

/* GStreamer
* Copyright (C) 2024 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 "gstd3d12swapchainsink.h"
#include "gstd3d12pluginutils.h"
#include "gstd3d12overlaycompositor.h"
#include <directx/d3dx12.h>
#include <mutex>
#include <wrl.h>
#include <vector>
#include <memory>
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
/* *INDENT-ON* */
enum
{
PROP_0,
PROP_ADAPTER,
PROP_FORCE_ASPECT_RATIO,
PROP_WIDTH,
PROP_HEIGHT,
PROP_BORDER_COLOR,
PROP_SWAPCHAIN,
PROP_SAMPLING_METHOD,
PROP_MSAA,
PROP_HUE,
PROP_SATURATION,
PROP_BRIGHTNESS,
PROP_CONTRAST,
};
#define DEFAULT_ADAPTER -1
#define DEFAULT_FORCE_ASPECT_RATIO TRUE
#define DEFAULT_WIDTH 1280
#define DEFAULT_HEIGHT 720
#define DEFAULT_BORDER_COLOR (G_GUINT64_CONSTANT(0xffff000000000000))
#define DEFAULT_SAMPLING_METHOD GST_D3D12_SAMPLING_METHOD_BILINEAR
#define DEFAULT_MSAA GST_D3D12_MSAA_DISABLED
#define DEFAULT_HUE 0.0
#define DEFAULT_SATURATION 1.0
#define DEFAULT_BRIGHTNESS 0.0
#define DEFAULT_CONTRAST 1.0
#define BACK_BUFFER_COUNT 2
enum
{
SIGNAL_RESIZE,
SIGNAL_LAST
};
static guint d3d12_swapchain_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_swapchain_sink_debug);
#define GST_CAT_DEFAULT gst_d3d12_swapchain_sink_debug
/* *INDENT-OFF* */
struct BackBuffer
{
BackBuffer (GstBuffer * buffer, ID3D12Resource * res)
{
backbuf = buffer;
resource = res;
}
~BackBuffer ()
{
gst_clear_buffer (&backbuf);
}
GstBuffer *backbuf = nullptr;
ComPtr<ID3D12Resource> resource;
};
struct GstD3D12SwapChainSinkPrivate
{
GstD3D12SwapChainSinkPrivate ()
{
const gchar *channels[4] = { "HUE", "SATURATION",
"BRIGHTNESS", "CONTRAST"
};
convert_config = gst_structure_new_empty ("convert-config");
fence_data_pool = gst_d3d12_fence_data_pool_new ();
gst_video_info_init (&info);
gst_video_info_set_format (&display_info, GST_VIDEO_FORMAT_RGBA,
width, height);
update_border_color ();
color_balance_channels = nullptr;
for (guint i = 0; i < G_N_ELEMENTS (channels); i++) {
auto ch = (GstColorBalanceChannel *)
g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, nullptr);
ch->label = g_strdup (channels[i]);
ch->min_value = -1000;
ch->max_value = 1000;
color_balance_channels = g_list_append (color_balance_channels, ch);
}
}
~GstD3D12SwapChainSinkPrivate ()
{
stop ();
gst_structure_free (convert_config);
gst_clear_object (&comp);
gst_clear_object (&ca_pool);
gst_clear_object (&fence_data_pool);
gst_clear_buffer (&msaa_buf);
backbuf.clear ();
auto iter = color_balance_channels;
while (iter) {
g_object_unref (iter->data);
iter = iter->next;
}
g_list_free (color_balance_channels);
}
void stop ()
{
if (cq && swapchain && fence_val > 0)
gst_d3d12_cmd_queue_idle_for_swapchain (cq, fence_val);
if (pool) {
gst_buffer_pool_set_active (pool, FALSE);
gst_clear_object (&pool);
}
gst_clear_caps (&caps);
gst_clear_buffer (&cached_buf);
gst_clear_object (&conv);
convert_format = GST_VIDEO_FORMAT_UNKNOWN;
caps_updated = false;
first_present = true;
}
void update_border_color ()
{
border_color_val[0] = ((border_color &
G_GUINT64_CONSTANT(0x0000ffff00000000)) >> 32) / (FLOAT) G_MAXUINT16;
border_color_val[1] = ((border_color &
G_GUINT64_CONSTANT(0x00000000ffff0000)) >> 16) / (FLOAT) G_MAXUINT16;
border_color_val[2] = (border_color &
G_GUINT64_CONSTANT(0x000000000000ffff)) / (FLOAT) G_MAXUINT16;
border_color_val[3] = ((border_color &
G_GUINT64_CONSTANT(0xffff000000000000)) >> 48) / (FLOAT) G_MAXUINT16;
}
std::recursive_mutex lock;
GstVideoInfo info;
GstVideoInfo display_info;
guint display_width;
guint display_height;
GstVideoFormat convert_format = GST_VIDEO_FORMAT_UNKNOWN;
ComPtr<IDXGISwapChain4> swapchain;
ComPtr<ID3D12GraphicsCommandList> cl;
std::vector<std::shared_ptr<BackBuffer>> backbuf;
GstStructure *convert_config = nullptr;
GstD3D12FenceDataPool *fence_data_pool = nullptr;
GstBufferPool *pool = nullptr;
GstD3D12CmdQueue *cq = nullptr;
GstD3D12CmdAllocPool *ca_pool = nullptr;
GstBuffer *cached_buf = nullptr;
GstBuffer *msaa_buf = nullptr;
GstCaps *caps = nullptr;
GstD3D12Converter *conv = nullptr;
GstD3D12OverlayCompositor *comp = nullptr;
guint64 fence_val = 0;
bool caps_updated = false;
bool first_present = true;
bool output_updated = false;
D3D12_BOX crop_rect = { };
D3D12_BOX prev_crop_rect = { };
FLOAT border_color_val[4];
GstVideoRectangle viewport = { };
gboolean auto_resize = FALSE;
gint adapter = DEFAULT_ADAPTER;
gint force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
guint width = DEFAULT_WIDTH;
guint height = DEFAULT_HEIGHT;
guint64 border_color = DEFAULT_BORDER_COLOR;
GstD3D12SamplingMethod sampling_method = DEFAULT_SAMPLING_METHOD;
GstD3D12MSAAMode msaa_mode = DEFAULT_MSAA;
GList *color_balance_channels = nullptr;
gdouble hue = DEFAULT_HUE;
gdouble saturation = DEFAULT_SATURATION;
gdouble brightness = DEFAULT_BRIGHTNESS;
gdouble contrast = DEFAULT_CONTRAST;
};
/* *INDENT-ON* */
struct _GstD3D12SwapChainSink
{
GstVideoSink parent;
GstD3D12Device *device;
GstD3D12SwapChainSinkPrivate *priv;
};
static void gst_d3d12_swapchain_sink_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec);
static void gst_d3d12_swapchain_sink_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec);
static void gst_d3d12_swapchain_sink_finalize (GObject * object);
static void gst_d3d12_swapchain_sink_set_context (GstElement * element,
GstContext * context);
static gboolean gst_d3d12_swapchain_sink_start (GstBaseSink * sink);
static gboolean gst_d3d12_swapchain_sink_stop (GstBaseSink * sink);
static gboolean gst_d3d12_swapchain_sink_propose_allocation (GstBaseSink * sink,
GstQuery * query);
static gboolean gst_d3d12_swapchain_sink_query (GstBaseSink * sink,
GstQuery * query);
static GstFlowReturn gst_d3d12_swapchain_sink_prepare (GstBaseSink * sink,
GstBuffer * buf);
static gboolean gst_d3d12_swapchain_sink_set_info (GstVideoSink * sink,
GstCaps * caps, const GstVideoInfo * info);
static GstFlowReturn gst_d3d12_swapchain_sink_show_frame (GstVideoSink * sink,
GstBuffer * buf);
static void gst_d3d12_swapchain_sink_resize (GstD3D12SwapChainSink * self,
guint width, guint height);
static void
gst_d3d12_swapchain_sink_resize_internal (GstD3D12SwapChainSink * self,
guint width, guint height);
static void
gst_d3d12_swapchain_sink_color_balance_init (GstColorBalanceInterface * iface);
#define gst_d3d12_swapchain_sink_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstD3D12SwapChainSink, gst_d3d12_swapchain_sink,
GST_TYPE_VIDEO_SINK,
G_IMPLEMENT_INTERFACE (GST_TYPE_COLOR_BALANCE,
gst_d3d12_swapchain_sink_color_balance_init));
static void
gst_d3d12_swapchain_sink_class_init (GstD3D12SwapChainSinkClass * 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_swapchain_sink_set_property;
object_class->get_property = gst_d3d12_swapchain_sink_get_property;
object_class->finalize = gst_d3d12_swapchain_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_WIDTH,
g_param_spec_uint ("swapchain-width", "Swapchain Width",
"Width of swapchain buffers",
1, D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION, DEFAULT_WIDTH,
(GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_HEIGHT,
g_param_spec_uint ("swapchain-height", "Swapchain Height",
"Height of swapchain buffers",
1, D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION, DEFAULT_HEIGHT,
(GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_BORDER_COLOR,
g_param_spec_uint64 ("border-color", "Border Color",
"ARGB64 representation of the border color to use",
0, G_MAXUINT64, DEFAULT_BORDER_COLOR,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_SWAPCHAIN,
g_param_spec_pointer ("swapchain", "SwapChain",
"DXGI swapchain handle",
(GParamFlags) (GST_PARAM_DOC_SHOW_DEFAULT | G_PARAM_READABLE |
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)));
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_HUE,
g_param_spec_double ("hue", "Hue", "hue", -1.0, 1.0, DEFAULT_HUE,
(GParamFlags) (GST_PARAM_CONTROLLABLE |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_SATURATION,
g_param_spec_double ("saturation", "Saturation", "saturation", 0.0, 2.0,
DEFAULT_SATURATION,
(GParamFlags) (GST_PARAM_CONTROLLABLE |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_BRIGHTNESS,
g_param_spec_double ("brightness", "Brightness", "brightness", -1.0, 1.0,
DEFAULT_BRIGHTNESS,
(GParamFlags) (GST_PARAM_CONTROLLABLE |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (object_class, PROP_CONTRAST,
g_param_spec_double ("contrast", "Contrast", "contrast", 0.0, 2.0,
DEFAULT_CONTRAST,
(GParamFlags) (GST_PARAM_CONTROLLABLE |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
d3d12_swapchain_sink_signals[SIGNAL_RESIZE] =
g_signal_new_class_handler ("resize", G_TYPE_FROM_CLASS (klass),
(GSignalFlags) (G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
G_CALLBACK (gst_d3d12_swapchain_sink_resize), nullptr, nullptr, nullptr,
G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);
element_class->set_context =
GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_set_context);
gst_element_class_set_static_metadata (element_class,
"Direct3D12 SwapChain Sink", "Sink/Video",
"DXGI composition swapchain 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_swapchain_sink_start);
basesink_class->stop = GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_stop);
basesink_class->propose_allocation =
GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_propose_allocation);
basesink_class->query = GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_query);
basesink_class->prepare =
GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_prepare);
videosink_class->set_info =
GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_set_info);
videosink_class->show_frame =
GST_DEBUG_FUNCPTR (gst_d3d12_swapchain_sink_show_frame);
GST_DEBUG_CATEGORY_INIT (gst_d3d12_swapchain_sink_debug,
"d3d12swapchainsink", 0, "d3d12swapchainsink");
gst_type_mark_as_plugin_api (GST_TYPE_D3D12_SAMPLING_METHOD,
(GstPluginAPIFlags) 0);
gst_type_mark_as_plugin_api (GST_TYPE_D3D12_MSAA_MODE, (GstPluginAPIFlags) 0);
}
static void
gst_d3d12_swapchain_sink_init (GstD3D12SwapChainSink * self)
{
self->priv = new GstD3D12SwapChainSinkPrivate ();
}
static void
gst_d3d12_swapchain_sink_finalize (GObject * object)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (object);
delete self->priv;
gst_clear_object (&self->device);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_d3d12_swapchain_sink_update_color_balance (GstD3D12SwapChainSink * self,
const gchar * name, gdouble * prev, gdouble value)
{
auto priv = self->priv;
if (*prev != value) {
GList *iter = priv->color_balance_channels;
*prev = value;
priv->output_updated = true;
while (iter) {
auto ch = (GstColorBalanceChannel *) iter->data;
if (g_ascii_strcasecmp (ch->label, name) == 0) {
auto iface = GST_COLOR_BALANCE (self);
gst_color_balance_value_changed (iface, ch,
gst_color_balance_get_value (iface, ch));
break;
}
iter = g_list_next (iter);
}
}
}
static void
gst_d3d12_swapchain_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
auto self = GST_D3D12_SWAPCHAIN_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:
{
auto val = g_value_get_boolean (value);
if (val != priv->force_aspect_ratio) {
priv->force_aspect_ratio = val;
gst_d3d12_swapchain_sink_resize_internal (self,
priv->width, priv->height);
}
break;
}
case PROP_BORDER_COLOR:
priv->border_color = g_value_get_uint64 (value);
priv->update_border_color ();
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;
if (priv->conv) {
g_object_set (priv->conv, "sampler-filter",
gst_d3d12_sampling_method_to_native (priv->sampling_method),
nullptr);
}
}
break;
}
case PROP_MSAA:
{
auto msaa = (GstD3D12MSAAMode) g_value_get_enum (value);
if (priv->msaa_mode != msaa) {
priv->msaa_mode = msaa;
gst_d3d12_swapchain_sink_resize_internal (self,
priv->width, priv->height);
}
break;
}
case PROP_HUE:
gst_d3d12_swapchain_sink_update_color_balance (self,
"HUE", &priv->hue, g_value_get_double (value));
break;
case PROP_SATURATION:
gst_d3d12_swapchain_sink_update_color_balance (self,
"SATURATION", &priv->saturation, g_value_get_double (value));
break;
case PROP_BRIGHTNESS:
gst_d3d12_swapchain_sink_update_color_balance (self,
"BRIGHTNESS", &priv->brightness, g_value_get_double (value));
break;
case PROP_CONTRAST:
gst_d3d12_swapchain_sink_update_color_balance (self,
"CONTRAST", &priv->contrast, g_value_get_double (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_d3d12_swapchain_sink_resize_unlocked (GstD3D12SwapChainSink * self,
guint width, guint height)
{
auto priv = self->priv;
if (width != priv->width || height != priv->height) {
GST_DEBUG_OBJECT (self, "Resizing swapchain, %ux%u -> %ux%u",
priv->width, priv->height, width, height);
if (priv->cq && priv->swapchain && priv->fence_val > 0)
gst_d3d12_cmd_queue_idle_for_swapchain (priv->cq, priv->fence_val);
priv->backbuf.clear ();
priv->width = width;
priv->height = height;
priv->first_present = true;
gst_video_info_set_format (&priv->display_info, GST_VIDEO_FORMAT_RGBA,
width, height);
}
if (priv->swapchain && priv->backbuf.empty ()) {
auto hr = priv->swapchain->ResizeBuffers (BACK_BUFFER_COUNT,
priv->width, priv->height, DXGI_FORMAT_R8G8B8A8_UNORM, 0);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Resize failed");
return FALSE;
}
for (guint i = 0; i < BACK_BUFFER_COUNT; i++) {
ComPtr < ID3D12Resource > backbuf;
hr = priv->swapchain->GetBuffer (i, IID_PPV_ARGS (&backbuf));
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't get backbuffer");
priv->backbuf.clear ();
return FALSE;
}
auto mem = gst_d3d12_allocator_alloc_wrapped (nullptr, self->device,
backbuf.Get (), 0, nullptr, nullptr);
auto buf = gst_buffer_new ();
gst_buffer_append_memory (buf, mem);
auto swapbuf = std::make_shared < BackBuffer > (buf, backbuf.Get ());
priv->backbuf.push_back (swapbuf);
}
}
gst_clear_buffer (&priv->msaa_buf);
if (priv->swapchain) {
DXGI_SAMPLE_DESC sample_desc = { };
gst_d3d12_calculate_sample_desc_for_msaa (self->device,
DXGI_FORMAT_R8G8B8A8_UNORM, priv->msaa_mode, &sample_desc);
if (sample_desc.Count > 1) {
auto device = gst_d3d12_device_get_device_handle (self->device);
GST_DEBUG_OBJECT (self, "Enable MSAA x%d with quality level %d",
sample_desc.Count, sample_desc.Quality);
D3D12_HEAP_PROPERTIES heap_prop =
CD3DX12_HEAP_PROPERTIES (D3D12_HEAP_TYPE_DEFAULT);
D3D12_RESOURCE_DESC resource_desc =
CD3DX12_RESOURCE_DESC::Tex2D (DXGI_FORMAT_R8G8B8A8_UNORM,
priv->width, priv->height,
1, 1, sample_desc.Count, sample_desc.Quality,
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
D3D12_CLEAR_VALUE clear_value = { };
clear_value.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
for (guint i = 0; i < 4; i++)
clear_value.Color[i] = priv->border_color_val[i];
ComPtr < ID3D12Resource > msaa_texture;
auto hr = device->CreateCommittedResource (&heap_prop,
D3D12_HEAP_FLAG_NONE,
&resource_desc, D3D12_RESOURCE_STATE_RENDER_TARGET, &clear_value,
IID_PPV_ARGS (&msaa_texture));
if (gst_d3d12_result (hr, self->device)) {
auto mem = gst_d3d12_allocator_alloc_wrapped (nullptr, self->device,
msaa_texture.Get (), 0, nullptr, nullptr);
priv->msaa_buf = gst_buffer_new ();
gst_buffer_append_memory (priv->msaa_buf, mem);
}
}
}
return TRUE;
}
static gboolean
gst_d3d12_swapchain_sink_ensure_swapchain (GstD3D12SwapChainSink * self)
{
auto priv = self->priv;
if (priv->swapchain)
return TRUE;
if (!gst_d3d12_ensure_element_data (GST_ELEMENT_CAST (self), priv->adapter,
&self->device)) {
GST_ERROR_OBJECT (self, "Cannot create device");
return FALSE;
}
priv->cq = gst_d3d12_device_get_cmd_queue (self->device,
D3D12_COMMAND_LIST_TYPE_DIRECT);
auto cq = gst_d3d12_cmd_queue_get_handle (priv->cq);
auto factory = gst_d3d12_device_get_factory_handle (self->device);
DXGI_SWAP_CHAIN_DESC1 desc = { };
desc.Width = priv->width;
desc.Height = priv->height;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.BufferCount = BACK_BUFFER_COUNT;
desc.Scaling = DXGI_SCALING_STRETCH;
desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
desc.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED;
ComPtr < IDXGISwapChain1 > swapchain;
auto hr = factory->CreateSwapChainForComposition (cq, &desc, nullptr,
&swapchain);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't create swapchain");
return FALSE;
}
hr = swapchain.As (&priv->swapchain);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't get IDXGISwapChain4 interface");
return FALSE;
}
auto device = gst_d3d12_device_get_device_handle (self->device);
priv->ca_pool = gst_d3d12_cmd_alloc_pool_new (device,
D3D12_COMMAND_LIST_TYPE_DIRECT);
GstVideoInfo info;
gst_video_info_set_format (&info,
GST_VIDEO_FORMAT_RGBA, priv->width, priv->height);
priv->comp = gst_d3d12_overlay_compositor_new (self->device, &info);
return gst_d3d12_swapchain_sink_resize_unlocked (self,
priv->width, priv->height);
}
static void
gst_d3d12_swapchain_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
auto self = GST_D3D12_SWAPCHAIN_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_WIDTH:
g_value_set_uint (value, priv->width);
break;
case PROP_HEIGHT:
g_value_set_uint (value, priv->height);
break;
case PROP_BORDER_COLOR:
g_value_set_uint64 (value, priv->border_color);
break;
case PROP_SWAPCHAIN:
gst_d3d12_swapchain_sink_ensure_swapchain (self);
g_value_set_pointer (value, priv->swapchain.Get ());
break;
case PROP_SAMPLING_METHOD:
g_value_set_enum (value, priv->sampling_method);
break;
case PROP_MSAA:
g_value_set_enum (value, priv->msaa_mode);
break;
case PROP_HUE:
g_value_set_double (value, priv->hue);
break;
case PROP_SATURATION:
g_value_set_double (value, priv->saturation);
break;
case PROP_BRIGHTNESS:
g_value_set_double (value, priv->brightness);
break;
case PROP_CONTRAST:
g_value_set_double (value, priv->contrast);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_d3d12_swapchain_sink_set_context (GstElement * element,
GstContext * context)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (element);
auto priv = self->priv;
gst_d3d12_handle_set_context (element, context, priv->adapter, &self->device);
GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
}
static gboolean
gst_d3d12_swapchain_sink_set_info (GstVideoSink * sink, GstCaps * caps,
const GstVideoInfo * info)
{
auto self = GST_D3D12_SWAPCHAIN_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->caps_updated = 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 gboolean
gst_d3d12_swapchain_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 gboolean
gst_d3d12_swapchain_sink_render (GstD3D12SwapChainSink * self)
{
auto priv = self->priv;
if (!priv->cached_buf) {
GST_DEBUG_OBJECT (self, "No cached buffer");
return TRUE;
}
auto crop_rect = priv->crop_rect;
auto crop_meta = gst_buffer_get_video_crop_meta (priv->cached_buf);
if (crop_meta) {
crop_rect = CD3DX12_BOX (crop_meta->x, crop_meta->y,
crop_meta->x + crop_meta->width, crop_meta->y + crop_meta->height);
}
if (crop_rect != priv->prev_crop_rect) {
g_object_set (priv->conv, "src-x", (gint) crop_rect.left,
"src-y", (gint) crop_rect.top,
"src-width", (gint) (crop_rect.right - crop_rect.left),
"src-height", (gint) (crop_rect.bottom - crop_rect.top), nullptr);
priv->prev_crop_rect = crop_rect;
}
priv->lock.lock ();
if (priv->first_present || priv->output_updated) {
GstVideoRectangle dst_rect = { };
dst_rect.w = priv->width;
dst_rect.h = priv->height;
if (priv->force_aspect_ratio) {
GstVideoRectangle src_rect = { };
src_rect.w = priv->display_width;
src_rect.h = priv->display_height;
gst_video_sink_center_rect (src_rect, dst_rect, &priv->viewport, TRUE);
} else {
priv->viewport = dst_rect;
}
g_object_set (priv->conv, "dest-x", priv->viewport.x,
"dest-y", priv->viewport.y, "dest-width", priv->viewport.w,
"dest-height", priv->viewport.h, "hue", priv->hue,
"saturation", priv->saturation, "brightness", priv->brightness,
"contrast", priv->contrast, nullptr);
gst_d3d12_overlay_compositor_update_viewport (priv->comp, &priv->viewport);
priv->first_present = false;
priv->output_updated = false;
}
priv->lock.unlock ();
gst_d3d12_overlay_compositor_upload (priv->comp, priv->cached_buf);
GstD3D12CmdAlloc *gst_ca;
if (!gst_d3d12_cmd_alloc_pool_acquire (priv->ca_pool, &gst_ca)) {
GST_ERROR_OBJECT (self, "Couldn't acquire command allocator");
return FALSE;
}
auto ca = gst_d3d12_cmd_alloc_get_handle (gst_ca);
auto hr = ca->Reset ();
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't reset command list");
gst_d3d12_cmd_alloc_unref (gst_ca);
return FALSE;
}
ComPtr < ID3D12GraphicsCommandList > cl;
if (!priv->cl) {
auto device_handle = gst_d3d12_device_get_device_handle (self->device);
hr = device_handle->CreateCommandList (0, D3D12_COMMAND_LIST_TYPE_DIRECT,
ca, nullptr, IID_PPV_ARGS (&cl));
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't create command list");
gst_d3d12_cmd_alloc_unref (gst_ca);
return FALSE;
}
priv->cl = cl;
} else {
cl = priv->cl;
hr = cl->Reset (ca, nullptr);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't reset command list");
gst_d3d12_cmd_alloc_unref (gst_ca);
return FALSE;
}
}
auto cur_idx = priv->swapchain->GetCurrentBackBufferIndex ();
auto backbuf = priv->backbuf[cur_idx]->backbuf;
GstD3D12FenceData *fence_data;
gst_d3d12_fence_data_pool_acquire (priv->fence_data_pool, &fence_data);
gst_d3d12_fence_data_push (fence_data, FENCE_NOTIFY_MINI_OBJECT (gst_ca));
auto mem = (GstD3D12Memory *) gst_buffer_peek_memory (backbuf, 0);
auto backbuf_texture = gst_d3d12_memory_get_resource_handle (mem);
GstBuffer *conv_outbuf = backbuf;
ID3D12Resource *msaa_resource = nullptr;
if (priv->msaa_buf) {
conv_outbuf = priv->msaa_buf;
mem = (GstD3D12Memory *) gst_buffer_peek_memory (conv_outbuf, 0);
msaa_resource = gst_d3d12_memory_get_resource_handle (mem);
auto msaa_buf = gst_buffer_ref (priv->msaa_buf);
gst_d3d12_fence_data_push (fence_data, FENCE_NOTIFY_MINI_OBJECT (msaa_buf));
} else {
D3D12_RESOURCE_BARRIER barrier =
CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_RENDER_TARGET);
cl->ResourceBarrier (1, &barrier);
}
if (priv->viewport.x != 0 || priv->viewport.y != 0 ||
(guint) priv->viewport.w != priv->width ||
(guint) priv->viewport.h != priv->height) {
auto rtv_heap = gst_d3d12_memory_get_render_target_view_heap (mem);
auto cpu_handle = GetCPUDescriptorHandleForHeapStart (rtv_heap);
cl->ClearRenderTargetView (cpu_handle, priv->border_color_val, 0, nullptr);
}
if (!gst_d3d12_converter_convert_buffer (priv->conv,
priv->cached_buf, conv_outbuf, fence_data, cl.Get (), TRUE)) {
GST_ERROR_OBJECT (self, "Couldn't build convert command");
gst_d3d12_fence_data_unref (fence_data);
return FALSE;
}
if (!gst_d3d12_overlay_compositor_draw (priv->comp,
conv_outbuf, fence_data, cl.Get ())) {
GST_ERROR_OBJECT (self, "Couldn't build overlay command");
gst_d3d12_fence_data_unref (fence_data);
return FALSE;
}
if (msaa_resource) {
std::vector < D3D12_RESOURCE_BARRIER > barriers;
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (msaa_resource,
D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_RESOLVE_SOURCE));
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_RESOLVE_DEST));
cl->ResourceBarrier (barriers.size (), barriers.data ());
cl->ResolveSubresource (backbuf_texture, 0, msaa_resource, 0,
DXGI_FORMAT_R8G8B8A8_UNORM);
barriers.clear ();
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (msaa_resource,
D3D12_RESOURCE_STATE_RESOLVE_SOURCE,
D3D12_RESOURCE_STATE_RENDER_TARGET));
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
D3D12_RESOURCE_STATE_RESOLVE_DEST, D3D12_RESOURCE_STATE_COMMON));
cl->ResourceBarrier (barriers.size (), barriers.data ());
} else {
auto barrier = CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COMMON);
cl->ResourceBarrier (1, &barrier);
}
hr = cl->Close ();
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't close command list");
gst_d3d12_fence_data_unref (fence_data);
return FALSE;
}
ID3D12CommandList *cmd_list[] = { cl.Get () };
hr = gst_d3d12_cmd_queue_execute_command_lists (priv->cq,
1, cmd_list, &priv->fence_val);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Signal failed");
gst_d3d12_fence_data_unref (fence_data);
return FALSE;
}
gst_d3d12_cmd_queue_set_notify (priv->cq, priv->fence_val,
fence_data, (GDestroyNotify) gst_d3d12_fence_data_unref);
return TRUE;
}
static gboolean
gst_d3d12_swapchain_sink_set_buffer (GstD3D12SwapChainSink * self,
GstBuffer * buffer, gboolean is_prepare)
{
auto priv = self->priv;
bool need_render = false;
bool update_converter = false;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!priv->swapchain || priv->backbuf.empty ()) {
GST_ERROR_OBJECT (self, "Swapchain was not configured");
return FALSE;
}
if (is_prepare) {
if (priv->caps_updated) {
need_render = false;
update_converter = false;
} else {
need_render = true;
update_converter = false;
}
} else {
if (priv->caps_updated) {
need_render = true;
update_converter = true;
priv->caps_updated = false;
if (priv->auto_resize) {
gst_clear_buffer (&priv->cached_buf);
gst_d3d12_swapchain_sink_resize_internal (self,
GST_VIDEO_SINK_WIDTH (self), GST_VIDEO_SINK_HEIGHT (self));
}
} else {
need_render = false;
update_converter = false;
}
}
if (update_converter) {
gst_d3d12_cmd_queue_idle_for_swapchain (priv->cq, priv->fence_val);
auto format = GST_VIDEO_INFO_FORMAT (&priv->info);
if (priv->convert_format != format)
gst_clear_object (&priv->conv);
priv->display_width = GST_VIDEO_SINK_WIDTH (self);
priv->display_height = GST_VIDEO_SINK_HEIGHT (self);
priv->convert_format = format;
priv->crop_rect = CD3DX12_BOX (0, 0, priv->info.width, priv->info.height);
priv->prev_crop_rect = priv->crop_rect;
priv->first_present = true;
gst_clear_buffer (&priv->cached_buf);
if (!priv->conv) {
DXGI_SAMPLE_DESC sample_desc = { };
gst_d3d12_calculate_sample_desc_for_msaa (self->device,
DXGI_FORMAT_R8G8B8A8_UNORM, priv->msaa_mode, &sample_desc);
gst_structure_set (priv->convert_config,
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,
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_PSO_SAMPLE_DESC_COUNT, G_TYPE_UINT,
sample_desc.Count,
GST_D3D12_CONVERTER_OPT_PSO_SAMPLE_DESC_QUALITY, G_TYPE_UINT,
sample_desc.Quality,
GST_D3D12_CONVERTER_OPT_COLOR_BALANCE,
GST_TYPE_D3D12_CONVERTER_COLOR_BALANCE,
GST_D3D12_CONVERTER_COLOR_BALANCE_ENABLED, nullptr);
priv->conv = gst_d3d12_converter_new (self->device, nullptr, &priv->info,
&priv->display_info, nullptr, nullptr,
gst_structure_copy (priv->convert_config));
if (!priv->conv) {
GST_ERROR_OBJECT (self, "Couldn't create converter");
return FALSE;
}
} else {
g_object_set (priv->conv, "src-x", 0, "src-y", 0,
"src-width", priv->info.width, "src-height", priv->info.height,
nullptr);
}
}
if (!need_render)
return TRUE;
auto mem = gst_buffer_peek_memory (buffer, 0);
if (!gst_is_d3d12_memory (mem)) {
GstBuffer *upload = nullptr;
gst_buffer_pool_acquire_buffer (priv->pool, &upload, nullptr);
if (!upload) {
GST_ERROR_OBJECT (self, "Couldn't allocate upload buffer");
return FALSE;
}
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 FALSE;
}
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 FALSE;
}
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 FALSE;
}
gst_buffer_foreach_meta (buffer,
(GstBufferForeachMetaFunc) gst_d3d12_swapchain_sink_foreach_meta,
upload);
gst_clear_buffer (&priv->cached_buf);
priv->cached_buf = upload;
} else {
gst_buffer_replace (&priv->cached_buf, buffer);
}
return gst_d3d12_swapchain_sink_render (self);
}
static void
gst_d3d12_swapchain_sink_resize_internal (GstD3D12SwapChainSink * self,
guint width, guint height)
{
auto priv = self->priv;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!gst_d3d12_swapchain_sink_resize_unlocked (self, width, height)) {
GST_ERROR_OBJECT (self, "Couldn't resize swapchain");
return;
}
if (priv->swapchain && priv->cached_buf &&
gst_d3d12_swapchain_sink_render (self)) {
GST_DEBUG_OBJECT (self, "resize %ux%u", width, height);
auto hr = priv->swapchain->Present (0, 0);
if (!gst_d3d12_result (hr, self->device))
GST_ERROR_OBJECT (self, "Present failed");
gst_d3d12_cmd_queue_execute_command_lists (priv->cq,
0, nullptr, &priv->fence_val);
}
}
static void
gst_d3d12_swapchain_sink_resize (GstD3D12SwapChainSink * self, guint width,
guint height)
{
auto priv = self->priv;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (width == 0 && height == 0) {
GST_DEBUG_OBJECT (self, "Enable auto resize");
priv->auto_resize = TRUE;
if (GST_VIDEO_SINK_WIDTH (self) > 0 && GST_VIDEO_SINK_HEIGHT (self) > 0) {
width = GST_VIDEO_SINK_WIDTH (self);
height = GST_VIDEO_SINK_HEIGHT (self);
} else {
GST_DEBUG_OBJECT (self, "Caps is not configured yet");
return;
}
} else {
if (width == 0 || width > D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION) {
GST_WARNING_OBJECT (self, "Invalid width value %u", width);
return;
}
if (height == 0 || height > D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION) {
GST_WARNING_OBJECT (self, "Invalid height value %u", height);
return;
}
priv->auto_resize = FALSE;
}
gst_d3d12_swapchain_sink_resize_internal (self, width, height);
}
static gboolean
gst_d3d12_swapchain_sink_start (GstBaseSink * sink)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "Start");
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!gst_d3d12_swapchain_sink_ensure_swapchain (self)) {
GST_ERROR_OBJECT (self, "Couldn't create swapchain");
return FALSE;
}
return TRUE;
}
static gboolean
gst_d3d12_swapchain_sink_stop (GstBaseSink * sink)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (sink);
auto priv = self->priv;
GST_DEBUG_OBJECT (self, "Stop");
priv->stop ();
return TRUE;
}
static gboolean
gst_d3d12_swapchain_sink_propose_allocation (GstBaseSink * sink,
GstQuery * query)
{
auto self = GST_D3D12_SWAPCHAIN_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_swapchain_sink_query (GstBaseSink * sink, GstQuery * query)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (sink);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONTEXT:
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_swapchain_sink_prepare (GstBaseSink * sink, GstBuffer * buffer)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (sink);
auto priv = self->priv;
auto pts = GST_BUFFER_PTS (buffer);
if (GST_CLOCK_TIME_IS_VALID (pts)) {
auto stream_time = gst_segment_to_stream_time (&sink->segment,
GST_FORMAT_TIME, pts);
if (GST_CLOCK_TIME_IS_VALID (stream_time))
gst_object_sync_values (GST_OBJECT (self), stream_time);
}
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!gst_d3d12_swapchain_sink_set_buffer (self, buffer, TRUE)) {
GST_ERROR_OBJECT (self, "Set buffer failed");
return GST_FLOW_ERROR;
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d12_swapchain_sink_show_frame (GstVideoSink * sink, GstBuffer * buf)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (sink);
auto priv = self->priv;
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!gst_d3d12_swapchain_sink_set_buffer (self, buf, FALSE)) {
GST_ERROR_OBJECT (self, "Set buffer failed");
return GST_FLOW_ERROR;
}
auto hr = priv->swapchain->Present (0, 0);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Present failed");
return GST_FLOW_ERROR;
}
/* To update fence value */
gst_d3d12_cmd_queue_execute_command_lists (priv->cq,
0, nullptr, &priv->fence_val);
return GST_FLOW_OK;
}
static const GList *
gst_d3d12_swapchain_sink_color_balance_list_channels (GstColorBalance * iface)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (iface);
auto priv = self->priv;
return priv->color_balance_channels;
}
static void
gst_d3d12_swapchain_sink_color_balance_set_value (GstColorBalance * iface,
GstColorBalanceChannel * channel, gint value)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (iface);
auto priv = self->priv;
gdouble new_val;
g_return_if_fail (channel->label);
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!g_ascii_strcasecmp (channel->label, "HUE")) {
new_val = (value + 1000.0) * 2.0 / 2000.0 - 1.0;
gst_d3d12_swapchain_sink_update_color_balance (self,
"HUE", &priv->hue, new_val);
} else if (!g_ascii_strcasecmp (channel->label, "SATURATION")) {
new_val = (value + 1000.0) * 2.0 / 2000.0;
gst_d3d12_swapchain_sink_update_color_balance (self,
"SATURATION", &priv->saturation, new_val);
} else if (!g_ascii_strcasecmp (channel->label, "BRIGHTNESS")) {
new_val = (value + 1000.0) * 2.0 / 2000.0 - 1.0;
gst_d3d12_swapchain_sink_update_color_balance (self,
"BRIGHTNESS", &priv->brightness, new_val);
} else if (!g_ascii_strcasecmp (channel->label, "CONTRAST")) {
new_val = (value + 1000.0) * 2.0 / 2000.0;
gst_d3d12_swapchain_sink_update_color_balance (self,
"BRIGHTNESS", &priv->contrast, new_val);
}
}
static gint
gst_d3d12_swapchain_sink_color_balance_get_value (GstColorBalance * iface,
GstColorBalanceChannel * channel)
{
auto self = GST_D3D12_SWAPCHAIN_SINK (iface);
auto priv = self->priv;
gint value = 0;
g_return_val_if_fail (channel->label, 0);
{
std::lock_guard < std::recursive_mutex > lk (priv->lock);
if (!g_ascii_strcasecmp (channel->label, "HUE")) {
auto hue = priv->hue;
value = static_cast < gint > ((hue + 1) * 2000.0 / 2.0 - 1000.0);
} else if (!g_ascii_strcasecmp (channel->label, "SATURATION")) {
auto saturation = priv->saturation;
value = static_cast < gint > (saturation * 2000.0 / 2.0 - 1000.0);
} else if (!g_ascii_strcasecmp (channel->label, "BRIGHTNESS")) {
auto brightness = priv->brightness;
value = static_cast < gint > ((brightness + 1) * 2000.0 / 2.0 - 1000.0);
} else if (!g_ascii_strcasecmp (channel->label, "CONTRAST")) {
auto contrast = priv->contrast;
value = static_cast < gint > (contrast * 2000.0 / 2.0 - 1000.0);
}
}
return value;
}
static GstColorBalanceType
gst_d3d12_swapchain_sink_color_balance_get_balance_type (GstColorBalance *
iface)
{
return GST_COLOR_BALANCE_HARDWARE;
}
static void
gst_d3d12_swapchain_sink_color_balance_init (GstColorBalanceInterface * iface)
{
iface->list_channels = gst_d3d12_swapchain_sink_color_balance_list_channels;
iface->set_value = gst_d3d12_swapchain_sink_color_balance_set_value;
iface->get_value = gst_d3d12_swapchain_sink_color_balance_get_value;
iface->get_balance_type =
gst_d3d12_swapchain_sink_color_balance_get_balance_type;
}
Reference in a new issue View git blame Copy permalink