Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
feat(recording): capture the webcam at its real resolution and frame rate
Christian Schmitteld93a2b1afa1c
diff --git a/electron/app-settings.test.ts b/electron/app-settings.test.tsindex c6c9e74f3..f3781734f 100644--- a/electron/app-settings.test.ts+++ b/electron/app-settings.test.ts@@ -129,4 +129,40 @@ describe("app settings store", () => {store.dismissStarPrompt();expect(store.getSnapshot().recording).toMatchObject({ micEnabled: true, micDeviceId: "mic" });});++ it("stores a camera quality and rejects one it cannot capture at", () => {+ const dir = temp();+ const store = new AppSettingsStore(dir);++ expect(store.setRecordingPreferences({ camQuality: "1080p" }).recording.camQuality).toBe(+ "1080p",+ );+ expect(() => store.setRecordingPreferences({ camQuality: "4320p" as never })).toThrow(+ TypeError,+ );+ expect(store.getSnapshot().recording.camQuality).toBe("1080p");+ });++ it("leaves the camera quality alone when a patch does not mention it", () => {+ // Every other window writes narrow patches; a camera toggle from the HUD+ // must not quietly reset the resolution the user picked.+ const dir = temp();+ const store = new AppSettingsStore(dir);+ store.setRecordingPreferences({ camQuality: "1440p" });++ store.setRecordingPreferences({ camEnabled: true });++ expect(store.getSnapshot().recording.camQuality).toBe("1440p");+ });++ it("reads a settings file written before the camera had a quality", () => {+ const dir = temp();+ writeFileSync(+ path.join(dir, "recording-settings.json"),+ JSON.stringify({ micEnabled: true }),+ "utf8",+ );++ expect(new AppSettingsStore(dir).getSnapshot().recording.camQuality).toBe("2160p");+ });});diff --git a/electron/app-settings.ts b/electron/app-settings.tsindex 2cc1cee25..bef025bf3 100644--- a/electron/app-settings.ts+++ b/electron/app-settings.ts@@ -1,5 +1,11 @@import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";import path from "node:path";+import {+ DEFAULT_WEBCAM_QUALITY,+ WEBCAM_QUALITY_IDS,+ type WebcamQualityId,+ webcamQualityFrom,+} from "../src/hooks/webcamCaptureTarget";import type { CursorCaptureMode } from "../src/lib/recordingSession";export interface RecordingPreferences {@@ -9,6 +15,8 @@ export interface RecordingPreferences {camEnabled: boolean;camDeviceId: string | null;camDeviceName: string | null;+ /** Capture resolution for the camera. See WEBCAM_QUALITY_PRESETS. */+ camQuality: WebcamQualityId;systemAudioEnabled: boolean;cursorCaptureMode: CursorCaptureMode;/** Display captures on macOS and Windows. Opt-in: on Windows the icons also leave the real desktop while recording. */@@ -30,6 +38,7 @@ export const DEFAULT_RECORDING_PREFERENCES: RecordingPreferences = {camEnabled: false,camDeviceId: null,camDeviceName: null,+ camQuality: DEFAULT_WEBCAM_QUALITY,systemAudioEnabled: false,cursorCaptureMode: "editable-overlay",hideDesktopIcons: false,@@ -100,6 +109,9 @@ function parseRecording(raw: RawSettings): RecordingPreferences {camEnabled: bool(raw.camEnabled, DEFAULT_RECORDING_PREFERENCES.camEnabled),camDeviceId: nullableString(raw.camDeviceId, DEFAULT_RECORDING_PREFERENCES.camDeviceId),camDeviceName: nullableString(raw.camDeviceName, DEFAULT_RECORDING_PREFERENCES.camDeviceName),+ // Unset in every settings file written before the camera had a quality+ // setting, and `webcamQualityFrom` answers those with the default.+ camQuality: webcamQualityFrom(raw.camQuality),systemAudioEnabled: bool(raw.systemAudioEnabled,DEFAULT_RECORDING_PREFERENCES.systemAudioEnabled,@@ -167,6 +179,12 @@ function validateRecordingPatch(patch: Partial<RecordingPreferences>): void {if (key === "cursorCaptureMode" && value !== "system" && value !== "editable-overlay") {throw new TypeError("cursorCaptureMode is invalid");}+ // Rejected here rather than coerced on read, so a bad write is a visible+ // error at its source instead of a resolution that silently is not the+ // one the caller asked for.+ if (key === "camQuality" && !WEBCAM_QUALITY_IDS.includes(value as WebcamQualityId)) {+ throw new TypeError("camQuality is invalid");+ }}}diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.tsindex 6e6bac45f..c3bd11c01 100644--- a/electron/ipc/handlers.ts+++ b/electron/ipc/handlers.ts@@ -17,6 +17,7 @@ import {shell,systemPreferences,} from "electron";+import { DEFAULT_WEBCAM_QUALITY, type WebcamQualityId } from "../../src/hooks/webcamCaptureTarget";import {type AxcutDocument,isAxcutDocumentFile,@@ -649,6 +650,8 @@ export interface RecordingPrefs {camDeviceId: string | null;/** Camera label paired with the preferred id for restart-safe resolution. */camDeviceName: string | null;+ /** Capture resolution for the camera. See WEBCAM_QUALITY_PRESETS. */+ camQuality: WebcamQualityId;systemAudioEnabled: boolean;cursorCaptureMode: CursorCaptureMode;hideDesktopIcons: boolean;@@ -662,6 +665,7 @@ const defaultRecordingPrefs: RecordingPrefs = {camEnabled: false,camDeviceId: null,camDeviceName: null,+ camQuality: DEFAULT_WEBCAM_QUALITY,systemAudioEnabled: false,cursorCaptureMode: "editable-overlay",hideDesktopIcons: false,diff --git a/electron/ipc/recordingPrefs.test.ts b/electron/ipc/recordingPrefs.test.tsindex fe8cdce9d..2c3317af9 100644--- a/electron/ipc/recordingPrefs.test.ts+++ b/electron/ipc/recordingPrefs.test.ts@@ -19,6 +19,7 @@ const defaults: RecordingPrefs = {camEnabled: false,camDeviceId: null,camDeviceName: null,+ camQuality: "2160p",systemAudioEnabled: false,cursorCaptureMode: "editable-overlay",hideDesktopIcons: false,diff --git a/electron/native/wgc-capture/CMakeLists.txt b/electron/native/wgc-capture/CMakeLists.txtindex c0921486f..efa82295d 100644--- a/electron/native/wgc-capture/CMakeLists.txt+++ b/electron/native/wgc-capture/CMakeLists.txt@@ -55,6 +55,8 @@ add_executable(wgc-capturesrc/wasapi_render_keepalive.cppsrc/wasapi_render_keepalive.hsrc/webcam_capture.cpp+ src/webcam_format.cpp+ src/webcam_format.hsrc/webcam_capture.hsrc/wgc_session.cppsrc/wgc_session.h@@ -117,3 +119,17 @@ target_link_libraries(audio_sample_utils_test PRIVATEmfuuidole32)++add_executable(webcam_format_test+ src/webcam_format.cpp+ src/webcam_format.h+ src/webcam_format_test.cpp+)++target_compile_definitions(webcam_format_test PRIVATE+ NOMINMAX+ WIN32_LEAN_AND_MEAN+ _WIN32_WINNT=0x0A00+)++target_compile_options(webcam_format_test PRIVATE /EHsc /W4 /utf-8)diff --git a/electron/native/wgc-capture/src/dshow_webcam_capture.cpp b/electron/native/wgc-capture/src/dshow_webcam_capture.cppindex f39e4b065..d421f9cf3 100644--- a/electron/native/wgc-capture/src/dshow_webcam_capture.cpp+++ b/electron/native/wgc-capture/src/dshow_webcam_capture.cpp@@ -1,5 +1,7 @@#include "dshow_webcam_capture.h"+#include "webcam_format.h"+#include <initguid.h>#include <dshow.h>#include <wrl/client.h>@@ -29,6 +31,19 @@ public:virtual HRESULT STDMETHODCALLTYPE SetCallback(IUnknown* callback, long whichMethodToCallback) = 0;};+/**+ * Is this subtype something the graph must DECODE before this class can unpack it?+ *+ * Listed positively -- an unknown subtype counts as compressed -- because+ * guessing wrong this way only costs resolution, while guessing wrong the other+ * way costs the camera track entirely.+ */+bool isCompressedDshowSubtype(const GUID& subtype) {+ return !(subtype == MEDIASUBTYPE_YUY2 || subtype == MEDIASUBTYPE_NV12 ||+ subtype == MEDIASUBTYPE_RGB32 || subtype == MEDIASUBTYPE_RGB24 ||+ subtype == MEDIASUBTYPE_UYVY || subtype == MEDIASUBTYPE_YV12);+}+bool succeeded(HRESULT hr, const char* label) {if (SUCCEEDED(hr)) {return true;@@ -112,7 +127,93 @@ DirectShowWebcamCapture::~DirectShowWebcamCapture() {delete impl_;}-bool DirectShowWebcamCapture::buildGraph(const CLSID& sourceClsid, const GUID* preferredSubtype) {+void DirectShowWebcamCapture::applyPreferredFormat(int requestedWidth, int requestedHeight, int requestedFps) {+ Microsoft::WRL::ComPtr<IAMStreamConfig> streamConfig;+ if (FAILED(impl_->captureGraph->FindInterface(+ &PIN_CATEGORY_CAPTURE,+ &MEDIATYPE_Video,+ impl_->captureFilter.Get(),+ IID_PPV_ARGS(&streamConfig)))) {+ // Virtual cameras commonly expose a single fixed format and no+ // IAMStreamConfig at all. Nothing to choose from; let the graph connect.+ return;+ }++ int capCount = 0;+ int capSize = 0;+ if (FAILED(streamConfig->GetNumberOfCapabilities(&capCount, &capSize)) ||+ capSize != sizeof(VIDEO_STREAM_CONFIG_CAPS)) {+ return;+ }++ std::vector<WebcamFormat> formats;+ formats.reserve(static_cast<size_t>(std::max(0, capCount)));+ for (int index = 0; index < capCount; ++index) {+ VIDEO_STREAM_CONFIG_CAPS caps{};+ AM_MEDIA_TYPE* mediaType = nullptr;+ if (FAILED(streamConfig->GetStreamCaps(index, &mediaType, reinterpret_cast<BYTE*>(&caps))) || !mediaType) {+ continue;+ }+ if (mediaType->formattype == FORMAT_VideoInfo && mediaType->pbFormat) {+ const auto* videoInfo = reinterpret_cast<VIDEOINFOHEADER*>(mediaType->pbFormat);+ // AvgTimePerFrame is in 100ns units; 333333 is 30 fps.+ const int fps = videoInfo->AvgTimePerFrame > 0+ ? static_cast<int>((10'000'000LL + videoInfo->AvgTimePerFrame / 2) / videoInfo->AvgTimePerFrame)+ : 0;+ formats.push_back(WebcamFormat{+ std::abs(videoInfo->bmiHeader.biWidth),+ std::abs(videoInfo->bmiHeader.biHeight),+ fps,+ isCompressedDshowSubtype(mediaType->subtype)});+ }+ freeMediaType(*mediaType);+ CoTaskMemFree(mediaType);+ }++ const WebcamFormat chosen = chooseWebcamFormat(+ formats,+ requestedWidth > 0 ? requestedWidth : 1920,+ requestedHeight > 0 ? requestedHeight : 1080,+ std::max(1, requestedFps));++ // Second pass: set the first capability that matches the choice. GetStreamCaps+ // hands back the media type we must give to SetFormat, so it has to be+ // re-read rather than cached across the loop above.+ for (int index = 0; index < capCount; ++index) {+ VIDEO_STREAM_CONFIG_CAPS caps{};+ AM_MEDIA_TYPE* mediaType = nullptr;+ if (FAILED(streamConfig->GetStreamCaps(index, &mediaType, reinterpret_cast<BYTE*>(&caps))) || !mediaType) {+ continue;+ }+ bool matched = false;+ if (mediaType->formattype == FORMAT_VideoInfo && mediaType->pbFormat) {+ auto* videoInfo = reinterpret_cast<VIDEOINFOHEADER*>(mediaType->pbFormat);+ if (std::abs(videoInfo->bmiHeader.biWidth) == chosen.width &&+ std::abs(videoInfo->bmiHeader.biHeight) == chosen.height &&+ isCompressedDshowSubtype(mediaType->subtype) == chosen.compressed) {+ if (chosen.fps > 0) {+ videoInfo->AvgTimePerFrame = 10'000'000LL / chosen.fps;+ }+ matched = SUCCEEDED(streamConfig->SetFormat(mediaType));+ if (matched) {+ std::cerr << "INFO: DirectShow webcam format " << chosen.width << "x" << chosen.height+ << "@" << chosen.fps << std::endl;+ }+ }+ }+ freeMediaType(*mediaType);+ CoTaskMemFree(mediaType);+ if (matched) {+ return;+ }+ }+}++bool DirectShowWebcamCapture::buildGraph(+ const CLSID& sourceClsid,+ const GUID* preferredSubtype,+ int preferredWidth,+ int preferredHeight) {// Every attempt starts from empty filters. A RenderStream that fails can// leave pins connected behind it, and retrying on top of that half-built// graph is how you get a second failure that says nothing about the format.@@ -175,6 +276,8 @@ bool DirectShowWebcamCapture::buildGraph(const CLSID& sourceClsid, const GUID* preturn false;}+ applyPreferredFormat(preferredWidth, preferredHeight, fps_);+return succeeded(impl_->captureGraph->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Video,@@ -231,14 +334,14 @@ bool DirectShowWebcamCapture::initialize(// it connects with a subtype this file cannot read// (getopenscreen/openscreen#387). Naming a concrete subtype on the retry is// what makes DirectShow insert a colour converter for it.- if (!buildGraph(selectedClsid, nullptr)) {+ if (!buildGraph(selectedClsid, nullptr, requestedWidth, requestedHeight)) {return false;}if (!resolveConnectedFormat(requestedWidth, requestedHeight, false)) {std::cerr << "WARNING: DirectShow webcam speaks a format this build cannot unpack; ""asking for RGB32 so the graph converts it"<< std::endl;- if (!buildGraph(selectedClsid, &MEDIASUBTYPE_RGB32)) {+ if (!buildGraph(selectedClsid, &MEDIASUBTYPE_RGB32, requestedWidth, requestedHeight)) {return false;}if (!resolveConnectedFormat(requestedWidth, requestedHeight, true)) {diff --git a/electron/native/wgc-capture/src/dshow_webcam_capture.h b/electron/native/wgc-capture/src/dshow_webcam_capture.hindex cf510e2df..c0ba3503d 100644--- a/electron/native/wgc-capture/src/dshow_webcam_capture.h+++ b/electron/native/wgc-capture/src/dshow_webcam_capture.h@@ -59,7 +59,21 @@ private:* without leaving the graph half-built, so the caller can retry with a* different constraint.*/- bool buildGraph(const CLSID& sourceClsid, const GUID* preferredSubtype);+ bool buildGraph(+ const CLSID& sourceClsid,+ const GUID* preferredSubtype,+ int preferredWidth,+ int preferredHeight);+ /**+ * Pins the capture pin to the best format the device offers, before the+ * graph is rendered.+ *+ * Skipped, RenderStream's intelligent connect takes the pin's default+ * format, which on a UVC camera is the first one it enumerates -- 640x480+ * on hardware that can do far better. Best-effort: a device without+ * IAMStreamConfig, or one that rejects the format, still gets a graph.+ */+ void applyPreferredFormat(int requestedWidth, int requestedHeight, int requestedFps);/*** Reads back what the graph actually negotiated and records how to unpack it.*diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cppindex c86524d6d..08fe11aa0 100644--- a/electron/native/wgc-capture/src/main.cpp+++ b/electron/native/wgc-capture/src/main.cpp@@ -393,6 +393,42 @@ void reportCaptureAdapters(ID3D11Device* device, HMONITOR targetMonitor) {}}+/**+ * The NV12 twin of `hasVisibleBgraContent`: luma is the Y plane, one byte per+ * pixel, so no colour conversion is needed to judge whether a frame has any+ * picture in it. The Y plane is the first two thirds of an NV12 buffer.+ */+bool hasVisibleNv12Content(const std::vector<BYTE>& frame) {+ if (frame.size() < 6) {+ return false;+ }++ const size_t lumaCount = frame.size() * 2 / 3;+ const size_t step = std::max<size_t>(1, lumaCount / 4096);+ uint64_t lumaTotal = 0;+ BYTE maxLuma = 0;+ size_t sampled = 0;+ for (size_t offset = 0; offset < lumaCount; offset += step) {+ const BYTE luma = frame[offset];+ lumaTotal += luma;+ maxLuma = std::max(maxLuma, luma);+ sampled += 1;+ }++ // The same thresholds the BGRA probe uses. NV12 from a camera is+ // studio-range, so a black frame sits at 16 rather than 0 -- which the+ // maxLuma > 24 test already tolerates.+ const uint64_t averageLuma = sampled > 0 ? lumaTotal / sampled : 0;+ return maxLuma > 24 || averageLuma > 4;+}++bool hasVisibleBgraContent(const std::vector<BYTE>& frame);++/** Dispatches to the probe matching the frame's layout. */+bool hasVisibleWebcamContent(const std::vector<BYTE>& frame, bool isNv12) {+ return isNv12 ? hasVisibleNv12Content(frame) : hasVisibleBgraContent(frame);+}+bool hasVisibleBgraContent(const std::vector<BYTE>& frame) {if (frame.size() < 4) {return false;@@ -777,7 +813,10 @@ int wmain(int argc, wchar_t* argv[]) {WebcamCapture webcamCapture;bool webcamActive = false;- bool writeSeparateWebcam = false;+ // Decided before initialize(), not after: it selects the capture pixel+ // format, and only a camera going to its own file can use NV12 -- an inline+ // picture-in-picture composite needs the frame as BGRA.+ bool writeSeparateWebcam = config.webcamEnabled && !config.webcamOutputPath.empty();if (config.webcamEnabled) {if (!webcamCapture.initialize(utf8ToWide(config.webcamDeviceId),@@ -785,7 +824,8 @@ int wmain(int argc, wchar_t* argv[]) {utf8ToWide(config.webcamDirectShowClsid),config.webcamWidth,config.webcamHeight,- config.webcamFps > 0 ? config.webcamFps : config.fps)) {+ config.webcamFps > 0 ? config.webcamFps : config.fps,+ writeSeparateWebcam)) {// Non-fatal: a screen+audio recording the user can still use is far// better than losing the whole recording because one camera device// didn't match. Report it so the renderer can inform the user (and,@@ -797,13 +837,14 @@ int wmain(int argc, wchar_t* argv[]) {"\"Failed to initialize native webcam capture\"}"<< std::endl;config.webcamEnabled = false;+ writeSeparateWebcam = false;} else {std::cout << "{\"event\":\"webcam-format\",\"schemaVersion\":2,\"width\":" << webcamCapture.width()<< ",\"height\":" << webcamCapture.height()<< ",\"fps\":" << webcamCapture.fps()<< ",\"deviceName\":\"" << jsonEscape(wideToUtf8(webcamCapture.selectedDeviceName()))<< "\"}" << std::endl;- writeSeparateWebcam = !config.webcamOutputPath.empty();+ // writeSeparateWebcam was decided above, before the pixel format.}}@@ -980,8 +1021,18 @@ int wmain(int argc, wchar_t* argv[]) {MFEncoderOptions webcamEncoderOptions = encoderOptions;webcamEncoderOptions.injectDefaultSinkWriterFailureOnce = false;webcamEncoderOptions.useDxgiInput = false;+ webcamEncoderOptions.cpuInputIsNv12 = webcamCapture.deliversNv12();+ // The two-step ladder this replaces topped out at 8 Mbit/s for anything+ // 720p or larger. That was sized for a camera nobody had configured+ // above 640x480; now that the capture runs at the camera's real+ // resolution, 8 Mbit/s starves a 1440p or 2160p frame badly enough to+ // undo the extra pixels. The tiers mirror the screen ladder above.const int webcamPixels = std::max(1, webcamCapture.width()) * std::max(1, webcamCapture.height());- const int webcamBitrate = webcamPixels >= 1280 * 720 ? 8'000'000 : 4'000'000;+ const int webcamBitrate = webcamPixels >= 3840 * 2160 ? 40'000'000+ : webcamPixels >= 2560 * 1440 ? 24'000'000+ : webcamPixels >= 1920 * 1080 ? 16'000'000+ : webcamPixels >= 1280 * 720 ? 8'000'000+ : 4'000'000;if (!webcamEncoder.initialize(utf8ToWide(config.webcamOutputPath),webcamCapture.width(),@@ -1175,7 +1226,7 @@ int wmain(int argc, wchar_t* argv[]) {WebcamFrameSnapshot candidateWebcamFrame;if (webcamCapture.copyLatestFrame(candidateWebcamFrame) &&candidateWebcamFrame.sequence != latestWebcamSequence &&- hasVisibleBgraContent(candidateWebcamFrame.data)) {+ hasVisibleWebcamContent(candidateWebcamFrame.data, webcamCapture.deliversNv12())) {latestWebcamFrame = std::move(candidateWebcamFrame.data);latestWebcamWidth = candidateWebcamFrame.width;latestWebcamHeight = candidateWebcamFrame.height;@@ -1230,7 +1281,15 @@ int wmain(int argc, wchar_t* argv[]) {// Capture the sample here, but submit it to the sink// writer OUTSIDE this block below (issue #115) so a// slow WriteSample can't hold up the next frame pull.- hasWebcamSample = webcamEncoder.captureBgraSample(webcamFrame, webcamTimestampHns, webcamSample);+ hasWebcamSample =+ webcamCapture.deliversNv12()+ ? webcamEncoder.captureNv12Sample(+ Nv12FrameView{+ webcamFrame.data, webcamFrame.width, webcamFrame.height},+ webcamTimestampHns,+ webcamSample)+ : webcamEncoder.captureBgraSample(+ webcamFrame, webcamTimestampHns, webcamSample);if (!hasWebcamSample) {encodeFailed = true;control.requestStop();@@ -1461,7 +1520,7 @@ int wmain(int argc, wchar_t* argv[]) {while (std::chrono::steady_clock::now() < webcamDeadline && !hasVisibleWebcamFrame) {WebcamFrameSnapshot candidateWebcamFrame;if (webcamCapture.copyLatestFrame(candidateWebcamFrame) &&- hasVisibleBgraContent(candidateWebcamFrame.data)) {+ hasVisibleWebcamContent(candidateWebcamFrame.data, webcamCapture.deliversNv12())) {latestWebcamFrame = std::move(candidateWebcamFrame.data);latestWebcamWidth = candidateWebcamFrame.width;latestWebcamHeight = candidateWebcamFrame.height;diff --git a/electron/native/wgc-capture/src/mf_encoder.cpp b/electron/native/wgc-capture/src/mf_encoder.cppindex b4dabcc54..786881e00 100644--- a/electron/native/wgc-capture/src/mf_encoder.cpp+++ b/electron/native/wgc-capture/src/mf_encoder.cpp@@ -690,6 +690,7 @@ bool MFEncoder::initialize(// attempt would eat the injection and the run would land on the plain CPU// encoder, never reaching the software encoder the knob is aimed at.useDxgiInput_ = options.useDxgiInput && !options.injectDefaultSinkWriterFailureOnce;+ cpuInputIsNv12_ = options.cpuInputIsNv12;videoEncoderSelection_ = kVideoEncoderSelectionDefault;videoEncoderRuntime_ = kVideoEncoderRuntimeUnknown;@@ -725,9 +726,26 @@ bool MFEncoder::initialize(// type the RGB32 path would have produced from scratch. Every attribute// one mode sets is deleted by the other; nothing carries over.auto configureVideoInputType = [&](bool dxgi) {+ // Three input shapes, not two: GPU NV12, system-memory NV12 (the+ // webcam, whose camera hands us NV12 already) and system-memory RGB32.+ const bool nv12 = dxgi || cpuInputIsNv12_;inputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);- inputType->SetGUID(MF_MT_SUBTYPE, dxgi ? MFVideoFormat_NV12 : MFVideoFormat_RGB32);+ inputType->SetGUID(MF_MT_SUBTYPE, nv12 ? MFVideoFormat_NV12 : MFVideoFormat_RGB32);inputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);+ if (!dxgi && cpuInputIsNv12_) {+ // NV12's declared stride is the Y plane's, which is one byte per+ // pixel -- not the four an RGB32 row needs.+ inputType->SetUINT32(MF_MT_DEFAULT_STRIDE, static_cast<UINT32>(width_));+ // A camera's NV12 is studio-range, and at these sizes BT.709.+ // Untagged, the encoder and the player each fall back to their own+ // default and the recording comes back with shifted colours.+ inputType->SetUINT32(MF_MT_VIDEO_NOMINAL_RANGE, MFNominalRange_16_235);+ inputType->SetUINT32(MF_MT_YUV_MATRIX, MFVideoTransferMatrix_BT709);+ setFrameSize(inputType.Get(), static_cast<UINT32>(width_), static_cast<UINT32>(height_));+ setFrameRate(inputType.Get(), static_cast<UINT32>(fps_));+ setPixelAspectRatio(inputType.Get());+ return;+ }if (dxgi) {inputType->DeleteItem(MF_MT_DEFAULT_STRIDE);// The video processor below converts full-range BGRA into@@ -750,7 +768,7 @@ bool MFEncoder::initialize(// Carried on the H.264 type as well so the MP4 sink writes the matching// colour tags instead of leaving players to guess from the frame size.auto configureOutputColorTags = [&](bool dxgi) {- if (dxgi) {+ if (dxgi || cpuInputIsNv12_) {outputType->SetUINT32(MF_MT_VIDEO_NOMINAL_RANGE, MFNominalRange_16_235);outputType->SetUINT32(MF_MT_YUV_MATRIX, MFVideoTransferMatrix_BT709);} else {@@ -1110,12 +1128,16 @@ bool MFEncoder::copyBgraFrameToBuffer(const BgraFrameView& frame, BYTE* destinat}if (frame.width == width_ && frame.height == height_) {- for (DWORD i = 0; i < requiredBytes; i += 4) {- destination[i] = frame.data[i];- destination[i + 1] = frame.data[i + 1];- destination[i + 2] = frame.data[i + 2];- destination[i + 3] = 255;- }+ // One memcpy, not a per-pixel loop forcing alpha to 255.+ //+ // The loop this replaces ran once per BYTE: at 3840x2160 that is 8.3+ // million iterations per frame, which measured out at ~12 fps of real+ // camera motion inside a file whose container claimed 30 -- the encoder+ // padded the gap with duplicates. The alpha it was writing is dead+ // weight anyway: this buffer feeds an H.264 encoder through+ // MFVideoFormat_RGB32, and RGB-to-YUV conversion ignores the alpha+ // channel entirely.+ std::memcpy(destination, frame.data, requiredBytes);return true;}@@ -1649,6 +1671,56 @@ bool MFEncoder::captureVideoSample(return true;}+bool MFEncoder::captureNv12Sample(+ const Nv12FrameView& frame,+ int64_t timestampHns,+ Microsoft::WRL::ComPtr<IMFSample>& outSample) {+ outSample.Reset();++ if (!frame.data || frame.width != width_ || frame.height != height_) {+ // No rescaler here on purpose: the webcam encoder is created with the+ // capture's own dimensions, so a mismatch means a bug upstream rather+ // than a frame worth stretching.+ std::cerr << "ERROR: NV12 webcam frame does not match the encoder's size" << std::endl;+ return false;+ }++ const int64_t sampleDuration = 10'000'000LL / fps_;+ const int64_t sampleTime = nextSampleTime(timestampHns, sampleDuration);+ const DWORD frameBytes = static_cast<DWORD>(width_ * height_ * 3 / 2);++ Microsoft::WRL::ComPtr<IMFMediaBuffer> buffer;+ if (!succeeded(MFCreateMemoryBuffer(frameBytes, &buffer), "MFCreateMemoryBuffer(webcam NV12)")) {+ return false;+ }++ BYTE* data = nullptr;+ DWORD maxLength = 0;+ DWORD currentLength = 0;+ if (!succeeded(buffer->Lock(&data, &maxLength, ¤tLength), "IMFMediaBuffer::Lock(webcam NV12)")) {+ return false;+ }+ if (maxLength < frameBytes) {+ buffer->Unlock();+ std::cerr << "ERROR: Media Foundation webcam NV12 buffer is too small" << std::endl;+ return false;+ }+ std::memcpy(data, frame.data, frameBytes);+ buffer->Unlock();+ buffer->SetCurrentLength(frameBytes);++ Microsoft::WRL::ComPtr<IMFSample> sample;+ if (!succeeded(MFCreateSample(&sample), "MFCreateSample(webcam NV12)")) {+ return false;+ }+ sample->AddBuffer(buffer.Get());+ sample->SetSampleTime(sampleTime);+ sample->SetSampleDuration(sampleDuration);++ outSample = sample;+ return true;+}+bool MFEncoder::captureBgraSample(const BgraFrameView& frame,int64_t timestampHns,diff --git a/electron/native/wgc-capture/src/mf_encoder.h b/electron/native/wgc-capture/src/mf_encoder.hindex 8d1d6ae6e..148693408 100644--- a/electron/native/wgc-capture/src/mf_encoder.h+++ b/electron/native/wgc-capture/src/mf_encoder.h@@ -18,6 +18,21 @@ struct BgraFrameView {int height = 0;};+/**+ * A planar NV12 frame: a width*height Y plane followed by an interleaved+ * width/2 * height/2 UV plane, so width*height*3/2 bytes in total.+ *+ * Used for the webcam, whose camera can hand Media Foundation NV12 directly.+ * Asking that same camera for RGB32 made the source reader decode and convert+ * every frame, which measured at 92ms per 4K frame -- a hard ceiling near 11+ * fps -- against 32ms for NV12.+ */+struct Nv12FrameView {+ const BYTE* data = nullptr;+ int width = 0;+ int height = 0;+};+struct AudioInputFormat {GUID subtype = MFAudioFormat_PCM;UINT32 sampleRate = 0;@@ -47,6 +62,14 @@ struct MFEncoderOptions {// driver that refuses shared keyed-mutex textures records exactly as it did// before the path existed. Ask usesDxgiInput() for what actually happened.bool useDxgiInput = false;+ /**+ * Feed this encoder NV12 from system memory instead of RGB32.+ *+ * Only meaningful when `useDxgiInput` is false. The webcam encoder sets it+ * when the camera itself delivers NV12; the screen encoder's CPU path+ * still produces BGRA and leaves it alone.+ */+ bool cpuInputIsNv12 = false;};constexpr const char* kVideoEncoderSelectionDefault = "default";@@ -122,6 +145,10 @@ public:ID3D11Texture2D* texture,int64_t timestampHns,Microsoft::WRL::ComPtr<IMFSample>& outSample);+ bool captureNv12Sample(+ const Nv12FrameView& frame,+ int64_t timestampHns,+ Microsoft::WRL::ComPtr<IMFSample>& outSample);bool captureBgraSample(const BgraFrameView& frame,int64_t timestampHns,@@ -237,6 +264,7 @@ private:int64_t lastTimestampHns_ = -1;bool finalized_ = false;bool useDxgiInput_ = false;+ bool cpuInputIsNv12_ = false;const char* videoEncoderSelection_ = kVideoEncoderSelectionDefault;const char* videoEncoderRuntime_ = kVideoEncoderRuntimeUnknown;const char* containerFormat_ = kContainerFormatMp4;diff --git a/electron/native/wgc-capture/src/webcam_capture.cpp b/electron/native/wgc-capture/src/webcam_capture.cppindex 6377a799b..0a3666482 100644--- a/electron/native/wgc-capture/src/webcam_capture.cpp+++ b/electron/native/wgc-capture/src/webcam_capture.cpp@@ -1,5 +1,7 @@#include "webcam_capture.h"+#include "webcam_format.h"+#include <mfapi.h>#include <mferror.h>#include <propvarutil.h>@@ -153,7 +155,8 @@ bool WebcamCapture::initialize(const std::wstring& directShowClsid,int requestedWidth,int requestedHeight,- int requestedFps) {+ int requestedFps,+ bool preferNv12) {fps_ = std::clamp(requestedFps > 0 ? requestedFps : 30, 1, 60);usingDirectShow_ = false;selectedMatchScore_ = 0;@@ -196,7 +199,7 @@ bool WebcamCapture::initialize(return false;}- return configureReader(requestedWidth, requestedHeight, fps_);+ return configureReader(requestedWidth, requestedHeight, fps_, preferNv12);}bool WebcamCapture::selectDevice(const std::wstring& deviceId, const std::wstring& deviceName) {@@ -252,7 +255,133 @@ bool WebcamCapture::selectDevice(const std::wstring& deviceId, const std::wstrinreturn succeeded(hr, "ActivateObject(webcam)");}-bool WebcamCapture::configureReader(int requestedWidth, int requestedHeight, int requestedFps) {+namespace {++/**+ * Is this subtype something the source reader must DECODE before it can convert?+ *+ * Listed positively -- an unknown subtype counts as compressed -- because the+ * cost of guessing wrong the other way is a camera that silently records+ * nothing, while guessing wrong this way only costs resolution.+ */+bool isCompressedVideoSubtype(const GUID& subtype) {+ static const GUID* const kUncompressed[] = {+ &MFVideoFormat_NV12,+ &MFVideoFormat_YUY2,+ &MFVideoFormat_RGB32,+ &MFVideoFormat_RGB24,+ &MFVideoFormat_ARGB32,+ &MFVideoFormat_UYVY,+ &MFVideoFormat_YV12,+ &MFVideoFormat_I420,+ &MFVideoFormat_IYUV,+ };+ for (const GUID* candidate : kUncompressed) {+ if (subtype == *candidate) {+ return false;+ }+ }+ return true;+}++/**+ * Every video format the camera advertises, read off the source reader.+ *+ * MF_MT_FRAME_RATE is a ratio; a 30000/1001 entry is NTSC 29.97 and rounds to+ * 30, which is what we want to compare against the requested rate. A type+ * missing either attribute is skipped rather than guessed at -- it cannot be+ * requested by size anyway.+ */+std::vector<WebcamFormat> readNativeFormats(IMFSourceReader* reader) {+ std::vector<WebcamFormat> formats;+ for (DWORD index = 0;; ++index) {+ Microsoft::WRL::ComPtr<IMFMediaType> nativeType;+ const HRESULT hr =+ reader->GetNativeMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, index, &nativeType);+ if (hr == MF_E_NO_MORE_TYPES || FAILED(hr)) {+ break;+ }++ UINT32 width = 0;+ UINT32 height = 0;+ if (FAILED(MFGetAttributeSize(nativeType.Get(), MF_MT_FRAME_SIZE, &width, &height))) {+ continue;+ }++ UINT32 numerator = 0;+ UINT32 denominator = 0;+ int fps = 0;+ if (SUCCEEDED(MFGetAttributeRatio(nativeType.Get(), MF_MT_FRAME_RATE, &numerator, &denominator)) &&+ denominator > 0) {+ fps = static_cast<int>((numerator + denominator / 2) / denominator);+ }++ GUID subtype{};+ const bool compressed = SUCCEEDED(nativeType->GetGUID(MF_MT_SUBTYPE, &subtype))+ ? isCompressedVideoSubtype(subtype)+ : true;++ formats.push_back(+ WebcamFormat{static_cast<int>(width), static_cast<int>(height), fps, compressed});+ }+ return formats;+}+++/**+ * Puts the camera itself on `wanted` by selecting the matching native type.+ *+ * Best-effort: a driver that refuses leaves the reader on whatever it had, and+ * the RGB32 request that follows still produces a usable -- if smaller -- frame.+ */+void selectNativeFormat(IMFSourceReader* reader, const WebcamFormat& wanted) {+ for (DWORD index = 0;; ++index) {+ Microsoft::WRL::ComPtr<IMFMediaType> nativeType;+ const HRESULT hr =+ reader->GetNativeMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, index, &nativeType);+ if (hr == MF_E_NO_MORE_TYPES || FAILED(hr)) {+ return;+ }++ UINT32 width = 0;+ UINT32 height = 0;+ if (FAILED(MFGetAttributeSize(nativeType.Get(), MF_MT_FRAME_SIZE, &width, &height))) {+ continue;+ }+ if (static_cast<int>(width) != wanted.width || static_cast<int>(height) != wanted.height) {+ continue;+ }++ GUID subtype{};+ if (FAILED(nativeType->GetGUID(MF_MT_SUBTYPE, &subtype)) ||+ isCompressedVideoSubtype(subtype) != wanted.compressed) {+ continue;+ }++ UINT32 numerator = 0;+ UINT32 denominator = 0;+ if (wanted.fps > 0 &&+ SUCCEEDED(MFGetAttributeRatio(nativeType.Get(), MF_MT_FRAME_RATE, &numerator, &denominator)) &&+ denominator > 0) {+ const int fps = static_cast<int>((numerator + denominator / 2) / denominator);+ if (fps != wanted.fps) {+ continue;+ }+ }++ if (SUCCEEDED(reader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, nativeType.Get()))) {+ return;+ }+ }+}++} // namespace++bool WebcamCapture::configureReader(+ int requestedWidth,+ int requestedHeight,+ int requestedFps,+ bool preferNv12) {Microsoft::WRL::ComPtr<IMFAttributes> attributes;if (!succeeded(MFCreateAttributes(&attributes, 3), "MFCreateAttributes(webcam reader)")) {return false;@@ -274,15 +403,57 @@ bool WebcamCapture::configureReader(int requestedWidth, int requestedHeight, intreturn false;}mediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);- mediaType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32);- if (requestedWidth > 0 && requestedHeight > 0) {- MFSetAttributeSize(mediaType.Get(), MF_MT_FRAME_SIZE, static_cast<UINT32>(requestedWidth), static_cast<UINT32>(requestedHeight));- }+ // NV12 when the frame only has to reach the webcam encoder, which wants+ // NV12 anyway. Asking for RGB32 instead makes the source reader decode AND+ // convert every frame: measured at 92ms per 3840x2160 frame against 32ms+ // for NV12, which is the difference between 11 fps and the camera's full+ // 30. BGRA is still used when the frame is composited into the screen+ // recording inline, which needs it in that layout.+ deliversNv12_ = preferNv12;+ mediaType->SetGUID(MF_MT_SUBTYPE, preferNv12 ? MFVideoFormat_NV12 : MFVideoFormat_RGB32);++ // Pick the capture format, then SELECT it on the source before asking for+ // RGB32 output.+ //+ // Both halves matter. Handing Media Foundation an output type with no+ // MF_MT_FRAME_SIZE leaves the device on its default format -- 640x480 on a+ // BRIO that offers 3840x2160 -- and that default is what the overlay was+ // upscaling. But naming the size on the *output* type alone is not enough+ // either: with MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING the reader answers+ // S_OK by inserting a converter in front of whichever native type is+ // already selected, so the camera keeps running at 640x480 and the size we+ // asked for is quietly dropped. Selecting the native type first is what+ // actually reconfigures the camera.+ const WebcamFormat chosen = chooseWebcamFormat(+ readNativeFormats(sourceReader_.Get()),+ requestedWidth > 0 ? requestedWidth : 1920,+ requestedHeight > 0 ? requestedHeight : 1080,+ std::max(1, requestedFps));+ std::cerr << "INFO: Native webcam format " << chosen.width << "x" << chosen.height << "@"+ << chosen.fps << (chosen.compressed ? " (compressed)" : " (uncompressed)") << std::endl;+ selectNativeFormat(sourceReader_.Get(), chosen);++ MFSetAttributeSize(+ mediaType.Get(), MF_MT_FRAME_SIZE, static_cast<UINT32>(chosen.width), static_cast<UINT32>(chosen.height));MFSetAttributeRatio(mediaType.Get(), MF_MT_FRAME_RATE, static_cast<UINT32>(std::max(1, requestedFps)), 1);- if (!succeeded(sourceReader_->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, mediaType.Get()),- "SetCurrentMediaType(webcam RGB32)")) {- return false;+ if (FAILED(sourceReader_->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, mediaType.Get()))) {+ // Some drivers refuse a size they nonetheless enumerate. A slightly soft+ // camera beats no camera, so drop the size and let the driver choose --+ // exactly what this code did before it asked for anything.+ std::cerr << "WARNING: Webcam rejected " << chosen.width << "x" << chosen.height+ << "; falling back to the device default format" << std::endl;+ Microsoft::WRL::ComPtr<IMFMediaType> fallbackType;+ if (!succeeded(MFCreateMediaType(&fallbackType), "MFCreateMediaType(webcam fallback)")) {+ return false;+ }+ fallbackType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);+ fallbackType->SetGUID(MF_MT_SUBTYPE, preferNv12 ? MFVideoFormat_NV12 : MFVideoFormat_RGB32);+ if (!succeeded(+ sourceReader_->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, fallbackType.Get()),+ "SetCurrentMediaType(webcam RGB32)")) {+ return false;+ }}sourceReader_->SetStreamSelection(MF_SOURCE_READER_ALL_STREAMS, FALSE);sourceReader_->SetStreamSelection(MF_SOURCE_READER_FIRST_VIDEO_STREAM, TRUE);@@ -336,12 +507,14 @@ void WebcamCapture::stop() {void WebcamCapture::captureLoop() {CoInitializeEx(nullptr, COINIT_MULTITHREADED);+ const auto loopStartedAt = std::chrono::steady_clock::now();while (!stopRequested_) {DWORD streamIndex = 0;DWORD flags = 0;LONGLONG timestamp = 0;Microsoft::WRL::ComPtr<IMFSample> sample;+ const auto readStartedAt = std::chrono::steady_clock::now();HRESULT hr = sourceReader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM,0,@@ -349,24 +522,35 @@ void WebcamCapture::captureLoop() {&flags,×tamp,&sample);+ readSampleUs_ += static_cast<uint64_t>(+ std::chrono::duration_cast<std::chrono::microseconds>(+ std::chrono::steady_clock::now() - readStartedAt)+ .count());(void)streamIndex;(void)timestamp;if (FAILED(hr)) {- std::cerr << "WARNING: Failed to read webcam sample (hr=0x" << std::hex << hr << std::dec << ")"- << std::endl;+ // Counted, not printed: a reader that fails every call would other-+ // wise write thousands of identical lines over a long take.+ readFailures_ += 1;+ lastReadFailure_ = hr;std::this_thread::sleep_for(std::chrono::milliseconds(20));continue;}if ((flags & MF_SOURCE_READERF_ENDOFSTREAM) != 0) {+ sawEndOfStream_ = true;break;}if (!sample) {+ // Normal in small numbers (MF_SOURCE_READERF_STREAMTICK); a run of+ // nothing else is a camera that never started producing.+ emptySamples_ += 1;continue;}Microsoft::WRL::ComPtr<IMFMediaBuffer> buffer;if (FAILED(sample->ConvertToContiguousBuffer(&buffer)) || !buffer) {+ bufferFailures_ += 1;continue;}@@ -374,19 +558,54 @@ void WebcamCapture::captureLoop() {DWORD maxLength = 0;DWORD currentLength = 0;if (FAILED(buffer->Lock(&data, &maxLength, ¤tLength)) || !data) {+ bufferFailures_ += 1;continue;}- const DWORD expectedLength = static_cast<DWORD>(std::max(0, width_) * std::max(0, height_) * 4);+ const int pixels = std::max(0, width_) * std::max(0, height_);+ const DWORD expectedLength =+ static_cast<DWORD>(deliversNv12_ ? pixels * 3 / 2 : pixels * 4);if (currentLength >= expectedLength && expectedLength > 0) {- std::scoped_lock lock(frameMutex_);- latestFrame_.assign(data, data + expectedLength);- latestFrameSequence_ += 1;+ if (framesDelivered_ == 0) {+ const auto waitedMs = std::chrono::duration_cast<std::chrono::milliseconds>(+ std::chrono::steady_clock::now() - loopStartedAt)+ .count();+ std::cerr << "INFO: First webcam frame after " << waitedMs << "ms" << std::endl;+ }+ framesDelivered_ += 1;+ const auto storeStartedAt = std::chrono::steady_clock::now();+ {+ std::scoped_lock lock(frameMutex_);+ latestFrame_.assign(data, data + expectedLength);+ latestFrameSequence_ += 1;+ }+ storeUs_ += static_cast<uint64_t>(+ std::chrono::duration_cast<std::chrono::microseconds>(+ std::chrono::steady_clock::now() - storeStartedAt)+ .count());+ } else if (shortBuffers_++, !reportedShortBuffer_) {+ // Every frame arriving short means the reader is handing us something+ // other than the RGB32 we asked for -- a compressed frame it never+ // converted, most often. Silently dropped, that reads downstream as a+ // camera that produced nothing at all, with no clue why. Said once,+ // because it is true for every frame that follows.+ reportedShortBuffer_ = true;+ std::cerr << "WARNING: Webcam frame is " << currentLength << " bytes, expected "+ << expectedLength << " for " << width_ << "x" << height_ << " "+ << (deliversNv12_ ? "NV12" : "RGB32") << "; dropping frames" << std::endl;}buffer->Unlock();}+ std::cerr << "INFO: Webcam capture loop ended: delivered=" << framesDelivered_+ << " emptySamples=" << emptySamples_ << " shortBuffers=" << shortBuffers_+ << " bufferFailures=" << bufferFailures_ << " readFailures=" << readFailures_+ << " lastReadHr=0x" << std::hex << lastReadFailure_ << std::dec+ << " endOfStream=" << (sawEndOfStream_ ? "yes" : "no")+ << " readSampleMs=" << (readSampleUs_ / 1000) << " storeMs=" << (storeUs_ / 1000)+ << std::endl;+CoUninitialize();}@@ -406,6 +625,10 @@ bool WebcamCapture::copyLatestFrame(WebcamFrameSnapshot& destination) {return true;}+bool WebcamCapture::deliversNv12() const {+ return !usingDirectShow_ && deliversNv12_;+}+int WebcamCapture::width() const {if (usingDirectShow_) {return directShowCapture_.width();diff --git a/electron/native/wgc-capture/src/webcam_capture.h b/electron/native/wgc-capture/src/webcam_capture.hindex 5b61aa6b9..612e36603 100644--- a/electron/native/wgc-capture/src/webcam_capture.h+++ b/electron/native/wgc-capture/src/webcam_capture.h@@ -28,7 +28,8 @@ public:const std::wstring& directShowClsid,int requestedWidth,int requestedHeight,- int requestedFps);+ int requestedFps,+ bool preferNv12);bool start();void stop();bool copyLatestFrame(WebcamFrameSnapshot& destination);@@ -36,11 +37,19 @@ public:int width() const;int height() const;int fps() const;+ /**+ * Do the frames from `copyLatestFrame` carry NV12 rather than BGRA?+ *+ * Always false on the DirectShow fallback, which unpacks whatever the+ * camera speaks into BGRA itself. Callers must ask rather than assume:+ * the two layouts differ in size as well as in meaning.+ */+ bool deliversNv12() const;const std::wstring& selectedDeviceName() const;private:bool selectDevice(const std::wstring& deviceId, const std::wstring& deviceName);- bool configureReader(int requestedWidth, int requestedHeight, int requestedFps);+ bool configureReader(int requestedWidth, int requestedHeight, int requestedFps, bool preferNv12);void captureLoop();Microsoft::WRL::ComPtr<IMFMediaSource> mediaSource_;@@ -56,6 +65,27 @@ private:int fps_ = 30;bool mfStarted_ = false;bool usingDirectShow_ = false;+ bool deliversNv12_ = false;+ /** Latches the short-buffer warning so it is said once, not 30x a second. */+ bool reportedShortBuffer_ = false;+ /**+ * Why the capture loop did or did not produce frames.+ *+ * A camera that delivers nothing used to surface only as+ * MF_E_SINK_NO_SAMPLES_PROCESSED from the encoder's Finalize -- the one+ * place that cannot say which of the loop's five silent `continue` paths+ * swallowed the frames. These are reported once when the loop ends.+ */+ uint64_t framesDelivered_ = 0;+ uint64_t emptySamples_ = 0;+ uint64_t readFailures_ = 0;+ uint64_t shortBuffers_ = 0;+ uint64_t bufferFailures_ = 0;+ bool sawEndOfStream_ = false;+ HRESULT lastReadFailure_ = S_OK;+ /** Where the loop's wall time goes, in microseconds. */+ uint64_t readSampleUs_ = 0;+ uint64_t storeUs_ = 0;int selectedMatchScore_ = 0;std::wstring selectedDeviceName_;};diff --git a/electron/native/wgc-capture/src/webcam_format.cpp b/electron/native/wgc-capture/src/webcam_format.cppnew file mode 100644index 000000000..32e2020ed--- /dev/null+++ b/electron/native/wgc-capture/src/webcam_format.cpp@@ -0,0 +1,82 @@+#include "webcam_format.h"++#include <algorithm>++namespace {++bool isUsable(const WebcamFormat& format) {+ return format.width > 0 && format.height > 0;+}++bool fitsTarget(const WebcamFormat& format, int targetWidth, int targetHeight) {+ return format.width <= targetWidth && format.height <= targetHeight;+}++long long pixels(const WebcamFormat& format) {+ return static_cast<long long>(format.width) * static_cast<long long>(format.height);+}++// True when `candidate` is a better frame rate than `best` for a target of+// `targetFps`: the lowest rate that still reaches the target, or -- when no+// mode reaches it -- the highest one on offer.+bool betterFps(int candidate, int best, int targetFps) {+ const bool candidateReaches = candidate >= targetFps;+ const bool bestReaches = best >= targetFps;+ if (candidateReaches != bestReaches) {+ return candidateReaches;+ }+ return candidateReaches ? candidate < best : candidate > best;+}++} // namespace++WebcamFormat chooseWebcamFormat(+ const std::vector<WebcamFormat>& available,+ int targetWidth,+ int targetHeight,+ int targetFps) {+ const WebcamFormat target{targetWidth, targetHeight, targetFps, false};++ // Compressed modes are a last resort, so they are only considered when the+ // camera offers nothing else at all.+ const bool anyUncompressed = std::any_of(available.begin(), available.end(), [](const WebcamFormat& format) {+ return isUsable(format) && !format.compressed;+ });++ const auto eligible = [&](const WebcamFormat& format) {+ return isUsable(format) && !(anyUncompressed && format.compressed);+ };++ const bool anyFits = std::any_of(available.begin(), available.end(), [&](const WebcamFormat& format) {+ return eligible(format) && fitsTarget(format, targetWidth, targetHeight);+ });++ const WebcamFormat* best = nullptr;+ for (const WebcamFormat& format : available) {+ if (!eligible(format)) {+ continue;+ }+ // Once anything fits, oversized modes are out of the running entirely.+ // With nothing fitting we rank the oversized modes instead, smallest+ // first, so the scaler has the least work to do.+ if (anyFits != fitsTarget(format, targetWidth, targetHeight)) {+ continue;+ }+ if (best == nullptr) {+ best = &format;+ continue;+ }+ if (pixels(format) != pixels(*best)) {+ const bool wins = anyFits ? pixels(format) > pixels(*best) : pixels(format) < pixels(*best);+ if (wins) {+ best = &format;+ }+ continue;+ }+ if (betterFps(format.fps, best->fps, targetFps)) {+ best = &format;+ }+ }++ return best ? *best : target;+}diff --git a/electron/native/wgc-capture/src/webcam_format.h b/electron/native/wgc-capture/src/webcam_format.hnew file mode 100644index 000000000..7cb329af7--- /dev/null+++ b/electron/native/wgc-capture/src/webcam_format.h@@ -0,0 +1,44 @@+#pragma once++#include <vector>++// One capture format a camera advertises.+struct WebcamFormat {+ int width = 0;+ int height = 0;+ int fps = 0;+ /**+ * True for MJPEG/H264 modes, which reach higher resolutions than a camera's+ * uncompressed ones but need a decoder MFT in front of the RGB32 conversion.+ */+ bool compressed = false;+};++// Picks the format to drive the camera at, given everything it advertises.+//+// Both capture backends used to leave this to the driver: Media Foundation was+// handed a media type with no MF_MT_FRAME_SIZE, and the DirectShow graph was+// rendered without touching IAMStreamConfig. In both cases the device answers+// with its *default* type, and for a UVC camera that is the first format it+// enumerates -- 640x480 even on a BRIO that offers 3840x2160. The recording was+// then upscaled into the overlay, which is the pixelation users reported.+//+// Rules, in order:+// * uncompressed modes beat compressed ones outright, whatever their size.+// Pinning a camera's MJPEG mode and asking the source reader for RGB32+// leaves it delivering no samples at all on some hosts -- a recording with+// no camera in it, which is far worse than a smaller one that works;+// * only formats that fit inside the target in BOTH dimensions are eligible,+// so an ultrawide mode cannot sneak in on pixel count alone;+// * among those, the most pixels wins;+// * ties go to the lowest frame rate that still reaches the target, else the+// highest available -- a 1080p60 mode is no help when we encode at 30;+// * if nothing fits (a camera that only does 4K), the smallest mode wins, so+// we scale down rather than push 1 GB/s of RGB32 through the encoder;+// * an empty list returns the target unchanged, letting the caller fall back+// to whatever the driver would have picked on its own.+WebcamFormat chooseWebcamFormat(+ const std::vector<WebcamFormat>& available,+ int targetWidth,+ int targetHeight,+ int targetFps);diff --git a/electron/native/wgc-capture/src/webcam_format_test.cpp b/electron/native/wgc-capture/src/webcam_format_test.cppnew file mode 100644index 000000000..9e40f5cbf--- /dev/null+++ b/electron/native/wgc-capture/src/webcam_format_test.cpp@@ -0,0 +1,131 @@+#include "webcam_format.h"++#include <cstdio>+#include <string>++namespace {++int failures = 0;++void expectFormat(const std::string& label, WebcamFormat actual, int width, int height, int fps) {+ if (actual.width == width && actual.height == height && actual.fps == fps) {+ return;+ }+ std::printf(+ "FAIL %s: expected %dx%d@%d, got %dx%d@%d\n",+ label.c_str(),+ width,+ height,+ fps,+ actual.width,+ actual.height,+ actual.fps);+ ++failures;+}++// Every mode a Logitech BRIO advertises that this helper could drive, as read+// off the device with `ffmpeg -f dshow -list_options true`.+const std::vector<WebcamFormat> kBrio = {+ {640, 480, 30, false}, {640, 360, 30, false}, {1280, 720, 30, false},+ {1920, 1080, 30, false}, {1280, 720, 90, true}, {1920, 1080, 60, true},+ {2560, 1440, 30, true}, {3840, 2160, 30, true}, {160, 120, 30, false},+ {340, 340, 30, false}, {1600, 896, 30, false}, {1024, 576, 30, false},+};++} // namespace++int main() {+ // The regression this file exists for: a BRIO asked for 1080p must not come+ // back with the 640x480 default it enumerates first.+ expectFormat("brio targets 1080p", chooseWebcamFormat(kBrio, 1920, 1080, 30), 1920, 1080, 30);++ // Asked for more than the camera can do uncompressed, it must stop at the+ // best uncompressed mode rather than pin an MJPEG one. Pinning MJPEG and+ // asking the source reader for RGB32 produced a reader that delivered no+ // samples at all, so the take had no camera in it.+ expectFormat(+ "4K request settles for the best uncompressed mode",+ chooseWebcamFormat(kBrio, 3840, 2160, 30),+ 1920,+ 1080,+ 30);+ if (chooseWebcamFormat(kBrio, 3840, 2160, 30).compressed) {+ std::printf("FAIL 4K request must not pin a compressed mode\n");+ ++failures;+ }++ // A camera with nothing but compressed modes still has to be usable.+ expectFormat(+ "compressed-only camera is still driven",+ chooseWebcamFormat({{1920, 1080, 30, true}, {1280, 720, 30, true}}, 1920, 1080, 30),+ 1920,+ 1080,+ 30);++ // Uncompressed wins even when it is much smaller than a compressed option.+ expectFormat(+ "uncompressed beats a larger compressed mode",+ chooseWebcamFormat({{3840, 2160, 30, true}, {640, 480, 30, false}}, 3840, 2160, 30),+ 640,+ 480,+ 30);++ // 1080p60 exists too; at a 30 fps encode the extra frames only cost bandwidth.+ expectFormat(+ "prefers the frame rate we encode at",+ chooseWebcamFormat({{1920, 1080, 60}, {1920, 1080, 30}}, 1920, 1080, 30),+ 1920,+ 1080,+ 30);++ // Nothing reaches 30, so take the best the camera can do rather than fail.+ expectFormat(+ "falls back to the highest rate offered",+ chooseWebcamFormat({{1920, 1080, 15}, {1920, 1080, 24}}, 1920, 1080, 30),+ 1920,+ 1080,+ 24);++ // A 720p-only camera keeps working, just smaller.+ expectFormat(+ "720p camera stays 720p",+ chooseWebcamFormat({{1280, 720, 30}, {640, 480, 30}}, 1920, 1080, 30),+ 1280,+ 720,+ 30);++ // 2560x800 has fewer pixels than 1920x1080 but is far wider; picking it+ // would letterbox the overlay and cost a needless downscale.+ expectFormat(+ "rejects an oversized dimension even when pixel count fits",+ chooseWebcamFormat({{2560, 800, 30}, {1280, 720, 30}}, 1920, 1080, 30),+ 1280,+ 720,+ 30);++ // Only modes above the target: scale down from the cheapest of them.+ expectFormat(+ "oversized-only camera takes the smallest mode",+ chooseWebcamFormat({{3840, 2160, 30}, {2560, 1440, 30}}, 1920, 1080, 30),+ 2560,+ 1440,+ 30);++ // Nothing to choose from: hand the target back and let the driver decide.+ expectFormat("empty list returns the target", chooseWebcamFormat({}, 1920, 1080, 30), 1920, 1080, 30);++ // Drivers do report junk; it must not win.+ expectFormat(+ "ignores degenerate entries",+ chooseWebcamFormat({{0, 0, 30}, {-1920, 1080, 30}, {1280, 720, 30}}, 1920, 1080, 30),+ 1280,+ 720,+ 30);++ if (failures == 0) {+ std::printf("webcam_format_test: all assertions passed\n");+ return 0;+ }+ std::printf("webcam_format_test: %d assertion(s) failed\n", failures);+ return 1;+}diff --git a/scripts/build-windows-wgc-helper.mjs b/scripts/build-windows-wgc-helper.mjsindex 8d4cfc018..b4e4a59bd 100644--- a/scripts/build-windows-wgc-helper.mjs+++ b/scripts/build-windows-wgc-helper.mjs@@ -105,3 +105,13 @@ if (!fs.existsSync(audioUtilsTestPath)) {// Pack) instead of failing this packaging command.await run(audioUtilsTestPath, [], { cwd: BUILD_DIR });console.log(`Passed ${audioUtilsTestPath}`);++const webcamFormatTestPath = path.join(BUILD_DIR, "webcam_format_test.exe");+if (!fs.existsSync(webcamFormatTestPath)) {+ throw new Error(`WGC helper build completed but ${webcamFormatTestPath} was not found.`);+}+// Guards the capture resolution the camera is driven at. Left unpinned, both+// backends fall back to the device default -- 640x480 on hardware that offers+// far more -- and the overlay upscales it.+await run(webcamFormatTestPath, [], { cwd: BUILD_DIR });+console.log(`Passed ${webcamFormatTestPath}`);diff --git a/scripts/test-windows-wgc-helper.mjs b/scripts/test-windows-wgc-helper.mjsindex 785e48c1e..2bca55bd7 100644--- a/scripts/test-windows-wgc-helper.mjs+++ b/scripts/test-windows-wgc-helper.mjs@@ -490,9 +490,13 @@ const config = {webcamDirectShowClsid: resolveDirectShowWebcamClsid(process.env.OPENSCREEN_WGC_TEST_WEBCAM_DEVICE_NAME ?? "",),- webcamWidth: 640,- webcamHeight: 360,- webcamFps: 30,+ // DEFAULT_WEBCAM_QUALITY from src/hooks/webcamCaptureTarget.ts -- the target the+ // app actually sends, so this exercises the format negotiation rather than a+ // size no shipped pipeline ever asks for. A camera that cannot reach it is+ // driven at its own best format, which is the case worth covering anyway.+ webcamWidth: Number(process.env.OPENSCREEN_WGC_TEST_WEBCAM_WIDTH ?? 3840),+ webcamHeight: Number(process.env.OPENSCREEN_WGC_TEST_WEBCAM_HEIGHT ?? 2160),+ webcamFps: Number(process.env.OPENSCREEN_WGC_TEST_WEBCAM_FPS ?? 30),outputs: {screenPath: outputPath,...(webcamOutputPath ? { webcamPath: webcamOutputPath } : {}),@@ -631,9 +635,23 @@ const encoderSelectionLine = result.stdout.split(/\r?\n/).find((line) => line.includes('"event":"encoder-selection"'));const encoderSelection = encoderSelectionLine ? JSON.parse(encoderSelectionLine) : null;-const nativeWebcamDiagnostics = result.stderr- .split(/\r?\n/)- .filter((line) => line.includes("Native webcam candidate"));+const nativeWebcamDiagnostics = result.stderr.split(/\r?\n/).filter(+ (line) =>+ line.includes("Native webcam candidate") ||+ // Which capture format the camera was actually driven at. Without this+ // the smoke test could pass on a 640x480 take from a 4K camera and say+ // nothing about it.+ line.includes("Native webcam format") ||+ line.includes("DirectShow webcam format") ||+ line.includes("DirectShow webcam connected") ||+ line.includes("falling back to the device default") ||+ // How long the camera took to produce its first frame, and the tally of what+ // the capture loop did with everything it read. Without these, a camera that+ // delivers nothing is only visible as a failed Finalize, which cannot say why.+ line.includes("First webcam frame") ||+ line.includes("Webcam capture loop ended") ||+ line.includes("Webcam frame is"),+);const nativeMicrophoneDiagnostics = result.stderr.split(/\r?\n/).filter(diff --git a/src/components/launch/HudDeviceSettings.quality.test.tsx b/src/components/launch/HudDeviceSettings.quality.test.tsxnew file mode 100644index 000000000..a44cf19b4--- /dev/null+++ b/src/components/launch/HudDeviceSettings.quality.test.tsx@@ -0,0 +1,96 @@+// @vitest-environment jsdom+import { fireEvent, render, screen } from "@testing-library/react";+import { describe, expect, it, vi } from "vitest";+import { WEBCAM_QUALITY_IDS } from "../../hooks/webcamCaptureTarget";+import { HudDeviceSettings, type HudDeviceSettingsLabels } from "./HudDeviceSettings";++vi.mock("../../hooks/useAudioLevelMeter", () => ({+ useAudioLevelMeter: () => ({ level: 0 }),+}));+vi.mock("../../hooks/useCameraPreviewStream", () => ({+ useCameraPreviewStream: () => ({ stream: null, error: null }),+}));++const labels: HudDeviceSettingsLabels = {+ title: "Device settings",+ done: "Done",+ microphone: "Microphone",+ camera: "Camera",+ micLevel: "Input level",+ micHint: "Speak to check",+ noMicrophones: "No microphone found",+ searching: "Searching...",+ noCameras: "No camera found",+ cameraUnavailable: "Camera unavailable",+ preview: "Preview",+ previewUnavailable: "Preview unavailable",+ about: "About",+ checkForUpdates: "Check for updates",+ checkingForUpdates: "Checking…",+ cameraQuality: "Camera quality",+ cameraQualityOptions: {+ "1080p": "1080p",+ "1440p": "1440p",+ "2160p": "4K",+ },+};++function renderPanel(overrides: Partial<Parameters<typeof HudDeviceSettings>[0]> = {}) {+ const onSelectCameraQuality = vi.fn();+ render(+ <HudDeviceSettings+ micDevices={[]}+ cameraDevices={[{ deviceId: "cam-1", label: "Logitech BRIO" }]}+ activeMicId={undefined}+ activeCameraId="cam-1"+ cameraLoading={false}+ cameraError={null}+ labels={labels}+ versionLabel={null}+ canCheckForUpdates={false}+ checkingForUpdates={false}+ cameraQuality="1440p"+ onSelectCameraQuality={onSelectCameraQuality}+ onSelectMic={vi.fn()}+ onSelectCamera={vi.fn()}+ onCheckForUpdates={vi.fn()}+ onClose={vi.fn()}+ panelRef={() => undefined}+ {...overrides}+ />,+ );+ return { onSelectCameraQuality };+}++describe("HudDeviceSettings camera quality", () => {+ it("offers every preset the capture pipeline knows about", () => {+ renderPanel();++ for (const id of WEBCAM_QUALITY_IDS) {+ expect(screen.getByTestId(`camera-quality-${id}`)).toBeTruthy();+ }+ });++ it("marks the stored choice as the checked one", () => {+ renderPanel();++ expect(screen.getByTestId("camera-quality-1440p").getAttribute("aria-checked")).toBe("true");+ expect(screen.getByTestId("camera-quality-2160p").getAttribute("aria-checked")).toBe("false");+ });++ it("reports the picked preset so it can be persisted", () => {+ const { onSelectCameraQuality } = renderPanel();++ fireEvent.click(screen.getByTestId("camera-quality-2160p"));++ expect(onSelectCameraQuality).toHaveBeenCalledWith("2160p");+ });++ it("hides the choice when there is no camera to apply it to", () => {+ // A resolution picker above "No camera found" is a control that cannot do+ // anything, and it pushes the real message out of view.+ renderPanel({ cameraDevices: [], activeCameraId: undefined });++ expect(screen.queryByTestId("camera-quality-2160p")).toBeNull();+ });+});diff --git a/src/components/launch/HudDeviceSettings.tsx b/src/components/launch/HudDeviceSettings.tsxindex d807f752b..3bf43df74 100644--- a/src/components/launch/HudDeviceSettings.tsx+++ b/src/components/launch/HudDeviceSettings.tsx@@ -4,6 +4,7 @@ import { useAudioLevelMeter } from "../../hooks/useAudioLevelMeter";import type { CameraDevice } from "../../hooks/useCameraDevices";import { useCameraPreviewStream } from "../../hooks/useCameraPreviewStream";import type { MicrophoneDevice } from "../../hooks/useMicrophoneDevices";+import { WEBCAM_QUALITY_IDS, type WebcamQualityId } from "../../hooks/webcamCaptureTarget";import styles from "./LaunchWindow.module.css";const LEVEL_SEGMENTS = 12;@@ -25,6 +26,8 @@ export interface HudDeviceSettingsLabels {about: string;checkForUpdates: string;checkingForUpdates: string;+ cameraQuality: string;+ cameraQualityOptions: Record<WebcamQualityId, string>;}/** Segmented input-level bar, driven by the live analyser. */@@ -96,6 +99,8 @@ export const HudDeviceSettings = memo(function HudDeviceSettings({versionLabel,canCheckForUpdates,checkingForUpdates,+ cameraQuality,+ onSelectCameraQuality,onSelectMic,onSelectCamera,onCheckForUpdates,@@ -116,6 +121,8 @@ export const HudDeviceSettings = memo(function HudDeviceSettings({versionLabel: string | null;canCheckForUpdates: boolean;checkingForUpdates: boolean;+ cameraQuality: WebcamQualityId;+ onSelectCameraQuality: (quality: WebcamQualityId) => void;onSelectMic: (device: MicrophoneDevice) => void;onSelectCamera: (device: CameraDevice) => void;onCheckForUpdates: () => void;@@ -214,6 +221,29 @@ export const HudDeviceSettings = memo(function HudDeviceSettings({)}{hasCamera ? (<>+ {/* Below the device list, because it qualifies the camera picked+ above. Hidden with no camera present -- a resolution control+ over "No camera found" cannot do anything. */}+ <div className={styles.hudModalMeterRow}>+ <span className={styles.hudModalMeterLabel}>{labels.cameraQuality}</span>+ </div>+ {WEBCAM_QUALITY_IDS.map((quality) => {+ const isActive = quality === cameraQuality;+ return (+ <button+ key={quality}+ type="button"+ role="menuitemradio"+ aria-checked={isActive}+ data-testid={`camera-quality-${quality}`}+ onClick={() => onSelectCameraQuality(quality)}+ className={`${styles.languageMenuItem} ${isActive ? styles.languageMenuItemActive : ""}`}+ >+ <span className="truncate">{labels.cameraQualityOptions[quality]}</span>+ {isActive ? <Check size={11} className="text-white/85" /> : null}+ </button>+ );+ })}<div className={styles.hudModalMeterRow}><span className={styles.hudModalMeterLabel}>{labels.preview}</span></div>diff --git a/src/components/launch/LaunchWindow.tsx b/src/components/launch/LaunchWindow.tsxindex b7fcc9715..5ddffd89e 100644--- a/src/components/launch/LaunchWindow.tsx+++ b/src/components/launch/LaunchWindow.tsx@@ -13,6 +13,7 @@ import {} from "../../hooks/useMicrophoneDevices";import { usePortalOwnsSource } from "../../hooks/usePortalOwnsSource";import { useScreenRecorder } from "../../hooks/useScreenRecorder";+import type { WebcamQualityId } from "../../hooks/webcamCaptureTarget";import { requestCameraAccess } from "../../lib/requestCameraAccess";import {HudCameraButton,@@ -111,6 +112,8 @@ export function LaunchWindow() {setWebcamEnabled,webcamDeviceId,setWebcamDeviceId,+ webcamQuality,+ setWebcamQuality,webcamDeviceName,setWebcamDeviceName,cursorCaptureMode,@@ -862,6 +865,7 @@ export function LaunchWindow() {camEnabled?: boolean;camDeviceId?: string;camDeviceName?: string;+ camQuality?: WebcamQualityId;micEnabled?: boolean;micDeviceId?: string;micDeviceName?: string;@@ -927,6 +931,14 @@ export function LaunchWindow() {[persistRecordingPrefs, setSelectedCameraId, setWebcamDeviceId, setWebcamDeviceName],);+ const handleSelectCameraQuality = useCallback(+ (quality: WebcamQualityId) => {+ setWebcamQuality(quality);+ persistRecordingPrefs({ camQuality: quality });+ },+ [persistRecordingPrefs, setWebcamQuality],+ );+const toggleDeviceSettings = useCallback(() => {if (controlsLocked) return;setIsLanguageMenuOpen(false);@@ -1068,6 +1080,12 @@ export function LaunchWindow() {about: t("deviceSettings.about"),checkForUpdates: tCommon("actions.checkForUpdates"),checkingForUpdates: t("deviceSettings.checkingForUpdates"),+ cameraQuality: t("webcam.quality"),+ cameraQualityOptions: {+ "1080p": t("webcam.quality1080p"),+ "1440p": t("webcam.quality1440p"),+ "2160p": t("webcam.quality2160p"),+ },}),[t, tCommon],);@@ -1282,6 +1300,8 @@ export function LaunchWindow() {// main process refuses the check then — an offered button would be dead.canCheckForUpdates={(appInfo?.canCheckForUpdates ?? false) && !recording}checkingForUpdates={isCheckingForUpdates}+ cameraQuality={webcamQuality}+ onSelectCameraQuality={handleSelectCameraQuality}onSelectMic={handleSelectMicDevice}onSelectCamera={handleSelectCameraDevice}onCheckForUpdates={handleCheckForUpdates}diff --git a/src/hooks/useCameraPreviewStream.ts b/src/hooks/useCameraPreviewStream.tsindex 9080e7c8d..9e04c0558 100644--- a/src/hooks/useCameraPreviewStream.ts+++ b/src/hooks/useCameraPreviewStream.ts@@ -1,4 +1,5 @@import { useEffect, useRef, useState } from "react";+import { webcamVideoConstraints } from "./webcamCaptureTarget";export interface CameraPreviewStreamOptions {enabled: boolean;@@ -28,7 +29,13 @@ export function useCameraPreviewStream({ enabled, deviceId }: CameraPreviewStrealet cancelled = false;navigator.mediaDevices.getUserMedia({- video: deviceId ? { deviceId: { exact: deviceId } } : true,+ // Pinned to the smallest preset, not to whatever the recording is set+ // to. Left unconstrained this opened at 640x480 and made the camera+ // look as soft in the HUD as it did in the take; driving it at the+ // user's 4K choice would be the opposite mistake, since this renders+ // into a thumbnail a couple of hundred pixels wide and the recorder+ // opens its own stream anyway.+ video: webcamVideoConstraints(deviceId, "1080p"),audio: false,}).then((s) => {diff --git a/src/hooks/useScreenRecorder.ts b/src/hooks/useScreenRecorder.tsindex 3e036e46e..d01131056 100644--- a/src/hooks/useScreenRecorder.ts+++ b/src/hooks/useScreenRecorder.ts@@ -21,6 +21,15 @@ import { requestCameraAccess } from "@/lib/requestCameraAccess";import { loadUserPreferences, saveUserPreferences } from "@/lib/userPreferences";import { canRecordMicrophone } from "@/utils/platformUtils";import { createRecorderHandle, type RecorderHandle } from "./recorderHandle";+import {+ DEFAULT_WEBCAM_QUALITY,+ WEBCAM_TARGET_FRAME_RATE,+ type WebcamQualityId,+ webcamBitrateForStream,+ webcamPresetFor,+ webcamQualityFrom,+ webcamVideoConstraints,+} from "./webcamCaptureTarget";import { webcamDeviceIdentityFrom } from "./webcamDeviceIdentity";const TARGET_FRAME_RATE = 60;@@ -77,8 +86,6 @@ function effectiveBrowserCursorMode(const AUDIO_BITRATE_VOICE = 128_000;const AUDIO_BITRATE_SYSTEM = 192_000;-const WEBCAM_TARGET_FRAME_RATE = 30;-type UseScreenRecorderReturn = {recording: boolean;paused: boolean;@@ -99,6 +106,8 @@ type UseScreenRecorderReturn = {setMicrophoneDeviceName: (deviceName: string | undefined) => void;webcamDeviceId: string | undefined;setWebcamDeviceId: (deviceId: string | undefined) => void;+ webcamQuality: WebcamQualityId;+ setWebcamQuality: (quality: WebcamQualityId) => void;webcamDeviceName: string | undefined;setWebcamDeviceName: (deviceName: string | undefined) => void;systemAudioEnabled: boolean;@@ -257,6 +266,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {const [microphoneDeviceId, setMicrophoneDeviceId] = useState<string | undefined>(undefined);const [microphoneDeviceName, setMicrophoneDeviceName] = useState<string | undefined>(undefined);const [webcamDeviceId, setWebcamDeviceId] = useState<string | undefined>(undefined);+ const [webcamQuality, setWebcamQuality] = useState<WebcamQualityId>(DEFAULT_WEBCAM_QUALITY);const [webcamDeviceName, setWebcamDeviceName] = useState<string | undefined>(undefined);const [systemAudioEnabled, setSystemAudioEnabled] = useState(false);const [webcamEnabled, setWebcamEnabledState] = useState(false);@@ -281,6 +291,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {camEnabled: boolean;camDeviceId?: string | null;camDeviceName?: string | null;+ camQuality?: WebcamQualityId | null;systemAudioEnabled: boolean;cursorCaptureMode: CursorCaptureMode;}) => {@@ -298,6 +309,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {setWebcamDeviceId(prefs.camDeviceId ?? undefined);setWebcamDeviceName(prefs.camDeviceName ?? undefined);}+ setWebcamQuality(webcamQualityFrom(prefs.camQuality));setSystemAudioEnabled(prefs.systemAudioEnabled);setCursorCaptureMode(prefs.cursorCaptureMode);setRecordingPrefsLoaded(true);@@ -480,14 +492,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {try {const stream = await navigator.mediaDevices.getUserMedia({audio: false,- video: webcamDeviceId- ? {- deviceId: { exact: webcamDeviceId },- frameRate: { ideal: WEBCAM_TARGET_FRAME_RATE, max: WEBCAM_TARGET_FRAME_RATE },- }- : {- frameRate: { ideal: WEBCAM_TARGET_FRAME_RATE, max: WEBCAM_TARGET_FRAME_RATE },- },+ video: webcamVideoConstraints(webcamDeviceId, webcamQuality),});if (cancelled || thisAcquireId !== webcamAcquireId.current) {@@ -545,7 +550,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {webcamStream.current = null;}};- }, [webcamEnabled, webcamDeviceId, webcamDeviceName, t]);+ }, [webcamEnabled, webcamDeviceId, webcamDeviceName, webcamQuality, t]);const finalizeRecording = useCallback((@@ -1240,8 +1245,8 @@ export function useScreenRecorder(): UseScreenRecorderReturn {enabled: webcamEnabled,deviceId: webcamIdentity.deviceId,deviceName: webcamIdentity.deviceName,- width: 0,- height: 0,+ width: webcamPresetFor(webcamQuality).width,+ height: webcamPresetFor(webcamQuality).height,fps: WEBCAM_TARGET_FRAME_RATE,},cursor: {@@ -1358,7 +1363,10 @@ export function useScreenRecorder(): UseScreenRecorderReturn {webcamStream.current,{mimeType: selectMimeType(),- videoBitsPerSecond: BITRATE_BASE,+ // Sized from the track, not from BITRATE_BASE: that was the+ // screen's rate and it starves a 1440p or 2160p camera frame+ // badly enough to undo the resolution we just asked for.+ videoBitsPerSecond: webcamBitrateForStream(webcamStream.current),},`${RECORDING_FILE_PREFIX}${activeRecordingId}${WEBCAM_FILE_SUFFIX}${VIDEO_FILE_EXTENSION}`,);@@ -1403,8 +1411,8 @@ export function useScreenRecorder(): UseScreenRecorderReturn {// Same pairing rule as the Windows path; here the stream is still// open, so the identity can be read at the point of use....readWebcamDeviceIdentity(),- width: 0,- height: 0,+ width: webcamPresetFor(webcamQuality).width,+ height: webcamPresetFor(webcamQuality).height,fps: WEBCAM_TARGET_FRAME_RATE,},cursor: {@@ -1557,7 +1565,10 @@ export function useScreenRecorder(): UseScreenRecorderReturn {webcamStream.current,{mimeType: selectMimeType(),- videoBitsPerSecond: BITRATE_BASE,+ // Sized from the track, not from BITRATE_BASE: that was the+ // screen's rate and it starves a 1440p or 2160p camera frame+ // badly enough to undo the resolution we just asked for.+ videoBitsPerSecond: webcamBitrateForStream(webcamStream.current),},`${RECORDING_FILE_PREFIX}${activeRecordingId}${WEBCAM_FILE_SUFFIX}${VIDEO_FILE_EXTENSION}`,);@@ -2403,6 +2414,8 @@ export function useScreenRecorder(): UseScreenRecorderReturn {setMicrophoneDeviceName,webcamDeviceId,setWebcamDeviceId,+ webcamQuality,+ setWebcamQuality,webcamDeviceName,setWebcamDeviceName,systemAudioEnabled,diff --git a/src/hooks/webcamCaptureTarget.test.ts b/src/hooks/webcamCaptureTarget.test.tsnew file mode 100644index 000000000..25f83efdd--- /dev/null+++ b/src/hooks/webcamCaptureTarget.test.ts@@ -0,0 +1,137 @@+import { describe, expect, it } from "vitest";+import {+ DEFAULT_WEBCAM_QUALITY,+ WEBCAM_QUALITY_IDS,+ WEBCAM_QUALITY_PRESETS,+ WEBCAM_TARGET_FRAME_RATE,+ webcamBitrateFor,+ webcamBitrateForStream,+ webcamPresetFor,+ webcamQualityFrom,+ webcamVideoConstraints,+} from "./webcamCaptureTarget";++describe("webcamVideoConstraints", () => {+ it("asks for the chosen preset, not the browser's 640x480 default", () => {+ expect(webcamVideoConstraints(undefined, "2160p")).toMatchObject({+ width: { ideal: 3840 },+ height: { ideal: 2160 },+ });+ expect(webcamVideoConstraints(undefined, "1080p")).toMatchObject({+ width: { ideal: 1920 },+ height: { ideal: 1080 },+ });+ });++ it("keeps the size negotiable so a 720p-only camera still opens", () => {+ // `exact` would make getUserMedia throw OverconstrainedError on every+ // camera that cannot hit the target, losing the webcam entirely rather+ // than recording it a little smaller.+ const constraints = webcamVideoConstraints(undefined, "2160p");++ expect(constraints.width).not.toHaveProperty("exact");+ expect(constraints.height).not.toHaveProperty("exact");+ expect(constraints.width).not.toHaveProperty("min");+ expect(constraints.height).not.toHaveProperty("min");+ });++ it("still pins the chosen device and caps the frame rate", () => {+ const constraints = webcamVideoConstraints("camera-7", "1440p");++ expect(constraints.deviceId).toEqual({ exact: "camera-7" });+ expect(constraints.frameRate).toEqual({+ ideal: WEBCAM_TARGET_FRAME_RATE,+ max: WEBCAM_TARGET_FRAME_RATE,+ });+ });++ it("omits deviceId entirely when no camera was chosen", () => {+ expect(webcamVideoConstraints(undefined, "1080p")).not.toHaveProperty("deviceId");+ });++ it("falls back to the default preset rather than an unconstrained request", () => {+ // An unrecognised stored value must not reopen the 640x480 hole.+ expect(webcamVideoConstraints(undefined, undefined)).toEqual(+ webcamVideoConstraints(undefined, DEFAULT_WEBCAM_QUALITY),+ );+ });+});++describe("webcamQualityFrom", () => {+ it("accepts every advertised preset", () => {+ for (const id of WEBCAM_QUALITY_IDS) {+ expect(webcamQualityFrom(id)).toBe(id);+ }+ });++ it("rejects anything else, including settings files from a future build", () => {+ expect(webcamQualityFrom("4320p")).toBe(DEFAULT_WEBCAM_QUALITY);+ expect(webcamQualityFrom(undefined)).toBe(DEFAULT_WEBCAM_QUALITY);+ expect(webcamQualityFrom(null)).toBe(DEFAULT_WEBCAM_QUALITY);+ expect(webcamQualityFrom(1080)).toBe(DEFAULT_WEBCAM_QUALITY);+ });+});++describe("webcamPresetFor", () => {+ it("never returns a size below 1080p", () => {+ for (const id of WEBCAM_QUALITY_IDS) {+ const preset = webcamPresetFor(id);+ expect(preset.width).toBeGreaterThanOrEqual(1920);+ expect(preset.height).toBeGreaterThanOrEqual(1080);+ }+ expect(Object.keys(WEBCAM_QUALITY_PRESETS)).toEqual([...WEBCAM_QUALITY_IDS]);+ });+});++describe("webcamBitrateFor", () => {+ it("scales with the frame the camera actually delivers", () => {+ // A flat rate sized for 640x480 is what made the extra pixels pointless:+ // starve a 2160p frame and it blocks up worse than a clean 1080p one.+ expect(webcamBitrateFor(3840, 2160)).toBeGreaterThan(webcamBitrateFor(2560, 1440));+ expect(webcamBitrateFor(2560, 1440)).toBeGreaterThan(webcamBitrateFor(1920, 1080));+ expect(webcamBitrateFor(1920, 1080)).toBeGreaterThan(webcamBitrateFor(1280, 720));+ expect(webcamBitrateFor(1280, 720)).toBeGreaterThan(webcamBitrateFor(640, 480));+ });++ it("gives 4K enough headroom to be worth capturing", () => {+ expect(webcamBitrateFor(3840, 2160)).toBe(40_000_000);+ });++ it("matches the tier boundaries the native helper uses", () => {+ // One pixel under a tier must not claim that tier's rate; the ladder in+ // wgc-capture/src/main.cpp draws the lines at the same places.+ expect(webcamBitrateFor(2560, 1439)).toBe(webcamBitrateFor(1920, 1080));+ expect(webcamBitrateFor(1920, 1079)).toBe(webcamBitrateFor(1280, 720));+ });++ it("rates a small camera by what it delivered, not by what we asked for", () => {+ // The preset is a request. A 720p camera asked for 2160p must not be+ // handed a 4K bitrate it cannot fill.+ expect(webcamBitrateFor(1280, 720)).toBe(8_000_000);+ });++ it("survives a track that reports nothing", () => {+ // getSettings() may omit width/height before the first frame arrives.+ const preset = WEBCAM_QUALITY_PRESETS[DEFAULT_WEBCAM_QUALITY];+ expect(webcamBitrateFor(undefined, undefined)).toBe(+ webcamBitrateFor(preset.width, preset.height),+ );+ expect(webcamBitrateFor(0, 0)).toBeGreaterThan(0);+ });+});++describe("webcamBitrateForStream", () => {+ const streamWith = (settings: MediaTrackSettings) =>+ ({ getVideoTracks: () => [{ getSettings: () => settings }] }) as unknown as MediaStream;++ it("reads the size off the live track", () => {+ expect(webcamBitrateForStream(streamWith({ width: 2560, height: 1440 }))).toBe(24_000_000);+ });++ it("falls back when there is no stream or no video track", () => {+ expect(webcamBitrateForStream(null)).toBe(webcamBitrateFor(undefined, undefined));+ expect(webcamBitrateForStream({ getVideoTracks: () => [] } as unknown as MediaStream)).toBe(+ webcamBitrateFor(undefined, undefined),+ );+ });+});diff --git a/src/hooks/webcamCaptureTarget.ts b/src/hooks/webcamCaptureTarget.tsnew file mode 100644index 000000000..906412b19--- /dev/null+++ b/src/hooks/webcamCaptureTarget.ts@@ -0,0 +1,104 @@+/**+ * The resolution the webcam is captured at, and the rate it is encoded at.+ *+ * Nothing here used to name a size. `getUserMedia({ video: { deviceId } })` and+ * a Media Foundation source reader left without MF_MT_FRAME_SIZE both fall back+ * to the device's *default* media type, and for a UVC camera that is the first+ * format it enumerates -- 640x480. A Logitech BRIO that offers MJPEG up to+ * 3840x2160 was therefore recorded at 640x480 and then scaled up into the+ * picture-in-picture, which is what "the camera looks pixelated" actually was.+ */++export const WEBCAM_TARGET_FRAME_RATE = 30;++export const WEBCAM_QUALITY_IDS = ["1080p", "1440p", "2160p"] as const;+export type WebcamQualityId = (typeof WEBCAM_QUALITY_IDS)[number];++export interface WebcamQualityPreset {+ id: WebcamQualityId;+ width: number;+ height: number;+}++/**+ * Sizes are a *request*, never a floor. A camera that tops out below the chosen+ * preset is driven at the best format it has; the native helper picks that with+ * `chooseWebcamFormat`, and the browser does it through `ideal` constraints.+ *+ * Measured on a BRIO (Snapdragon X, alongside a screen capture), 8s takes,+ * frames the camera actually delivered out of 240, over four runs each:+ * 1080p 244 14.2 Mbit/s 4/4+ * 1440p 242-244 21.9 Mbit/s 4/4+ * 2160p 243-244 38.4 Mbit/s 4/4+ *+ * All three run at the camera's full rate. That is recent: driving the capture+ * as RGB32 made Media Foundation decode and convert every frame, costing 92ms+ * per 2160p frame -- a ceiling near 11 fps, inside a file whose container still+ * claimed 30 because the encoder padded the gap with duplicates. The capture+ * now asks for NV12, which the camera produces directly and the encoder+ * consumes directly; see webcam_capture.cpp. Higher presets cost file size, not+ * frames, which is why this is a user choice.+ */+export const WEBCAM_QUALITY_PRESETS: Record<WebcamQualityId, WebcamQualityPreset> = {+ "1080p": { id: "1080p", width: 1920, height: 1080 },+ "1440p": { id: "1440p", width: 2560, height: 1440 },+ "2160p": { id: "2160p", width: 3840, height: 2160 },+};++export const DEFAULT_WEBCAM_QUALITY: WebcamQualityId = "2160p";++/** Narrows a persisted or IPC-delivered value to a preset we can act on. */+export function webcamQualityFrom(value: unknown): WebcamQualityId {+ return WEBCAM_QUALITY_IDS.includes(value as WebcamQualityId)+ ? (value as WebcamQualityId)+ : DEFAULT_WEBCAM_QUALITY;+}++export function webcamPresetFor(quality: WebcamQualityId | undefined): WebcamQualityPreset {+ return WEBCAM_QUALITY_PRESETS[webcamQualityFrom(quality)];+}++/**+ * Video constraints for a webcam stream, optionally pinned to one device.+ *+ * Sizes are `ideal`, never `exact` or `min`: a camera that tops out at 720p has+ * to keep working. `exact` turns "record it a bit smaller" into+ * OverconstrainedError, and the recording then has no camera at all.+ */+export function webcamVideoConstraints(+ deviceId: string | undefined,+ quality?: WebcamQualityId,+): MediaTrackConstraints {+ const preset = webcamPresetFor(quality);+ return {+ ...(deviceId ? { deviceId: { exact: deviceId } } : {}),+ width: { ideal: preset.width },+ height: { ideal: preset.height },+ frameRate: { ideal: WEBCAM_TARGET_FRAME_RATE, max: WEBCAM_TARGET_FRAME_RATE },+ };+}++/**+ * Encoder bitrate for a frame the camera actually delivered.+ *+ * Keyed off the delivered size rather than the requested preset: a 720p camera+ * asked for 2160p must not be encoded as if it were 4K. The tiers mirror the+ * native ladder in electron/native/wgc-capture/src/main.cpp -- keep them in step.+ */+export function webcamBitrateFor(width: number | undefined, height: number | undefined): number {+ const preset = WEBCAM_QUALITY_PRESETS[DEFAULT_WEBCAM_QUALITY];+ const pixels =+ width && height && width > 0 && height > 0 ? width * height : preset.width * preset.height;++ if (pixels >= 3840 * 2160) return 40_000_000;+ if (pixels >= 2560 * 1440) return 24_000_000;+ if (pixels >= 1920 * 1080) return 16_000_000;+ if (pixels >= 1280 * 720) return 8_000_000;+ return 4_000_000;+}++/** The bitrate for whatever the stream's first video track ended up delivering. */+export function webcamBitrateForStream(stream: MediaStream | null): number {+ const settings = stream?.getVideoTracks()[0]?.getSettings();+ return webcamBitrateFor(settings?.width, settings?.height);+}diff --git a/src/i18n/locales/ar/launch.json b/src/i18n/locales/ar/launch.jsonindex 2b3db0f7e..b1dc21aff 100644--- a/src/i18n/locales/ar/launch.json+++ b/src/i18n/locales/ar/launch.json@@ -50,7 +50,11 @@"noneFound": "لم يتم العثور على كاميرا","unavailable": "الكاميرا غير متوفرة","camera": "الكاميرا",- "cameraDevice": "جهاز الكاميرا"+ "cameraDevice": "جهاز الكاميرا",+ "quality": "جودة الكاميرا",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"sourceSelector": {"loading": "جاري تحميل المصادر...",diff --git a/src/i18n/locales/cs/launch.json b/src/i18n/locales/cs/launch.jsonindex b3ae9a56f..d4d3f3104 100644--- a/src/i18n/locales/cs/launch.json+++ b/src/i18n/locales/cs/launch.json@@ -50,7 +50,11 @@"noneFound": "Kamera nenalezena","unavailable": "Kamera nedostupná","camera": "Kamera",- "cameraDevice": "Zařízení kamery"+ "cameraDevice": "Zařízení kamery",+ "quality": "Kvalita kamery",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Použít upravitelný kurzor: znovu zapne automatické přiblížení a efekty kurzoru",diff --git a/src/i18n/locales/de/launch.json b/src/i18n/locales/de/launch.jsonindex 81c6eeec0..8d199afaa 100644--- a/src/i18n/locales/de/launch.json+++ b/src/i18n/locales/de/launch.json@@ -50,7 +50,11 @@"noneFound": "Keine Kamera gefunden","unavailable": "Kamera nicht verfügbar","camera": "Kamera",- "cameraDevice": "Kameragerät"+ "cameraDevice": "Kameragerät",+ "quality": "Kameraqualität",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Bearbeitbaren Cursor verwenden: schaltet Auto-Zoom und Cursor-Effekte wieder ein",diff --git a/src/i18n/locales/en/launch.json b/src/i18n/locales/en/launch.jsonindex 3963513c3..e02d96f8e 100644--- a/src/i18n/locales/en/launch.json+++ b/src/i18n/locales/en/launch.json@@ -50,7 +50,11 @@"noneFound": "No camera found","unavailable": "Camera unavailable","camera": "Camera",- "cameraDevice": "Camera device"+ "cameraDevice": "Camera device",+ "quality": "Camera quality",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Use editable cursor: turns auto zoom and cursor effects back on",diff --git a/src/i18n/locales/es/launch.json b/src/i18n/locales/es/launch.jsonindex 348f42b5e..34965561c 100644--- a/src/i18n/locales/es/launch.json+++ b/src/i18n/locales/es/launch.json@@ -50,7 +50,11 @@"noneFound": "No se encontró cámara","unavailable": "Cámara no disponible","camera": "Cámara",- "cameraDevice": "Dispositivo de cámara"+ "cameraDevice": "Dispositivo de cámara",+ "quality": "Calidad de la cámara",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Usar cursor editable: vuelve a activar el zoom automático y los efectos del cursor",diff --git a/src/i18n/locales/fr/launch.json b/src/i18n/locales/fr/launch.jsonindex 5782d07e6..3a8d35690 100644--- a/src/i18n/locales/fr/launch.json+++ b/src/i18n/locales/fr/launch.json@@ -50,7 +50,11 @@"noneFound": "Aucune caméra trouvée","unavailable": "Caméra non disponible","camera": "Caméra",- "cameraDevice": "Périphérique caméra"+ "cameraDevice": "Périphérique caméra",+ "quality": "Qualité de la caméra",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Utiliser le curseur éditable : réactive le zoom automatique et les effets de curseur",diff --git a/src/i18n/locales/it/launch.json b/src/i18n/locales/it/launch.jsonindex 2c863de0f..fae376c8d 100644--- a/src/i18n/locales/it/launch.json+++ b/src/i18n/locales/it/launch.json@@ -50,7 +50,11 @@"noneFound": "Nessuna fotocamera trovata","unavailable": "Fotocamera non disponibile","camera": "Fotocamera",- "cameraDevice": "Dispositivo fotocamera"+ "cameraDevice": "Dispositivo fotocamera",+ "quality": "Qualità della fotocamera",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Usa cursore modificabile: riattiva lo zoom automatico e gli effetti del cursore",diff --git a/src/i18n/locales/ja-JP/launch.json b/src/i18n/locales/ja-JP/launch.jsonindex 20c7e0530..0429770d8 100644--- a/src/i18n/locales/ja-JP/launch.json+++ b/src/i18n/locales/ja-JP/launch.json@@ -50,7 +50,11 @@"noneFound": "カメラが見つかりません","unavailable": "カメラが利用できません","camera": "カメラ",- "cameraDevice": "カメラデバイス"+ "cameraDevice": "カメラデバイス",+ "quality": "カメラの画質",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "編集可能なカーソルを使う:自動ズームとカーソル効果が再びオンになります",diff --git a/src/i18n/locales/ko-KR/launch.json b/src/i18n/locales/ko-KR/launch.jsonindex 1aef23e07..70f0886dc 100644--- a/src/i18n/locales/ko-KR/launch.json+++ b/src/i18n/locales/ko-KR/launch.json@@ -50,7 +50,11 @@"noneFound": "카메라를 찾을 수 없음","unavailable": "카메라를 사용할 수 없음","camera": "카메라",- "cameraDevice": "카메라 장치"+ "cameraDevice": "카메라 장치",+ "quality": "카메라 화질",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "편집 가능한 커서 사용: 자동 줌과 커서 효과가 다시 켜집니다",diff --git a/src/i18n/locales/pt-BR/launch.json b/src/i18n/locales/pt-BR/launch.jsonindex 35aedb23a..0ed727214 100644--- a/src/i18n/locales/pt-BR/launch.json+++ b/src/i18n/locales/pt-BR/launch.json@@ -50,7 +50,11 @@"noneFound": "Nenhuma câmera encontrada","unavailable": "Câmera indisponível","camera": "Câmera",- "cameraDevice": "Dispositivo de câmera"+ "cameraDevice": "Dispositivo de câmera",+ "quality": "Qualidade da câmera",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Usar cursor editável: reativa o zoom automático e os efeitos do cursor",diff --git a/src/i18n/locales/ru/launch.json b/src/i18n/locales/ru/launch.jsonindex 48ca06b7e..67ebf3da8 100644--- a/src/i18n/locales/ru/launch.json+++ b/src/i18n/locales/ru/launch.json@@ -50,7 +50,11 @@"noneFound": "Камера не найдена","unavailable": "Камера недоступна","camera": "Камера",- "cameraDevice": "Устройство камеры"+ "cameraDevice": "Устройство камеры",+ "quality": "Качество камеры",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"sourceSelector": {"loading": "Загрузка источников...",diff --git a/src/i18n/locales/tr/launch.json b/src/i18n/locales/tr/launch.jsonindex e919ba448..7df10beb9 100644--- a/src/i18n/locales/tr/launch.json+++ b/src/i18n/locales/tr/launch.json@@ -50,7 +50,11 @@"noneFound": "Kamera bulunamadı","unavailable": "Kamera kullanılamıyor","camera": "Kamera",- "cameraDevice": "Kamera cihazı"+ "cameraDevice": "Kamera cihazı",+ "quality": "Kamera kalitesi",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "Düzenlenebilir imleci kullan: otomatik yakınlaştırmayı ve imleç efektlerini yeniden açar",diff --git a/src/i18n/locales/vi/launch.json b/src/i18n/locales/vi/launch.jsonindex 4bc27b80a..a76f0db84 100644--- a/src/i18n/locales/vi/launch.json+++ b/src/i18n/locales/vi/launch.json@@ -50,7 +50,11 @@"noneFound": "Không tìm thấy máy ảnh","unavailable": "Máy ảnh không khả dụng","camera": "Máy ảnh",- "cameraDevice": "Thiết bị máy ảnh"+ "cameraDevice": "Thiết bị máy ảnh",+ "quality": "Chất lượng camera",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"sourceSelector": {"loading": "Đang tải nguồn...",diff --git a/src/i18n/locales/zh-CN/launch.json b/src/i18n/locales/zh-CN/launch.jsonindex 4ee356acf..7a0b26cb9 100644--- a/src/i18n/locales/zh-CN/launch.json+++ b/src/i18n/locales/zh-CN/launch.json@@ -50,7 +50,11 @@"noneFound": "未找到摄像头","unavailable": "摄像头不可用","camera": "摄像头",- "cameraDevice": "摄像头设备"+ "cameraDevice": "摄像头设备",+ "quality": "摄像头画质",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "使用可编辑光标:将重新开启自动缩放和光标效果",diff --git a/src/i18n/locales/zh-TW/launch.json b/src/i18n/locales/zh-TW/launch.jsonindex a899f50e0..423d585d6 100644--- a/src/i18n/locales/zh-TW/launch.json+++ b/src/i18n/locales/zh-TW/launch.json@@ -50,7 +50,11 @@"noneFound": "未找到攝影機","unavailable": "攝影機不可用","camera": "攝影機",- "cameraDevice": "攝影機裝置"+ "cameraDevice": "攝影機裝置",+ "quality": "攝影機畫質",+ "quality1080p": "1080p",+ "quality1440p": "1440p",+ "quality2160p": "4K"},"cursor": {"useEditableCursorHint": "使用可編輯游標:將重新開啟自動縮放與游標效果",