Merge pull request #1613 from CapSoftware/cursor/editor-windows-playback-performance-f2d4

richiemcilroy · web-flow · commit f5e712d68b54 · 2026-02-17T23:09:59.000Z
Editor windows playback performance
diff --git a/apps/desktop/src-tauri/src/gpu_context.rs b/apps/desktop/src-tauri/src/gpu_context.rs
@@ -49,6 +49,12 @@ pub struct SharedGpuContext {
 static GPU: OnceCell<Option<SharedGpuContext>> = OnceCell::const_new();
 
 async fn init_gpu_inner() -> Option<SharedGpuContext> {
+    #[cfg(target_os = "windows")]
+    let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+        backends: wgpu::Backends::DX12 | wgpu::Backends::VULKAN,
+        ..Default::default()
+    });
+    #[cfg(not(target_os = "windows"))]
     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
 
     let hardware_adapter = instance
diff --git a/apps/desktop/src/utils/webgpu-renderer.ts b/apps/desktop/src/utils/webgpu-renderer.ts
@@ -81,7 +81,9 @@ export async function isWebGPUSupported(): Promise<boolean> {
 		return false;
 	}
 	try {
-		const adapter = await navigator.gpu.requestAdapter();
+		const adapter = await navigator.gpu.requestAdapter({
+			powerPreference: "high-performance",
+		});
 		return adapter !== null;
 	} catch {
 		return false;
@@ -91,7 +93,9 @@ export async function isWebGPUSupported(): Promise<boolean> {
 export async function initWebGPU(
 	canvas: OffscreenCanvas,
 ): Promise<WebGPURenderer> {
-	const adapter = await navigator.gpu.requestAdapter();
+	const adapter = await navigator.gpu.requestAdapter({
+		powerPreference: "high-performance",
+	});
 	if (!adapter) {
 		throw new Error("No WebGPU adapter available");
 	}
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
@@ -147,20 +147,48 @@ impl Renderer {
                     break;
                 }
             }
-            match frame_renderer
-                .render_immediate(
-                    current.segment_frames,
-                    current.uniforms,
+            let nv12_result = frame_renderer
+                .render_nv12(
+                    current.segment_frames.clone(),
+                    current.uniforms.clone(),
                     &current.cursor,
                     &mut layers,
                 )
-                .await
-            {
-                Ok(frame) => {
-                    (self.frame_cb)(EditorFrameOutput::Rgba(frame));
+                .await;
+
+            match nv12_result {
+                Ok(pipeline_frame) => {
+                    if let Some(prev) = pipeline_frame {
+                        (self.frame_cb)(EditorFrameOutput::Nv12(prev));
+                    }
+                    match frame_renderer.flush_pipeline_nv12().await {
+                        Some(Ok(current_frame)) => {
+                            (self.frame_cb)(EditorFrameOutput::Nv12(current_frame));
+                        }
+                        Some(Err(e)) => {
+                            tracing::warn!(error = %e, "Failed to flush NV12 pipeline frame");
+                        }
+                        None => {}
+                    }
                 }
                 Err(e) => {
-                    tracing::error!(error = %e, "Failed to render frame in editor");
+                    tracing::warn!(error = %e, "NV12 render failed, falling back to RGBA");
+                    match frame_renderer
+                        .render_immediate(
+                            current.segment_frames,
+                            current.uniforms,
+                            &current.cursor,
+                            &mut layers,
+                        )
+                        .await
+                    {
+                        Ok(frame) => {
+                            (self.frame_cb)(EditorFrameOutput::Rgba(frame));
+                        }
+                        Err(e) => {
+                            tracing::error!(error = %e, "Failed to render frame in editor");
+                        }
+                    }
                 }
             }
 
diff --git a/crates/gpu-converters/src/bgra_rgba/mod.rs b/crates/gpu-converters/src/bgra_rgba/mod.rs
@@ -14,6 +14,12 @@ pub struct BGRAToRGBA {
 
 impl BGRAToRGBA {
     pub async fn new() -> Result<Self, GpuConverterError> {
+        #[cfg(target_os = "windows")]
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::DX12 | wgpu::Backends::VULKAN,
+            ..Default::default()
+        });
+        #[cfg(not(target_os = "windows"))]
         let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
 
         let adapter = instance
diff --git a/crates/gpu-converters/src/nv12_rgba/mod.rs b/crates/gpu-converters/src/nv12_rgba/mod.rs
@@ -12,9 +12,14 @@ pub struct NV12ToRGBA {
 impl NV12ToRGBA {
     pub async fn new() -> Self {
         println!("NV12ToRGBA");
+        #[cfg(target_os = "windows")]
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::DX12 | wgpu::Backends::VULKAN,
+            ..Default::default()
+        });
+        #[cfg(not(target_os = "windows"))]
         let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
 
-        // Get adapter for GPU
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
                 power_preference: wgpu::PowerPreference::HighPerformance,
diff --git a/crates/gpu-converters/src/uyvy_rgba/mod.rs b/crates/gpu-converters/src/uyvy_rgba/mod.rs
@@ -14,6 +14,12 @@ pub struct UYVYToRGBA {
 
 impl UYVYToRGBA {
     pub async fn new() -> Self {
+        #[cfg(target_os = "windows")]
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::DX12 | wgpu::Backends::VULKAN,
+            ..Default::default()
+        });
+        #[cfg(not(target_os = "windows"))]
         let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
 
         let adapter = instance
diff --git a/crates/gpu-converters/src/yuyv_nv12/mod.rs b/crates/gpu-converters/src/yuyv_nv12/mod.rs
@@ -11,6 +11,12 @@ pub struct YUYVToNV12 {
 
 impl YUYVToNV12 {
     pub async fn new() -> Result<Self, GpuConverterError> {
+        #[cfg(target_os = "windows")]
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::DX12 | wgpu::Backends::VULKAN,
+            ..Default::default()
+        });
+        #[cfg(not(target_os = "windows"))]
         let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
 
         let adapter = instance
diff --git a/crates/gpu-converters/src/yuyv_rgba/mod.rs b/crates/gpu-converters/src/yuyv_rgba/mod.rs
@@ -13,6 +13,12 @@ pub struct YUYVToRGBA {
 
 impl YUYVToRGBA {
     pub async fn new() -> Result<Self, GpuConverterError> {
+        #[cfg(target_os = "windows")]
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::DX12 | wgpu::Backends::VULKAN,
+            ..Default::default()
+        });
+        #[cfg(not(target_os = "windows"))]
         let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
 
         let adapter = instance
diff --git a/crates/rendering/src/decoder/mod.rs b/crates/rendering/src/decoder/mod.rs
@@ -667,38 +667,131 @@ pub async fn spawn_decoder(
 
     #[cfg(target_os = "windows")]
     {
-        let _ = force_ffmpeg;
-        let (ready_tx, ready_rx) = oneshot::channel::<Result<DecoderInitResult, String>>();
-        let (tx, rx) = mpsc::channel();
+        if force_ffmpeg {
+            info!(
+                "Video '{}' using FFmpeg decoder (forced via experimental setting)",
+                name
+            );
+            let (ready_tx, ready_rx) = oneshot::channel::<Result<DecoderInitResult, String>>();
+            let (tx, rx) = mpsc::channel();
 
-        ffmpeg::FfmpegDecoder::spawn(name, path, fps, rx, ready_tx)
-            .map_err(|e| format!("'{name}' FFmpeg decoder / {e}"))?;
+            ffmpeg::FfmpegDecoder::spawn(name, path, fps, rx, ready_tx)
+                .map_err(|e| format!("'{name}' FFmpeg decoder / {e}"))?;
 
-        match tokio::time::timeout(timeout_duration, ready_rx).await {
-            Ok(Ok(Ok(init_result))) => {
-                info!(
-                    "Video '{}' using {} decoder ({}x{})",
-                    name, init_result.decoder_type, init_result.width, init_result.height
+            return match tokio::time::timeout(timeout_duration, ready_rx).await {
+                Ok(Ok(Ok(init_result))) => {
+                    info!(
+                        "Video '{}' using {} decoder ({}x{})",
+                        name, init_result.decoder_type, init_result.width, init_result.height
+                    );
+                    let status = DecoderStatus {
+                        decoder_type: init_result.decoder_type,
+                        video_width: init_result.width,
+                        video_height: init_result.height,
+                        fallback_reason: None,
+                    };
+                    Ok(AsyncVideoDecoderHandle {
+                        sender: tx,
+                        offset,
+                        status,
+                    })
+                }
+                Ok(Ok(Err(e))) => Err(format!(
+                    "'{name}' FFmpeg decoder initialization failed: {e}"
+                )),
+                Ok(Err(e)) => Err(format!("'{name}' FFmpeg decoder channel closed: {e}")),
+                Err(_) => Err(format!(
+                    "'{name}' FFmpeg decoder timed out after 30s initializing: {path_display}"
+                )),
+            };
+        }
+
+        let mf_result = {
+            let (ready_tx, ready_rx) = oneshot::channel::<Result<DecoderInitResult, String>>();
+            let (tx, rx) = mpsc::channel();
+
+            match media_foundation::MFDecoder::spawn(name, path.clone(), fps, rx, ready_tx) {
+                Ok(()) => match tokio::time::timeout(timeout_duration, ready_rx).await {
+                    Ok(Ok(Ok(init_result))) => {
+                        info!(
+                            "Video '{}' using {} decoder ({}x{})",
+                            name, init_result.decoder_type, init_result.width, init_result.height
+                        );
+                        let status = DecoderStatus {
+                            decoder_type: init_result.decoder_type,
+                            video_width: init_result.width,
+                            video_height: init_result.height,
+                            fallback_reason: None,
+                        };
+                        Ok(AsyncVideoDecoderHandle {
+                            sender: tx,
+                            offset,
+                            status,
+                        })
+                    }
+                    Ok(Ok(Err(e))) => Err(format!(
+                        "'{name}' MediaFoundation initialization failed: {e} ({path_display})"
+                    )),
+                    Ok(Err(e)) => Err(format!(
+                        "'{name}' MediaFoundation channel closed: {e} ({path_display})"
+                    )),
+                    Err(_) => Err(format!(
+                        "'{name}' MediaFoundation timed out after 30s initializing: {path_display}"
+                    )),
+                },
+                Err(e) => Err(format!(
+                    "'{name}' MediaFoundation spawn failed: {e} ({path_display})"
+                )),
+            }
+        };
+
+        match mf_result {
+            Ok(handle) => Ok(handle),
+            Err(mf_error) => {
+                tracing::warn!(
+                    name = name,
+                    error = %mf_error,
+                    "MediaFoundation failed, falling back to FFmpeg decoder"
                 );
-                let status = DecoderStatus {
-                    decoder_type: init_result.decoder_type,
-                    video_width: init_result.width,
-                    video_height: init_result.height,
-                    fallback_reason: None,
-                };
-                Ok(AsyncVideoDecoderHandle {
-                    sender: tx,
-                    offset,
-                    status,
-                })
+
+                let (ready_tx, ready_rx) = oneshot::channel::<Result<DecoderInitResult, String>>();
+                let (tx, rx) = mpsc::channel();
+
+                if let Err(e) = ffmpeg::FfmpegDecoder::spawn(name, path, fps, rx, ready_tx) {
+                    return Err(format!(
+                        "'{name}' decoder failed - MediaFoundation: {mf_error}, FFmpeg: {e}"
+                    ));
+                }
+
+                match tokio::time::timeout(timeout_duration, ready_rx).await {
+                    Ok(Ok(Ok(init_result))) => {
+                        info!(
+                            "Video '{}' using {} decoder ({}x{}) after MediaFoundation failure",
+                            name, init_result.decoder_type, init_result.width, init_result.height
+                        );
+                        let status = DecoderStatus {
+                            decoder_type: init_result.decoder_type,
+                            video_width: init_result.width,
+                            video_height: init_result.height,
+                            fallback_reason: Some(mf_error),
+                        };
+                        Ok(AsyncVideoDecoderHandle {
+                            sender: tx,
+                            offset,
+                            status,
+                        })
+                    }
+                    Ok(Ok(Err(e))) => Err(format!(
+                        "'{name}' decoder failed - MediaFoundation: {mf_error}, FFmpeg: {e}"
+                    )),
+                    Ok(Err(e)) => Err(format!(
+                        "'{name}' decoder failed - MediaFoundation: {mf_error}, FFmpeg channel: {e}"
+                    )),
+                    Err(_) => Err(format!(
+                        "'{name}' decoder failed - MediaFoundation: {mf_error}, FFmpeg timed out"
+                    )),
+                }
             }
-            Ok(Ok(Err(e))) => Err(format!(
-                "'{name}' FFmpeg decoder initialization failed: {e}"
-            )),
-            Ok(Err(e)) => Err(format!("'{name}' FFmpeg decoder channel closed: {e}")),
-            Err(_) => Err(format!(
-                "'{name}' FFmpeg decoder timed out after 30s initializing: {path_display}"
-            )),
         }
     }
 
diff --git a/crates/rendering/src/layers/display.rs b/crates/rendering/src/layers/display.rs
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
