Add Windows capture backends for recording

jonoomph · jonoomph · commit 1cde209af60e · 2026-06-19T22:52:31.000-05:00
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
@@ -105,6 +105,8 @@ windows-builder-x64:
     - $env:OpenCV_DIR = "$env:OPENCV_ROOT\lib\cmake\opencv4"
     - $env:Path = "$env:OPENCV_ROOT\bin;C:\msys64\mingw64\bin;C:\msys64\usr\bin;C:\msys64\usr\local\bin;" + $env:Path;
     - $env:MSYSTEM = "MINGW64"
+    - ffmpeg -hide_banner -devices | findstr /I "gdigrab"
+    - ffmpeg -hide_banner -devices | findstr /I "dshow"
     - cmake -B build -S . -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -D"babl_DIR=C:/msys64/mingw64" -D"CMAKE_INSTALL_PREFIX:PATH=$CI_PROJECT_DIR\build\install-x64" -D"OpenShotAudio_ROOT=$CI_PROJECT_DIR\build\install-x64" -D"OpenCV_DIR:PATH=$env:OpenCV_DIR" -D"PYTHON_MODULE_PATH=python" -D"RUBY_MODULE_PATH=ruby" -G "MinGW Makefiles" -D"CMAKE_BUILD_TYPE:STRING=Release"
     - cmake --build build --parallel $([Environment]::ProcessorCount)
     - ctest --test-dir build --output-on-failure -VV
@@ -134,6 +136,8 @@ windows-builder-x86:
     - $env:OpenCV_DIR = "$env:OPENCV_ROOT\lib\cmake\opencv4"
     - $env:Path = "$env:OPENCV_ROOT\bin;C:\msys64\mingw32\bin;C:\msys64\usr\bin;C:\msys64\usr\local\bin;" + $env:Path;
     - $env:MSYSTEM = "MINGW32"
+    - ffmpeg -hide_banner -devices | findstr /I "gdigrab"
+    - ffmpeg -hide_banner -devices | findstr /I "dshow"
     - cmake -B build -S . -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -D"babl_DIR=C:/msys64/mingw32" -D"CMAKE_INSTALL_PREFIX:PATH=$CI_PROJECT_DIR\build\install-x86" -D"OpenShotAudio_ROOT=$CI_PROJECT_DIR\build\install-x86" -D"OpenCV_DIR:PATH=$env:OpenCV_DIR" -D"PYTHON_MODULE_PATH=python" -D"RUBY_MODULE_PATH=ruby" -G "MinGW Makefiles" -D"CMAKE_BUILD_TYPE:STRING=Release" -D"CMAKE_CXX_FLAGS=-m32" -D"CMAKE_EXE_LINKER_FLAGS=-Wl,--large-address-aware" -D"CMAKE_C_FLAGS=-m32"
     - cmake --build build --parallel $([Environment]::ProcessorCount)
     - cmake --install build
diff --git a/src/CameraCaptureReader.cpp b/src/CameraCaptureReader.cpp
@@ -14,6 +14,10 @@
 
 #include <cstdlib>
 
+extern "C" {
+	#include <libavdevice/avdevice.h>
+}
+
 #include "Exceptions.h"
 
 using namespace openshot;
@@ -38,6 +42,8 @@ bool CameraCaptureReader::IsBackendSupported(CameraCaptureBackend backend)
 {
 #if defined(__linux__)
 	return backend == CAMERA_CAPTURE_V4L2 || backend == CAMERA_CAPTURE_AUTO;
+#elif defined(_WIN32)
+	return backend == CAMERA_CAPTURE_WINDOWS_DSHOW || backend == CAMERA_CAPTURE_AUTO;
 #else
 	(void) backend;
 	return false;
@@ -48,18 +54,78 @@ CameraCaptureBackend CameraCaptureReader::DefaultBackend()
 {
 #if defined(__linux__)
 	return CAMERA_CAPTURE_V4L2;
+#elif defined(_WIN32)
+	return CAMERA_CAPTURE_WINDOWS_DSHOW;
 #else
 	return CAMERA_CAPTURE_AUTO;
 #endif
 }
 
+AudioDeviceList CameraCaptureReader::GetDeviceNames(CameraCaptureBackend backend)
+{
+	if (backend == CAMERA_CAPTURE_AUTO) {
+		backend = DefaultBackend();
+	}
+
+	AudioDeviceList devices;
+	const char* input_format_name = nullptr;
+#if defined(__linux__)
+	if (backend == CAMERA_CAPTURE_V4L2) {
+		input_format_name = "v4l2";
+	}
+#elif defined(_WIN32)
+	if (backend == CAMERA_CAPTURE_WINDOWS_DSHOW) {
+		input_format_name = "dshow";
+	}
+#endif
+	if (!input_format_name) {
+		return devices;
+	}
+
+	avdevice_register_all();
+	const AVInputFormat* input_format = av_find_input_format(input_format_name);
+	if (!input_format) {
+		return devices;
+	}
+
+	AVDeviceInfoList* device_list = nullptr;
+	const int result = avdevice_list_input_sources(input_format, nullptr, nullptr, &device_list);
+	if (result >= 0 && device_list) {
+		for (int index = 0; index < device_list->nb_devices; ++index) {
+			const AVDeviceInfo* device = device_list->devices[index];
+			if (!device || !device->device_name) {
+				continue;
+			}
+			if (device->nb_media_types > 0 && device->media_types) {
+				bool has_video = false;
+				for (int media_index = 0; media_index < device->nb_media_types; ++media_index) {
+					if (device->media_types[media_index] == AVMEDIA_TYPE_VIDEO) {
+						has_video = true;
+						break;
+					}
+				}
+				if (!has_video) {
+					continue;
+				}
+			}
+			const std::string name = device->device_name;
+			const std::string label = device->device_description
+				? device->device_description
+				: device->device_name;
+			devices.emplace_back(label, name);
+		}
+	}
+	avdevice_free_list_devices(&device_list);
+	return devices;
+}
+
 void CameraCaptureReader::ValidateSettings() const
 {
 	if (!IsBackendSupported(settings.backend)) {
 		throw InvalidOptions("Camera capture backend is not supported on this OS.");
 	}
-	if (settings.backend != CAMERA_CAPTURE_V4L2) {
-		throw InvalidOptions("Only the v4l2 camera capture backend is implemented in this build.");
+	if (settings.backend != CAMERA_CAPTURE_V4L2 && settings.backend != CAMERA_CAPTURE_WINDOWS_DSHOW) {
+		throw InvalidOptions("Camera capture backend is not implemented in this build.");
 	}
 	if (settings.device.empty()) {
 		throw InvalidOptions("Camera capture requires a device path.");
@@ -75,13 +141,19 @@ void CameraCaptureReader::ValidateSettings() const
 ScreenCaptureSettings CameraCaptureReader::ToDeviceSettings() const
 {
 	ScreenCaptureSettings converted;
-	converted.backend = SCREEN_CAPTURE_X11;
 	converted.display = settings.device;
 	converted.width = settings.width;
 	converted.height = settings.height;
 	converted.fps = settings.fps;
 	converted.options = settings.options;
-	converted.options["input_format_name"] = "v4l2";
+	if (settings.backend == CAMERA_CAPTURE_WINDOWS_DSHOW) {
+		converted.backend = SCREEN_CAPTURE_WINDOWS_GDI;
+		converted.display = "video=" + settings.device;
+		converted.options["input_format_name"] = "dshow";
+	} else {
+		converted.backend = SCREEN_CAPTURE_X11;
+		converted.options["input_format_name"] = "v4l2";
+	}
 	return converted;
 }
 
diff --git a/src/CameraCaptureReader.h b/src/CameraCaptureReader.h
@@ -13,6 +13,7 @@
 #ifndef OPENSHOT_CAMERACAPTUREREADER_H
 #define OPENSHOT_CAMERACAPTUREREADER_H
 
+#include "AudioDevices.h"
 #include "ScreenCaptureReader.h"
 
 #include <memory>
@@ -58,6 +59,7 @@ namespace openshot
 		CameraCaptureSettings GetSettings() const { return settings; };
 		static bool IsBackendSupported(CameraCaptureBackend backend);
 		static CameraCaptureBackend DefaultBackend();
+		static AudioDeviceList GetDeviceNames(CameraCaptureBackend backend = CAMERA_CAPTURE_AUTO);
 
 	private:
 		void ValidateSettings() const;
diff --git a/src/ScreenCaptureReader.cpp b/src/ScreenCaptureReader.cpp
@@ -100,6 +100,8 @@ bool ScreenCaptureReader::IsBackendSupported(ScreenCaptureBackend backend)
 	}
 #endif
 	return false;
+#elif defined(_WIN32)
+	return backend == SCREEN_CAPTURE_WINDOWS_GDI || backend == SCREEN_CAPTURE_AUTO;
 #else
 	(void) backend;
 	return false;
@@ -116,18 +118,19 @@ ScreenCaptureBackend ScreenCaptureReader::DefaultBackend()
 	if (!session || std::string(session) == "x11") {
 		return SCREEN_CAPTURE_X11;
 	}
+#elif defined(_WIN32)
+	return SCREEN_CAPTURE_WINDOWS_GDI;
 #endif
 	return SCREEN_CAPTURE_AUTO;
 }
 
 void ScreenCaptureReader::ValidateSettings() const
 {
-	const bool using_v4l2_device = settings.options.count("input_format_name") && settings.options.at("input_format_name") == "v4l2";
 	if (!IsBackendSupported(settings.backend)) {
 		throw InvalidOptions("Screen capture backend is not supported on this OS or session.");
 	}
-	if (!UsesFFmpegDevice() && !UsesWaylandPortal() && !using_v4l2_device) {
-		throw InvalidOptions("Only the X11 screen capture backend is implemented in this build.");
+	if (!UsesFFmpegDevice() && !UsesWaylandPortal()) {
+		throw InvalidOptions("Screen capture backend is not implemented in this build.");
 	}
 	if (settings.width <= 0 || settings.height <= 0) {
 		throw InvalidOptions("Screen capture requires a positive width and height.");
@@ -139,8 +142,9 @@ void ScreenCaptureReader::ValidateSettings() const
 
 bool ScreenCaptureReader::UsesFFmpegDevice() const
 {
-	const bool using_v4l2_device = settings.options.count("input_format_name") && settings.options.at("input_format_name") == "v4l2";
-	return settings.backend == SCREEN_CAPTURE_X11 || using_v4l2_device;
+	return settings.backend == SCREEN_CAPTURE_X11
+		|| settings.backend == SCREEN_CAPTURE_WINDOWS_GDI
+		|| settings.options.count("input_format_name");
 }
 
 bool ScreenCaptureReader::UsesWaylandPortal() const
@@ -157,6 +161,9 @@ std::string ScreenCaptureReader::InputFormatName() const
 	if (settings.backend == SCREEN_CAPTURE_X11) {
 		return "x11grab";
 	}
+	if (settings.backend == SCREEN_CAPTURE_WINDOWS_GDI) {
+		return "gdigrab";
+	}
 	return "";
 }
 
@@ -165,6 +172,12 @@ std::string ScreenCaptureReader::InputName() const
 	if (InputFormatName() == "v4l2") {
 		return settings.display.empty() ? "/dev/video0" : settings.display;
 	}
+	if (InputFormatName() == "dshow") {
+		return settings.display;
+	}
+	if (InputFormatName() == "gdigrab") {
+		return settings.display.empty() ? "desktop" : settings.display;
+	}
 
 	std::string display = settings.display;
 	if (display.empty()) {
@@ -239,6 +252,11 @@ void ScreenCaptureReader::OpenDevice()
 	if (InputFormatName() == "x11grab") {
 		set_option(&options, "draw_mouse", settings.include_cursor ? "1" : "0");
 		set_option(&options, "show_region", settings.show_region ? "1" : "0");
+	} else if (InputFormatName() == "gdigrab") {
+		set_option(&options, "draw_mouse", settings.include_cursor ? "1" : "0");
+		set_option(&options, "show_region", settings.show_region ? "1" : "0");
+		set_option(&options, "offset_x", std::to_string(settings.x));
+		set_option(&options, "offset_y", std::to_string(settings.y));
 	}
 	for (const auto& option : settings.options) {
 		if (option.first == "input_format_name") {
diff --git a/tests/CameraCaptureReader.cpp b/tests/CameraCaptureReader.cpp
@@ -19,10 +19,15 @@ using namespace openshot;
 
 TEST_CASE("Camera capture settings validation", "[libopenshot][cameracapturereader]")
 {
-#if defined(__linux__)
 	CameraCaptureSettings settings;
+#if defined(__linux__)
 	settings.backend = CAMERA_CAPTURE_V4L2;
 	settings.device = "/dev/video0";
+#elif defined(_WIN32)
+	settings.backend = CAMERA_CAPTURE_WINDOWS_DSHOW;
+	settings.device = "Integrated Camera";
+#endif
+#if defined(__linux__) || defined(_WIN32)
 	settings.width = 640;
 	settings.height = 480;
 	settings.fps = Fraction(30, 1);
@@ -42,10 +47,15 @@ TEST_CASE("Camera capture settings validation", "[libopenshot][cameracaptureread
 
 TEST_CASE("Camera capture reader reports configured video info", "[libopenshot][cameracapturereader]")
 {
-#if defined(__linux__)
 	CameraCaptureSettings settings;
+#if defined(__linux__)
 	settings.backend = CAMERA_CAPTURE_V4L2;
 	settings.device = "/dev/video9";
+#elif defined(_WIN32)
+	settings.backend = CAMERA_CAPTURE_WINDOWS_DSHOW;
+	settings.device = "Integrated Camera";
+#endif
+#if defined(__linux__) || defined(_WIN32)
 	settings.width = 1280;
 	settings.height = 720;
 	settings.fps = Fraction(24, 1);
@@ -67,3 +77,11 @@ TEST_CASE("Camera capture reader reports configured video info", "[libopenshot][
 	CHECK_FALSE(CameraCaptureReader::IsBackendSupported(CAMERA_CAPTURE_V4L2));
 #endif
 }
+
+TEST_CASE("Camera capture default backend follows platform", "[libopenshot][cameracapturereader]")
+{
+#if defined(_WIN32)
+	CHECK(CameraCaptureReader::IsBackendSupported(CAMERA_CAPTURE_WINDOWS_DSHOW));
+	CHECK(CameraCaptureReader::DefaultBackend() == CAMERA_CAPTURE_WINDOWS_DSHOW);
+#endif
+}
diff --git a/tests/ScreenCaptureReader.cpp b/tests/ScreenCaptureReader.cpp
@@ -22,10 +22,15 @@ using namespace openshot;
 
 TEST_CASE("Screen capture settings validation", "[libopenshot][screencapturereader]")
 {
-#if defined(__linux__)
 	ScreenCaptureSettings settings;
+#if defined(__linux__)
 	settings.backend = SCREEN_CAPTURE_X11;
 	settings.display = ":0.0";
+#elif defined(_WIN32)
+	settings.backend = SCREEN_CAPTURE_WINDOWS_GDI;
+	settings.display = "desktop";
+#endif
+#if defined(__linux__) || defined(_WIN32)
 	settings.width = 640;
 	settings.height = 360;
 	settings.fps = Fraction(30, 1);
@@ -45,10 +50,15 @@ TEST_CASE("Screen capture settings validation", "[libopenshot][screencaptureread
 
 TEST_CASE("Screen capture reader reports configured video info", "[libopenshot][screencapturereader]")
 {
-#if defined(__linux__)
 	ScreenCaptureSettings settings;
+#if defined(__linux__)
 	settings.backend = SCREEN_CAPTURE_X11;
 	settings.display = ":99.0";
+#elif defined(_WIN32)
+	settings.backend = SCREEN_CAPTURE_WINDOWS_GDI;
+	settings.display = "desktop";
+#endif
+#if defined(__linux__) || defined(_WIN32)
 	settings.x = 10;
 	settings.y = 20;
 	settings.width = 800;
@@ -74,7 +84,9 @@ TEST_CASE("Screen capture reader reports configured video info", "[libopenshot][
 	CHECK(json["y"].asInt() == 20);
 	CHECK(json["include_cursor"].asBool() == false);
 	CHECK(json["show_region"].asBool() == true);
+#if defined(__linux__)
 	CHECK(json["options"]["window_id"].asString() == "12345");
+#endif
 #else
 	CHECK_FALSE(ScreenCaptureReader::IsBackendSupported(SCREEN_CAPTURE_X11));
 #endif
@@ -96,13 +108,25 @@ TEST_CASE("Screen capture backend support follows platform build features", "[li
 	} else {
 		CHECK_THROWS_AS([&wayland_settings]() { ScreenCaptureReader reader(wayland_settings); }(), InvalidOptions);
 	}
+#else
+#if defined(_WIN32)
+	CHECK(ScreenCaptureReader::IsBackendSupported(SCREEN_CAPTURE_AUTO));
+	CHECK(ScreenCaptureReader::IsBackendSupported(SCREEN_CAPTURE_WINDOWS_GDI));
 #else
 	CHECK_FALSE(ScreenCaptureReader::IsBackendSupported(SCREEN_CAPTURE_AUTO));
+#endif
 	CHECK_FALSE(ScreenCaptureReader::IsBackendSupported(SCREEN_CAPTURE_X11));
 	CHECK_FALSE(ScreenCaptureReader::IsBackendSupported(SCREEN_CAPTURE_WAYLAND));
 #endif
 }
 
+TEST_CASE("Screen capture default backend follows platform", "[libopenshot][screencapturereader]")
+{
+#if defined(_WIN32)
+	CHECK(ScreenCaptureReader::DefaultBackend() == SCREEN_CAPTURE_WINDOWS_GDI);
+#endif
+}
+
 TEST_CASE("Screen capture auto backend prefers Wayland only when supported", "[libopenshot][screencapturereader]")
 {
 #if defined(__linux__)
