Create polished demo videos without editing skills. Mac/Windows/Linux
Add native WGC screen capture for Windows
tokenflow1me6f36a4d14f5
diff --git a/.gitignore b/.gitignoreindex 422f77dc..43ddf77b 100644--- a/.gitignore+++ b/.gitignore@@ -27,4 +27,7 @@ release/***.kiro/# npx electron-builder --mac --win.tmp/-.history/+.history/++# WGC native capture build artifacts+electron/native/wgc-capture/build/diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.tsindex 786fb75b..a4bf779f 100644--- a/electron/electron-env.d.ts+++ b/electron/electron-env.d.ts@@ -78,6 +78,8 @@ interface Window {hudOverlayClose: () => void;setHasUnsavedChanges: (hasChanges: boolean) => voidonRequestSaveBeforeClose: (callback: () => Promise<void>) => () => void+ isWgcAvailable: () => Promise<{ available: boolean }>+ storeWgcAudio: (audioData: ArrayBuffer, type: 'system' | 'mic') => Promise<{ success: boolean; path?: string; error?: string }>/** Hide the OS cursor before browser capture starts. */hideOsCursor: () => Promise<{ success: boolean }>}diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.tsindex d05196ac..690a1cf7 100644--- a/electron/ipc/handlers.ts+++ b/electron/ipc/handlers.ts@@ -59,6 +59,13 @@ let nativeCaptureStopRequested = falselet nativeCaptureMicrophonePath: string | null = nulllet nativeCursorMonitorProcess: ChildProcessWithoutNullStreams | null = nulllet nativeCursorMonitorOutputBuffer = ''+let wgcCaptureProcess: ChildProcessWithoutNullStreams | null = null+let wgcCaptureOutputBuffer = ''+let wgcCaptureTargetPath: string | null = null+let wgcScreenRecordingActive = false+let wgcCaptureStopRequested = false+let wgcSystemAudioPath: string | null = null+let wgcMicAudioPath: string | null = nulllet ffmpegScreenRecordingActive = falselet ffmpegCaptureProcess: ChildProcessWithoutNullStreams | null = nulllet ffmpegCaptureOutputBuffer = ''@@ -678,6 +685,197 @@ async function buildFfmpegCaptureArgs(source: SelectedSource, outputPath: stringthrow new Error(`FFmpeg capture is not supported on ${process.platform}`)}+function getWgcCaptureExePath() {+ return resolveUnpackedAppPath('electron', 'native', 'wgc-capture', 'build', 'Release', 'wgc-capture.exe')+}++async function isWgcCaptureAvailable(): Promise<boolean> {+ if (process.platform !== 'win32') return false++ try {+ await fs.access(getWgcCaptureExePath(), fsConstants.X_OK)+ } catch {+ return false+ }++ // Windows 10 2004 (Build 19041) minimum for IsCursorCaptureEnabled+ const os = await import('node:os')+ const [major, , build] = os.release().split('.').map(Number)+ return major >= 10 && build >= 19041+}++function waitForWgcCaptureStart(proc: ChildProcessWithoutNullStreams) {+ return new Promise<void>((resolve, reject) => {+ const timer = setTimeout(() => {+ cleanup()+ reject(new Error('Timed out waiting for WGC capture to start'))+ }, 12000)++ const onStdout = (chunk: Buffer) => {+ const text = chunk.toString()+ if (text.includes('Recording started')) {+ cleanup()+ resolve()+ }+ }++ const onError = (error: Error) => {+ cleanup()+ reject(error)+ }++ const onExit = (code: number | null) => {+ cleanup()+ reject(new Error(wgcCaptureOutputBuffer.trim() || `WGC capture exited before recording started (code ${code ?? 'unknown'})`))+ }++ const cleanup = () => {+ clearTimeout(timer)+ proc.stdout.off('data', onStdout)+ proc.off('error', onError)+ proc.off('exit', onExit)+ }++ proc.stdout.on('data', onStdout)+ proc.once('error', onError)+ proc.once('exit', onExit)+ })+}++function waitForWgcCaptureStop(proc: ChildProcessWithoutNullStreams) {+ return new Promise<string>((resolve, reject) => {+ const onClose = (code: number | null) => {+ cleanup()+ const match = wgcCaptureOutputBuffer.match(/Recording stopped\. Output path: (.+)/)+ if (match?.[1]) {+ resolve(match[1].trim())+ return+ }+ if (code === 0 && wgcCaptureTargetPath) {+ resolve(wgcCaptureTargetPath)+ return+ }+ reject(new Error(wgcCaptureOutputBuffer.trim() || `WGC capture exited with code ${code ?? 'unknown'}`))+ }++ const onError = (error: Error) => {+ cleanup()+ reject(error)+ }++ const cleanup = () => {+ proc.off('close', onClose)+ proc.off('error', onError)+ }++ proc.once('close', onClose)+ proc.once('error', onError)+ })+}++function attachWgcCaptureLifecycle(proc: ChildProcessWithoutNullStreams) {+ proc.once('close', () => {+ const wasActive = wgcScreenRecordingActive+ wgcCaptureProcess = null++ if (!wasActive || wgcCaptureStopRequested) {+ return+ }++ wgcScreenRecordingActive = false+ wgcCaptureTargetPath = null+ wgcCaptureStopRequested = false++ const sourceName = selectedSource?.name ?? 'Screen'+ BrowserWindow.getAllWindows().forEach((window) => {+ if (!window.isDestroyed()) {+ window.webContents.send('recording-state-changed', {+ recording: false,+ sourceName,+ })+ }+ })++ emitRecordingInterrupted('capture-stopped', 'Recording stopped unexpectedly.')+ })+}++async function muxWgcVideoWithAudio(videoPath: string, systemAudioPath: string | null, micAudioPath: string | null) {+ const ffmpegPath = getFfmpegBinaryPath()+ const inputs: string[] = ['-i', videoPath]+ const audioInputs: string[] = []++ if (systemAudioPath) {+ try {+ await fs.access(systemAudioPath)+ inputs.push('-i', systemAudioPath)+ audioInputs.push('system')+ } catch {+ // system audio file not available+ }+ }++ if (micAudioPath) {+ try {+ await fs.access(micAudioPath)+ inputs.push('-i', micAudioPath)+ audioInputs.push('mic')+ } catch {+ // mic audio file not available+ }+ }++ if (audioInputs.length === 0) return++ const mixedOutputPath = `${videoPath}.muxed.mp4`++ if (audioInputs.length === 2) {+ // Both system + mic audio: mix them+ await execFileAsync(+ ffmpegPath,+ [+ '-y',+ ...inputs,+ '-filter_complex', '[1:a][2:a]amix=inputs=2:duration=longest:normalize=0[aout]',+ '-map', '0:v:0',+ '-map', '[aout]',+ '-c:v', 'copy',+ '-c:a', 'aac',+ '-b:a', '192k',+ '-shortest',+ mixedOutputPath,+ ],+ { timeout: 120000, maxBuffer: 10 * 1024 * 1024 },+ )+ } else {+ // Single audio track+ await execFileAsync(+ ffmpegPath,+ [+ '-y',+ ...inputs,+ '-map', '0:v:0',+ '-map', '1:a:0',+ '-c:v', 'copy',+ '-c:a', 'aac',+ '-b:a', '192k',+ '-shortest',+ mixedOutputPath,+ ],+ { timeout: 120000, maxBuffer: 10 * 1024 * 1024 },+ )+ }++ await moveFileWithOverwrite(mixedOutputPath, videoPath)++ // Clean up audio files+ for (const audioPath of [systemAudioPath, micAudioPath]) {+ if (audioPath) {+ await fs.rm(audioPath, { force: true }).catch(() => {})+ }+ }+}+function waitForNativeCaptureStart(process: ChildProcessWithoutNullStreams) {return new Promise<void>((resolve, reject) => {const timer = setTimeout(() => {@@ -1492,6 +1690,74 @@ export function registerIpcHandlers(})ipcMain.handle('start-native-screen-recording', async (_, source: SelectedSource, options?: NativeMacRecordingOptions) => {+ // Windows WGC path+ if (process.platform === 'win32') {+ const wgcAvailable = await isWgcCaptureAvailable()+ if (!wgcAvailable) {+ return { success: false, message: 'WGC capture is not available on this system.' }+ }++ if (wgcCaptureProcess && !wgcScreenRecordingActive) {+ try { wgcCaptureProcess.kill() } catch { /* ignore */ }+ wgcCaptureProcess = null+ wgcCaptureTargetPath = null+ wgcCaptureStopRequested = false+ }++ if (wgcCaptureProcess) {+ return { success: false, message: 'A WGC screen recording is already active.' }+ }++ try {+ const exePath = getWgcCaptureExePath()+ const outputPath = path.join(RECORDINGS_DIR, `recording-${Date.now()}.mp4`)+ const screenId = Number(source?.display_id)+ const displayId = Number.isFinite(screenId) && screenId > 0+ ? screenId+ : Number(getScreen().getPrimaryDisplay().id)++ const config: Record<string, unknown> = {+ displayId,+ outputPath,+ fps: 60,+ }++ wgcCaptureOutputBuffer = ''+ wgcCaptureTargetPath = outputPath+ wgcCaptureStopRequested = false+ wgcCaptureProcess = spawn(exePath, [JSON.stringify(config)], {+ cwd: RECORDINGS_DIR,+ stdio: ['pipe', 'pipe', 'pipe'],+ })+ attachWgcCaptureLifecycle(wgcCaptureProcess)++ wgcCaptureProcess.stdout.on('data', (chunk: Buffer) => {+ wgcCaptureOutputBuffer += chunk.toString()+ })+ wgcCaptureProcess.stderr.on('data', (chunk: Buffer) => {+ wgcCaptureOutputBuffer += chunk.toString()+ })++ await waitForWgcCaptureStart(wgcCaptureProcess)+ wgcScreenRecordingActive = true+ nativeScreenRecordingActive = true+ return { success: true }+ } catch (error) {+ console.error('Failed to start WGC capture:', error)+ try { wgcCaptureProcess?.kill() } catch { /* ignore */ }+ wgcScreenRecordingActive = false+ nativeScreenRecordingActive = false+ wgcCaptureProcess = null+ wgcCaptureTargetPath = null+ wgcCaptureStopRequested = false+ return {+ success: false,+ message: 'Failed to start WGC capture',+ error: String(error),+ }+ }+ }+if (process.platform !== 'darwin') {return { success: false, message: 'Native screen recording is only available on macOS.' }}@@ -1599,6 +1865,68 @@ export function registerIpcHandlers(})ipcMain.handle('stop-native-screen-recording', async () => {+ // Windows WGC stop path+ if (process.platform === 'win32' && wgcScreenRecordingActive) {+ try {+ if (!wgcCaptureProcess) {+ throw new Error('WGC capture process is not running')+ }++ const proc = wgcCaptureProcess+ const preferredVideoPath = wgcCaptureTargetPath+ wgcCaptureStopRequested = true+ proc.stdin.write('stop\n')+ const tempVideoPath = await waitForWgcCaptureStop(proc)+ wgcCaptureProcess = null+ wgcScreenRecordingActive = false+ nativeScreenRecordingActive = false+ wgcCaptureTargetPath = null+ wgcCaptureStopRequested = false++ const finalVideoPath = preferredVideoPath ?? tempVideoPath+ if (tempVideoPath !== finalVideoPath) {+ await moveFileWithOverwrite(tempVideoPath, finalVideoPath)+ }++ if (wgcSystemAudioPath || wgcMicAudioPath) {+ try {+ await muxWgcVideoWithAudio(finalVideoPath, wgcSystemAudioPath, wgcMicAudioPath)+ } catch (muxError) {+ console.warn('Failed to mux WGC audio:', muxError)+ }+ wgcSystemAudioPath = null+ wgcMicAudioPath = null+ }++ return await finalizeStoredVideo(finalVideoPath)+ } catch (error) {+ console.error('Failed to stop WGC capture:', error)+ const fallbackPath = wgcCaptureTargetPath+ wgcScreenRecordingActive = false+ nativeScreenRecordingActive = false+ wgcCaptureProcess = null+ wgcCaptureTargetPath = null+ wgcCaptureStopRequested = false+ wgcSystemAudioPath = null+ wgcMicAudioPath = null++ if (fallbackPath) {+ try {+ await fs.access(fallbackPath)+ return await finalizeStoredVideo(fallbackPath)+ } catch {+ // File doesn't exist+ }+ }++ return {+ success: false,+ message: 'Failed to stop WGC capture',+ error: String(error),+ }+ }+ }+if (process.platform !== 'darwin') {return { success: false, message: 'Native screen recording is only available on macOS.' }}@@ -1676,6 +2004,25 @@ export function registerIpcHandlers(}})+ ipcMain.handle('is-wgc-available', async () => {+ return { available: await isWgcCaptureAvailable() }+ })++ ipcMain.handle('store-wgc-audio', async (_, audioData: ArrayBuffer, type: 'system' | 'mic') => {+ try {+ const audioPath = path.join(RECORDINGS_DIR, `recording-${Date.now()}.${type}.webm`)+ await fs.writeFile(audioPath, Buffer.from(audioData))+ if (type === 'system') {+ wgcSystemAudioPath = audioPath+ } else {+ wgcMicAudioPath = audioPath+ }+ return { success: true, path: audioPath }+ } catch (error) {+ return { success: false, error: String(error) }+ }+ })+ipcMain.handle('start-ffmpeg-recording', async (_, source: SelectedSource) => {if (ffmpegCaptureProcess) {return { success: false, message: 'An FFmpeg recording is already active.' }diff --git a/electron/native/wgc-capture/CMakeLists.txt b/electron/native/wgc-capture/CMakeLists.txtnew file mode 100644index 00000000..418fbb8f--- /dev/null+++ b/electron/native/wgc-capture/CMakeLists.txt@@ -0,0 +1,26 @@+cmake_minimum_required(VERSION 3.20)+project(wgc-capture LANGUAGES CXX)++set(CMAKE_CXX_STANDARD 17)+set(CMAKE_CXX_STANDARD_REQUIRED ON)++add_executable(wgc-capture+ src/main.cpp+ src/wgc_session.cpp+ src/mf_encoder.cpp+ src/monitor_utils.cpp+)++target_compile_options(wgc-capture PRIVATE /EHsc /W3 /utf-8)++target_link_libraries(wgc-capture PRIVATE+ windowsapp+ d3d11+ dxgi+ mfplat+ mfreadwrite+ mf+ mfuuid+ ole32+ shcore+)diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cppnew file mode 100644index 00000000..ac2063e4--- /dev/null+++ b/electron/native/wgc-capture/src/main.cpp@@ -0,0 +1,196 @@+#include "wgc_session.h"+#include "mf_encoder.h"+#include "monitor_utils.h"++#include <winrt/Windows.Foundation.h>+#include <winrt/Windows.System.h>++#include <iostream>+#include <string>+#include <thread>+#include <atomic>+#include <mutex>+#include <condition_variable>++static std::atomic<bool> g_stopRequested{false};+static std::mutex g_stopMutex;+static std::condition_variable g_stopCv;++struct CaptureConfig {+ int displayId = 0;+ std::string outputPath;+ int fps = 60;+ int width = 0;+ int height = 0;+};++static bool parseSimpleJson(const std::string& json, CaptureConfig& config) {+ auto findInt = [&](const std::string& key) -> int {+ auto pos = json.find("\"" + key + "\"");+ if (pos == std::string::npos) return -1;+ pos = json.find(':', pos);+ if (pos == std::string::npos) return -1;+ pos++;+ while (pos < json.size() && (json[pos] == ' ' || json[pos] == '\t')) pos++;+ try {+ return std::stoi(json.substr(pos));+ } catch (...) {+ return -1;+ }+ };++ auto findString = [&](const std::string& key) -> std::string {+ auto pos = json.find("\"" + key + "\"");+ if (pos == std::string::npos) return "";+ pos = json.find(':', pos);+ if (pos == std::string::npos) return "";+ pos++;+ while (pos < json.size() && (json[pos] == ' ' || json[pos] == '\t')) pos++;+ if (pos >= json.size() || json[pos] != '"') return "";+ pos++;+ std::string result;+ while (pos < json.size() && json[pos] != '"') {+ if (json[pos] == '\\' && pos + 1 < json.size()) {+ pos++;+ if (json[pos] == 'n') result += '\n';+ else if (json[pos] == 't') result += '\t';+ else if (json[pos] == '\\') result += '\\';+ else if (json[pos] == '"') result += '"';+ else if (json[pos] == '/') result += '/';+ else result += json[pos];+ } else {+ result += json[pos];+ }+ pos++;+ }+ return result;+ };++ config.outputPath = findString("outputPath");+ if (config.outputPath.empty()) return false;++ int displayId = findInt("displayId");+ if (displayId >= 0) config.displayId = displayId;++ int fps = findInt("fps");+ if (fps > 0) config.fps = fps;++ int width = findInt("width");+ if (width > 0) config.width = width;++ int height = findInt("height");+ if (height > 0) config.height = height;++ return true;+}++static std::wstring utf8ToWide(const std::string& str) {+ if (str.empty()) return L"";+ int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), static_cast<int>(str.size()), nullptr, 0);+ std::wstring wstr(len, L'\0');+ MultiByteToWideChar(CP_UTF8, 0, str.c_str(), static_cast<int>(str.size()), &wstr[0], len);+ return wstr;+}++static void stdinListenerThread() {+ std::string line;+ while (std::getline(std::cin, line)) {+ // Trim whitespace+ while (!line.empty() && (line.back() == '\r' || line.back() == '\n' || line.back() == ' ')) {+ line.pop_back();+ }++ if (line == "stop") {+ g_stopRequested = true;+ g_stopCv.notify_all();+ return;+ }+ }++ // stdin closed (parent process died)+ g_stopRequested = true;+ g_stopCv.notify_all();+}++int main(int argc, char* argv[]) {+ if (argc < 2) {+ std::cerr << "ERROR: Missing JSON config argument" << std::endl;+ return 1;+ }++ winrt::init_apartment(winrt::apartment_type::multi_threaded);++ CaptureConfig config;+ if (!parseSimpleJson(argv[1], config)) {+ std::cerr << "ERROR: Failed to parse config JSON" << std::endl;+ return 1;+ }++ // Resolve monitor+ HMONITOR monitor = findMonitorByDisplayId(config.displayId);+ if (!monitor) {+ std::cerr << "ERROR: Could not find monitor for displayId " << config.displayId << std::endl;+ return 1;+ }++ // Initialize WGC session+ WgcSession session;+ if (!session.initialize(monitor, config.fps)) {+ std::cerr << "ERROR: Failed to initialize WGC capture session" << std::endl;+ return 1;+ }++ int captureWidth = config.width > 0 ? config.width : session.captureWidth();+ int captureHeight = config.height > 0 ? config.height : session.captureHeight();++ // Ensure even dimensions for H.264+ captureWidth = (captureWidth / 2) * 2;+ captureHeight = (captureHeight / 2) * 2;++ // Initialize encoder+ MFEncoder encoder;+ std::wstring outputPathW = utf8ToWide(config.outputPath);+ if (!encoder.initialize(outputPathW, captureWidth, captureHeight, config.fps,+ session.device(), session.context())) {+ std::cerr << "ERROR: Failed to initialize Media Foundation encoder" << std::endl;+ return 1;+ }++ // Set up frame callback+ std::atomic<int64_t> frameCount{0};+ session.setFrameCallback([&](ID3D11Texture2D* texture, int64_t timestampHns) {+ if (g_stopRequested) return;+ if (encoder.writeFrame(texture, timestampHns)) {+ frameCount++;+ }+ });++ // Start stdin listener+ std::thread stdinThread(stdinListenerThread);+ stdinThread.detach();++ // Start capture+ if (!session.startCapture()) {+ std::cerr << "ERROR: Failed to start WGC capture" << std::endl;+ return 1;+ }++ std::cout << "Recording started" << std::endl;+ std::cout.flush();++ // Wait for stop signal+ {+ std::unique_lock<std::mutex> lock(g_stopMutex);+ g_stopCv.wait(lock, [] { return g_stopRequested.load(); });+ }++ // Stop capture and finalize+ session.stopCapture();+ encoder.finalize();++ std::cout << "Recording stopped. Output path: " << config.outputPath << std::endl;+ std::cout.flush();++ // Fast exit to avoid WinRT/COM teardown crashes during apartment cleanup+ ExitProcess(0);+}diff --git a/electron/native/wgc-capture/src/mf_encoder.cpp b/electron/native/wgc-capture/src/mf_encoder.cppnew file mode 100644index 00000000..e0b74707--- /dev/null+++ b/electron/native/wgc-capture/src/mf_encoder.cpp@@ -0,0 +1,200 @@+#include "mf_encoder.h"+#include <mfapi.h>+#include <mferror.h>+#include <codecapi.h>+#include <iostream>+#include <cstring>++#pragma comment(lib, "mfplat.lib")+#pragma comment(lib, "mfreadwrite.lib")+#pragma comment(lib, "mf.lib")+#pragma comment(lib, "mfuuid.lib")++static int clampByte(int v) {+ return v < 0 ? 0 : (v > 255 ? 255 : v);+}++MFEncoder::MFEncoder() {}++MFEncoder::~MFEncoder() {+ finalize();+}++bool MFEncoder::initialize(const std::wstring& outputPath, int width, int height, int fps,+ ID3D11Device* device, ID3D11DeviceContext* context) {+ if (initialized_) return false;++ width_ = width;+ height_ = height;+ fps_ = fps;+ device_ = device;+ context_ = context;++ HRESULT hr = MFStartup(MF_VERSION);+ if (FAILED(hr)) {+ std::cerr << "ERROR: MFStartup failed: 0x" << std::hex << hr << std::endl;+ return false;+ }++ // Output media type (H.264)+ ComPtr<IMFMediaType> outputType;+ hr = MFCreateMediaType(&outputType);+ if (FAILED(hr)) return false;++ outputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);+ outputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);+ outputType->SetUINT32(MF_MT_AVG_BITRATE, 20000000);+ MFSetAttributeSize(outputType.Get(), MF_MT_FRAME_SIZE, width_, height_);+ MFSetAttributeRatio(outputType.Get(), MF_MT_FRAME_RATE, fps_, 1);+ MFSetAttributeRatio(outputType.Get(), MF_MT_PIXEL_ASPECT_RATIO, 1, 1);+ outputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);++ // Input media type (NV12)+ ComPtr<IMFMediaType> inputType;+ hr = MFCreateMediaType(&inputType);+ if (FAILED(hr)) return false;++ inputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);+ inputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12);+ MFSetAttributeSize(inputType.Get(), MF_MT_FRAME_SIZE, width_, height_);+ MFSetAttributeRatio(inputType.Get(), MF_MT_FRAME_RATE, fps_, 1);+ MFSetAttributeRatio(inputType.Get(), MF_MT_PIXEL_ASPECT_RATIO, 1, 1);+ inputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);++ // Create SinkWriter with MPEG4 container+ ComPtr<IMFAttributes> writerAttrs;+ hr = MFCreateAttributes(&writerAttrs, 1);+ if (FAILED(hr)) return false;++ writerAttrs->SetUINT32(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, TRUE);++ hr = MFCreateSinkWriterFromURL(outputPath.c_str(), nullptr, writerAttrs.Get(), &sinkWriter_);+ if (FAILED(hr)) {+ std::cerr << "ERROR: MFCreateSinkWriterFromURL failed: 0x" << std::hex << hr << std::endl;+ return false;+ }++ hr = sinkWriter_->AddStream(outputType.Get(), &streamIndex_);+ if (FAILED(hr)) {+ std::cerr << "ERROR: AddStream failed: 0x" << std::hex << hr << std::endl;+ return false;+ }++ hr = sinkWriter_->SetInputMediaType(streamIndex_, inputType.Get(), nullptr);+ if (FAILED(hr)) {+ std::cerr << "ERROR: SetInputMediaType failed: 0x" << std::hex << hr << std::endl;+ return false;+ }++ hr = sinkWriter_->BeginWriting();+ if (FAILED(hr)) {+ std::cerr << "ERROR: BeginWriting failed: 0x" << std::hex << hr << std::endl;+ return false;+ }++ // Pre-allocate staging texture+ D3D11_TEXTURE2D_DESC stagingDesc = {};+ stagingDesc.Width = width_;+ stagingDesc.Height = height_;+ stagingDesc.MipLevels = 1;+ stagingDesc.ArraySize = 1;+ stagingDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;+ stagingDesc.SampleDesc.Count = 1;+ stagingDesc.Usage = D3D11_USAGE_STAGING;+ stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;++ hr = device_->CreateTexture2D(&stagingDesc, nullptr, &stagingTexture_);+ if (FAILED(hr)) {+ std::cerr << "ERROR: Failed to create staging texture: 0x" << std::hex << hr << std::endl;+ return false;+ }++ // Pre-allocate NV12 buffer+ const int ySize = width_ * height_;+ const int uvSize = (width_ / 2) * (height_ / 2) * 2;+ nv12Buffer_.resize(ySize + uvSize);++ initialized_ = true;+ return true;+}++bool MFEncoder::writeFrame(ID3D11Texture2D* texture, int64_t timestampHns) {+ if (!initialized_ || !sinkWriter_) return false;++ context_->CopyResource(stagingTexture_.Get(), texture);++ D3D11_MAPPED_SUBRESOURCE mapped;+ HRESULT hr = context_->Map(stagingTexture_.Get(), 0, D3D11_MAP_READ, 0, &mapped);+ if (FAILED(hr)) return false;++ // Convert BGRA → NV12+ const uint8_t* bgra = static_cast<const uint8_t*>(mapped.pData);+ const int bgraPitch = static_cast<int>(mapped.RowPitch);++ // Y plane+ for (int y = 0; y < height_; y++) {+ for (int x = 0; x < width_; x++) {+ const uint8_t* pixel = bgra + y * bgraPitch + x * 4;+ uint8_t b = pixel[0], g = pixel[1], r = pixel[2];+ int yVal = ((66 * r + 129 * g + 25 * b + 128) >> 8) + 16;+ nv12Buffer_[y * width_ + x] = static_cast<uint8_t>(clampByte(yVal));+ }+ }++ // UV plane (interleaved, subsampled 2x2)+ const int ySize = width_ * height_;+ uint8_t* uvPlane = nv12Buffer_.data() + ySize;+ for (int y = 0; y < height_; y += 2) {+ for (int x = 0; x < width_; x += 2) {+ const uint8_t* pixel = bgra + y * bgraPitch + x * 4;+ uint8_t b = pixel[0], g = pixel[1], r = pixel[2];+ int u = ((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128;+ int v = ((112 * r - 94 * g - 18 * b + 128) >> 8) + 128;+ int uvIdx = (y / 2) * width_ + (x / 2) * 2;+ uvPlane[uvIdx] = static_cast<uint8_t>(clampByte(u));+ uvPlane[uvIdx + 1] = static_cast<uint8_t>(clampByte(v));+ }+ }++ context_->Unmap(stagingTexture_.Get(), 0);++ // Create MF sample+ DWORD bufferSize = static_cast<DWORD>(nv12Buffer_.size());+ ComPtr<IMFMediaBuffer> buffer;+ hr = MFCreateMemoryBuffer(bufferSize, &buffer);+ if (FAILED(hr)) return false;++ BYTE* bufferData = nullptr;+ hr = buffer->Lock(&bufferData, nullptr, nullptr);+ if (FAILED(hr)) return false;++ std::memcpy(bufferData, nv12Buffer_.data(), bufferSize);+ buffer->Unlock();+ buffer->SetCurrentLength(bufferSize);++ ComPtr<IMFSample> sample;+ hr = MFCreateSample(&sample);+ if (FAILED(hr)) return false;++ sample->AddBuffer(buffer.Get());+ sample->SetSampleTime(timestampHns);+ sample->SetSampleDuration(10000000LL / fps_);++ hr = sinkWriter_->WriteSample(streamIndex_, sample.Get());+ return SUCCEEDED(hr);+}++bool MFEncoder::finalize() {+ if (!initialized_) return false;+ initialized_ = false;++ stagingTexture_.Reset();+ nv12Buffer_.clear();+ nv12Buffer_.shrink_to_fit();++ if (!sinkWriter_) return false;+ HRESULT hr = sinkWriter_->Finalize();+ sinkWriter_.Reset();+ MFShutdown();+ return SUCCEEDED(hr);+}diff --git a/electron/native/wgc-capture/src/mf_encoder.h b/electron/native/wgc-capture/src/mf_encoder.hnew file mode 100644index 00000000..7eb8e642--- /dev/null+++ b/electron/native/wgc-capture/src/mf_encoder.h@@ -0,0 +1,35 @@+#pragma once++#include <windows.h>+#include <mfapi.h>+#include <mfidl.h>+#include <mfreadwrite.h>+#include <d3d11.h>+#include <wrl/client.h>+#include <string>+#include <vector>++using Microsoft::WRL::ComPtr;++class MFEncoder {+public:+ MFEncoder();+ ~MFEncoder();++ bool initialize(const std::wstring& outputPath, int width, int height, int fps,+ ID3D11Device* device, ID3D11DeviceContext* context);+ bool writeFrame(ID3D11Texture2D* texture, int64_t timestampHns);+ bool finalize();++private:+ ComPtr<IMFSinkWriter> sinkWriter_;+ ID3D11Device* device_ = nullptr;+ ID3D11DeviceContext* context_ = nullptr;+ ComPtr<ID3D11Texture2D> stagingTexture_;+ std::vector<uint8_t> nv12Buffer_;+ DWORD streamIndex_ = 0;+ int width_ = 0;+ int height_ = 0;+ int fps_ = 60;+ bool initialized_ = false;+};diff --git a/electron/native/wgc-capture/src/monitor_utils.cpp b/electron/native/wgc-capture/src/monitor_utils.cppnew file mode 100644index 00000000..25203ebf--- /dev/null+++ b/electron/native/wgc-capture/src/monitor_utils.cpp@@ -0,0 +1,61 @@+#include "monitor_utils.h"+#include <ShellScalingApi.h>++static BOOL CALLBACK enumMonitorCallback(HMONITOR hMonitor, HDC, LPRECT, LPARAM lParam) {+ auto* monitors = reinterpret_cast<std::vector<MonitorInfo>*>(lParam);++ MONITORINFOEXW mi = {};+ mi.cbSize = sizeof(mi);+ if (GetMonitorInfoW(hMonitor, &mi)) {+ MonitorInfo info;+ info.handle = hMonitor;+ info.x = mi.rcMonitor.left;+ info.y = mi.rcMonitor.top;+ info.width = mi.rcMonitor.right - mi.rcMonitor.left;+ info.height = mi.rcMonitor.bottom - mi.rcMonitor.top;+ info.deviceName = mi.szDevice;+ monitors->push_back(info);+ }++ return TRUE;+}++std::vector<MonitorInfo> enumerateMonitors() {+ std::vector<MonitorInfo> monitors;+ EnumDisplayMonitors(nullptr, nullptr, enumMonitorCallback, reinterpret_cast<LPARAM>(&monitors));+ return monitors;+}++// Electron uses the HMONITOR handle value cast to a number as the display ID.+HMONITOR findMonitorByDisplayId(int displayId) {+ auto monitors = enumerateMonitors();++ for (const auto& m : monitors) {+ if (static_cast<int>(reinterpret_cast<intptr_t>(m.handle)) == displayId) {+ return m.handle;+ }+ }++ if (!monitors.empty()) {+ return monitors[0].handle;+ }++ return MonitorFromPoint({0, 0}, MONITOR_DEFAULTTOPRIMARY);+}++MonitorInfo getMonitorInfo(HMONITOR monitor) {+ MonitorInfo info;+ info.handle = monitor;++ MONITORINFOEXW mi = {};+ mi.cbSize = sizeof(mi);+ if (GetMonitorInfoW(monitor, &mi)) {+ info.x = mi.rcMonitor.left;+ info.y = mi.rcMonitor.top;+ info.width = mi.rcMonitor.right - mi.rcMonitor.left;+ info.height = mi.rcMonitor.bottom - mi.rcMonitor.top;+ info.deviceName = mi.szDevice;+ }++ return info;+}diff --git a/electron/native/wgc-capture/src/monitor_utils.h b/electron/native/wgc-capture/src/monitor_utils.hnew file mode 100644index 00000000..513e3105--- /dev/null+++ b/electron/native/wgc-capture/src/monitor_utils.h@@ -0,0 +1,18 @@+#pragma once++#include <windows.h>+#include <string>+#include <vector>++struct MonitorInfo {+ HMONITOR handle;+ int x;+ int y;+ int width;+ int height;+ std::wstring deviceName;+};++std::vector<MonitorInfo> enumerateMonitors();+HMONITOR findMonitorByDisplayId(int displayId);+MonitorInfo getMonitorInfo(HMONITOR monitor);diff --git a/electron/native/wgc-capture/src/wgc_session.cpp b/electron/native/wgc-capture/src/wgc_session.cppnew file mode 100644index 00000000..b00ece5f--- /dev/null+++ b/electron/native/wgc-capture/src/wgc_session.cpp@@ -0,0 +1,196 @@+#include "wgc_session.h"++#include <windows.graphics.capture.interop.h>+#include <Windows.Graphics.Capture.h>+#include <inspectable.h>++#include <winrt/Windows.Foundation.h>+#include <winrt/Windows.System.h>++#include <iostream>+#include <chrono>++// IDirect3DDxgiInterfaceAccess is a COM interface for getting the DXGI interface+// from a WinRT IDirect3DSurface+MIDL_INTERFACE("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1")+IDirect3DDxgiInterfaceAccess : public IUnknown {+ virtual HRESULT STDMETHODCALLTYPE GetInterface(REFIID iid, void** p) = 0;+};++// Convert ID3D11Device → IDirect3DDevice (WinRT interop)+extern "C" {+ HRESULT __stdcall CreateDirect3D11DeviceFromDXGIDevice(+ IDXGIDevice* dxgiDevice,+ IInspectable** graphicsDevice);+}++WgcSession::WgcSession() {}++WgcSession::~WgcSession() {+ stopCapture();+}++bool WgcSession::createD3DDevice() {+ D3D_FEATURE_LEVEL featureLevels[] = {+ D3D_FEATURE_LEVEL_11_1,+ D3D_FEATURE_LEVEL_11_0,+ };++ HRESULT hr = D3D11CreateDevice(+ nullptr,+ D3D_DRIVER_TYPE_HARDWARE,+ nullptr,+ D3D11_CREATE_DEVICE_BGRA_SUPPORT,+ featureLevels,+ ARRAYSIZE(featureLevels),+ D3D11_SDK_VERSION,+ &d3dDevice_,+ nullptr,+ &d3dContext_);++ if (FAILED(hr)) {+ std::cerr << "ERROR: D3D11CreateDevice failed: 0x" << std::hex << hr << std::endl;+ return false;+ }++ return true;+}++winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice WgcSession::createWinRTDevice() {+ ComPtr<IDXGIDevice> dxgiDevice;+ HRESULT hr = d3dDevice_.As(&dxgiDevice);+ if (FAILED(hr)) return nullptr;++ winrt::com_ptr<IInspectable> inspectable;+ hr = CreateDirect3D11DeviceFromDXGIDevice(dxgiDevice.Get(), inspectable.put());+ if (FAILED(hr)) return nullptr;++ return inspectable.as<winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice>();+}++winrt::Windows::Graphics::Capture::GraphicsCaptureItem WgcSession::createCaptureItemForMonitor(HMONITOR monitor) {+ auto factory = winrt::get_activation_factory<+ winrt::Windows::Graphics::Capture::GraphicsCaptureItem>();++ auto interop = factory.as<IGraphicsCaptureItemInterop>();++ winrt::Windows::Graphics::Capture::GraphicsCaptureItem item{nullptr};+ HRESULT hr = interop->CreateForMonitor(+ monitor,+ winrt::guid_of<ABI::Windows::Graphics::Capture::IGraphicsCaptureItem>(),+ winrt::put_abi(item));++ if (FAILED(hr)) {+ std::cerr << "ERROR: CreateForMonitor failed: 0x" << std::hex << hr << std::endl;+ return nullptr;+ }++ return item;+}++bool WgcSession::initialize(HMONITOR monitor, int fps) {+ fps_ = fps;+ frameIntervalHns_ = 10000000LL / fps_;++ if (!createD3DDevice()) return false;++ winrtDevice_ = createWinRTDevice();+ if (!winrtDevice_) {+ std::cerr << "ERROR: Failed to create WinRT D3D device" << std::endl;+ return false;+ }++ captureItem_ = createCaptureItemForMonitor(monitor);+ if (!captureItem_) return false;++ auto size = captureItem_.Size();+ captureWidth_ = size.Width;+ captureHeight_ = size.Height;++ framePool_ = winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool::CreateFreeThreaded(+ winrtDevice_,+ winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized,+ 2,+ size);++ session_ = framePool_.CreateCaptureSession(captureItem_);++ session_.IsCursorCaptureEnabled(false);+ session_.IsBorderRequired(false);++ return true;+}++void WgcSession::setFrameCallback(FrameCallback callback) {+ frameCallback_ = std::move(callback);+}++bool WgcSession::startCapture() {+ if (!session_ || !framePool_) return false;++ capturing_ = true;+ lastFrameTimeHns_ = 0;++ frameArrivedRevoker_ = framePool_.FrameArrived(+ winrt::auto_revoke,+ [this](auto const& sender, auto const& args) {+ onFrameArrived(sender, args);+ });++ session_.StartCapture();+ return true;+}++void WgcSession::stopCapture() {+ capturing_ = false;++ frameArrivedRevoker_.revoke();++ if (session_) {+ session_.Close();+ session_ = nullptr;+ }+ if (framePool_) {+ framePool_.Close();+ framePool_ = nullptr;+ }+}++void WgcSession::onFrameArrived(+ winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool const& sender,+ winrt::Windows::Foundation::IInspectable const&) {++ if (!capturing_) return;++ auto frame = sender.TryGetNextFrame();+ if (!frame) return;++ auto timestamp = frame.SystemRelativeTime();+ int64_t frameTimeHns = std::chrono::duration_cast<std::chrono::duration<int64_t, std::ratio<1, 10000000>>>(timestamp).count();++ // Frame rate limiting: skip frames that arrive too soon+ if (lastFrameTimeHns_ > 0 && (frameTimeHns - lastFrameTimeHns_) < (frameIntervalHns_ * 7 / 10)) {+ frame.Close();+ return;+ }+ lastFrameTimeHns_ = frameTimeHns;++ auto surface = frame.Surface();++ // Get the underlying D3D texture from the WinRT surface via COM interop+ winrt::com_ptr<IDirect3DDxgiInterfaceAccess> access;+ try {+ access = surface.as<IDirect3DDxgiInterfaceAccess>();+ } catch (...) {+ frame.Close();+ return;+ }+ ComPtr<ID3D11Texture2D> texture;+ HRESULT hr = access->GetInterface(IID_PPV_ARGS(&texture));++ if (SUCCEEDED(hr) && texture && frameCallback_) {+ frameCallback_(texture.Get(), frameTimeHns);+ }++ frame.Close();+}diff --git a/electron/native/wgc-capture/src/wgc_session.h b/electron/native/wgc-capture/src/wgc_session.hnew file mode 100644index 00000000..094d95d3--- /dev/null+++ b/electron/native/wgc-capture/src/wgc_session.h@@ -0,0 +1,59 @@+#pragma once++#include <windows.h>+#include <d3d11.h>+#include <dxgi1_2.h>+#include <wrl/client.h>++#include <winrt/Windows.Foundation.h>+#include <winrt/Windows.Graphics.Capture.h>+#include <winrt/Windows.Graphics.DirectX.h>+#include <winrt/Windows.Graphics.DirectX.Direct3D11.h>++#include <functional>+#include <atomic>+#include <string>++using Microsoft::WRL::ComPtr;++class WgcSession {+public:+ using FrameCallback = std::function<void(ID3D11Texture2D*, int64_t timestampHns)>;++ WgcSession();+ ~WgcSession();++ bool initialize(HMONITOR monitor, int fps);+ void setFrameCallback(FrameCallback callback);+ bool startCapture();+ void stopCapture();++ int captureWidth() const { return captureWidth_; }+ int captureHeight() const { return captureHeight_; }+ ID3D11Device* device() const { return d3dDevice_.Get(); }+ ID3D11DeviceContext* context() const { return d3dContext_.Get(); }++private:+ ComPtr<ID3D11Device> d3dDevice_;+ ComPtr<ID3D11DeviceContext> d3dContext_;+ winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice winrtDevice_{nullptr};+ winrt::Windows::Graphics::Capture::GraphicsCaptureItem captureItem_{nullptr};+ winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool framePool_{nullptr};+ winrt::Windows::Graphics::Capture::GraphicsCaptureSession session_{nullptr};+ winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool::FrameArrived_revoker frameArrivedRevoker_;++ FrameCallback frameCallback_;+ std::atomic<bool> capturing_{false};+ int fps_ = 60;+ int captureWidth_ = 0;+ int captureHeight_ = 0;+ int64_t frameIntervalHns_ = 0;+ int64_t lastFrameTimeHns_ = 0;++ bool createD3DDevice();+ winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice createWinRTDevice();+ winrt::Windows::Graphics::Capture::GraphicsCaptureItem createCaptureItemForMonitor(HMONITOR monitor);+ void onFrameArrived(+ winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool const& sender,+ winrt::Windows::Foundation::IInspectable const& args);+};diff --git a/electron/preload.ts b/electron/preload.tsindex fa84e195..e8729f3f 100644--- a/electron/preload.ts+++ b/electron/preload.ts@@ -177,6 +177,8 @@ contextBridge.exposeInMainWorld('electronAPI', {ipcRenderer.on('request-save-before-close', listener)return () => ipcRenderer.removeListener('request-save-before-close', listener)},+ isWgcAvailable: () => ipcRenderer.invoke('is-wgc-available'),+ storeWgcAudio: (audioData: ArrayBuffer, type: 'system' | 'mic') => ipcRenderer.invoke('store-wgc-audio', audioData, type),// Cursor visibility control for cursor-free browser capture fallbackhideOsCursor: () => ipcRenderer.invoke('hide-cursor'),})diff --git a/package.json b/package.jsonindex e38f3062..247a89e6 100644--- a/package.json+++ b/package.json@@ -24,8 +24,9 @@"preview": "vite preview","rebuild:native": "electron-rebuild --force --only uiohook-napi","build:native-helpers": "node scripts/build-native-helpers.mjs",+ "build:wgc-capture": "node scripts/build-wgc-capture.mjs","build:mac": "npm run build:native-helpers && tsc && vite build && electron-builder --mac",- "build:win": "tsc && vite build && electron-builder --win",+ "build:win": "npm run build:wgc-capture && tsc && vite build && electron-builder --win","build:linux": "tsc && vite build && electron-builder --linux","i18n:check": "node scripts/i18n-check.mjs","test": "vitest --run",diff --git a/scripts/build-wgc-capture.mjs b/scripts/build-wgc-capture.mjsnew file mode 100644index 00000000..1c200506--- /dev/null+++ b/scripts/build-wgc-capture.mjs@@ -0,0 +1,90 @@+import { execSync } from 'node:child_process';+import { mkdirSync, existsSync } from 'node:fs';+import path from 'node:path';++const projectRoot = process.cwd();+const sourceDir = path.join(projectRoot, 'electron', 'native', 'wgc-capture');+const buildDir = path.join(sourceDir, 'build');++if (process.platform !== 'win32') {+ console.log('[build-wgc-capture] Skipping: host platform is not Windows.');+ process.exit(0);+}++if (!existsSync(path.join(sourceDir, 'CMakeLists.txt'))) {+ console.error('[build-wgc-capture] CMakeLists.txt not found at', sourceDir);+ process.exit(1);+}++function findCmake() {+ // Check PATH first+ try {+ execSync('cmake --version', { stdio: 'pipe' });+ return 'cmake';+ } catch {+ // not on PATH+ }++ // VS 2022 bundled CMake+ const vsEditions = ['Community', 'Professional', 'Enterprise', 'BuildTools'];+ for (const edition of vsEditions) {+ const cmakePath = path.join(+ 'C:', 'Program Files', 'Microsoft Visual Studio', '2022', edition,+ 'Common7', 'IDE', 'CommonExtensions', 'Microsoft', 'CMake', 'CMake', 'bin', 'cmake.exe'+ );+ if (existsSync(cmakePath)) {+ return `"${cmakePath}"`;+ }+ }++ return null;+}++const cmake = findCmake();+if (!cmake) {+ console.error('[build-wgc-capture] CMake not found. Install Visual Studio with C++ CMake tools or standalone CMake.');+ process.exit(1);+}++mkdirSync(buildDir, { recursive: true });++console.log('[build-wgc-capture] Configuring CMake...');+try {+ execSync(`${cmake} .. -G "Visual Studio 17 2022" -A x64`, {+ cwd: buildDir,+ stdio: 'inherit',+ timeout: 120000,+ });+} catch {+ console.log('[build-wgc-capture] VS 2022 generator not found, trying VS 2019...');+ try {+ execSync(`${cmake} .. -G "Visual Studio 16 2019" -A x64`, {+ cwd: buildDir,+ stdio: 'inherit',+ timeout: 120000,+ });+ } catch (innerError) {+ console.error('[build-wgc-capture] CMake configure failed:', innerError.message);+ process.exit(1);+ }+}++console.log('[build-wgc-capture] Building...');+try {+ execSync(`${cmake} --build . --config Release`, {+ cwd: buildDir,+ stdio: 'inherit',+ timeout: 300000,+ });+} catch (error) {+ console.error('[build-wgc-capture] Build failed:', error.message);+ process.exit(1);+}++const exePath = path.join(buildDir, 'Release', 'wgc-capture.exe');+if (existsSync(exePath)) {+ console.log(`[build-wgc-capture] Built successfully: ${exePath}`);+} else {+ console.error('[build-wgc-capture] Expected exe not found at', exePath);+ process.exit(1);+}diff --git a/src/hooks/useScreenRecorder.ts b/src/hooks/useScreenRecorder.tsindex 3269297c..7abc9561 100644--- a/src/hooks/useScreenRecorder.ts+++ b/src/hooks/useScreenRecorder.ts@@ -54,6 +54,8 @@ export function useScreenRecorder(): UseScreenRecorderReturn {const chunks = useRef<Blob[]>([]);const startTime = useRef<number>(0);const nativeScreenRecording = useRef(false);+ const wgcAudioRecorders = useRef<MediaRecorder[]>([]);+ const wgcAudioChunks = useRef<Map<string, Blob[]>>(new Map());const startInFlight = useRef(false);const hasPromptedForReselect = useRef(false);@@ -126,6 +128,95 @@ export function useScreenRecorder(): UseScreenRecorderReturn {return Math.round(BITRATE_BASE * highFrameRateBoost);};+ const stopWgcAudioCapture = useCallback(async () => {+ for (const recorder of wgcAudioRecorders.current) {+ if (recorder.state === "recording") {+ recorder.stop();+ }+ }++ // Wait briefly for onstop callbacks to fire+ await new Promise((resolve) => setTimeout(resolve, 200));++ for (const [type, chunks] of wgcAudioChunks.current.entries()) {+ if (chunks.length > 0) {+ const blob = new Blob(chunks, { type: "audio/webm" });+ const buffer = await blob.arrayBuffer();+ try {+ await window.electronAPI.storeWgcAudio(buffer, type as "system" | "mic");+ } catch (error) {+ console.warn(`Failed to store WGC ${type} audio:`, error);+ }+ }+ }++ wgcAudioRecorders.current = [];+ wgcAudioChunks.current = new Map();+ }, []);++ const startWgcAudioCapture = async (+ source: { id?: string; display_id?: string },+ captureSystemAudio: boolean,+ captureMicrophone: boolean,+ micDeviceId?: string,+ ) => {+ wgcAudioRecorders.current = [];+ wgcAudioChunks.current = new Map();++ if (captureSystemAudio) {+ try {+ const systemAudioStream = await (navigator.mediaDevices as any).getUserMedia({+ audio: {+ mandatory: {+ chromeMediaSource: CHROME_MEDIA_SOURCE,+ chromeMediaSourceId: source.id,+ },+ },+ video: false,+ });++ const systemChunks: Blob[] = [];+ wgcAudioChunks.current.set("system", systemChunks);+ const recorder = new MediaRecorder(systemAudioStream, {+ mimeType: "audio/webm",+ audioBitsPerSecond: AUDIO_BITRATE_SYSTEM,+ });+ recorder.ondataavailable = (e) => {+ if (e.data.size > 0) systemChunks.push(e.data);+ };+ recorder.start(RECORDER_TIMESLICE_MS);+ wgcAudioRecorders.current.push(recorder);+ } catch (error) {+ console.warn("WGC: System audio capture failed:", error);+ }+ }++ if (captureMicrophone) {+ try {+ const micStream = await navigator.mediaDevices.getUserMedia({+ audio: micDeviceId+ ? { deviceId: { exact: micDeviceId }, echoCancellation: true, noiseSuppression: true }+ : { echoCancellation: true, noiseSuppression: true },+ video: false,+ });++ const micChunks: Blob[] = [];+ wgcAudioChunks.current.set("mic", micChunks);+ const recorder = new MediaRecorder(micStream, {+ mimeType: "audio/webm",+ audioBitsPerSecond: AUDIO_BITRATE_VOICE,+ });+ recorder.ondataavailable = (e) => {+ if (e.data.size > 0) micChunks.push(e.data);+ };+ recorder.start(RECORDER_TIMESLICE_MS);+ wgcAudioRecorders.current.push(recorder);+ } catch (error) {+ console.warn("WGC: Microphone capture failed:", error);+ }+ }+ };+const cleanupCapturedMedia = useCallback(() => {if (stream.current) {stream.current.getTracks().forEach((track) => track.stop());@@ -154,6 +245,11 @@ export function useScreenRecorder(): UseScreenRecorderReturn {setRecording(false);void (async () => {+ // Stop WGC audio recorders first so audio data is stored before stop+ if (wgcAudioRecorders.current.length > 0) {+ await stopWgcAudioCapture();+ }+const result = await window.electronAPI.stopNativeScreenRecording();window.electronAPI?.setRecordingState(false);@@ -256,23 +352,49 @@ export function useScreenRecorder(): UseScreenRecorderReturn {(selectedSource.id?.startsWith("screen:") || selectedSource.id?.startsWith("window:")) &&typeof window.electronAPI.startNativeScreenRecording === "function";- if (useNativeMacScreenCapture) {+ let useWgcCapture = false;+ if (+ platform === "win32" &&+ selectedSource.id?.startsWith("screen:") &&+ typeof window.electronAPI.isWgcAvailable === "function"+ ) {+ try {+ const wgcResult = await window.electronAPI.isWgcAvailable();+ useWgcCapture = wgcResult.available;+ } catch {+ useWgcCapture = false;+ }+ }++ if (useNativeMacScreenCapture || useWgcCapture) {const nativeResult = await window.electronAPI.startNativeScreenRecording(selectedSource, {capturesSystemAudio: systemAudioEnabled,capturesMicrophone: microphoneEnabled,microphoneDeviceId,});if (!nativeResult.success) {- throw new Error(- nativeResult.error ?? nativeResult.message ?? "Failed to start native screen recording",- );+ if (useWgcCapture) {+ console.warn("WGC capture failed, falling back to browser capture:", nativeResult.error ?? nativeResult.message);+ } else {+ throw new Error(+ nativeResult.error ?? nativeResult.message ?? "Failed to start native screen recording",+ );+ }}- nativeScreenRecording.current = true;- startTime.current = Date.now();- setRecording(true);- window.electronAPI?.setRecordingState(true);- return;+ if (nativeResult.success) {+ nativeScreenRecording.current = true;+ startTime.current = Date.now();+ setRecording(true);+ window.electronAPI?.setRecordingState(true);++ // WGC: start audio-only MediaRecorders in parallel+ if (useWgcCapture && (systemAudioEnabled || microphoneEnabled)) {+ void startWgcAudioCapture(selectedSource, systemAudioEnabled, microphoneEnabled, microphoneDeviceId);+ }++ return;+ }}const wantsAudioCapture = microphoneEnabled || systemAudioEnabled;