jp9000/obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2156 from LittleMatth/master

Browse Source 
Vulkan Game Capture
This commit is contained in:
Jim 2020-02-29 05:37:44 -08:00 committed by GitHub
commit 1a071982aa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 3069 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
UI/win-update/updater/CMakeLists.txt
View File

@ -23,6 +23,7 @@ set(updater_HEADERS
)
set(updater_SOURCES
../win-update-helpers.cpp
init-hook-files.c
updater.cpp
patch.cpp
http.cpp

135
UI/win-update/updater/init-hook-files.c Normal file
View File

@ -0,0 +1,135 @@
#include <windows.h>
#include <strsafe.h>
#include <shlobj.h>
#include <stdbool.h>
static inline bool file_exists(const wchar_t *path)
{
WIN32_FIND_DATAW wfd;
HANDLE h = FindFirstFileW(path, &wfd);
if (h == INVALID_HANDLE_VALUE)
return false;
FindClose(h);
return true;
}
static LSTATUS get_reg(HKEY hkey, LPCWSTR sub_key, LPCWSTR value_name, bool b64)
{
HKEY key;
LSTATUS status;
DWORD flags = b64 ? KEY_WOW64_64KEY : KEY_WOW64_32KEY;
DWORD size = sizeof(DWORD);
DWORD val;
status = RegOpenKeyEx(hkey, sub_key, 0, KEY_READ | flags, &key);
if (status == ERROR_SUCCESS) {
status = RegQueryValueExW(key, value_name, NULL, NULL,
(LPBYTE)&val, &size);
RegCloseKey(key);
}
return status;
}
#define get_programdata_path(path, subpath) \
do { \
SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, \
SHGFP_TYPE_CURRENT, path); \
StringCbCatW(path, sizeof(path), L"\\"); \
StringCbCatW(path, sizeof(path), subpath); \
} while (false)
#define make_filename(str, name, ext) \
do { \
StringCbCatW(str, sizeof(str), name); \
StringCbCatW(str, sizeof(str), b64 ? L"64" : L"32"); \
StringCbCatW(str, sizeof(str), ext); \
} while (false)
#define IMPLICIT_LAYERS L"SOFTWARE\\Khronos\\Vulkan\\ImplicitLayers"
#define HOOK_LOCATION L"\\data\\obs-plugins\\win-capture\\"
static bool update_hook_file(bool b64)
{
wchar_t temp[MAX_PATH];
wchar_t src[MAX_PATH];
wchar_t dst[MAX_PATH];
wchar_t src_json[MAX_PATH];
wchar_t dst_json[MAX_PATH];
GetCurrentDirectoryW(_countof(src_json), src_json);
StringCbCat(src_json, sizeof(src_json), HOOK_LOCATION);
make_filename(src_json, L"obs-vulkan", L".json");
GetCurrentDirectoryW(_countof(src), src);
StringCbCat(src, sizeof(src), HOOK_LOCATION);
make_filename(src, L"graphics-hook", L".dll");
get_programdata_path(temp, L"obs-studio-hook\\");
StringCbCopyW(dst_json, sizeof(dst_json), temp);
StringCbCopyW(dst, sizeof(dst), temp);
make_filename(dst_json, L"obs-vulkan", L".json");
make_filename(dst, L"graphics-hook", L".dll");
if (!file_exists(src)) {
return false;
}
CreateDirectoryW(temp, NULL);
CopyFileW(src, dst, false);
CopyFileW(src_json, dst_json, false);
return true;
}
static void update_vulkan_registry(bool b64)
{
DWORD flags = b64 ? KEY_WOW64_64KEY : KEY_WOW64_32KEY;
wchar_t path[MAX_PATH];
DWORD temp;
LSTATUS s;
HKEY key;
get_programdata_path(path, L"obs-studio-hook\\");
make_filename(path, L"obs-vulkan", L".json");
s = get_reg(HKEY_CURRENT_USER, IMPLICIT_LAYERS, path, b64);
if (s == ERROR_SUCCESS) {
s = RegOpenKeyEx(HKEY_CURRENT_USER, IMPLICIT_LAYERS, 0,
KEY_WRITE | flags, &key);
if (s == ERROR_SUCCESS) {
RegDeleteValueW(key, path);
RegCloseKey(key);
}
}
s = get_reg(HKEY_LOCAL_MACHINE, IMPLICIT_LAYERS, path, b64);
if (s == ERROR_SUCCESS) {
return;
}
/* ------------------- */
s = RegCreateKeyExW(HKEY_LOCAL_MACHINE, IMPLICIT_LAYERS, 0, NULL, 0,
KEY_WRITE | flags, NULL, &key, &temp);
if (s != ERROR_SUCCESS) {
goto finish;
}
DWORD zero = 0;
s = RegSetValueExW(key, path, 0, REG_DWORD, (const BYTE *)&zero,
sizeof(zero));
if (s != ERROR_SUCCESS) {
goto finish;
}
finish:
if (key)
RegCloseKey(key);
}
void UpdateHookFiles(void)
{
if (update_hook_file(true))
update_vulkan_registry(true);
if (update_hook_file(false))
update_vulkan_registry(false);
}

10
UI/win-update/updater/updater.cpp
View File

@ -1071,6 +1071,8 @@ static bool UpdateVS2017Redists(json_t *root)
return success;
}
extern "C" void UpdateHookFiles(void);
static bool Update(wchar_t *cmdLine)
{
/* ------------------------------------- *
@ -1408,6 +1410,14 @@ static bool Update(wchar_t *cmdLine)
}
}
/* ------------------------------------- *
* Update hook files and vulkan registry */
UpdateHookFiles();
/* ------------------------------------- *
* Finish */
/* If we get here, all updates installed successfully so we can purge
* the old versions */
for (update_t &update : updates) {

70
cmake/Modules/FindVulkan.cmake Normal file
View File

@ -0,0 +1,70 @@
# Once done these will be defined:
#
# VULKAN_FOUND
# VULKAN_INCLUDE_DIRS
# VULKAN_LIBRARIES
#
# For use in OBS:
#
# VULKAN_INCLUDE_DIR
find_package(PkgConfig QUIET)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_VULKAN QUIET vulkan)
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(_lib_suffix 64)
else()
set(_lib_suffix 32)
endif()
find_path(VULKAN_INCLUDE_DIR
NAMES vulkan/vulkan.h
HINTS
ENV vulkanPath${_lib_suffix}
ENV vulkanPath
ENV DepsPath${_lib_suffix}
ENV DepsPath
ENV VULKAN_SDK
${vulkanPath${_lib_suffix}}
${vulkanPath}
${DepsPath${_lib_suffix}}
${DepsPath}
${_VULKAN_INCLUDE_DIRS}
PATHS
/usr/include /usr/local/include /opt/local/include /sw/include
PATH_SUFFIXES
include)
find_library(VULKAN_LIB
NAMES ${_VULKAN_LIBRARIES} vulkan-1 vulkan libvulkan
HINTS
ENV vulkanPath${_lib_suffix}
ENV vulkanPath
ENV DepsPath${_lib_suffix}
ENV DepsPath
ENV VULKAN_SDK
${vulkanPath${_lib_suffix}}
${vulkanPath}
${DepsPath${_lib_suffix}}
${DepsPath}
${_VULKAN_LIBRARY_DIRS}
PATHS
/usr/lib /usr/local/lib /opt/local/lib /sw/lib
PATH_SUFFIXES
lib${_lib_suffix} lib
libs${_lib_suffix} libs
bin${_lib_suffix} bin
../lib${_lib_suffix} ../lib
../libs${_lib_suffix} ../libs
../bin${_lib_suffix} ../bin)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(vulkan DEFAULT_MSG VULKAN_LIB VULKAN_INCLUDE_DIR)
mark_as_advanced(VULKAN_INCLUDE_DIR VULKAN_LIB)
if(VULKAN_FOUND)
set(VULKAN_INCLUDE_DIRS ${VULKAN_INCLUDE_DIR})
set(VULKAN_LIBRARIES ${VULKAN_LIB})
endif()

2
plugins/win-capture/CMakeLists.txt
View File

@ -8,6 +8,7 @@ set(win-capture_HEADERS
inject-library.h
cursor-capture.h
graphics-hook-info.h
graphics-hook-ver.h
window-helpers.h
dc-capture.h)
@ -22,6 +23,7 @@ set(win-capture_SOURCES
monitor-capture.c
window-capture.c
load-graphics-offsets.c
game-capture-file-init.c
duplicator-monitor-capture.c
plugin-main.c)

238
plugins/win-capture/game-capture-file-init.c Normal file
View File

@ -0,0 +1,238 @@
#include <windows.h>
#include <strsafe.h>
#include <shlobj.h>
#include <obs-module.h>
#include <util/windows/win-version.h>
#include <util/platform.h>
#include <util/c99defs.h>
#include <util/base.h>
/* ------------------------------------------------------------------------- */
/* helper funcs */
static bool has_elevation()
{
SID_IDENTIFIER_AUTHORITY sia = SECURITY_NT_AUTHORITY;
PSID sid = NULL;
BOOL elevated = false;
BOOL success;
success = AllocateAndInitializeSid(&sia, 2, SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0,
0, 0, &sid);
if (success && sid) {
CheckTokenMembership(NULL, sid, &elevated);
FreeSid(sid);
}
return elevated;
}
static inline bool file_exists(const wchar_t *path)
{
WIN32_FIND_DATAW wfd;
HANDLE h = FindFirstFileW(path, &wfd);
if (h == INVALID_HANDLE_VALUE)
return false;
FindClose(h);
return true;
}
static LSTATUS get_reg(HKEY hkey, LPCWSTR sub_key, LPCWSTR value_name, bool b64)
{
HKEY key;
LSTATUS status;
DWORD flags = b64 ? KEY_WOW64_64KEY : KEY_WOW64_32KEY;
DWORD size = sizeof(DWORD);
DWORD val;
status = RegOpenKeyEx(hkey, sub_key, 0, KEY_READ | flags, &key);
if (status == ERROR_SUCCESS) {
status = RegQueryValueExW(key, value_name, NULL, NULL,
(LPBYTE)&val, &size);
RegCloseKey(key);
}
return status;
}
#define get_programdata_path(path, subpath) \
do { \
SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, \
SHGFP_TYPE_CURRENT, path); \
StringCbCatW(path, sizeof(path), L"\\"); \
StringCbCatW(path, sizeof(path), subpath); \
} while (false)
#define make_filename(str, name, ext) \
do { \
StringCbCatW(str, sizeof(str), name); \
StringCbCatW(str, sizeof(str), b64 ? L"64" : L"32"); \
StringCbCatW(str, sizeof(str), ext); \
} while (false)
/* ------------------------------------------------------------------------- */
/* function to get the path to the hook */
static bool programdata64_hook_exists = false;
static bool programdata32_hook_exists = false;
char *get_hook_path(bool b64)
{
wchar_t path[MAX_PATH];
get_programdata_path(path, L"obs-studio-hook\\");
make_filename(path, L"graphics-hook", L".dll");
if ((b64 && programdata64_hook_exists) ||
(!b64 && programdata32_hook_exists)) {
char *path_utf8 = NULL;
os_wcs_to_utf8_ptr(path, 0, &path_utf8);
return path_utf8;
}
return obs_module_file(b64 ? "graphics-hook64.dll"
: "graphics-hook32.dll");
}
/* ------------------------------------------------------------------------- */
/* initialization */
#define IMPLICIT_LAYERS L"SOFTWARE\\Khronos\\Vulkan\\ImplicitLayers"
static bool update_hook_file(bool b64)
{
wchar_t temp[MAX_PATH];
wchar_t src[MAX_PATH];
wchar_t dst[MAX_PATH];
wchar_t src_json[MAX_PATH];
wchar_t dst_json[MAX_PATH];
StringCbCopyW(temp, sizeof(temp),
L"..\\..\\data\\obs-plugins\\"
L"win-capture\\");
make_filename(temp, L"obs-vulkan", L".json");
if (_wfullpath(src_json, temp, MAX_PATH) == NULL)
return false;
StringCbCopyW(temp, sizeof(temp),
L"..\\..\\data\\obs-plugins\\"
L"win-capture\\");
make_filename(temp, L"graphics-hook", L".dll");
if (_wfullpath(src, temp, MAX_PATH) == NULL)
return false;
get_programdata_path(temp, L"obs-studio-hook\\");
StringCbCopyW(dst_json, sizeof(dst_json), temp);
StringCbCopyW(dst, sizeof(dst), temp);
make_filename(dst_json, L"obs-vulkan", L".json");
make_filename(dst, L"graphics-hook", L".dll");
if (!file_exists(src)) {
return false;
}
if (!file_exists(src_json)) {
return false;
}
if (!file_exists(dst) || !file_exists(dst_json)) {
CreateDirectoryW(temp, NULL);
if (!CopyFileW(src_json, dst_json, false))
return false;
if (!CopyFileW(src, dst, false))
return false;
return true;
}
struct win_version_info ver_src = {0};
struct win_version_info ver_dst = {0};
if (!get_dll_ver(src, &ver_src))
return false;
if (!get_dll_ver(dst, &ver_dst))
return false;
/* if source is greater than dst, overwrite new file */
while (win_version_compare(&ver_dst, &ver_src) < 0) {
if (!CopyFileW(src_json, dst_json, false))
return false;
if (!CopyFileW(src, dst, false))
return false;
if (!get_dll_ver(dst, &ver_dst))
return false;
}
/* do not use if major version incremented in target compared to
* ours */
if (ver_dst.major > ver_src.major) {
return false;
}
return true;
}
#define warn(format, ...) \
blog(LOG_WARNING, "%s: " format, "[Vulkan Capture Init]", ##__VA_ARGS__)
/* Sets vulkan layer registry if it doesn't already exist */
static void init_vulkan_registry(bool b64)
{
HKEY key = NULL;
LSTATUS s;
wchar_t path[MAX_PATH];
get_programdata_path(path, L"obs-studio-hook\\");
s = get_reg(HKEY_LOCAL_MACHINE, IMPLICIT_LAYERS, path, b64);
make_filename(path, L"obs-vulkan", L".json");
if (s == ERROR_FILE_NOT_FOUND) {
s = get_reg(HKEY_CURRENT_USER, IMPLICIT_LAYERS, path, b64);
if (s != ERROR_FILE_NOT_FOUND && s != ERROR_SUCCESS) {
warn("Failed to query registry keys: %d", (int)s);
goto finish;
}
} else if (s != ERROR_SUCCESS) {
warn("Failed to query registry keys: %d", (int)s);
goto finish;
}
if (s == ERROR_SUCCESS) {
goto finish;
}
HKEY type = has_elevation() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
DWORD flags = b64 ? KEY_WOW64_64KEY : KEY_WOW64_32KEY;
DWORD temp;
s = RegCreateKeyExW(type, IMPLICIT_LAYERS, 0, NULL, 0,
KEY_WRITE | flags, NULL, &key, &temp);
if (s != ERROR_SUCCESS) {
warn("Failed to create registry key");
goto finish;
}
DWORD zero = 0;
s = RegSetValueExW(key, path, 0, REG_DWORD, (const BYTE *)&zero,
sizeof(zero));
if (s != ERROR_SUCCESS) {
warn("Failed to set registry value");
}
finish:
if (key)
RegCloseKey(key);
}
void init_hook_files()
{
if (update_hook_file(true)) {
programdata64_hook_exists = true;
init_vulkan_registry(true);
}
if (update_hook_file(false)) {
programdata32_hook_exists = true;
init_vulkan_registry(false);
}
}

21
plugins/win-capture/game-capture.c
View File

@ -10,6 +10,7 @@
#include "obfuscate.h"
#include "inject-library.h"
#include "graphics-hook-info.h"
#include "graphics-hook-ver.h"
#include "window-helpers.h"
#include "cursor-capture.h"
#include "app-helpers.h"
@ -893,23 +894,22 @@ static inline bool create_inject_process(struct game_capture *gc,
return success;
}
extern char *get_hook_path(bool b64);
static inline bool inject_hook(struct game_capture *gc)
{
bool matching_architecture;
bool success = false;
const char *hook_dll;
char *inject_path;
char *hook_path;
if (gc->process_is_64bit) {
hook_dll = "graphics-hook64.dll";
inject_path = obs_module_file("inject-helper64.exe");
} else {
hook_dll = "graphics-hook32.dll";
inject_path = obs_module_file("inject-helper32.exe");
}
hook_path = obs_module_file(hook_dll);
hook_path = get_hook_path(gc->process_is_64bit);
if (!check_file_integrity(gc, inject_path, "inject helper")) {
goto cleanup;
@ -930,7 +930,7 @@ static inline bool inject_hook(struct game_capture *gc)
} else {
info("using helper (%s hook)",
use_anticheat(gc) ? "compatibility" : "direct");
success = create_inject_process(gc, inject_path, hook_dll);
success = create_inject_process(gc, inject_path, hook_path);
}
cleanup:
@ -1611,6 +1611,17 @@ static bool start_capture(struct game_capture *gc)
{
debug("Starting capture");
/* prevent from using a DLL version that's higher than current */
if (gc->global_hook_info->hook_ver_major > HOOK_VER_MAJOR) {
warn("cannot initialize hook, DLL hook version is "
"%" PRIu32 ".%" PRIu32
", current plugin hook major version is %d.%d",
gc->global_hook_info->hook_ver_major,
gc->global_hook_info->hook_ver_minor, HOOK_VER_MAJOR,
HOOK_VER_MINOR);
return false;
}
if (gc->global_hook_info->type == CAPTURE_TYPE_MEMORY) {
if (!init_shmem_capture(gc)) {
return false;

6
plugins/win-capture/graphics-hook-info.h
View File

@ -80,6 +80,10 @@ struct graphics_offsets {
};
struct hook_info {
/* hook version */
uint32_t hook_ver_major;
uint32_t hook_ver_minor;
/* capture info */
enum capture_type type;
uint32_t window;
@ -101,6 +105,8 @@ struct hook_info {
/* hook addresses */
struct graphics_offsets offsets;
uint32_t reserved[128];
};
#pragma pack(pop)

22
plugins/win-capture/graphics-hook-ver.h Normal file
View File

@ -0,0 +1,22 @@
/* DO NOT MODIFY THIS FILE WITHOUT CONSULTING JIM. OTHERWISE, JIM WILL DO
* EVERYTHING IN HIS POWER TO MAKE YOUR LIFE MISERABLE FROM THEREON OUT WITH A
* LEVEL OF DETERMINATION UNLIKE ANYTHING ANYONE HAS EVER SEEN IN THE HISTORY
* OF MANKIND.
*
* YES, THAT MEANS YOU READING THIS RIGHT NOW.
*
* IF YOU HAVE A FORK AND FEEL YOU NEED TO MODIFY THIS, SUBMIT A PULL REQUEST
* AND WAIT UNTIL IT HAS BEEN MERGED AND FULLY RELEASED IN THE CORE PROJECT
* BEFORE USING IT.
*
* THIS IS YOUR ONLY WARNING. */
#define HOOK_VER_MAJOR 1
#define HOOK_VER_MINOR 0
#define HOOK_VER_PATCH 2
#define STRINGIFY(s) #s
#define MAKE_VERSION_NAME(major, minor, patch) \
STRINGIFY(major) "." STRINGIFY(minor) "." STRINGIFY(patch) ".0"
#define HOOK_VERSION_NAME \
MAKE_VERSION_NAME(HOOK_VER_MAJOR, HOOK_VER_MINOR, HOOK_VER_PATCH)

20
plugins/win-capture/graphics-hook/CMakeLists.txt
View File

@ -2,6 +2,9 @@ project(graphics-hook)
set(COMPILE_D3D12_HOOK FALSE CACHE BOOL "Compile D3D12 hook support (required windows 10 SDK)")
find_package(Vulkan REQUIRED)
include_directories(${VULKAN_INCLUDE_DIR})
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/graphics-hook-config.h.in"
"${CMAKE_BINARY_DIR}/plugins/win-capture/graphics-hook/config/graphics-hook-config.h")
@ -10,6 +13,7 @@ configure_file(
set(graphics-hook_HEADERS
"${CMAKE_BINARY_DIR}/plugins/win-capture/graphics-hook/config/graphics-hook-config.h"
graphics-hook.h
../graphics-hook-ver.h
../graphics-hook-info.h
../hook-helpers.h
../funchook.h
@ -33,7 +37,15 @@ if(MSVC)
add_compile_options("$<IF:$<CONFIG:Debug>,/MTd,/MT>")
endif()
if (VULKAN_FOUND)
list(APPEND graphics-hook_SOURCES
vulkan-capture.c)
list(APPEND graphics-hook_HEADERS
vulkan-capture.h)
endif()
add_library(graphics-hook MODULE
graphics-hook.rc
${graphics-hook_SOURCES}
${graphics-hook_HEADERS})
@ -53,4 +65,12 @@ set_target_properties(graphics-hook
PROPERTIES
OUTPUT_NAME "graphics-hook${_output_suffix}")
if (VULKAN_FOUND)
add_custom_command(TARGET graphics-hook POST_BUILD
COMMAND "${CMAKE_COMMAND}" -E copy
"${CMAKE_CURRENT_SOURCE_DIR}/obs-vulkan64.json" "${OBS_OUTPUT_DIR}/$<CONFIGURATION>/data/obs-plugins/win-capture/obs-vulkan64.json"
COMMAND "${CMAKE_COMMAND}" -E copy
"${CMAKE_CURRENT_SOURCE_DIR}/obs-vulkan32.json" "${OBS_OUTPUT_DIR}/$<CONFIGURATION>/data/obs-plugins/win-capture/obs-vulkan32.json"
VERBATIM)
endif()
install_obs_datatarget(graphics-hook "obs-plugins/win-capture")

2
plugins/win-capture/graphics-hook/graphics-hook-config.h.in
View File

@ -13,3 +13,5 @@
#endif
#define COMPILE_D3D12_HOOK @COMPILE_D3D12_HOOK@
#define COMPILE_VULKAN_HOOK @VULKAN_FOUND@

61
plugins/win-capture/graphics-hook/graphics-hook.c
View File

@ -1,6 +1,7 @@
#include <windows.h>
#include <psapi.h>
#include "graphics-hook.h"
#include "../graphics-hook-ver.h"
#include "../obfuscate.h"
#include "../funchook.h"
@ -37,6 +38,7 @@ static HANDLE filemap_hook_info = NULL;
static HINSTANCE dll_inst = NULL;
static volatile bool stop_loop = false;
static HANDLE dup_hook_mutex = NULL;
static HANDLE capture_thread = NULL;
char system_path[MAX_PATH] = {0};
char process_name[MAX_PATH] = {0};
@ -272,6 +274,7 @@ static void free_hook(void)
close_handle(&signal_ready);
close_handle(&signal_stop);
close_handle(&signal_restart);
close_handle(&dup_hook_mutex);
ipc_pipe_client_free(&pipe);
}
@ -312,6 +315,15 @@ static inline bool attempt_hook(void)
static bool d3d9_hooked = false;
static bool dxgi_hooked = false;
static bool gl_hooked = false;
#if COMPILE_VULKAN_HOOK
static bool vulkan_hooked = false;
if (!vulkan_hooked) {
vulkan_hooked = hook_vulkan();
if (vulkan_hooked) {
return true;
}
}
#endif //COMPILE_VULKAN_HOOK
if (!d3d9_hooked) {
if (!d3d9_hookable()) {
@ -528,6 +540,8 @@ bool capture_init_shtex(struct shtex_data **data, HWND window, uint32_t base_cx,
*data = shmem_info;
(*data)->tex_handle = (uint32_t)handle;
global_hook_info->hook_ver_major = HOOK_VER_MAJOR;
global_hook_info->hook_ver_minor = HOOK_VER_MINOR;
global_hook_info->window = (uint32_t)(uintptr_t)window;
global_hook_info->type = CAPTURE_TYPE_TEXTURE;
global_hook_info->format = format;
@ -721,6 +735,8 @@ bool capture_init_shmem(struct shmem_data **data, HWND window, uint32_t base_cx,
(*data)->tex1_offset = (uint32_t)align_pos;
(*data)->tex2_offset = (*data)->tex1_offset + aligned_tex;
global_hook_info->hook_ver_major = HOOK_VER_MAJOR;
global_hook_info->hook_ver_minor = HOOK_VER_MINOR;
global_hook_info->window = (uint32_t)(uintptr_t)window;
global_hook_info->type = CAPTURE_TYPE_MEMORY;
global_hook_info->format = format;
@ -786,6 +802,33 @@ void capture_free(void)
active = false;
}
BOOL init_vk_layer();
BOOL shutdown_vk_layer();
#define HOOK_NAME L"graphics_hook_dup_mutex"
static inline HANDLE open_mutex_plus_id(const wchar_t *name, DWORD id)
{
wchar_t new_name[64];
_snwprintf(new_name, 64, L"%s%lu", name, id);
return open_mutex(new_name);
}
static bool init_dll(void)
{
DWORD pid = GetCurrentProcessId();
HANDLE h;
h = open_mutex_plus_id(HOOK_NAME, pid);
if (h) {
CloseHandle(h);
return false;
}
dup_hook_mutex = create_mutex_plus_id(HOOK_NAME, pid);
return !!dup_hook_mutex;
}
BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID unused1)
{
if (reason == DLL_PROCESS_ATTACH) {
@ -793,6 +836,11 @@ BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID unused1)
dll_inst = hinst;
if (!init_dll()) {
DbgOut("Duplicate hook library");
return false;
}
HANDLE cur_thread;
bool success = DuplicateHandle(GetCurrentProcess(),
GetCurrentThread(),
@ -814,7 +862,11 @@ BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID unused1)
if (!init_mutexes()) {
return false;
}
#if COMPILE_VULKAN_HOOK
if (!init_vk_layer()) {
return false;
}
#endif
/* this prevents the library from being automatically unloaded
* by the next FreeLibrary call */
GetModuleFileNameW(hinst, name, MAX_PATH);
@ -829,12 +881,19 @@ BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID unused1)
}
} else if (reason == DLL_PROCESS_DETACH) {
if (!dup_hook_mutex) {
return true;
}
if (capture_thread) {
stop_loop = true;
WaitForSingleObject(capture_thread, 300);
CloseHandle(capture_thread);
}
#if COMPILE_VULKAN_HOOK
shutdown_vk_layer();
#endif
free_hook();
}

3
plugins/win-capture/graphics-hook/graphics-hook.h
View File

@ -45,6 +45,9 @@ extern bool hook_d3d8(void);
extern bool hook_d3d9(void);
extern bool hook_dxgi(void);
extern bool hook_gl(void);
#if COMPILE_VULKAN_HOOK
extern bool hook_vulkan(void);
#endif
extern void d3d10_capture(void *swap, void *backbuffer, bool capture_overlay);
extern void d3d10_free(void);

39
plugins/win-capture/graphics-hook/graphics-hook.rc Normal file
View File

@ -0,0 +1,39 @@
/* DO NOT MODIFY THIS FILE WITHOUT CONSULTING JIM. OTHERWISE, JIM WILL DO
* EVERYTHING IN HIS POWER TO MAKE YOUR LIFE MISERABLE FROM THEREON OUT WITH A
* LEVEL OF DETERMINATION UNLIKE ANYTHING ANYONE HAS EVER SEEN IN THE HISTORY
* OF MANKIND.
*
* YES, THAT MEANS YOU READING THIS RIGHT NOW.
*
* IF YOU HAVE A FORK AND FEEL YOU NEED TO MODIFY THIS, SUBMIT A PULL REQUEST
* AND WAIT UNTIL IT HAS BEEN MERGED AND FULLY RELEASED IN THE CORE PROJECT
* BEFORE USING IT.
*
* THIS IS YOUR ONLY WARNING. */
#include "../graphics-hook-ver.h"
1 VERSIONINFO
FILEVERSION HOOK_VER_MAJOR,HOOK_VER_MINOR,HOOK_VER_PATCH,0
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904B0"
BEGIN
VALUE "CompanyName", "OBS Project"
VALUE "FileDescription", "OBS Graphics Hook"
VALUE "FileVersion", HOOK_VERSION_NAME
VALUE "InternalName", "graphics-hook"
VALUE "OriginalFilename", "graphics-hook"
VALUE "ProductName", "OBS Graphics Hook"
VALUE "ProductVersion", HOOK_VERSION_NAME
VALUE "Comments", "Free and open source software for video recording and live streaming"
VALUE "LegalCopyright", "(C) Hugh Bailey"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x0409, 0x04B0
END
END

17
plugins/win-capture/graphics-hook/obs-vulkan32.json Normal file
View File

@ -0,0 +1,17 @@
{
"file_format_version": "1.1.2",
"layer": {
"name": "VK_LAYER_OBS_hook",
"type": "GLOBAL",
"library_path": ".\\graphics-hook32.dll",
"api_version": "1.2.131",
"implementation_version": "1",
"description": "Open Broadcaster Software hook",
"functions": {
"vkNegotiateLoaderLayerInterfaceVersion": "OBS_Negotiate"
},
"disable_environment": {
"DISABLE_VULKAN_OBS_CAPTURE": "1"
}
}
}

17
plugins/win-capture/graphics-hook/obs-vulkan64.json Normal file
View File

@ -0,0 +1,17 @@
{
"file_format_version": "1.1.2",
"layer": {
"name": "VK_LAYER_OBS_hook",
"type": "GLOBAL",
"library_path": ".\\graphics-hook64.dll",
"api_version": "1.2.131",
"implementation_version": "1",
"description": "Open Broadcaster Software hook",
"functions": {
"vkNegotiateLoaderLayerInterfaceVersion": "OBS_Negotiate"
},
"disable_environment": {
"DISABLE_VULKAN_OBS_CAPTURE": "1"
}
}
}

1533
plugins/win-capture/graphics-hook/vulkan-capture.c Normal file
View File

File diff suppressed because it is too large Load Diff

874
plugins/win-capture/graphics-hook/vulkan-capture.h Normal file
View File

@ -0,0 +1,874 @@
#pragma once
#define DEF_FUNC(x) PFN_vk##x x
struct vk_inst_funcs {
DEF_FUNC(GetInstanceProcAddr);
DEF_FUNC(DestroyInstance);
DEF_FUNC(CreateWin32SurfaceKHR);
DEF_FUNC(GetPhysicalDeviceMemoryProperties);
DEF_FUNC(GetPhysicalDeviceImageFormatProperties2);
};
struct vk_device_funcs {
DEF_FUNC(GetDeviceProcAddr);
DEF_FUNC(DestroyDevice);
DEF_FUNC(CreateSwapchainKHR);
DEF_FUNC(DestroySwapchainKHR);
DEF_FUNC(QueuePresentKHR);
DEF_FUNC(AllocateMemory);
DEF_FUNC(FreeMemory);
DEF_FUNC(BindImageMemory);
DEF_FUNC(BindImageMemory2);
DEF_FUNC(GetSwapchainImagesKHR);
DEF_FUNC(CreateImage);
DEF_FUNC(DestroyImage);
DEF_FUNC(GetImageMemoryRequirements);
DEF_FUNC(GetImageMemoryRequirements2);
DEF_FUNC(BeginCommandBuffer);
DEF_FUNC(EndCommandBuffer);
DEF_FUNC(CmdCopyImage);
DEF_FUNC(CmdPipelineBarrier);
DEF_FUNC(GetDeviceQueue);
DEF_FUNC(QueueSubmit);
DEF_FUNC(CreateCommandPool);
DEF_FUNC(DestroyCommandPool);
DEF_FUNC(AllocateCommandBuffers);
DEF_FUNC(CreateFence);
DEF_FUNC(DestroyFence);
DEF_FUNC(WaitForFences);
DEF_FUNC(ResetFences);
};
#undef DEF_FUNC
const char *vk_format_to_str(VkFormat format)
{
switch (format) {
default:
#define VAL(x) \
case x: \
return #x
VAL(VK_FORMAT_UNDEFINED);
VAL(VK_FORMAT_R4G4_UNORM_PACK8);
VAL(VK_FORMAT_R4G4B4A4_UNORM_PACK16);
VAL(VK_FORMAT_B4G4R4A4_UNORM_PACK16);
VAL(VK_FORMAT_R5G6B5_UNORM_PACK16);
VAL(VK_FORMAT_B5G6R5_UNORM_PACK16);
VAL(VK_FORMAT_R5G5B5A1_UNORM_PACK16);
VAL(VK_FORMAT_B5G5R5A1_UNORM_PACK16);
VAL(VK_FORMAT_A1R5G5B5_UNORM_PACK16);
VAL(VK_FORMAT_R8_UNORM);
VAL(VK_FORMAT_R8_SNORM);
VAL(VK_FORMAT_R8_USCALED);
VAL(VK_FORMAT_R8_SSCALED);
VAL(VK_FORMAT_R8_UINT);
VAL(VK_FORMAT_R8_SINT);
VAL(VK_FORMAT_R8_SRGB);
VAL(VK_FORMAT_R8G8_UNORM);
VAL(VK_FORMAT_R8G8_SNORM);
VAL(VK_FORMAT_R8G8_USCALED);
VAL(VK_FORMAT_R8G8_SSCALED);
VAL(VK_FORMAT_R8G8_UINT);
VAL(VK_FORMAT_R8G8_SINT);
VAL(VK_FORMAT_R8G8_SRGB);
VAL(VK_FORMAT_R8G8B8_UNORM);
VAL(VK_FORMAT_R8G8B8_SNORM);
VAL(VK_FORMAT_R8G8B8_USCALED);
VAL(VK_FORMAT_R8G8B8_SSCALED);
VAL(VK_FORMAT_R8G8B8_UINT);
VAL(VK_FORMAT_R8G8B8_SINT);
VAL(VK_FORMAT_R8G8B8_SRGB);
VAL(VK_FORMAT_B8G8R8_UNORM);
VAL(VK_FORMAT_B8G8R8_SNORM);
VAL(VK_FORMAT_B8G8R8_USCALED);
VAL(VK_FORMAT_B8G8R8_SSCALED);
VAL(VK_FORMAT_B8G8R8_UINT);
VAL(VK_FORMAT_B8G8R8_SINT);
VAL(VK_FORMAT_B8G8R8_SRGB);
VAL(VK_FORMAT_R8G8B8A8_UNORM);
VAL(VK_FORMAT_R8G8B8A8_SNORM);
VAL(VK_FORMAT_R8G8B8A8_USCALED);
VAL(VK_FORMAT_R8G8B8A8_SSCALED);
VAL(VK_FORMAT_R8G8B8A8_UINT);
VAL(VK_FORMAT_R8G8B8A8_SINT);
VAL(VK_FORMAT_R8G8B8A8_SRGB); /* dota 2 */
VAL(VK_FORMAT_B8G8R8A8_UNORM);
VAL(VK_FORMAT_B8G8R8A8_SNORM);
VAL(VK_FORMAT_B8G8R8A8_USCALED);
VAL(VK_FORMAT_B8G8R8A8_SSCALED);
VAL(VK_FORMAT_B8G8R8A8_UINT);
VAL(VK_FORMAT_B8G8R8A8_SINT);
VAL(VK_FORMAT_B8G8R8A8_SRGB);
VAL(VK_FORMAT_A8B8G8R8_UNORM_PACK32);
VAL(VK_FORMAT_A8B8G8R8_SNORM_PACK32);
VAL(VK_FORMAT_A8B8G8R8_USCALED_PACK32);
VAL(VK_FORMAT_A8B8G8R8_SSCALED_PACK32);
VAL(VK_FORMAT_A8B8G8R8_UINT_PACK32);
VAL(VK_FORMAT_A8B8G8R8_SINT_PACK32);
VAL(VK_FORMAT_A8B8G8R8_SRGB_PACK32);
VAL(VK_FORMAT_A2R10G10B10_UNORM_PACK32);
VAL(VK_FORMAT_A2R10G10B10_SNORM_PACK32);
VAL(VK_FORMAT_A2R10G10B10_USCALED_PACK32);
VAL(VK_FORMAT_A2R10G10B10_SSCALED_PACK32);
VAL(VK_FORMAT_A2R10G10B10_UINT_PACK32);
VAL(VK_FORMAT_A2R10G10B10_SINT_PACK32);
VAL(VK_FORMAT_A2B10G10R10_UNORM_PACK32);
VAL(VK_FORMAT_A2B10G10R10_SNORM_PACK32);
VAL(VK_FORMAT_A2B10G10R10_USCALED_PACK32);
VAL(VK_FORMAT_A2B10G10R10_SSCALED_PACK32);
VAL(VK_FORMAT_A2B10G10R10_UINT_PACK32);
VAL(VK_FORMAT_A2B10G10R10_SINT_PACK32);
VAL(VK_FORMAT_R16_UNORM);
VAL(VK_FORMAT_R16_SNORM);
VAL(VK_FORMAT_R16_USCALED);
VAL(VK_FORMAT_R16_SSCALED);
VAL(VK_FORMAT_R16_UINT);
VAL(VK_FORMAT_R16_SINT);
VAL(VK_FORMAT_R16_SFLOAT);
VAL(VK_FORMAT_R16G16_UNORM);
VAL(VK_FORMAT_R16G16_SNORM);
VAL(VK_FORMAT_R16G16_USCALED);
VAL(VK_FORMAT_R16G16_SSCALED);
VAL(VK_FORMAT_R16G16_UINT);
VAL(VK_FORMAT_R16G16_SINT);
VAL(VK_FORMAT_R16G16_SFLOAT);
VAL(VK_FORMAT_R16G16B16_UNORM);
VAL(VK_FORMAT_R16G16B16_SNORM);
VAL(VK_FORMAT_R16G16B16_USCALED);
VAL(VK_FORMAT_R16G16B16_SSCALED);
VAL(VK_FORMAT_R16G16B16_UINT);
VAL(VK_FORMAT_R16G16B16_SINT);
VAL(VK_FORMAT_R16G16B16_SFLOAT);
VAL(VK_FORMAT_R16G16B16A16_UNORM);
VAL(VK_FORMAT_R16G16B16A16_SNORM);
VAL(VK_FORMAT_R16G16B16A16_USCALED);
VAL(VK_FORMAT_R16G16B16A16_SSCALED);
VAL(VK_FORMAT_R16G16B16A16_UINT);
VAL(VK_FORMAT_R16G16B16A16_SINT);
VAL(VK_FORMAT_R16G16B16A16_SFLOAT);
VAL(VK_FORMAT_R32_UINT);
VAL(VK_FORMAT_R32_SINT);
VAL(VK_FORMAT_R32_SFLOAT);
VAL(VK_FORMAT_R32G32_UINT);
VAL(VK_FORMAT_R32G32_SINT);
VAL(VK_FORMAT_R32G32_SFLOAT);
VAL(VK_FORMAT_R32G32B32_UINT);
VAL(VK_FORMAT_R32G32B32_SINT);
VAL(VK_FORMAT_R32G32B32_SFLOAT);
VAL(VK_FORMAT_R32G32B32A32_UINT);
VAL(VK_FORMAT_R32G32B32A32_SINT);
VAL(VK_FORMAT_R32G32B32A32_SFLOAT);
VAL(VK_FORMAT_R64_UINT);
VAL(VK_FORMAT_R64_SINT);
VAL(VK_FORMAT_R64_SFLOAT);
VAL(VK_FORMAT_R64G64_UINT);
VAL(VK_FORMAT_R64G64_SINT);
VAL(VK_FORMAT_R64G64_SFLOAT);
VAL(VK_FORMAT_R64G64B64_UINT);
VAL(VK_FORMAT_R64G64B64_SINT);
VAL(VK_FORMAT_R64G64B64_SFLOAT);
VAL(VK_FORMAT_R64G64B64A64_UINT);
VAL(VK_FORMAT_R64G64B64A64_SINT);
VAL(VK_FORMAT_R64G64B64A64_SFLOAT);
VAL(VK_FORMAT_B10G11R11_UFLOAT_PACK32);
VAL(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32);
VAL(VK_FORMAT_D16_UNORM);
VAL(VK_FORMAT_X8_D24_UNORM_PACK32);
VAL(VK_FORMAT_D32_SFLOAT);
VAL(VK_FORMAT_S8_UINT);
VAL(VK_FORMAT_D16_UNORM_S8_UINT);
VAL(VK_FORMAT_D24_UNORM_S8_UINT);
VAL(VK_FORMAT_D32_SFLOAT_S8_UINT);
VAL(VK_FORMAT_BC1_RGB_UNORM_BLOCK);
VAL(VK_FORMAT_BC1_RGB_SRGB_BLOCK);
VAL(VK_FORMAT_BC1_RGBA_UNORM_BLOCK);
VAL(VK_FORMAT_BC1_RGBA_SRGB_BLOCK);
VAL(VK_FORMAT_BC2_UNORM_BLOCK);
VAL(VK_FORMAT_BC2_SRGB_BLOCK);
VAL(VK_FORMAT_BC3_UNORM_BLOCK);
VAL(VK_FORMAT_BC3_SRGB_BLOCK);
VAL(VK_FORMAT_BC4_UNORM_BLOCK);
VAL(VK_FORMAT_BC4_SNORM_BLOCK);
VAL(VK_FORMAT_BC5_UNORM_BLOCK);
VAL(VK_FORMAT_BC5_SNORM_BLOCK);
VAL(VK_FORMAT_BC6H_UFLOAT_BLOCK);
VAL(VK_FORMAT_BC6H_SFLOAT_BLOCK);
VAL(VK_FORMAT_BC7_UNORM_BLOCK);
VAL(VK_FORMAT_BC7_SRGB_BLOCK);
VAL(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK);
VAL(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK);
VAL(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK);
VAL(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK);
VAL(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK);
VAL(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK);
VAL(VK_FORMAT_EAC_R11_UNORM_BLOCK);
VAL(VK_FORMAT_EAC_R11_SNORM_BLOCK);
VAL(VK_FORMAT_EAC_R11G11_UNORM_BLOCK);
VAL(VK_FORMAT_EAC_R11G11_SNORM_BLOCK);
VAL(VK_FORMAT_ASTC_4x4_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_4x4_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_5x4_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_5x5_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_5x5_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_6x5_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_6x5_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_6x6_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_6x6_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_8x5_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_8x5_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_8x6_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_8x6_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_8x8_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_8x8_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_10x5_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_10x5_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_10x6_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_10x6_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_10x8_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_10x8_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_10x10_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_10x10_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_12x10_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_12x10_SRGB_BLOCK);
VAL(VK_FORMAT_ASTC_12x12_UNORM_BLOCK);
VAL(VK_FORMAT_ASTC_12x12_SRGB_BLOCK);
VAL(VK_FORMAT_G8B8G8R8_422_UNORM);
VAL(VK_FORMAT_B8G8R8G8_422_UNORM);
VAL(VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM);
VAL(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM);
VAL(VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM);
VAL(VK_FORMAT_G8_B8R8_2PLANE_422_UNORM);
VAL(VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM);
VAL(VK_FORMAT_R10X6_UNORM_PACK16);
VAL(VK_FORMAT_R10X6G10X6_UNORM_2PACK16);
VAL(VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16);
VAL(VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16);
VAL(VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16);
VAL(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16);
VAL(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16);
VAL(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16);
VAL(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16);
VAL(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16);
VAL(VK_FORMAT_R12X4_UNORM_PACK16);
VAL(VK_FORMAT_R12X4G12X4_UNORM_2PACK16);
VAL(VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16);
VAL(VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16);
VAL(VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16);
VAL(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16);
VAL(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16);
VAL(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16);
VAL(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16);
VAL(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16);
VAL(VK_FORMAT_G16B16G16R16_422_UNORM);
VAL(VK_FORMAT_B16G16R16G16_422_UNORM);
VAL(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM);
VAL(VK_FORMAT_G16_B16R16_2PLANE_420_UNORM);
VAL(VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM);
VAL(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM);
VAL(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM);
VAL(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG);
VAL(VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG);
}
}
const char *result_to_str(VkResult result)
{
switch (result) {
VAL(VK_SUCCESS);
VAL(VK_NOT_READY);
VAL(VK_TIMEOUT);
VAL(VK_EVENT_SET);
VAL(VK_EVENT_RESET);
VAL(VK_INCOMPLETE);
VAL(VK_ERROR_OUT_OF_HOST_MEMORY);
VAL(VK_ERROR_OUT_OF_DEVICE_MEMORY);
VAL(VK_ERROR_INITIALIZATION_FAILED);
VAL(VK_ERROR_DEVICE_LOST);
VAL(VK_ERROR_MEMORY_MAP_FAILED);
VAL(VK_ERROR_LAYER_NOT_PRESENT);
VAL(VK_ERROR_EXTENSION_NOT_PRESENT);
VAL(VK_ERROR_FEATURE_NOT_PRESENT);
VAL(VK_ERROR_INCOMPATIBLE_DRIVER);
VAL(VK_ERROR_TOO_MANY_OBJECTS);
VAL(VK_ERROR_FORMAT_NOT_SUPPORTED);
VAL(VK_ERROR_FRAGMENTED_POOL);
VAL(VK_ERROR_OUT_OF_POOL_MEMORY);
VAL(VK_ERROR_INVALID_EXTERNAL_HANDLE);
VAL(VK_ERROR_SURFACE_LOST_KHR);
VAL(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
VAL(VK_SUBOPTIMAL_KHR);
VAL(VK_ERROR_OUT_OF_DATE_KHR);
VAL(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
VAL(VK_ERROR_VALIDATION_FAILED_EXT);
VAL(VK_ERROR_INVALID_SHADER_NV);
VAL(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
VAL(VK_ERROR_FRAGMENTATION_EXT);
VAL(VK_ERROR_NOT_PERMITTED_EXT);
VAL(VK_ERROR_INVALID_DEVICE_ADDRESS_EXT);
VAL(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
//VAL(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
//VAL(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
//VAL(VK_RESULT_BEGIN_RANGE);
//VAL(VK_RESULT_END_RANGE);
VAL(VK_RESULT_RANGE_SIZE);
VAL(VK_RESULT_MAX_ENUM);
#undef VAL
default:
return "Unknown VkResult";
break;
}
}
DXGI_FORMAT vk_format_to_dxgi(VkFormat format)
{
//this is not a real format matching !
//ex: we need to avoid stacking srg
DXGI_FORMAT dxgi_format = DXGI_FORMAT_UNKNOWN;
switch (format) {
default:
case VK_FORMAT_UNDEFINED:
break;
case VK_FORMAT_R4G4_UNORM_PACK8:
break;
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
break;
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
dxgi_format = DXGI_FORMAT_B4G4R4A4_UNORM;
break;
case VK_FORMAT_R5G6B5_UNORM_PACK16:
break;
case VK_FORMAT_B5G6R5_UNORM_PACK16:
dxgi_format = DXGI_FORMAT_B5G6R5_UNORM;
break;
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
break;
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
dxgi_format = DXGI_FORMAT_B5G5R5A1_UNORM;
break;
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
break;
case VK_FORMAT_R8_UNORM:
dxgi_format = DXGI_FORMAT_R8_UNORM;
break;
case VK_FORMAT_R8_SNORM:
dxgi_format = DXGI_FORMAT_R8_SNORM;
break;
case VK_FORMAT_R8_USCALED:
break;
case VK_FORMAT_R8_SSCALED:
break;
case VK_FORMAT_R8_UINT:
dxgi_format = DXGI_FORMAT_R8_UINT;
break;
case VK_FORMAT_R8_SINT:
dxgi_format = DXGI_FORMAT_R8_SINT;
break;
case VK_FORMAT_R8_SRGB:
break;
case VK_FORMAT_R8G8_UNORM:
dxgi_format = DXGI_FORMAT_R8G8_UNORM;
break;
case VK_FORMAT_R8G8_SNORM:
dxgi_format = DXGI_FORMAT_R8G8_SNORM;
break;
case VK_FORMAT_R8G8_USCALED:
break;
case VK_FORMAT_R8G8_SSCALED:
break;
case VK_FORMAT_R8G8_UINT:
dxgi_format = DXGI_FORMAT_R8G8_UINT;
break;
case VK_FORMAT_R8G8_SINT:
dxgi_format = DXGI_FORMAT_R8G8_UINT;
break;
case VK_FORMAT_R8G8_SRGB:
break;
case VK_FORMAT_R8G8B8_UNORM:
break;
case VK_FORMAT_R8G8B8_SNORM:
break;
case VK_FORMAT_R8G8B8_USCALED:
break;
case VK_FORMAT_R8G8B8_SSCALED:
break;
case VK_FORMAT_R8G8B8_UINT:
break;
case VK_FORMAT_R8G8B8_SINT:
break;
case VK_FORMAT_R8G8B8_SRGB:
break;
case VK_FORMAT_B8G8R8_UNORM:
break;
case VK_FORMAT_B8G8R8_SNORM:
break;
case VK_FORMAT_B8G8R8_USCALED:
break;
case VK_FORMAT_B8G8R8_SSCALED:
break;
case VK_FORMAT_B8G8R8_UINT:
break;
case VK_FORMAT_B8G8R8_SINT:
break;
case VK_FORMAT_B8G8R8_SRGB:
break;
case VK_FORMAT_R8G8B8A8_UNORM:
dxgi_format = DXGI_FORMAT_R8G8B8A8_UNORM;
break;
case VK_FORMAT_R8G8B8A8_SNORM:
dxgi_format = DXGI_FORMAT_R8G8B8A8_SNORM;
break;
case VK_FORMAT_R8G8B8A8_USCALED:
break;
case VK_FORMAT_R8G8B8A8_SSCALED:
break;
case VK_FORMAT_R8G8B8A8_UINT:
dxgi_format = DXGI_FORMAT_R8G8B8A8_UINT;
break;
case VK_FORMAT_R8G8B8A8_SINT:
dxgi_format = DXGI_FORMAT_R8G8B8A8_SINT;
break;
case VK_FORMAT_R8G8B8A8_SRGB:
dxgi_format = DXGI_FORMAT_R8G8B8A8_UNORM;
break; //dota2
case VK_FORMAT_B8G8R8A8_UNORM:
dxgi_format = DXGI_FORMAT_B8G8R8A8_UNORM;
break;
case VK_FORMAT_B8G8R8A8_SNORM:
break;
case VK_FORMAT_B8G8R8A8_USCALED:
break;
case VK_FORMAT_B8G8R8A8_SSCALED:
break;
case VK_FORMAT_B8G8R8A8_UINT:
break;
case VK_FORMAT_B8G8R8A8_SINT:
break;
case VK_FORMAT_B8G8R8A8_SRGB:
dxgi_format = DXGI_FORMAT_B8G8R8A8_UNORM;
break;
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
break;
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
break;
case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
break;
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
break;
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
break;
case VK_FORMAT_A8B8G8R8_SINT_PACK32:
break;
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
break;
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
dxgi_format = DXGI_FORMAT_R10G10B10A2_UNORM;
break;
case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
break;
case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
break;
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
break;
case VK_FORMAT_A2R10G10B10_UINT_PACK32:
dxgi_format = DXGI_FORMAT_R10G10B10A2_UINT;
break;
case VK_FORMAT_A2R10G10B10_SINT_PACK32:
break;
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
dxgi_format = DXGI_FORMAT_R10G10B10A2_UNORM;
break; //no man sky
case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
break;
case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
break;
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
break;
case VK_FORMAT_A2B10G10R10_UINT_PACK32:
break;
case VK_FORMAT_A2B10G10R10_SINT_PACK32:
break;
case VK_FORMAT_R16_UNORM:
dxgi_format = DXGI_FORMAT_R16_UNORM;
break;
case VK_FORMAT_R16_SNORM:
dxgi_format = DXGI_FORMAT_R16_SNORM;
break;
case VK_FORMAT_R16_USCALED:
break;
case VK_FORMAT_R16_SSCALED:
break;
case VK_FORMAT_R16_UINT:
dxgi_format = DXGI_FORMAT_R16_UINT;
break;
case VK_FORMAT_R16_SINT:
dxgi_format = DXGI_FORMAT_R16_SINT;
break;
case VK_FORMAT_R16_SFLOAT:
dxgi_format = DXGI_FORMAT_R16_FLOAT;
break;
case VK_FORMAT_R16G16_UNORM:
dxgi_format = DXGI_FORMAT_R16G16_UNORM;
break;
case VK_FORMAT_R16G16_SNORM:
dxgi_format = DXGI_FORMAT_R16G16_SNORM;
break;
case VK_FORMAT_R16G16_USCALED:
break;
case VK_FORMAT_R16G16_SSCALED:
break;
case VK_FORMAT_R16G16_UINT:
dxgi_format = DXGI_FORMAT_R16G16_UINT;
break;
case VK_FORMAT_R16G16_SINT:
dxgi_format = DXGI_FORMAT_R16G16_SINT;
break;
case VK_FORMAT_R16G16_SFLOAT:
dxgi_format = DXGI_FORMAT_R16G16_FLOAT;
break;
case VK_FORMAT_R16G16B16_UNORM:
break;
case VK_FORMAT_R16G16B16_SNORM:
break;
case VK_FORMAT_R16G16B16_USCALED:
break;
case VK_FORMAT_R16G16B16_SSCALED:
break;
case VK_FORMAT_R16G16B16_UINT:
break;
case VK_FORMAT_R16G16B16_SINT:
break;
case VK_FORMAT_R16G16B16_SFLOAT:
break;
case VK_FORMAT_R16G16B16A16_UNORM:
dxgi_format = DXGI_FORMAT_R16G16B16A16_UNORM;
break;
case VK_FORMAT_R16G16B16A16_SNORM:
dxgi_format = DXGI_FORMAT_R16G16B16A16_SNORM;
break;
case VK_FORMAT_R16G16B16A16_USCALED:
break;
case VK_FORMAT_R16G16B16A16_SSCALED:
break;
case VK_FORMAT_R16G16B16A16_UINT:
dxgi_format = DXGI_FORMAT_R16G16B16A16_UINT;
break;
case VK_FORMAT_R16G16B16A16_SINT:
dxgi_format = DXGI_FORMAT_R16G16B16A16_SINT;
break;
case VK_FORMAT_R16G16B16A16_SFLOAT:
dxgi_format = DXGI_FORMAT_R16G16B16A16_FLOAT;
break;
case VK_FORMAT_R32_UINT:
dxgi_format = DXGI_FORMAT_R32_UINT;
break;
case VK_FORMAT_R32_SINT:
dxgi_format = DXGI_FORMAT_R32_SINT;
break;
case VK_FORMAT_R32_SFLOAT:
dxgi_format = DXGI_FORMAT_R32_FLOAT;
break;
case VK_FORMAT_R32G32_UINT:
dxgi_format = DXGI_FORMAT_R32G32_UINT;
break;
case VK_FORMAT_R32G32_SINT:
dxgi_format = DXGI_FORMAT_R32G32_SINT;
break;
case VK_FORMAT_R32G32_SFLOAT:
dxgi_format = DXGI_FORMAT_R32G32_FLOAT;
break;
case VK_FORMAT_R32G32B32_UINT:
dxgi_format = DXGI_FORMAT_R32G32B32_UINT;
break;
case VK_FORMAT_R32G32B32_SINT:
dxgi_format = DXGI_FORMAT_R32G32B32_SINT;
break;
case VK_FORMAT_R32G32B32_SFLOAT:
dxgi_format = DXGI_FORMAT_R32G32B32_FLOAT;
break;
case VK_FORMAT_R32G32B32A32_UINT:
dxgi_format = DXGI_FORMAT_R32G32B32A32_UINT;
break;
case VK_FORMAT_R32G32B32A32_SINT:
dxgi_format = DXGI_FORMAT_R32G32B32A32_SINT;
break;
case VK_FORMAT_R32G32B32A32_SFLOAT:
dxgi_format = DXGI_FORMAT_R32G32B32A32_FLOAT;
break;
case VK_FORMAT_R64_UINT:
break;
case VK_FORMAT_R64_SINT:
break;
case VK_FORMAT_R64_SFLOAT:
break;
case VK_FORMAT_R64G64_UINT:
break;
case VK_FORMAT_R64G64_SINT:
break;
case VK_FORMAT_R64G64_SFLOAT:
break;
case VK_FORMAT_R64G64B64_UINT:
break;
case VK_FORMAT_R64G64B64_SINT:
break;
case VK_FORMAT_R64G64B64_SFLOAT:
break;
case VK_FORMAT_R64G64B64A64_UINT:
break;
case VK_FORMAT_R64G64B64A64_SINT:
break;
case VK_FORMAT_R64G64B64A64_SFLOAT:
break;
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
break;
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
break;
case VK_FORMAT_D16_UNORM:
break;
case VK_FORMAT_X8_D24_UNORM_PACK32:
break;
case VK_FORMAT_D32_SFLOAT:
break;
case VK_FORMAT_S8_UINT:
break;
case VK_FORMAT_D16_UNORM_S8_UINT:
break;
case VK_FORMAT_D24_UNORM_S8_UINT:
break;
case VK_FORMAT_D32_SFLOAT_S8_UINT:
break;
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
break;
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
break;
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
break;
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
break;
case VK_FORMAT_BC2_UNORM_BLOCK:
break;
case VK_FORMAT_BC2_SRGB_BLOCK:
break;
case VK_FORMAT_BC3_UNORM_BLOCK:
break;
case VK_FORMAT_BC3_SRGB_BLOCK:
break;
case VK_FORMAT_BC4_UNORM_BLOCK:
break;
case VK_FORMAT_BC4_SNORM_BLOCK:
break;
case VK_FORMAT_BC5_UNORM_BLOCK:
break;
case VK_FORMAT_BC5_SNORM_BLOCK:
break;
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
break;
case VK_FORMAT_BC6H_SFLOAT_BLOCK:
break;
case VK_FORMAT_BC7_UNORM_BLOCK:
break;
case VK_FORMAT_BC7_SRGB_BLOCK:
break;
case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
break;
case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
break;
case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
break;
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
break;
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
break;
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
break;
case VK_FORMAT_EAC_R11_UNORM_BLOCK:
break;
case VK_FORMAT_EAC_R11_SNORM_BLOCK:
break;
case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
break;
case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
break;
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
break;
case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
break;
case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
break;
case VK_FORMAT_G8B8G8R8_422_UNORM:
break;
case VK_FORMAT_B8G8R8G8_422_UNORM:
break;
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
break;
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
break;
case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
break;
case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
break;
case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
break;
case VK_FORMAT_R10X6_UNORM_PACK16:
break;
case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
break;
case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
break;
case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
break;
case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
break;
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
break;
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
break;
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
break;
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
break;
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
break;
case VK_FORMAT_R12X4_UNORM_PACK16:
break;
case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
break;
case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
break;
case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
break;
case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
break;
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
break;
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
break;
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
break;
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
break;
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
break;
case VK_FORMAT_G16B16G16R16_422_UNORM:
break;
case VK_FORMAT_B16G16R16G16_422_UNORM:
break;
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
break;
case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
break;
case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
break;
case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
break;
case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
break;
case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
break;
case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
break;
}
if (dxgi_format == DXGI_FORMAT_UNKNOWN) {
flog("unknown swapchain format, "
"defaulting to B8G8R8A8_UNORM");
dxgi_format = DXGI_FORMAT_B8G8R8A8_UNORM;
}
return dxgi_format;
}
//#define DEBUG_PRINT
//#define DEBUG_PRINT_PROCADDR
#ifdef DEBUG_PRINT
#include <stdio.h>
#define debug(format, ...) \
do { \
char str[256]; \
snprintf(str, sizeof(str) - 1, "%s " format "\n", \
"[OBS graphics-hook]", ##__VA_ARGS__); \
OutputDebugStringA(str); \
} while (false)
#define debug_res(x, y) debug("%s result: %s", x, result_to_str(y))
#else
#define debug(x, ...)
#define debug_res(x, y)
#endif
#ifdef DEBUG_PRINT_PROCADDR
#define debug_procaddr(format, ...) debug(format, ##__VA_ARGS__)
#else
#define debug_procaddr(format, ...)
#endif

7
plugins/win-capture/inject-helper/inject-helper.c
View File

@ -109,12 +109,7 @@ int main(int argc, char *argv_ansi[])
if (argv && argc == 4) {
DWORD size = GetModuleFileNameW(NULL, dll_path, MAX_PATH);
if (size) {
wchar_t *name_start = wcsrchr(dll_path, '\\');
if (name_start) {
*(++name_start) = 0;
wcscpy(name_start, argv[1]);
ret = inject_helper(argv, dll_path);
}
ret = inject_helper(argv, argv[1]);
}
}
LocalFree(argv);

3
plugins/win-capture/plugin-main.c
View File

@ -65,6 +65,8 @@ void wait_for_hook_initialization(void)
}
}
void init_hook_files(void);
bool obs_module_load(void)
{
struct win_version_info ver;
@ -94,6 +96,7 @@ bool obs_module_load(void)
char *config_path = obs_module_config_path(NULL);
init_hook_files();
init_hooks_thread =
CreateThread(NULL, 0, init_hooks, config_path, 0, NULL);
obs_register_source(&game_capture_info);