mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-14 05:12:09 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/d3d12/gstd3d12graphicscapture.cpp
Seungha Yang 18091f0115 d3d12memory: Update for API interop 
Add support for destroy notify in case of wrapped memory, and
allow setting external fence for interop

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/6428>
2024-03-22 20:01:16 +09:00

1340 lines
38 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
#ifdef WINAPI_PARTITION_APP
#undef WINAPI_PARTITION_APP
#endif
#define WINAPI_PARTITION_APP 1
#include "gstd3d12graphicscapture.h"
#include "gstd3d12pluginutils.h"
#include <d3d11_4.h>
#include <dxgi.h>
#include <directx/d3dx12.h>
#include <gmodule.h>
#include <dwmapi.h>
#include <winstring.h>
#include <roapi.h>
#include <dispatcherqueue.h>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <wrl.h>
#include <string.h>
#include <windows.h>
#include <windows.system.h>
#include <windows.graphics.capture.h>
#include <windows.graphics.capture.interop.h>
#include <windows.graphics.directx.direct3d11.h>
#include <windows.graphics.directx.direct3d11.interop.h>
GST_DEBUG_CATEGORY_EXTERN (gst_d3d12_screen_capture_debug);
#define GST_CAT_DEFAULT gst_d3d12_screen_capture_debug
#define CAPTURE_POOL_SIZE 2
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
using namespace ABI::Windows::System;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::Graphics;
using namespace ABI::Windows::Graphics::Capture;
using namespace ABI::Windows::Graphics::DirectX;
using namespace ABI::Windows::Graphics::DirectX::Direct3D11;
using namespace Windows::Graphics::DirectX::Direct3D11;
typedef ABI::Windows::Foundation::__FITypedEventHandler_2_Windows__CGraphics__CCapture__CDirect3D11CaptureFramePool_IInspectable_t
IFrameArrivedHandler;
typedef ABI::Windows::Foundation::__FITypedEventHandler_2_Windows__CGraphics__CCapture__CGraphicsCaptureItem_IInspectable_t
IItemClosedHandler;
struct GraphicsCaptureVTable
{
gboolean loaded;
/* d3d11.dll */
HRESULT (WINAPI * CreateDirect3D11DeviceFromDXGIDevice) (IDXGIDevice *
dxgi_device, IInspectable ** graphics_device);
/* combase.dll */
HRESULT (WINAPI * RoInitialize) (RO_INIT_TYPE init_type);
HRESULT (WINAPI * RoUninitialize) (void);
HRESULT (WINAPI * WindowsCreateString) (PCNZWCH source_string,
UINT32 length, HSTRING * string);
HRESULT (WINAPI * WindowsDeleteString) (HSTRING string);
HRESULT (WINAPI * RoGetActivationFactory) (HSTRING activatable_class_id,
REFIID iid, void ** factory);
/* user32.dll */
DPI_AWARENESS_CONTEXT (WINAPI * SetThreadDpiAwarenessContext) (DPI_AWARENESS_CONTEXT context);
/* coremessaging.dll */
HRESULT (WINAPI * CreateDispatcherQueueController) (DispatcherQueueOptions options,
PDISPATCHERQUEUECONTROLLER * controller);
};
static GraphicsCaptureVTable g_vtable = { };
#define LOAD_SYMBOL(module,name,func) G_STMT_START { \
if (!g_module_symbol (module, G_STRINGIFY (name), (gpointer *) &g_vtable.func)) { \
GST_WARNING ("Failed to load '%s', %s", G_STRINGIFY (name), g_module_error()); \
if (d3d11_module) \
g_module_close (d3d11_module); \
if (combase_module) \
g_module_close (combase_module); \
if (user32_module) \
g_module_close (user32_module); \
return; \
} \
} G_STMT_END
gboolean
gst_d3d12_graphics_capture_load_library (void)
{
static GModule *d3d11_module = nullptr;
static GModule *combase_module = nullptr;
static GModule *user32_module = nullptr;
static GModule *coremessaging_module = nullptr;
GST_D3D12_CALL_ONCE_BEGIN {
g_vtable.loaded = FALSE;
d3d11_module = g_module_open ("d3d11.dll", G_MODULE_BIND_LAZY);
if (!d3d11_module)
return;
combase_module = g_module_open ("combase.dll", G_MODULE_BIND_LAZY);
if (!combase_module) {
g_module_close (d3d11_module);
return;
}
user32_module = g_module_open ("user32.dll", G_MODULE_BIND_LAZY);
if (!user32_module) {
g_module_close (combase_module);
g_module_close (d3d11_module);
return;
}
coremessaging_module =
g_module_open ("coremessaging.dll", G_MODULE_BIND_LAZY);
if (!coremessaging_module) {
g_module_close (user32_module);
g_module_close (combase_module);
g_module_close (d3d11_module);
return;
}
LOAD_SYMBOL (d3d11_module, CreateDirect3D11DeviceFromDXGIDevice,
CreateDirect3D11DeviceFromDXGIDevice);
LOAD_SYMBOL (combase_module, RoInitialize, RoInitialize);
LOAD_SYMBOL (combase_module, RoUninitialize, RoUninitialize);
LOAD_SYMBOL (combase_module, WindowsCreateString, WindowsCreateString);
LOAD_SYMBOL (combase_module, WindowsDeleteString, WindowsDeleteString);
LOAD_SYMBOL (combase_module, RoGetActivationFactory,
RoGetActivationFactory);
LOAD_SYMBOL (user32_module, SetThreadDpiAwarenessContext,
SetThreadDpiAwarenessContext);
LOAD_SYMBOL (coremessaging_module, CreateDispatcherQueueController,
CreateDispatcherQueueController);
g_vtable.loaded = TRUE;
} GST_D3D12_CALL_ONCE_END;
return g_vtable.loaded;
}
template < typename InterfaceType, PCNZWCH runtime_class_id >
static HRESULT
GstGetActivationFactory (InterfaceType ** factory)
{
if (!gst_d3d12_graphics_capture_load_library ())
return E_NOINTERFACE;
HSTRING class_id_hstring;
HRESULT hr = g_vtable.WindowsCreateString (runtime_class_id,
wcslen (runtime_class_id), &class_id_hstring);
if (FAILED (hr))
return hr;
hr = g_vtable.RoGetActivationFactory (class_id_hstring,
IID_PPV_ARGS (factory));
if (FAILED (hr)) {
g_vtable.WindowsDeleteString (class_id_hstring);
return hr;
}
return g_vtable.WindowsDeleteString (class_id_hstring);
}
static gint64
get_d3d11_texture_token (void)
{
static gint64 token = 0;
GST_D3D12_CALL_ONCE_BEGIN {
token = gst_d3d12_create_user_token ();
} GST_D3D12_CALL_ONCE_END;
return token;
}
struct SharedTextureData
{
ComPtr<ID3D11Device> device;
ComPtr<ID3D11Texture2D> shared_texture;
};
static void
shared_texture_data_free (SharedTextureData * data)
{
data->shared_texture = nullptr;
data->device = nullptr;
delete data;
}
class GraphicsCapture : public RuntimeClass<RuntimeClassFlags<ClassicCom>,
FtmBase, IFrameArrivedHandler, IItemClosedHandler>
{
public:
GraphicsCapture ()
{
gst_video_info_init (&pool_info_);
fence_event_handle_ = CreateEventEx (nullptr, nullptr, 0, EVENT_ALL_ACCESS);
}
virtual ~GraphicsCapture ()
{
GST_INFO_OBJECT (obj_, "Fin");
if (d3d12_pool_) {
gst_buffer_pool_set_active (d3d12_pool_, FALSE);
gst_object_unref (d3d12_pool_);
}
if (video_pool_) {
gst_buffer_pool_set_active (video_pool_, FALSE);
gst_object_unref (video_pool_);
}
gst_clear_object (&device12_);
CloseHandle (fence_event_handle_);
}
STDMETHODIMP
RuntimeClassInitialize (GstD3D12GraphicsCapture * obj,
GstD3D12Device * device12, ID3D11Device * device11,
IDirect3DDevice * d3d_device,
IDirect3D11CaptureFramePoolStatics * pool_statics,
IGraphicsCaptureItem * item, HWND window_handle)
{
obj_ = obj;
device12_ = (GstD3D12Device *) gst_object_ref (device12);
device11->QueryInterface (IID_PPV_ARGS (&device11_));
if (!device11_) {
GST_ERROR_OBJECT (obj_, "ID3D11Device5 interface unavailable");
return E_FAIL;
}
ComPtr<ID3D11DeviceContext> context;
device11_->GetImmediateContext (&context);
context.As (&context_);
if (!context_) {
GST_ERROR_OBJECT (obj_, "ID3D11DeviceContext4 interface unavailable");
return E_FAIL;
}
auto hr = device11_->CreateFence (0, D3D11_FENCE_FLAG_SHARED,
IID_PPV_ARGS (&shared_fence11_));
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj_, "Couldn't create d3d11 fence");
return E_FAIL;
}
HANDLE fence_handle;
hr = shared_fence11_->CreateSharedHandle (nullptr,
GENERIC_ALL, nullptr, &fence_handle);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj_, "Couldn't create shared handle");
return E_FAIL;
}
auto device12_handle = gst_d3d12_device_get_device_handle (device12);
hr = device12_handle->OpenSharedHandle (fence_handle,
IID_PPV_ARGS (&shared_fence12_));
CloseHandle (fence_handle);
if (!gst_d3d12_result (hr, device12)) {
GST_ERROR_OBJECT (obj_, "Couldn't open d3d12 fence");
return E_FAIL;
}
device_ = d3d_device;
item_ = item;
hwnd_ = window_handle;
hr = item->get_Size (&frame_size_);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj, "Couldn't query item size");
return hr;
}
hr = item->add_Closed (this, &closed_token_);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj, "Couldn't install closed callback");
return hr;
}
hr = pool_statics->Create (d3d_device,
DirectXPixelFormat::DirectXPixelFormat_B8G8R8A8UIntNormalized,
CAPTURE_POOL_SIZE, frame_size_, &frame_pool_);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj, "Couldn't create frame pool");
return hr;
}
hr = frame_pool_->add_FrameArrived (this, &arrived_token_);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj, "Couldn't install FrameArrived callback");
return hr;
}
hr = frame_pool_->CreateCaptureSession (item, &session_);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj, "Couldn't create session");
return hr;
}
session_.As (&session2_);
if (session2_)
session2_->put_IsCursorCaptureEnabled (FALSE);
session_.As (&session3_);
if (session3_)
session3_->put_IsBorderRequired (FALSE);
hr = session_->StartCapture ();
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj, "Couldn't start capture");
return hr;
}
return S_OK;
}
IFACEMETHOD(Invoke) (IDirect3D11CaptureFramePool * pool, IInspectable * arg)
{
ComPtr < IDirect3D11CaptureFrame > frame;
GST_LOG_OBJECT (obj_, "Frame arrived");
pool->TryGetNextFrame (&frame);
if (!frame) {
GST_WARNING_OBJECT (obj_, "No frame");
return S_OK;
}
SizeInt32 frame_size;
auto hr = frame->get_ContentSize (&frame_size);
if (FAILED (hr)) {
GST_WARNING_OBJECT (obj_, "Couldn't get content size");
return S_OK;
}
if (frame_size.Width != frame_size_.Width ||
frame_size.Height != frame_size_.Height) {
GST_DEBUG_OBJECT (obj_, "Frame size changed %dx%d -> %dx%d",
frame_size_.Width, frame_size_.Height,
frame_size.Width, frame_size.Height);
std::lock_guard <std::mutex> lk (lock_);
if (d3d12_pool_) {
gst_buffer_pool_set_active (d3d12_pool_, FALSE);
gst_clear_object (&d3d12_pool_);
}
if (video_pool_) {
gst_buffer_pool_set_active (video_pool_, FALSE);
gst_clear_object (&video_pool_);
}
frame_ = nullptr;
texture_ = nullptr;
staging_ = nullptr;
pool->Recreate (device_.Get (),
DirectXPixelFormat::DirectXPixelFormat_B8G8R8A8UIntNormalized,
CAPTURE_POOL_SIZE, frame_size);
frame_size_ = frame_size;
return S_OK;
}
ComPtr < IDirect3DSurface > surface;
frame->get_Surface (&surface);
if (!surface) {
GST_WARNING_OBJECT (obj_, "IDirect3DSurface interface unavailable");
return S_OK;
}
ComPtr < IDirect3DDxgiInterfaceAccess > access;
surface.As (&access);
if (!access) {
GST_WARNING_OBJECT (obj_,
"IDirect3DDxgiInterfaceAccess interface unavailable");
return S_OK;
}
ComPtr < ID3D11Texture2D > texture;
access->GetInterface (IID_PPV_ARGS (&texture));
if (!texture) {
GST_WARNING_OBJECT (obj_,
"ID3D11Texture2D interface unavailable");
return S_OK;
}
D3D11_TEXTURE2D_DESC desc;
texture->GetDesc (&desc);
std::lock_guard <std::mutex> lk (lock_);
crop_box_.left = 0;
crop_box_.top = 0;
crop_box_.right = desc.Width;
crop_box_.bottom = desc.Height;
crop_box_.front = 0;
crop_box_.back = 1;
texture_ = texture;
frame_ = frame;
if (hwnd_ && client_only_)
updateClientBox (desc, crop_box_);
cond_.notify_all ();
return S_OK;
}
IFACEMETHOD(Invoke) (IGraphicsCaptureItem * pool, IInspectable * arg)
{
GST_INFO_OBJECT (obj_, "Item closed");
std::lock_guard <std::mutex> lk (lock_);
closed_ = true;
cond_.notify_all ();
return S_OK;
}
void SetCursorEnabled (boolean value)
{
if (session2_)
session2_->put_IsCursorCaptureEnabled (value);
}
void SetBorderRequired (boolean value)
{
if (session3_)
session3_->put_IsBorderRequired (value);
}
void SetClientOnly (bool value)
{
client_only_ = value;
}
void GetSize (guint * width, guint * height)
{
std::lock_guard <std::mutex> lk (lock_);
*width = MAX (1, (guint) frame_size_.Width);
*height = MAX (1, (guint) frame_size_.Height);
}
GstFlowReturn GetD3D12Frame (const CaptureCropRect * crop_rect,
GstBuffer ** buffer, guint * width, guint * height)
{
std::unique_lock <std::mutex> lk (lock_);
while (!frame_ && !flushing_ && !closed_)
cond_.wait (lk);
if (flushing_)
return GST_FLOW_FLUSHING;
if (closed_)
return GST_FLOW_EOS;
guint crop_w = crop_box_.right - crop_box_.left;
guint crop_h = crop_box_.bottom - crop_box_.top;
D3D12_BOX crop_box = crop_box_;
if (crop_rect->crop_x + crop_rect->crop_w > crop_w ||
crop_rect->crop_y + crop_rect->crop_h > crop_h) {
/* Ignore this crop rect */
} else {
if (crop_rect->crop_w)
crop_w = crop_rect->crop_w;
if (crop_rect->crop_h)
crop_h = crop_rect->crop_h;
crop_box.left += crop_rect->crop_x;
crop_box.top += crop_rect->crop_y;
crop_box.right = crop_box.left + crop_w;
crop_box.bottom = crop_box.top + crop_h;
}
if (!d3d12_pool_ || pool_info_.width != crop_w ||
pool_info_.height != crop_h) {
GST_DEBUG_OBJECT (obj_, "Size changed, recrate buffer pool");
if (d3d12_pool_) {
gst_buffer_pool_set_active (d3d12_pool_, FALSE);
gst_clear_object (&d3d12_pool_);
}
gst_video_info_set_format (&pool_info_, GST_VIDEO_FORMAT_BGRA,
crop_w, crop_h);
d3d12_pool_ = gst_d3d12_buffer_pool_new (device12_);
if (!d3d12_pool_) {
GST_ERROR_OBJECT (obj_, "Couldn't create buffer pool");
return GST_FLOW_ERROR;
}
auto caps = gst_video_info_to_caps (&pool_info_);
auto config = gst_buffer_pool_get_config (d3d12_pool_);
gst_buffer_pool_config_set_params (config, caps, pool_info_.size, 0, 0);
gst_caps_unref (caps);
auto params = gst_d3d12_allocation_params_new (device12_, &pool_info_,
GST_D3D12_ALLOCATION_FLAG_DEFAULT,
D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS |
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, D3D12_HEAP_FLAG_SHARED);
gst_buffer_pool_config_set_d3d12_allocation_params (config, params);
gst_d3d12_allocation_params_free (params);
if (!gst_buffer_pool_set_config (d3d12_pool_, config)) {
GST_ERROR_OBJECT (obj_, "Couldn't set buffer pool config");
gst_clear_object (&d3d12_pool_);
return GST_FLOW_ERROR;
}
if (!gst_buffer_pool_set_active (d3d12_pool_, TRUE)) {
GST_ERROR_OBJECT (obj_, "Couldn't activate pool");
gst_clear_object (&d3d12_pool_);
return GST_FLOW_ERROR;
}
}
GstBuffer *outbuf = nullptr;
gst_buffer_pool_acquire_buffer (d3d12_pool_, &outbuf, nullptr);
if (!outbuf) {
GST_ERROR_OBJECT (obj_, "Couldn't acquire buffer");
return GST_FLOW_ERROR;
}
GstMapInfo map_info;
auto mem = gst_buffer_peek_memory (outbuf, 0);
auto dmem = GST_D3D12_MEMORY_CAST (mem);
GST_MEMORY_FLAG_UNSET (dmem, GST_D3D12_MEMORY_TRANSFER_NEED_UPLOAD);
gst_d3d12_memory_sync (dmem);
SharedTextureData *shared_data = (SharedTextureData *)
gst_d3d12_memory_get_token_data (dmem,
get_d3d11_texture_token ());
if (!shared_data) {
HANDLE shared_handle = nullptr;
if (!gst_d3d12_memory_get_nt_handle (dmem, &shared_handle)) {
GST_ERROR_OBJECT (obj_, "Couldn't get shared handle");
gst_buffer_unref (outbuf);
return GST_FLOW_ERROR;
}
ComPtr<ID3D11Texture2D> shared_texture;
auto hr = device11_->OpenSharedResource1 (shared_handle,
IID_PPV_ARGS (&shared_texture));
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj_, "Couldn't open shared d3d11 texture");
gst_buffer_unref (outbuf);
return GST_FLOW_ERROR;
}
shared_data = new SharedTextureData ();
shared_data->shared_texture = shared_texture;
shared_data->device = device11_;
gst_d3d12_memory_set_token_data (dmem, get_d3d11_texture_token (),
shared_data, (GDestroyNotify) shared_texture_data_free);
}
if (!gst_memory_map (mem,
&map_info, (GstMapFlags) (GST_MAP_WRITE | GST_MAP_D3D12))) {
GST_ERROR_OBJECT (obj_, "Couldn't map memory");
gst_buffer_unref (outbuf);
return GST_FLOW_ERROR;
}
context_->CopySubresourceRegion (shared_data->shared_texture.Get (),
0, 0, 0, 0, texture_.Get (), 0, (const D3D11_BOX *) &crop_box);
fence_val_++;
context_->Signal (shared_fence11_.Get (), fence_val_);
gst_memory_unmap (mem, &map_info);
auto completed = shared_fence12_->GetCompletedValue ();
if (completed < fence_val_) {
auto hr = shared_fence12_->SetEventOnCompletion (fence_val_,
fence_event_handle_);
if (!gst_d3d12_result (hr, device12_)) {
GST_ERROR_OBJECT (obj_, "SetEventOnCompletion failed");
gst_buffer_unref (outbuf);
return GST_FLOW_ERROR;
}
WaitForSingleObject (fence_event_handle_, INFINITE);
}
*width = crop_w;
*height = crop_h;
*buffer = outbuf;
return GST_FLOW_OK;
}
GstFlowReturn GetVideoFrame (const CaptureCropRect * crop_rect,
GstBuffer ** buffer, guint * width, guint * height)
{
std::unique_lock <std::mutex> lk (lock_);
while (!frame_ && !flushing_ && !closed_)
cond_.wait (lk);
if (flushing_)
return GST_FLOW_FLUSHING;
if (closed_)
return GST_FLOW_EOS;
guint crop_w = crop_box_.right - crop_box_.left;
guint crop_h = crop_box_.bottom - crop_box_.top;
D3D12_BOX crop_box = crop_box_;
if (crop_rect->crop_x + crop_rect->crop_w > crop_w ||
crop_rect->crop_y + crop_rect->crop_h > crop_h) {
/* Ignore this crop rect */
} else {
if (crop_rect->crop_w)
crop_w = crop_rect->crop_w;
if (crop_rect->crop_h)
crop_h = crop_rect->crop_h;
crop_box.left += crop_rect->crop_x;
crop_box.top += crop_rect->crop_y;
crop_box.right = crop_box.left + crop_w;
crop_box.bottom = crop_box.top + crop_h;
}
if (!video_pool_ || pool_info_.width != crop_w ||
pool_info_.height != crop_h) {
GST_DEBUG_OBJECT (obj_, "Size changed, recrate buffer pool");
if (video_pool_) {
gst_buffer_pool_set_active (video_pool_, FALSE);
gst_clear_object (&video_pool_);
}
staging_ = nullptr;
D3D11_TEXTURE2D_DESC desc = { };
desc.Width = crop_w;
desc.Height = crop_h;
desc.MipLevels = 1;
desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.ArraySize = 1;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
auto hr = device11_->CreateTexture2D (&desc, nullptr, &staging_);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj_, "Couldn't create staging texture");
return GST_FLOW_ERROR;
}
gst_video_info_set_format (&pool_info_, GST_VIDEO_FORMAT_BGRA,
crop_w, crop_h);
video_pool_ = gst_video_buffer_pool_new ();
if (!video_pool_) {
GST_ERROR_OBJECT (obj_, "Couldn't create buffer pool");
return GST_FLOW_ERROR;
}
auto caps = gst_video_info_to_caps (&pool_info_);
auto config = gst_buffer_pool_get_config (video_pool_);
gst_buffer_pool_config_set_params (config, caps, pool_info_.size, 0, 0);
gst_caps_unref (caps);
if (!gst_buffer_pool_set_config (video_pool_, config)) {
GST_ERROR_OBJECT (obj_, "Couldn't set buffer pool config");
gst_clear_object (&video_pool_);
return GST_FLOW_ERROR;
}
if (!gst_buffer_pool_set_active (video_pool_, TRUE)) {
GST_ERROR_OBJECT (obj_, "Couldn't activate pool");
gst_clear_object (&video_pool_);
return GST_FLOW_ERROR;
}
}
context_->CopySubresourceRegion (staging_.Get (), 0, 0, 0, 0,
texture_.Get (), 0, (const D3D11_BOX *) &crop_box);
D3D11_MAPPED_SUBRESOURCE mapped_resource;
auto hr = context_->Map (staging_.Get (), 0, D3D11_MAP_READ,
0, &mapped_resource);
if (FAILED (hr)) {
GST_ERROR_OBJECT (obj_, "Couldn't map staging texture");
return GST_FLOW_ERROR;
}
GstBuffer *outbuf = nullptr;
gst_buffer_pool_acquire_buffer (video_pool_, &outbuf, nullptr);
if (!outbuf) {
GST_ERROR_OBJECT (obj_, "Couldn't acquire buffer");
context_->Unmap (staging_.Get (), 0);
return GST_FLOW_ERROR;
}
GstVideoFrame vframe;
if (!gst_video_frame_map (&vframe, &pool_info_, outbuf, GST_MAP_WRITE)) {
GST_ERROR_OBJECT (obj_, "Couldn't map video frame");
context_->Unmap (staging_.Get (), 0);
gst_buffer_unref (outbuf);
return GST_FLOW_ERROR;
}
guint8 *dst = (guint8 *) GST_VIDEO_FRAME_PLANE_DATA (&vframe, 0);
guint8 *src = (guint8 *) mapped_resource.pData;
guint width_in_bytes = GST_VIDEO_FRAME_COMP_PSTRIDE (&vframe, 0)
* GST_VIDEO_FRAME_COMP_WIDTH (&vframe, 0);
for (guint i = 0; i < GST_VIDEO_FRAME_HEIGHT (&vframe); i++) {
memcpy (dst, src, width_in_bytes);
dst += GST_VIDEO_FRAME_PLANE_STRIDE (&vframe, 0);
src += mapped_resource.RowPitch;
}
gst_video_frame_unmap (&vframe);
context_->Unmap (staging_.Get (), 0);
*width = crop_w;
*height = crop_h;
*buffer = outbuf;
return GST_FLOW_OK;
}
void SetFlushing (bool flushing)
{
std::lock_guard <std::mutex> lk (lock_);
flushing_ = flushing;
cond_.notify_all ();
}
void Close ()
{
if (item_)
item_->remove_Closed (closed_token_);
if (frame_pool_)
frame_pool_->remove_FrameArrived (arrived_token_);
texture_ = nullptr;
frame_ = nullptr;
staging_ = nullptr;
if (session_) {
ComPtr<IClosable> closable;
session_.As (&closable);
if (closable)
closable->Close ();
}
if (frame_pool_) {
ComPtr<IClosable> closable;
frame_pool_.As (&closable);
if (closable)
closable->Close ();
}
if (item_) {
ComPtr<IClosable> closable;
item_.As (&closable);
if (closable)
closable->Close ();
}
}
private:
bool updateClientBox (const D3D11_TEXTURE2D_DESC & desc, D3D12_BOX & box)
{
if (IsIconic (hwnd_))
return false;
RECT client_rect;
if (!GetClientRect (hwnd_, &client_rect))
return false;
if (client_rect.right <= 0 || client_rect.bottom <= 0)
return false;
RECT bound_rect;
auto hr = DwmGetWindowAttribute (hwnd_,
DWMWA_EXTENDED_FRAME_BOUNDS, &bound_rect, sizeof (RECT));
if (FAILED (hr))
return false;
POINT client_pos = { };
if (!ClientToScreen (hwnd_, &client_pos))
return false;
UINT left = 0;
if (client_pos.x > bound_rect.left)
left = client_pos.x - bound_rect.left;
UINT width = 1;
if (desc.Width > left) {
width = desc.Width - left;
if (width > client_rect.right)
width = client_rect.right;
}
UINT right = left + width;
if (right > desc.Width)
return false;
UINT top = 0;
if (client_pos.y > bound_rect.top)
top = client_pos.y - bound_rect.top;
UINT height = 1;
if (desc.Height > top) {
height = desc.Height - top;
if (height > client_rect.bottom)
height = client_rect.bottom;
}
UINT bottom = top + height;
if (bottom > desc.Height)
return false;
box.left = left;
box.top = top;
box.right = right;
box.bottom = bottom;
box.front = 0;
box.back = 1;
return true;
}
private:
GstD3D12GraphicsCapture *obj_ = nullptr;
HWND hwnd_ = nullptr;
GstD3D12Device *device12_ = nullptr;
GstVideoInfo pool_info_;
GstBufferPool *d3d12_pool_ = nullptr;
GstBufferPool *video_pool_ = nullptr;
ComPtr<ID3D11Device5> device11_;
ComPtr<ID3D11DeviceContext4> context_;
ComPtr<IDirect3DDevice> device_;
ComPtr<IGraphicsCaptureItem> item_;
ComPtr<IDirect3D11CaptureFramePool> frame_pool_;
ComPtr<IGraphicsCaptureSession> session_;
ComPtr<IGraphicsCaptureSession2> session2_;
ComPtr<IGraphicsCaptureSession3> session3_;
ComPtr<IDirect3D11CaptureFrame> frame_;
ComPtr<ID3D11Texture2D> texture_;
ComPtr<ID3D11Texture2D> staging_;
SizeInt32 frame_size_ = { };
EventRegistrationToken arrived_token_ = { };
EventRegistrationToken closed_token_ = { };
std::mutex lock_;
std::condition_variable cond_;
bool closed_ = false;
bool flushing_ = false;
std::atomic<bool> client_only_ = { false };
D3D12_BOX crop_box_ = { };
UINT64 fence_val_ = 0;
ComPtr<ID3D11Fence> shared_fence11_;
ComPtr<ID3D12Fence> shared_fence12_;
HANDLE fence_event_handle_;
};
class AsyncWaiter : public RuntimeClass<RuntimeClassFlags<ClassicCom>,
FtmBase, IAsyncActionCompletedHandler>
{
public:
STDMETHODIMP
RuntimeClassInitialize (HANDLE event_handle)
{
event_handle_ = event_handle;
return S_OK;
}
STDMETHOD (Invoke) (IAsyncAction * action, AsyncStatus status)
{
SetEvent (event_handle_);
return S_OK;
}
private:
HANDLE event_handle_;
};
enum LoopState
{
LOOP_STATE_INIT,
LOOP_STATE_RUNNING,
LOOP_STATE_STOPPED,
};
struct GstD3D12GraphicsCapturePrivate
{
GstD3D12GraphicsCapturePrivate ()
{
shutdown_handle = CreateEventEx (nullptr, nullptr, 0, EVENT_ALL_ACCESS);
}
~GstD3D12GraphicsCapturePrivate ()
{
SetEvent (shutdown_handle);
g_clear_pointer (&loop_thread, g_thread_join);
CloseHandle (shutdown_handle);
gst_clear_object (&device);
}
GstD3D12Device *device = nullptr;
ComPtr<ID3D11Device> d3d11_device;
ComPtr<GraphicsCapture> capture;
HMONITOR monitor_handle = nullptr;
HWND window_handle = nullptr;
HWND hidden_hwnd = nullptr;
HANDLE shutdown_handle;
GThread *loop_thread = nullptr;
LoopState loop_state = LOOP_STATE_INIT;
std::mutex loop_lock;
std::condition_variable loop_cond;
};
/* *INDENT-ON* */
struct _GstD3D12GraphicsCapture
{
GstObject parent;
GstD3D12GraphicsCapturePrivate *priv;
};
static void gst_d3d12_graphics_capture_finalize (GObject * object);
static GstFlowReturn
gst_d3d12_graphics_capture_prepare (GstD3D12ScreenCapture * capture);
static gboolean
gst_d3d12_graphics_capture_get_size (GstD3D12ScreenCapture * capture,
guint * width, guint * height);
static gboolean
gst_d3d12_graphics_capture_unlock (GstD3D12ScreenCapture * capture);
static gboolean
gst_d3d12_graphics_capture_unlock_stop (GstD3D12ScreenCapture * capture);
#define gst_d3d12_graphics_capture_parent_class parent_class
G_DEFINE_TYPE (GstD3D12GraphicsCapture,
gst_d3d12_graphics_capture, GST_TYPE_D3D12_SCREEN_CAPTURE);
static void
gst_d3d12_graphics_capture_class_init (GstD3D12GraphicsCaptureClass * klass)
{
auto object_class = G_OBJECT_CLASS (klass);
auto capture_class = GST_D3D12_SCREEN_CAPTURE_CLASS (klass);
object_class->finalize = gst_d3d12_graphics_capture_finalize;
capture_class->prepare =
GST_DEBUG_FUNCPTR (gst_d3d12_graphics_capture_prepare);
capture_class->get_size =
GST_DEBUG_FUNCPTR (gst_d3d12_graphics_capture_get_size);
capture_class->unlock = GST_DEBUG_FUNCPTR (gst_d3d12_graphics_capture_unlock);
capture_class->unlock_stop =
GST_DEBUG_FUNCPTR (gst_d3d12_graphics_capture_unlock_stop);
}
static void
gst_d3d12_graphics_capture_init (GstD3D12GraphicsCapture * self)
{
self->priv = new GstD3D12GraphicsCapturePrivate ();
}
static void
gst_d3d12_graphics_capture_finalize (GObject * object)
{
auto self = GST_D3D12_GRAPHICS_CAPTURE (object);
delete self->priv;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gboolean
open_device (GstD3D12GraphicsCapture * self, IDirect3DDevice ** d3d_device)
{
auto priv = self->priv;
static const D3D_FEATURE_LEVEL feature_levels[] = {
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
auto adapter = gst_d3d12_device_get_adapter_handle (priv->device);
auto hr = D3D11CreateDevice (adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
D3D11_CREATE_DEVICE_BGRA_SUPPORT, feature_levels,
G_N_ELEMENTS (feature_levels), D3D11_SDK_VERSION,
&priv->d3d11_device, nullptr, nullptr);
if (FAILED (hr)) {
hr = D3D11CreateDevice (adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
D3D11_CREATE_DEVICE_BGRA_SUPPORT, &feature_levels[1],
G_N_ELEMENTS (feature_levels) - 1, D3D11_SDK_VERSION,
&priv->d3d11_device, nullptr, nullptr);
}
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't create d3d11 device");
return FALSE;
}
ComPtr < ID3D10Multithread > multi_thread;
priv->d3d11_device.As (&multi_thread);
if (multi_thread)
multi_thread->SetMultithreadProtected (TRUE);
ComPtr < IDXGIDevice > dxgi_device;
hr = priv->d3d11_device.As (&dxgi_device);
if (FAILED (hr)) {
GST_WARNING_OBJECT (self, "IDXGIDevice interface unavailable");
return FALSE;
}
ComPtr < IInspectable > inspectable;
hr = g_vtable.CreateDirect3D11DeviceFromDXGIDevice (dxgi_device.Get (),
&inspectable);
if (FAILED (hr)) {
GST_WARNING_OBJECT (self, "CreateDirect3D11DeviceFromDXGIDevice failed");
return FALSE;
}
ComPtr < IDirect3DDevice > device;
hr = inspectable.As (&device);
if (FAILED (hr)) {
GST_WARNING_OBJECT (self, "IDirect3DDevice interface unavailable");
return FALSE;
}
*d3d_device = device.Detach ();
return TRUE;
}
static gboolean
create_session (GstD3D12GraphicsCapture * self, IDirect3DDevice * d3d_device)
{
auto priv = self->priv;
auto capture = priv->capture;
ComPtr < IGraphicsCaptureItemInterop > interop;
auto hr = GstGetActivationFactory < IGraphicsCaptureItemInterop,
RuntimeClass_Windows_Graphics_Capture_GraphicsCaptureItem > (&interop);
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "IGraphicsCaptureItemInterop is not available");
return FALSE;
}
ComPtr < IGraphicsCaptureItem > item;
if (priv->monitor_handle) {
hr = interop->CreateForMonitor (priv->monitor_handle, IID_PPV_ARGS (&item));
} else {
hr = interop->CreateForWindow (priv->window_handle, IID_PPV_ARGS (&item));
}
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't create item");
return FALSE;
}
ComPtr < IDirect3D11CaptureFramePoolStatics > pool_statics;
hr = GstGetActivationFactory < IDirect3D11CaptureFramePoolStatics,
RuntimeClass_Windows_Graphics_Capture_Direct3D11CaptureFramePool >
(&pool_statics);
if (FAILED (hr)) {
GST_WARNING_OBJECT (self,
"IDirect3D11CaptureFramePoolStatics is unavailable");
return FALSE;
}
hr = MakeAndInitialize < GraphicsCapture > (&priv->capture,
self, priv->device, priv->d3d11_device.Get (), d3d_device,
pool_statics.Get (), item.Get (), priv->window_handle);
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't initialize capture object");
return FALSE;
}
return TRUE;
}
static gpointer
gst_d3d11_graphics_thread_func (GstD3D12GraphicsCapture * self)
{
HRESULT hr;
ComPtr < IDispatcherQueueController > queue_ctrl;
auto priv = self->priv;
HANDLE event_handle = CreateEventEx (nullptr, nullptr, 0, EVENT_ALL_ACCESS);
ComPtr < IDirect3DDevice > d3d_device;
HANDLE waitables[] = { priv->shutdown_handle, event_handle };
ComPtr < AsyncWaiter > async_waiter;
ComPtr < IAsyncAction > shutdown_action;
GST_INFO_OBJECT (self, "Entering loop thread");
g_vtable.SetThreadDpiAwarenessContext
(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE);
g_vtable.RoInitialize (RO_INIT_MULTITHREADED);
hr = MakeAndInitialize < AsyncWaiter > (&async_waiter, event_handle);
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't create async waiter");
goto out;
}
DispatcherQueueOptions queue_opt;
queue_opt.dwSize = sizeof (DispatcherQueueOptions);
queue_opt.threadType = DQTYPE_THREAD_CURRENT;
queue_opt.apartmentType = DQTAT_COM_NONE;
hr = g_vtable.CreateDispatcherQueueController (queue_opt, &queue_ctrl);
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't create dispatcher queue controller");
goto out;
}
if (!open_device (self, &d3d_device)) {
GST_ERROR_OBJECT (self, "Couldn't open device");
goto out;
}
if (!create_session (self, d3d_device.Get ())) {
GST_ERROR_OBJECT (self, "Couldn't open session");
goto out;
}
{
std::lock_guard < std::mutex > lk (priv->loop_lock);
priv->loop_state = LOOP_STATE_RUNNING;
priv->loop_cond.notify_all ();
}
while (true) {
MSG msg;
while (PeekMessage (&msg, nullptr, 0, 0, PM_REMOVE)) {
TranslateMessage (&msg);
DispatchMessage (&msg);
}
auto wait_ret = MsgWaitForMultipleObjects (G_N_ELEMENTS (waitables),
waitables, FALSE, INFINITE, QS_ALLINPUT);
if (wait_ret == WAIT_OBJECT_0) {
GST_DEBUG_OBJECT (self, "Begin shutdown");
priv->capture->Close ();
hr = queue_ctrl->ShutdownQueueAsync (&shutdown_action);
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Shutdown failed");
break;
}
hr = shutdown_action->put_Completed (async_waiter.Get ());
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Couldn't install shutdown callback");
break;
}
} else if (wait_ret == WAIT_OBJECT_0 + 1) {
GST_DEBUG_OBJECT (self, "Shutdown completed");
break;
} else if (wait_ret != WAIT_OBJECT_0 + G_N_ELEMENTS (waitables)) {
GST_ERROR_OBJECT (self, "Unexpected wait return %u", (guint) wait_ret);
break;
}
}
out:
{
std::lock_guard < std::mutex > lk (priv->loop_lock);
priv->loop_state = LOOP_STATE_STOPPED;
priv->loop_cond.notify_all ();
}
priv->capture = nullptr;
queue_ctrl = nullptr;
shutdown_action = nullptr;
async_waiter = nullptr;
if (d3d_device) {
ComPtr < IClosable > closable;
d3d_device.As (&closable);
if (closable)
closable->Close ();
closable = nullptr;
d3d_device = nullptr;
}
CloseHandle (event_handle);
g_vtable.RoUninitialize ();
GST_INFO_OBJECT (self, "Leaving loop thread");
return nullptr;
}
static GstFlowReturn
gst_d3d12_graphics_capture_prepare (GstD3D12ScreenCapture * capture)
{
return GST_FLOW_OK;
}
static gboolean
gst_d3d12_graphics_capture_get_size (GstD3D12ScreenCapture * capture,
guint * width, guint * height)
{
auto self = GST_D3D12_GRAPHICS_CAPTURE (capture);
auto priv = self->priv;
priv->capture->GetSize (width, height);
return TRUE;
}
static gboolean
gst_d3d12_graphics_capture_unlock (GstD3D12ScreenCapture * capture)
{
auto self = GST_D3D12_GRAPHICS_CAPTURE (capture);
auto priv = self->priv;
priv->capture->SetFlushing (true);
return TRUE;
}
static gboolean
gst_d3d12_graphics_capture_unlock_stop (GstD3D12ScreenCapture * capture)
{
auto self = GST_D3D12_GRAPHICS_CAPTURE (capture);
auto priv = self->priv;
priv->capture->SetFlushing (false);
return TRUE;
}
GstD3D12ScreenCapture *
gst_d3d12_graphics_capture_new (GstD3D12Device * device, HWND window_handle,
HMONITOR monitor_handle)
{
g_return_val_if_fail (device, nullptr);
if (!gst_d3d12_graphics_capture_load_library ()) {
GST_WARNING ("Couldn't load library");
return nullptr;
}
if (window_handle && !IsWindow (window_handle)) {
GST_ERROR ("%p is not a valid HWND", window_handle);
return nullptr;
}
auto self = (GstD3D12GraphicsCapture *)
g_object_new (GST_TYPE_D3D12_GRAPHICS_CAPTURE, nullptr);
gst_object_ref_sink (self);
auto priv = self->priv;
priv->device = (GstD3D12Device *) gst_object_ref (device);
priv->window_handle = window_handle;
priv->monitor_handle = monitor_handle;
priv->loop_thread = g_thread_new ("GstD3D12GraphicsCapture",
(GThreadFunc) gst_d3d11_graphics_thread_func, self);
bool configured = false;
{
std::unique_lock < std::mutex > lk (priv->loop_lock);
while (priv->loop_state == LOOP_STATE_INIT)
priv->loop_cond.wait (lk);
if (priv->loop_state == LOOP_STATE_RUNNING)
configured = true;
}
if (!configured)
gst_clear_object (&self);
return (GstD3D12ScreenCapture *) self;
}
void
gst_d3d12_graphics_capture_show_border (GstD3D12GraphicsCapture * capture,
gboolean show)
{
auto priv = capture->priv;
priv->capture->SetBorderRequired (show);
}
void
gst_d3d12_graphics_capture_show_cursor (GstD3D12GraphicsCapture * capture,
gboolean show)
{
auto priv = capture->priv;
priv->capture->SetCursorEnabled (show);
}
void
gst_d3d12_graphics_capture_set_client_only (GstD3D12GraphicsCapture * capture,
gboolean client_only)
{
auto priv = capture->priv;
priv->capture->SetClientOnly (client_only);
}
GstFlowReturn
gst_d3d12_graphics_capture_do_capture (GstD3D12GraphicsCapture * capture,
gboolean is_d3d12, const CaptureCropRect * crop_rect, GstBuffer ** buffer,
guint * width, guint * height)
{
auto priv = capture->priv;
if (is_d3d12)
return priv->capture->GetD3D12Frame (crop_rect, buffer, width, height);
return priv->capture->GetVideoFrame (crop_rect, buffer, width, height);
}
Reference in a new issue View git blame Copy permalink