mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-30 13:41:48 +00:00
6ffed9b3dc
set_buffer() can be called with null buffer Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/5895>
1767 lines
51 KiB
C++
1767 lines
51 KiB
C++
/* GStreamer
|
|
* Copyright (C) 2023 Seungha Yang <seungha@centricular.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gstd3d12window.h"
|
|
#include "gstd3d12overlaycompositor.h"
|
|
#include <directx/d3dx12.h>
|
|
#include <mutex>
|
|
#include <condition_variable>
|
|
#include <vector>
|
|
#include <memory>
|
|
#include <atomic>
|
|
#include <wrl.h>
|
|
#include <string>
|
|
|
|
/* *INDENT-OFF* */
|
|
using namespace Microsoft::WRL;
|
|
static std::mutex global_hwnd_lock;
|
|
/* *INDENT-ON* */
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (gst_d3d12_window_debug);
|
|
#define GST_CAT_DEFAULT gst_d3d12_window_debug
|
|
|
|
#define WS_GST_D3D12 (WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW)
|
|
#define EXTERNAL_PROC_PROP_NAME L"gst-d3d12-hwnd-external-proc"
|
|
#define D3D12_WINDOW_PROP_NAME L"gst-d3d12-hwnd-obj"
|
|
#define WM_GST_D3D12_FULLSCREEN (WM_USER + 1)
|
|
#define WM_GST_D3D12_CONSTRUCT_INTERNAL_WINDOW (WM_USER + 2)
|
|
#define WM_GST_D3D12_DESTROY_INTERNAL_WINDOW (WM_USER + 3)
|
|
#define WM_GST_D3D12_UPDATE_RENDER_RECT (WM_USER + 4)
|
|
|
|
#define BACK_BUFFER_COUNT 3
|
|
|
|
enum
|
|
{
|
|
SIGNAL_KEY_EVENT,
|
|
SIGNAL_MOUSE_EVENT,
|
|
SIGNAL_FULLSCREEN,
|
|
SIGNAL_LAST
|
|
};
|
|
|
|
static guint d3d12_window_signals[SIGNAL_LAST] = { 0, };
|
|
|
|
/* *INDENT-OFF* */
|
|
struct SwapBuffer
|
|
{
|
|
SwapBuffer (GstBuffer * buf)
|
|
{
|
|
backbuf = buf;
|
|
}
|
|
|
|
~SwapBuffer ()
|
|
{
|
|
gst_clear_buffer (&backbuf);
|
|
}
|
|
|
|
GstBuffer *backbuf = nullptr;
|
|
gboolean first = TRUE;
|
|
};
|
|
|
|
struct DeviceContext
|
|
{
|
|
DeviceContext () = delete;
|
|
DeviceContext (GstD3D12Device * dev)
|
|
{
|
|
event_handle = CreateEventEx (nullptr, nullptr, 0, EVENT_ALL_ACCESS);
|
|
device = (GstD3D12Device *) gst_object_ref (dev);
|
|
|
|
D3D12_COMMAND_QUEUE_DESC queue_desc = { };
|
|
queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
|
|
queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
|
|
|
|
queue = gst_d3d12_command_queue_new (device,
|
|
&queue_desc, BACK_BUFFER_COUNT * 2);
|
|
if (!queue) {
|
|
GST_ERROR_OBJECT (device, "Couldn't create command queue");
|
|
return;
|
|
}
|
|
|
|
ca_pool = gst_d3d12_command_allocator_pool_new (device,
|
|
D3D12_COMMAND_LIST_TYPE_DIRECT);
|
|
if (!ca_pool) {
|
|
GST_ERROR_OBJECT (device, "Couldn't create command allocator pool");
|
|
return;
|
|
}
|
|
|
|
initialized = true;
|
|
}
|
|
|
|
~DeviceContext ()
|
|
{
|
|
WaitGpu ();
|
|
|
|
CloseHandle (event_handle);
|
|
|
|
gst_clear_object (&queue);
|
|
gst_clear_object (&ca_pool);
|
|
gst_clear_buffer (&cached_buf);
|
|
gst_clear_object (&conv);
|
|
gst_clear_object (&comp);
|
|
gst_clear_buffer (&msaa_buf);
|
|
gst_clear_object (&device);
|
|
}
|
|
|
|
void WaitGpu ()
|
|
{
|
|
if (!queue)
|
|
return;
|
|
|
|
gst_d3d12_command_queue_fence_wait (queue, G_MAXUINT64, event_handle);
|
|
}
|
|
|
|
ComPtr<ID3D12GraphicsCommandList> cl;
|
|
ComPtr<IDXGISwapChain4> swapchain;
|
|
GstBuffer *msaa_buf = nullptr;
|
|
std::vector<std::shared_ptr<SwapBuffer>> swap_buffers;
|
|
D3D12_RESOURCE_DESC buffer_desc;
|
|
GstD3D12Converter *conv = nullptr;
|
|
GstD3D12OverlayCompositor *comp = nullptr;
|
|
GstBuffer *cached_buf = nullptr;
|
|
GstD3D12Device *device = nullptr;
|
|
GstD3D12CommandQueue *queue = nullptr;
|
|
GstD3D12CommandAllocatorPool *ca_pool = nullptr;
|
|
UINT64 fence_val = 0;
|
|
HANDLE event_handle;
|
|
bool initialized = false;
|
|
};
|
|
|
|
struct GstD3D12WindowPrivate
|
|
{
|
|
GstD3D12WindowPrivate ()
|
|
{
|
|
main_context = g_main_context_new ();
|
|
loop = g_main_loop_new (main_context, FALSE);
|
|
|
|
render_rect.w = -1;
|
|
render_rect.h = -1;
|
|
|
|
gst_video_info_init (&input_info);
|
|
gst_video_info_init (&display_info);
|
|
|
|
fence_data_pool = gst_d3d12_fence_data_pool_new ();
|
|
}
|
|
|
|
~GstD3D12WindowPrivate ()
|
|
{
|
|
g_main_loop_unref (loop);
|
|
g_main_context_unref (main_context);
|
|
gst_clear_object (&fence_data_pool);
|
|
}
|
|
|
|
std::recursive_mutex lock;
|
|
DXGI_FORMAT display_format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
|
|
GstVideoOrientationMethod orientation = GST_VIDEO_ORIENTATION_IDENTITY;
|
|
gfloat fov = 90.0f;
|
|
gboolean ortho = FALSE;
|
|
gfloat rotation_x = 0;
|
|
gfloat rotation_y = 0;
|
|
gfloat rotation_z = 0;
|
|
gfloat scale_x = 1.0f;
|
|
gfloat scale_y = 1.0f;
|
|
|
|
/* fullscreen related variables */
|
|
gboolean fullscreen_on_alt_enter = TRUE;
|
|
gboolean requested_fullscreen = FALSE;
|
|
gboolean applied_fullscreen = FALSE;
|
|
LONG restore_style;
|
|
WINDOWPLACEMENT restore_placement;
|
|
|
|
GstD3D12FenceDataPool *fence_data_pool;
|
|
|
|
/* User specified rect */
|
|
GstVideoRectangle render_rect = { };
|
|
|
|
GstVideoRectangle output_rect = { };
|
|
RECT dirty_rect = { };
|
|
GstVideoInfo input_info;
|
|
GstVideoInfo display_info;
|
|
|
|
D3D12_BOX crop_rect = { };
|
|
D3D12_BOX prev_crop_rect = { };
|
|
|
|
gboolean force_aspect_ratio = TRUE;
|
|
std::atomic<gboolean> enable_navigation = { TRUE };
|
|
gboolean first_present = TRUE;
|
|
gboolean backbuf_rendered = FALSE;
|
|
|
|
std::unique_ptr<DeviceContext> ctx;
|
|
|
|
std::wstring title;
|
|
gboolean update_title = FALSE;
|
|
|
|
GstD3D12MSAAMode msaa = GST_D3D12_MSAA_DISABLED;
|
|
|
|
/* Win32 window handles */
|
|
std::mutex hwnd_lock;
|
|
std::condition_variable hwnd_cond;
|
|
HWND hwnd = nullptr;
|
|
HWND external_hwnd = nullptr;
|
|
std::atomic<GstD3D12WindowState> state = { GST_D3D12_WINDOW_STATE_INIT };
|
|
GThread *main_loop_thread = nullptr;
|
|
|
|
GThread *internal_hwnd_thread = nullptr;
|
|
|
|
GMainLoop *loop = nullptr;
|
|
GMainContext *main_context = nullptr;
|
|
gboolean flushing = FALSE;
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
struct _GstD3D12Window
|
|
{
|
|
GstObject parent;
|
|
|
|
GstD3D12Device *device;
|
|
|
|
GstD3D12WindowPrivate *priv;
|
|
};
|
|
|
|
static GstFlowReturn gst_d3d12_window_on_resize (GstD3D12Window * self);
|
|
|
|
#define gst_d3d12_window_parent_class parent_class
|
|
G_DEFINE_TYPE (GstD3D12Window, gst_d3d12_window, GST_TYPE_OBJECT);
|
|
|
|
static void gst_d3d12_window_finalize (GObject * object);
|
|
|
|
static void
|
|
gst_d3d12_window_class_init (GstD3D12WindowClass * klass)
|
|
{
|
|
auto object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->finalize = gst_d3d12_window_finalize;
|
|
|
|
d3d12_window_signals[SIGNAL_KEY_EVENT] =
|
|
g_signal_new ("key-event", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST, 0, nullptr, nullptr, nullptr,
|
|
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
|
|
|
|
d3d12_window_signals[SIGNAL_MOUSE_EVENT] =
|
|
g_signal_new ("mouse-event", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST, 0, nullptr, nullptr, nullptr,
|
|
G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
|
|
|
|
d3d12_window_signals[SIGNAL_FULLSCREEN] =
|
|
g_signal_new ("fullscreen", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST, 0, nullptr, nullptr, nullptr,
|
|
G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
|
|
|
|
GST_DEBUG_CATEGORY_INIT (gst_d3d12_window_debug,
|
|
"d3d12window", 0, "d3d12window");
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_init (GstD3D12Window * self)
|
|
{
|
|
self->priv = new GstD3D12WindowPrivate ();
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_finalize (GObject * object)
|
|
{
|
|
auto self = GST_D3D12_WINDOW (object);
|
|
|
|
delete self->priv;
|
|
|
|
gst_clear_object (&self->device);
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_on_key_event (GstD3D12Window * self,
|
|
UINT msg, WPARAM wparam, LPARAM lparam)
|
|
{
|
|
gunichar2 keyname[128];
|
|
const gchar *event;
|
|
|
|
if (!GetKeyNameTextW (lparam, (LPWSTR) keyname, 128))
|
|
return;
|
|
|
|
gchar *name = g_utf16_to_utf8 (keyname, 128, nullptr, nullptr, nullptr);
|
|
if (!name)
|
|
return;
|
|
|
|
if (msg == WM_KEYDOWN)
|
|
event = "key-press";
|
|
else
|
|
event = "key-release";
|
|
|
|
g_signal_emit (self, d3d12_window_signals[SIGNAL_KEY_EVENT], 0, event, name);
|
|
g_free (name);
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_on_mouse_event (GstD3D12Window * self, UINT msg, WPARAM wparam,
|
|
LPARAM lparam)
|
|
{
|
|
auto priv = self->priv;
|
|
gint button = 0;
|
|
const gchar *event = nullptr;
|
|
|
|
switch (msg) {
|
|
case WM_MOUSEMOVE:
|
|
button = 0;
|
|
event = "mouse-move";
|
|
break;
|
|
case WM_LBUTTONDOWN:
|
|
button = 1;
|
|
event = "mouse-button-press";
|
|
break;
|
|
case WM_LBUTTONUP:
|
|
button = 1;
|
|
event = "mouse-button-release";
|
|
break;
|
|
case WM_RBUTTONDOWN:
|
|
button = 2;
|
|
event = "mouse-button-press";
|
|
break;
|
|
case WM_RBUTTONUP:
|
|
button = 2;
|
|
event = "mouse-button-release";
|
|
break;
|
|
case WM_MBUTTONDOWN:
|
|
button = 3;
|
|
event = "mouse-button-press";
|
|
break;
|
|
case WM_MBUTTONUP:
|
|
button = 3;
|
|
event = "mouse-button-release";
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
GstVideoRectangle output_rect = { };
|
|
GstVideoOrientationMethod orientation;
|
|
gint in_w, in_h;
|
|
{
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
orientation = priv->orientation;
|
|
output_rect = priv->output_rect;
|
|
in_w = priv->input_info.width;
|
|
in_h = priv->input_info.height;
|
|
}
|
|
auto xpos = LOWORD (lparam);
|
|
auto ypos = HIWORD (lparam);
|
|
|
|
if (in_w <= 0 || in_h <= 0 || xpos < output_rect.x ||
|
|
xpos >= output_rect.x + output_rect.w || ypos < output_rect.y ||
|
|
ypos >= output_rect.y + output_rect.h) {
|
|
return;
|
|
}
|
|
|
|
gint src_w, src_h;
|
|
switch (orientation) {
|
|
case GST_VIDEO_ORIENTATION_90R:
|
|
case GST_VIDEO_ORIENTATION_90L:
|
|
case GST_VIDEO_ORIENTATION_UL_LR:
|
|
case GST_VIDEO_ORIENTATION_UR_LL:
|
|
src_w = in_h;
|
|
src_h = in_w;
|
|
break;
|
|
default:
|
|
src_w = in_w;
|
|
src_h = in_h;
|
|
break;
|
|
}
|
|
|
|
xpos = ((xpos - output_rect.x) / (double) output_rect.w) * src_w;
|
|
ypos = ((ypos - output_rect.y) / (double) output_rect.h) * src_h;
|
|
|
|
xpos = CLAMP (xpos, 0, (LONG) (src_w - 1));
|
|
ypos = CLAMP (ypos, 0, (LONG) (src_h - 1));
|
|
|
|
double final_x = 0;
|
|
double final_y = 0;
|
|
|
|
switch (orientation) {
|
|
case GST_VIDEO_ORIENTATION_90R:
|
|
final_x = ypos;
|
|
final_y = src_w - xpos;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_90L:
|
|
final_x = src_h - ypos;
|
|
final_y = xpos;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_UR_LL:
|
|
final_x = src_h - ypos;
|
|
final_y = src_w - xpos;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_UL_LR:
|
|
final_x = ypos;
|
|
final_y = xpos;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_180:
|
|
final_x = src_w - xpos;
|
|
final_y = src_h - ypos;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_HORIZ:
|
|
final_x = src_w - xpos;
|
|
final_y = ypos;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_VERT:
|
|
final_x = xpos;
|
|
final_y = src_h - ypos;
|
|
break;
|
|
default:
|
|
final_x = xpos;
|
|
final_y = ypos;
|
|
break;
|
|
}
|
|
|
|
g_signal_emit (self, d3d12_window_signals[SIGNAL_MOUSE_EVENT], 0,
|
|
event, button, final_x, final_y);
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_toggle_fullscreen_mode (GstD3D12Window * self,
|
|
gboolean emit_signal)
|
|
{
|
|
auto priv = self->priv;
|
|
HWND hwnd = nullptr;
|
|
gboolean is_fullscreen;
|
|
ComPtr < IDXGISwapChain > swapchain;
|
|
|
|
{
|
|
std::lock_guard < std::mutex > hlk (priv->hwnd_lock);
|
|
hwnd = priv->external_hwnd ? priv->external_hwnd : priv->hwnd;
|
|
|
|
if (!hwnd)
|
|
return;
|
|
|
|
if (priv->requested_fullscreen == priv->applied_fullscreen)
|
|
return;
|
|
|
|
{
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
if (priv->ctx)
|
|
swapchain = priv->ctx->swapchain;
|
|
}
|
|
|
|
if (!swapchain)
|
|
return;
|
|
|
|
GST_DEBUG_OBJECT (self, "Change mode to %s",
|
|
priv->requested_fullscreen ? "fullscreen" : "windowed");
|
|
|
|
priv->applied_fullscreen = priv->requested_fullscreen;
|
|
is_fullscreen = priv->applied_fullscreen;
|
|
}
|
|
|
|
if (!is_fullscreen) {
|
|
SetWindowLongW (hwnd, GWL_STYLE, priv->restore_style);
|
|
SetWindowPlacement (hwnd, &priv->restore_placement);
|
|
} else {
|
|
ComPtr < IDXGIOutput > output;
|
|
DXGI_OUTPUT_DESC output_desc;
|
|
|
|
/* remember current placement to restore window later */
|
|
GetWindowPlacement (hwnd, &priv->restore_placement);
|
|
|
|
/* show window before change style */
|
|
ShowWindow (hwnd, SW_SHOW);
|
|
|
|
priv->restore_style = GetWindowLong (hwnd, GWL_STYLE);
|
|
|
|
/* Make the window borderless so that the client area can fill the screen */
|
|
SetWindowLongA (hwnd, GWL_STYLE,
|
|
priv->restore_style &
|
|
~(WS_CAPTION | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SYSMENU |
|
|
WS_THICKFRAME | WS_MAXIMIZE));
|
|
|
|
swapchain->GetContainingOutput (&output);
|
|
output->GetDesc (&output_desc);
|
|
|
|
SetWindowPos (hwnd, HWND_TOP,
|
|
output_desc.DesktopCoordinates.left,
|
|
output_desc.DesktopCoordinates.top,
|
|
output_desc.DesktopCoordinates.right,
|
|
output_desc.DesktopCoordinates.bottom,
|
|
SWP_FRAMECHANGED | SWP_NOACTIVATE);
|
|
|
|
ShowWindow (hwnd, SW_MAXIMIZE);
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (self, "Fullscreen mode change done");
|
|
|
|
if (emit_signal) {
|
|
g_signal_emit (self, d3d12_window_signals[SIGNAL_FULLSCREEN],
|
|
0, is_fullscreen);
|
|
}
|
|
}
|
|
|
|
static GstD3D12Window *
|
|
gst_d3d12_window_from_hwnd (HWND hwnd)
|
|
{
|
|
std::lock_guard < std::mutex > lk (global_hwnd_lock);
|
|
auto self = GetPropW (hwnd, D3D12_WINDOW_PROP_NAME);
|
|
if (self)
|
|
gst_object_ref (self);
|
|
|
|
return (GstD3D12Window *) self;
|
|
}
|
|
|
|
static LRESULT CALLBACK
|
|
gst_d3d12_window_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
|
|
{
|
|
switch (msg) {
|
|
case WM_CREATE:
|
|
{
|
|
LPCREATESTRUCTW create_param = (LPCREATESTRUCTW) lparam;
|
|
SetPropW (hwnd, D3D12_WINDOW_PROP_NAME, create_param->lpCreateParams);
|
|
break;
|
|
}
|
|
case WM_GST_D3D12_DESTROY_INTERNAL_WINDOW:
|
|
{
|
|
GST_INFO ("Handle destroy window message");
|
|
DestroyWindow (hwnd);
|
|
return 0;
|
|
}
|
|
case WM_GST_D3D12_UPDATE_RENDER_RECT:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
GstVideoRectangle render_rect = { };
|
|
{
|
|
auto priv = self->priv;
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
render_rect = priv->render_rect;
|
|
}
|
|
|
|
if (render_rect.w > 0 && render_rect.h > 0) {
|
|
MoveWindow (hwnd,
|
|
render_rect.x, render_rect.y, render_rect.w, render_rect.h, TRUE);
|
|
}
|
|
|
|
gst_object_unref (self);
|
|
}
|
|
return 0;
|
|
}
|
|
case WM_GST_D3D12_FULLSCREEN:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
gst_d3d12_window_toggle_fullscreen_mode (self, FALSE);
|
|
gst_object_unref (self);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
case WM_SYSKEYDOWN:
|
|
{
|
|
WORD state = GetKeyState (VK_RETURN);
|
|
BYTE high = HIBYTE (state);
|
|
|
|
if (high & 0x1) {
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
auto priv = self->priv;
|
|
bool do_toggle = false;
|
|
{
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
if (priv->fullscreen_on_alt_enter) {
|
|
priv->requested_fullscreen = !priv->applied_fullscreen;
|
|
do_toggle = true;
|
|
}
|
|
}
|
|
|
|
if (do_toggle)
|
|
gst_d3d12_window_toggle_fullscreen_mode (self, TRUE);
|
|
|
|
gst_object_unref (self);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_SIZE:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
gst_d3d12_window_on_resize (self);
|
|
gst_object_unref (self);
|
|
}
|
|
break;
|
|
}
|
|
case WM_CLOSE:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
auto priv = self->priv;
|
|
GST_DEBUG_OBJECT (self, "Internal window is being closed");
|
|
{
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
RemovePropW (priv->hwnd, D3D12_WINDOW_PROP_NAME);
|
|
priv->hwnd = nullptr;
|
|
priv->state = GST_D3D12_WINDOW_STATE_CLOSED;
|
|
|
|
}
|
|
gst_object_unref (self);
|
|
}
|
|
break;
|
|
}
|
|
case WM_NCHITTEST:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self && self->priv->external_hwnd) {
|
|
gst_object_unref (self);
|
|
|
|
/* To passthrough mouse event if external window is used.
|
|
* Only hit-test succeeded window can receive/handle some mouse events
|
|
* and we want such events to be handled by parent (application) window
|
|
*/
|
|
return (LRESULT) HTTRANSPARENT;
|
|
}
|
|
|
|
gst_clear_object (&self);
|
|
break;
|
|
}
|
|
case WM_KEYDOWN:
|
|
case WM_KEYUP:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
auto priv = self->priv;
|
|
if (priv->enable_navigation)
|
|
gst_d3d12_window_on_key_event (self, msg, wparam, lparam);
|
|
gst_object_unref (self);
|
|
}
|
|
break;
|
|
}
|
|
case WM_LBUTTONDOWN:
|
|
case WM_LBUTTONUP:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_RBUTTONUP:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_MBUTTONUP:
|
|
case WM_MOUSEMOVE:
|
|
{
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
if (self) {
|
|
auto priv = self->priv;
|
|
if (priv->enable_navigation)
|
|
gst_d3d12_window_on_mouse_event (self, msg, wparam, lparam);
|
|
gst_object_unref (self);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return DefWindowProcW (hwnd, msg, wparam, lparam);
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_create_hwnd (GstD3D12Window * self)
|
|
{
|
|
auto priv = self->priv;
|
|
auto inst = GetModuleHandle (nullptr);
|
|
|
|
{
|
|
static std::mutex class_lock;
|
|
std::lock_guard < std::mutex > lk (class_lock);
|
|
WNDCLASSEXW wc = { };
|
|
|
|
if (!GetClassInfoExW (inst, L"GstD3D12Hwnd", &wc)) {
|
|
wc.cbSize = sizeof (WNDCLASSEXW);
|
|
wc.lpfnWndProc = gst_d3d12_window_proc;
|
|
wc.hInstance = inst;
|
|
wc.hIcon = LoadIcon (nullptr, IDI_WINLOGO);
|
|
wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
|
|
wc.hCursor = LoadCursor (nullptr, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
|
|
wc.lpszClassName = L"GstD3D12Hwnd";
|
|
|
|
RegisterClassExW (&wc);
|
|
}
|
|
}
|
|
|
|
int x = CW_USEDEFAULT;
|
|
int y = CW_USEDEFAULT;
|
|
int w = 0;
|
|
int h = 0;
|
|
DWORD style = WS_GST_D3D12;
|
|
|
|
std::wstring title = L"Direct3D12 Renderer";
|
|
if (!priv->title.empty ())
|
|
title = priv->title;
|
|
|
|
if (!priv->external_hwnd) {
|
|
if (priv->render_rect.w > 0 && priv->render_rect.h > 0) {
|
|
x = priv->render_rect.x;
|
|
y = priv->render_rect.y;
|
|
w = priv->render_rect.w;
|
|
h = priv->render_rect.h;
|
|
} else {
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
RECT rect = { };
|
|
switch (priv->orientation) {
|
|
case GST_VIDEO_ORIENTATION_90R:
|
|
case GST_VIDEO_ORIENTATION_90L:
|
|
case GST_VIDEO_ORIENTATION_UL_LR:
|
|
case GST_VIDEO_ORIENTATION_UR_LL:
|
|
rect.right = GST_VIDEO_INFO_HEIGHT (&priv->display_info);
|
|
rect.bottom = GST_VIDEO_INFO_WIDTH (&priv->display_info);
|
|
break;
|
|
default:
|
|
rect.right = GST_VIDEO_INFO_WIDTH (&priv->display_info);
|
|
rect.bottom = GST_VIDEO_INFO_HEIGHT (&priv->display_info);
|
|
break;
|
|
}
|
|
|
|
AdjustWindowRect (&rect, WS_GST_D3D12, FALSE);
|
|
|
|
w = rect.right - rect.left;
|
|
h = rect.bottom - rect.top;
|
|
}
|
|
|
|
style |= WS_VISIBLE;
|
|
}
|
|
|
|
priv->hwnd = CreateWindowExW (0, L"GstD3D12Hwnd", title.c_str (),
|
|
style, x, y, w, h, (HWND) nullptr, (HMENU) nullptr, inst, self);
|
|
priv->applied_fullscreen = FALSE;
|
|
priv->internal_hwnd_thread = g_thread_self ();
|
|
}
|
|
|
|
static void
|
|
gst_d3d12_window_release_external_hwnd (GstD3D12Window * self)
|
|
{
|
|
auto priv = self->priv;
|
|
|
|
if (!priv->external_hwnd)
|
|
return;
|
|
|
|
auto hwnd = priv->external_hwnd;
|
|
priv->external_hwnd = nullptr;
|
|
|
|
auto external_proc = (WNDPROC) GetPropW (hwnd, EXTERNAL_PROC_PROP_NAME);
|
|
if (!external_proc) {
|
|
GST_WARNING_OBJECT (self, "Failed to get original window procedure");
|
|
return;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (self, "release external window %" G_GUINTPTR_FORMAT
|
|
", original window procedure %p", (guintptr) hwnd, external_proc);
|
|
|
|
RemovePropW (hwnd, EXTERNAL_PROC_PROP_NAME);
|
|
RemovePropW (hwnd, D3D12_WINDOW_PROP_NAME);
|
|
|
|
if (!SetWindowLongPtrW (hwnd, GWLP_WNDPROC, (LONG_PTR) external_proc))
|
|
GST_WARNING_OBJECT (self, "Couldn't restore original window procedure");
|
|
}
|
|
|
|
static LRESULT FAR PASCAL
|
|
sub_class_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
|
|
{
|
|
auto external_window_proc =
|
|
(WNDPROC) GetPropW (hwnd, EXTERNAL_PROC_PROP_NAME);
|
|
auto self = gst_d3d12_window_from_hwnd (hwnd);
|
|
|
|
if (!self) {
|
|
GST_DEBUG ("No object attached to the window, chain up to default");
|
|
return CallWindowProcW (external_window_proc, hwnd, msg, wparam, lparam);
|
|
}
|
|
|
|
auto priv = self->priv;
|
|
switch (msg) {
|
|
case WM_GST_D3D12_CONSTRUCT_INTERNAL_WINDOW:
|
|
{
|
|
GST_DEBUG_OBJECT (self, "Create internal window");
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
if (priv->hwnd) {
|
|
GST_WARNING_OBJECT (self,
|
|
"Window already created, probably we have received 2 creation messages");
|
|
gst_object_unref (self);
|
|
return 0;
|
|
}
|
|
|
|
gst_d3d12_window_create_hwnd (self);
|
|
SetWindowLongPtrW (priv->hwnd, GWL_STYLE, WS_CHILD | WS_MAXIMIZE);
|
|
SetParent (priv->hwnd, priv->external_hwnd);
|
|
|
|
RECT rect;
|
|
GetClientRect (priv->external_hwnd, &rect);
|
|
|
|
if (priv->render_rect.w > 0 && priv->render_rect.h > 0) {
|
|
rect.left = priv->render_rect.x;
|
|
rect.top = priv->render_rect.y;
|
|
rect.right = priv->render_rect.x + priv->render_rect.w;
|
|
rect.bottom = priv->render_rect.y + priv->render_rect.h;
|
|
}
|
|
|
|
SetWindowPos (priv->hwnd, HWND_TOP, rect.left, rect.top,
|
|
rect.right - rect.left, rect.bottom - rect.top,
|
|
SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
|
|
SWP_FRAMECHANGED | SWP_NOACTIVATE);
|
|
MoveWindow (priv->hwnd, rect.left, rect.top,
|
|
rect.right - rect.left, rect.bottom - rect.top, FALSE);
|
|
ShowWindow (priv->hwnd, SW_SHOW);
|
|
|
|
priv->state = GST_D3D12_WINDOW_STATE_OPENED;
|
|
priv->hwnd_cond.notify_all ();
|
|
|
|
/* don't need to be chained up to parent window procedure,
|
|
* as this is our custom message */
|
|
gst_object_unref (self);
|
|
return 0;
|
|
}
|
|
case WM_SYSKEYDOWN:
|
|
{
|
|
WORD state = GetKeyState (VK_RETURN);
|
|
BYTE high = HIBYTE (state);
|
|
|
|
if (high & 0x1) {
|
|
bool do_toggle = false;
|
|
{
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
if (priv->fullscreen_on_alt_enter) {
|
|
priv->requested_fullscreen = !priv->applied_fullscreen;
|
|
do_toggle = true;
|
|
}
|
|
}
|
|
|
|
if (do_toggle)
|
|
gst_d3d12_window_toggle_fullscreen_mode (self, TRUE);
|
|
}
|
|
break;
|
|
}
|
|
case WM_SIZE:
|
|
if (priv->render_rect.w > 0 || priv->render_rect.h > 0) {
|
|
MoveWindow (priv->hwnd,
|
|
priv->render_rect.x, priv->render_rect.y,
|
|
priv->render_rect.w, priv->render_rect.h, FALSE);
|
|
} else {
|
|
MoveWindow (priv->hwnd, 0, 0, LOWORD (lparam), HIWORD (lparam), FALSE);
|
|
}
|
|
break;
|
|
case WM_DESTROY:
|
|
{
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
GST_WARNING_OBJECT (self, "external window is closing");
|
|
|
|
gst_d3d12_window_release_external_hwnd (self);
|
|
|
|
if (priv->hwnd)
|
|
DestroyWindow (priv->hwnd);
|
|
priv->hwnd = nullptr;
|
|
|
|
priv->state = GST_D3D12_WINDOW_STATE_CLOSED;
|
|
priv->hwnd_cond.notify_all ();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
gst_object_unref (self);
|
|
|
|
return CallWindowProcW (external_window_proc, hwnd, msg, wparam, lparam);
|
|
}
|
|
|
|
static gboolean
|
|
msg_io_cb (GIOChannel * source, GIOCondition condition, gpointer data)
|
|
{
|
|
MSG msg;
|
|
|
|
if (!PeekMessage (&msg, nullptr, 0, 0, PM_REMOVE))
|
|
return G_SOURCE_CONTINUE;
|
|
|
|
TranslateMessage (&msg);
|
|
DispatchMessage (&msg);
|
|
|
|
return G_SOURCE_CONTINUE;
|
|
}
|
|
|
|
static gpointer
|
|
gst_d3d12_window_hwnd_thread_func (GstD3D12Window * self)
|
|
{
|
|
auto priv = self->priv;
|
|
|
|
g_main_context_push_thread_default (priv->main_context);
|
|
|
|
gst_d3d12_window_create_hwnd (self);
|
|
priv->state = GST_D3D12_WINDOW_STATE_OPENED;
|
|
|
|
auto msg_io_ch = g_io_channel_win32_new_messages (0);
|
|
auto msg_source = g_io_create_watch (msg_io_ch, G_IO_IN);
|
|
g_source_set_callback (msg_source, (GSourceFunc) msg_io_cb, nullptr, nullptr);
|
|
g_source_attach (msg_source, priv->main_context);
|
|
|
|
auto idle_source = g_idle_source_new ();
|
|
g_source_set_callback (idle_source,[](gpointer data)->gboolean {
|
|
auto self = GST_D3D12_WINDOW (data);
|
|
auto priv = self->priv;
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->hwnd_cond.notify_all ();
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
, self, nullptr);
|
|
|
|
g_source_attach (idle_source, priv->main_context);
|
|
g_source_unref (idle_source);
|
|
|
|
g_main_loop_run (priv->loop);
|
|
|
|
g_clear_pointer (&priv->hwnd, DestroyWindow);
|
|
|
|
g_source_destroy (msg_source);
|
|
g_source_unref (msg_source);
|
|
g_io_channel_unref (msg_io_ch);
|
|
|
|
g_main_context_pop_thread_default (priv->main_context);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_d3d12_window_prepare_hwnd (GstD3D12Window * self, guintptr window_handle)
|
|
{
|
|
auto priv = self->priv;
|
|
|
|
switch (priv->state) {
|
|
case GST_D3D12_WINDOW_STATE_OPENED:
|
|
return GST_FLOW_OK;
|
|
case GST_D3D12_WINDOW_STATE_CLOSED:
|
|
return GST_FLOW_ERROR;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
std::unique_lock < std::mutex > lk (priv->hwnd_lock);
|
|
priv->external_hwnd = (HWND) window_handle;
|
|
if (!priv->external_hwnd) {
|
|
priv->main_loop_thread = g_thread_new ("GstD3D12Window",
|
|
(GThreadFunc) gst_d3d12_window_hwnd_thread_func, self);
|
|
while (!g_main_loop_is_running (priv->loop))
|
|
priv->hwnd_cond.wait (lk);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
if (!IsWindow (priv->external_hwnd)) {
|
|
GST_ERROR_OBJECT (self, "Invalid window handle");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
{
|
|
std::lock_guard < std::mutex > glk (global_hwnd_lock);
|
|
auto external_proc =
|
|
(WNDPROC) GetWindowLongPtrA (priv->external_hwnd, GWLP_WNDPROC);
|
|
|
|
SetPropW (priv->external_hwnd, EXTERNAL_PROC_PROP_NAME,
|
|
(HANDLE) external_proc);
|
|
SetPropW (priv->external_hwnd, D3D12_WINDOW_PROP_NAME, self);
|
|
SetWindowLongPtrW (priv->external_hwnd, GWLP_WNDPROC,
|
|
(LONG_PTR) sub_class_proc);
|
|
}
|
|
|
|
PostMessageW (priv->external_hwnd,
|
|
WM_GST_D3D12_CONSTRUCT_INTERNAL_WINDOW, 0, 0);
|
|
while (priv->external_hwnd &&
|
|
priv->state == GST_D3D12_WINDOW_STATE_INIT && !priv->flushing) {
|
|
priv->hwnd_cond.wait (lk);
|
|
}
|
|
|
|
if (priv->state != GST_D3D12_WINDOW_STATE_OPENED) {
|
|
if (priv->flushing) {
|
|
GST_DEBUG_OBJECT (self, "We are flushing");
|
|
return GST_FLOW_FLUSHING;
|
|
}
|
|
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_unprepare (GstD3D12Window * window)
|
|
{
|
|
GST_DEBUG_OBJECT (window, "Unprepare");
|
|
|
|
auto priv = window->priv;
|
|
|
|
{
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
priv->ctx = nullptr;
|
|
gst_clear_object (&window->device);
|
|
}
|
|
|
|
if (priv->external_hwnd) {
|
|
{
|
|
std::lock_guard < std::mutex > lk (global_hwnd_lock);
|
|
gst_d3d12_window_release_external_hwnd (window);
|
|
}
|
|
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
if (priv->hwnd) {
|
|
if (priv->internal_hwnd_thread == g_thread_self ()) {
|
|
/* State changing thread is identical to internal window thread.
|
|
* window can be closed here */
|
|
|
|
GST_INFO_OBJECT (window, "Closing internal window immediately");
|
|
DestroyWindow (priv->hwnd);
|
|
} else {
|
|
/* We cannot destroy internal window from non-window thread.
|
|
* and we cannot use synchronously SendMessage() method at this point
|
|
* since window thread might be waiting for current thread and SendMessage()
|
|
* will be blocked until it's called from window thread.
|
|
* Instead, posts message so that it can be closed from window thread
|
|
* asynchronously */
|
|
GST_INFO_OBJECT (window, "Posting custom destory message");
|
|
PostMessageW (priv->hwnd, WM_GST_D3D12_DESTROY_INTERNAL_WINDOW, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
g_main_loop_quit (priv->loop);
|
|
g_clear_pointer (&priv->main_loop_thread, g_thread_join);
|
|
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->hwnd = nullptr;
|
|
priv->external_hwnd = nullptr;
|
|
priv->internal_hwnd_thread = nullptr;
|
|
priv->state = GST_D3D12_WINDOW_STATE_INIT;
|
|
priv->applied_fullscreen = FALSE;
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_unlock (GstD3D12Window * window)
|
|
{
|
|
GST_DEBUG_OBJECT (window, "Unlock");
|
|
|
|
auto priv = window->priv;
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->flushing = TRUE;
|
|
priv->hwnd_cond.notify_all ();
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_unlock_stop (GstD3D12Window * window)
|
|
{
|
|
GST_DEBUG_OBJECT (window, "Unlock stop");
|
|
|
|
auto priv = window->priv;
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->flushing = FALSE;
|
|
priv->hwnd_cond.notify_all ();
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_d3d12_window_on_resize (GstD3D12Window * self)
|
|
{
|
|
auto priv = self->priv;
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
|
|
/* resize might be called before swapchain configuration */
|
|
if (!priv->ctx)
|
|
return GST_FLOW_OK;
|
|
|
|
if (priv->ctx->fence_val != 0)
|
|
priv->ctx->WaitGpu ();
|
|
priv->ctx->swap_buffers.clear ();
|
|
gst_clear_buffer (&priv->ctx->msaa_buf);
|
|
|
|
DXGI_SWAP_CHAIN_DESC desc = { };
|
|
priv->ctx->swapchain->GetDesc (&desc);
|
|
auto hr = priv->ctx->swapchain->ResizeBuffers (BACK_BUFFER_COUNT,
|
|
0, 0, priv->display_format, desc.Flags);
|
|
if (!gst_d3d12_result (hr, self->device)) {
|
|
GST_ERROR_OBJECT (self, "Couldn't resize buffers");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
for (guint i = 0; i < BACK_BUFFER_COUNT; i++) {
|
|
ComPtr < ID3D12Resource > backbuf;
|
|
hr = priv->ctx->swapchain->GetBuffer (i, IID_PPV_ARGS (&backbuf));
|
|
if (!gst_d3d12_result (hr, self->device)) {
|
|
GST_ERROR_OBJECT (self, "Couldn't get backbuffer");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
if (i == 0)
|
|
priv->ctx->buffer_desc = backbuf->GetDesc ();
|
|
|
|
auto mem = gst_d3d12_allocator_alloc_wrapped (nullptr, self->device,
|
|
backbuf.Get (), 0);
|
|
auto buf = gst_buffer_new ();
|
|
gst_buffer_append_memory (buf, mem);
|
|
priv->ctx->swap_buffers.push_back (std::make_shared < SwapBuffer > (buf));
|
|
}
|
|
|
|
guint sample_count = 1;
|
|
switch (priv->msaa) {
|
|
case GST_D3D12_MSAA_2X:
|
|
sample_count = 2;
|
|
break;
|
|
case GST_D3D12_MSAA_4X:
|
|
sample_count = 4;
|
|
break;
|
|
case GST_D3D12_MSAA_8X:
|
|
sample_count = 8;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
auto device = gst_d3d12_device_get_device_handle (self->device);
|
|
D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS feature_data = { };
|
|
feature_data.Format = priv->ctx->buffer_desc.Format;
|
|
feature_data.SampleCount = sample_count;
|
|
|
|
while (feature_data.SampleCount > 1) {
|
|
hr = device->CheckFeatureSupport (D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
|
|
&feature_data, sizeof (feature_data));
|
|
if (SUCCEEDED (hr) && feature_data.NumQualityLevels > 0)
|
|
break;
|
|
|
|
feature_data.SampleCount /= 2;
|
|
}
|
|
|
|
if (feature_data.SampleCount > 1 && feature_data.NumQualityLevels > 0) {
|
|
GST_DEBUG_OBJECT (self, "Enable MSAA x%d with quality level %d",
|
|
feature_data.SampleCount, feature_data.NumQualityLevels - 1);
|
|
D3D12_HEAP_PROPERTIES heap_prop =
|
|
CD3DX12_HEAP_PROPERTIES (D3D12_HEAP_TYPE_DEFAULT);
|
|
D3D12_RESOURCE_DESC resource_desc =
|
|
CD3DX12_RESOURCE_DESC::Tex2D (priv->ctx->buffer_desc.Format,
|
|
priv->ctx->buffer_desc.Width, priv->ctx->buffer_desc.Height,
|
|
1, 1, feature_data.SampleCount, feature_data.NumQualityLevels - 1,
|
|
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
|
|
D3D12_CLEAR_VALUE clear_value = { };
|
|
clear_value.Format = priv->ctx->buffer_desc.Format;
|
|
clear_value.Color[0] = 0.0f;
|
|
clear_value.Color[1] = 0.0f;
|
|
clear_value.Color[2] = 0.0f;
|
|
clear_value.Color[3] = 1.0f;
|
|
|
|
ComPtr < ID3D12Resource > msaa_texture;
|
|
hr = device->CreateCommittedResource (&heap_prop, D3D12_HEAP_FLAG_NONE,
|
|
&resource_desc, D3D12_RESOURCE_STATE_RENDER_TARGET, &clear_value,
|
|
IID_PPV_ARGS (&msaa_texture));
|
|
if (!gst_d3d12_result (hr, self->device)) {
|
|
GST_ERROR_OBJECT (self, "Couldn't create MSAA texture");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
auto mem = gst_d3d12_allocator_alloc_wrapped (nullptr, self->device,
|
|
msaa_texture.Get (), 0);
|
|
priv->ctx->msaa_buf = gst_buffer_new ();
|
|
gst_buffer_append_memory (priv->ctx->msaa_buf, mem);
|
|
}
|
|
|
|
priv->first_present = TRUE;
|
|
priv->backbuf_rendered = FALSE;
|
|
|
|
/* redraw the last scene if cached buffer exits */
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
if (priv->ctx->cached_buf) {
|
|
ret = gst_d3d12_window_set_buffer (self, priv->ctx->cached_buf);
|
|
if (ret == GST_FLOW_OK)
|
|
ret = gst_d3d12_window_present (self);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
GstFlowReturn
|
|
gst_d3d12_window_prepare (GstD3D12Window * window, GstD3D12Device * device,
|
|
guintptr window_handle, guint display_width, guint display_height,
|
|
GstCaps * caps, GstStructure * config)
|
|
{
|
|
auto priv = window->priv;
|
|
GstVideoInfo in_info;
|
|
GstVideoFormat format = GST_VIDEO_FORMAT_RGBA;
|
|
priv->display_format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
gst_video_info_from_caps (&in_info, caps);
|
|
|
|
if (GST_VIDEO_INFO_COMP_DEPTH (&in_info, 0) > 8) {
|
|
auto device_handle = gst_d3d12_device_get_device_handle (device);
|
|
D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support = { };
|
|
const D3D12_FORMAT_SUPPORT1 support_flags =
|
|
D3D12_FORMAT_SUPPORT1_RENDER_TARGET | D3D12_FORMAT_SUPPORT1_DISPLAY;
|
|
format_support.Format = DXGI_FORMAT_R10G10B10A2_UNORM;
|
|
format_support.Support1 = support_flags;
|
|
auto hr = device_handle->CheckFeatureSupport (D3D12_FEATURE_FORMAT_SUPPORT,
|
|
&format_support, sizeof (format_support));
|
|
if (SUCCEEDED (hr) && (format_support.Support1 & support_flags)
|
|
== support_flags) {
|
|
priv->display_format = DXGI_FORMAT_R10G10B10A2_UNORM;
|
|
format = GST_VIDEO_FORMAT_RGB10A2_LE;
|
|
}
|
|
}
|
|
|
|
{
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
gst_video_info_set_format (&priv->display_info, format,
|
|
display_width, display_height);
|
|
}
|
|
|
|
auto ret = gst_d3d12_window_prepare_hwnd (window, window_handle);
|
|
if (ret != GST_FLOW_OK) {
|
|
GST_WARNING_OBJECT (window, "Couldn't setup window handle");
|
|
if (config)
|
|
gst_structure_free (config);
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::unique_lock < std::recursive_mutex > lk (priv->lock);
|
|
HRESULT hr;
|
|
|
|
if (window->device != device) {
|
|
priv->ctx = nullptr;
|
|
gst_clear_object (&window->device);
|
|
window->device = (GstD3D12Device *) gst_object_ref (device);
|
|
}
|
|
|
|
if (!priv->ctx) {
|
|
auto ctx = std::make_unique < DeviceContext > (device);
|
|
if (!ctx->initialized) {
|
|
GST_ERROR_OBJECT (window, "Couldn't initialize device context");
|
|
if (config)
|
|
gst_structure_free (config);
|
|
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
DXGI_SWAP_CHAIN_DESC1 desc = { };
|
|
desc.Format = priv->display_format;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
|
|
desc.BufferCount = BACK_BUFFER_COUNT;
|
|
desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
|
|
|
|
auto factory = gst_d3d12_device_get_factory_handle (device);
|
|
|
|
ComPtr < ID3D12CommandQueue > cq;
|
|
gst_d3d12_command_queue_get_handle (ctx->queue, &cq);
|
|
|
|
ComPtr < IDXGISwapChain1 > swapchain;
|
|
hr = factory->CreateSwapChainForHwnd (cq.Get (), priv->hwnd,
|
|
&desc, nullptr, nullptr, &swapchain);
|
|
if (!gst_d3d12_result (hr, window->device)) {
|
|
GST_ERROR_OBJECT (window, "Couldn't create swapchain");
|
|
if (config)
|
|
gst_structure_free (config);
|
|
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
ComPtr < IDXGIFactory1 > parent_factory;
|
|
hr = swapchain->GetParent (IID_PPV_ARGS (&parent_factory));
|
|
if (!gst_d3d12_result (hr, window->device)) {
|
|
GST_WARNING_OBJECT (window, "Couldn't get parent factory");
|
|
} else {
|
|
hr = parent_factory->MakeWindowAssociation (priv->hwnd,
|
|
DXGI_MWA_NO_ALT_ENTER);
|
|
if (!gst_d3d12_result (hr, window->device)) {
|
|
GST_WARNING_OBJECT (window, "MakeWindowAssociation failed, hr: 0x%x",
|
|
(guint) hr);
|
|
}
|
|
}
|
|
|
|
hr = swapchain.As (&ctx->swapchain);
|
|
if (!gst_d3d12_result (hr, window->device)) {
|
|
GST_ERROR_OBJECT (window, "IDXGISwapChain4 interface is unavailable");
|
|
if (config)
|
|
gst_structure_free (config);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
priv->ctx = std::move (ctx);
|
|
} else {
|
|
priv->ctx->WaitGpu ();
|
|
}
|
|
|
|
priv->input_info = in_info;
|
|
priv->crop_rect = CD3DX12_BOX (0, 0, in_info.width, in_info.height);
|
|
priv->prev_crop_rect = priv->crop_rect;
|
|
|
|
gst_clear_object (&priv->ctx->conv);
|
|
gst_clear_object (&priv->ctx->comp);
|
|
gst_clear_buffer (&priv->ctx->cached_buf);
|
|
|
|
if (GST_VIDEO_INFO_HAS_ALPHA (&in_info)) {
|
|
gst_structure_set (config, GST_D3D12_CONVERTER_OPT_DEST_ALPHA_MODE,
|
|
GST_TYPE_D3D12_CONVERTER_ALPHA_MODE,
|
|
GST_D3D12_CONVERTER_ALPHA_MODE_PREMULTIPLIED, nullptr);
|
|
}
|
|
|
|
priv->ctx->conv = gst_d3d12_converter_new (window->device,
|
|
&priv->input_info, &priv->display_info, nullptr, nullptr, config);
|
|
if (!priv->ctx->conv) {
|
|
GST_ERROR_OBJECT (window, "Couldn't create converter");
|
|
priv->ctx = nullptr;
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
priv->ctx->comp = gst_d3d12_overlay_compositor_new (window->device,
|
|
&priv->display_info);
|
|
if (!priv->ctx->comp) {
|
|
GST_ERROR_OBJECT (window, "Couldn't create overlay compositor");
|
|
priv->ctx = nullptr;
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
ret = gst_d3d12_window_on_resize (window);
|
|
if (ret != GST_FLOW_OK)
|
|
return ret;
|
|
|
|
lk.unlock ();
|
|
|
|
std::lock_guard < std::mutex > hlk (priv->hwnd_lock);
|
|
if (priv->requested_fullscreen != priv->applied_fullscreen)
|
|
PostMessageW (priv->hwnd, WM_GST_D3D12_FULLSCREEN, 0, 0);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
GstFlowReturn
|
|
gst_d3d12_window_set_buffer (GstD3D12Window * window, GstBuffer * buffer)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
if (buffer && priv->state != GST_D3D12_WINDOW_STATE_OPENED) {
|
|
GST_ERROR_OBJECT (window, "Window was closed");
|
|
return GST_D3D12_WINDOW_FLOW_CLOSED;
|
|
}
|
|
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
if (!priv->ctx) {
|
|
if (!buffer) {
|
|
GST_DEBUG_OBJECT (window, "Swapchain was not configured");
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
GST_ERROR_OBJECT (window, "Swapchain was not configured");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
if (buffer)
|
|
gst_buffer_replace (&priv->ctx->cached_buf, buffer);
|
|
|
|
if (!priv->ctx->cached_buf)
|
|
return GST_FLOW_OK;
|
|
|
|
auto cur_idx = priv->ctx->swapchain->GetCurrentBackBufferIndex ();
|
|
auto swapbuf = priv->ctx->swap_buffers[cur_idx];
|
|
|
|
auto crop_rect = priv->crop_rect;
|
|
auto crop_meta = gst_buffer_get_video_crop_meta (priv->ctx->cached_buf);
|
|
if (crop_meta) {
|
|
crop_rect = CD3DX12_BOX (crop_meta->x, crop_meta->y,
|
|
crop_meta->x + crop_meta->width, crop_meta->y + crop_meta->height);
|
|
}
|
|
|
|
if (crop_rect != priv->prev_crop_rect) {
|
|
g_object_set (priv->ctx->conv, "src-x", (gint) crop_rect.left,
|
|
"src-y", (gint) crop_rect.top,
|
|
"src-width", (gint) (crop_rect.right - crop_rect.left),
|
|
"src-height", (gint) (crop_rect.bottom - crop_rect.top), nullptr);
|
|
priv->prev_crop_rect = crop_rect;
|
|
}
|
|
|
|
if (priv->first_present) {
|
|
GstVideoRectangle dst_rect = { };
|
|
GstVideoRectangle rst_rect = { };
|
|
dst_rect.w = (gint) priv->ctx->buffer_desc.Width;
|
|
dst_rect.h = (gint) priv->ctx->buffer_desc.Height;
|
|
|
|
for (size_t i = 0; i < priv->ctx->swap_buffers.size (); i++)
|
|
priv->ctx->swap_buffers[i]->first = true;
|
|
|
|
if (priv->force_aspect_ratio) {
|
|
GstVideoRectangle src_rect = { };
|
|
|
|
switch (priv->orientation) {
|
|
case GST_VIDEO_ORIENTATION_90R:
|
|
case GST_VIDEO_ORIENTATION_90L:
|
|
case GST_VIDEO_ORIENTATION_UL_LR:
|
|
case GST_VIDEO_ORIENTATION_UR_LL:
|
|
src_rect.w = GST_VIDEO_INFO_HEIGHT (&priv->display_info);
|
|
src_rect.h = GST_VIDEO_INFO_WIDTH (&priv->display_info);
|
|
break;
|
|
default:
|
|
src_rect.w = GST_VIDEO_INFO_WIDTH (&priv->display_info);
|
|
src_rect.h = GST_VIDEO_INFO_HEIGHT (&priv->display_info);
|
|
break;
|
|
}
|
|
|
|
gst_video_sink_center_rect (src_rect, dst_rect, &rst_rect, TRUE);
|
|
} else {
|
|
rst_rect = dst_rect;
|
|
}
|
|
|
|
priv->output_rect = rst_rect;
|
|
priv->dirty_rect.left = rst_rect.x;
|
|
priv->dirty_rect.top = rst_rect.y;
|
|
priv->dirty_rect.right = rst_rect.x + rst_rect.w;
|
|
priv->dirty_rect.bottom = rst_rect.y + rst_rect.h;
|
|
|
|
g_object_set (priv->ctx->conv, "dest-x", priv->output_rect.x,
|
|
"dest-y", priv->output_rect.y, "dest-width", priv->output_rect.w,
|
|
"dest-height", priv->output_rect.h, nullptr);
|
|
|
|
if (gst_d3d12_need_transform (priv->rotation_x, priv->rotation_y,
|
|
priv->rotation_z, priv->scale_x, priv->scale_y)) {
|
|
gst_d3d12_converter_apply_transform (priv->ctx->conv, priv->orientation,
|
|
priv->output_rect.w, priv->output_rect.h, priv->fov, priv->ortho,
|
|
priv->rotation_x, priv->rotation_y, priv->rotation_z,
|
|
priv->scale_x, priv->scale_y);
|
|
} else {
|
|
g_object_set (priv->ctx->conv,
|
|
"video-direction", priv->orientation, nullptr);
|
|
}
|
|
|
|
gst_d3d12_overlay_compositor_update_viewport (priv->ctx->comp,
|
|
&priv->output_rect);
|
|
}
|
|
|
|
g_object_set (priv->ctx->conv, "fill-border", swapbuf->first, nullptr);
|
|
swapbuf->first = FALSE;
|
|
|
|
gst_d3d12_overlay_compositor_upload (priv->ctx->comp, priv->ctx->cached_buf);
|
|
|
|
GstD3D12CommandAllocator *gst_ca;
|
|
if (!gst_d3d12_command_allocator_pool_acquire (priv->ctx->ca_pool, &gst_ca)) {
|
|
GST_ERROR_OBJECT (window, "Couldn't acquire command allocator");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
ComPtr < ID3D12CommandAllocator > ca;
|
|
gst_d3d12_command_allocator_get_handle (gst_ca, &ca);
|
|
auto hr = ca->Reset ();
|
|
if (!gst_d3d12_result (hr, window->device)) {
|
|
GST_ERROR_OBJECT (window, "Couldn't reset command list");
|
|
gst_d3d12_command_allocator_unref (gst_ca);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
ComPtr < ID3D12GraphicsCommandList > cl;
|
|
if (!priv->ctx->cl) {
|
|
auto device = gst_d3d12_device_get_device_handle (priv->ctx->device);
|
|
hr = device->CreateCommandList (0, D3D12_COMMAND_LIST_TYPE_DIRECT,
|
|
ca.Get (), nullptr, IID_PPV_ARGS (&cl));
|
|
if (!gst_d3d12_result (hr, priv->ctx->device)) {
|
|
GST_ERROR_OBJECT (window, "Couldn't create command list");
|
|
gst_d3d12_command_allocator_unref (gst_ca);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
priv->ctx->cl = cl;
|
|
} else {
|
|
cl = priv->ctx->cl;
|
|
hr = cl->Reset (ca.Get (), nullptr);
|
|
if (!gst_d3d12_result (hr, priv->ctx->device)) {
|
|
GST_ERROR_OBJECT (window, "Couldn't reset command list");
|
|
gst_d3d12_command_allocator_unref (gst_ca);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
GstD3D12FenceData *fence_data;
|
|
gst_d3d12_fence_data_pool_acquire (priv->fence_data_pool, &fence_data);
|
|
gst_d3d12_fence_data_add_notify_mini_object (fence_data, gst_ca);
|
|
|
|
auto mem = (GstD3D12Memory *) gst_buffer_peek_memory (swapbuf->backbuf, 0);
|
|
auto backbuf_texture = gst_d3d12_memory_get_resource_handle (mem);
|
|
ID3D12Resource *msaa_resource = nullptr;
|
|
GstBuffer *conv_outbuf = swapbuf->backbuf;
|
|
if (priv->ctx->msaa_buf) {
|
|
conv_outbuf = priv->ctx->msaa_buf;
|
|
mem = (GstD3D12Memory *) gst_buffer_peek_memory (priv->ctx->msaa_buf, 0);
|
|
msaa_resource = gst_d3d12_memory_get_resource_handle (mem);
|
|
/* MSAA resource must be render target state here already */
|
|
} else {
|
|
D3D12_RESOURCE_BARRIER barrier =
|
|
CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
|
|
D3D12_RESOURCE_STATE_COMMON,
|
|
D3D12_RESOURCE_STATE_RENDER_TARGET);
|
|
cl->ResourceBarrier (1, &barrier);
|
|
}
|
|
|
|
if (!gst_d3d12_converter_convert_buffer (priv->ctx->conv,
|
|
priv->ctx->cached_buf, conv_outbuf, fence_data, cl.Get ())) {
|
|
GST_ERROR_OBJECT (window, "Couldn't build convert command");
|
|
gst_d3d12_fence_data_unref (fence_data);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
if (!gst_d3d12_overlay_compositor_draw (priv->ctx->comp,
|
|
conv_outbuf, fence_data, cl.Get ())) {
|
|
GST_ERROR_OBJECT (window, "Couldn't build overlay command");
|
|
gst_d3d12_fence_data_unref (fence_data);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
if (msaa_resource) {
|
|
std::vector < D3D12_RESOURCE_BARRIER > barriers;
|
|
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (msaa_resource,
|
|
D3D12_RESOURCE_STATE_RENDER_TARGET,
|
|
D3D12_RESOURCE_STATE_RESOLVE_SOURCE));
|
|
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
|
|
D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_RESOLVE_DEST));
|
|
cl->ResourceBarrier (barriers.size (), barriers.data ());
|
|
|
|
cl->ResolveSubresource (backbuf_texture, 0, msaa_resource, 0,
|
|
priv->display_format);
|
|
|
|
barriers.clear ();
|
|
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (msaa_resource,
|
|
D3D12_RESOURCE_STATE_RESOLVE_SOURCE,
|
|
D3D12_RESOURCE_STATE_RENDER_TARGET));
|
|
barriers.push_back (CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
|
|
D3D12_RESOURCE_STATE_RESOLVE_DEST, D3D12_RESOURCE_STATE_COMMON));
|
|
cl->ResourceBarrier (barriers.size (), barriers.data ());
|
|
} else {
|
|
D3D12_RESOURCE_BARRIER barrier =
|
|
CD3DX12_RESOURCE_BARRIER::Transition (backbuf_texture,
|
|
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COMMON);
|
|
|
|
cl->ResourceBarrier (1, &barrier);
|
|
}
|
|
|
|
hr = cl->Close ();
|
|
if (!gst_d3d12_result (hr, priv->ctx->device)) {
|
|
GST_ERROR_OBJECT (window, "Couldn't close command list");
|
|
gst_d3d12_fence_data_unref (fence_data);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
guint64 max_fence_val = 0;
|
|
auto num_mem = gst_buffer_n_memory (priv->ctx->cached_buf);
|
|
for (guint i = 0; i < num_mem; i++) {
|
|
mem = (GstD3D12Memory *) gst_buffer_peek_memory (priv->ctx->cached_buf, 0);
|
|
if (mem->fence_value > max_fence_val)
|
|
max_fence_val = mem->fence_value;
|
|
}
|
|
|
|
auto completed = gst_d3d12_device_get_completed_value (priv->ctx->device,
|
|
D3D12_COMMAND_LIST_TYPE_DIRECT);
|
|
|
|
if (completed < max_fence_val) {
|
|
auto device_queue = gst_d3d12_device_get_command_queue (priv->ctx->device,
|
|
D3D12_COMMAND_LIST_TYPE_DIRECT);
|
|
ComPtr < ID3D12Fence > fence;
|
|
gst_d3d12_command_queue_get_fence (device_queue, &fence);
|
|
gst_d3d12_command_queue_execute_wait (priv->ctx->queue, fence.Get (),
|
|
max_fence_val);
|
|
}
|
|
|
|
ID3D12CommandList *cmd_list[] = { cl.Get () };
|
|
hr = gst_d3d12_command_queue_execute_command_lists (priv->ctx->queue,
|
|
1, cmd_list, &priv->ctx->fence_val);
|
|
if (!gst_d3d12_result (hr, priv->ctx->device)) {
|
|
GST_ERROR_OBJECT (window, "Signal failed");
|
|
gst_d3d12_fence_data_unref (fence_data);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
gst_d3d12_command_queue_set_notify (priv->ctx->queue, priv->ctx->fence_val,
|
|
fence_data, (GDestroyNotify) gst_d3d12_fence_data_unref);
|
|
|
|
priv->backbuf_rendered = TRUE;
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
GstFlowReturn
|
|
gst_d3d12_window_present (GstD3D12Window * window)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
if (priv->state != GST_D3D12_WINDOW_STATE_OPENED) {
|
|
GST_ERROR_OBJECT (window, "Window was closed");
|
|
return GST_D3D12_WINDOW_FLOW_CLOSED;
|
|
}
|
|
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
if (!priv->ctx) {
|
|
GST_ERROR_OBJECT (window, "Swapchain was not configured");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
if (priv->backbuf_rendered) {
|
|
DXGI_PRESENT_PARAMETERS params = { };
|
|
|
|
if (!priv->first_present) {
|
|
params.DirtyRectsCount = 1;
|
|
params.pDirtyRects = &priv->dirty_rect;
|
|
}
|
|
|
|
auto hr = priv->ctx->swapchain->Present1 (0,
|
|
DXGI_PRESENT_DO_NOT_WAIT, ¶ms);
|
|
|
|
priv->first_present = FALSE;
|
|
priv->backbuf_rendered = FALSE;
|
|
if (hr != DXGI_ERROR_WAS_STILL_DRAWING &&
|
|
!gst_d3d12_result (hr, window->device))
|
|
GST_WARNING_OBJECT (window, "Present return 0x%x", (guint) hr);
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
guintptr
|
|
gst_d3d12_window_get_window_handle (GstD3D12Window * window)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
return (guintptr) priv->hwnd;
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_render_rect (GstD3D12Window * window,
|
|
const GstVideoRectangle * rect)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
{
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->render_rect = *rect;
|
|
}
|
|
|
|
if (priv->hwnd) {
|
|
PostMessageW (priv->hwnd, WM_GST_D3D12_UPDATE_RENDER_RECT, 0, 0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_force_aspect_ratio (GstD3D12Window * window,
|
|
gboolean force_aspect_ratio)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
if (priv->force_aspect_ratio != force_aspect_ratio) {
|
|
priv->force_aspect_ratio = force_aspect_ratio;
|
|
gst_d3d12_window_on_resize (window);
|
|
}
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_enable_navigation_events (GstD3D12Window * window,
|
|
gboolean enable)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
priv->enable_navigation = enable;
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_orientation (GstD3D12Window * window, gboolean immediate,
|
|
GstVideoOrientationMethod orientation, gfloat fov, gboolean ortho,
|
|
gfloat rotation_x, gfloat rotation_y, gfloat rotation_z,
|
|
gfloat scale_x, gfloat scale_y)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
if (priv->orientation != orientation || priv->fov != fov
|
|
|| priv->ortho != ortho
|
|
|| priv->rotation_x != rotation_x || priv->rotation_y != rotation_y
|
|
|| priv->rotation_z != rotation_z || priv->scale_x != scale_x
|
|
|| priv->scale_y != scale_y) {
|
|
priv->orientation = orientation;
|
|
priv->fov = fov;
|
|
priv->ortho = ortho;
|
|
priv->rotation_x = rotation_x;
|
|
priv->rotation_y = rotation_y;
|
|
priv->rotation_z = rotation_z;
|
|
priv->scale_x = scale_x;
|
|
priv->scale_y = scale_y;
|
|
priv->first_present = TRUE;
|
|
if (immediate)
|
|
gst_d3d12_window_set_buffer (window, nullptr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_title (GstD3D12Window * window, const gchar * title)
|
|
{
|
|
auto priv = window->priv;
|
|
wchar_t *wtitle = nullptr;
|
|
|
|
if (title)
|
|
wtitle = (wchar_t *) g_utf8_to_utf16 (title, -1, nullptr, nullptr, nullptr);
|
|
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
if (!wtitle) {
|
|
priv->title.clear ();
|
|
} else {
|
|
priv->title = wtitle;
|
|
}
|
|
g_free (wtitle);
|
|
}
|
|
|
|
GstD3D12Window *
|
|
gst_d3d12_window_new (void)
|
|
{
|
|
auto self = (GstD3D12Window *) g_object_new (GST_TYPE_D3D12_WINDOW, nullptr);
|
|
gst_object_ref_sink (self);
|
|
|
|
return self;
|
|
}
|
|
|
|
GstD3D12WindowState
|
|
gst_d3d12_window_get_state (GstD3D12Window * window)
|
|
{
|
|
auto priv = window->priv;
|
|
|
|
return priv->state;
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_enable_fullscreen_on_alt_enter (GstD3D12Window * window,
|
|
gboolean enable)
|
|
{
|
|
auto priv = window->priv;
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->fullscreen_on_alt_enter = enable;
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_fullscreen (GstD3D12Window * window, gboolean enable)
|
|
{
|
|
auto priv = window->priv;
|
|
std::lock_guard < std::mutex > lk (priv->hwnd_lock);
|
|
priv->requested_fullscreen = enable;
|
|
if (priv->hwnd && priv->applied_fullscreen != priv->requested_fullscreen)
|
|
PostMessageW (priv->hwnd, WM_GST_D3D12_FULLSCREEN, 0, 0);
|
|
}
|
|
|
|
void
|
|
gst_d3d12_window_set_msaa (GstD3D12Window * window, GstD3D12MSAAMode msaa)
|
|
{
|
|
auto priv = window->priv;
|
|
std::lock_guard < std::recursive_mutex > lk (priv->lock);
|
|
if (priv->msaa != msaa) {
|
|
priv->msaa = msaa;
|
|
gst_d3d12_window_on_resize (window);
|
|
}
|
|
}
|