win-capture: Add win8+ monitor capture

Uses the output duplicator API in order to get a high performance
monitor capture on windows 8+.  This is actually designed to be
interchangeable with regular GDI-based monitor capture (uses the same
source id).

plugins/win-capture/CMakeLists.txt

@@ -17,6 +17,7 @@ set(win-capture_SOURCES
 	monitor-capture.c
 	window-capture.c
 	load-graphics-offsets.c
+	duplicator-monitor-capture.c
 	plugin-main.c)
 
 add_library(win-capture MODULE

plugins/win-capture/duplicator-monitor-capture.c

@@ -0,0 +1,300 @@
+#include <windows.h>
+
+#include <obs-module.h>
+#include <util/dstr.h>
+
+#include "cursor-capture.h"
+
+#define do_log(level, format, ...) \
+	blog(level, "[duplicator-monitor-capture: '%s'] " format, \
+			obs_source_get_name(capture->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 TEXT_MONITOR_CAPTURE obs_module_text("MonitorCapture")
+#define TEXT_CAPTURE_CURSOR  obs_module_text("CaptureCursor")
+#define TEXT_COMPATIBILITY   obs_module_text("Compatibility")
+#define TEXT_MONITOR         obs_module_text("Monitor")
+#define TEXT_PRIMARY_MONITOR obs_module_text("PrimaryMonitor")
+
+#define RESET_INTERVAL_SEC 3.0f
+
+struct duplicator_capture {
+	obs_source_t                   *source;
+	int                            monitor;
+	bool                           capture_cursor;
+
+	long                           x;
+	long                           y;
+	int                            rot;
+	uint32_t                       width;
+	uint32_t                       height;
+	gs_duplicator_t                *duplicator;
+	float                          reset_timeout;
+	struct cursor_data             cursor_data;
+};
+
+/* ------------------------------------------------------------------------- */
+
+static inline void update_settings(struct duplicator_capture *capture,
+		obs_data_t *settings)
+{
+	capture->monitor        = (int)obs_data_get_int(settings, "monitor");
+	capture->capture_cursor = obs_data_get_bool(settings, "capture_cursor");
+
+	obs_enter_graphics();
+
+	gs_duplicator_destroy(capture->duplicator);
+	capture->duplicator = gs_duplicator_create(capture->monitor);
+	capture->width = 0;
+	capture->height = 0;
+	capture->x = 0;
+	capture->y = 0;
+	capture->rot = 0;
+	capture->reset_timeout = 0.0f;
+
+	obs_leave_graphics();
+}
+
+/* ------------------------------------------------------------------------- */
+
+static const char *duplicator_capture_getname(void)
+{
+	return TEXT_MONITOR_CAPTURE;
+}
+
+static void duplicator_capture_destroy(void *data)
+{
+	struct duplicator_capture *capture = data;
+
+	obs_enter_graphics();
+
+	gs_duplicator_destroy(capture->duplicator);
+	cursor_data_free(&capture->cursor_data);
+
+	obs_leave_graphics();
+
+	bfree(capture);
+}
+
+static void duplicator_capture_defaults(obs_data_t *settings)
+{
+	obs_data_set_default_int(settings, "monitor", 0);
+	obs_data_set_default_bool(settings, "capture_cursor", true);
+}
+
+static void duplicator_capture_update(void *data, obs_data_t *settings)
+{
+	struct duplicator_capture *mc = data;
+	update_settings(mc, settings);
+}
+
+static void *duplicator_capture_create(obs_data_t *settings,
+		obs_source_t *source)
+{
+	struct duplicator_capture *capture;
+
+	capture = bzalloc(sizeof(struct duplicator_capture));
+	capture->source = source;
+
+	update_settings(capture, settings);
+
+	return capture;
+}
+
+static void reset_capture_data(struct duplicator_capture *capture)
+{
+	struct gs_monitor_info monitor_info = {0};
+	gs_texture_t *texture = gs_duplicator_get_texture(capture->duplicator);
+
+	gs_get_duplicator_monitor_info(capture->monitor, &monitor_info);
+	capture->width = gs_texture_get_width(texture);
+	capture->height = gs_texture_get_height(texture);
+	capture->x = monitor_info.x;
+	capture->y = monitor_info.y;
+	capture->rot = monitor_info.rotation_degrees;
+}
+
+static void duplicator_capture_tick(void *data, float seconds)
+{
+	struct duplicator_capture *capture = data;
+
+	if (!obs_source_showing(capture->source))
+		return;
+
+	obs_enter_graphics();
+
+	if (!capture->duplicator) {
+		capture->reset_timeout += seconds;
+
+		if (capture->reset_timeout >= RESET_INTERVAL_SEC) {
+			capture->duplicator =
+				gs_duplicator_create(capture->monitor);
+
+			capture->reset_timeout = 0.0f;
+		}
+	}
+
+	if (!!capture->duplicator) {
+		if (capture->capture_cursor)
+			cursor_capture(&capture->cursor_data);
+
+		if (!gs_duplicator_update_frame(capture->duplicator)) {
+			gs_duplicator_destroy(capture->duplicator);
+			capture->duplicator = NULL;
+			capture->width = 0;
+			capture->height = 0;
+			capture->x = 0;
+			capture->y = 0;
+			capture->rot = 0;
+			capture->reset_timeout = 0.0f;
+
+		} else if (capture->width == 0) {
+			reset_capture_data(capture);
+		}
+	}
+
+	obs_leave_graphics();
+
+	UNUSED_PARAMETER(seconds);
+}
+
+static uint32_t duplicator_capture_width(void *data)
+{
+	struct duplicator_capture *capture = data;
+	return capture->rot % 180 == 0 ? capture->width : capture->height;
+}
+
+static uint32_t duplicator_capture_height(void *data)
+{
+	struct duplicator_capture *capture = data;
+	return capture->rot % 180 == 0 ? capture->height : capture->width;
+}
+
+static void draw_cursor(struct duplicator_capture *capture)
+{
+	cursor_draw(&capture->cursor_data, -capture->x, -capture->y,
+		1.0f, 1.0f,
+		capture->rot % 180 == 0 ? capture->width : capture->height,
+		capture->rot % 180 == 0 ? capture->height : capture->width);
+}
+
+static void duplicator_capture_render(void *data, gs_effect_t *effect)
+{
+	struct duplicator_capture *capture = data;
+	gs_texture_t *texture;
+	int rot;
+
+	if (!capture->duplicator)
+		return;
+
+	texture = gs_duplicator_get_texture(capture->duplicator);
+	if (!texture)
+		return;
+
+	effect = obs_get_default_effect();
+
+	rot = capture->rot;
+
+	while (gs_effect_loop(effect, "Draw")) {
+		gs_enable_blending(false);
+		gs_enable_color(true, true, true, false);
+
+		if (rot != 0) {
+			float x;
+			float y;
+
+			switch (rot) {
+			case 90:
+				x = (float)capture->height;
+				y = 0.0f;
+				break;
+			case 180:
+				x = (float)capture->width;
+				y = (float)capture->height;
+				break;
+			case 270:
+				x = 0.0f;
+				y = (float)capture->width;
+				break;
+			}
+
+			gs_matrix_push();
+			gs_matrix_translate3f(x, y, 0.0f);
+			gs_matrix_rotaa4f(0.0f, 0.0f, 1.0f, RAD((float)rot));
+		}
+
+		obs_source_draw(texture, 0, 0, 0, 0, false);
+
+		if (rot != 0)
+			gs_matrix_pop();
+
+		gs_enable_blending(true);
+		gs_enable_color(true, true, true, true);
+
+		if (capture->capture_cursor)
+			draw_cursor(capture);
+	}
+}
+
+static bool get_monitor_props(obs_property_t *monitor_list, int monitor_idx)
+{
+	struct dstr monitor_desc = {0};
+	struct gs_monitor_info info;
+
+	if (!gs_get_duplicator_monitor_info(monitor_idx, &info))
+		return false;
+
+	dstr_catf(&monitor_desc, "%s %d: %ldx%ld @ %ld,%ld",
+			TEXT_MONITOR, monitor_idx,
+			info.cx, info.cy, info.x, info.y);
+
+	obs_property_list_add_int(monitor_list, monitor_desc.array,
+			monitor_idx);
+
+	dstr_free(&monitor_desc);
+
+	return true;
+}
+
+static obs_properties_t *duplicator_capture_properties(void *unused)
+{
+	int monitor_idx = 0;
+
+	UNUSED_PARAMETER(unused);
+
+	obs_properties_t *props = obs_properties_create();
+
+	obs_property_t *monitors = obs_properties_add_list(props,
+		"monitor", TEXT_MONITOR,
+		OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+
+	obs_property_t *capture_cursor = obs_properties_add_bool(props,
+		"capture_cursor", TEXT_CAPTURE_CURSOR);
+
+	obs_enter_graphics();
+
+	while (get_monitor_props(monitors, monitor_idx++));
+
+	obs_leave_graphics();
+
+	return props;
+}
+
+struct obs_source_info duplicator_capture_info = {
+	.id             = "monitor_capture",
+	.type           = OBS_SOURCE_TYPE_INPUT,
+	.output_flags   = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW,
+	.get_name       = duplicator_capture_getname,
+	.create         = duplicator_capture_create,
+	.destroy        = duplicator_capture_destroy,
+	.video_render   = duplicator_capture_render,
+	.video_tick     = duplicator_capture_tick,
+	.update         = duplicator_capture_update,
+	.get_width      = duplicator_capture_width,
+	.get_height     = duplicator_capture_height,
+	.get_defaults   = duplicator_capture_defaults,
+	.get_properties = duplicator_capture_properties
+};

plugins/win-capture/plugin-main.c

@@ -1,8 +1,10 @@
+#include <windows.h>
 #include <obs-module.h>
 
 OBS_DECLARE_MODULE()
 OBS_MODULE_USE_DEFAULT_LOCALE("win-capture", "en-US")
 
+extern struct obs_source_info duplicator_capture_info;
 extern struct obs_source_info monitor_capture_info;
 extern struct obs_source_info window_capture_info;
 extern struct obs_source_info game_capture_info;
@@ -19,7 +21,25 @@ extern bool load_graphics_offsets(bool is32bit);
 
 bool obs_module_load(void)
 {
-	obs_register_source(&monitor_capture_info);
+	OSVERSIONINFO osvi = {0};
+	bool win8_or_above = false;
+
+	osvi.dwOSVersionInfoSize = sizeof(osvi);
+
+	if (!!GetVersionEx(&osvi)) {
+		win8_or_above = osvi.dwMajorVersion > 6 ||
+			(osvi.dwMajorVersion == 6 && osvi.dwMinorVersion >= 2);
+	}
+
+	obs_enter_graphics();
+
+	if (win8_or_above && gs_get_device_type() == GS_DEVICE_DIRECT3D_11)
+		obs_register_source(&duplicator_capture_info);
+	else
+		obs_register_source(&monitor_capture_info);
+
+	obs_leave_graphics();
+
 	obs_register_source(&window_capture_info);
 
 	if (load_graphics_offsets(IS32BIT)) {