jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/plugins/win-capture/game-capture.c

1604 lines
43 KiB
C
Raw Normal View History

win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
#include <inttypes.h>
#include <obs-module.h>
#include <util/platform.h>
#include <windows.h>
#include <dxgi.h>
win-capture: Modify 16bit to 32bit color conversion to use SSE
2015-06-04 10:20:38 -07:00
#include <emmintrin.h>
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
#include <ipc-util/pipe.h>
#include "obfuscate.h"
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
#include "inject-library.h"
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
#include "graphics-hook-info.h"
#include "window-helpers.h"
#include "cursor-capture.h"
#define do_log(level, format, ...) \
blog(level, "[game-capture: '%s'] " format, \
obs_source_get_name(gc->source), ##__VA_ARGS__)
#define warn(format, ...) do_log(LOG_WARNING, format, ##__VA_ARGS__)
#define info(format, ...) do_log(LOG_INFO, format, ##__VA_ARGS__)
#define debug(format, ...) do_log(LOG_DEBUG, format, ##__VA_ARGS__)
#define SETTING_ANY_FULLSCREEN "capture_any_fullscreen"
#define SETTING_CAPTURE_WINDOW "window"
win-capture: Change 'Activate' text if active The game capture 'Activate' button is likely to fool users in to thinking it's not actually active if the game capture displays black, so if it's active, rename the button to 'Reactivate' in order to sort of hint at the user that it's actually active.
2015-01-04 00:39:43 -08:00
#define SETTING_ACTIVE_WINDOW "active_window"
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
#define SETTING_WINDOW_PRIORITY "priority"
#define SETTING_COMPATIBILITY "sli_compatibility"
#define SETTING_FORCE_SCALING "force_scaling"
#define SETTING_SCALE_RES "scale_res"
#define SETTING_CURSOR "capture_cursor"
#define SETTING_TRANSPARENCY "allow_transparency"
#define SETTING_LIMIT_FRAMERATE "limit_framerate"
#define SETTING_CAPTURE_OVERLAYS "capture_overlays"
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
#define SETTING_ANTI_CHEAT_HOOK "anti_cheat_hook"
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
#define TEXT_GAME_CAPTURE obs_module_text("GameCapture")
#define TEXT_ANY_FULLSCREEN obs_module_text("GameCapture.AnyFullscreen")
#define TEXT_SLI_COMPATIBILITY obs_module_text("Compatibility")
#define TEXT_ALLOW_TRANSPARENCY obs_module_text("AllowTransparency")
#define TEXT_FORCE_SCALING obs_module_text("GameCapture.ForceScaling")
#define TEXT_SCALE_RES obs_module_text("GameCapture.ScaleRes")
#define TEXT_WINDOW obs_module_text("WindowCapture.Window")
#define TEXT_MATCH_PRIORITY obs_module_text("WindowCapture.Priority")
#define TEXT_MATCH_TITLE obs_module_text("WindowCapture.Priority.Title")
#define TEXT_MATCH_CLASS obs_module_text("WindowCapture.Priority.Class")
#define TEXT_MATCH_EXE obs_module_text("WindowCapture.Priority.Exe")
#define TEXT_CAPTURE_CURSOR obs_module_text("CaptureCursor")
#define TEXT_LIMIT_FRAMERATE obs_module_text("GameCapture.LimitFramerate")
#define TEXT_CAPTURE_OVERLAYS obs_module_text("GameCapture.CaptureOverlays")
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
#define TEXT_ANTI_CHEAT_HOOK obs_module_text("GameCapture.AntiCheatHook")
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
win-capture: Use macros for intervals Having macros that state what these numbers mean is much more ideal than just having a random number thrown in there, wondering why it was used and what its purpose is (magic numbers).
2015-01-06 01:41:13 -08:00
#define DEFAULT_RETRY_INTERVAL 2.0f
#define ERROR_RETRY_INTERVAL 4.0f
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
struct game_capture_config {
char *title;
char *class;
char *executable;
enum window_priority priority;
uint32_t scale_cx;
uint32_t scale_cy;
bool cursor : 1;
bool force_shmem : 1;
bool capture_any_fullscreen : 1;
bool force_scaling : 1;
bool allow_transparency : 1;
bool limit_framerate : 1;
bool capture_overlays : 1;
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
bool anticheat_hook : 1;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
};
struct game_capture {
obs_source_t *source;
struct cursor_data cursor_data;
HANDLE injector_process;
uint32_t cx;
uint32_t cy;
uint32_t pitch;
DWORD process_id;
DWORD thread_id;
HWND next_window;
HWND window;
win-capture: Rename variables for consistency Variables that track time should not have the name 'interval', they should have the name 'time' instead so it's crystal clear that the variable is tracking time.
2015-01-05 02:53:29 -08:00
float retry_time;
float fps_reset_time;
win-capture: Add 'retry_interval' variable Adds a variable 'retry_interval' to game capture that allows the interval at which game capture checks to update to longer intervals if the hook initialization has some sort of failure. The reason why I want to do this is because I don't really like it when the hook updates too often in failure, it just leads to log file spam that I feel can be reduced, and it frequent updates feel a bit invasive. I just generally feel more comfortable reducing the interval at which the hook retries after failure.
2015-01-05 00:33:18 -08:00
float retry_interval;
win-capture: Wait before auto-fullscreen hooking If using the auto-fullscreen feature to hook in to a fullscreen, I found that if you don't wait a few seconds before initializing the hook that you can catch the process when it's just starting up and loading important libraries (especially things such as steam/uplay/etc), which can cause a little bit of interference with the process and on rare occasions cause it to crash. To help prevent the likelihood of that happening, this just makes it so that the hook waits at least 3 seconds before even attempting to inject the hook when using auto-fullscreen mode. After some extensive testing I haven't had any issues since.
2015-01-05 01:10:19 -08:00
bool wait_for_target_startup : 1;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
bool active : 1;
win-capture: Retry hooks on most failures The design to not retry the hooks on most general error is just bad. There are plenty of legitimate cases where it should retry the hook. This changes it so that if a general failure occurs or if it isn't capturing when the inject helper exits, it retries and increases the length of time between retries.
2015-01-05 00:45:47 -08:00
bool capturing : 1;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
bool activate_hook : 1;
bool process_is_64bit : 1;
win-hook: Fix variable name typo Was 'error_aqcuiring', now 'error_acquiring'
2015-01-05 00:30:12 -08:00
bool error_acquiring : 1;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
bool dwm_capture : 1;
bool initial_config : 1;
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
bool convert_16bit : 1;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
struct game_capture_config config;
ipc_pipe_server_t pipe;
gs_texture_t *texture;
struct hook_info *global_hook_info;
HANDLE keep_alive;
HANDLE hook_restart;
HANDLE hook_stop;
HANDLE hook_ready;
HANDLE hook_exit;
HANDLE hook_data_map;
HANDLE global_hook_info_map;
HANDLE target_process;
HANDLE texture_mutexes[2];
union {
struct {
struct shmem_data *shmem_data;
uint8_t *texture_buffers[2];
};
struct shtex_data *shtex_data;
void *data;
};
void (*copy_texture)(struct game_capture*);
};
struct graphics_offsets offsets32 = {0};
struct graphics_offsets offsets64 = {0};
static inline enum gs_color_format convert_format(uint32_t format)
{
switch (format) {
case DXGI_FORMAT_R8G8B8A8_UNORM: return GS_RGBA;
case DXGI_FORMAT_B8G8R8X8_UNORM: return GS_BGRX;
case DXGI_FORMAT_B8G8R8A8_UNORM: return GS_BGRA;
case DXGI_FORMAT_R10G10B10A2_UNORM: return GS_R10G10B10A2;
case DXGI_FORMAT_R16G16B16A16_UNORM: return GS_RGBA16;
case DXGI_FORMAT_R16G16B16A16_FLOAT: return GS_RGBA16F;
case DXGI_FORMAT_R32G32B32A32_FLOAT: return GS_RGBA32F;
}
return GS_UNKNOWN;
}
static void close_handle(HANDLE *p_handle)
{
HANDLE handle = *p_handle;
if (handle) {
if (handle != INVALID_HANDLE_VALUE)
CloseHandle(handle);
*p_handle = NULL;
}
}
static inline HMODULE kernel32(void)
{
static HMODULE kernel32_handle = NULL;
if (!kernel32_handle)
kernel32_handle = GetModuleHandleW(L"kernel32");
return kernel32_handle;
}
static inline HANDLE open_process(DWORD desired_access, bool inherit_handle,
DWORD process_id)
{
static HANDLE (WINAPI *open_process_proc)(DWORD, BOOL, DWORD) = NULL;
if (!open_process_proc)
open_process_proc = get_obfuscated_func(kernel32(),
"NuagUykjcxr", 0x1B694B59451ULL);
return open_process_proc(desired_access, inherit_handle, process_id);
}
static void stop_capture(struct game_capture *gc)
{
ipc_pipe_server_free(&gc->pipe);
if (gc->hook_stop) {
SetEvent(gc->hook_stop);
}
if (gc->global_hook_info) {
UnmapViewOfFile(gc->global_hook_info);
gc->global_hook_info = NULL;
}
if (gc->data) {
UnmapViewOfFile(gc->data);
gc->data = NULL;
}
close_handle(&gc->keep_alive);
close_handle(&gc->hook_restart);
close_handle(&gc->hook_stop);
close_handle(&gc->hook_ready);
close_handle(&gc->hook_exit);
close_handle(&gc->hook_data_map);
close_handle(&gc->global_hook_info_map);
close_handle(&gc->target_process);
close_handle(&gc->texture_mutexes[0]);
close_handle(&gc->texture_mutexes[1]);
if (gc->texture) {
obs_enter_graphics();
gs_texture_destroy(gc->texture);
obs_leave_graphics();
gc->texture = NULL;
}
gc->copy_texture = NULL;
win-capture: Wait before auto-fullscreen hooking If using the auto-fullscreen feature to hook in to a fullscreen, I found that if you don't wait a few seconds before initializing the hook that you can catch the process when it's just starting up and loading important libraries (especially things such as steam/uplay/etc), which can cause a little bit of interference with the process and on rare occasions cause it to crash. To help prevent the likelihood of that happening, this just makes it so that the hook waits at least 3 seconds before even attempting to inject the hook when using auto-fullscreen mode. After some extensive testing I haven't had any issues since.
2015-01-05 01:10:19 -08:00
gc->wait_for_target_startup = false;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
gc->active = false;
win-capture: Retry hooks on most failures The design to not retry the hooks on most general error is just bad. There are plenty of legitimate cases where it should retry the hook. This changes it so that if a general failure occurs or if it isn't capturing when the inject helper exits, it retries and increases the length of time between retries.
2015-01-05 00:45:47 -08:00
gc->capturing = false;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
static inline void free_config(struct game_capture_config *config)
{
bfree(config->title);
bfree(config->class);
bfree(config->executable);
memset(config, 0, sizeof(*config));
}
static void game_capture_destroy(void *data)
{
struct game_capture *gc = data;
stop_capture(gc);
obs_enter_graphics();
cursor_data_free(&gc->cursor_data);
obs_leave_graphics();
free_config(&gc->config);
bfree(gc);
}
static inline void get_config(struct game_capture_config *cfg,
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
obs_data_t *settings, const char *window)
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
{
int ret;
const char *scale_str;
build_window_strings(window, &cfg->class, &cfg->title,
&cfg->executable);
cfg->capture_any_fullscreen = obs_data_get_bool(settings,
SETTING_ANY_FULLSCREEN);
cfg->priority = (enum window_priority)obs_data_get_int(settings,
SETTING_WINDOW_PRIORITY);
cfg->force_shmem = obs_data_get_bool(settings,
SETTING_COMPATIBILITY);
cfg->cursor = obs_data_get_bool(settings, SETTING_CURSOR);
cfg->allow_transparency = obs_data_get_bool(settings,
SETTING_TRANSPARENCY);
cfg->force_scaling = obs_data_get_bool(settings,
SETTING_FORCE_SCALING);
cfg->limit_framerate = obs_data_get_bool(settings,
SETTING_LIMIT_FRAMERATE);
cfg->capture_overlays = obs_data_get_bool(settings,
SETTING_CAPTURE_OVERLAYS);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
cfg->anticheat_hook = obs_data_get_bool(settings,
SETTING_ANTI_CHEAT_HOOK);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
scale_str = obs_data_get_string(settings, SETTING_SCALE_RES);
ret = sscanf(scale_str, "%"PRIu32"x%"PRIu32,
&cfg->scale_cx, &cfg->scale_cy);
cfg->scale_cx &= ~2;
cfg->scale_cy &= ~2;
if (cfg->force_scaling) {
if (ret != 2 || cfg->scale_cx == 0 || cfg->scale_cy == 0) {
cfg->scale_cx = 0;
cfg->scale_cy = 0;
}
}
}
static inline int s_cmp(const char *str1, const char *str2)
{
if (!str1 || !str2)
return -1;
return strcmp(str1, str2);
}
static inline bool capture_needs_reset(struct game_capture_config *cfg1,
struct game_capture_config *cfg2)
{
if (cfg1->capture_any_fullscreen != cfg2->capture_any_fullscreen) {
return true;
} else if (!cfg1->capture_any_fullscreen &&
(s_cmp(cfg1->class, cfg2->class) != 0 ||
s_cmp(cfg1->title, cfg2->title) != 0 ||
s_cmp(cfg1->executable, cfg2->executable) != 0 ||
cfg1->priority != cfg2->priority)) {
return true;
} else if (cfg1->force_scaling != cfg2->force_scaling) {
return true;
} else if (cfg1->force_scaling &&
(cfg1->scale_cx != cfg2->scale_cx ||
cfg1->scale_cy != cfg2->scale_cy)) {
return true;
} else if (cfg1->force_shmem != cfg2->force_shmem) {
return true;
} else if (cfg1->limit_framerate != cfg2->limit_framerate) {
return true;
} else if (cfg1->capture_overlays != cfg2->capture_overlays) {
return true;
}
return false;
}
static void game_capture_update(void *data, obs_data_t *settings)
{
struct game_capture *gc = data;
struct game_capture_config cfg;
bool reset_capture = false;
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
const char *window = obs_data_get_string(settings,
SETTING_CAPTURE_WINDOW);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
get_config(&cfg, settings, window);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
reset_capture = capture_needs_reset(&cfg, &gc->config);
if (cfg.force_scaling && (cfg.scale_cx == 0 || cfg.scale_cy == 0)) {
win-hook: Fix variable name typo Was 'error_aqcuiring', now 'error_acquiring'
2015-01-05 00:30:12 -08:00
gc->error_acquiring = true;
win-capture: Log more hooking errors Adds a few previously-missing log messages that specify the actual reason why there was an error acquiring the hook, rather than just saying nothing.
2015-01-05 01:15:16 -08:00
warn("error acquiring, scale is bad");
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
} else {
win-hook: Fix variable name typo Was 'error_aqcuiring', now 'error_acquiring'
2015-01-05 00:30:12 -08:00
gc->error_acquiring = false;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
free_config(&gc->config);
gc->config = cfg;
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
gc->activate_hook = !!window && !!*window;
win-capture: Use macros for intervals Having macros that state what these numbers mean is much more ideal than just having a random number thrown in there, wondering why it was used and what its purpose is (magic numbers).
2015-01-06 01:41:13 -08:00
gc->retry_interval = DEFAULT_RETRY_INTERVAL;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
if (!gc->initial_config) {
if (reset_capture) {
stop_capture(gc);
}
} else {
gc->initial_config = false;
}
}
static void *game_capture_create(obs_data_t *settings, obs_source_t *source)
{
struct game_capture *gc = bzalloc(sizeof(*gc));
gc->source = source;
gc->initial_config = true;
win-capture: Use macros for intervals Having macros that state what these numbers mean is much more ideal than just having a random number thrown in there, wondering why it was used and what its purpose is (magic numbers).
2015-01-06 01:41:13 -08:00
gc->retry_interval = DEFAULT_RETRY_INTERVAL;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
game_capture_update(gc, settings);
return gc;
}
static inline HANDLE create_event_id(bool manual_reset, bool initial_state,
const char *name, DWORD process_id)
{
char new_name[128];
Fix windows printf format warnings (from mingw)
2015-02-08 15:40:51 -08:00
sprintf(new_name, "%s%lu", name, process_id);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
return CreateEventA(NULL, manual_reset, initial_state, new_name);
}
static inline HANDLE open_event_id(const char *name, DWORD process_id)
{
char new_name[128];
Fix windows printf format warnings (from mingw)
2015-02-08 15:40:51 -08:00
sprintf(new_name, "%s%lu", name, process_id);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
return OpenEventA(EVENT_ALL_ACCESS, false, new_name);
}
#define STOP_BEING_BAD \
" This is most likely due to security software. Please make sure " \
"that the OBS installation folder is excluded/ignored in the " \
"settings of the security software you are using."
static bool check_file_integrity(struct game_capture *gc, const char *file,
const char *name)
{
DWORD error;
HANDLE handle;
if (!file || !*file) {
warn("Game capture %s not found." STOP_BEING_BAD, name);
return false;
}
handle = CreateFileA(file, GENERIC_READ | GENERIC_EXECUTE,
FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (handle != INVALID_HANDLE_VALUE) {
CloseHandle(handle);
return true;
}
error = GetLastError();
if (error == ERROR_FILE_NOT_FOUND) {
warn("Game capture file '%s' not found."
STOP_BEING_BAD, file);
} else if (error == ERROR_ACCESS_DENIED) {
warn("Game capture file '%s' could not be loaded."
STOP_BEING_BAD, file);
} else {
warn("Game capture file '%s' could not be loaded: %lu."
STOP_BEING_BAD, file, error);
}
return false;
}
static inline bool is_64bit_windows(void)
{
#ifdef _WIN64
return true;
#else
BOOL x86 = false;
bool success = !!IsWow64Process(GetCurrentProcess(), &x86);
return success && !!x86;
#endif
}
static inline bool is_64bit_process(HANDLE process)
{
BOOL x86 = true;
if (is_64bit_windows()) {
bool success = !!IsWow64Process(process, &x86);
if (!success) {
return false;
}
}
return !x86;
}
static inline bool open_target_process(struct game_capture *gc)
{
gc->target_process = open_process(
PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
false, gc->process_id);
if (!gc->target_process) {
warn("could not open process: %s", gc->config.executable);
return false;
}
gc->process_is_64bit = is_64bit_process(gc->target_process);
return true;
}
static inline bool init_keepalive(struct game_capture *gc)
{
gc->keep_alive = create_event_id(false, false, EVENT_HOOK_KEEPALIVE,
gc->process_id);
if (!gc->keep_alive) {
warn("failed to create keepalive event");
return false;
}
return true;
}
static inline bool init_texture_mutexes(struct game_capture *gc)
{
gc->texture_mutexes[0] = get_mutex_plus_id(MUTEX_TEXTURE1,
gc->process_id);
gc->texture_mutexes[1] = get_mutex_plus_id(MUTEX_TEXTURE2,
gc->process_id);
if (!gc->texture_mutexes[0] || !gc->texture_mutexes[1]) {
warn("failed to create texture mutexes: %lu", GetLastError());
return false;
}
return true;
}
/* if there's already a hook in the process, then signal and start */
static inline bool attempt_existing_hook(struct game_capture *gc)
{
gc->hook_restart = open_event_id(EVENT_CAPTURE_RESTART, gc->process_id);
if (gc->hook_restart) {
debug("existing hook found, signaling process: %s",
gc->config.executable);
SetEvent(gc->hook_restart);
return true;
}
return false;
}
static inline void reset_frame_interval(struct game_capture *gc)
{
struct obs_video_info ovi;
uint64_t interval = 0;
win-capture: Always have some capture FPS limit For game capture, if a game is running at for example 800 FPS and limit capture framerate is off, it would try to capture all 800 of those frames, dramatically reducing performance more than what would ever be necessary. When limit capture framerate is off, instead of capturing all frames, capture frames at an interval of twice the OBS FPS, identical to how OBS1 works by default. This should greatly increase performance under that circumstance.
2015-09-19 09:42:29 -07:00
if (obs_get_video_info(&ovi)) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
interval = ovi.fps_den * 1000000000ULL / ovi.fps_num;
win-capture: Always have some capture FPS limit For game capture, if a game is running at for example 800 FPS and limit capture framerate is off, it would try to capture all 800 of those frames, dramatically reducing performance more than what would ever be necessary. When limit capture framerate is off, instead of capturing all frames, capture frames at an interval of twice the OBS FPS, identical to how OBS1 works by default. This should greatly increase performance under that circumstance.
2015-09-19 09:42:29 -07:00
/* Always limit capture framerate to some extent. If a game
* running at 900 FPS is being captured without some sort of
* limited capture interval, it will dramatically reduce
* performance. */
if (!gc->config.limit_framerate)
interval /= 2;
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
gc->global_hook_info->frame_interval = interval;
}
static inline bool init_hook_info(struct game_capture *gc)
{
gc->global_hook_info_map = get_hook_info(gc->process_id);
if (!gc->global_hook_info_map) {
warn("init_hook_info: get_hook_info failed: %lu",
GetLastError());
return false;
}
gc->global_hook_info = MapViewOfFile(gc->global_hook_info_map,
FILE_MAP_ALL_ACCESS, 0, 0,
sizeof(*gc->global_hook_info));
if (!gc->global_hook_info) {
warn("init_hook_info: failed to map data view: %lu",
GetLastError());
return false;
}
gc->global_hook_info->offsets = gc->process_is_64bit ?
offsets64 : offsets32;
gc->global_hook_info->capture_overlay = gc->config.capture_overlays;
gc->global_hook_info->force_shmem = gc->config.force_shmem;
gc->global_hook_info->use_scale = gc->config.force_scaling;
gc->global_hook_info->cx = gc->config.scale_cx;
gc->global_hook_info->cy = gc->config.scale_cy;
reset_frame_interval(gc);
obs_enter_graphics();
if (!gs_shared_texture_available())
gc->global_hook_info->force_shmem = true;
obs_leave_graphics();
obs_enter_graphics();
if (!gs_shared_texture_available())
gc->global_hook_info->force_shmem = true;
obs_leave_graphics();
return true;
}
static void pipe_log(void *param, uint8_t *data, size_t size)
{
struct game_capture *gc = param;
if (data && size)
info("%s", data);
}
static inline bool init_pipe(struct game_capture *gc)
{
char name[64];
Fix windows printf format warnings (from mingw)
2015-02-08 15:40:51 -08:00
sprintf(name, "%s%lu", PIPE_NAME, gc->process_id);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
if (!ipc_pipe_server_start(&gc->pipe, name, pipe_log, gc)) {
warn("init_pipe: failed to start pipe");
return false;
}
return true;
}
win-capture: Fix bad return type This was casting the return type to bool, which caused any non-zero return code be converted to 1.
2015-07-11 15:36:53 -07:00
static inline int inject_library(HANDLE process, const wchar_t *dll)
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
{
return inject_library_obf(process, dll,
"D|hkqkW`kl{k\\osofj", 0xa178ef3655e5ade7,
"[uawaRzbhh{tIdkj~~", 0x561478dbd824387c,
"[fr}pboIe`dlN}", 0x395bfbc9833590fd,
"\\`zs}gmOzhhBq", 0x12897dd89168789a,
"GbfkDaezbp~X", 0x76aff7238788f7db);
}
static inline bool hook_direct(struct game_capture *gc,
const char *hook_path_rel)
{
wchar_t hook_path_abs_w[MAX_PATH];
wchar_t *hook_path_rel_w;
wchar_t *path_ret;
HANDLE process;
int ret;
os_utf8_to_wcs_ptr(hook_path_rel, 0, &hook_path_rel_w);
if (!hook_path_rel_w) {
warn("hook_direct: could not convert string");
return false;
}
path_ret = _wfullpath(hook_path_abs_w, hook_path_rel_w, MAX_PATH);
bfree(hook_path_rel_w);
if (path_ret == NULL) {
warn("hook_direct: could not make absolute path");
return false;
}
process = open_process(PROCESS_ALL_ACCESS, false, gc->process_id);
if (!process) {
warn("hook_direct: could not open process: %s (%lu)",
gc->config.executable, GetLastError());
return false;
}
ret = inject_library(process, hook_path_abs_w);
CloseHandle(process);
if (ret != 0) {
win-capture: Fix mingw compiler warnings
2015-07-11 14:22:44 -07:00
warn("hook_direct: inject failed: %d", ret);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
return false;
}
return true;
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
static inline bool create_inject_process(struct game_capture *gc,
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
const char *inject_path, const char *hook_dll)
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
{
wchar_t *command_line_w = malloc(4096 * sizeof(wchar_t));
wchar_t *inject_path_w;
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
wchar_t *hook_dll_w;
bool anti_cheat = gc->config.anticheat_hook;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
PROCESS_INFORMATION pi = {0};
STARTUPINFO si = {0};
bool success = false;
os_utf8_to_wcs_ptr(inject_path, 0, &inject_path_w);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
os_utf8_to_wcs_ptr(hook_dll, 0, &hook_dll_w);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
si.cb = sizeof(si);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
swprintf(command_line_w, 4096, L"\"%s\" \"%s\" %lu %lu",
inject_path_w, hook_dll_w,
(unsigned long)anti_cheat,
anti_cheat ? gc->thread_id : gc->process_id);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
success = !!CreateProcessW(inject_path_w, command_line_w, NULL, NULL,
false, CREATE_NO_WINDOW, NULL, NULL, &si, &pi);
if (success) {
CloseHandle(pi.hThread);
gc->injector_process = pi.hProcess;
} else {
warn("Failed to create inject helper process: %lu",
GetLastError());
}
free(command_line_w);
bfree(inject_path_w);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
bfree(hook_dll_w);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
return success;
}
static inline bool inject_hook(struct game_capture *gc)
{
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
bool matching_architecture;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
bool success = false;
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
const char *hook_dll;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
char *inject_path;
char *hook_path;
if (gc->process_is_64bit) {
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
hook_dll = "graphics-hook64.dll";
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
inject_path = obs_module_file("inject-helper64.exe");
} else {
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
hook_dll = "graphics-hook32.dll";
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
inject_path = obs_module_file("inject-helper32.exe");
}
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
hook_path = obs_module_file(hook_dll);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
if (!check_file_integrity(gc, inject_path, "inject helper")) {
goto cleanup;
}
if (!check_file_integrity(gc, hook_path, "graphics hook")) {
goto cleanup;
}
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
#ifdef _WIN64
matching_architecture = gc->process_is_64bit;
#else
matching_architecture = !gc->process_is_64bit;
#endif
if (matching_architecture && !gc->config.anticheat_hook) {
info("using direct hook");
success = hook_direct(gc, hook_path);
} else {
info("using helper (%s hook)", gc->config.anticheat_hook ?
"compatibility" : "direct");
success = create_inject_process(gc, inject_path, hook_dll);
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
cleanup:
bfree(inject_path);
bfree(hook_path);
return success;
}
static bool init_hook(struct game_capture *gc)
{
if (gc->config.capture_any_fullscreen) {
struct dstr name = {0};
if (get_window_exe(&name, gc->next_window)) {
info("attempting to hook fullscreen process: %s",
name.array);
dstr_free(&name);
}
} else {
info("attempting to hook process: %s", gc->config.executable);
}
if (!open_target_process(gc)) {
return false;
}
if (!init_keepalive(gc)) {
return false;
}
if (!init_texture_mutexes(gc)) {
return false;
}
if (!init_hook_info(gc)) {
return false;
}
if (!init_pipe(gc)) {
return false;
}
if (!attempt_existing_hook(gc)) {
if (!inject_hook(gc)) {
return false;
}
}
gc->window = gc->next_window;
gc->next_window = NULL;
gc->active = true;
return true;
}
static void get_fullscreen_window(struct game_capture *gc)
{
HWND window = GetForegroundWindow();
MONITORINFO mi = {0};
HMONITOR monitor;
DWORD styles;
RECT rect;
gc->next_window = NULL;
if (!window) {
return;
}
if (!GetWindowRect(window, &rect)) {
return;
}
/* ignore regular maximized windows */
styles = (DWORD)GetWindowLongPtr(window, GWL_STYLE);
if ((styles & WS_MAXIMIZE) != 0 && (styles & WS_BORDER) != 0) {
return;
}
monitor = MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST);
if (!monitor) {
return;
}
mi.cbSize = sizeof(mi);
if (!GetMonitorInfo(monitor, &mi)) {
return;
}
if (rect.left == mi.rcMonitor.left &&
rect.right == mi.rcMonitor.right &&
rect.bottom == mi.rcMonitor.bottom &&
rect.top == mi.rcMonitor.top) {
win-capture: Wait before auto-fullscreen hooking If using the auto-fullscreen feature to hook in to a fullscreen, I found that if you don't wait a few seconds before initializing the hook that you can catch the process when it's just starting up and loading important libraries (especially things such as steam/uplay/etc), which can cause a little bit of interference with the process and on rare occasions cause it to crash. To help prevent the likelihood of that happening, this just makes it so that the hook waits at least 3 seconds before even attempting to inject the hook when using auto-fullscreen mode. After some extensive testing I haven't had any issues since.
2015-01-05 01:10:19 -08:00
/* always wait a bit for the target process to start up before
* starting the hook process; sometimes they have important
* modules to load first or other hooks (such as steam) need a
* little bit of time to load. ultimately this helps prevent
* crashes */
if (gc->wait_for_target_startup) {
gc->retry_interval = 3.0f;
gc->wait_for_target_startup = false;
} else {
gc->next_window = window;
}
} else {
gc->wait_for_target_startup = true;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
}
static void get_selected_window(struct game_capture *gc)
{
if (strcmpi(gc->config.class, "dwm") == 0) {
wchar_t class_w[512];
os_utf8_to_wcs(gc->config.class, 0, class_w, 512);
gc->next_window = FindWindowW(class_w, NULL);
} else {
gc->next_window = find_window(INCLUDE_MINIMIZED,
gc->config.priority,
gc->config.class,
gc->config.title,
gc->config.executable);
}
}
static void try_hook(struct game_capture *gc)
{
if (gc->config.capture_any_fullscreen) {
get_fullscreen_window(gc);
} else {
get_selected_window(gc);
}
if (gc->next_window) {
gc->thread_id = GetWindowThreadProcessId(gc->next_window,
&gc->process_id);
if (!gc->thread_id || !gc->process_id) {
win-capture: Log more hooking errors Adds a few previously-missing log messages that specify the actual reason why there was an error acquiring the hook, rather than just saying nothing.
2015-01-05 01:15:16 -08:00
warn("error acquiring, failed to get window "
Fix windows printf format warnings (from mingw)
2015-02-08 15:40:51 -08:00
"thread/process ids: %lu",
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
GetLastError());
win-hook: Fix variable name typo Was 'error_aqcuiring', now 'error_acquiring'
2015-01-05 00:30:12 -08:00
gc->error_acquiring = true;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
return;
}
if (!init_hook(gc)) {
stop_capture(gc);
}
} else {
gc->active = false;
}
}
static inline bool init_events(struct game_capture *gc)
{
if (!gc->hook_restart) {
gc->hook_restart = get_event_plus_id(EVENT_CAPTURE_RESTART,
gc->process_id);
if (!gc->hook_restart) {
warn("init_events: failed to get hook_restart "
"event: %lu", GetLastError());
return false;
}
}
if (!gc->hook_stop) {
win-capture: Fix potentially overwritten values The code neglected to take in to account that start_capture can also be called when the texture updates its size/format in the hook and 'ready' is signaled again, so it's possible that existing variables in the game capture structure could be overwritten with new ones unintentionally.
2015-01-04 04:37:34 -08:00
gc->hook_stop = get_event_plus_id(EVENT_CAPTURE_STOP,
gc->process_id);
if (!gc->hook_stop) {
warn("init_events: failed to get hook_stop event: %lu",
GetLastError());
return false;
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
if (!gc->hook_ready) {
win-capture: Fix potentially overwritten values The code neglected to take in to account that start_capture can also be called when the texture updates its size/format in the hook and 'ready' is signaled again, so it's possible that existing variables in the game capture structure could be overwritten with new ones unintentionally.
2015-01-04 04:37:34 -08:00
gc->hook_ready = get_event_plus_id(EVENT_HOOK_READY,
gc->process_id);
if (!gc->hook_ready) {
warn("init_events: failed to get hook_ready event: %lu",
GetLastError());
return false;
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
if (!gc->hook_exit) {
win-capture: Fix potentially overwritten values The code neglected to take in to account that start_capture can also be called when the texture updates its size/format in the hook and 'ready' is signaled again, so it's possible that existing variables in the game capture structure could be overwritten with new ones unintentionally.
2015-01-04 04:37:34 -08:00
gc->hook_exit = get_event_plus_id(EVENT_HOOK_EXIT,
gc->process_id);
if (!gc->hook_exit) {
warn("init_events: failed to get hook_exit event: %lu",
GetLastError());
return false;
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
return true;
}
win-capture: Fix game capture acquiring issue If capture starts too quickly, the file mapping will return 2, which means file not found, and it would then reset the capture and try again. Sometimes this would result in long intervals where it wouldn't capture. This fixes the issue by simply making game capture retry if file mapping returns error number 2.
2015-03-25 14:08:07 -07:00
enum capture_result {
CAPTURE_FAIL,
CAPTURE_RETRY,
CAPTURE_SUCCESS
};
static inline enum capture_result init_capture_data(struct game_capture *gc)
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
{
char name[64];
sprintf(name, "%s%u", SHMEM_TEXTURE, gc->global_hook_info->map_id);
gc->cx = gc->global_hook_info->cx;
gc->cy = gc->global_hook_info->cy;
gc->pitch = gc->global_hook_info->pitch;
win-capture: Fix potentially overwritten values The code neglected to take in to account that start_capture can also be called when the texture updates its size/format in the hook and 'ready' is signaled again, so it's possible that existing variables in the game capture structure could be overwritten with new ones unintentionally.
2015-01-04 04:37:34 -08:00
if (gc->data) {
UnmapViewOfFile(gc->data);
gc->data = NULL;
}
CloseHandle(gc->hook_data_map);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
gc->hook_data_map = OpenFileMappingA(FILE_MAP_ALL_ACCESS, false, name);
if (!gc->hook_data_map) {
win-capture: Change error message for file mapping If shared memory file mapping fails, I've found that it's somewhat normal due to something in windows -- usually the capture will always eventually start up after a few tries. Only seems to apply to some games though, for example seems to happen with counterstrike a lot for some strange reason. Capture always eventually starts back up though. I remember seeing this with OBS1 as well in many cases but always thought it was some sort of fluke
2015-01-05 01:16:47 -08:00
DWORD error = GetLastError();
if (error == 2) {
win-capture: Fix game capture acquiring issue If capture starts too quickly, the file mapping will return 2, which means file not found, and it would then reset the capture and try again. Sometimes this would result in long intervals where it wouldn't capture. This fixes the issue by simply making game capture retry if file mapping returns error number 2.
2015-03-25 14:08:07 -07:00
return CAPTURE_RETRY;
win-capture: Change error message for file mapping If shared memory file mapping fails, I've found that it's somewhat normal due to something in windows -- usually the capture will always eventually start up after a few tries. Only seems to apply to some games though, for example seems to happen with counterstrike a lot for some strange reason. Capture always eventually starts back up though. I remember seeing this with OBS1 as well in many cases but always thought it was some sort of fluke
2015-01-05 01:16:47 -08:00
} else {
warn("init_capture_data: failed to open file "
"mapping: %lu", error);
}
win-capture: Fix game capture acquiring issue If capture starts too quickly, the file mapping will return 2, which means file not found, and it would then reset the capture and try again. Sometimes this would result in long intervals where it wouldn't capture. This fixes the issue by simply making game capture retry if file mapping returns error number 2.
2015-03-25 14:08:07 -07:00
return CAPTURE_FAIL;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
gc->data = MapViewOfFile(gc->hook_data_map, FILE_MAP_ALL_ACCESS, 0, 0,
gc->global_hook_info->map_size);
if (!gc->data) {
warn("init_capture_data: failed to map data view: %lu",
GetLastError());
win-capture: Fix game capture acquiring issue If capture starts too quickly, the file mapping will return 2, which means file not found, and it would then reset the capture and try again. Sometimes this would result in long intervals where it wouldn't capture. This fixes the issue by simply making game capture retry if file mapping returns error number 2.
2015-03-25 14:08:07 -07:00
return CAPTURE_FAIL;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
win-capture: Fix game capture acquiring issue If capture starts too quickly, the file mapping will return 2, which means file not found, and it would then reset the capture and try again. Sometimes this would result in long intervals where it wouldn't capture. This fixes the issue by simply making game capture retry if file mapping returns error number 2.
2015-03-25 14:08:07 -07:00
return CAPTURE_SUCCESS;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
#define PIXEL_16BIT_SIZE 2
#define PIXEL_32BIT_SIZE 4
static inline uint32_t convert_5_to_8bit(uint16_t val)
{
return (uint32_t)((double)(val & 0x1F) * (255.0/31.0));
}
static inline uint32_t convert_6_to_8bit(uint16_t val)
{
return (uint32_t)((double)(val & 0x3F) * (255.0/63.0));
}
static void copy_b5g6r5_tex(struct game_capture *gc, int cur_texture,
uint8_t *data, uint32_t pitch)
{
uint8_t *input = gc->texture_buffers[cur_texture];
uint32_t gc_cx = gc->cx;
uint32_t gc_cy = gc->cy;
uint32_t gc_pitch = gc->pitch;
for (uint32_t y = 0; y < gc_cy; y++) {
win-capture: Modify 16bit to 32bit color conversion to use SSE
2015-06-04 10:20:38 -07:00
uint8_t *row = input + (gc_pitch * y);
uint8_t *out = data + (pitch * y);
for (uint32_t x = 0; x < gc_cx; x += 8) {
__m128i pixels_blue, pixels_green, pixels_red;
__m128i pixels_result;
__m128i *pixels_dest;
__m128i *pixels_src = (__m128i*)(row + x * sizeof(uint16_t));
__m128i pixels = _mm_load_si128(pixels_src);
__m128i zero = _mm_setzero_si128();
__m128i pixels_low = _mm_unpacklo_epi16(pixels, zero);
__m128i pixels_high = _mm_unpackhi_epi16(pixels, zero);
__m128i blue_channel_mask = _mm_set1_epi32(0x0000001F);
__m128i blue_offset = _mm_set1_epi32(0x00000003);
__m128i green_channel_mask = _mm_set1_epi32(0x000007E0);
__m128i green_offset = _mm_set1_epi32(0x00000008);
__m128i red_channel_mask = _mm_set1_epi32(0x0000F800);
__m128i red_offset = _mm_set1_epi32(0x00000300);
pixels_blue = _mm_and_si128(pixels_low, blue_channel_mask);
pixels_blue = _mm_slli_epi32(pixels_blue, 3);
pixels_blue = _mm_add_epi32(pixels_blue, blue_offset);
pixels_green = _mm_and_si128(pixels_low, green_channel_mask);
pixels_green = _mm_add_epi32(pixels_green, green_offset);
pixels_green = _mm_slli_epi32(pixels_green, 5);
pixels_red = _mm_and_si128(pixels_low, red_channel_mask);
pixels_red = _mm_add_epi32(pixels_red, red_offset);
pixels_red = _mm_slli_epi32(pixels_red, 8);
pixels_result = _mm_set1_epi32(0xFF000000);
pixels_result = _mm_or_si128(pixels_result, pixels_blue);
pixels_result = _mm_or_si128(pixels_result, pixels_green);
pixels_result = _mm_or_si128(pixels_result, pixels_red);
pixels_dest = (__m128i*)(out + x * sizeof(uint32_t));
_mm_store_si128(pixels_dest, pixels_result);
pixels_blue = _mm_and_si128(pixels_high, blue_channel_mask);
pixels_blue = _mm_slli_epi32(pixels_blue, 3);
pixels_blue = _mm_add_epi32(pixels_blue, blue_offset);
pixels_green = _mm_and_si128(pixels_high, green_channel_mask);
pixels_green = _mm_add_epi32(pixels_green, green_offset);
pixels_green = _mm_slli_epi32(pixels_green, 5);
pixels_red = _mm_and_si128(pixels_high, red_channel_mask);
pixels_red = _mm_add_epi32(pixels_red, red_offset);
pixels_red = _mm_slli_epi32(pixels_red, 8);
pixels_result = _mm_set1_epi32(0xFF000000);
pixels_result = _mm_or_si128(pixels_result, pixels_blue);
pixels_result = _mm_or_si128(pixels_result, pixels_green);
pixels_result = _mm_or_si128(pixels_result, pixels_red);
pixels_dest = (__m128i*)(out + (x + 4) * sizeof(uint32_t));
_mm_store_si128(pixels_dest, pixels_result);
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
}
}
}
static void copy_b5g5r5a1_tex(struct game_capture *gc, int cur_texture,
uint8_t *data, uint32_t pitch)
{
uint8_t *input = gc->texture_buffers[cur_texture];
uint32_t gc_cx = gc->cx;
uint32_t gc_cy = gc->cy;
uint32_t gc_pitch = gc->pitch;
for (uint32_t y = 0; y < gc_cy; y++) {
win-capture: Modify 16bit to 32bit color conversion to use SSE
2015-06-04 10:20:38 -07:00
uint8_t *row = input + (gc_pitch * y);
uint8_t *out = data + (pitch * y);
for (uint32_t x = 0; x < gc_cx; x += 8) {
__m128i pixels_blue, pixels_green, pixels_red, pixels_alpha;
__m128i pixels_result;
__m128i *pixels_dest;
__m128i *pixels_src = (__m128i*)(row + x * sizeof(uint16_t));
__m128i pixels = _mm_load_si128(pixels_src);
__m128i zero = _mm_setzero_si128();
__m128i pixels_low = _mm_unpacklo_epi16(pixels, zero);
__m128i pixels_high = _mm_unpackhi_epi16(pixels, zero);
__m128i blue_channel_mask = _mm_set1_epi32(0x0000001F);
__m128i blue_offset = _mm_set1_epi32(0x00000003);
__m128i green_channel_mask = _mm_set1_epi32(0x000003E0);
__m128i green_offset = _mm_set1_epi32(0x000000C);
__m128i red_channel_mask = _mm_set1_epi32(0x00007C00);
__m128i red_offset = _mm_set1_epi32(0x00000180);
__m128i alpha_channel_mask = _mm_set1_epi32(0x00008000);
__m128i alpha_offset = _mm_set1_epi32(0x00000001);
__m128i alpha_mask32 = _mm_set1_epi32(0xFF000000);
pixels_blue = _mm_and_si128(pixels_low, blue_channel_mask);
pixels_blue = _mm_slli_epi32(pixels_blue, 3);
pixels_blue = _mm_add_epi32(pixels_blue, blue_offset);
pixels_green = _mm_and_si128(pixels_low, green_channel_mask);
pixels_green = _mm_add_epi32(pixels_green, green_offset);
pixels_green = _mm_slli_epi32(pixels_green, 6);
pixels_red = _mm_and_si128(pixels_low, red_channel_mask);
pixels_red = _mm_add_epi32(pixels_red, red_offset);
pixels_red = _mm_slli_epi32(pixels_red, 9);
pixels_alpha = _mm_and_si128(pixels_low, alpha_channel_mask);
pixels_alpha = _mm_srli_epi32(pixels_alpha, 15);
pixels_alpha = _mm_sub_epi32(pixels_alpha, alpha_offset);
pixels_alpha = _mm_andnot_si128(pixels_alpha, alpha_mask32);
pixels_result = pixels_red;
pixels_result = _mm_or_si128(pixels_result, pixels_alpha);
pixels_result = _mm_or_si128(pixels_result, pixels_blue);
pixels_result = _mm_or_si128(pixels_result, pixels_green);
pixels_dest = (__m128i*)(out + x * sizeof(uint32_t));
_mm_store_si128(pixels_dest, pixels_result);
pixels_blue = _mm_and_si128(pixels_high, blue_channel_mask);
pixels_blue = _mm_slli_epi32(pixels_blue, 3);
pixels_blue = _mm_add_epi32(pixels_blue, blue_offset);
pixels_green = _mm_and_si128(pixels_high, green_channel_mask);
pixels_green = _mm_add_epi32(pixels_green, green_offset);
pixels_green = _mm_slli_epi32(pixels_green, 6);
pixels_red = _mm_and_si128(pixels_high, red_channel_mask);
pixels_red = _mm_add_epi32(pixels_red, red_offset);
pixels_red = _mm_slli_epi32(pixels_red, 9);
pixels_alpha = _mm_and_si128(pixels_high, alpha_channel_mask);
pixels_alpha = _mm_srli_epi32(pixels_alpha, 15);
pixels_alpha = _mm_sub_epi32(pixels_alpha, alpha_offset);
pixels_alpha = _mm_andnot_si128(pixels_alpha, alpha_mask32);
pixels_result = pixels_red;
pixels_result = _mm_or_si128(pixels_result, pixels_alpha);
pixels_result = _mm_or_si128(pixels_result, pixels_blue);
pixels_result = _mm_or_si128(pixels_result, pixels_green);
pixels_dest = (__m128i*)(out + (x + 4) * sizeof(uint32_t));
_mm_store_si128(pixels_dest, pixels_result);
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
}
}
}
static inline void copy_16bit_tex(struct game_capture *gc, int cur_texture,
uint8_t *data, uint32_t pitch)
{
if (gc->global_hook_info->format == DXGI_FORMAT_B5G5R5A1_UNORM) {
copy_b5g5r5a1_tex(gc, cur_texture, data, pitch);
} else if (gc->global_hook_info->format == DXGI_FORMAT_B5G6R5_UNORM) {
copy_b5g6r5_tex(gc, cur_texture, data, pitch);
}
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
static void copy_shmem_tex(struct game_capture *gc)
{
int cur_texture = gc->shmem_data->last_tex;
HANDLE mutex = NULL;
uint32_t pitch;
int next_texture;
uint8_t *data;
if (cur_texture < 0 || cur_texture > 1)
return;
next_texture = cur_texture == 1 ? 0 : 1;
if (object_signalled(gc->texture_mutexes[cur_texture])) {
mutex = gc->texture_mutexes[cur_texture];
} else if (object_signalled(gc->texture_mutexes[next_texture])) {
mutex = gc->texture_mutexes[next_texture];
cur_texture = next_texture;
} else {
return;
}
if (gs_texture_map(gc->texture, &data, &pitch)) {
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
if (gc->convert_16bit) {
copy_16bit_tex(gc, cur_texture, data, pitch);
} else if (pitch == gc->pitch) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
memcpy(data, gc->texture_buffers[cur_texture],
pitch * gc->cy);
} else {
uint8_t *input = gc->texture_buffers[cur_texture];
uint32_t best_pitch =
pitch < gc->pitch ? pitch : gc->pitch;
for (uint32_t y = 0; y < gc->cy; y++) {
uint8_t *line_in = input + gc->pitch * y;
uint8_t *line_out = data + pitch * y;
memcpy(line_out, line_in, best_pitch);
}
}
gs_texture_unmap(gc->texture);
}
ReleaseMutex(mutex);
}
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
static inline bool is_16bit_format(uint32_t format)
{
return format == DXGI_FORMAT_B5G5R5A1_UNORM ||
format == DXGI_FORMAT_B5G6R5_UNORM;
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
static inline bool init_shmem_capture(struct game_capture *gc)
{
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
enum gs_color_format format;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
gc->texture_buffers[0] =
(uint8_t*)gc->data + gc->shmem_data->tex1_offset;
gc->texture_buffers[1] =
(uint8_t*)gc->data + gc->shmem_data->tex2_offset;
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
gc->convert_16bit = is_16bit_format(gc->global_hook_info->format);
format = gc->convert_16bit ?
GS_BGRA : convert_format(gc->global_hook_info->format);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
obs_enter_graphics();
win-capture: Fix potentially overwritten values The code neglected to take in to account that start_capture can also be called when the texture updates its size/format in the hook and 'ready' is signaled again, so it's possible that existing variables in the game capture structure could be overwritten with new ones unintentionally.
2015-01-04 04:37:34 -08:00
gs_texture_destroy(gc->texture);
win-capture: Implement D3D8 game capture support
2015-02-06 09:43:24 -08:00
gc->texture = gs_texture_create(gc->cx, gc->cy, format, 1, NULL,
GS_DYNAMIC);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
obs_leave_graphics();
if (!gc->texture) {
warn("init_shmem_capture: failed to create texture");
return false;
}
gc->copy_texture = copy_shmem_tex;
return true;
}
static inline bool init_shtex_capture(struct game_capture *gc)
{
obs_enter_graphics();
win-capture: Fix potentially overwritten values The code neglected to take in to account that start_capture can also be called when the texture updates its size/format in the hook and 'ready' is signaled again, so it's possible that existing variables in the game capture structure could be overwritten with new ones unintentionally.
2015-01-04 04:37:34 -08:00
gs_texture_destroy(gc->texture);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
gc->texture = gs_texture_open_shared(gc->shtex_data->tex_handle);
obs_leave_graphics();
if (!gc->texture) {
warn("init_shtex_capture: failed to open shared handle");
return false;
}
return true;
}
static bool start_capture(struct game_capture *gc)
{
if (!init_events(gc)) {
return false;
}
if (gc->global_hook_info->type == CAPTURE_TYPE_MEMORY) {
if (!init_shmem_capture(gc)) {
return false;
}
} else {
if (!init_shtex_capture(gc)) {
return false;
}
}
return true;
}
win-capture: Clarify if statement via inline func Clears up a warning (to prevent && and || confusion), and clarifies what specifically the if statement is trying to accomplish (check to see if the capture is valid)
2015-02-08 16:07:48 -08:00
static inline bool capture_valid(struct game_capture *gc)
{
if (!gc->dwm_capture && !IsWindow(gc->window))
return false;
return !object_signalled(gc->target_process);
}
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
static void game_capture_tick(void *data, float seconds)
{
struct game_capture *gc = data;
if (gc->hook_stop && object_signalled(gc->hook_stop)) {
stop_capture(gc);
}
if (gc->active && !gc->hook_ready && gc->process_id) {
gc->hook_ready = get_event_plus_id(EVENT_HOOK_READY,
gc->process_id);
}
if (gc->injector_process && object_signalled(gc->injector_process)) {
DWORD exit_code = 0;
GetExitCodeProcess(gc->injector_process, &exit_code);
close_handle(&gc->injector_process);
if (exit_code != 0) {
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
warn("inject process failed: %ld", (long)exit_code);
win-hook: Fix variable name typo Was 'error_aqcuiring', now 'error_acquiring'
2015-01-05 00:30:12 -08:00
gc->error_acquiring = true;
win-capture: Retry hooks on most failures The design to not retry the hooks on most general error is just bad. There are plenty of legitimate cases where it should retry the hook. This changes it so that if a general failure occurs or if it isn't capturing when the inject helper exits, it retries and increases the length of time between retries.
2015-01-05 00:45:47 -08:00
} else if (!gc->capturing) {
win-capture: Use macros for intervals Having macros that state what these numbers mean is much more ideal than just having a random number thrown in there, wondering why it was used and what its purpose is (magic numbers).
2015-01-06 01:41:13 -08:00
gc->retry_interval = ERROR_RETRY_INTERVAL;
win-capture: Retry hooks on most failures The design to not retry the hooks on most general error is just bad. There are plenty of legitimate cases where it should retry the hook. This changes it so that if a general failure occurs or if it isn't capturing when the inject helper exits, it retries and increases the length of time between retries.
2015-01-05 00:45:47 -08:00
stop_capture(gc);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
}
if (gc->hook_ready && object_signalled(gc->hook_ready)) {
win-capture: Fix game capture acquiring issue If capture starts too quickly, the file mapping will return 2, which means file not found, and it would then reset the capture and try again. Sometimes this would result in long intervals where it wouldn't capture. This fixes the issue by simply making game capture retry if file mapping returns error number 2.
2015-03-25 14:08:07 -07:00
enum capture_result result = init_capture_data(gc);
if (result == CAPTURE_SUCCESS)
gc->capturing = start_capture(gc);
if (result != CAPTURE_RETRY && !gc->capturing) {
win-capture: Use macros for intervals Having macros that state what these numbers mean is much more ideal than just having a random number thrown in there, wondering why it was used and what its purpose is (magic numbers).
2015-01-06 01:41:13 -08:00
gc->retry_interval = ERROR_RETRY_INTERVAL;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
stop_capture(gc);
}
}
win-capture: Rename variables for consistency Variables that track time should not have the name 'interval', they should have the name 'time' instead so it's crystal clear that the variable is tracking time.
2015-01-05 02:53:29 -08:00
gc->retry_time += seconds;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
if (!gc->active) {
win-capture: Don't hook game if source not showing
2015-09-21 21:38:54 -07:00
if (!obs_source_showing(gc->source)) {
gc->retry_time = 0.0f;
return;
}
win-capture: Add 'retry_interval' variable Adds a variable 'retry_interval' to game capture that allows the interval at which game capture checks to update to longer intervals if the hook initialization has some sort of failure. The reason why I want to do this is because I don't really like it when the hook updates too often in failure, it just leads to log file spam that I feel can be reduced, and it frequent updates feel a bit invasive. I just generally feel more comfortable reducing the interval at which the hook retries after failure.
2015-01-05 00:33:18 -08:00
if (!gc->error_acquiring &&
win-capture: Rename variables for consistency Variables that track time should not have the name 'interval', they should have the name 'time' instead so it's crystal clear that the variable is tracking time.
2015-01-05 02:53:29 -08:00
gc->retry_time > gc->retry_interval) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
if (gc->config.capture_any_fullscreen ||
gc->activate_hook) {
try_hook(gc);
win-capture: Rename variables for consistency Variables that track time should not have the name 'interval', they should have the name 'time' instead so it's crystal clear that the variable is tracking time.
2015-01-05 02:53:29 -08:00
gc->retry_time = 0.0f;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
}
} else {
win-capture: Clarify if statement via inline func Clears up a warning (to prevent && and || confusion), and clarifies what specifically the if statement is trying to accomplish (check to see if the capture is valid)
2015-02-08 16:07:48 -08:00
if (!capture_valid(gc)) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
info("capture window no longer exists, "
"terminating capture");
stop_capture(gc);
} else {
if (gc->copy_texture) {
obs_enter_graphics();
gc->copy_texture(gc);
obs_leave_graphics();
}
if (gc->config.cursor) {
obs_enter_graphics();
cursor_capture(&gc->cursor_data);
obs_leave_graphics();
}
win-capture: Rename variables for consistency Variables that track time should not have the name 'interval', they should have the name 'time' instead so it's crystal clear that the variable is tracking time.
2015-01-05 02:53:29 -08:00
gc->fps_reset_time += seconds;
if (gc->fps_reset_time >= gc->retry_interval) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
reset_frame_interval(gc);
win-capture: Rename variables for consistency Variables that track time should not have the name 'interval', they should have the name 'time' instead so it's crystal clear that the variable is tracking time.
2015-01-05 02:53:29 -08:00
gc->fps_reset_time = 0.0f;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
}
}
}
static inline void game_capture_render_cursor(struct game_capture *gc)
{
POINT p = {0};
if (!gc->global_hook_info->window ||
!gc->global_hook_info->base_cx ||
!gc->global_hook_info->base_cy)
return;
win-capture: Fix ptr -> int cast warnings (mingw)
2015-02-08 16:11:51 -08:00
ClientToScreen((HWND)(uintptr_t)gc->global_hook_info->window, &p);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
float x_scale = (float)gc->global_hook_info->cx /
(float)gc->global_hook_info->base_cx;
float y_scale = (float)gc->global_hook_info->cy /
(float)gc->global_hook_info->base_cy;
win-capture: Don't draw cursor if outside area
2014-12-31 23:58:41 -08:00
cursor_draw(&gc->cursor_data, -p.x, -p.y, x_scale, y_scale,
gc->global_hook_info->base_cx,
gc->global_hook_info->base_cy);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
static void game_capture_render(void *data, gs_effect_t *effect)
{
struct game_capture *gc = data;
if (!gc->texture)
return;
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
effect = obs_get_base_effect(gc->config.allow_transparency ?
OBS_EFFECT_DEFAULT : OBS_EFFECT_OPAQUE);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
while (gs_effect_loop(effect, "Draw")) {
obs_source_draw(gc->texture, 0, 0, 0, 0,
gc->global_hook_info->flip);
Make capture sources w/o alpha use opaque effect This fixes an issue primarily with filter rendering: when capturing windows and displays, their alpha channel is almost always 0, causing the image to be completely invisible unintentionally. The original fix for this for many sources was just to turn off the blending, which would be fine if you're not rendering any filters, but filters will render to render targets first, and that lack of alpha will end up carrying over in to the final image. This doesn't apply to any mac captures because mac actually seems to set the alpha channel to 1.
2015-03-14 00:38:09 -07:00
if (gc->config.allow_transparency && gc->config.cursor) {
game_capture_render_cursor(gc);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
Make capture sources w/o alpha use opaque effect This fixes an issue primarily with filter rendering: when capturing windows and displays, their alpha channel is almost always 0, causing the image to be completely invisible unintentionally. The original fix for this for many sources was just to turn off the blending, which would be fine if you're not rendering any filters, but filters will render to render targets first, and that lack of alpha will end up carrying over in to the final image. This doesn't apply to any mac captures because mac actually seems to set the alpha channel to 1.
2015-03-14 00:38:09 -07:00
}
if (!gc->config.allow_transparency && gc->config.cursor) {
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
effect = obs_get_base_effect(OBS_EFFECT_DEFAULT);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
Make capture sources w/o alpha use opaque effect This fixes an issue primarily with filter rendering: when capturing windows and displays, their alpha channel is almost always 0, causing the image to be completely invisible unintentionally. The original fix for this for many sources was just to turn off the blending, which would be fine if you're not rendering any filters, but filters will render to render targets first, and that lack of alpha will end up carrying over in to the final image. This doesn't apply to any mac captures because mac actually seems to set the alpha channel to 1.
2015-03-14 00:38:09 -07:00
while (gs_effect_loop(effect, "Draw")) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
game_capture_render_cursor(gc);
}
}
}
static uint32_t game_capture_width(void *data)
{
struct game_capture *gc = data;
Revert "win-capture: Use texture for actual source size" This reverts commit 74354dc4cf47af0d36d177366c57edb10acdd5b6. I really shouldn't have modified this, especially not in this way. Was the wrong approach. The thing I was trying to fix was very rare as well.
2015-08-16 11:41:49 -07:00
return gc->active ? gc->global_hook_info->cx : 0;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
static uint32_t game_capture_height(void *data)
{
struct game_capture *gc = data;
Revert "win-capture: Use texture for actual source size" This reverts commit 74354dc4cf47af0d36d177366c57edb10acdd5b6. I really shouldn't have modified this, especially not in this way. Was the wrong approach. The thing I was trying to fix was very rare as well.
2015-08-16 11:41:49 -07:00
return gc->active ? gc->global_hook_info->cy : 0;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
static const char *game_capture_name(void *unused)
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
{
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
UNUSED_PARAMETER(unused);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
return TEXT_GAME_CAPTURE;
}
static void game_capture_defaults(obs_data_t *settings)
{
obs_data_set_default_bool(settings, SETTING_ANY_FULLSCREEN, true);
obs_data_set_default_int(settings, SETTING_WINDOW_PRIORITY,
(int)WINDOW_PRIORITY_EXE);
obs_data_set_default_bool(settings, SETTING_COMPATIBILITY, false);
obs_data_set_default_bool(settings, SETTING_FORCE_SCALING, false);
obs_data_set_default_bool(settings, SETTING_CURSOR, true);
obs_data_set_default_bool(settings, SETTING_TRANSPARENCY, false);
obs_data_set_default_string(settings, SETTING_SCALE_RES, "0x0");
obs_data_set_default_bool(settings, SETTING_LIMIT_FRAMERATE, false);
obs_data_set_default_bool(settings, SETTING_CAPTURE_OVERLAYS, false);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
obs_data_set_default_bool(settings, SETTING_ANTI_CHEAT_HOOK, false);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
static bool any_fullscreen_callback(obs_properties_t *ppts,
obs_property_t *p, obs_data_t *settings)
{
bool any_fullscreen = obs_data_get_bool(settings,
SETTING_ANY_FULLSCREEN);
p = obs_properties_get(ppts, SETTING_CAPTURE_WINDOW);
obs_property_set_enabled(p, !any_fullscreen);
p = obs_properties_get(ppts, SETTING_WINDOW_PRIORITY);
obs_property_set_enabled(p, !any_fullscreen);
return true;
}
static bool use_scaling_callback(obs_properties_t *ppts, obs_property_t *p,
obs_data_t *settings)
{
bool use_scale = obs_data_get_bool(settings, SETTING_FORCE_SCALING);
p = obs_properties_get(ppts, SETTING_SCALE_RES);
obs_property_set_enabled(p, use_scale);
return true;
}
static void insert_preserved_val(obs_property_t *p, const char *val)
{
char *class = NULL;
char *title = NULL;
char *executable = NULL;
struct dstr desc = {0};
build_window_strings(val, &class, &title, &executable);
dstr_printf(&desc, "[%s]: %s", executable, title);
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
obs_property_list_insert_string(p, 1, desc.array, val);
obs_property_list_item_disable(p, 1, true);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
dstr_free(&desc);
bfree(class);
bfree(title);
bfree(executable);
}
static bool window_changed_callback(obs_properties_t *ppts, obs_property_t *p,
obs_data_t *settings)
{
const char *cur_val;
bool match = false;
size_t i = 0;
cur_val = obs_data_get_string(settings, SETTING_CAPTURE_WINDOW);
if (!cur_val) {
return false;
}
for (;;) {
const char *val = obs_property_list_item_string(p, i++);
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
if (!val)
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
break;
if (strcmp(val, cur_val) == 0) {
match = true;
break;
}
}
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
if (cur_val && *cur_val && !match) {
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
insert_preserved_val(p, cur_val);
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
return true;
win-capture: Change 'Activate' text if active The game capture 'Activate' button is likely to fool users in to thinking it's not actually active if the game capture displays black, so if it's active, rename the button to 'Reactivate' in order to sort of hint at the user that it's actually active.
2015-01-04 00:39:43 -08:00
}
win-capture: Mark unused parameters
2015-02-08 16:27:45 -08:00
UNUSED_PARAMETER(ppts);
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
return false;
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
}
static const double default_scale_vals[] = {
1.25,
1.5,
2.0,
2.5,
3.0
};
#define NUM_DEFAULT_SCALE_VALS \
(sizeof(default_scale_vals) / sizeof(default_scale_vals[0]))
static BOOL CALLBACK EnumFirstMonitor(HMONITOR monitor, HDC hdc,
LPRECT rc, LPARAM data)
{
*(HMONITOR*)data = monitor;
win-capture: Mark unused parameters
2015-02-08 16:27:45 -08:00
UNUSED_PARAMETER(hdc);
UNUSED_PARAMETER(rc);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
return false;
}
static obs_properties_t *game_capture_properties(void *data)
{
HMONITOR monitor;
uint32_t cx = 1920;
uint32_t cy = 1080;
/* scaling is free form, this is mostly just to provide some common
* values */
bool success = !!EnumDisplayMonitors(NULL, NULL, EnumFirstMonitor,
(LPARAM)&monitor);
if (success) {
MONITORINFO mi = {0};
mi.cbSize = sizeof(mi);
if (!!GetMonitorInfo(monitor, &mi)) {
cx = (uint32_t)(mi.rcMonitor.right - mi.rcMonitor.left);
cy = (uint32_t)(mi.rcMonitor.bottom - mi.rcMonitor.top);
}
}
obs_properties_t *ppts = obs_properties_create();
obs_property_t *p;
p = obs_properties_add_bool(ppts, SETTING_ANY_FULLSCREEN,
TEXT_ANY_FULLSCREEN);
obs_property_set_modified_callback(p, any_fullscreen_callback);
p = obs_properties_add_list(ppts, SETTING_CAPTURE_WINDOW, TEXT_WINDOW,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
win-capture: Remove game capture 'Activate' button The activate button is just silly for configuration in retrospect. It's confusing to users, and was even confusing to some other developers. Instead of using an 'Activate' button for game capture every time you want to capture a window, just make the 'window' list have a default 'no window' value (empty), and then have it always active when an actual window is selected. The way syphon handles this on mac is actually where I took the idea from (as suggested by Palana).
2015-01-06 01:30:55 -08:00
obs_property_list_add_string(p, "", "");
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
fill_window_list(p, INCLUDE_MINIMIZED);
obs_property_set_modified_callback(p, window_changed_callback);
p = obs_properties_add_list(ppts, SETTING_WINDOW_PRIORITY,
TEXT_MATCH_PRIORITY, OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(p, TEXT_MATCH_TITLE, WINDOW_PRIORITY_TITLE);
obs_property_list_add_int(p, TEXT_MATCH_CLASS, WINDOW_PRIORITY_CLASS);
obs_property_list_add_int(p, TEXT_MATCH_EXE, WINDOW_PRIORITY_EXE);
obs_properties_add_bool(ppts, SETTING_COMPATIBILITY,
TEXT_SLI_COMPATIBILITY);
p = obs_properties_add_bool(ppts, SETTING_FORCE_SCALING,
TEXT_FORCE_SCALING);
obs_property_set_modified_callback(p, use_scaling_callback);
p = obs_properties_add_list(ppts, SETTING_SCALE_RES, TEXT_SCALE_RES,
OBS_COMBO_TYPE_EDITABLE, OBS_COMBO_FORMAT_STRING);
for (size_t i = 0; i < NUM_DEFAULT_SCALE_VALS; i++) {
char scale_str[64];
uint32_t new_cx =
(uint32_t)((double)cx / default_scale_vals[i]) & ~2;
uint32_t new_cy =
(uint32_t)((double)cy / default_scale_vals[i]) & ~2;
sprintf(scale_str, "%"PRIu32"x%"PRIu32, new_cx, new_cy);
obs_property_list_add_string(p, scale_str, scale_str);
}
obs_property_set_enabled(p, false);
obs_properties_add_bool(ppts, SETTING_TRANSPARENCY,
TEXT_ALLOW_TRANSPARENCY);
obs_properties_add_bool(ppts, SETTING_LIMIT_FRAMERATE,
TEXT_LIMIT_FRAMERATE);
win-capture: Add direct hooking and use by default I've come to realize that it's probably not wise to deviate from the original version's functionality due to the fact that the original version works without issues. I'm wondering if some of the capture problems have been due to the fact that the direct hook method (via CreateRemoteThread) was removed, so I put it back in, made it default, and added an option to use anti-cheat compatibility just like in the original version.
2015-07-05 12:29:27 -07:00
obs_properties_add_bool(ppts, SETTING_CURSOR, TEXT_CAPTURE_CURSOR);
obs_properties_add_bool(ppts, SETTING_ANTI_CHEAT_HOOK,
TEXT_ANTI_CHEAT_HOOK);
win-capture: Add game capture This adds the windows version of game capture. New features: - An option to hook any fullscreen application automatically (that doesn't have borders) so that no specific window configuration is required. Definitely a sorely needed feature - An option to force memory capture for the sake of compatibility with things such as SLI, multi-adapter setups (usually laptops), as well as the ability to be used with the OpenGL renderer - An optimization option to force scaling on the GPU before texture transfer, reducing the transfer bandwidth (which is especially important for compatibility capture) - An optimization option to limit framerate to the current OBS framerate to improve capture performance (mostly useful for compatibility capture) - An option to capture third-party overlays (such as steam) - Logging improvements, game capture log will now be sent via pipe instead of written to a separate file, making diagnosing problems a little bit easier
2014-11-10 17:35:02 -08:00
obs_properties_add_bool(ppts, SETTING_CAPTURE_OVERLAYS,
TEXT_CAPTURE_OVERLAYS);
UNUSED_PARAMETER(data);
return ppts;
}
struct obs_source_info game_capture_info = {
.id = "game_capture",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW,
.get_name = game_capture_name,
.create = game_capture_create,
.destroy = game_capture_destroy,
.get_width = game_capture_width,
.get_height = game_capture_height,
.get_defaults = game_capture_defaults,
.get_properties = game_capture_properties,
.update = game_capture_update,
.video_tick = game_capture_tick,
.video_render = game_capture_render
};