OBS/obs-studio
OBS/obs-studio
1
0
Fork 0
mirror of https://github.com/obsproject/obs-studio.git synced 2024-07-07 03:53:38 +00:00
Code Issues Packages Projects Releases Wiki Activity
obs-studio/plugins/win-capture/window-capture.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

571 lines
15 KiB
C
Raw Normal View History

Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
#include <stdlib.h>
#include <util/dstr.h>
#include "dc-capture.h"
win-capture: Separate window finding source code Because other capture methods may end up needing to share this code, separate the window finding source code to window-helpers.c and window-helpers.h. This include a function to fill out a property list with windows, a function to find a window based upon priority/title/class/exe, and a function to decode the window title/class/exe strings from a window setting string.
2014-10-17 11:01:18 +00:00
#include "window-helpers.h"
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
#include "../../libobs/util/platform.h"
#include "../../libobs-winrt/winrt-capture.h"
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-23 05:13:45 +00:00
/* clang-format off */
Add locale for modules
2014-07-10 05:12:57 +00:00
#define TEXT_WINDOW_CAPTURE obs_module_text("WindowCapture")
#define TEXT_WINDOW obs_module_text("WindowCapture.Window")
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
#define TEXT_METHOD obs_module_text("WindowCapture.Method")
win-capture: Add 'auto' method to window capture Adds an "Automatic" method to the capture method property of window capture. This allows the ability for window capture to automatically determine the best capture method to use. Primarily, it prefers BitBlt in most cases, but will use WGC when it detects the window is a browser, microsoft office, or a UWP program. This was implemented because the new capture method has a number of undesired effects associated with it -- the issue of the capture border that we can do nothing about, the fact that we can't control the capture of the cursor, and the fact that Microsoft designed it to switch the cursor away from hardware cursor mode when the capture is active (there was absolutely no reason to do this because even OBS can capture the hardware cursor with no issue). Until we get a new version of this API that doesn't absolutely blow, we're stuck preferring BitBlt instead. But hey, at least people will be able to capture browser windows now.
2020-02-22 06:32:38 +00:00
#define TEXT_METHOD_AUTO obs_module_text("WindowCapture.Method.Auto")
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
#define TEXT_METHOD_BITBLT obs_module_text("WindowCapture.Method.BitBlt")
#define TEXT_METHOD_WGC obs_module_text("WindowCapture.Method.WindowsGraphicsCapture")
Add locale for modules
2014-07-10 05:12:57 +00:00
#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_COMPATIBILITY obs_module_text("Compatibility")
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
#define TEXT_CLIENT_AREA obs_module_text("ClientArea")
Add locale for modules
2014-07-10 05:12:57 +00:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-23 05:13:45 +00:00
/* clang-format on */
win-capture: Faster display / window capture updates When changing the target for display or window capture, force a refresh of the source by setting the timer to fire immediately. This removes 1-3 seconds of "lag" before the new display or window is visible and makes the UI feel more responsive. Closes https://github.com/obsproject/obs-studio/issues/2322
2020-02-03 22:22:42 +00:00
#define WC_CHECK_TIMER 1.0f
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
struct winrt_exports {
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
BOOL *(*winrt_capture_supported)();
BOOL *(*winrt_capture_cursor_toggle_supported)();
struct winrt_capture *(*winrt_capture_init)(BOOL cursor, HWND window,
libobs-winrt: win-capture: Clean up error handling Use proper check to fix false positive on 1809, and rework error spew to remove output parameters from winrt_capture_init.
2020-03-18 07:33:12 +00:00
BOOL client_area);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
void (*winrt_capture_free)(struct winrt_capture *capture);
libobs-winrt: win-capture: Detect GraphicsCaptureItem closure Make WGC window capture recover from GraphicsCaptureItem closure, which can occur when following links in fullscreen Chrome for example.
2020-05-07 04:32:57 +00:00
BOOL *(*winrt_capture_active)(const struct winrt_capture *capture);
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
void (*winrt_capture_show_cursor)(struct winrt_capture *capture,
BOOL visible);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
void (*winrt_capture_render)(struct winrt_capture *capture,
gs_effect_t *effect);
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
uint32_t (*winrt_capture_width)(const struct winrt_capture *capture);
uint32_t (*winrt_capture_height)(const struct winrt_capture *capture);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
};
enum window_capture_method {
win-capture: Add 'auto' method to window capture Adds an "Automatic" method to the capture method property of window capture. This allows the ability for window capture to automatically determine the best capture method to use. Primarily, it prefers BitBlt in most cases, but will use WGC when it detects the window is a browser, microsoft office, or a UWP program. This was implemented because the new capture method has a number of undesired effects associated with it -- the issue of the capture border that we can do nothing about, the fact that we can't control the capture of the cursor, and the fact that Microsoft designed it to switch the cursor away from hardware cursor mode when the capture is active (there was absolutely no reason to do this because even OBS can capture the hardware cursor with no issue). Until we get a new version of this API that doesn't absolutely blow, we're stuck preferring BitBlt instead. But hey, at least people will be able to capture browser windows now.
2020-02-22 06:32:38 +00:00
METHOD_AUTO,
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
METHOD_BITBLT,
METHOD_WGC,
};
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
struct window_capture {
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_source_t *source;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
char *title;
char *class;
char *executable;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
enum window_capture_method method;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
enum window_priority priority;
bool cursor;
bool compatibility;
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
bool client_area;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
bool use_wildcards; /* TODO */
struct dc_capture capture;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
bool wgc_supported;
win-capture: Fix potential crash due to unhandled exceptions
2020-03-17 19:22:20 +00:00
bool previously_failed;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
void *winrt_module;
struct winrt_exports exports;
struct winrt_capture *capture_winrt;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
float resize_timer;
win-capture: Don't try to find window every frame When window capture is not capturing a window, don't try to find the window every frame. Instead, just check once per frame. The process of finding a window has a lot of checks and requires a surprising amount of processing.
2019-02-12 01:57:24 +00:00
float check_window_timer;
win-capture: Hide cursor when in background (window capture)
2017-05-10 21:47:44 +00:00
float cursor_check_time;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
HWND window;
RECT last_rect;
};
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
static const char *wgc_partial_match_classes[] = {
"Chrome",
"Mozilla",
NULL,
};
static const char *wgc_whole_match_classes[] = {
"ApplicationFrameWindow",
"Windows.UI.Core.CoreWindow",
"XLMAIN", /* excel*/
"PPTFrameClass", /* powerpoint */
"OpusApp", /* word */
NULL,
};
static enum window_capture_method
choose_method(enum window_capture_method method, bool wgc_supported,
const char *current_class)
{
win-capture: Prevent WGC being selected when unavailable
2020-03-03 10:06:25 +00:00
if (!wgc_supported)
return METHOD_BITBLT;
if (method != METHOD_AUTO)
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
return method;
if (!current_class)
return METHOD_BITBLT;
const char **class = wgc_partial_match_classes;
while (*class) {
if (astrstri(current_class, *class) != NULL) {
return METHOD_WGC;
}
class ++;
}
class = wgc_whole_match_classes;
while (*class) {
if (astrcmpi(current_class, *class) == 0) {
return METHOD_WGC;
}
class ++;
}
return METHOD_BITBLT;
}
win-capture: Log window capture method
2020-05-08 08:16:28 +00:00
static const char *get_method_name(int method)
{
const char *method_name = "";
switch (method) {
case METHOD_AUTO:
method_name = "Automatic";
break;
case METHOD_BITBLT:
method_name = "BitBlt";
break;
case METHOD_WGC:
method_name = "WGC";
break;
}
return method_name;
}
win-capture: Fix excessive window capture logging
2020-08-25 17:18:45 +00:00
static void log_settings(struct window_capture *wc, obs_data_t *s)
{
int method = (int)obs_data_get_int(s, "method");
if (wc->title != NULL) {
blog(LOG_INFO,
"[window-capture: '%s'] update settings:\n"
"\texecutable: %s\n"
"\tmethod selected: %s\n"
"\tmethod chosen: %s\n",
obs_source_get_name(wc->source), wc->executable,
get_method_name(method), get_method_name(wc->method));
blog(LOG_DEBUG, "\tclass: %s", wc->class);
}
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
static void update_settings(struct window_capture *wc, obs_data_t *s)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
{
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
int method = (int)obs_data_get_int(s, "method");
(API Change) Unsquish obs_data_* names Changed: To: ----------------------------------------------- obs_data_getjson obs_data_get_json obs_data_getstring obs_data_get_string obs_data_getint obs_data_get_int obs_data_getdouble obs_data_get_double obs_data_getbool obs_data_get_bool obs_data_getobj obs_data_get_obj obs_data_getarray obs_data_get_array obs_data_setstring obs_data_set_string obs_data_setint obs_data_set_int obs_data_setdouble obs_data_set_double obs_data_setbool obs_data_set_bool obs_data_setobj obs_data_set_obj obs_data_setarray obs_data_set_array obs_data_item_getstring obs_data_item_get_string obs_data_item_getint obs_data_item_get_int obs_data_item_getdouble obs_data_item_get_double obs_data_item_getbool obs_data_item_get_bool obs_data_item_getobj obs_data_item_get_obj obs_data_item_getarray obs_data_item_get_array obs_data_item_setstring obs_data_item_set_string obs_data_item_setint obs_data_item_set_int obs_data_item_setdouble obs_data_item_set_double obs_data_item_setbool obs_data_item_set_bool obs_data_item_setobj obs_data_item_set_obj obs_data_item_setarray obs_data_item_set_array
2014-08-05 18:09:29 +00:00
const char *window = obs_data_get_string(s, "window");
int priority = (int)obs_data_get_int(s, "priority");
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
bfree(wc->title);
bfree(wc->class);
bfree(wc->executable);
win-capture: Separate window finding source code Because other capture methods may end up needing to share this code, separate the window finding source code to window-helpers.c and window-helpers.h. This include a function to fill out a property list with windows, a function to find a window based upon priority/title/class/exe, and a function to decode the window title/class/exe strings from a window setting string.
2014-10-17 11:01:18 +00:00
build_window_strings(window, &wc->class, &wc->title, &wc->executable);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
wc->method = choose_method(method, wc->wgc_supported, wc->class);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
wc->priority = (enum window_priority)priority;
(API Change) Unsquish obs_data_* names Changed: To: ----------------------------------------------- obs_data_getjson obs_data_get_json obs_data_getstring obs_data_get_string obs_data_getint obs_data_get_int obs_data_getdouble obs_data_get_double obs_data_getbool obs_data_get_bool obs_data_getobj obs_data_get_obj obs_data_getarray obs_data_get_array obs_data_setstring obs_data_set_string obs_data_setint obs_data_set_int obs_data_setdouble obs_data_set_double obs_data_setbool obs_data_set_bool obs_data_setobj obs_data_set_obj obs_data_setarray obs_data_set_array obs_data_item_getstring obs_data_item_get_string obs_data_item_getint obs_data_item_get_int obs_data_item_getdouble obs_data_item_get_double obs_data_item_getbool obs_data_item_get_bool obs_data_item_getobj obs_data_item_get_obj obs_data_item_getarray obs_data_item_get_array obs_data_item_setstring obs_data_item_set_string obs_data_item_setint obs_data_item_set_int obs_data_item_setdouble obs_data_item_set_double obs_data_item_setbool obs_data_item_set_bool obs_data_item_setobj obs_data_item_set_obj obs_data_item_setarray obs_data_item_set_array
2014-08-05 18:09:29 +00:00
wc->cursor = obs_data_get_bool(s, "cursor");
wc->use_wildcards = obs_data_get_bool(s, "use_wildcards");
win-capture: Fix compatibility bug for window cap. The compatibility mode setting wasn't being set when an update occurred.
2015-05-01 08:58:21 +00:00
wc->compatibility = obs_data_get_bool(s, "compatibility");
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
wc->client_area = obs_data_get_bool(s, "client_area");
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00: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 08:30:51 +00:00
static const char *wc_getname(void *unused)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00: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 08:30:51 +00:00
UNUSED_PARAMETER(unused);
Add locale for modules
2014-07-10 05:12:57 +00:00
return TEXT_WINDOW_CAPTURE;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
#define WINRT_IMPORT(func) \
do { \
exports->func = os_dlsym(module, #func); \
if (!exports->func) { \
success = false; \
blog(LOG_ERROR, \
"Could not load function '%s' from " \
"module '%s'", \
#func, module_name); \
} \
} while (false)
static bool load_winrt_imports(struct winrt_exports *exports, void *module,
const char *module_name)
{
bool success = true;
WINRT_IMPORT(winrt_capture_supported);
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
WINRT_IMPORT(winrt_capture_cursor_toggle_supported);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
WINRT_IMPORT(winrt_capture_init);
WINRT_IMPORT(winrt_capture_free);
libobs-winrt: win-capture: Detect GraphicsCaptureItem closure Make WGC window capture recover from GraphicsCaptureItem closure, which can occur when following links in fullscreen Chrome for example.
2020-05-07 04:32:57 +00:00
WINRT_IMPORT(winrt_capture_active);
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
WINRT_IMPORT(winrt_capture_show_cursor);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
WINRT_IMPORT(winrt_capture_render);
WINRT_IMPORT(winrt_capture_width);
WINRT_IMPORT(winrt_capture_height);
return success;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
static void *wc_create(obs_data_t *settings, obs_source_t *source)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00: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 07:38:09 +00:00
struct window_capture *wc = bzalloc(sizeof(struct window_capture));
wc->source = source;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
obs_enter_graphics();
const bool uses_d3d11 = gs_get_device_type() == GS_DEVICE_DIRECT3D_11;
obs_leave_graphics();
if (uses_d3d11) {
static const char *const module = "libobs-winrt";
bool use_winrt_capture = false;
wc->winrt_module = os_dlopen(module);
if (wc->winrt_module &&
load_winrt_imports(&wc->exports, wc->winrt_module,
module) &&
wc->exports.winrt_capture_supported()) {
wc->wgc_supported = true;
}
}
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
update_settings(wc, settings);
win-capture: Fix excessive window capture logging
2020-08-25 17:18:45 +00:00
log_settings(wc, settings);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
return wc;
}
win-capture: Destroy winrt in graphics thread
2020-03-14 17:40:42 +00:00
static void wc_actual_destroy(void *data)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
{
struct window_capture *wc = data;
win-capture: Destroy winrt in graphics thread
2020-03-14 17:40:42 +00:00
if (wc->capture_winrt) {
wc->exports.winrt_capture_free(wc->capture_winrt);
}
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Destroy winrt in graphics thread
2020-03-14 17:40:42 +00:00
obs_enter_graphics();
dc_capture_free(&wc->capture);
obs_leave_graphics();
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Destroy winrt in graphics thread
2020-03-14 17:40:42 +00:00
bfree(wc->title);
bfree(wc->class);
bfree(wc->executable);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
win-capture: Destroy winrt in graphics thread
2020-03-14 17:40:42 +00:00
if (wc->winrt_module)
os_dlclose(wc->winrt_module);
bfree(wc);
}
static void wc_destroy(void *data)
{
obs_queue_task(OBS_TASK_GRAPHICS, wc_actual_destroy, data, false);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
static void wc_update(void *data, obs_data_t *settings)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
{
struct window_capture *wc = data;
update_settings(wc, settings);
win-capture: Fix excessive window capture logging
2020-08-25 17:18:45 +00:00
log_settings(wc, settings);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
/* forces a reset */
wc->window = NULL;
win-capture: Faster display / window capture updates When changing the target for display or window capture, force a refresh of the source by setting the timer to fire immediately. This removes 1-3 seconds of "lag" before the new display or window is visible and makes the UI feel more responsive. Closes https://github.com/obsproject/obs-studio/issues/2322
2020-02-03 22:22:42 +00:00
wc->check_window_timer = WC_CHECK_TIMER;
libobs-winrt: win-capture: Clean up error handling Use proper check to fix false positive on 1809, and rework error spew to remove output parameters from winrt_capture_init.
2020-03-18 07:33:12 +00:00
wc->previously_failed = false;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
static uint32_t wc_width(void *data)
{
struct window_capture *wc = data;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
return (wc->method == METHOD_WGC)
? wc->exports.winrt_capture_width(wc->capture_winrt)
: wc->capture.width;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
static uint32_t wc_height(void *data)
{
struct window_capture *wc = data;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
return (wc->method == METHOD_WGC)
? wc->exports.winrt_capture_height(wc->capture_winrt)
: wc->capture.height;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
static void wc_defaults(obs_data_t *defaults)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
{
win-capture: Add 'auto' method to window capture Adds an "Automatic" method to the capture method property of window capture. This allows the ability for window capture to automatically determine the best capture method to use. Primarily, it prefers BitBlt in most cases, but will use WGC when it detects the window is a browser, microsoft office, or a UWP program. This was implemented because the new capture method has a number of undesired effects associated with it -- the issue of the capture border that we can do nothing about, the fact that we can't control the capture of the cursor, and the fact that Microsoft designed it to switch the cursor away from hardware cursor mode when the capture is active (there was absolutely no reason to do this because even OBS can capture the hardware cursor with no issue). Until we get a new version of this API that doesn't absolutely blow, we're stuck preferring BitBlt instead. But hey, at least people will be able to capture browser windows now.
2020-02-22 06:32:38 +00:00
obs_data_set_default_int(defaults, "method", METHOD_AUTO);
window capture: Fix defaults overriding values
2014-08-05 17:58:10 +00:00
obs_data_set_default_bool(defaults, "cursor", true);
obs_data_set_default_bool(defaults, "compatibility", false);
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
obs_data_set_default_bool(defaults, "client_area", true);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
static void update_settings_visibility(obs_properties_t *props,
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
struct window_capture *wc)
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
{
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
const enum window_capture_method method = wc->method;
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
const bool bitblt_options = method == METHOD_BITBLT;
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
const bool wgc_options = method == METHOD_WGC;
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
const bool wgc_cursor_toggle =
wgc_options &&
wc->exports.winrt_capture_cursor_toggle_supported();
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
obs_property_t *p = obs_properties_get(props, "cursor");
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
obs_property_set_visible(p, bitblt_options || wgc_cursor_toggle);
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
p = obs_properties_get(props, "compatibility");
obs_property_set_visible(p, bitblt_options);
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
p = obs_properties_get(props, "client_area");
obs_property_set_visible(p, wgc_options);
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
}
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
static bool wc_capture_method_changed(obs_properties_t *props,
obs_property_t *p, obs_data_t *settings)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
{
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
struct window_capture *wc = obs_properties_get_param(props);
update_settings(wc, settings);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
update_settings_visibility(props, wc);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
return true;
}
win-capture: Preserve current window setting This re-uses the game capture code for checking whether the original window still exists or not. If it doesn't or the name changed, it'll insert the value at the top of the list so it doesn't automatically select another when the user opens properties. Basically, this fixes an issue where opening properties could sometimes cause it to instantly capture whatever window was at the top of the list, which is undesirable. Closes obsproject/obs-studio#2421
2020-02-27 12:38:24 +00:00
extern bool check_window_property_setting(obs_properties_t *ppts,
obs_property_t *p,
obs_data_t *settings, const char *val,
size_t idx);
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
static bool wc_window_changed(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings)
{
struct window_capture *wc = obs_properties_get_param(props);
update_settings(wc, settings);
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
update_settings_visibility(props, wc);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
win-capture: Preserve current window setting This re-uses the game capture code for checking whether the original window still exists or not. If it doesn't or the name changed, it'll insert the value at the top of the list so it doesn't automatically select another when the user opens properties. Basically, this fixes an issue where opening properties could sometimes cause it to instantly capture whatever window was at the top of the list, which is undesirable. Closes obsproject/obs-studio#2421
2020-02-27 12:38:24 +00:00
check_window_property_setting(props, p, settings, "window", 0);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
return true;
}
static obs_properties_t *wc_properties(void *data)
{
struct window_capture *wc = data;
(API Change) Pass data to get_properties when possible
2014-09-29 15:36:13 +00:00
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_properties_t *ppts = obs_properties_create();
win-capture: Hide settings if Automatic is WGC
2020-02-25 03:42:46 +00:00
obs_properties_set_param(ppts, wc, NULL);
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_property_t *p;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Move window capture method below window
2020-02-27 11:22:04 +00:00
p = obs_properties_add_list(ppts, "window", TEXT_WINDOW,
OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
fill_window_list(p, EXCLUDE_MINIMIZED, NULL);
obs_property_set_modified_callback(p, wc_window_changed);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
p = obs_properties_add_list(ppts, "method", TEXT_METHOD,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
win-capture: Add 'auto' method to window capture Adds an "Automatic" method to the capture method property of window capture. This allows the ability for window capture to automatically determine the best capture method to use. Primarily, it prefers BitBlt in most cases, but will use WGC when it detects the window is a browser, microsoft office, or a UWP program. This was implemented because the new capture method has a number of undesired effects associated with it -- the issue of the capture border that we can do nothing about, the fact that we can't control the capture of the cursor, and the fact that Microsoft designed it to switch the cursor away from hardware cursor mode when the capture is active (there was absolutely no reason to do this because even OBS can capture the hardware cursor with no issue). Until we get a new version of this API that doesn't absolutely blow, we're stuck preferring BitBlt instead. But hey, at least people will be able to capture browser windows now.
2020-02-22 06:32:38 +00:00
obs_property_list_add_int(p, TEXT_METHOD_AUTO, METHOD_AUTO);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
obs_property_list_add_int(p, TEXT_METHOD_BITBLT, METHOD_BITBLT);
obs_property_list_add_int(p, TEXT_METHOD_WGC, METHOD_WGC);
win-capture: Disable correct capture method index When "Automatic" was added, the index for the item that needed to be disabled became incorrect (to disable WCG).
2020-03-04 05:08:43 +00:00
obs_property_list_item_disable(p, 2, !wc->wgc_supported);
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
obs_property_set_modified_callback(p, wc_capture_method_changed);
Add locale for modules
2014-07-10 05:12:57 +00:00
p = obs_properties_add_list(ppts, "priority", TEXT_MATCH_PRIORITY,
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
Add locale for modules
2014-07-10 05:12:57 +00:00
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);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
Add locale for modules
2014-07-10 05:12:57 +00:00
obs_properties_add_bool(ppts, "cursor", TEXT_CAPTURE_CURSOR);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
Add locale for modules
2014-07-10 05:12:57 +00:00
obs_properties_add_bool(ppts, "compatibility", TEXT_COMPATIBILITY);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
libobs-winrt: win-capture: Support client area toggle for WGC
2020-02-25 05:21:52 +00:00
obs_properties_add_bool(ppts, "client_area", TEXT_CLIENT_AREA);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
return ppts;
}
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
static void wc_hide(void *data)
{
struct window_capture *wc = data;
if (wc->capture_winrt) {
wc->exports.winrt_capture_free(wc->capture_winrt);
wc->capture_winrt = NULL;
}
memset(&wc->last_rect, 0, sizeof(wc->last_rect));
}
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
#define RESIZE_CHECK_TIME 0.2f
win-capture: Hide cursor when in background (window capture)
2017-05-10 21:47:44 +00:00
#define CURSOR_CHECK_TIME 0.2f
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
static void wc_tick(void *data, float seconds)
{
struct window_capture *wc = data;
RECT rect;
bool reset_capture = false;
Don't update video of sources if not displaying This is a bit of an optimization to reduce load a little bit if any of the video capture sources are not currently being displayed on the screen. They will simply not capture or update their texture data if they are not currently being shown anywhere. The mac and window game capture sources don't really apply due to the fact that their textures aren't updated on the source's end (they update inside of the hooks).
2015-01-04 06:39:21 +00:00
if (!obs_source_showing(wc->source))
return;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
if (!wc->window || !IsWindow(wc->window)) {
if (!wc->title && !wc->class)
return;
win-capture: Don't try to find window every frame When window capture is not capturing a window, don't try to find the window every frame. Instead, just check once per frame. The process of finding a window has a lot of checks and requires a surprising amount of processing.
2019-02-12 01:57:24 +00:00
wc->check_window_timer += seconds;
win-capture: Faster display / window capture updates When changing the target for display or window capture, force a refresh of the source by setting the timer to fire immediately. This removes 1-3 seconds of "lag" before the new display or window is visible and makes the UI feel more responsive. Closes https://github.com/obsproject/obs-studio/issues/2322
2020-02-03 22:22:42 +00:00
if (wc->check_window_timer < WC_CHECK_TIMER) {
win-capture: Don't try to find window every frame When window capture is not capturing a window, don't try to find the window every frame. Instead, just check once per frame. The process of finding a window has a lot of checks and requires a surprising amount of processing.
2019-02-12 01:57:24 +00:00
if (wc->capture.valid)
dc_capture_free(&wc->capture);
return;
}
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
if (wc->capture_winrt) {
wc->exports.winrt_capture_free(wc->capture_winrt);
wc->capture_winrt = NULL;
}
win-capture: Don't try to find window every frame When window capture is not capturing a window, don't try to find the window every frame. Instead, just check once per frame. The process of finding a window has a lot of checks and requires a surprising amount of processing.
2019-02-12 01:57:24 +00:00
wc->check_window_timer = 0.0f;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
wc->window = (wc->method == METHOD_WGC)
win-capture: Find correct window even if it's minimized In window capture, it will search for a window with a specific title, but will not search minimized windows. This fixes that by making is acquire the correct window even if that window is minimized, rather than potentially risk it capturing the wrong window of the same type.
2020-03-04 15:24:14 +00:00
? find_window_top_level(INCLUDE_MINIMIZED,
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
wc->priority,
wc->class,
wc->title,
wc->executable)
win-capture: Find correct window even if it's minimized In window capture, it will search for a window with a specific title, but will not search minimized windows. This fixes that by making is acquire the correct window even if that window is minimized, rather than potentially risk it capturing the wrong window of the same type.
2020-03-04 15:24:14 +00:00
: find_window(INCLUDE_MINIMIZED,
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
wc->priority, wc->class,
wc->title, wc->executable);
win-capture: Clear window capture if window no longer exists
2016-05-15 11:35:01 +00:00
if (!wc->window) {
if (wc->capture.valid)
dc_capture_free(&wc->capture);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
return;
win-capture: Clear window capture if window no longer exists
2016-05-15 11:35:01 +00:00
}
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Reset WGC fail flag for new window WGC will give up on a window that it fails to capture, but that shouldn't stop it from attempting to capture new windows. Fixes #2928.
2020-05-13 14:54:41 +00:00
wc->previously_failed = false;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
reset_capture = true;
} else if (IsIconic(wc->window)) {
return;
}
win-capture: Hide cursor when in background (window capture)
2017-05-10 21:47:44 +00:00
wc->cursor_check_time += seconds;
if (wc->cursor_check_time > CURSOR_CHECK_TIME) {
DWORD foreground_pid, target_pid;
// Can't just compare the window handle in case of app with child windows
if (!GetWindowThreadProcessId(GetForegroundWindow(),
&foreground_pid))
foreground_pid = 0;
if (!GetWindowThreadProcessId(wc->window, &target_pid))
target_pid = 0;
libobs-winrt: win-capture: HDC cursor capture for WGC Starting with Windows 10 2004, we can disable WGC cursor capture, and provide a user toggle. We swap out WGC support for our own though because ours does not break hardware cursor support.
2020-03-07 17:27:58 +00:00
const bool cursor_hidden = foreground_pid && target_pid &&
foreground_pid != target_pid;
wc->capture.cursor_hidden = cursor_hidden;
if (wc->capture_winrt)
wc->exports.winrt_capture_show_cursor(wc->capture_winrt,
!cursor_hidden);
win-capture: Hide cursor when in background (window capture)
2017-05-10 21:47:44 +00:00
wc->cursor_check_time = 0.0f;
}
(API Change) Remove obs_graphics() API Removed: - graphics_t obs_graphics(); Replaced With: - void obs_enter_graphics(); - void obs_leave_graphics(); Description: obs_graphics() was somewhat of a pointless function. The only time that it was ever necessary was to pass it as a parameter to gs_entercontext() followed by a subsequent gs_leavecontext() call after that. So, I felt that it made a bit more sense just to implement obs_enter_graphics() and obs_leave_graphics() functions to do the exact same thing without having to repeat that code. There's really no need to ever "hold" the graphics pointer, though I suppose that could change in the future so having a similar function come back isn't out of the question. Still, this at least reduces the amount of unnecessary repeated code for the time being.
2014-08-04 12:48:58 +00:00
obs_enter_graphics();
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
if (wc->method == METHOD_BITBLT) {
GetClientRect(wc->window, &rect);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
if (!reset_capture) {
wc->resize_timer += seconds;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
if (wc->resize_timer >= RESIZE_CHECK_TIME) {
if ((rect.bottom - rect.top) !=
(wc->last_rect.bottom -
wc->last_rect.top) ||
(rect.right - rect.left) !=
(wc->last_rect.right -
wc->last_rect.left))
reset_capture = true;
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
wc->resize_timer = 0.0f;
}
}
if (reset_capture) {
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
wc->resize_timer = 0.0f;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
wc->last_rect = rect;
dc_capture_free(&wc->capture);
dc_capture_init(&wc->capture, 0, 0,
rect.right - rect.left,
rect.bottom - rect.top, wc->cursor,
wc->compatibility);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
dc_capture_capture(&wc->capture, wc->window);
} else if (wc->method == METHOD_WGC) {
if (wc->window && (wc->capture_winrt == NULL)) {
libobs-winrt: win-capture: Clean up error handling Use proper check to fix false positive on 1809, and rework error spew to remove output parameters from winrt_capture_init.
2020-03-18 07:33:12 +00:00
if (!wc->previously_failed) {
wc->capture_winrt =
wc->exports.winrt_capture_init(
wc->cursor, wc->window,
wc->client_area);
if (!wc->capture_winrt) {
wc->previously_failed = true;
}
win-capture: Fix potential crash due to unhandled exceptions
2020-03-17 19:22:20 +00:00
}
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
}
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
(API Change) Remove obs_graphics() API Removed: - graphics_t obs_graphics(); Replaced With: - void obs_enter_graphics(); - void obs_leave_graphics(); Description: obs_graphics() was somewhat of a pointless function. The only time that it was ever necessary was to pass it as a parameter to gs_entercontext() followed by a subsequent gs_leavecontext() call after that. So, I felt that it made a bit more sense just to implement obs_enter_graphics() and obs_leave_graphics() functions to do the exact same thing without having to repeat that code. There's really no need to ever "hold" the graphics pointer, though I suppose that could change in the future so having a similar function come back isn't out of the question. Still, this at least reduces the amount of unnecessary repeated code for the time being.
2014-08-04 12:48:58 +00:00
obs_leave_graphics();
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
static void wc_render(void *data, gs_effect_t *effect)
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
{
struct window_capture *wc = data;
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
gs_effect_t *const opaque = obs_get_base_effect(OBS_EFFECT_OPAQUE);
libobs-winrt: win-capture: Detect GraphicsCaptureItem closure Make WGC window capture recover from GraphicsCaptureItem closure, which can occur when following links in fullscreen Chrome for example.
2020-05-07 04:32:57 +00:00
if (wc->method == METHOD_WGC) {
if (wc->capture_winrt) {
if (wc->exports.winrt_capture_active(
wc->capture_winrt)) {
wc->exports.winrt_capture_render(
wc->capture_winrt, opaque);
} else {
wc->exports.winrt_capture_free(
wc->capture_winrt);
wc->capture_winrt = NULL;
}
}
} else {
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
dc_capture_render(&wc->capture, opaque);
libobs-winrt: win-capture: Detect GraphicsCaptureItem closure Make WGC window capture recover from GraphicsCaptureItem closure, which can occur when following links in fullscreen Chrome for example.
2020-05-07 04:32:57 +00:00
}
Fix 'unused parameter' warnings on windows
2014-07-12 18:59:07 +00:00
UNUSED_PARAMETER(effect);
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
}
struct obs_source_info window_capture_info = {
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
.id = "window_capture",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW,
.get_name = wc_getname,
.create = wc_create,
.destroy = wc_destroy,
.update = wc_update,
.video_render = wc_render,
win-capture: Windows Graphics Capture support Users will now have the option of legacy window capture via BitBlt, or Windows Graphics Capture, which is new to Windows 10. There are two annoyances with the new capture method though. One is that there is a bright, yellow border added to the original window (but not the OBS view of it). The other is that the mouse cursor is always captured, and we won't be able to capture without cursor until a later version of Windows 10 is released. It should also be noted that DPI scaling is now applied, which may result in blurrier images caused by Windows rescaling.
2019-11-28 00:44:27 +00:00
.hide = wc_hide,
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
.video_tick = wc_tick,
.get_width = wc_width,
.get_height = wc_height,
.get_defaults = wc_defaults,
.get_properties = wc_properties,
UI: Add source icons
2019-07-28 04:59:16 +00:00
.icon_type = OBS_ICON_TYPE_WINDOW_CAPTURE,
Add window capture Now that we have the priorties window in we can finally be able to select windows for capture source such as window capture. Only took about an hour or two to write. Also, fixed some depednency issues on winmm.lib with obs-outputs
2014-04-07 08:20:36 +00:00
};
Reference in a new issue Copy permalink