diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11.h b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11.h index 5ba4e5a240..decbfe712b 100644 --- a/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11.h +++ b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11.h @@ -28,9 +28,10 @@ #include #include #include -#include -#include #include -#include +#include +#include #include +#include +#include diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11compile.cpp b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11compile.cpp new file mode 100644 index 0000000000..144cb0ca14 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11compile.cpp @@ -0,0 +1,309 @@ +/* GStreamer + * Copyright (C) 2022 Seungha Yang + * + * 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 "gstd3d11compile.h" +#include "gstd3d11device.h" +#include "gstd3d11utils.h" +#include +#include +#include + +/* *INDENT-OFF* */ +using namespace Microsoft::WRL; +/* *INDENT-ON* */ + +#ifndef GST_DISABLE_GST_DEBUG +#define GST_CAT_DEFAULT ensure_debug_category() +static GstDebugCategory * +ensure_debug_category (void) +{ + static gsize cat_gonce = 0; + + if (g_once_init_enter (&cat_gonce)) { + gsize cat_done; + + cat_done = (gsize) _gst_debug_category_new ("d3d11compile", 0, + "d3d11compile"); + + g_once_init_leave (&cat_gonce, cat_done); + } + + return (GstDebugCategory *) cat_gonce; +} +#else +#define ensure_debug_category() /* NOOP */ +#endif /* GST_DISABLE_GST_DEBUG */ + +static GModule *d3d_compiler_module = nullptr; +static pD3DCompile GstD3DCompileFunc = nullptr; + +/** + * gst_d3d11_compile_init: + * + * Loads HLSL compiler library + * + * Returns: %TRUE if HLSL compiler library is available + */ +gboolean +gst_d3d11_compile_init (void) +{ + static gsize init_once = 0; + + if (g_once_init_enter (&init_once)) { +#if GST_D3D11_WINAPI_ONLY_APP + /* Assuming that d3d compiler library is available */ + GstD3DCompileFunc = D3DCompile; +#else + static const gchar *d3d_compiler_names[] = { + "d3dcompiler_47.dll", + "d3dcompiler_46.dll", + "d3dcompiler_45.dll", + "d3dcompiler_44.dll", + "d3dcompiler_43.dll", + }; + for (guint i = 0; i < G_N_ELEMENTS (d3d_compiler_names); i++) { + d3d_compiler_module = + g_module_open (d3d_compiler_names[i], G_MODULE_BIND_LAZY); + + if (d3d_compiler_module) { + GST_INFO ("D3D compiler %s is available", d3d_compiler_names[i]); + if (!g_module_symbol (d3d_compiler_module, "D3DCompile", + (gpointer *) & GstD3DCompileFunc)) { + GST_ERROR ("Cannot load D3DCompile symbol from %s", + d3d_compiler_names[i]); + g_module_close (d3d_compiler_module); + d3d_compiler_module = nullptr; + GstD3DCompileFunc = nullptr; + } else { + break; + } + } + } + + if (!GstD3DCompileFunc) + GST_WARNING ("D3D11 compiler library is unavailable"); +#endif + + g_once_init_leave (&init_once, 1); + } + + if (!GstD3DCompileFunc) + return FALSE; + + return TRUE; +} + +/** + * gst_d3d11_compile: + * @src_data: source data to compile + * @src_data_size: length of src_data + * @source_name: (nullable): used for strings that specify error messages + * @defines: (nullable): null-terminated array of D3D_SHADER_MACRO struct that defines shader macros + * @include: (nullable): a ID3DInclude + * @entry_point: (nullable): the name of entry point function + * @target: a string specifies the shader target + * @flags1: flags defined by D3DCOMPILE constants + * @flags2: flags defined by D3DCOMPILE_EFFECT constants + * @code: (out) (optional): a compiled code + * @error_msgs: (out) (optional) (nullable): compiler error messages + * + * Compiles HLSL code or an effect file into bytecode for a given target + * + * Returns: HRESULT return code + */ +HRESULT +gst_d3d11_compile (LPCVOID src_data, SIZE_T src_data_size, LPCSTR source_name, + CONST D3D_SHADER_MACRO * defines, ID3DInclude * include, LPCSTR entry_point, + LPCSTR target, UINT flags1, UINT flags2, ID3DBlob ** code, + ID3DBlob ** error_msgs) +{ + if (!gst_d3d11_compile_init ()) + return E_FAIL; + + return GstD3DCompileFunc (src_data, src_data_size, source_name, defines, + include, entry_point, target, flags1, flags2, code, error_msgs); +} + +/** + * gst_d3d11_create_pixel_shader_simple: + * @device: a #GstD3D11Device + * @source: a pixel shader code to compile + * @entry_point: the name of entry point function + * @shader: (out): a ID3D11PixelShader + + * Compiles pixel shader code and creates ID3D11PixelShader + * + * Returns: HRESULT return code + */ +HRESULT +gst_d3d11_create_pixel_shader_simple (GstD3D11Device * device, + const gchar * source, const gchar * entry_point, + ID3D11PixelShader ** shader) +{ + ID3D11Device *device_handle; + HRESULT hr; + ComPtr < ID3DBlob > ps_blob; + ComPtr < ID3DBlob > error_msg; + D3D_FEATURE_LEVEL feature_level; + const gchar *target; + + g_return_val_if_fail (GST_IS_D3D11_DEVICE (device), E_INVALIDARG); + g_return_val_if_fail (source != nullptr, E_INVALIDARG); + g_return_val_if_fail (entry_point != nullptr, E_INVALIDARG); + g_return_val_if_fail (shader != nullptr, E_INVALIDARG); + + device_handle = gst_d3d11_device_get_device_handle (device); + feature_level = device_handle->GetFeatureLevel (); + + if (feature_level >= D3D_FEATURE_LEVEL_11_0) + target = "ps_5_0"; + else if (feature_level >= D3D_FEATURE_LEVEL_10_0) + target = "ps_4_0"; + else if (feature_level >= D3D_FEATURE_LEVEL_9_3) + target = "ps_4_0_level_9_3"; + else + target = "ps_4_0_level_9_1"; + + GST_DEBUG_OBJECT (device, "Compile code\n%s", source); + + hr = gst_d3d11_compile (source, strlen (source), nullptr, nullptr, nullptr, + entry_point, target, 0, 0, &ps_blob, &error_msg); + + if (!gst_d3d11_result (hr, device)) { + const gchar *err = nullptr; + + if (error_msg) + err = (const gchar *) error_msg->GetBufferPointer (); + + GST_ERROR_OBJECT (device, + "Couldn't compile code, hr: 0x%x, error detail: %s, source code: \n%s", + (guint) hr, GST_STR_NULL (err), source); + + return hr; + } + + if (error_msg) { + const gchar *err = (const gchar *) error_msg->GetBufferPointer (); + + GST_DEBUG_OBJECT (device, "HLSL compiler warning %s, shader code %s", + GST_STR_NULL (err), source); + } + + return device_handle->CreatePixelShader (ps_blob->GetBufferPointer (), + ps_blob->GetBufferSize (), nullptr, shader); +} + +/** + * gst_d3d11_create_vertex_shader_simple: + * @device: a #GstD3D11Device + * @source: a vertex shader code to compile + * @entry_point: the name of entry point function + * @input_desc: an array of D3D11_INPUT_ELEMENT_DESC + * @desc_len: length of input_desc + * @shader: (out): a ID3D11VertexShader + * @layout: (out): a ID3D11InputLayout + + * Compiles vertex shader code and creates ID3D11VertexShader and + * ID3D11InputLayout + * + * Returns: HRESULT return code + */ +HRESULT +gst_d3d11_create_vertex_shader_simple (GstD3D11Device * device, + const gchar * source, const gchar * entry_point, + const D3D11_INPUT_ELEMENT_DESC * input_desc, guint desc_len, + ID3D11VertexShader ** shader, ID3D11InputLayout ** layout) +{ + ID3D11Device *device_handle; + HRESULT hr; + ComPtr < ID3DBlob > vs_blob; + ComPtr < ID3DBlob > error_msg; + ComPtr < ID3D11VertexShader > vs; + ComPtr < ID3D11InputLayout > input_layout; + D3D_FEATURE_LEVEL feature_level; + const gchar *target; + + g_return_val_if_fail (GST_IS_D3D11_DEVICE (device), E_INVALIDARG); + g_return_val_if_fail (source != nullptr, E_INVALIDARG); + g_return_val_if_fail (entry_point != nullptr, E_INVALIDARG); + g_return_val_if_fail (input_desc != nullptr, E_INVALIDARG); + g_return_val_if_fail (desc_len > 0, E_INVALIDARG); + g_return_val_if_fail (shader != nullptr, E_INVALIDARG); + g_return_val_if_fail (layout != nullptr, E_INVALIDARG); + + device_handle = gst_d3d11_device_get_device_handle (device); + feature_level = device_handle->GetFeatureLevel (); + + if (feature_level >= D3D_FEATURE_LEVEL_11_0) + target = "vs_5_0"; + else if (feature_level >= D3D_FEATURE_LEVEL_10_0) + target = "vs_4_0"; + else if (feature_level >= D3D_FEATURE_LEVEL_9_3) + target = "vs_4_0_level_9_3"; + else + target = "vs_4_0_level_9_1"; + + GST_DEBUG_OBJECT (device, "Compile code\n%s", source); + + hr = gst_d3d11_compile (source, strlen (source), nullptr, nullptr, nullptr, + entry_point, target, 0, 0, &vs_blob, &error_msg); + + if (!gst_d3d11_result (hr, device)) { + const gchar *err = nullptr; + + if (error_msg) + err = (const gchar *) error_msg->GetBufferPointer (); + + GST_ERROR_OBJECT (device, + "Couldn't compile code, hr: 0x%x, error detail: %s, source code: \n%s", + (guint) hr, GST_STR_NULL (err), source); + + return hr; + } + + if (error_msg) { + const gchar *err = (const gchar *) error_msg->GetBufferPointer (); + + GST_DEBUG_OBJECT (device, "HLSL compiler warning %s, shader code %s", + GST_STR_NULL (err), source); + } + + hr = device_handle->CreateVertexShader (vs_blob->GetBufferPointer (), + vs_blob->GetBufferSize (), nullptr, &vs); + if (!gst_d3d11_result (hr, device)) { + GST_ERROR_OBJECT (device, "Couldn't create vertex shader"); + return hr; + } + + hr = device_handle->CreateInputLayout (input_desc, desc_len, + vs_blob->GetBufferPointer (), vs_blob->GetBufferSize (), &input_layout); + if (!gst_d3d11_result (hr, device)) { + GST_ERROR_OBJECT (device, "Couldn't create input layout"); + return hr; + } + + *shader = vs.Detach (); + *layout = input_layout.Detach (); + + return hr; +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11compile.h b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11compile.h new file mode 100644 index 0000000000..1e643507d9 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11compile.h @@ -0,0 +1,59 @@ +/* GStreamer + * Copyright (C) 2022 Seungha Yang + * + * 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. + */ + +#pragma once + +#include +#include +#include + +G_BEGIN_DECLS + +GST_D3D11_API +gboolean gst_d3d11_compile_init (void); + +GST_D3D11_API +HRESULT gst_d3d11_compile (LPCVOID src_data, + SIZE_T src_data_size, + LPCSTR source_name, + CONST D3D_SHADER_MACRO * defines, + ID3DInclude * include, + LPCSTR entry_point, + LPCSTR target, + UINT flags1, + UINT flags2, + ID3DBlob ** code, + ID3DBlob ** error_msgs); + +GST_D3D11_API +HRESULT gst_d3d11_create_pixel_shader_simple (GstD3D11Device * device, + const gchar * source, + const gchar * entry_point, + ID3D11PixelShader ** shader); + +GST_D3D11_API +HRESULT gst_d3d11_create_vertex_shader_simple (GstD3D11Device * device, + const gchar * source, + const gchar * entry_point, + const D3D11_INPUT_ELEMENT_DESC * input_desc, + guint desc_len, + ID3D11VertexShader ** shader, + ID3D11InputLayout ** layout); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/meson.build b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/meson.build index 033151fe56..97abce2194 100644 --- a/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/meson.build +++ b/subprojects/gst-plugins-bad/gst-libs/gst/d3d11/meson.build @@ -1,5 +1,6 @@ d3d11_sources = [ 'gstd3d11bufferpool.cpp', + 'gstd3d11compile.cpp', 'gstd3d11device.cpp', 'gstd3d11format.cpp', 'gstd3d11memory.cpp', @@ -51,10 +52,22 @@ dxgi_lib = cc.find_library('dxgi', required : false) d3dcompiler_lib = cc.find_library('d3dcompiler', required: false) runtimeobject_lib = cc.find_library('runtimeobject', required : false) -if not d3d11_lib.found() or not dxgi_lib.found() or not cc.has_header('d3d11_4.h') or not cc.has_header('dxgi1_6.h') +if not d3d11_lib.found() or not dxgi_lib.found() subdir_done() endif +sdk_headers = [ + 'd3d11_4.h', + 'dxgi1_6.h', + 'd3dcompiler.h' +] + +foreach h : sdk_headers + if not cc.has_header (h) + subdir_done () + endif +endforeach + d3d11_winapi_desktop = cxx.compiles('''#include #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) #error "not win32" @@ -83,6 +96,7 @@ if not d3d11_winapi_desktop and not d3d11_winapi_app subdir_done() endif +extra_deps = [] d3d11_winapi_only_app = d3d11_winapi_app and not d3d11_winapi_desktop d3d11_conf.set10('GST_D3D11_WINAPI_ONLY_APP', d3d11_winapi_only_app) d3d11_conf.set10('GST_D3D11_WINAPI_APP', d3d11_winapi_app) @@ -144,6 +158,10 @@ if have_dxgidebug_h extra_comm_args += ['-DHAVE_DXGIDEBUG_H'] endif +if d3d11_winapi_only_app + extra_deps += [d3dcompiler_lib, runtimeobject_lib] +endif + # MinGW 32bits compiler seems to be complaining about redundant-decls # when ComPtr is in use. Let's just disable the warning if cc.get_id() != 'msvc' @@ -186,7 +204,7 @@ gstd3d11 = library('gstd3d11-' + api_version, version : libversion, soversion : soversion, install : true, - dependencies : [gstbase_dep, gstvideo_dep, gmodule_dep, d3d11_lib, dxgi_lib] + dependencies : [gstbase_dep, gstvideo_dep, gmodule_dep, d3d11_lib, dxgi_lib] + extra_deps ) pkgconfig.generate(gstd3d11, diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11compositor.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11compositor.cpp index b8d0a0c0bd..d91c88778f 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11compositor.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11compositor.cpp @@ -44,7 +44,6 @@ #include "gstd3d11compositor.h" #include "gstd3d11converter.h" -#include "gstd3d11shader.h" #include "gstd3d11pluginutils.h" #include #include @@ -1823,7 +1822,8 @@ gst_d3d11_compositor_create_checker_quad (GstD3D11Compositor * self, ps_src = checker_ps_src_luma; } - if (!gst_d3d11_create_pixel_shader (self->device, ps_src, &ps)) { + hr = gst_d3d11_create_pixel_shader_simple (self->device, ps_src, "main", &ps); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Couldn't setup pixel shader"); return nullptr; } @@ -1837,8 +1837,9 @@ gst_d3d11_compositor_create_checker_quad (GstD3D11Compositor * self, input_desc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; input_desc.InstanceDataStepRate = 0; - if (!gst_d3d11_create_vertex_shader (self->device, checker_vs_src, - &input_desc, 1, &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (self->device, checker_vs_src, + "main", &input_desc, 1, &vs, &layout); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Couldn't setup vertex shader"); return nullptr; } diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11converter.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11converter.cpp index b6730a7241..b956d420d6 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11converter.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11converter.cpp @@ -23,7 +23,6 @@ #endif #include "gstd3d11converter.h" -#include "gstd3d11shader.h" #include "gstd3d11pluginutils.h" #include #include @@ -1159,7 +1158,6 @@ gst_d3d11_color_convert_setup_shader (GstD3D11Converter * self, ComPtr < ID3D11Buffer > vertex_buffer; ComPtr < ID3D11Buffer > index_buffer; gint i; - gboolean ret; memset (&sampler_desc, 0, sizeof (sampler_desc)); memset (input_desc, 0, sizeof (input_desc)); @@ -1196,9 +1194,10 @@ gst_d3d11_color_convert_setup_shader (GstD3D11Converter * self, cinfo->build_output_func[i], cinfo->gamma_decode_func, cinfo->gamma_encode_func, cinfo->XYZ_convert_func); - ret = gst_d3d11_create_pixel_shader (device, shader_code, &ps[i]); + hr = gst_d3d11_create_pixel_shader_simple (device, + shader_code, "main", &ps[i]); g_free (shader_code); - if (!ret) { + if (!gst_d3d11_result (hr, device)) { return FALSE; } } @@ -1220,8 +1219,9 @@ gst_d3d11_color_convert_setup_shader (GstD3D11Converter * self, input_desc[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; input_desc[1].InstanceDataStepRate = 0; - if (!gst_d3d11_create_vertex_shader (device, templ_vertex_shader, - input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (device, templ_vertex_shader, + "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, device)) { GST_ERROR_OBJECT (self, "Couldn't vertex pixel shader"); return FALSE; } diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlaycompositor.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlaycompositor.cpp index 8bbcb5e1f4..6f46d725d7 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlaycompositor.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11overlaycompositor.cpp @@ -22,7 +22,6 @@ #endif #include "gstd3d11overlaycompositor.h" -#include "gstd3d11shader.h" #include "gstd3d11pluginutils.h" #include @@ -381,7 +380,9 @@ gst_d3d11_overlay_compositor_setup_shader (GstD3D11OverlayCompositor * self) return FALSE; } - if (!gst_d3d11_create_pixel_shader (device, templ_pixel_shader, &ps)) { + hr = gst_d3d11_create_pixel_shader_simple (device, + templ_pixel_shader, "main", &ps); + if (!gst_d3d11_result (hr, device)) { GST_ERROR_OBJECT (self, "Couldn't create pixel shader"); return FALSE; } @@ -402,8 +403,9 @@ gst_d3d11_overlay_compositor_setup_shader (GstD3D11OverlayCompositor * self) input_desc[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; input_desc[1].InstanceDataStepRate = 0; - if (!gst_d3d11_create_vertex_shader (device, templ_vertex_shader, - input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (device, templ_vertex_shader, + "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, device)) { GST_ERROR_OBJECT (self, "Couldn't vertex pixel shader"); return FALSE; } diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapture.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapture.cpp index 2534977679..ca44073037 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapture.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapture.cpp @@ -47,7 +47,6 @@ #endif #include "gstd3d11screencapture.h" -#include "gstd3d11shader.h" #include "gstd3d11pluginutils.h" #include @@ -654,14 +653,18 @@ private: ComPtr vs; ComPtr layout; - if (!gst_d3d11_create_vertex_shader (device, - vs_str, input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + HRESULT hr; + + hr = gst_d3d11_create_vertex_shader_simple (device, + vs_str, "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, device)) { GST_ERROR ("Failed to create vertex shader"); return false; } ComPtr ps; - if (!gst_d3d11_create_pixel_shader (device, ps_str, &ps)) { + hr = gst_d3d11_create_pixel_shader_simple (device, ps_str, "main", &ps); + if (!gst_d3d11_result (hr, device)) { GST_ERROR ("Failed to create pixel shader"); return false; } @@ -678,7 +681,7 @@ private: ID3D11Device *device_handle = gst_d3d11_device_get_device_handle (device); ComPtr sampler; - HRESULT hr = device_handle->CreateSamplerState (&sampler_desc, &sampler); + hr = device_handle->CreateSamplerState (&sampler_desc, &sampler); if (!gst_d3d11_result (hr, device)) { GST_ERROR ("Failed to create sampler state, hr 0x%x", (guint) hr); return false; diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapturesrc.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapturesrc.cpp index eacd32cc49..246fb61816 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapturesrc.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11screencapturesrc.cpp @@ -39,7 +39,6 @@ #include "gstd3d11screencapturesrc.h" #include "gstd3d11screencapture.h" #include "gstd3d11pluginutils.h" -#include "gstd3d11shader.h" #include #include @@ -663,13 +662,15 @@ gst_d3d11_screen_capture_prepare_shader (GstD3D11ScreenCaptureSrc * self) device_handle = gst_d3d11_device_get_device_handle (self->device); - if (!gst_d3d11_create_vertex_shader (self->device, - vs_str, input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (self->device, + vs_str, "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to create vertex shader"); return FALSE; } - if (!gst_d3d11_create_pixel_shader (self->device, ps_str, &ps)) { + hr = gst_d3d11_create_pixel_shader_simple (self->device, ps_str, "main", &ps); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to create pixel shader"); return FALSE; } diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11shader.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11shader.cpp deleted file mode 100644 index 912a0284c2..0000000000 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11shader.cpp +++ /dev/null @@ -1,228 +0,0 @@ -/* GStreamer - * Copyright (C) <2019> Seungha Yang - * - * 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 "gstd3d11shader.h" -#include "gstd3d11pluginutils.h" -#include -#include - -/* *INDENT-OFF* */ -using namespace Microsoft::WRL; -/* *INDENT-ON* */ - -GST_DEBUG_CATEGORY_EXTERN (gst_d3d11_shader_debug); -#define GST_CAT_DEFAULT gst_d3d11_shader_debug - -static GModule *d3d_compiler_module = NULL; -static pD3DCompile GstD3DCompileFunc = NULL; - -gboolean -gst_d3d11_shader_init (void) -{ - static gsize _init = 0; - - if (g_once_init_enter (&_init)) { -#if GST_D3D11_WINAPI_ONLY_APP - /* Assuming that d3d compiler library is available */ - GstD3DCompileFunc = D3DCompile; -#else - static const gchar *d3d_compiler_names[] = { - "d3dcompiler_47.dll", - "d3dcompiler_46.dll", - "d3dcompiler_45.dll", - "d3dcompiler_44.dll", - "d3dcompiler_43.dll", - }; - guint i; - for (i = 0; i < G_N_ELEMENTS (d3d_compiler_names); i++) { - d3d_compiler_module = - g_module_open (d3d_compiler_names[i], G_MODULE_BIND_LAZY); - - if (d3d_compiler_module) { - GST_INFO ("D3D compiler %s is available", d3d_compiler_names[i]); - if (!g_module_symbol (d3d_compiler_module, "D3DCompile", - (gpointer *) & GstD3DCompileFunc)) { - GST_ERROR ("Cannot load D3DCompile symbol from %s", - d3d_compiler_names[i]); - g_module_close (d3d_compiler_module); - d3d_compiler_module = NULL; - GstD3DCompileFunc = NULL; - } else { - break; - } - } - } - - if (!GstD3DCompileFunc) - GST_WARNING ("D3D11 compiler library is unavailable"); -#endif - - g_once_init_leave (&_init, 1); - } - - return !!GstD3DCompileFunc; -} - -static gboolean -compile_shader (GstD3D11Device * device, const gchar * shader_source, - gboolean is_pixel_shader, ID3DBlob ** blob) -{ - const gchar *shader_target; - D3D_FEATURE_LEVEL feature_level; - HRESULT hr; - ID3D11Device *device_handle; - /* *INDENT-OFF* */ - ComPtr ret; - ComPtr error; - /* *INDENT-ON* */ - - if (!gst_d3d11_shader_init ()) { - GST_ERROR ("D3DCompiler is unavailable"); - return FALSE; - } - - device_handle = gst_d3d11_device_get_device_handle (device); - feature_level = device_handle->GetFeatureLevel (); - - if (is_pixel_shader) { - if (feature_level >= D3D_FEATURE_LEVEL_10_0) - shader_target = "ps_4_0"; - else if (feature_level >= D3D_FEATURE_LEVEL_9_3) - shader_target = "ps_4_0_level_9_3"; - else - shader_target = "ps_4_0_level_9_1"; - } else { - if (feature_level >= D3D_FEATURE_LEVEL_10_0) - shader_target = "vs_4_0"; - else if (feature_level >= D3D_FEATURE_LEVEL_9_3) - shader_target = "vs_4_0_level_9_3"; - else - shader_target = "vs_4_0_level_9_1"; - } - - g_assert (GstD3DCompileFunc); - - GST_TRACE ("Compile code \n%s", shader_source); - - hr = GstD3DCompileFunc (shader_source, strlen (shader_source), NULL, NULL, - NULL, "main", shader_target, 0, 0, &ret, &error); - - if (!gst_d3d11_result (hr, device)) { - const gchar *err = NULL; - - if (error) - err = (const gchar *) error->GetBufferPointer (); - - GST_ERROR ("could not compile source, hr: 0x%x, error detail %s", - (guint) hr, GST_STR_NULL (err)); - return FALSE; - } - - if (error) { - const gchar *err = (const gchar *) error->GetBufferPointer (); - - GST_DEBUG ("HLSL compiler warnings:\n%s\nShader code:\n%s", - GST_STR_NULL (err), GST_STR_NULL (shader_source)); - } - - *blob = ret.Detach (); - - return TRUE; -} - -gboolean -gst_d3d11_create_pixel_shader (GstD3D11Device * device, - const gchar * source, ID3D11PixelShader ** shader) -{ - ID3D11Device *device_handle; - HRESULT hr; - /* *INDENT-OFF* */ - ComPtr ps_blob; - /* *INDENT-ON* */ - - g_return_val_if_fail (GST_IS_D3D11_DEVICE (device), FALSE); - g_return_val_if_fail (source != NULL, FALSE); - g_return_val_if_fail (shader != NULL, FALSE); - - if (!compile_shader (device, source, TRUE, &ps_blob)) { - GST_ERROR ("Failed to compile pixel shader"); - return FALSE; - } - - device_handle = gst_d3d11_device_get_device_handle (device); - hr = device_handle->CreatePixelShader (ps_blob->GetBufferPointer (), - ps_blob->GetBufferSize (), NULL, shader); - if (!gst_d3d11_result (hr, device)) { - GST_ERROR ("could not create pixel shader, hr: 0x%x", (guint) hr); - return FALSE; - } - - return TRUE; -} - -gboolean -gst_d3d11_create_vertex_shader (GstD3D11Device * device, const gchar * source, - const D3D11_INPUT_ELEMENT_DESC * input_desc, guint desc_len, - ID3D11VertexShader ** shader, ID3D11InputLayout ** layout) -{ - ID3D11Device *device_handle; - HRESULT hr; - /* *INDENT-OFF* */ - ComPtr vs_blob; - ComPtr vs; - ComPtr in_layout; - /* *INDENT-ON* */ - - g_return_val_if_fail (GST_IS_D3D11_DEVICE (device), FALSE); - g_return_val_if_fail (source != NULL, FALSE); - g_return_val_if_fail (input_desc != NULL, FALSE); - g_return_val_if_fail (desc_len > 0, FALSE); - g_return_val_if_fail (shader != NULL, FALSE); - g_return_val_if_fail (layout != NULL, FALSE); - - if (!compile_shader (device, source, FALSE, &vs_blob)) { - GST_ERROR ("Failed to compile shader code"); - return FALSE; - } - - device_handle = gst_d3d11_device_get_device_handle (device); - hr = device_handle->CreateVertexShader (vs_blob->GetBufferPointer (), - vs_blob->GetBufferSize (), NULL, &vs); - if (!gst_d3d11_result (hr, device)) { - GST_ERROR ("could not create vertex shader, hr: 0x%x", (guint) hr); - return FALSE; - } - - hr = device_handle->CreateInputLayout (input_desc, - desc_len, vs_blob->GetBufferPointer (), - vs_blob->GetBufferSize (), &in_layout); - if (!gst_d3d11_result (hr, device)) { - GST_ERROR ("could not create input layout shader, hr: 0x%x", (guint) hr); - return FALSE; - } - - *shader = vs.Detach (); - *layout = in_layout.Detach (); - - return TRUE; -} diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11shader.h b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11shader.h deleted file mode 100644 index 2ef3ae8ebe..0000000000 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11shader.h +++ /dev/null @@ -1,46 +0,0 @@ -/* GStreamer - * Copyright (C) <2019> Seungha Yang - * - * 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. - */ - -#ifndef __GST_D3D11_SHADER_H__ -#define __GST_D3D11_SHADER_H__ - -#include -#include -#include - -#include - -G_BEGIN_DECLS - -gboolean gst_d3d11_shader_init (void); - -gboolean gst_d3d11_create_pixel_shader (GstD3D11Device * device, - const gchar * source, - ID3D11PixelShader ** shader); - -gboolean gst_d3d11_create_vertex_shader (GstD3D11Device * device, - const gchar * source, - const D3D11_INPUT_ELEMENT_DESC * input_desc, - guint desc_len, - ID3D11VertexShader ** shader, - ID3D11InputLayout ** layout); - -G_END_DECLS - -#endif /* __GST_D3D11_SHADER_H__ */ diff --git a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11testsrc.cpp b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11testsrc.cpp index 4389d727fa..9c425454ba 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11testsrc.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11testsrc.cpp @@ -38,7 +38,6 @@ #include "gstd3d11testsrc.h" #include "gstd3d11pluginutils.h" -#include "gstd3d11shader.h" #include "gstd3d11converter.h" #include #include @@ -324,7 +323,6 @@ setup_snow_render (GstD3D11TestSrc * self, GstD3D11TestSrcRender * render, guint on_smpte) { HRESULT hr; - gboolean ret; D3D11_INPUT_ELEMENT_DESC input_desc[2]; D3D11_BUFFER_DESC buffer_desc; D3D11_MAPPED_SUBRESOURCE map; @@ -361,14 +359,16 @@ setup_snow_render (GstD3D11TestSrc * self, GstD3D11TestSrcRender * render, input_desc[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; input_desc[1].InstanceDataStepRate = 0; - if (!gst_d3d11_create_vertex_shader (self->device, templ_vs_coord, - input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (self->device, templ_vs_coord, + "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to compile vertext shader"); return FALSE; } - ret = gst_d3d11_create_pixel_shader (self->device, templ_ps_snow, &ps); - if (!ret) { + hr = gst_d3d11_create_pixel_shader_simple (self->device, + templ_ps_snow, "main", &ps); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to compile pixel shader"); return FALSE; } @@ -527,7 +527,6 @@ static gboolean setup_smpte_render (GstD3D11TestSrc * self, GstD3D11TestSrcRender * render) { HRESULT hr; - gboolean ret; D3D11_INPUT_ELEMENT_DESC input_desc[2]; D3D11_BUFFER_DESC buffer_desc; D3D11_MAPPED_SUBRESOURCE map; @@ -565,14 +564,17 @@ setup_smpte_render (GstD3D11TestSrc * self, GstD3D11TestSrcRender * render) input_desc[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; input_desc[1].InstanceDataStepRate = 0; - if (!gst_d3d11_create_vertex_shader (self->device, templ_vs_color, - input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (self->device, templ_vs_coord, + "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to compile vertext shader"); return FALSE; } - ret = gst_d3d11_create_pixel_shader (self->device, templ_ps_smpte, &ps); - if (!ret) { + + hr = gst_d3d11_create_pixel_shader_simple (self->device, + templ_ps_smpte, "main", &ps); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to compile pixel shader"); return FALSE; } @@ -863,7 +865,6 @@ setup_checker_render (GstD3D11TestSrc * self, GstD3D11TestSrcRender * render, guint checker_size) { HRESULT hr; - gboolean ret; D3D11_INPUT_ELEMENT_DESC input_desc[2]; D3D11_BUFFER_DESC buffer_desc; D3D11_MAPPED_SUBRESOURCE map; @@ -900,17 +901,18 @@ setup_checker_render (GstD3D11TestSrc * self, GstD3D11TestSrcRender * render, input_desc[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; input_desc[1].InstanceDataStepRate = 0; - if (!gst_d3d11_create_vertex_shader (self->device, templ_vs_coord, - input_desc, G_N_ELEMENTS (input_desc), &vs, &layout)) { + hr = gst_d3d11_create_vertex_shader_simple (self->device, templ_vs_coord, + "main", input_desc, G_N_ELEMENTS (input_desc), &vs, &layout); + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to compile vertext shader"); return FALSE; } ps_src = g_strdup_printf (templ_ps_checker, self->info.width, self->info.height, checker_size); - ret = gst_d3d11_create_pixel_shader (self->device, ps_src, &ps); + hr = gst_d3d11_create_pixel_shader_simple (self->device, ps_src, "main", &ps); g_free (ps_src); - if (!ret) { + if (!gst_d3d11_result (hr, self->device)) { GST_ERROR_OBJECT (self, "Failed to compile pixel shader"); return FALSE; } diff --git a/subprojects/gst-plugins-bad/sys/d3d11/meson.build b/subprojects/gst-plugins-bad/sys/d3d11/meson.build index 805bf23f44..2a780b523e 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/meson.build +++ b/subprojects/gst-plugins-bad/sys/d3d11/meson.build @@ -12,7 +12,6 @@ d3d11_sources = [ 'gstd3d11mpeg2dec.cpp', 'gstd3d11overlaycompositor.cpp', 'gstd3d11pluginutils.cpp', - 'gstd3d11shader.cpp', 'gstd3d11testsrc.cpp', 'gstd3d11upload.cpp', 'gstd3d11videosink.cpp', @@ -32,14 +31,13 @@ if host_system != 'windows' or d3d11_option.disabled() subdir_done() endif -if not gstd3d11_dep.found() or not cc.has_header('dxva.h') or not cc.has_header('d3d9.h') or not cc.has_header('d3dcompiler.h') +if not gstd3d11_dep.found() or not cc.has_header('dxva.h') or not cc.has_header('d3d9.h') if d3d11_option.enabled() error('The d3d11 was enabled explicitly, but required dependencies were not found.') endif subdir_done() endif -d3dcompiler_lib = cc.find_library('d3dcompiler', required: d3d11_option) runtimeobject_lib = cc.find_library('runtimeobject', required : false) winmm_lib = cc.find_library('winmm', required: false) @@ -55,7 +53,7 @@ endif if d3d11_winapi_app d3d11_sources += ['gstd3d11window_corewindow.cpp', 'gstd3d11window_swapchainpanel.cpp'] - extra_dep += [runtimeobject_lib, d3dcompiler_lib] + extra_dep += [runtimeobject_lib] endif if d3d11_winapi_desktop diff --git a/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp b/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp index c811abccdb..5d31fd4155 100644 --- a/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp +++ b/subprojects/gst-plugins-bad/sys/d3d11/plugin.cpp @@ -66,7 +66,6 @@ #include "gstd3d11upload.h" #include "gstd3d11download.h" #include "gstd3d11convert.h" -#include "gstd3d11shader.h" #include "gstd3d11compositor.h" #include "gstd3d11h264dec.h" #include "gstd3d11h265dec.h" @@ -89,7 +88,6 @@ using namespace Microsoft::WRL; /* *INDENT-ON* */ GST_DEBUG_CATEGORY (gst_d3d11_debug); -GST_DEBUG_CATEGORY (gst_d3d11_shader_debug); GST_DEBUG_CATEGORY (gst_d3d11_plugin_utils_debug); GST_DEBUG_CATEGORY (gst_d3d11_format_debug); GST_DEBUG_CATEGORY (gst_d3d11_device_debug); @@ -121,8 +119,6 @@ plugin_init (GstPlugin * plugin) ComPtr < IDXGIFactory1 > factory; GST_DEBUG_CATEGORY_INIT (gst_d3d11_debug, "d3d11", 0, "direct3d 11 plugin"); - GST_DEBUG_CATEGORY_INIT (gst_d3d11_shader_debug, - "d3d11shader", 0, "d3d11shader"); GST_DEBUG_CATEGORY_INIT (gst_d3d11_plugin_utils_debug, "d3d11pluginutils", 0, "d3d11 plugin utility functions"); GST_DEBUG_CATEGORY_INIT (gst_d3d11_overlay_compositor_debug, @@ -132,8 +128,8 @@ plugin_init (GstPlugin * plugin) GST_DEBUG_CATEGORY_INIT (gst_d3d11_video_processor_debug, "d3d11videoprocessor", 0, "d3d11videoprocessor"); - if (!gst_d3d11_shader_init ()) { - GST_WARNING ("Cannot initialize d3d11 shader"); + if (!gst_d3d11_compile_init ()) { + GST_WARNING ("Cannot initialize d3d11 compiler"); return TRUE; }