gstreamer/subprojects/gst-plugins-bad/sys/dwrite/gstdwriterender_d3d12.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

903 lines
29 KiB
C++
Raw Normal View 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 "gstdwriterender_d3d12.h"
#include "gstdwrite-renderer.h"
#include <gst/d3d12/gstd3d12-private.h>
#include <d3d11on12.h>
#include <wrl.h>
#include <vector>
#include <queue>
GST_DEBUG_CATEGORY_EXTERN (dwrite_overlay_object_debug);
#define GST_CAT_DEFAULT dwrite_overlay_object_debug
#define ASYNC_DEPTH 4
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
struct GstDWriteD3D12RenderPrivate
{
GstDWriteD3D12RenderPrivate ()
{
fence_data_pool = gst_d3d12_fence_data_pool_new ();
}
~GstDWriteD3D12RenderPrivate ()
{
renderer = nullptr;
dwrite_factory = nullptr;
d2d_factory = nullptr;
ClearResource ();
gst_clear_object (&fence_data_pool);
}
void ClearResource ()
{
if (device) {
gst_d3d12_device_fence_wait (device, D3D12_COMMAND_LIST_TYPE_DIRECT,
fence_val);
}
gst_clear_object (&ca_pool);
cl = nullptr;
{
GstD3D12Device11on12LockGuard lk (device);
d2d_target = nullptr;
wrapped_texture = nullptr;
layout_resource = nullptr;
device11on12 = nullptr;
d3d11_context = nullptr;
device11 = nullptr;
}
if (layout_pool)
gst_buffer_pool_set_active (layout_pool, FALSE);
gst_clear_object (&layout_pool);
if (blend_pool)
gst_buffer_pool_set_active (blend_pool, FALSE);
gst_clear_object (&blend_pool);
gst_clear_object (&pre_conv);
gst_clear_object (&blend_conv);
gst_clear_object (&post_conv);
gst_clear_object (&device);
prepared = FALSE;
fence_val = 0;
scheduled = { };
}
GstD3D12Device *device = nullptr;
ComPtr<ID2D1Factory> d2d_factory;
ComPtr<IDWriteFactory> dwrite_factory;
ComPtr<IGstDWriteTextRenderer> renderer;
ComPtr<ID3D11Texture2D> wrapped_texture;
ComPtr<ID3D12Resource> layout_resource;
ComPtr<ID2D1RenderTarget> d2d_target;
GstBufferPool *layout_pool = nullptr;
GstBufferPool *blend_pool = nullptr;
GstVideoInfo layout_info;
GstVideoInfo blend_info;
GstVideoInfo info;
gboolean direct_blend = FALSE;
gboolean prepared = FALSE;
GstD3D12Converter *pre_conv = nullptr;
GstD3D12Converter *blend_conv = nullptr;
GstD3D12Converter *post_conv = nullptr;
guint64 fence_val = 0;
ComPtr<ID3D12GraphicsCommandList> cl;
GstD3D12FenceDataPool *fence_data_pool;
GstD3D12CommandAllocatorPool *ca_pool = nullptr;
ComPtr<ID3D11On12Device> device11on12;
ComPtr<ID3D11Device> device11;
ComPtr<ID3D11DeviceContext> d3d11_context;
std::queue<guint64> scheduled;
};
/* *INDENT-ON* */
struct _GstDWriteD3D12Render
{
GstDWriteRender parent;
GstDWriteD3D12RenderPrivate *priv;
};
static void gst_dwrite_d3d12_render_finalize (GObject * object);
static GstBuffer *gst_dwrite_d3d12_render_draw_layout (GstDWriteRender * render,
IDWriteTextLayout * layout, gint x, gint y);
static gboolean gst_dwrite_d3d12_render_blend (GstDWriteRender * render,
GstBuffer * layout_buf, gint x, gint y, GstBuffer * output);
static gboolean
gst_dwrite_d3d12_render_update_device (GstDWriteRender * render,
GstBuffer * buffer);
static gboolean
gst_dwrite_d3d12_render_handle_allocation_query (GstDWriteRender * render,
GstElement * elem, GstQuery * query);
static gboolean gst_dwrite_d3d12_render_can_inplace (GstDWriteRender * render,
GstBuffer * buffer);
static gboolean gst_dwrite_d3d12_render_upload (GstDWriteRender * render,
const GstVideoInfo * info, GstBuffer * in_buf, GstBuffer * out_buf);
static gboolean gst_dwrite_d3d12_render_prepare (GstDWriteD3D12Render * self);
#define gst_dwrite_d3d12_render_parent_class parent_class
G_DEFINE_FINAL_TYPE (GstDWriteD3D12Render, gst_dwrite_d3d12_render,
GST_TYPE_DWRITE_RENDER);
static void
gst_dwrite_d3d12_render_class_init (GstDWriteD3D12RenderClass * klass)
{
auto object_class = G_OBJECT_CLASS (klass);
auto render_class = GST_DWRITE_RENDER_CLASS (klass);
object_class->finalize = gst_dwrite_d3d12_render_finalize;
render_class->draw_layout = gst_dwrite_d3d12_render_draw_layout;
render_class->blend = gst_dwrite_d3d12_render_blend;
render_class->update_device = gst_dwrite_d3d12_render_update_device;
render_class->handle_allocation_query =
gst_dwrite_d3d12_render_handle_allocation_query;
render_class->can_inplace = gst_dwrite_d3d12_render_can_inplace;
render_class->upload = gst_dwrite_d3d12_render_upload;
}
static void
gst_dwrite_d3d12_render_init (GstDWriteD3D12Render * self)
{
self->priv = new GstDWriteD3D12RenderPrivate ();
}
static void
gst_dwrite_d3d12_render_finalize (GObject * object)
{
auto self = GST_DWRITE_D3D12_RENDER (object);
delete self->priv;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GstBufferPool *
gst_dwrite_d3d12_render_create_pool (GstDWriteD3D12Render * self,
const GstVideoInfo * info)
{
auto priv = self->priv;
auto caps = gst_video_info_to_caps (info);
if (!caps) {
GST_ERROR_OBJECT (self, "Invalid info");
return nullptr;
}
auto pool = gst_d3d12_buffer_pool_new (priv->device);
auto config = gst_buffer_pool_get_config (pool);
auto params = gst_d3d12_allocation_params_new (priv->device, info,
GST_D3D12_ALLOCATION_FLAG_DEFAULT,
D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS |
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, D3D12_HEAP_FLAG_NONE);
gst_buffer_pool_config_set_d3d12_allocation_params (config, params);
gst_d3d12_allocation_params_free (params);
gst_buffer_pool_config_set_params (config, caps, 0, 0, 0);
gst_caps_unref (caps);
if (!gst_buffer_pool_set_config (pool, config)) {
GST_ERROR_OBJECT (self, "Couldn't set config");
gst_object_unref (pool);
return nullptr;
}
if (!gst_buffer_pool_set_active (pool, TRUE)) {
GST_ERROR_OBJECT (self, "Couldn't set active");
gst_object_unref (pool);
return nullptr;
}
return pool;
}
static GstBuffer *
gst_dwrite_d3d12_render_draw_layout (GstDWriteRender * render,
IDWriteTextLayout * layout, gint x, gint y)
{
auto self = GST_DWRITE_D3D12_RENDER (render);
auto priv = self->priv;
if (!priv->prepared) {
GST_ERROR_OBJECT (self, "Not prepapred");
return nullptr;
}
auto width = (gint) layout->GetMaxWidth ();
auto height = (gint) layout->GetMaxHeight ();
if (priv->layout_pool && (priv->layout_info.width != width ||
priv->layout_info.height != height)) {
gst_buffer_pool_set_active (priv->layout_pool, FALSE);
gst_clear_object (&priv->layout_pool);
GstD3D12Device11on12LockGuard lk (priv->device);
priv->d2d_target = nullptr;
priv->wrapped_texture = nullptr;
priv->layout_resource = nullptr;
}
if (!priv->layout_pool) {
gst_video_info_set_format (&priv->layout_info, GST_VIDEO_FORMAT_BGRA,
width, height);
priv->layout_pool = gst_dwrite_d3d12_render_create_pool (self,
&priv->layout_info);
if (!priv->layout_pool) {
GST_ERROR_OBJECT (self, "Couldn't create pool");
return nullptr;
}
}
if (!priv->layout_resource) {
auto device = gst_d3d12_device_get_device_handle (priv->device);
D3D12_HEAP_PROPERTIES heap_prop = { };
heap_prop.Type = D3D12_HEAP_TYPE_DEFAULT;
heap_prop.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heap_prop.CreationNodeMask = 1;
heap_prop.VisibleNodeMask = 1;
D3D12_RESOURCE_DESC desc = { };
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
desc.Width = width;
desc.Height = height;
desc.DepthOrArraySize = 1;
desc.MipLevels = 1;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET |
D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS;
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
auto hr = device->CreateCommittedResource (&heap_prop,
D3D12_HEAP_FLAG_SHARED, &desc, D3D12_RESOURCE_STATE_COMMON,
nullptr, IID_PPV_ARGS (&priv->layout_resource));
if (!gst_d3d12_result (hr, priv->device)) {
GST_ERROR_OBJECT (self, "Couldn't create layout texture");
return nullptr;
}
GstD3D12Device11on12LockGuard lk (priv->device);
D3D11_RESOURCE_FLAGS flags11 = { };
flags11.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
flags11.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
hr = priv->device11on12->CreateWrappedResource (priv->
layout_resource.Get (), &flags11, D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
IID_PPV_ARGS (&priv->wrapped_texture));
if (!gst_d3d12_result (hr, priv->device)) {
GST_ERROR_OBJECT (self, "Couldn't create wrappred resource");
priv->layout_resource = nullptr;
return nullptr;
}
ComPtr < IDXGISurface > surface;
static const D2D1_RENDER_TARGET_PROPERTIES props = {
D2D1_RENDER_TARGET_TYPE_DEFAULT, DXGI_FORMAT_B8G8R8A8_UNORM,
D2D1_ALPHA_MODE_PREMULTIPLIED, 0, 0, D2D1_RENDER_TARGET_USAGE_NONE,
D2D1_FEATURE_LEVEL_DEFAULT
};
hr = priv->wrapped_texture->QueryInterface (IID_PPV_ARGS (&surface));
if (!gst_d3d12_result (hr, priv->device)) {
GST_ERROR_OBJECT (self, "Couldn't get DXGI surface");
priv->wrapped_texture = nullptr;
priv->layout_resource = nullptr;
return nullptr;
}
hr = priv->d2d_factory->CreateDxgiSurfaceRenderTarget (surface.Get (),
props, &priv->d2d_target);
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't create d2d render target");
priv->wrapped_texture = nullptr;
priv->layout_resource = nullptr;
return nullptr;
}
}
if (priv->scheduled.size () >= ASYNC_DEPTH) {
auto fence_to_wait = priv->scheduled.front ();
priv->scheduled.pop ();
gst_d3d12_device_fence_wait (priv->device,
D3D12_COMMAND_LIST_TYPE_DIRECT, fence_to_wait);
}
GstBuffer *layout_buf = nullptr;
gst_buffer_pool_acquire_buffer (priv->layout_pool, &layout_buf, nullptr);
if (!layout_buf) {
GST_ERROR_OBJECT (self, "Couldn't acquire buffer");
return nullptr;
}
{
GstD3D12Device11on12LockGuard lk (priv->device);
ID3D11Resource *wrapped[] = { priv->wrapped_texture.Get () };
priv->device11on12->AcquireWrappedResources (wrapped, 1);
priv->d2d_target->BeginDraw ();
priv->d2d_target->Clear (D2D1::ColorF (D2D1::ColorF::Black, 0.0));
priv->renderer->Draw (D2D1::Point2F (),
D2D1::Rect (0, 0, width, height), layout, priv->d2d_target.Get ());
priv->d2d_target->EndDraw ();
priv->device11on12->ReleaseWrappedResources (wrapped, 1);
priv->d3d11_context->Flush ();
}
auto dmem = (GstD3D12Memory *) gst_buffer_peek_memory (layout_buf, 0);
auto texture = gst_d3d12_memory_get_resource_handle (dmem);
GstD3D12CopyTextureRegionArgs args = { };
args.src.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
args.src.pResource = priv->layout_resource.Get ();
args.dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
args.dst.pResource = texture;
GstD3D12FenceData *fence_data;
gst_d3d12_fence_data_pool_acquire (priv->fence_data_pool, &fence_data);
auto resource_clone = priv->layout_resource;
auto wrapped_clone = priv->wrapped_texture;
gst_d3d12_fence_data_push (fence_data,
FENCE_NOTIFY_COM (resource_clone.Detach ()));
gst_d3d12_fence_data_push (fence_data,
FENCE_NOTIFY_COM (wrapped_clone.Detach ()));
gst_d3d12_device_copy_texture_region (priv->device,
1, &args, fence_data, 0, nullptr, nullptr, D3D12_COMMAND_LIST_TYPE_DIRECT,
&priv->fence_val);
priv->scheduled.push (priv->fence_val);
gst_d3d12_memory_set_fence (dmem,
gst_d3d12_device_get_fence_handle (priv->device,
D3D12_COMMAND_LIST_TYPE_DIRECT), priv->fence_val, FALSE);
GST_MINI_OBJECT_FLAG_SET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_DOWNLOAD);
GST_MINI_OBJECT_FLAG_UNSET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
return layout_buf;
}
static gboolean
gst_dwrite_d3d12_render_blend (GstDWriteRender * render, GstBuffer * layout_buf,
gint x, gint y, GstBuffer * output)
{
auto self = GST_DWRITE_D3D12_RENDER (render);
auto priv = self->priv;
if (!priv->prepared) {
GST_ERROR_OBJECT (self, "Not prepapred");
return FALSE;
}
if (priv->scheduled.size () >= ASYNC_DEPTH) {
auto fence_to_wait = priv->scheduled.front ();
priv->scheduled.pop ();
gst_d3d12_device_fence_wait (priv->device,
D3D12_COMMAND_LIST_TYPE_DIRECT, fence_to_wait);
}
GstD3D12Frame out_frame;
if (!gst_d3d12_frame_map (&out_frame, &priv->info, output,
GST_MAP_WRITE_D3D12, GST_D3D12_FRAME_MAP_FLAG_RTV)) {
GST_ERROR_OBJECT (self, "Couldn't map output frame");
return FALSE;
}
gst_d3d12_frame_unmap (&out_frame);
GstD3D12CommandAllocator *gst_ca;
if (!gst_d3d12_command_allocator_pool_acquire (priv->ca_pool, &gst_ca)) {
GST_ERROR_OBJECT (self, "Couldn't acquire command allocator");
return FALSE;
}
auto ca = gst_d3d12_command_allocator_get_handle (gst_ca);
auto hr = ca->Reset ();
if (!gst_d3d12_result (hr, priv->device)) {
GST_ERROR_OBJECT (self, "Couldn't reset command allocator");
gst_d3d12_command_allocator_unref (gst_ca);
return FALSE;
}
if (!priv->cl) {
auto device = gst_d3d12_device_get_device_handle (priv->device);
hr = device->CreateCommandList (0, D3D12_COMMAND_LIST_TYPE_DIRECT,
ca, nullptr, IID_PPV_ARGS (&priv->cl));
if (!gst_d3d12_result (hr, priv->device)) {
GST_ERROR_OBJECT (self, "Couldn't create command list");
gst_d3d12_command_allocator_unref (gst_ca);
return FALSE;
}
} else {
hr = priv->cl->Reset (ca, nullptr);
if (!gst_d3d12_result (hr, priv->device)) {
GST_ERROR_OBJECT (self, "Couldn't reset command list");
gst_d3d12_command_allocator_unref (gst_ca);
return FALSE;
}
}
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));
g_object_set (priv->blend_conv, "src-width", priv->layout_info.width,
"src-height", priv->layout_info.height,
"dest-x", x, "dest-y", y, "dest-width", priv->layout_info.width,
"dest-height", priv->layout_info.height, nullptr);
gboolean ret = TRUE;
GstBuffer *bgra_buf = nullptr;
auto cq = gst_d3d12_device_get_command_queue (priv->device,
D3D12_COMMAND_LIST_TYPE_DIRECT);
auto fence = gst_d3d12_command_queue_get_fence_handle (cq);
if (priv->direct_blend) {
GST_LOG_OBJECT (self, "Direct blend");
ret = gst_d3d12_converter_convert_buffer (priv->blend_conv,
layout_buf, output, fence_data, priv->cl.Get (), TRUE);
} else {
GST_LOG_OBJECT (self, "Need conversion for blending");
gst_buffer_pool_acquire_buffer (priv->blend_pool, &bgra_buf, nullptr);
if (!bgra_buf) {
GST_ERROR_OBJECT (self, "Couldn't acquire preconv buffer");
ret = FALSE;
}
if (ret) {
ret = gst_d3d12_converter_convert_buffer (priv->pre_conv,
output, bgra_buf, fence_data, priv->cl.Get (), TRUE);
}
if (ret) {
auto dmem = (GstD3D12Memory *) gst_buffer_peek_memory (bgra_buf, 0);
auto resource = gst_d3d12_memory_get_resource_handle (dmem);
D3D12_RESOURCE_BARRIER barrier = { };
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = resource;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barrier.Transition.StateAfter =
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
priv->cl->ResourceBarrier (1, &barrier);
ret = gst_d3d12_converter_convert_buffer (priv->blend_conv,
layout_buf, bgra_buf, fence_data, priv->cl.Get (), FALSE);
}
if (ret) {
std::vector < D3D12_RESOURCE_BARRIER > barriers;
auto dmem = (GstD3D12Memory *) gst_buffer_peek_memory (bgra_buf, 0);
auto resource = gst_d3d12_memory_get_resource_handle (dmem);
D3D12_RESOURCE_BARRIER barrier = { };
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = resource;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barrier.Transition.StateAfter =
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barriers.push_back (barrier);
for (guint i = 0; i < gst_buffer_n_memory (output); i++) {
dmem = (GstD3D12Memory *) gst_buffer_peek_memory (output, i);
resource = gst_d3d12_memory_get_resource_handle (dmem);
barrier.Transition.pResource = resource;
barrier.Transition.StateBefore =
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
barriers.push_back (barrier);
}
priv->cl->ResourceBarrier (barriers.size (), barriers.data ());
ret = gst_d3d12_converter_convert_buffer (priv->post_conv,
bgra_buf, output, fence_data, priv->cl.Get (), FALSE);
}
gst_clear_buffer (&bgra_buf);
}
hr = priv->cl->Close ();
if (ret)
ret = gst_d3d12_result (hr, priv->device);
if (ret) {
ID3D12CommandList *cl[] = { priv->cl.Get () };
hr = gst_d3d12_command_queue_execute_command_lists (cq,
1, cl, &priv->fence_val);
ret = gst_d3d12_result (hr, priv->device);
}
if (ret) {
gst_d3d12_command_queue_set_notify (cq, priv->fence_val,
FENCE_NOTIFY_MINI_OBJECT (fence_data));
priv->scheduled.push (priv->fence_val);
for (guint i = 0; i < gst_buffer_n_memory (output); i++) {
auto dmem = (GstD3D12Memory *) gst_buffer_peek_memory (output, i);
gst_d3d12_memory_set_fence (dmem, fence, priv->fence_val, FALSE);
GST_MINI_OBJECT_FLAG_SET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_DOWNLOAD);
GST_MINI_OBJECT_FLAG_UNSET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
}
} else {
gst_d3d12_fence_data_unref (fence_data);
}
return ret;
}
static gboolean
gst_dwrite_d3d12_render_update_device (GstDWriteRender * render,
GstBuffer * buffer)
{
auto self = GST_DWRITE_D3D12_RENDER (render);
auto priv = self->priv;
auto mem = gst_buffer_peek_memory (buffer, 0);
if (!gst_is_d3d12_memory (mem))
return FALSE;
auto dmem = GST_D3D12_MEMORY_CAST (mem);
if (!gst_d3d12_device_is_equal (dmem->device, priv->device)) {
priv->ClearResource ();
priv->device = (GstD3D12Device *) gst_object_ref (dmem->device);
gst_dwrite_d3d12_render_prepare (self);
return TRUE;
}
return FALSE;
}
static gboolean
gst_dwrite_d3d12_render_handle_allocation_query (GstDWriteRender * render,
GstElement * elem, GstQuery * query)
{
auto self = GST_DWRITE_D3D12_RENDER (render);
auto priv = self->priv;
GstCaps *caps = nullptr;
gst_query_parse_allocation (query, &caps, nullptr);
if (!caps) {
GST_WARNING_OBJECT (elem, "Query without caps");
return FALSE;
}
GstVideoInfo info;
if (!gst_video_info_from_caps (&info, caps)) {
GST_ERROR_OBJECT (elem, "Invalid caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
auto features = gst_caps_get_features (caps, 0);
if (!gst_caps_features_contains (features,
GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY)) {
GST_DEBUG_OBJECT (elem, "Not a d3d12 caps");
return TRUE;
}
gboolean update_pool = FALSE;
guint min, max, size;
GstBufferPool *pool = nullptr;
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
} else {
min = max = 0;
size = info.size;
}
if (pool) {
if (!GST_IS_D3D12_BUFFER_POOL (pool)) {
gst_clear_object (&pool);
} else {
auto dpool = GST_D3D12_BUFFER_POOL (pool);
if (!gst_d3d12_device_is_equal (dpool->device, priv->device))
gst_clear_object (&pool);
}
}
if (!pool)
pool = gst_d3d12_buffer_pool_new (priv->device);
auto config = gst_buffer_pool_get_config (pool);
auto params = gst_buffer_pool_config_get_d3d12_allocation_params (config);
if (!params) {
params = gst_d3d12_allocation_params_new (priv->device, &info,
GST_D3D12_ALLOCATION_FLAG_DEFAULT,
D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS |
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, D3D12_HEAP_FLAG_NONE);
} else {
gst_d3d12_allocation_params_set_resource_flags (params,
D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS |
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
gst_d3d12_allocation_params_unset_resource_flags (params,
D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE);
}
gst_buffer_pool_config_set_d3d12_allocation_params (config, params);
gst_d3d12_allocation_params_free (params);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
if (!gst_buffer_pool_set_config (pool, config)) {
GST_ERROR_OBJECT (self, "Couldn't set config");
gst_object_unref (pool);
return FALSE;
}
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, nullptr, &size, nullptr, nullptr);
gst_structure_free (config);
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool (query, pool, size, min, max);
gst_object_unref (pool);
return TRUE;
}
static gboolean
gst_dwrite_d3d12_render_can_inplace (GstDWriteRender * render,
GstBuffer * buffer)
{
auto self = GST_DWRITE_D3D12_RENDER (render);
auto priv = self->priv;
auto mem = gst_buffer_peek_memory (buffer, 0);
if (!gst_is_d3d12_memory (mem))
return FALSE;
auto dmem = GST_D3D12_MEMORY_CAST (mem);
if (!gst_d3d12_device_is_equal (dmem->device, priv->device))
return FALSE;
D3D12_RESOURCE_DESC desc;
auto resource = gst_d3d12_memory_get_resource_handle (dmem);
desc = resource->GetDesc ();
if ((desc.Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE) != 0 ||
(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) == 0) {
return FALSE;
}
return TRUE;
}
static gboolean
gst_dwrite_d3d12_render_upload_d3d12 (GstDWriteD3D12Render * self,
GstBuffer * dst, GstBuffer * src)
{
auto priv = self->priv;
GST_TRACE_OBJECT (self, "d3d12 copy");
return gst_d3d12_buffer_copy_into (dst, src, &priv->info);
}
static gboolean
gst_dwrite_d3d12_render_upload (GstDWriteRender * render,
const GstVideoInfo * info, GstBuffer * in_buf, GstBuffer * out_buf)
{
auto self = GST_DWRITE_D3D12_RENDER (render);
auto priv = self->priv;
if (!priv->prepared) {
GST_ERROR_OBJECT (self, "Not prepared");
return FALSE;
}
auto mem = gst_buffer_peek_memory (in_buf, 0);
if (gst_is_d3d12_memory (mem) &&
gst_d3d12_device_is_equal (GST_D3D12_MEMORY_CAST (mem)->device,
priv->device)) {
return gst_dwrite_d3d12_render_upload_d3d12 (self, out_buf, in_buf);
}
return GST_DWRITE_RENDER_CLASS (parent_class)->upload (render,
info, in_buf, out_buf);
}
static gboolean
is_subsampled_yuv (const GstVideoInfo * info)
{
if (!GST_VIDEO_INFO_IS_YUV (info))
return FALSE;
for (guint i = 0; i < GST_VIDEO_MAX_COMPONENTS; i++) {
if (info->finfo->w_sub[i] != 0 || info->finfo->h_sub[i] != 0)
return TRUE;
}
return FALSE;
}
static GstD3D12Converter *
create_converter (GstDWriteD3D12Render * self, const GstVideoInfo * in_info,
const GstVideoInfo * out_info, gboolean is_blend)
{
auto priv = self->priv;
D3D12_FILTER filter = D3D12_FILTER_MIN_MAG_MIP_POINT;
D3D12_BLEND_DESC blend_desc = { };
blend_desc.AlphaToCoverageEnable = FALSE;
blend_desc.IndependentBlendEnable = FALSE;
blend_desc.RenderTarget[0].BlendEnable = FALSE;
blend_desc.RenderTarget[0].LogicOpEnable = FALSE;
blend_desc.RenderTarget[0].SrcBlend = D3D12_BLEND_ONE;
blend_desc.RenderTarget[0].DestBlend = D3D12_BLEND_ZERO;
blend_desc.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
blend_desc.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_ONE;
blend_desc.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_ZERO;
blend_desc.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
blend_desc.RenderTarget[0].LogicOp = D3D12_LOGIC_OP_NOOP;
blend_desc.RenderTarget[0].RenderTargetWriteMask =
D3D12_COLOR_WRITE_ENABLE_ALL;
if (is_subsampled_yuv (in_info) || is_subsampled_yuv (out_info))
filter = D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT;
auto config = gst_structure_new ("convert-config",
GST_D3D12_CONVERTER_OPT_SAMPLER_FILTER,
GST_TYPE_D3D12_CONVERTER_SAMPLER_FILTER, filter, nullptr);
if (is_blend) {
blend_desc.RenderTarget[0].BlendEnable = TRUE;
blend_desc.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
blend_desc.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
blend_desc.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
blend_desc.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_ONE;
blend_desc.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
blend_desc.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
gst_structure_set (config, GST_D3D11_CONVERTER_OPT_SRC_ALPHA_MODE,
GST_TYPE_D3D12_CONVERTER_ALPHA_MODE,
GST_D3D12_CONVERTER_ALPHA_MODE_PREMULTIPLIED, nullptr);
}
auto ret = gst_d3d12_converter_new (priv->device, nullptr, in_info, out_info,
&blend_desc, nullptr, config);
if (!ret)
GST_ERROR_OBJECT (self, "Couldn't create converter");
return ret;
}
static gboolean
gst_dwrite_d3d12_render_prepare (GstDWriteD3D12Render * self)
{
auto priv = self->priv;
GstVideoInfo bgra_info;
gst_video_info_set_format (&bgra_info,
GST_VIDEO_FORMAT_BGRA, priv->info.width, priv->info.height);
if (priv->direct_blend) {
priv->blend_conv = create_converter (self, &bgra_info, &priv->blend_info,
TRUE);
} else {
priv->blend_pool = gst_dwrite_d3d12_render_create_pool (self,
&priv->blend_info);
if (!priv->blend_pool)
return FALSE;
priv->pre_conv = create_converter (self,
&priv->info, &priv->blend_info, FALSE);
if (!priv->pre_conv)
return FALSE;
priv->blend_conv = create_converter (self,
&bgra_info, &priv->blend_info, TRUE);
if (!priv->blend_conv)
return FALSE;
priv->post_conv = create_converter (self,
&priv->blend_info, &priv->info, FALSE);
if (!priv->post_conv)
return FALSE;
}
ComPtr < IUnknown > unknown =
gst_d3d12_device_get_11on12_handle (priv->device);
if (!unknown) {
GST_ERROR_OBJECT (self, "Couldn't get d3d11on12 device");
return FALSE;
}
unknown.As (&priv->device11on12);
priv->device11on12.As (&priv->device11);
priv->device11->GetImmediateContext (&priv->d3d11_context);
auto device = gst_d3d12_device_get_device_handle (priv->device);
priv->ca_pool = gst_d3d12_command_allocator_pool_new (device,
D3D12_COMMAND_LIST_TYPE_DIRECT);
GST_DEBUG_OBJECT (self, "Resource prepared");
priv->prepared = TRUE;
return TRUE;
}
GstDWriteRender *
gst_dwrite_d3d12_render_new (GstD3D12Device * device, const GstVideoInfo * info,
ID2D1Factory * d2d_factory, IDWriteFactory * dwrite_factory)
{
auto self = (GstDWriteD3D12Render *)
g_object_new (GST_TYPE_DWRITE_D3D12_RENDER, nullptr);
gst_object_ref_sink (self);
auto priv = self->priv;
priv->device = (GstD3D12Device *) gst_object_ref (device);
priv->info = *info;
auto format = GST_VIDEO_INFO_FORMAT (info);
switch (format) {
case GST_VIDEO_FORMAT_BGRA:
case GST_VIDEO_FORMAT_RGBA:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_VUYA:
case GST_VIDEO_FORMAT_RGBA64_LE:
case GST_VIDEO_FORMAT_RGB10A2_LE:
priv->direct_blend = TRUE;
gst_video_info_set_format (&priv->blend_info,
format, info->width, info->height);
break;
default:
priv->direct_blend = FALSE;
if (GST_VIDEO_INFO_COMP_DEPTH (info, 0) > 8) {
gst_video_info_set_format (&priv->blend_info,
GST_VIDEO_FORMAT_RGBA64_LE, info->width, info->height);
} else {
gst_video_info_set_format (&priv->blend_info,
GST_VIDEO_FORMAT_BGRA, info->width, info->height);
}
break;
}
if (!gst_dwrite_d3d12_render_prepare (self)) {
gst_object_unref (self);
return nullptr;
}
priv->d2d_factory = d2d_factory;
priv->dwrite_factory = dwrite_factory;
IGstDWriteTextRenderer::CreateInstance (dwrite_factory, &priv->renderer);
return GST_DWRITE_RENDER (self);
}