gstreamer/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11winrtcapture.cpp

1095 lines
32 KiB
C++

/*
* GStreamer
* Copyright (C) 2022 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 "gstd3d11winrtcapture.h"
#include "gstd3d11pluginutils.h"
#include <gmodule.h>
#include <winstring.h>
#include <roapi.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>
#include <string.h>
#include <dwmapi.h>
#include <wrl.h>
#ifdef HAVE_WINMM
#include <mmsystem.h>
#endif
GST_DEBUG_CATEGORY_EXTERN (gst_d3d11_screen_capture_debug);
#define GST_CAT_DEFAULT gst_d3d11_screen_capture_debug
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
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;
static SRWLOCK capture_list_lock = SRWLOCK_INIT;
static GList *capture_list = nullptr;
#define D3D11_WINRT_CAPTURE_PROP_NAME "gst-d3d11-winrt-capture"
#define WM_GST_D3D11_WINRT_CAPTURE_CLOSED (WM_USER + 1)
typedef struct
{
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);
DPI_AWARENESS_CONTEXT (WINAPI * SetThreadDpiAwarenessContext) (DPI_AWARENESS_CONTEXT context);
} GstD3D11WinRTVTable;
static GstD3D11WinRTVTable winrt_vtable = { FALSE, };
template < typename InterfaceType, PCNZWCH runtime_class_id >
static HRESULT
GstGetActivationFactory (InterfaceType ** factory)
{
if (!gst_d3d11_winrt_capture_load_library ())
return E_NOINTERFACE;
HSTRING class_id_hstring;
HRESULT hr = winrt_vtable.WindowsCreateString (runtime_class_id,
wcslen (runtime_class_id), &class_id_hstring);
if (FAILED (hr))
return hr;
hr = winrt_vtable.RoGetActivationFactory (class_id_hstring,
IID_PPV_ARGS (factory));
if (FAILED (hr)) {
winrt_vtable.WindowsDeleteString (class_id_hstring);
return hr;
}
return winrt_vtable.WindowsDeleteString (class_id_hstring);
}
#define CLOSE_COM(obj) G_STMT_START { \
if (obj) { \
ComPtr<IClosable> closable; \
obj.As (&closable); \
if (closable) \
closable->Close (); \
obj = nullptr; \
} \
} G_STMT_END
struct GstD3D11WinRTCaptureInner
{
~GstD3D11WinRTCaptureInner()
{
CLOSE_COM (session);
CLOSE_COM (pool);
CLOSE_COM (item);
CLOSE_COM (d3d_device);
}
STDMETHODIMP
OnClosed (IGraphicsCaptureItem * item, IInspectable * args)
{
GST_WARNING ("Item %p got closed", this);
this->closed = true;
return S_OK;
}
ComPtr < IDirect3DDevice > d3d_device;
ComPtr < IGraphicsCaptureItem > item;
ComPtr < IDirect3D11CaptureFramePool > pool;
ComPtr < IGraphicsCaptureSession > session;
bool closed = false;
};
/* *INDENT-ON* */
#define LOAD_SYMBOL(module,name,func) G_STMT_START { \
if (!g_module_symbol (module, G_STRINGIFY (name), (gpointer *) &winrt_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_d3d11_winrt_capture_load_library (void)
{
static GModule *d3d11_module = nullptr;
static GModule *combase_module = nullptr;
static GModule *user32_module = nullptr;
GST_D3D11_CALL_ONCE_BEGIN {
d3d11_module = g_module_open ("d3d11.dll", G_MODULE_BIND_LAZY);
/* Shouldn't happen... */
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;
}
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);
winrt_vtable.loaded = TRUE;
}
GST_D3D11_CALL_ONCE_END;
return winrt_vtable.loaded;
}
enum
{
PROP_0,
PROP_D3D11_DEVICE,
PROP_MONITOR_HANDLE,
PROP_WINDOW_HANDLE,
PROP_CLIENT_ONLY,
};
struct _GstD3D11WinRTCapture
{
GstD3D11ScreenCapture parent;
GstD3D11Device *device;
GstD3D11WinRTCaptureInner *inner;
/* Reported by WGC API */
SizeInt32 pool_size;
/* Actual texture resolution */
UINT width;
UINT height;
UINT capture_width;
UINT capture_height;
gboolean flushing;
boolean show_mouse;
boolean show_border;
GThread *thread;
GMainContext *context;
GMainLoop *loop;
CRITICAL_SECTION lock;
CONDITION_VARIABLE cond;
LARGE_INTEGER frequency;
HMONITOR monitor_handle;
HWND window_handle;
gboolean client_only;
HWND hidden_window;
};
static void gst_d3d11_winrt_capture_constructed (GObject * object);
static void gst_d3d11_winrt_capture_dispose (GObject * object);
static void gst_d3d11_winrt_capture_finalize (GObject * object);
static void gst_d3d11_winrt_capture_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec);
static GstFlowReturn
gst_d3d11_winrt_capture_prepare (GstD3D11ScreenCapture * capture);
static gboolean
gst_d3d11_winrt_capture_get_size (GstD3D11ScreenCapture * capture,
guint * width, guint * height);
static gboolean
gst_d3d11_winrt_capture_get_colorimetry (GstD3D11ScreenCapture * capture,
GstVideoColorimetry * colorimetry);
static gboolean
gst_d3d11_winrt_capture_unlock (GstD3D11ScreenCapture * capture);
static gboolean
gst_d3d11_winrt_capture_unlock_stop (GstD3D11ScreenCapture * capture);
static void
gst_d3d11_winrt_capture_show_border (GstD3D11ScreenCapture * capture,
gboolean show);
static GstFlowReturn
gst_d3d11_winrt_capture_do_capture (GstD3D11ScreenCapture * capture,
GstD3D11Device * device, ID3D11Texture2D * texture,
ID3D11RenderTargetView * rtv, ID3D11VertexShader * vs,
ID3D11PixelShader * ps, ID3D11InputLayout * layout,
ID3D11SamplerState * sampler, ID3D11BlendState * blend,
D3D11_BOX * crop_box, gboolean draw_mouse);
static gpointer
gst_d3d11_winrt_capture_thread_func (GstD3D11WinRTCapture * self);
#define gst_d3d11_winrt_capture_parent_class parent_class
G_DEFINE_TYPE (GstD3D11WinRTCapture, gst_d3d11_winrt_capture,
GST_TYPE_D3D11_SCREEN_CAPTURE);
static void
gst_d3d11_winrt_capture_class_init (GstD3D11WinRTCaptureClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstD3D11ScreenCaptureClass *capture_class =
GST_D3D11_SCREEN_CAPTURE_CLASS (klass);
gobject_class->constructed = gst_d3d11_winrt_capture_constructed;
gobject_class->dispose = gst_d3d11_winrt_capture_dispose;
gobject_class->finalize = gst_d3d11_winrt_capture_finalize;
gobject_class->set_property = gst_d3d11_winrt_capture_set_property;
g_object_class_install_property (gobject_class, PROP_D3D11_DEVICE,
g_param_spec_object ("d3d11device", "D3D11 Device",
"GstD3D11Device object for operating",
GST_TYPE_D3D11_DEVICE, (GParamFlags)
(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_MONITOR_HANDLE,
g_param_spec_pointer ("monitor-handle", "Monitor Handle",
"A HMONITOR handle of monitor to capture", (GParamFlags)
(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_WINDOW_HANDLE,
g_param_spec_pointer ("window-handle", "Window Handle",
"A HWND handle of window to capture", (GParamFlags)
(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_CLIENT_ONLY,
g_param_spec_boolean ("client-only",
"Client Only", "Captures only client area", FALSE,
(GParamFlags) (G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS)));
capture_class->prepare = GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_prepare);
capture_class->get_size =
GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_get_size);
capture_class->get_colorimetry =
GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_get_colorimetry);
capture_class->unlock = GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_unlock);
capture_class->unlock_stop =
GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_unlock_stop);
capture_class->show_border =
GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_show_border);
capture_class->do_capture =
GST_DEBUG_FUNCPTR (gst_d3d11_winrt_capture_do_capture);
}
static void
gst_d3d11_winrt_capture_init (GstD3D11WinRTCapture * self)
{
InitializeCriticalSection (&self->lock);
}
static void
gst_d3d11_winrt_capture_constructed (GObject * object)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (object);
GstD3D11CSLockGuard lk (&self->lock);
self->context = g_main_context_new ();
self->loop = g_main_loop_new (self->context, FALSE);
self->thread = g_thread_new ("GstD3D11WinRTCapture",
(GThreadFunc) gst_d3d11_winrt_capture_thread_func, self);
while (!g_main_loop_is_running (self->loop))
SleepConditionVariableCS (&self->cond, &self->lock, INFINITE);
G_OBJECT_CLASS (parent_class)->constructed (object);
}
static void
gst_d3d11_winrt_capture_dispose (GObject * object)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (object);
if (self->loop)
g_main_loop_quit (self->loop);
g_clear_pointer (&self->thread, g_thread_join);
g_clear_pointer (&self->loop, g_main_loop_unref);
g_clear_pointer (&self->context, g_main_context_unref);
gst_clear_object (&self->device);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_d3d11_winrt_capture_finalize (GObject * object)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (object);
DeleteCriticalSection (&self->lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_d3d11_winrt_capture_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (object);
switch (prop_id) {
case PROP_D3D11_DEVICE:
self->device = (GstD3D11Device *) g_value_dup_object (value);
break;
case PROP_MONITOR_HANDLE:
self->monitor_handle = (HMONITOR) g_value_get_pointer (value);
break;
case PROP_WINDOW_HANDLE:
self->window_handle = (HWND) g_value_get_pointer (value);
break;
case PROP_CLIENT_ONLY:
self->client_only = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_d3d11_winrt_capture_running_cb (GstD3D11WinRTCapture * self)
{
GstD3D11CSLockGuard lk (&self->lock);
WakeAllConditionVariable (&self->cond);
return G_SOURCE_REMOVE;
}
static void
gst_d3d11_winrt_configure (GstD3D11WinRTCapture * self)
{
HRESULT hr;
GstD3D11Device *device = self->device;
ComPtr < ID3D10Multithread > multi_thread;
ComPtr < IGraphicsCaptureItemInterop > interop;
ID3D11Device *device_handle;
ComPtr < IDXGIDevice > dxgi_device;
ComPtr < IInspectable > inspectable;
ComPtr < IDirect3D11CaptureFramePoolStatics > pool_statics;
ComPtr < IDirect3D11CaptureFramePoolStatics2 > pool_statics2;
ComPtr < IGraphicsCaptureSession2 > session2;
ComPtr < IGraphicsCaptureSession3 > session3;
GstD3D11WinRTCaptureInner *inner = nullptr;
device_handle = gst_d3d11_device_get_device_handle (device);
hr = device_handle->QueryInterface (IID_PPV_ARGS (&multi_thread));
if (!gst_d3d11_result (hr, device)) {
GST_ERROR_OBJECT (self, "ID3D10Multithread interface is unavailable");
return;
}
multi_thread->SetMultithreadProtected (TRUE);
hr = GstGetActivationFactory < IGraphicsCaptureItemInterop,
RuntimeClass_Windows_Graphics_Capture_GraphicsCaptureItem > (&interop);
if (!gst_d3d11_result (hr, device)) {
GST_WARNING_OBJECT (self, "IGraphicsCaptureItemInterop is not available");
return;
}
inner = new GstD3D11WinRTCaptureInner ();
if (self->monitor_handle) {
hr = interop->CreateForMonitor (self->monitor_handle,
IID_PPV_ARGS (&inner->item));
} else if (self->window_handle) {
hr = interop->CreateForWindow (self->window_handle,
IID_PPV_ARGS (&inner->item));
} else {
g_assert_not_reached ();
goto error;
}
if (!gst_d3d11_result (hr, device)) {
GST_WARNING_OBJECT (self, "Could not create item");
goto error;
}
hr = device_handle->QueryInterface (IID_PPV_ARGS (&dxgi_device));
if (!gst_d3d11_result (hr, device)) {
GST_WARNING_OBJECT (self, "IDXGIDevice is not available");
goto error;
}
hr = winrt_vtable.CreateDirect3D11DeviceFromDXGIDevice (dxgi_device.Get (),
&inspectable);
if (!gst_d3d11_result (hr, device)) {
GST_WARNING_OBJECT (self, "CreateDirect3D11DeviceFromDXGIDevice failed");
goto error;
}
hr = inspectable.As (&inner->d3d_device);
if (!gst_d3d11_result (hr, device)) {
GST_WARNING_OBJECT (device, "IDirect3DDevice is not available");
goto error;
}
hr = GstGetActivationFactory < IDirect3D11CaptureFramePoolStatics,
RuntimeClass_Windows_Graphics_Capture_Direct3D11CaptureFramePool >
(&pool_statics);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self,
"IDirect3D11CaptureFramePoolStatics is not available");
goto error;
}
hr = pool_statics.As (&pool_statics2);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self,
"IDirect3D11CaptureFramePoolStatics2 is not available");
goto error;
}
hr = inner->item->get_Size (&self->pool_size);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not get item size");
goto error;
}
self->width = self->capture_width = (UINT) self->pool_size.Width;
self->height = self->capture_height = (UINT) self->pool_size.Height;
if (self->window_handle && self->client_only) {
RECT rect;
if (!GetClientRect (self->window_handle, &rect)) {
GST_ERROR_OBJECT (self, "Could not get client rect");
goto error;
}
self->capture_width = rect.right - rect.left;
self->capture_height = rect.bottom - rect.top;
self->capture_width = MAX (self->capture_width, 1);
self->capture_height = MAX (self->capture_height, 1);
GST_DEBUG_OBJECT (self, "Client rect %d:%d:%d:%d, pool size %dx%d",
rect.left, rect.top, rect.right, rect.bottom,
self->width, self->height);
}
hr = pool_statics2->CreateFreeThreaded (inner->d3d_device.Get (),
DirectXPixelFormat::DirectXPixelFormat_B8G8R8A8UIntNormalized,
1, self->pool_size, &inner->pool);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not setup pool");
goto error;
}
hr = inner->pool->CreateCaptureSession (inner->item.Get (), &inner->session);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not create session");
goto error;
}
inner->session.As (&session2);
if (session2)
session2->put_IsCursorCaptureEnabled (FALSE);
inner->session.As (&session3);
if (session3)
session3->put_IsBorderRequired (self->show_border);
hr = inner->session->StartCapture ();
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not start capture");
goto error;
}
self->inner = inner;
return;
error:
if (inner)
delete inner;
}
static LRESULT CALLBACK
gst_d3d11_winrt_capture_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
GstD3D11WinRTCapture *self;
if (msg == WM_CREATE) {
self = GST_D3D11_WINRT_CAPTURE (((LPCREATESTRUCTA) lparam)->lpCreateParams);
SetPropA (hwnd, D3D11_WINRT_CAPTURE_PROP_NAME, self);
} else if (GetPropA (hwnd, D3D11_WINRT_CAPTURE_PROP_NAME) &&
msg == WM_GST_D3D11_WINRT_CAPTURE_CLOSED) {
HANDLE handle = GetPropA (hwnd, D3D11_WINRT_CAPTURE_PROP_NAME);
if (!GST_IS_D3D11_WINRT_CAPTURE (handle)) {
GST_WARNING ("%p is not d3d11window object", handle);
return DefWindowProcA (hwnd, msg, wparam, lparam);
}
self = GST_D3D11_WINRT_CAPTURE (handle);
GST_INFO_OBJECT (self, "Target window got closed");
GstD3D11CSLockGuard lk (&self->lock);
if (self->inner)
self->inner->closed = true;
WakeAllConditionVariable (&self->cond);
return 0;
}
return DefWindowProcA (hwnd, msg, wparam, lparam);
}
static HWND
gst_d3d11_winrt_create_hidden_window (GstD3D11WinRTCapture * self)
{
static SRWLOCK lock = SRWLOCK_INIT;
WNDCLASSEXA wc;
ATOM atom;
HINSTANCE inst = GetModuleHandle (nullptr);
AcquireSRWLockExclusive (&lock);
atom = GetClassInfoExA (inst, "GstD3D11WinRTCapture", &wc);
if (atom == 0) {
ZeroMemory (&wc, sizeof (WNDCLASSEXA));
wc.cbSize = sizeof (WNDCLASSEXA);
wc.lpfnWndProc = gst_d3d11_winrt_capture_proc;
wc.hInstance = inst;
wc.style = CS_OWNDC;
wc.lpszClassName = "GstD3D11WinRTCapture";
atom = RegisterClassExA (&wc);
ReleaseSRWLockExclusive (&lock);
if (atom == 0) {
GST_ERROR_OBJECT (self, "Failed to register window class 0x%x",
(guint) GetLastError ());
return nullptr;
}
} else {
ReleaseSRWLockExclusive (&lock);
}
return CreateWindowExA (0, "GstD3D11WinRTCapture", "GstD3D11WinRTCapture",
WS_POPUP, 0, 0, 1, 1, nullptr, nullptr, inst, self);
}
static void CALLBACK
event_hook_func (HWINEVENTHOOK hook, DWORD event, HWND hwnd, LONG id_obj,
LONG id_child, DWORD id_event_thread, DWORD event_time)
{
if (event != EVENT_OBJECT_DESTROY || id_obj != OBJID_WINDOW ||
id_child != INDEXID_CONTAINER || !hwnd) {
return;
}
GstD3D11SRWLockGuard lk (&capture_list_lock);
GList *iter;
for (iter = capture_list; iter; iter = g_list_next (iter)) {
GstD3D11WinRTCapture *capture = GST_D3D11_WINRT_CAPTURE (iter->data);
GstD3D11CSLockGuard capture_lk (&capture->lock);
if (capture->hidden_window && capture->window_handle == hwnd) {
PostMessageA (capture->hidden_window, WM_GST_D3D11_WINRT_CAPTURE_CLOSED,
0, 0);
return;
}
}
}
static gboolean
gst_d3d11_winrt_capture_msg_cb (GIOChannel * source, GIOCondition condition,
gpointer data)
{
MSG msg;
if (!PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
return G_SOURCE_CONTINUE;
TranslateMessage (&msg);
DispatchMessage (&msg);
return G_SOURCE_CONTINUE;
}
static void
gst_d3d11_winrt_capture_weak_ref_notify (gpointer data,
GstD3D11WinRTCapture * self)
{
GstD3D11SRWLockGuard lk (&capture_list_lock);
capture_list = g_list_remove (capture_list, self);
}
static gpointer
gst_d3d11_winrt_capture_thread_func (GstD3D11WinRTCapture * self)
{
GSource *source;
GSource *msg_source = nullptr;
GIOChannel *msg_io_channel = nullptr;
HWINEVENTHOOK hook = nullptr;
#if HAVE_WINMM
TIMECAPS time_caps;
guint timer_res = 0;
if (timeGetDevCaps (&time_caps, sizeof (TIMECAPS)) == TIMERR_NOERROR) {
guint resolution;
resolution = MIN (MAX (time_caps.wPeriodMin, 1), time_caps.wPeriodMax);
if (timeBeginPeriod (resolution) != TIMERR_NOERROR)
timer_res = resolution;
}
#endif
winrt_vtable.SetThreadDpiAwarenessContext
(DPI_AWARENESS_CONTEXT_SYSTEM_AWARE);
QueryPerformanceFrequency (&self->frequency);
winrt_vtable.RoInitialize (RO_INIT_MULTITHREADED);
g_main_context_push_thread_default (self->context);
source = g_idle_source_new ();
g_source_set_callback (source,
(GSourceFunc) gst_d3d11_winrt_capture_running_cb, self, nullptr);
g_source_attach (source, self->context);
g_source_unref (source);
gst_d3d11_winrt_configure (self);
if (self->inner && self->window_handle) {
/* hold list of capture objects to send target window closed event */
AcquireSRWLockExclusive (&capture_list_lock);
g_object_weak_ref (G_OBJECT (self),
(GWeakNotify) gst_d3d11_winrt_capture_weak_ref_notify, nullptr);
capture_list = g_list_append (capture_list, self);
ReleaseSRWLockExclusive (&capture_list_lock);
self->hidden_window = gst_d3d11_winrt_create_hidden_window (self);
if (self->hidden_window) {
DWORD process_id, thread_id;
thread_id = GetWindowThreadProcessId (self->window_handle, &process_id);
if (thread_id) {
hook = SetWinEventHook (EVENT_OBJECT_DESTROY, EVENT_OBJECT_DESTROY,
nullptr, event_hook_func, process_id, thread_id,
WINEVENT_OUTOFCONTEXT);
}
msg_io_channel =
g_io_channel_win32_new_messages ((guintptr) self->hidden_window);
msg_source = g_io_create_watch (msg_io_channel, G_IO_IN);
g_source_set_callback (msg_source,
(GSourceFunc) gst_d3d11_winrt_capture_msg_cb, self, nullptr);
g_source_attach (msg_source, self->context);
}
}
g_main_loop_run (self->loop);
if (hook)
UnhookWinEvent (hook);
EnterCriticalSection (&self->lock);
if (self->hidden_window) {
RemovePropA (self->hidden_window, D3D11_WINRT_CAPTURE_PROP_NAME);
DestroyWindow (self->hidden_window);
self->hidden_window = nullptr;
}
LeaveCriticalSection (&self->lock);
if (msg_source) {
g_source_destroy (msg_source);
g_source_unref (msg_source);
}
if (msg_io_channel)
g_io_channel_unref (msg_io_channel);
if (self->inner)
delete self->inner;
self->inner = nullptr;
g_main_context_pop_thread_default (self->context);
winrt_vtable.RoUninitialize ();
#if HAVE_WINMM
if (timer_res != 0)
timeEndPeriod (timer_res);
#endif
return nullptr;
}
static GstFlowReturn
gst_d3d11_winrt_capture_prepare (GstD3D11ScreenCapture * capture)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (capture);
g_assert (self->inner != nullptr);
return GST_FLOW_OK;
}
static gboolean
gst_d3d11_winrt_capture_get_size (GstD3D11ScreenCapture * capture,
guint * width, guint * height)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (capture);
*width = self->capture_width;
*height = self->capture_height;
return TRUE;
}
static gboolean
gst_d3d11_winrt_capture_get_colorimetry (GstD3D11ScreenCapture * capture,
GstVideoColorimetry * colorimetry)
{
return FALSE;
}
static gboolean
gst_d3d11_winrt_capture_unlock (GstD3D11ScreenCapture * capture)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (capture);
GstD3D11CSLockGuard lk (&self->lock);
self->flushing = TRUE;
WakeAllConditionVariable (&self->cond);
return TRUE;
}
static gboolean
gst_d3d11_winrt_capture_unlock_stop (GstD3D11ScreenCapture * capture)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (capture);
GstD3D11CSLockGuard lk (&self->lock);
self->flushing = FALSE;
WakeAllConditionVariable (&self->cond);
return TRUE;
}
static void
gst_d3d11_winrt_capture_show_border (GstD3D11ScreenCapture * capture,
gboolean show)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (capture);
GstD3D11CSLockGuard lk (&self->lock);
self->show_border = show;
if (self->inner->session) {
ComPtr < IGraphicsCaptureSession3 > session3;
self->inner->session.As (&session3);
if (session3)
session3->put_IsBorderRequired (self->show_border);
}
}
static GstFlowReturn
gst_d3d11_winrt_capture_do_capture (GstD3D11ScreenCapture * capture,
GstD3D11Device * device, ID3D11Texture2D * texture,
ID3D11RenderTargetView * rtv, ID3D11VertexShader * vs,
ID3D11PixelShader * ps, ID3D11InputLayout * layout,
ID3D11SamplerState * sampler, ID3D11BlendState * blend,
D3D11_BOX * crop_box, gboolean draw_mouse)
{
GstD3D11WinRTCapture *self = GST_D3D11_WINRT_CAPTURE (capture);
GstD3D11WinRTCaptureInner *inner = self->inner;
ComPtr < IDirect3D11CaptureFrame > frame;
ComPtr < IDirect3DSurface > surface;
ComPtr < IDirect3DDxgiInterfaceAccess > access;
ComPtr < ID3D11Texture2D > captured_texture;
ID3D11DeviceContext *context_handle;
SizeInt32 size;
HRESULT hr;
LARGE_INTEGER now;
LONGLONG timeout;
D3D11_TEXTURE2D_DESC desc;
gboolean size_changed = FALSE;
D3D11_BOX box = *crop_box;
GstD3D11CSLockGuard lk (&self->lock);
again:
frame = nullptr;
surface = nullptr;
access = nullptr;
captured_texture = nullptr;
if (inner->closed) {
GST_ERROR_OBJECT (self, "Item was closed");
return GST_FLOW_ERROR;
}
if (self->flushing) {
GST_INFO_OBJECT (self, "We are flushing");
return GST_FLOW_FLUSHING;
}
if ((draw_mouse && !self->show_mouse) || (!draw_mouse && self->show_mouse)) {
ComPtr < IGraphicsCaptureSession2 > session2;
self->show_mouse = draw_mouse;
inner->session.As (&session2);
if (session2) {
hr = session2->put_IsCursorCaptureEnabled (draw_mouse);
if (!gst_d3d11_result (hr, self->device))
GST_DEBUG_OBJECT (self, "Could not set IsCursorCaptureEnabled");
} else {
GST_LOG_OBJECT (self, "IGraphicsCaptureSession2 is not available");
}
}
/* Magic number 5 sec timeout */
QueryPerformanceCounter (&now);
timeout = now.QuadPart + 5 * self->frequency.QuadPart;
do {
hr = inner->pool->TryGetNextFrame (&frame);
if (frame)
break;
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not capture frame");
return GST_FLOW_ERROR;
}
SleepConditionVariableCS (&self->cond, &self->lock, 1);
QueryPerformanceCounter (&now);
} while (!inner->closed && !self->flushing && now.QuadPart < timeout);
if (self->flushing) {
GST_INFO_OBJECT (self, "We are flushing");
return GST_FLOW_FLUSHING;
}
if (inner->closed) {
GST_WARNING_OBJECT (self, "Capture item was closed");
return GST_FLOW_ERROR;
}
if (!frame) {
GST_WARNING_OBJECT (self, "No frame available");
return GST_D3D11_SCREEN_CAPTURE_FLOW_EXPECTED_ERROR;
}
hr = frame->get_ContentSize (&size);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not get content size");
return GST_FLOW_ERROR;
}
if (size.Width != self->pool_size.Width ||
size.Height != self->pool_size.Height) {
GST_DEBUG_OBJECT (self, "Size changed %dx%d -> %dx%d",
self->pool_size.Width, self->pool_size.Height, size.Width, size.Height);
self->pool_size = size;
frame = nullptr;
hr = inner->pool->Recreate (inner->d3d_device.Get (),
DirectXPixelFormat::DirectXPixelFormat_B8G8R8A8UIntNormalized,
1, self->pool_size);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not recreate");
return GST_FLOW_ERROR;
}
size_changed = TRUE;
goto again;
}
hr = frame->get_Surface (&surface);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not get IDirect3DSurface");
return GST_FLOW_ERROR;
}
hr = surface.As (&access);
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not get IDirect3DDxgiInterfaceAccess");
return GST_FLOW_ERROR;
}
hr = access->GetInterface (IID_PPV_ARGS (&captured_texture));
if (!gst_d3d11_result (hr, self->device)) {
GST_ERROR_OBJECT (self, "Could not get texture from frame");
return GST_FLOW_ERROR;
}
/* XXX: actual texture size can be different from reported pool size */
captured_texture->GetDesc (&desc);
if (desc.Width != self->width || desc.Height != self->height) {
GST_DEBUG_OBJECT (self, "Texture size changed %dx%d -> %dx%d",
self->width, self->height, desc.Width, desc.Height);
self->width = desc.Width;
self->height = desc.Height;
if (!self->window_handle || !self->client_only) {
self->capture_width = self->width;
self->capture_height = self->capture_height;
}
size_changed = TRUE;
}
if (self->window_handle && self->client_only) {
RECT client_rect, bound_rect;
POINT client_pos = { 0, };
UINT width, height;
DPI_AWARENESS_CONTEXT prev;
BOOL ret;
prev = winrt_vtable.SetThreadDpiAwarenessContext
(DPI_AWARENESS_CONTEXT_SYSTEM_AWARE);
ret = GetClientRect (self->window_handle, &client_rect) &&
DwmGetWindowAttribute (self->window_handle,
DWMWA_EXTENDED_FRAME_BOUNDS, &bound_rect, sizeof (RECT)) == S_OK &&
ClientToScreen (self->window_handle, &client_pos);
if (prev)
winrt_vtable.SetThreadDpiAwarenessContext (prev);
if (!ret) {
GST_ERROR_OBJECT (self, "Could not get client rect");
return GST_FLOW_ERROR;
}
width = client_rect.right - client_rect.left;
height = client_rect.bottom - client_rect.top;
width = MAX (width, 1);
height = MAX (height, 1);
if (self->capture_width != width || self->capture_height != height) {
GST_DEBUG_OBJECT (self, "Client rect size changed %dx%d -> %dx%d",
self->capture_width, self->capture_height, width, height);
self->capture_width = width;
self->capture_height = height;
size_changed = TRUE;
} else {
UINT x_offset = 0;
UINT y_offset = 0;
GST_LOG_OBJECT (self, "bound-rect: %d:%d:%d:%d, "
"client-rect: %d:%d:%d:%d, client-upper-left: %d:%d",
bound_rect.left, bound_rect.top, bound_rect.right, bound_rect.bottom,
client_rect.left, client_rect.top, client_rect.right,
client_rect.bottom, client_pos.x, client_pos.y);
if (client_pos.x > bound_rect.left)
x_offset = client_pos.x - bound_rect.left;
if (client_pos.y > bound_rect.top)
y_offset = client_pos.y - bound_rect.top;
box.left += x_offset;
box.top += y_offset;
box.right += x_offset;
box.bottom += y_offset;
/* left and top is inclusive */
box.left = MIN (desc.Width - 1, box.left);
box.top = MIN (desc.Height - 1, box.top);
box.right = MIN (desc.Width, box.right);
box.bottom = MIN (desc.Height, box.bottom);
}
}
if (size_changed)
return GST_D3D11_SCREEN_CAPTURE_FLOW_SIZE_CHANGED;
context_handle = gst_d3d11_device_get_device_context_handle (self->device);
GstD3D11DeviceLockGuard device_lk (self->device);
context_handle->CopySubresourceRegion (texture, 0, 0, 0, 0,
captured_texture.Get (), 0, &box);
return GST_FLOW_OK;
}
GstD3D11ScreenCapture *
gst_d3d11_winrt_capture_new (GstD3D11Device * device, HMONITOR monitor_handle,
HWND window_handle, gboolean client_only)
{
GstD3D11WinRTCapture *self;
if (window_handle && !IsWindow (window_handle)) {
GST_WARNING_OBJECT (device, "Not a valid window handle");
return nullptr;
}
if (!gst_d3d11_winrt_capture_load_library ())
return nullptr;
self = (GstD3D11WinRTCapture *) g_object_new (GST_TYPE_D3D11_WINRT_CAPTURE,
"d3d11device", device, "monitor-handle", (gpointer) monitor_handle,
"window-handle", (gpointer) window_handle, "client-only", client_only,
nullptr);
if (!self->inner) {
gst_clear_object (&self);
return nullptr;
}
gst_object_ref_sink (self);
return GST_D3D11_SCREEN_CAPTURE_CAST (self);
}