mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-22 09:41:07 +00:00
Code Issues 1 Projects Releases Wiki Activity

d3d12decoder: Add support for d3d11 output again

Browse source 
Although d3d12download supports d3d12 to d3d11 texture copy,
this feature might be useful if an application is not ready to d3d12
support and it expects output type of decodebin(3) is d3d11.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7208>
This commit is contained in:
Seungha Yang 2024-07-19 01:14:20 +09:00
parent 8c2bbd8760
commit 800961cf28
15 changed files with 524 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12av1dec.cpp
View file

@ -95,11 +95,9 @@ gst_d3d12_av1_dec_class_init (GstD3D12AV1DecClass * klass, gpointer data)
static void
gst_d3d12_av1_dec_init (GstD3D12AV1Dec * self)
{
GstD3D12AV1DecClass *klass = GST_D3D12_AV1_DEC_GET_CLASS (self);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_AV1_DEC_GET_CLASS (self);
self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_AV1,
cdata->adapter_luid);
self->decoder = gst_d3d12_decoder_new (&klass->class_data);
}
static void
@ -116,8 +114,8 @@ static void
gst_d3d12_av1_dec_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstD3D12AV1DecClass *klass = GST_D3D12_AV1_DEC_GET_CLASS (object);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_AV1_DEC_GET_CLASS (object);
auto cdata = &klass->class_data;
gst_d3d12_decoder_proxy_get_property (object, prop_id, value, pspec, cdata);
}
@ -322,7 +320,7 @@ gst_d3d12_av1_dec_output_picture (GstDxvaAV1Decoder * decoder,
void
gst_d3d12_av1_dec_register (GstPlugin * plugin, GstD3D12Device * device,
ID3D12VideoDevice * video_device, guint rank)
ID3D12VideoDevice * video_device, guint rank, gboolean d3d11_interop)
{
GType type;
gchar *type_name;
@ -343,12 +341,14 @@ gst_d3d12_av1_dec_register (GstPlugin * plugin, GstD3D12Device * device,
GST_DEBUG_CATEGORY_INIT (gst_d3d12_av1_dec_debug, "d3d12av1dec", 0,
"d3d12av1dec");
type_info.class_data =
gst_d3d12_decoder_check_feature_support (device, video_device,
auto cdata = gst_d3d12_decoder_check_feature_support (device, video_device,
GST_DXVA_CODEC_AV1);
if (!type_info.class_data)
if (!cdata)
return;
cdata->subclass_data.d3d11_interop = d3d11_interop;
type_info.class_data = cdata;
type_name = g_strdup ("GstD3D12AV1Dec");
feature_name = g_strdup ("d3d12av1dec");

3
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12av1dec.h
View file

@ -26,7 +26,8 @@ G_BEGIN_DECLS
void gst_d3d12_av1_dec_register (GstPlugin * plugin,
GstD3D12Device * device,
ID3D12VideoDevice * video_device,
guint rank);
guint rank,
gboolean d3d11_interop);
G_END_DECLS

581
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12decoder.cpp
View file

@ -21,6 +21,8 @@
#include <config.h>
#endif
#include "gstd3d12plugin-config.h"
#include "gstd3d12decoder.h"
#include "gstd3d12decodercpbpool.h"
#include <directx/d3dx12.h>
@ -38,6 +40,12 @@
#include <algorithm>
#include <atomic>
#ifdef HAVE_GST_D3D11
#include <d3d11_4.h>
#include <gst/d3d11/gstd3d11.h>
#include <gst/d3d11/gstd3d11-private.h>
#endif
#ifndef GST_DISABLE_GST_DEBUG
#define GST_CAT_DEFAULT ensure_debug_category()
static GstDebugCategory *
@ -210,6 +218,7 @@ enum GstD3D12DecoderOutputType
GST_D3D12_DECODER_OUTPUT_UNKNOWN = 0,
GST_D3D12_DECODER_OUTPUT_SYSTEM = (1 << 0),
GST_D3D12_DECODER_OUTPUT_D3D12 = (1 << 1),
GST_D3D12_DECODER_OUTPUT_D3D11 = (1 << 2),
};
DEFINE_ENUM_FLAG_OPERATORS (GstD3D12DecoderOutputType);
@ -226,6 +235,15 @@ struct DecoderCmdData
/* Fence to wait at command record thread */
UINT64 fence_val = 0;
#ifdef HAVE_GST_D3D11
ComPtr<ID3D11Device5> device11_5;
ComPtr<ID3D11DeviceContext4> context11_4;
ComPtr<ID3D11Fence> fence11;
ComPtr<ID3D12Fence> fence12;
UINT64 fence_val_11 = 0;
#endif
};
struct DecoderOutputData
@ -355,6 +373,11 @@ struct _GstD3D12Decoder
GstDxvaCodec codec;
GstD3D12Device *device;
gint64 adapter_luid;
gboolean d3d11_interop;
#ifdef HAVE_GST_D3D11
GstD3D11Device *device11;
#endif
GstD3D12DecoderPrivate *priv;
};
@ -385,6 +408,9 @@ gst_d3d12_decoder_finalize (GObject * object)
auto self = GST_D3D12_DECODER (object);
gst_clear_object (&self->device);
#ifdef HAVE_GST_D3D11
gst_clear_object (&self->device11);
#endif
delete self->priv;
@ -392,16 +418,16 @@ gst_d3d12_decoder_finalize (GObject * object)
}
GstD3D12Decoder *
gst_d3d12_decoder_new (GstDxvaCodec codec, gint64 adapter_luid)
gst_d3d12_decoder_new (const GstD3D12DecoderSubClassData * cdata)
{
GstD3D12Decoder *self;
g_return_val_if_fail (codec > GST_DXVA_CODEC_NONE, nullptr);
g_return_val_if_fail (codec < GST_DXVA_CODEC_LAST, nullptr);
g_return_val_if_fail (cdata, nullptr);
self = (GstD3D12Decoder *) g_object_new (GST_TYPE_D3D12_DECODER, nullptr);
self->codec = codec;
self->adapter_luid = adapter_luid;
self->codec = cdata->codec;
self->adapter_luid = cdata->adapter_luid;
self->d3d11_interop = cdata->d3d11_interop;
return self;
}
@ -409,13 +435,17 @@ gst_d3d12_decoder_new (GstDxvaCodec codec, gint64 adapter_luid)
gboolean
gst_d3d12_decoder_open (GstD3D12Decoder * decoder, GstElement * element)
{
if (!gst_d3d12_ensure_element_data_for_adapter_luid (element,
decoder->adapter_luid, &decoder->device)) {
GST_ERROR_OBJECT (element, "Cannot create d3d12device");
return FALSE;
auto priv = decoder->priv;
{
std::lock_guard < std::recursive_mutex > lk (priv->context_lock);
if (!gst_d3d12_ensure_element_data_for_adapter_luid (element,
decoder->adapter_luid, &decoder->device)) {
GST_ERROR_OBJECT (element, "Cannot create d3d12device");
return FALSE;
}
}
auto priv = decoder->priv;
auto cmd = std::make_unique < DecoderCmdData > ();
HRESULT hr;
@ -1289,6 +1319,245 @@ gst_d3d12_decoder_can_direct_render (GstD3D12Decoder * self,
return TRUE;
}
static GstFlowReturn
gst_d3d12_decoder_copy_output_12 (GstD3D12Decoder * self, GstBuffer * srcbuf,
ID3D12Resource * src, D3D12_TEXTURE_COPY_LOCATION dst[2],
D3D12_COMMAND_LIST_TYPE cmd_type, guint64 * fence_val)
{
auto priv = self->priv;
D3D12_BOX src_box[2];
std::vector < GstD3D12CopyTextureRegionArgs > copy_args;
for (guint i = 0; i < 2; i++) {
GstD3D12CopyTextureRegionArgs args;
memset (&args, 0, sizeof (args));
args.src = CD3DX12_TEXTURE_COPY_LOCATION (src, i);
args.dst = dst[i];
/* FIXME: only 4:2:0 */
if (i == 0) {
src_box[i].left = GST_ROUND_UP_2 (priv->session->crop_x);
src_box[i].top = GST_ROUND_UP_2 (priv->session->crop_y);
src_box[i].right = GST_ROUND_UP_2 (priv->session->crop_x +
priv->session->output_info.width);
src_box[i].bottom =
GST_ROUND_UP_2 (priv->session->crop_y +
priv->session->output_info.height);
} else {
src_box[i].left = GST_ROUND_UP_2 (priv->session->crop_x) / 2;
src_box[i].top = GST_ROUND_UP_2 (priv->session->crop_y) / 2;
src_box[i].right =
GST_ROUND_UP_2 (priv->session->crop_x +
priv->session->output_info.width) / 2;
src_box[i].bottom =
GST_ROUND_UP_2 (priv->session->crop_y +
priv->session->output_info.height) / 2;
}
src_box[i].front = 0;
src_box[i].back = 1;
args.src_box = &src_box[i];
copy_args.push_back (args);
}
GstD3D12FenceData *fence_data = nullptr;
if (cmd_type != D3D12_COMMAND_LIST_TYPE_COPY) {
gst_d3d12_fence_data_pool_acquire (priv->fence_data_pool, &fence_data);
gst_d3d12_fence_data_push (fence_data,
FENCE_NOTIFY_MINI_OBJECT (gst_buffer_ref (srcbuf)));
}
guint64 copy_fence_val = 0;
auto copy_ret = gst_d3d12_device_copy_texture_region (self->device,
copy_args.size (), copy_args.data (), fence_data, 0, nullptr, nullptr,
cmd_type, &copy_fence_val);
if (!copy_ret) {
GST_ERROR_OBJECT (self, "Couldn't copy decoded texture to output");
gst_clear_d3d12_fence_data (&fence_data);
return GST_FLOW_ERROR;
}
if (fence_val)
*fence_val = copy_fence_val;
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d12_decoder_copy_output (GstD3D12Decoder * self, GstBuffer * src_buf,
GstBuffer * dst_buf)
{
auto priv = self->priv;
auto session = priv->session.get ();
auto in_dmem = (GstD3D12Memory *) gst_buffer_peek_memory (src_buf, 0);
auto out_mem = gst_buffer_peek_memory (dst_buf, 0);
if (gst_is_d3d12_memory (out_mem)) {
auto out_dmem = GST_D3D12_MEMORY_CAST (out_mem);
if (gst_d3d12_device_is_equal (out_dmem->device, self->device)) {
D3D12_TEXTURE_COPY_LOCATION dst_location[2];
UINT out_subresource[2];
guint64 copy_fence_val;
auto in_resource = gst_d3d12_memory_get_resource_handle (in_dmem);
auto out_resource = gst_d3d12_memory_get_resource_handle (out_dmem);
gst_d3d12_memory_get_subresource_index (out_dmem, 0, &out_subresource[0]);
gst_d3d12_memory_get_subresource_index (out_dmem, 1, &out_subresource[1]);
dst_location[0] = CD3DX12_TEXTURE_COPY_LOCATION (out_resource,
out_subresource[0]);
dst_location[1] = CD3DX12_TEXTURE_COPY_LOCATION (out_resource,
out_subresource[1]);
auto ret = gst_d3d12_decoder_copy_output_12 (self, src_buf, in_resource,
dst_location, D3D12_COMMAND_LIST_TYPE_DIRECT, &copy_fence_val);
if (ret != GST_FLOW_OK)
return ret;
auto fence = gst_d3d12_device_get_fence_handle (self->device,
D3D12_COMMAND_LIST_TYPE_DIRECT);
gst_d3d12_memory_set_fence (out_dmem, fence, copy_fence_val, FALSE);
GST_MINI_OBJECT_FLAG_SET (out_dmem,
GST_D3D12_MEMORY_TRANSFER_NEED_DOWNLOAD);
GST_MINI_OBJECT_FLAG_UNSET (out_dmem,
GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
GST_TRACE_OBJECT (self, "d3d12 copy done");
return GST_FLOW_OK;
}
}
#ifdef HAVE_GST_D3D11
else if (session->output_type == GST_D3D12_DECODER_OUTPUT_D3D11 &&
self->d3d11_interop && gst_is_d3d11_memory (out_mem)) {
auto out_dmem = GST_D3D11_MEMORY_CAST (out_mem);
if (out_dmem->device == self->device11) {
GstMapInfo out_map;
auto device11 = gst_d3d11_device_get_device_handle (self->device11);
auto in_texture11 =
gst_d3d12_memory_get_d3d11_texture (in_dmem, device11);
if (!in_texture11) {
GST_ERROR_OBJECT (self,
"Couldn't get d3d11 texture from decoded texture");
return GST_FLOW_ERROR;
}
if (!gst_memory_map (out_mem, &out_map,
(GstMapFlags) (GST_MAP_WRITE | GST_MAP_D3D11))) {
GST_ERROR_OBJECT (self, "Couldn't map output d3d11 memory");
return GST_FLOW_ERROR;
}
HRESULT hr;
{
GstD3D11DeviceLockGuard device11_lk (self->device11);
D3D11_BOX src_box = { };
src_box.left = GST_ROUND_UP_2 (session->crop_x);
src_box.top = GST_ROUND_UP_2 (session->crop_y);
src_box.right = GST_ROUND_UP_2 (session->crop_x +
session->output_info.width);
src_box.bottom = GST_ROUND_UP_2 (session->crop_y +
session->output_info.height);
src_box.front = 0;
src_box.back = 1;
auto out_texture11 = gst_d3d11_memory_get_resource_handle (out_dmem);
auto out_subresource =
gst_d3d11_memory_get_subresource_index (out_dmem);
priv->cmd->context11_4->CopySubresourceRegion (out_texture11,
out_subresource, 0, 0, 0, in_texture11, 0, &src_box);
priv->cmd->fence_val_11++;
hr = priv->cmd->context11_4->Signal (priv->cmd->fence11.Get (),
priv->cmd->fence_val_11);
}
gst_memory_unmap (out_mem, &out_map);
if (!gst_d3d11_result (hr, self->device11)) {
GST_ERROR_OBJECT (self, "Signal failed");
return GST_FLOW_ERROR;
}
/* Set d3d11 device signalled fence to d3d12 memory.
* d3d12 buffer pool or allocator will wait for this fence
* to keep resource alive if it's still being used by d3d11 */
gst_d3d12_memory_set_fence (in_dmem, priv->cmd->fence12.Get (),
priv->cmd->fence_val_11, FALSE);
GST_TRACE_OBJECT (self, "Copy done via d3d11 interop");
return GST_FLOW_OK;
}
}
#endif
if (!gst_d3d12_decoder_ensure_staging_texture (self)) {
GST_ERROR_OBJECT (self, "Couldn't allocate staging texture");
return GST_FLOW_ERROR;
}
auto in_resource = gst_d3d12_memory_get_resource_handle (in_dmem);
D3D12_TEXTURE_COPY_LOCATION dst_location[2];
dst_location[0] = CD3DX12_TEXTURE_COPY_LOCATION (session->staging.Get (),
session->layout[0]);
dst_location[1] = CD3DX12_TEXTURE_COPY_LOCATION (session->staging.Get (),
session->layout[1]);
guint64 copy_fence_val;
auto ret = gst_d3d12_decoder_copy_output_12 (self, src_buf, in_resource,
dst_location, D3D12_COMMAND_LIST_TYPE_COPY, &copy_fence_val);
if (ret != GST_FLOW_OK) {
GST_ERROR_OBJECT (self, "Couldn't download to staging buffer");
return ret;
}
auto hr = gst_d3d12_device_fence_wait (self->device,
D3D12_COMMAND_LIST_TYPE_COPY, copy_fence_val);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't wait for fence");
return GST_FLOW_ERROR;
}
guint8 *map_data;
GstVideoFrame vframe;
hr = session->staging->Map (0, nullptr, (void **) &map_data);
if (!gst_d3d12_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Couldn't map staging texture");
return GST_FLOW_ERROR;
}
if (!gst_video_frame_map (&vframe,
&session->output_info, dst_buf, GST_MAP_WRITE)) {
GST_ERROR_OBJECT (self, "Couldn't map output buffer");
session->staging->Unmap (0, nullptr);
return GST_FLOW_ERROR;
}
for (guint i = 0; i < GST_VIDEO_FRAME_N_PLANES (&vframe); i++) {
guint8 *src_data = map_data + session->layout[i].Offset;
guint8 *dst_data = (guint8 *) GST_VIDEO_FRAME_PLANE_DATA (&vframe, i);
gint width = GST_VIDEO_FRAME_COMP_WIDTH (&vframe, i) *
GST_VIDEO_FRAME_COMP_PSTRIDE (&vframe, i);
for (gint j = 0; j < GST_VIDEO_FRAME_COMP_HEIGHT (&vframe, i); j++) {
memcpy (dst_data, src_data, width);
dst_data += GST_VIDEO_FRAME_PLANE_STRIDE (&vframe, i);
src_data += session->layout[i].Footprint.RowPitch;
}
}
session->staging->Unmap (0, nullptr);
gst_video_frame_unmap (&vframe);
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d12_decoder_process_output (GstD3D12Decoder * self,
GstVideoDecoder * videodec, GstVideoCodecFrame * frame,
@ -1297,10 +1566,6 @@ gst_d3d12_decoder_process_output (GstD3D12Decoder * self,
{
GstFlowReturn ret = GST_FLOW_ERROR;
GstBuffer *buffer;
GstD3D12Memory *dmem;
ID3D12Resource *resource;
UINT subresource[2];
HRESULT hr;
bool attach_crop_meta = false;
auto priv = self->priv;
@ -1337,153 +1602,30 @@ gst_d3d12_decoder_process_output (GstD3D12Decoder * self,
buffer = decoder_pic->output_buffer ?
decoder_pic->output_buffer : decoder_pic->buffer;
dmem = (GstD3D12Memory *) gst_buffer_peek_memory (buffer, 0);
priv->session->lock.lock ();
if (gst_d3d12_decoder_can_direct_render (self, videodec,
decoder_pic->buffer, display_width, display_height)) {
GST_LOG_OBJECT (self, "Outputting without copy");
GST_MINI_OBJECT_FLAG_SET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_DOWNLOAD);
GST_MINI_OBJECT_FLAG_UNSET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
auto mem = gst_buffer_peek_memory (buffer, 0);
GST_MINI_OBJECT_FLAG_SET (mem, GST_D3D12_MEMORY_TRANSFER_NEED_DOWNLOAD);
GST_MINI_OBJECT_FLAG_UNSET (mem, GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
if (priv->session->need_crop)
attach_crop_meta = true;
frame->output_buffer = gst_buffer_ref (buffer);
} else {
ID3D12Resource *out_resource = nullptr;
UINT out_subresource[2];
ret = gst_video_decoder_allocate_output_frame (videodec, frame);
if (ret != GST_FLOW_OK) {
GST_ERROR_OBJECT (videodec, "Couldn't allocate output buffer");
goto error;
}
auto out_mem = gst_buffer_peek_memory (frame->output_buffer, 0);
if (gst_is_d3d12_memory (out_mem)) {
auto out_dmem = GST_D3D12_MEMORY_CAST (out_mem);
if (gst_d3d12_device_is_equal (dmem->device, self->device)) {
out_resource = gst_d3d12_memory_get_resource_handle (out_dmem);
gst_d3d12_memory_get_subresource_index (out_dmem, 0,
&out_subresource[0]);
gst_d3d12_memory_get_subresource_index (out_dmem, 1,
&out_subresource[1]);
GST_MINI_OBJECT_FLAG_SET (out_dmem,
GST_D3D12_MEMORY_TRANSFER_NEED_DOWNLOAD);
GST_MINI_OBJECT_FLAG_UNSET (out_dmem,
GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
}
}
if (!out_resource && !gst_d3d12_decoder_ensure_staging_texture (self)) {
GST_ERROR_OBJECT (videodec, "Couldn't allocate staging texture");
ret = GST_FLOW_ERROR;
ret = gst_d3d12_decoder_copy_output (self, buffer, frame->output_buffer);
if (ret != GST_FLOW_OK)
goto error;
}
resource = gst_d3d12_memory_get_resource_handle (dmem);
gst_d3d12_memory_get_subresource_index (dmem, 0, &subresource[0]);
gst_d3d12_memory_get_subresource_index (dmem, 1, &subresource[1]);
/* Copy texture to staging */
D3D12_BOX src_box[2];
std::vector < GstD3D12CopyTextureRegionArgs > copy_args;
for (guint i = 0; i < 2; i++) {
GstD3D12CopyTextureRegionArgs args;
memset (&args, 0, sizeof (args));
args.src = CD3DX12_TEXTURE_COPY_LOCATION (resource, subresource[i]);
if (out_resource) {
args.dst =
CD3DX12_TEXTURE_COPY_LOCATION (out_resource, out_subresource[i]);
} else {
args.dst =
CD3DX12_TEXTURE_COPY_LOCATION (priv->session->staging.Get (),
priv->session->layout[i]);
}
/* FIXME: only 4:2:0 */
if (i == 0) {
src_box[i].left = GST_ROUND_UP_2 (priv->session->crop_x);
src_box[i].top = GST_ROUND_UP_2 (priv->session->crop_y);
src_box[i].right = GST_ROUND_UP_2 (priv->session->crop_x +
priv->session->output_info.width);
src_box[i].bottom =
GST_ROUND_UP_2 (priv->session->crop_y +
priv->session->output_info.height);
} else {
src_box[i].left = GST_ROUND_UP_2 (priv->session->crop_x) / 2;
src_box[i].top = GST_ROUND_UP_2 (priv->session->crop_y) / 2;
src_box[i].right =
GST_ROUND_UP_2 (priv->session->crop_x +
priv->session->output_info.width) / 2;
src_box[i].bottom =
GST_ROUND_UP_2 (priv->session->crop_y +
priv->session->output_info.height) / 2;
}
src_box[i].front = 0;
src_box[i].back = 1;
args.src_box = &src_box[i];
copy_args.push_back (args);
}
guint64 copy_fence_val = 0;
GstD3D12FenceData *fence_data = nullptr;
D3D12_COMMAND_LIST_TYPE queue_type = D3D12_COMMAND_LIST_TYPE_COPY;
if (out_resource) {
queue_type = D3D12_COMMAND_LIST_TYPE_DIRECT;
gst_d3d12_fence_data_pool_acquire (priv->fence_data_pool, &fence_data);
gst_d3d12_fence_data_push (fence_data,
FENCE_NOTIFY_MINI_OBJECT (gst_buffer_ref (buffer)));
}
gst_d3d12_device_copy_texture_region (self->device, copy_args.size (),
copy_args.data (), fence_data, 0, nullptr, nullptr, queue_type,
&copy_fence_val);
auto fence = gst_d3d12_device_get_fence_handle (self->device, queue_type);
if (!out_resource) {
guint8 *map_data;
GstVideoFrame vframe;
gst_d3d12_device_fence_wait (self->device, queue_type, copy_fence_val);
hr = priv->session->staging->Map (0, nullptr, (void **) &map_data);
if (!gst_d3d12_result (hr, self->device)) {
ret = GST_FLOW_ERROR;
goto error;
}
gst_video_frame_map (&vframe,
&priv->session->output_info, frame->output_buffer, GST_MAP_WRITE);
for (guint i = 0; i < GST_VIDEO_FRAME_N_PLANES (&vframe); i++) {
guint8 *src = map_data + priv->session->layout[i].Offset;
guint8 *dst = (guint8 *) GST_VIDEO_FRAME_PLANE_DATA (&vframe, i);
gint width = GST_VIDEO_FRAME_COMP_WIDTH (&vframe, i) *
GST_VIDEO_FRAME_COMP_PSTRIDE (&vframe, i);
for (gint j = 0; j < GST_VIDEO_FRAME_COMP_HEIGHT (&vframe, i); j++) {
memcpy (dst, src, width);
dst += GST_VIDEO_FRAME_PLANE_STRIDE (&vframe, i);
src += priv->session->layout[i].Footprint.RowPitch;
}
}
priv->session->staging->Unmap (0, nullptr);
gst_video_frame_unmap (&vframe);
} else {
gst_d3d12_buffer_set_fence (frame->output_buffer,
fence, copy_fence_val, FALSE);
}
}
priv->session->lock.unlock ();
@ -1646,6 +1788,12 @@ gst_d3d12_decoder_negotiate (GstD3D12Decoder * decoder,
GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY)) {
allowed_types |= GST_D3D12_DECODER_OUTPUT_D3D12;
}
#ifdef HAVE_GST_D3D11
if (gst_caps_features_contains (features,
GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY)) {
allowed_types |= GST_D3D12_DECODER_OUTPUT_D3D11;
}
#endif
}
}
gst_clear_caps (&peer_caps);
@ -1685,6 +1833,57 @@ gst_d3d12_decoder_negotiate (GstD3D12Decoder * decoder,
g_clear_pointer (&priv->session->output_state, gst_video_codec_state_unref);
priv->session->output_state = state;
#ifdef HAVE_GST_D3D11
/* Try d3d11 only if downstream does not support d3d12 but does d3d11,
* otherwise decoder will create unnecessary d3d11 device */
if ((allowed_types & GST_D3D12_DECODER_OUTPUT_D3D11) ==
GST_D3D12_DECODER_OUTPUT_D3D11 &&
(allowed_types & GST_D3D12_DECODER_OUTPUT_D3D12) !=
GST_D3D12_DECODER_OUTPUT_D3D12) {
auto elem = GST_ELEMENT (videodec);
if (decoder->d3d11_interop) {
if (gst_d3d11_ensure_element_data_for_adapter_luid (elem,
decoder->adapter_luid, &decoder->device11)) {
if (!priv->cmd->device11_5) {
auto device11 =
gst_d3d11_device_get_device_handle (decoder->device11);
device11->QueryInterface (IID_PPV_ARGS (&priv->cmd->device11_5));
}
if (priv->cmd->device11_5 && !priv->cmd->context11_4) {
ComPtr < ID3D11DeviceContext > context11;
ComPtr < ID3D11DeviceContext4 > context11_4;
priv->cmd->device11_5->GetImmediateContext (&context11);
context11.As (&priv->cmd->context11_4);
}
if (priv->cmd->context11_4 && !priv->cmd->fence11) {
priv->cmd->device11_5->CreateFence (0, D3D11_FENCE_FLAG_SHARED,
IID_PPV_ARGS (&priv->cmd->fence11));
}
if (priv->cmd->fence11 && !priv->cmd->fence12) {
HANDLE handle;
auto hr = priv->cmd->fence11->CreateSharedHandle (nullptr,
GENERIC_ALL, nullptr, &handle);
if (SUCCEEDED (hr)) {
priv->cmd->device->OpenSharedHandle (handle,
IID_PPV_ARGS (&priv->cmd->fence12));
CloseHandle (handle);
}
}
if (!priv->cmd->fence12)
allowed_types &= ~GST_D3D12_DECODER_OUTPUT_D3D11;
} else {
allowed_types &= ~GST_D3D12_DECODER_OUTPUT_D3D11;
}
} else if (!gst_d3d11_ensure_element_data (elem, -1, &decoder->device11)) {
allowed_types &= ~GST_D3D12_DECODER_OUTPUT_D3D11;
}
}
#endif
auto prev_output_type = priv->session->output_type;
if (prev_output_type != GST_D3D12_DECODER_OUTPUT_UNKNOWN &&
(prev_output_type & allowed_types) == prev_output_type) {
@ -1692,14 +1891,25 @@ gst_d3d12_decoder_negotiate (GstD3D12Decoder * decoder,
} else {
if ((allowed_types & GST_D3D12_DECODER_OUTPUT_D3D12) != 0)
priv->session->output_type = GST_D3D12_DECODER_OUTPUT_D3D12;
else if ((allowed_types & GST_D3D12_DECODER_OUTPUT_D3D11) != 0)
priv->session->output_type = GST_D3D12_DECODER_OUTPUT_D3D11;
else
priv->session->output_type = GST_D3D12_DECODER_OUTPUT_SYSTEM;
}
if (priv->session->output_type == GST_D3D12_DECODER_OUTPUT_D3D12) {
gst_caps_set_features (state->caps, 0,
gst_caps_features_new_single (GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY));
priv->session->output_type = GST_D3D12_DECODER_OUTPUT_D3D12;
switch (priv->session->output_type) {
case GST_D3D12_DECODER_OUTPUT_D3D12:
gst_caps_set_features (state->caps, 0,
gst_caps_features_new_single (GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY));
break;
#ifdef HAVE_GST_D3D11
case GST_D3D12_DECODER_OUTPUT_D3D11:
gst_caps_set_features (state->caps, 0,
gst_caps_features_new_single (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY));
break;
#endif
default:
break;
}
GST_DEBUG_OBJECT (decoder, "Selected output type %d",
@ -1756,13 +1966,28 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
"Downstream pool is not d3d12, will create new one");
gst_clear_object (&pool);
} else {
GstD3D12BufferPool *dpool = GST_D3D12_BUFFER_POOL (pool);
auto dpool = GST_D3D12_BUFFER_POOL (pool);
if (!gst_d3d12_device_is_equal (dpool->device, decoder->device)) {
GST_DEBUG_OBJECT (videodec, "Different device, will create new one");
gst_clear_object (&pool);
}
}
}
#ifdef HAVE_GST_D3D11
if (priv->session->output_type == GST_D3D12_DECODER_OUTPUT_D3D11) {
if (!GST_IS_D3D12_BUFFER_POOL (pool)) {
GST_DEBUG_OBJECT (videodec,
"Downstream pool is not d3d11, will create new one");
gst_clear_object (&pool);
} else if (decoder->d3d11_interop) {
auto dpool = GST_D3D11_BUFFER_POOL (pool);
if (dpool->device != decoder->device11) {
GST_DEBUG_OBJECT (videodec, "Different device, will create new one");
gst_clear_object (&pool);
}
}
}
#endif
}
if (!pool) {
@ -1770,6 +1995,11 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
case GST_D3D12_DECODER_OUTPUT_D3D12:
pool = gst_d3d12_buffer_pool_new (decoder->device);
break;
#ifdef HAVE_GST_D3D11
case GST_D3D12_DECODER_OUTPUT_D3D11:
pool = gst_d3d11_buffer_pool_new (decoder->device11);
break;
#endif
default:
pool = gst_video_buffer_pool_new ();
break;
@ -1783,13 +2013,12 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
if (priv->session->output_type == GST_D3D12_DECODER_OUTPUT_D3D12) {
GstD3D12AllocationParams *params;
GstVideoAlignment align;
gint width, height;
gst_video_alignment_reset (&align);
params = gst_buffer_pool_config_get_d3d12_allocation_params (config);
auto params = gst_buffer_pool_config_get_d3d12_allocation_params (config);
if (!params) {
params = gst_d3d12_allocation_params_new (decoder->device, &vinfo,
GST_D3D12_ALLOCATION_FLAG_DEFAULT,
@ -1811,14 +2040,20 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
gst_d3d12_allocation_params_alignment (params, &align);
gst_buffer_pool_config_set_d3d12_allocation_params (config, params);
gst_d3d12_allocation_params_free (params);
GST_DEBUG_OBJECT (videodec, "Downstream min buffres: %d", min);
/* We will not use downstream pool for decoding, and therefore preallocation
* is unnecessary. So, Non-zero min buffer will be a waste of GPU memory */
min = 0;
}
#ifdef HAVE_GST_D3D11
else if (priv->session->output_type == GST_D3D12_DECODER_OUTPUT_D3D11) {
auto params = gst_buffer_pool_config_get_d3d11_allocation_params (config);
if (!params) {
params = gst_d3d11_allocation_params_new (decoder->device11, &vinfo,
GST_D3D11_ALLOCATION_FLAG_DEFAULT,
D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, 0);
}
gst_buffer_pool_config_set_d3d11_allocation_params (config, params);
gst_d3d11_allocation_params_free (params);
}
#endif
gst_buffer_pool_set_config (pool, config);
/* d3d12 buffer pool will update buffer size based on allocated texture,
@ -1850,6 +2085,15 @@ gst_d3d12_decoder_set_context (GstD3D12Decoder * decoder, GstElement * element,
std::lock_guard < std::recursive_mutex > lk (priv->context_lock);
gst_d3d12_handle_set_context_for_adapter_luid (element,
context, decoder->adapter_luid, &decoder->device);
#ifdef HAVE_GST_D3D11
if (decoder->d3d11_interop) {
gst_d3d11_handle_set_context_for_adapter_luid (element,
context, decoder->adapter_luid, &decoder->device11);
} else {
/* Since we will do system copy, accept any device */
gst_d3d11_handle_set_context (element, context, -1, &decoder->device11);
}
#endif
}
gboolean
@ -1861,6 +2105,11 @@ gst_d3d12_decoder_handle_query (GstD3D12Decoder * decoder, GstElement * element,
auto priv = decoder->priv;
std::lock_guard < std::recursive_mutex > lk (priv->context_lock);
#ifdef HAVE_GST_D3D11
if (gst_d3d11_handle_context_query (element, query, decoder->device11))
return TRUE;
#endif
return gst_d3d12_handle_context_query (element, query, decoder->device);
}
@ -1871,14 +2120,6 @@ enum
PROP_DECODER_VENDOR_ID,
};
struct _GstD3D12DecoderClassData
{
GstD3D12DecoderSubClassData subclass_data;
GstCaps *sink_caps;
GstCaps *src_caps;
gchar *description;
};
static void
gst_d3d12_decoder_get_profiles (const GUID & profile,
std::vector < std::string > &list)
@ -2102,11 +2343,17 @@ gst_d3d12_decoder_check_feature_support (GstD3D12Device * device,
}
/* *INDENT-ON* */
GstCaps *sink_caps = gst_caps_from_string (sink_caps_string.c_str ());
GstCaps *raw_caps = gst_caps_from_string (src_caps_string.c_str ());
GstCaps *src_caps = gst_caps_copy (raw_caps);
auto sink_caps = gst_caps_from_string (sink_caps_string.c_str ());
auto raw_caps = gst_caps_from_string (src_caps_string.c_str ());
auto src_caps = gst_caps_copy (raw_caps);
gst_caps_set_features_simple (src_caps,
gst_caps_features_new_single (GST_CAPS_FEATURE_MEMORY_D3D12_MEMORY));
#ifdef HAVE_GST_D3D11
auto d3d11_caps = gst_caps_copy (raw_caps);
gst_caps_set_features_simple (d3d11_caps,
gst_caps_features_new_single (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY));
gst_caps_append (src_caps, d3d11_caps);
#endif
gst_caps_append (src_caps, raw_caps);
gint max_res = MAX (max_resolution.width, max_resolution.height);

14
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12decoder.h
View file

@ -31,14 +31,21 @@ G_BEGIN_DECLS
G_DECLARE_FINAL_TYPE (GstD3D12Decoder,
gst_d3d12_decoder, GST, D3D12_DECODER, GstObject);
typedef struct _GstD3D12DecoderClassData GstD3D12DecoderClassData;
struct GstD3D12DecoderSubClassData
{
GstDxvaCodec codec;
gint64 adapter_luid;
guint device_id;
guint vendor_id;
gboolean d3d11_interop;
};
struct GstD3D12DecoderClassData
{
GstD3D12DecoderSubClassData subclass_data;
GstCaps *sink_caps;
GstCaps *src_caps;
gchar *description;
};
#define GST_D3D12_DECODER_DEFINE_TYPE(ModuleObjName,module_obj_name,MODULE,OBJ_NAME,ParentName) \
@ -100,8 +107,7 @@ struct GstD3D12DecoderSubClassData
static GstFlowReturn module_obj_name##_duplicate_picture (ParentName * decoder, \
GstCodecPicture * src, GstCodecPicture * dst);
GstD3D12Decoder * gst_d3d12_decoder_new (GstDxvaCodec codec,
gint64 adapter_luid);
GstD3D12Decoder * gst_d3d12_decoder_new (const GstD3D12DecoderSubClassData * cdata);
gboolean gst_d3d12_decoder_open (GstD3D12Decoder * decoder,
GstElement * element);

24
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12h264dec.cpp
View file

@ -95,17 +95,15 @@ gst_d3d12_h264_dec_class_init (GstD3D12H264DecClass * klass, gpointer data)
static void
gst_d3d12_h264_dec_init (GstD3D12H264Dec * self)
{
GstD3D12H264DecClass *klass = GST_D3D12_H264_DEC_GET_CLASS (self);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_H264_DEC_GET_CLASS (self);
self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_H264,
cdata->adapter_luid);
self->decoder = gst_d3d12_decoder_new (&klass->class_data);
}
static void
gst_d3d12_h264_dec_finalize (GObject * object)
{
GstD3D12H264Dec *self = GST_D3D12_H264_DEC (object);
auto self = GST_D3D12_H264_DEC (object);
gst_object_unref (self->decoder);
@ -116,8 +114,8 @@ static void
gst_d3d12_h264_dec_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstD3D12H264DecClass *klass = GST_D3D12_H264_DEC_GET_CLASS (object);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_H264_DEC_GET_CLASS (object);
auto cdata = &klass->class_data;
gst_d3d12_decoder_proxy_get_property (object, prop_id, value, pspec, cdata);
}
@ -125,7 +123,7 @@ gst_d3d12_h264_dec_get_property (GObject * object, guint prop_id,
static void
gst_d3d12_h264_dec_set_context (GstElement * element, GstContext * context)
{
GstD3D12H264Dec *self = GST_D3D12_H264_DEC (element);
auto self = GST_D3D12_H264_DEC (element);
gst_d3d12_decoder_set_context (self->decoder, element, context);
@ -322,7 +320,7 @@ gst_d3d12_h264_dec_output_picture (GstDxvaH264Decoder * decoder,
void
gst_d3d12_h264_dec_register (GstPlugin * plugin, GstD3D12Device * device,
ID3D12VideoDevice * video_device, guint rank)
ID3D12VideoDevice * video_device, guint rank, gboolean d3d11_interop)
{
GType type;
gchar *type_name;
@ -343,12 +341,14 @@ gst_d3d12_h264_dec_register (GstPlugin * plugin, GstD3D12Device * device,
GST_DEBUG_CATEGORY_INIT (gst_d3d12_h264_dec_debug, "d3d12h264dec", 0,
"d3d12h264dec");
type_info.class_data =
gst_d3d12_decoder_check_feature_support (device, video_device,
auto cdata = gst_d3d12_decoder_check_feature_support (device, video_device,
GST_DXVA_CODEC_H264);
if (!type_info.class_data)
if (!cdata)
return;
cdata->subclass_data.d3d11_interop = d3d11_interop;
type_info.class_data = cdata;
type_name = g_strdup ("GstD3D12H264Dec");
feature_name = g_strdup ("d3d12h264dec");

3
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12h264dec.h
View file

@ -26,7 +26,8 @@ G_BEGIN_DECLS
void gst_d3d12_h264_dec_register (GstPlugin * plugin,
GstD3D12Device * device,
ID3D12VideoDevice * video_device,
guint rank);
guint rank,
gboolean d3d11_interop);
G_END_DECLS

20
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12h265dec.cpp
View file

@ -93,11 +93,9 @@ gst_d3d12_h265_dec_class_init (GstD3D12H265DecClass * klass, gpointer data)
static void
gst_d3d12_h265_dec_init (GstD3D12H265Dec * self)
{
GstD3D12H265DecClass *klass = GST_D3D12_H265_DEC_GET_CLASS (self);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_H265_DEC_GET_CLASS (self);
self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_H265,
cdata->adapter_luid);
self->decoder = gst_d3d12_decoder_new (&klass->class_data);
}
static void
@ -114,8 +112,8 @@ static void
gst_d3d12_h265_dec_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstD3D12H265DecClass *klass = GST_D3D12_H265_DEC_GET_CLASS (object);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_H265_DEC_GET_CLASS (object);
auto cdata = &klass->class_data;
gst_d3d12_decoder_proxy_get_property (object, prop_id, value, pspec, cdata);
}
@ -311,7 +309,7 @@ gst_d3d12_h265_dec_output_picture (GstDxvaH265Decoder * decoder,
void
gst_d3d12_h265_dec_register (GstPlugin * plugin, GstD3D12Device * device,
ID3D12VideoDevice * video_device, guint rank)
ID3D12VideoDevice * video_device, guint rank, gboolean d3d11_interop)
{
GType type;
gchar *type_name;
@ -332,12 +330,14 @@ gst_d3d12_h265_dec_register (GstPlugin * plugin, GstD3D12Device * device,
GST_DEBUG_CATEGORY_INIT (gst_d3d12_h265_dec_debug, "d3d12h265dec", 0,
"d3d12h265dec");
type_info.class_data =
gst_d3d12_decoder_check_feature_support (device, video_device,
auto cdata = gst_d3d12_decoder_check_feature_support (device, video_device,
GST_DXVA_CODEC_H265);
if (!type_info.class_data)
if (!cdata)
return;
cdata->subclass_data.d3d11_interop = d3d11_interop;
type_info.class_data = cdata;
type_name = g_strdup ("GstD3D12H265Dec");
feature_name = g_strdup ("d3d12h265dec");

3
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12h265dec.h
View file

@ -26,7 +26,8 @@ G_BEGIN_DECLS
void gst_d3d12_h265_dec_register (GstPlugin * plugin,
GstD3D12Device * device,
ID3D12VideoDevice * video_device,
guint rank);
guint rank,
gboolean d3d11_interop);
G_END_DECLS

14
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12mpeg2dec.cpp
View file

@ -98,10 +98,8 @@ static void
gst_d3d12_mpeg2_dec_init (GstD3D12Mpeg2Dec * self)
{
auto klass = GST_D3D12_MPEG2_DEC_GET_CLASS (self);
auto cdata = &klass->class_data;
self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_MPEG2,
cdata->adapter_luid);
self->decoder = gst_d3d12_decoder_new (&klass->class_data);
gst_dxva_mpeg2_decoder_disable_postproc (GST_DXVA_MPEG2_DECODER (self));
}
@ -325,7 +323,7 @@ gst_d3d12_mpeg2_dec_output_picture (GstDxvaMpeg2Decoder * decoder,
void
gst_d3d12_mpeg2_dec_register (GstPlugin * plugin, GstD3D12Device * device,
ID3D12VideoDevice * video_device, guint rank)
ID3D12VideoDevice * video_device, guint rank, gboolean d3d11_interop)
{
GType type;
gchar *type_name;
@ -346,12 +344,14 @@ gst_d3d12_mpeg2_dec_register (GstPlugin * plugin, GstD3D12Device * device,
GST_DEBUG_CATEGORY_INIT (gst_d3d12_mpeg2_dec_debug, "d3d12mpeg2dec", 0,
"d3d12mpeg2dec");
type_info.class_data =
gst_d3d12_decoder_check_feature_support (device, video_device,
auto cdata = gst_d3d12_decoder_check_feature_support (device, video_device,
GST_DXVA_CODEC_MPEG2);
if (!type_info.class_data)
if (!cdata)
return;
cdata->subclass_data.d3d11_interop = d3d11_interop;
type_info.class_data = cdata;
type_name = g_strdup ("GstD3D12Mpeg2Dec");
feature_name = g_strdup ("d3d12mpeg2dec");

3
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12mpeg2dec.h
View file

@ -26,7 +26,8 @@ G_BEGIN_DECLS
void gst_d3d12_mpeg2_dec_register (GstPlugin * plugin,
GstD3D12Device * device,
ID3D12VideoDevice * video_device,
guint rank);
guint rank,
gboolean d3d11_interop);
G_END_DECLS

14
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12vp8dec.cpp
View file

@ -94,10 +94,8 @@ static void
gst_d3d12_vp8_dec_init (GstD3D12Vp8Dec * self)
{
auto klass = GST_D3D12_VP8_DEC_GET_CLASS (self);
auto cdata = &klass->class_data;
self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_VP8,
cdata->adapter_luid);
self->decoder = gst_d3d12_decoder_new (&klass->class_data);
}
static void
@ -311,7 +309,7 @@ gst_d3d12_vp8_dec_output_picture (GstDxvaVp8Decoder * decoder,
void
gst_d3d12_vp8_dec_register (GstPlugin * plugin, GstD3D12Device * device,
ID3D12VideoDevice * video_device, guint rank)
ID3D12VideoDevice * video_device, guint rank, gboolean d3d11_interop)
{
GType type;
gchar *type_name;
@ -332,12 +330,14 @@ gst_d3d12_vp8_dec_register (GstPlugin * plugin, GstD3D12Device * device,
GST_DEBUG_CATEGORY_INIT (gst_d3d12_vp8_dec_debug, "d3d12vp8dec", 0,
"d3d12vp8dec");
type_info.class_data =
gst_d3d12_decoder_check_feature_support (device, video_device,
auto cdata = gst_d3d12_decoder_check_feature_support (device, video_device,
GST_DXVA_CODEC_VP8);
if (!type_info.class_data)
if (!cdata)
return;
cdata->subclass_data.d3d11_interop = d3d11_interop;
type_info.class_data = cdata;
type_name = g_strdup ("GstD3D12Vp8Dec");
feature_name = g_strdup ("d3d12vp8dec");

3
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12vp8dec.h
View file

@ -26,7 +26,8 @@ G_BEGIN_DECLS
void gst_d3d12_vp8_dec_register (GstPlugin * plugin,
GstD3D12Device * device,
ID3D12VideoDevice * video_device,
guint rank);
guint rank,
gboolean d3d11_interop);
G_END_DECLS

20
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12vp9dec.cpp
View file

@ -95,11 +95,9 @@ gst_d3d12_vp9_dec_class_init (GstD3D12Vp9DecClass * klass, gpointer data)
static void
gst_d3d12_vp9_dec_init (GstD3D12Vp9Dec * self)
{
GstD3D12Vp9DecClass *klass = GST_D3D12_VP9_DEC_GET_CLASS (self);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_VP9_DEC_GET_CLASS (self);
self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_VP9,
cdata->adapter_luid);
self->decoder = gst_d3d12_decoder_new (&klass->class_data);
}
static void
@ -116,8 +114,8 @@ static void
gst_d3d12_vp9_dec_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstD3D12Vp9DecClass *klass = GST_D3D12_VP9_DEC_GET_CLASS (object);
GstD3D12DecoderSubClassData *cdata = &klass->class_data;
auto klass = GST_D3D12_VP9_DEC_GET_CLASS (object);
auto cdata = &klass->class_data;
gst_d3d12_decoder_proxy_get_property (object, prop_id, value, pspec, cdata);
}
@ -324,7 +322,7 @@ gst_d3d12_vp9_dec_output_picture (GstDxvaVp9Decoder * decoder,
void
gst_d3d12_vp9_dec_register (GstPlugin * plugin, GstD3D12Device * device,
ID3D12VideoDevice * video_device, guint rank)
ID3D12VideoDevice * video_device, guint rank, gboolean d3d11_interop)
{
GType type;
gchar *type_name;
@ -345,12 +343,14 @@ gst_d3d12_vp9_dec_register (GstPlugin * plugin, GstD3D12Device * device,
GST_DEBUG_CATEGORY_INIT (gst_d3d12_vp9_dec_debug, "d3d12vp9dec", 0,
"d3d12vp9dec");
type_info.class_data =
gst_d3d12_decoder_check_feature_support (device, video_device,
auto cdata = gst_d3d12_decoder_check_feature_support (device, video_device,
GST_DXVA_CODEC_VP9);
if (!type_info.class_data)
if (!cdata)
return;
cdata->subclass_data.d3d11_interop = d3d11_interop;
type_info.class_data = cdata;
type_name = g_strdup ("GstD3D12Vp9Dec");
feature_name = g_strdup ("d3d12vp9dec");

3
subprojects/gst-plugins-bad/sys/d3d12/gstd3d12vp9dec.h
View file

@ -26,7 +26,8 @@ G_BEGIN_DECLS
void gst_d3d12_vp9_dec_register (GstPlugin * plugin,
GstD3D12Device * device,
ID3D12VideoDevice * video_device,
guint rank);
guint rank,
gboolean d3d11_interop);
G_END_DECLS

38
subprojects/gst-plugins-bad/sys/d3d12/plugin.cpp
View file

@ -55,6 +55,9 @@
#ifdef HAVE_GST_D3D11
#include "gstd3d12memorycopy.h"
#include <gst/d3d11/gstd3d11.h>
#include <gst/d3d11/gstd3d11device-private.h>
#include <d3d11_4.h>
#else
#include "gstd3d12download.h"
#include "gstd3d12upload.h"
@ -94,6 +97,7 @@ plugin_init (GstPlugin * plugin)
ID3D12Device *device_handle;
ComPtr < ID3D12VideoDevice > video_device;
HRESULT hr;
gboolean d3d11_interop = FALSE;
device = gst_d3d12_device_new (i);
if (!device)
@ -106,21 +110,43 @@ plugin_init (GstPlugin * plugin)
gst_object_unref (device);
continue;
}
#ifdef HAVE_GST_D3D11
gint64 luid;
g_object_get (device, "adapter-luid", &luid, nullptr);
auto device11 = gst_d3d11_device_new_for_adapter_luid (luid,
D3D11_CREATE_DEVICE_BGRA_SUPPORT);
if (device11 && gst_d3d11_device_d3d12_import_supported (device11)) {
auto device11_handle = gst_d3d11_device_get_device_handle (device11);
ComPtr < ID3D11Device5 > device11_5;
hr = device11_handle->QueryInterface (IID_PPV_ARGS (&device11_5));
if (SUCCEEDED (hr)) {
ComPtr < ID3D11DeviceContext > context11;
ComPtr < ID3D11DeviceContext4 > context11_4;
device11_5->GetImmediateContext (&context11);
hr = context11.As (&context11_4);
if (SUCCEEDED (hr))
d3d11_interop = TRUE;
}
}
gst_clear_object (&device11);
#endif
have_video_device = true;
gst_d3d12_mpeg2_dec_register (plugin, device, video_device.Get (),
decoder_rank);
decoder_rank, d3d11_interop);
gst_d3d12_h264_dec_register (plugin, device, video_device.Get (),
decoder_rank);
decoder_rank, d3d11_interop);
gst_d3d12_h265_dec_register (plugin, device, video_device.Get (),
decoder_rank);
decoder_rank, d3d11_interop);
gst_d3d12_vp8_dec_register (plugin, device, video_device.Get (),
decoder_rank);
decoder_rank, d3d11_interop);
gst_d3d12_vp9_dec_register (plugin, device, video_device.Get (),
decoder_rank);
decoder_rank, d3d11_interop);
gst_d3d12_av1_dec_register (plugin, device, video_device.Get (),
decoder_rank);
decoder_rank, d3d11_interop);
gst_d3d12_h264_enc_register (plugin, device, video_device.Get (),
GST_RANK_NONE);