A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(desktop): reuse window capture items on Windows 10 (#3449)
Hampus8cac3b35c914
diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yamlindex 571343715..aeb0f78a1 100644--- a/.github/workflows/tests.yaml+++ b/.github/workflows/tests.yaml@@ -117,6 +117,7 @@ jobs:with:toolchain: "1.98.1"components: clippy, rustfmt+ targets: x86_64-pc-windows-msvc- name: Install pnpmuses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413@@ -208,7 +209,7 @@ jobs:- name: Clippy (warnings as errors)run: cargo clippy --workspace --all-targets --all-features --locked -- -D warnings- - name: Clippy (desktop native workspaces on Linux, warnings as errors)+ - name: Clippy (desktop native workspaces on Linux and Windows backends, warnings as errors)run: tools/ci/check-desktop-native-workspaces.sh clippy- name: Verify the source-built ffmpeg CLI is on PATHdiff --git a/fluxer_desktop/native/win-game-capture/Cargo.toml b/fluxer_desktop/native/win-game-capture/Cargo.tomlindex b9a83a37c..ba6f985d2 100644--- a/fluxer_desktop/native/win-game-capture/Cargo.toml+++ b/fluxer_desktop/native/win-game-capture/Cargo.toml@@ -19,7 +19,9 @@ napi-derive = "3.6.7"windows = {version = "0.62.2", features = ["Win32_Foundation","Win32_System_LibraryLoader",+ "Win32_System_Memory","Win32_System_Threading",+ "Win32_System_WinRT_Graphics_Capture",]}[build-dependencies]diff --git a/fluxer_desktop/native/win-game-capture/index.d.ts b/fluxer_desktop/native/win-game-capture/index.d.tsindex 3efa35421..b028ea259 100644--- a/fluxer_desktop/native/win-game-capture/index.d.ts+++ b/fluxer_desktop/native/win-game-capture/index.d.ts@@ -2,4 +2,6 @@export declare function elevateGpuSchedulingPriority(processId?: number, priorityClass?: 'high' | 'realtime'): boolean;export declare function restoreGpuSchedulingPriority(processId?: number): boolean;+export declare function reuseWindowCaptureItems(): boolean;+export declare function windowCaptureItemCalls(): {forwarded: number; reused: number} | null;export declare const loadError: Error | null;diff --git a/fluxer_desktop/native/win-game-capture/index.js b/fluxer_desktop/native/win-game-capture/index.jsindex cf25831fe..571182460 100644--- a/fluxer_desktop/native/win-game-capture/index.js+++ b/fluxer_desktop/native/win-game-capture/index.js@@ -94,9 +94,27 @@ function restoreGpuSchedulingPriority(processId) {}}+function reuseWindowCaptureItems() {+ if (!binding) return false;+ try {+ binding.reuseWindowCaptureItems();+ return true;+ } catch (error) {+ console.warn('[win-game-capture] reuseWindowCaptureItems failed:', error?.message || error);+ return false;+ }+}++function windowCaptureItemCalls() {+ if (!binding) return null;+ return binding.windowCaptureItemCalls();+}+module.exports = {elevateGpuSchedulingPriority,restoreGpuSchedulingPriority,+ reuseWindowCaptureItems,+ windowCaptureItemCalls,get loadError() {return loadError;},diff --git a/fluxer_desktop/native/win-game-capture/package.json b/fluxer_desktop/native/win-game-capture/package.jsonindex 8e7f50026..c76c41fdf 100644--- a/fluxer_desktop/native/win-game-capture/package.json+++ b/fluxer_desktop/native/win-game-capture/package.json@@ -1,7 +1,7 @@{"name": "@fluxer/win-game-capture","version": "0.0.0",- "description": "Native Windows GPU scheduling priority helpers",+ "description": "Native Windows GPU scheduling priority and window capture item helpers","private": true,"license": "AGPL-3.0-or-later","os": [diff --git a/fluxer_desktop/native/win-game-capture/src/capture_item_reuse.rs b/fluxer_desktop/native/win-game-capture/src/capture_item_reuse.rsnew file mode 100644index 000000000..c15e57b86--- /dev/null+++ b/fluxer_desktop/native/win-game-capture/src/capture_item_reuse.rs@@ -0,0 +1,204 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++use crate::live_items::{LiveItems, WeakItem};+use std::{+ cell::RefCell,+ ffi::c_void,+ mem::{offset_of, size_of},+ sync::{+ OnceLock,+ atomic::{AtomicPtr, AtomicU64, Ordering},+ },+};+use windows::{+ Win32::{+ Foundation::{HMODULE, HWND},+ System::{+ LibraryLoader::{+ GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_PIN,+ GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, GetModuleHandleExW,+ },+ Memory::{PAGE_PROTECTION_FLAGS, PAGE_READWRITE, VirtualProtect},+ WinRT::{+ Graphics::Capture::{+ IGraphicsCaptureItemInterop, IGraphicsCaptureItemInterop_Vtbl,+ },+ RoGetActivationFactory,+ },+ },+ },+ core::{GUID, HRESULT, IUnknown, Interface, PCWSTR, Weak, h, w},+};++type CreateForWindow =+ unsafe extern "system" fn(*mut c_void, HWND, *const GUID, *mut *mut c_void) -> HRESULT;++const _: () = assert!(+ offset_of!(IGraphicsCaptureItemInterop_Vtbl, CreateForWindow) == 3 * size_of::<usize>()+);+const _: () = assert!(size_of::<CreateForWindow>() == size_of::<*mut c_void>());++static INSTALLED: OnceLock<Result<(), String>> = OnceLock::new();+static CREATE_FOR_WINDOW_ORIGINAL: OnceLock<CreateForWindow> = OnceLock::new();+static CALLS_FORWARDED: AtomicU64 = AtomicU64::new(0);+static CALLS_REUSED: AtomicU64 = AtomicU64::new(0);++pub struct CreateForWindowCalls {+ pub forwarded: u64,+ pub reused: u64,+}++thread_local! {+ static LIVE_ITEMS: RefCell<LiveItems<Weak<IUnknown>>> =+ const { RefCell::new(LiveItems::new()) };+}++impl WeakItem for Weak<IUnknown> {+ type Strong = IUnknown;++ fn upgrade(&self) -> Option<IUnknown> {+ Weak::upgrade(self)+ }+}++fn live_item(window: isize) -> Option<IUnknown> {+ LIVE_ITEMS+ .try_with(|items| items.try_borrow_mut().ok()?.lookup(window))+ .ok()+ .flatten()+}++fn remember_item(window: isize, item: &IUnknown) {+ let Ok(weak) = item.downgrade() else {+ return;+ };+ let _ = LIVE_ITEMS.try_with(|items| {+ if let Ok(mut items) = items.try_borrow_mut() {+ items.remember(window, weak);+ }+ });+}++unsafe fn reuse_live_item(+ window: isize,+ iid: *const GUID,+ result: *mut *mut c_void,+) -> Option<HRESULT> {+ if iid.is_null() {+ return None;+ }+ if result.is_null() {+ return None;+ }+ let item = live_item(window)?;+ let reused = unsafe { item.query(iid, result) };+ reused.is_ok().then_some(reused)+}++unsafe extern "system" fn create_for_window_reusing_live_item(+ this: *mut c_void,+ window: HWND,+ iid: *const GUID,+ result: *mut *mut c_void,+) -> HRESULT {+ let Some(original) = CREATE_FOR_WINDOW_ORIGINAL.get().copied() else {+ unreachable!("the slot is replaced only after the original is recorded");+ };+ let window_key = window.0 as isize;+ if let Some(reused) = unsafe { reuse_live_item(window_key, iid, result) } {+ CALLS_REUSED.fetch_add(1, Ordering::Relaxed);+ return reused;+ }+ CALLS_FORWARDED.fetch_add(1, Ordering::Relaxed);+ let created = unsafe { original(this, window, iid, result) };+ if created.is_err() {+ return created;+ }+ if result.is_null() {+ return created;+ }+ if let Some(item) = unsafe { IUnknown::from_raw_borrowed(&*result) } {+ remember_item(window_key, item);+ }+ created+}++fn module_at(address: *const c_void, flags: u32) -> Result<HMODULE, String> {+ let mut module = HMODULE::default();+ unsafe {+ GetModuleHandleExW(+ GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | flags,+ PCWSTR(address.cast()),+ &mut module,+ )+ }+ .map_err(|error| format!("GetModuleHandleExW(address): {error}"))?;+ Ok(module)+}++fn pin_modules(slot: *const c_void) -> Result<(), String> {+ let mut graphics_capture = HMODULE::default();+ unsafe {+ GetModuleHandleExW(+ GET_MODULE_HANDLE_EX_FLAG_PIN,+ w!("GraphicsCapture.dll"),+ &mut graphics_capture,+ )+ }+ .map_err(|error| format!("GetModuleHandleExW(GraphicsCapture.dll): {error}"))?;+ if module_at(slot, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT)? != graphics_capture {+ return Err("capture item factory vtable is outside GraphicsCapture.dll".into());+ }+ let replacement: CreateForWindow = create_for_window_reusing_live_item;+ module_at(replacement as *const c_void, GET_MODULE_HANDLE_EX_FLAG_PIN)?;+ Ok(())+}++fn replace_slot(slot: *mut CreateForWindow, original: CreateForWindow) -> Result<(), String> {+ let replacement: CreateForWindow = create_for_window_reusing_live_item;+ let size = size_of::<CreateForWindow>();+ let mut protection = PAGE_PROTECTION_FLAGS(0);+ unsafe { VirtualProtect(slot.cast(), size, PAGE_READWRITE, &mut protection) }+ .map_err(|error| format!("VirtualProtect(PAGE_READWRITE): {error}"))?;+ let slot_value = unsafe { AtomicPtr::<c_void>::from_ptr(slot.cast()) };+ slot_value.store(replacement as *mut c_void, Ordering::Release);+ let mut replaced = PAGE_PROTECTION_FLAGS(0);+ let restored = unsafe { VirtualProtect(slot.cast(), size, protection, &mut replaced) };+ if let Err(error) = restored {+ slot_value.store(original as *mut c_void, Ordering::Release);+ return Err(format!("VirtualProtect(restore): {error}"));+ }+ Ok(())+}++fn install_once() -> Result<(), String> {+ let interop: IGraphicsCaptureItemInterop =+ unsafe { RoGetActivationFactory(h!("Windows.Graphics.Capture.GraphicsCaptureItem")) }+ .map_err(|error| format!("GraphicsCaptureItem activation factory: {error}"))?;+ let vtable = unsafe {+ *interop+ .as_raw()+ .cast::<*mut IGraphicsCaptureItemInterop_Vtbl>()+ };+ assert!(!vtable.is_null());+ let slot = unsafe { &raw mut (*vtable).CreateForWindow };+ pin_modules(slot.cast())?;+ let original = unsafe { slot.read() };+ let replacement: CreateForWindow = create_for_window_reusing_live_item;+ assert!(!std::ptr::fn_addr_eq(original, replacement));+ CREATE_FOR_WINDOW_ORIGINAL+ .set(original)+ .map_err(|_| "CreateForWindow original already recorded".to_string())?;+ replace_slot(slot, original)+}++pub fn install() -> Result<(), String> {+ INSTALLED.get_or_init(install_once).clone()+}++pub fn create_for_window_calls() -> CreateForWindowCalls {+ CreateForWindowCalls {+ forwarded: CALLS_FORWARDED.load(Ordering::Relaxed),+ reused: CALLS_REUSED.load(Ordering::Relaxed),+ }+}diff --git a/fluxer_desktop/native/win-game-capture/src/lib.rs b/fluxer_desktop/native/win-game-capture/src/lib.rsindex 89a035bd0..7eed1e439 100644--- a/fluxer_desktop/native/win-game-capture/src/lib.rs+++ b/fluxer_desktop/native/win-game-capture/src/lib.rs@@ -2,7 +2,11 @@#![deny(clippy::all)]+#[cfg(target_os = "windows")]+mod capture_item_reuse;mod gpu_priority;+#[cfg(any(target_os = "windows", test))]+mod live_items;use napi::bindgen_prelude::*;use napi_derive::napi;@@ -19,3 +23,33 @@ pub fn elevate_gpu_scheduling_priority(pub fn restore_gpu_scheduling_priority(process_id: Option<u32>) -> Result<()> {gpu_priority::restore(process_id).map_err(napi::Error::from_reason)}++#[napi(object)]+pub struct WindowCaptureItemCalls {+ pub forwarded: i64,+ pub reused: i64,+}++#[napi(js_name = "reuseWindowCaptureItems")]+pub fn reuse_window_capture_items() -> Result<()> {+ #[cfg(target_os = "windows")]+ capture_item_reuse::install().map_err(napi::Error::from_reason)?;+ Ok(())+}++#[napi(js_name = "windowCaptureItemCalls")]+pub fn window_capture_item_calls() -> WindowCaptureItemCalls {+ #[cfg(target_os = "windows")]+ {+ let calls = capture_item_reuse::create_for_window_calls();+ WindowCaptureItemCalls {+ forwarded: i64::try_from(calls.forwarded).unwrap_or(i64::MAX),+ reused: i64::try_from(calls.reused).unwrap_or(i64::MAX),+ }+ }+ #[cfg(not(target_os = "windows"))]+ WindowCaptureItemCalls {+ forwarded: 0,+ reused: 0,+ }+}diff --git a/fluxer_desktop/native/win-game-capture/src/live_items.rs b/fluxer_desktop/native/win-game-capture/src/live_items.rsnew file mode 100644index 000000000..cc4b56bb0--- /dev/null+++ b/fluxer_desktop/native/win-game-capture/src/live_items.rs@@ -0,0 +1,305 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++pub const LIVE_ITEMS_MAX: usize = 8;++pub trait WeakItem {+ type Strong;++ fn upgrade(&self) -> Option<Self::Strong>;+}++struct LiveItem<W> {+ window: isize,+ weak: W,+ used_at: u64,+}++pub struct LiveItems<W> {+ slots: [Option<LiveItem<W>>; LIVE_ITEMS_MAX],+ uses: u64,+}++impl<W: WeakItem> LiveItems<W> {+ pub const fn new() -> Self {+ Self {+ slots: [const { None }; LIVE_ITEMS_MAX],+ uses: 0,+ }+ }++ pub fn lookup(&mut self, window: isize) -> Option<W::Strong> {+ let used_at = self.next_use();+ for slot in &mut self.slots {+ let Some(item) = slot else {+ continue;+ };+ if item.window != window {+ continue;+ }+ match item.weak.upgrade() {+ Some(strong) => {+ item.used_at = used_at;+ return Some(strong);+ }+ None => *slot = None,+ }+ }+ None+ }++ pub fn remember(&mut self, window: isize, weak: W) {+ let used_at = self.next_use();+ let index = self.vacant_index();+ assert!(index < LIVE_ITEMS_MAX);+ self.slots[index] = Some(LiveItem {+ window,+ weak,+ used_at,+ });+ }++ fn next_use(&mut self) -> u64 {+ assert!(self.uses < u64::MAX);+ self.uses += 1;+ self.uses+ }++ fn vacant_index(&self) -> usize {+ let mut least_recently_used = 0;+ let mut least_recent_use = u64::MAX;+ for (index, slot) in self.slots.iter().enumerate() {+ let Some(item) = slot else {+ return index;+ };+ if item.weak.upgrade().is_none() {+ return index;+ }+ if item.used_at < least_recent_use {+ least_recent_use = item.used_at;+ least_recently_used = index;+ }+ }+ least_recently_used+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::rc::{Rc, Weak};++ const FRAMES_IN_HALF_AN_HOUR_AT_30_FPS: u32 = 30 * 60 * 30;++ impl WeakItem for Weak<isize> {+ type Strong = Rc<isize>;++ fn upgrade(&self) -> Option<Rc<isize>> {+ Weak::upgrade(self)+ }+ }++ struct CaptureService {+ items_created: u32,+ live: LiveItems<Weak<isize>>,+ }++ impl CaptureService {+ fn new() -> Self {+ Self {+ items_created: 0,+ live: LiveItems::new(),+ }+ }++ fn create_for_window(&mut self, window: isize) -> Rc<isize> {+ if let Some(item) = self.live.lookup(window) {+ return item;+ }+ self.items_created += 1;+ let item = Rc::new(window);+ self.live.remember(window, Rc::downgrade(&item));+ item+ }++ fn occupied_count(&self) -> usize {+ self.live.slots.iter().flatten().count()+ }+ }++ #[test]+ fn per_frame_probes_reuse_the_item_the_share_holds() {+ let mut service = CaptureService::new();+ drop(service.create_for_window(0x1234));+ let share_item = service.create_for_window(0x1234);+ assert_eq!(service.items_created, 2);+ for _ in 0..FRAMES_IN_HALF_AN_HOUR_AT_30_FPS {+ let probe = service.create_for_window(0x1234);+ assert!(Rc::ptr_eq(&probe, &share_item));+ }+ assert_eq!(service.items_created, 2);+ assert_eq!(Rc::strong_count(&share_item), 1);+ }++ #[test]+ fn probes_without_a_held_item_each_create_one() {+ let mut service = CaptureService::new();+ for _ in 0..100 {+ drop(service.create_for_window(7));+ }+ assert_eq!(service.items_created, 100);+ assert_eq!(service.occupied_count(), 1);+ }++ #[test]+ fn a_new_share_of_the_same_window_creates_a_new_item() {+ let mut service = CaptureService::new();+ drop(service.create_for_window(9));+ let second_share_item = service.create_for_window(9);+ assert_eq!(service.items_created, 2);+ drop(second_share_item);+ assert!(service.live.lookup(9).is_none());+ assert_eq!(service.occupied_count(), 0);+ }++ #[test]+ fn windows_never_share_an_item() {+ let mut service = CaptureService::new();+ let first = service.create_for_window(1);+ let second = service.create_for_window(2);+ assert!(!Rc::ptr_eq(&first, &second));+ assert!(Rc::ptr_eq(&service.create_for_window(1), &first));+ assert!(Rc::ptr_eq(&service.create_for_window(2), &second));+ assert_eq!(service.items_created, 2);+ }++ #[test]+ fn a_dead_slot_is_reused_before_a_live_one_is_evicted() {+ let mut service = CaptureService::new();+ let held: Vec<_> = (0..LIVE_ITEMS_MAX as isize)+ .map(|window| service.create_for_window(window))+ .collect();+ drop(service.create_for_window(100));+ let newest = service.create_for_window(101);+ assert_eq!(service.occupied_count(), LIVE_ITEMS_MAX);+ assert!(Rc::ptr_eq(&service.create_for_window(101), &newest));+ for (window, item) in held.iter().enumerate().skip(1) {+ assert!(Rc::ptr_eq(+ &service.create_for_window(window as isize),+ item+ ));+ }+ }++ #[test]+ fn a_window_probed_every_frame_outlives_more_held_items_than_slots() {+ let mut service = CaptureService::new();+ drop(service.create_for_window(1));+ let editor_item = service.create_for_window(1);+ let mut slide_show_items = Vec::new();+ for slide_show in 0..(LIVE_ITEMS_MAX as isize * 3) {+ let slide_show_window = 100 + slide_show;+ drop(service.create_for_window(slide_show_window));+ let slide_show_item = service.create_for_window(slide_show_window);+ for _ in 0..30 {+ let probe = service.create_for_window(slide_show_window);+ assert!(Rc::ptr_eq(&probe, &slide_show_item));+ }+ slide_show_items.push(slide_show_item);+ let items_created = service.items_created;+ for _ in 0..30 {+ let probe = service.create_for_window(1);+ assert!(Rc::ptr_eq(&probe, &editor_item));+ }+ assert_eq!(service.items_created, items_created);+ }+ assert_eq!(service.items_created, 2 + 2 * LIVE_ITEMS_MAX as u32 * 3);+ assert_eq!(service.occupied_count(), LIVE_ITEMS_MAX);+ }++ #[test]+ fn the_least_recently_used_held_item_is_the_one_evicted() {+ for unused in 0..LIVE_ITEMS_MAX as isize {+ let mut service = CaptureService::new();+ let held: Vec<_> = (0..LIVE_ITEMS_MAX as isize)+ .map(|window| service.create_for_window(window))+ .collect();+ for window in (0..LIVE_ITEMS_MAX as isize).filter(|window| *window != unused) {+ drop(service.create_for_window(window));+ }+ let newest = service.create_for_window(100);+ assert!(service.live.lookup(unused).is_none());+ assert!(Rc::ptr_eq(&service.create_for_window(100), &newest));+ for window in (0..LIVE_ITEMS_MAX as isize).filter(|window| *window != unused) {+ assert!(Rc::ptr_eq(+ &service.create_for_window(window),+ &held[window as usize]+ ));+ }+ }+ }++ #[test]+ fn a_newly_held_item_is_evicted_after_the_older_ones() {+ let mut service = CaptureService::new();+ let mut held: Vec<_> = (0..LIVE_ITEMS_MAX as isize - 1)+ .map(|window| service.create_for_window(window))+ .collect();+ for window in 0..LIVE_ITEMS_MAX as isize - 1 {+ drop(service.create_for_window(window));+ }+ let newly_held_window = LIVE_ITEMS_MAX as isize - 1;+ held.push(service.create_for_window(newly_held_window));+ let over_the_bound = service.create_for_window(100);+ assert!(service.live.lookup(0).is_none());+ assert!(Rc::ptr_eq(+ &service.create_for_window(newly_held_window),+ &held[newly_held_window as usize]+ ));+ assert!(Rc::ptr_eq(&service.create_for_window(100), &over_the_bound));+ }++ #[test]+ fn random_share_sequences_match_a_reference_model() {+ for seed in 1..=32u64 {+ let mut state = seed.wrapping_mul(0x9E37_79B9_7F4A_7C15);+ let mut service = CaptureService::new();+ let mut held: [Option<Rc<isize>>; LIVE_ITEMS_MAX] = [const { None }; LIVE_ITEMS_MAX];+ let mut items_expected = 0;+ for _ in 0..5_000 {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ let window = (state % LIVE_ITEMS_MAX as u64) as usize;+ let action = (state >> 32) % 8;+ if action == 0 {+ held[window] = None;+ } else if let Some(share_item) = &held[window] {+ let probe = service.create_for_window(window as isize);+ assert!(Rc::ptr_eq(&probe, share_item), "seed {seed}");+ } else {+ items_expected += 1;+ let item = service.create_for_window(window as isize);+ assert_eq!(*item, window as isize, "seed {seed}");+ if action == 1 {+ held[window] = Some(item);+ }+ }+ assert_eq!(service.items_created, items_expected, "seed {seed}");+ for share_item in held.iter().flatten() {+ assert_eq!(Rc::strong_count(share_item), 1, "seed {seed}");+ }+ }+ }+ }++ #[test]+ fn the_table_never_grows_past_its_bound() {+ let mut service = CaptureService::new();+ let held: Vec<_> = (0..(LIVE_ITEMS_MAX as isize * 4))+ .map(|window| service.create_for_window(window))+ .collect();+ assert_eq!(service.occupied_count(), LIVE_ITEMS_MAX);+ drop(held);+ assert!(service.live.lookup(0).is_none());+ }+}diff --git a/fluxer_desktop/src/main/DisplayMedia.ts b/fluxer_desktop/src/main/DisplayMedia.tsindex 97e08b3a1..e99245bbc 100644--- a/fluxer_desktop/src/main/DisplayMedia.ts+++ b/fluxer_desktop/src/main/DisplayMedia.ts@@ -8,6 +8,7 @@ import {} from '@electron/main/DisplayMediaValidation';import {isWaylandSession} from '@electron/main/LinuxSession';import {startWindowsScreenCaptureGuardForSource} from '@electron/main/WindowsScreenCaptureGuard';+import {reuseWindowsCaptureItemsForSource} from '@electron/main/WindowsWindowCaptureItemReuse';import {BrowserWindow, desktopCapturer, ipcMain, screen} from 'electron';import log from 'electron-log';@@ -448,6 +449,7 @@ export function registerDisplayMediaHandlers(): void {withAudio: withAudio === true,});startWindowsScreenCaptureGuardForSource(selectedSource, event.sender);+ reuseWindowsCaptureItemsForSource(selectedSource);const streams: Electron.Streams = {video: selectedSource,};diff --git a/fluxer_desktop/src/main/StreamingPriority.ts b/fluxer_desktop/src/main/StreamingPriority.tsindex 13cf975c6..c3a80d4bc 100644--- a/fluxer_desktop/src/main/StreamingPriority.ts+++ b/fluxer_desktop/src/main/StreamingPriority.ts@@ -3,6 +3,7 @@import {createRequire} from 'node:module';import os from 'node:os';import {stopWindowsScreenCaptureGuard} from '@electron/main/WindowsScreenCaptureGuard';+import {reportWindowsCaptureItemReuse} from '@electron/main/WindowsWindowCaptureItemReuse';import {app, powerSaveBlocker} from 'electron';import log from 'electron-log';@@ -631,6 +632,7 @@ export function releaseStreamingPriority(): void {restoreProcessPriority();restoreGpuSchedulingPriority();stopWindowsScreenCaptureGuard('streaming-priority-release');+ reportWindowsCaptureItemReuse('streaming-priority-release');log.info('[StreamingPriority] Released');}}@@ -645,5 +647,6 @@ export function resetStreamingPriority(): void {restoreProcessPriority();restoreGpuSchedulingPriority();stopWindowsScreenCaptureGuard('streaming-priority-reset');+ reportWindowsCaptureItemReuse('streaming-priority-reset');log.info('[StreamingPriority] Reset');}diff --git a/fluxer_desktop/src/main/WindowsScreenCaptureGuard.ts b/fluxer_desktop/src/main/WindowsScreenCaptureGuard.tsindex 4dfbb4b28..94bfd58ae 100644--- a/fluxer_desktop/src/main/WindowsScreenCaptureGuard.ts+++ b/fluxer_desktop/src/main/WindowsScreenCaptureGuard.ts@@ -21,7 +21,7 @@ function isScreenSource(source: Electron.DesktopCapturerSource): boolean {return source.id.startsWith('screen:');}-function getWindowsBuildNumber(): number | null {+export function getWindowsBuildNumber(): number | null {const build = Number.parseInt(os.release().split('.')[2] ?? '', 10);return Number.isSafeInteger(build) && build > 0 ? build : null;}diff --git a/fluxer_desktop/src/main/WindowsWindowCaptureItemReuse.test.mjs b/fluxer_desktop/src/main/WindowsWindowCaptureItemReuse.test.mjsnew file mode 100644index 000000000..c295bb7eb--- /dev/null+++ b/fluxer_desktop/src/main/WindowsWindowCaptureItemReuse.test.mjs@@ -0,0 +1,139 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import assert from 'node:assert/strict';+import {readFileSync} from 'node:fs';+import {createRequire} from 'node:module';+import {describe, test} from 'node:test';+import {fileURLToPath} from 'node:url';+import vm from 'node:vm';++const require = createRequire(import.meta.url);+const esbuild = require('esbuild');++function transform(fileName) {+ const sourcePath = fileURLToPath(new URL(fileName, import.meta.url));+ return esbuild.transformSync(readFileSync(sourcePath, 'utf8'), {+ loader: 'ts',+ format: 'cjs',+ platform: 'node',+ target: 'node20',+ logLevel: 'silent',+ }).code;+}++const reuseSource = transform('./WindowsWindowCaptureItemReuse.ts');+const nativeAddonSource = transform('./NativeAddon.ts');++function loadReuse({platform = 'win32', windowsBuild = 19045, addon}) {+ const logged = [];+ const calls = {install: 0, loads: 0};+ const counts = {forwarded: 0, reused: 0};+ const fakeAddon = addon ?? {+ loadError: null,+ reuseWindowCaptureItems: () => {+ calls.install += 1;+ return true;+ },+ windowCaptureItemCalls: () => ({...counts}),+ };+ const context = vm.createContext({console, process: {platform, argv: []}});+ const load = (source) => {+ const module = {exports: {}};+ vm.runInContext(`(function (module, exports, require) {${source}\n})`, context)(+ module,+ module.exports,+ fakeRequire,+ );+ return module.exports;+ };+ const fakeRequire = (specifier) => {+ if (specifier === 'node:module') {+ return {+ createRequire: () => (name) => {+ assert.equal(name, '@fluxer/win-game-capture');+ calls.loads += 1;+ return fakeAddon;+ },+ };+ }+ if (specifier === '@electron/main/NativeAddon') return load(nativeAddonSource);+ if (specifier === '@electron/main/LaunchOptions') return {isSafeModeLaunch: () => false};+ if (specifier === '@electron/main/WindowsScreenCaptureGuard') return {getWindowsBuildNumber: () => windowsBuild};+ if (specifier === 'electron-log') {+ const record =+ (level) =>+ (...args) =>+ logged.push([level, ...args]);+ return {info: record('info'), warn: record('warn')};+ }+ throw new Error(`unexpected require ${specifier}`);+ };+ return {...load(reuseSource), calls, counts, logged};+}++const windowSource = {id: 'window:1234:0', name: 'Notepad'};++describe('Windows window capture item reuse', () => {+ test('installs once, only for window shares on Windows 10 2004 to 22H2', () => {+ const cases = [+ [17763, 0],+ [18362, 0],+ [19040, 0],+ [19041, 1],+ [19044, 1],+ [19045, 1],+ [19046, 0],+ [20348, 0],+ [22000, 0],+ [26100, 0],+ [null, 0],+ ];+ for (const [windowsBuild, installs] of cases) {+ const reuse = loadReuse({windowsBuild});+ reuse.reuseWindowsCaptureItemsForSource({id: 'screen:0:0', name: 'Screen 1'});+ assert.equal(reuse.calls.loads, 0, `build ${windowsBuild} screen share`);+ reuse.reuseWindowsCaptureItemsForSource(windowSource);+ reuse.reuseWindowsCaptureItemsForSource({id: 'window:5678:0', name: 'Explorer'});+ assert.equal(reuse.calls.install, installs, `build ${windowsBuild}`);+ assert.equal(reuse.calls.loads, installs, `build ${windowsBuild}`);+ }+ for (const platform of ['darwin', 'linux']) {+ const reuse = loadReuse({platform});+ reuse.reuseWindowsCaptureItemsForSource(windowSource);+ assert.equal(reuse.calls.loads, 0, platform);+ }+ });++ test('reports the capture item requests made since the previous report', () => {+ const reuse = loadReuse({});+ reuse.reuseWindowsCaptureItemsForSource(windowSource);+ Object.assign(reuse.counts, {forwarded: 3, reused: 53999});+ reuse.reportWindowsCaptureItemReuse('streaming-priority-release');+ reuse.reportWindowsCaptureItemReuse('streaming-priority-reset');+ Object.assign(reuse.counts, {forwarded: 6, reused: 54009});+ reuse.reportWindowsCaptureItemReuse('streaming-priority-release');+ const reports = reuse.logged+ .filter(([, message]) => message.includes('since the last report'))+ .map(([, , fields]) => ({...fields}));+ assert.deepEqual(reports, [+ {reason: 'streaming-priority-release', forwardedToCaptureService: 3, reusedFromLiveShare: 53999},+ {reason: 'streaming-priority-release', forwardedToCaptureService: 3, reusedFromLiveShare: 10},+ ]);+ });++ test('a failing addon never throws into the share request', () => {+ const reuse = loadReuse({+ addon: {+ loadError: null,+ reuseWindowCaptureItems: () => {+ throw new Error('binding exploded');+ },+ windowCaptureItemCalls: () => null,+ },+ });+ assert.doesNotThrow(() => reuse.reuseWindowsCaptureItemsForSource(windowSource));+ assert.doesNotThrow(() => reuse.reuseWindowsCaptureItemsForSource(windowSource));+ assert.doesNotThrow(() => reuse.reportWindowsCaptureItemReuse('streaming-priority-release'));+ assert.equal(reuse.logged.filter(([level]) => level === 'warn').length, 1);+ });+});diff --git a/fluxer_desktop/src/main/WindowsWindowCaptureItemReuse.ts b/fluxer_desktop/src/main/WindowsWindowCaptureItemReuse.tsnew file mode 100644index 000000000..7ff34cc80--- /dev/null+++ b/fluxer_desktop/src/main/WindowsWindowCaptureItemReuse.ts@@ -0,0 +1,86 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {createRequire} from 'node:module';+import {isSafeModeLaunch} from '@electron/main/LaunchOptions';+import {loadOptionalNativeAddon} from '@electron/main/NativeAddon';+import {getWindowsBuildNumber} from '@electron/main/WindowsScreenCaptureGuard';+import log from 'electron-log';++const WINDOWS_10_2004_BUILD = 19041;+const WINDOWS_10_22H2_BUILD = 19045;++const requireModule = createRequire(import.meta.url);++interface WindowCaptureItemCalls {+ forwarded: number;+ reused: number;+}++interface WindowCaptureItemReuseModule {+ reuseWindowCaptureItems: () => boolean;+ windowCaptureItemCalls: () => WindowCaptureItemCalls | null;+ loadError?: Error | null;+}++const loadWindowCaptureItemReuseModule = loadOptionalNativeAddon<WindowCaptureItemReuseModule>({+ platform: 'win32',+ disabled: () => isSafeModeLaunch(),+ load: () => requireModule('@fluxer/win-game-capture'),+ logger: log,+ level: 'warn',+ unavailableMessage:+ '[WindowsWindowCaptureItemReuse] Failed to load @fluxer/win-game-capture; window shares create a capture item per frame',+ disabledMessage:+ '[WindowsWindowCaptureItemReuse] Disabled by safe mode; window shares create a capture item per frame',+});++let reuseRequested = false;+let reusingModule: WindowCaptureItemReuseModule | null = null;+let reportedCalls: WindowCaptureItemCalls = {forwarded: 0, reused: 0};++function reusesCaptureItemsOnWindowsBuild(windowsBuild: number | null): windowsBuild is number {+ if (windowsBuild === null) return false;+ return windowsBuild >= WINDOWS_10_2004_BUILD && windowsBuild <= WINDOWS_10_22H2_BUILD;+}++export function reportWindowsCaptureItemReuse(reason: string): void {+ const calls = reusingModule?.windowCaptureItemCalls();+ if (!calls) return;+ const forwarded = calls.forwarded - reportedCalls.forwarded;+ const reused = calls.reused - reportedCalls.reused;+ if (forwarded === 0 && reused === 0) return;+ reportedCalls = calls;+ log.info('[WindowsWindowCaptureItemReuse] Capture item requests since the last report', {+ reason,+ forwardedToCaptureService: forwarded,+ reusedFromLiveShare: reused,+ });+}++export function reuseWindowsCaptureItemsForSource(source: Electron.DesktopCapturerSource): void {+ try {+ reuseCaptureItemsForSource(source);+ } catch (error) {+ log.warn('[WindowsWindowCaptureItemReuse] Window shares create a capture item per frame', {error});+ }+}++function reuseCaptureItemsForSource(source: Electron.DesktopCapturerSource): void {+ if (process.platform !== 'win32') return;+ if (!source.id.startsWith('window:')) return;+ if (reuseRequested) {+ reportWindowsCaptureItemReuse('window-share-start');+ return;+ }+ const windowsBuild = getWindowsBuildNumber();+ if (!reusesCaptureItemsOnWindowsBuild(windowsBuild)) return;+ reuseRequested = true;+ const addon = loadWindowCaptureItemReuseModule();+ if (!addon) return;+ if (!addon.reuseWindowCaptureItems()) {+ log.warn('[WindowsWindowCaptureItemReuse] Window shares create a capture item per frame', {windowsBuild});+ return;+ }+ reusingModule = addon;+ log.info('[WindowsWindowCaptureItemReuse] Window shares ask for their live capture item first', {windowsBuild});+}diff --git a/tools/ci/check-desktop-native-workspaces.sh b/tools/ci/check-desktop-native-workspaces.shindex f4766b29e..7c6ffd75e 100755--- a/tools/ci/check-desktop-native-workspaces.sh+++ b/tools/ci/check-desktop-native-workspaces.sh@@ -9,6 +9,7 @@ native_root="$repo_root/fluxer_desktop/native"cargo_bin="${CARGO_BIN:-cargo}"cargo_deny_bin="${CARGO_DENY_BIN:-cargo-deny}"native_target_dir="${DESKTOP_NATIVE_CARGO_TARGET_DIR:-$repo_root/target/desktop-native-workspaces}"+windows_backend_target="x86_64-pc-windows-msvc"mode="${1:-}"linux_workspaces=(@@ -130,6 +131,21 @@ run_clippy() {-D warnings}+run_clippy_windows_backend() {+ local manifest="$1"++ CARGO_TARGET_DIR="$native_target_dir" \+ "$cargo_bin" clippy \+ --manifest-path "$manifest" \+ --workspace \+ --all-targets \+ --all-features \+ --locked \+ --target "$windows_backend_target" \+ -- \+ -D warnings+}+run_tests() {local manifest="$1"@@ -190,6 +206,7 @@ if [ "$mode" = clippy ] || [ "$mode" = test ]; thenfichecked_count=0+windows_backend_count=0cd "$native_root"@@ -210,9 +227,14 @@ while IFS= read -r manifest; docase "$category" inlinux) printf 'Clippy full Linux/shared coverage: %s\n' "$relative_manifest" ;;macos) printf 'Clippy Linux stub/common coverage; macOS backend not validated: %s\n' "$relative_manifest" ;;- windows) printf 'Clippy Linux stub/common coverage; Windows backend not validated: %s\n' "$relative_manifest" ;;+ windows) printf 'Clippy Linux stub/common coverage: %s\n' "$relative_manifest" ;;esacrun_clippy "$manifest"+ if [ "$category" = windows ]; then+ printf 'Clippy Windows backend coverage for %s: %s\n' "$windows_backend_target" "$relative_manifest"+ run_clippy_windows_backend "$manifest"+ windows_backend_count=$((windows_backend_count + 1))+ fi;;test)case "$category" in@@ -227,5 +249,5 @@ while IFS= read -r manifest; dodone <"$manifest_list"discovered_count=$((linux_count + macos_count + windows_count))-printf 'Desktop native workspace categories: discovered=%s linux-full=%s macos-stub-common=%s windows-stub-common=%s\n' "$discovered_count" "$linux_count" "$macos_count" "$windows_count"-printf 'Desktop native %s summary: checked=%s\n' "$mode" "$checked_count"+printf 'Desktop native workspace categories: discovered=%s linux-full=%s macos-stub-common=%s windows=%s\n' "$discovered_count" "$linux_count" "$macos_count" "$windows_count"+printf 'Desktop native %s summary: checked=%s windows-backend=%s\n' "$mode" "$checked_count" "$windows_backend_count"