Desktop editor startup and playback latency optimizations

apps/desktop/app.config.ts

@@ -7,6 +7,28 @@ import tsconfigPaths from "vite-tsconfig-paths";
 
 const enableSolidDevtools = !!process.env.VITE_SOLID_DEVTOOLS;
 
+// Bundled fonts load from local assets near-instantly, so `block` is safe and
+// avoids the fallback-font flash (FOUT) that `swap` causes on every window
+// open. Desktop-only: web keeps `swap` for slow networks.
+// No `enforce`: must run after vite:css has inlined the virtual module's
+// @import statements (a `pre` transform only sees the un-inlined imports).
+const fontDisplayBlock = {
+	name: "cap:font-display-block",
+	transform(code: string, id: string) {
+		// unplugin-fonts inlines the @fontsource CSS into its virtual
+		// "unfonts.css" module, so match that as well as direct imports.
+		const [file] = id.split("?");
+		const isFontCss =
+			file.endsWith("unfonts.css") ||
+			(file.includes("@fontsource") && file.endsWith(".css"));
+		if (!isFontCss) return;
+		return {
+			code: code.replace(/font-display:\s*swap;/g, "font-display: block;"),
+			map: null,
+		};
+	},
+};
+
 export default defineConfig({
 	ssr: false,
 	server: { preset: "static" },
@@ -31,6 +53,7 @@ export default defineConfig({
 		assetsInclude: ["**/*.riv"],
 		plugins: [
 			...(enableSolidDevtools ? [devtools({ autoname: true })] : []),
+			fontDisplayBlock,
 			wasm(),
 			topLevelAwait(),
 			capUIPlugin,

apps/desktop/package.json

@@ -47,14 +47,14 @@
 		"@tauri-apps/plugin-deep-link": "^2.4.1",
 		"@tauri-apps/plugin-dialog": "2.4.2",
 		"@tauri-apps/plugin-fs": "2.4.2",
-		"@tauri-apps/plugin-http": "^2.5.1",
+		"@tauri-apps/plugin-http": "2.5.2",
 		"@tauri-apps/plugin-notification": "^2.3.0",
 		"@tauri-apps/plugin-opener": "^2.5.0",
 		"@tauri-apps/plugin-os": "^2.3.0",
 		"@tauri-apps/plugin-process": "2.3.0",
 		"@tauri-apps/plugin-shell": "^2.3.0",
 		"@tauri-apps/plugin-store": "^2.4.0",
-		"@tauri-apps/plugin-updater": "^2.9.0",
+		"@tauri-apps/plugin-updater": "2.9.0",
 		"@ts-rest/core": "^3.52.1",
 		"@types/react-tooltip": "^4.2.4",
 		"cva": "npm:class-variance-authority@^0.7.0",

apps/desktop/src-tauri/Cargo.toml

@@ -29,7 +29,7 @@ tauri-specta = { version = "=2.0.0-rc.20", features = ["derive", "typescript"] }
 tauri-plugin-dialog = "2.2.0"
 tauri-plugin-fs = "2.2.0"
 tauri-plugin-global-shortcut = "2.2.0"
-tauri-plugin-http = "2.2.0"
+tauri-plugin-http = "=2.5.2"
 tauri-plugin-notification = "2.2.0"
 tauri-plugin-os = "2.2.0"
 tauri-plugin-process = "2.2.0"

apps/desktop/src-tauri/examples/desktop-display-transport-benchmark.rs

@@ -58,6 +58,9 @@ impl Summary {
             PlaybackTelemetryEvent::RendererSendFailed { .. } => {
                 self.send_failures += 1;
             }
+            PlaybackTelemetryEvent::AudioSegmentsResolved { .. }
+            | PlaybackTelemetryEvent::AudioPipelineReady { .. }
+            | PlaybackTelemetryEvent::ClockStarted { .. } => {}
         }
     }
 
@@ -307,13 +310,15 @@ async fn main() {
     };
 
     let (_project_tx, project_rx) = watch::channel(project);
+    let audio_output = Arc::new(cap_editor::AudioOutput::new());
     let playback = Playback {
         renderer: renderer.clone(),
         render_constants,
         start_frame_number: 0,
         project: project_rx,
         segment_medias,
         music: cap_editor::MusicTracks::new(),
+        audio_output,
         telemetry: Some(telemetry),
     };
 

apps/desktop/src-tauri/src/lib.rs

@@ -139,6 +139,65 @@ use tauri::menu::{
 type FinalizingRecordingsMap =
     std::collections::HashMap<PathBuf, (watch::Sender<bool>, watch::Receiver<bool>)>;
 
+const EDITOR_PREVIEW_FPS: u32 = 60;
+const EDITOR_OUTPUT_SIZE: XY<u32> = XY::new(1920, 1080);
+const DEFAULT_EDITOR_PREVIEW_SCALE_NUMERATOR: u32 = 65;
+const DEFAULT_EDITOR_PREVIEW_SCALE_DENOMINATOR: u32 = 100;
+
+fn default_editor_preview_resolution() -> XY<u32> {
+    scaled_editor_preview_resolution(
+        EDITOR_OUTPUT_SIZE,
+        DEFAULT_EDITOR_PREVIEW_SCALE_NUMERATOR,
+        DEFAULT_EDITOR_PREVIEW_SCALE_DENOMINATOR,
+    )
+}
+
+fn scaled_editor_preview_resolution(
+    output_size: XY<u32>,
+    numerator: u32,
+    denominator: u32,
+) -> XY<u32> {
+    XY::new(
+        scaled_editor_preview_dimension(output_size.x, numerator, denominator, 4, 4),
+        scaled_editor_preview_dimension(output_size.y, numerator, denominator, 2, 2),
+    )
+}
+
+fn scaled_editor_preview_dimension(
+    value: u32,
+    numerator: u32,
+    denominator: u32,
+    minimum: u32,
+    alignment: u32,
+) -> u32 {
+    let denominator = denominator.max(1);
+    let alignment = alignment.max(1);
+    let scaled = ((u64::from(value) * u64::from(numerator)) + (u64::from(denominator) / 2))
+        / u64::from(denominator);
+    let rounded = u32::try_from(scaled).unwrap_or(u32::MAX).max(minimum);
+    let aligned = u64::from(rounded).div_ceil(u64::from(alignment)) * u64::from(alignment);
+
+    u32::try_from(aligned).unwrap_or(u32::MAX)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_editor_preview_resolution_matches_frontend_defaults() {
+        assert_eq!(default_editor_preview_resolution(), XY::new(1248, 702));
+    }
+
+    #[test]
+    fn scaled_editor_preview_resolution_rounds_like_frontend() {
+        assert_eq!(
+            scaled_editor_preview_resolution(XY::new(1919, 1079), 65, 100),
+            XY::new(1248, 702)
+        );
+    }
+}
+
 #[derive(Default)]
 pub struct FinalizingRecordings {
     recordings: std::sync::Mutex<FinalizingRecordingsMap>,
@@ -2850,10 +2909,6 @@ async fn create_editor_instance(window: Window) -> Result<SerializedEditorInstan
 
     let editor_instance = EditorInstances::get_or_create(&window, path).await?;
 
-    let meta = editor_instance.meta();
-
-    println!("Pretty name: {}", meta.pretty_name);
-
     Ok(SerializedEditorInstance {
         frames_socket_url: format!("ws://localhost:{}", editor_instance.ws_port),
         recording_duration: editor_instance.recordings.duration(),
@@ -4104,10 +4159,15 @@ async fn get_mic_waveforms(editor_instance: WindowEditorInstance) -> Result<Vec<
     let mut out = Vec::new();
 
     for segment in editor_instance.segment_medias.iter() {
-        if let Some(audio) = &segment.audio {
-            out.push(audio::get_waveform(audio));
-        } else {
-            out.push(Vec::new());
+        // Waits for the background decode; a failed track just renders as an
+        // empty waveform (playback/export surface the actual error).
+        match segment.audio.get().await {
+            Ok(Some(audio)) => out.push(audio::get_waveform(&audio)),
+            Ok(None) => out.push(Vec::new()),
+            Err(error) => {
+                warn!(%error, "Mic audio failed to load; returning empty waveform");
+                out.push(Vec::new());
+            }
         }
     }
 
@@ -4123,10 +4183,13 @@ async fn get_system_audio_waveforms(
     let mut out = Vec::new();
 
     for segment in editor_instance.segment_medias.iter() {
-        if let Some(audio) = &segment.system_audio {
-            out.push(audio::get_waveform(audio));
-        } else {
-            out.push(Vec::new());
+        match segment.system_audio.get().await {
+            Ok(Some(audio)) => out.push(audio::get_waveform(&audio)),
+            Ok(None) => out.push(Vec::new()),
+            Err(error) => {
+                warn!(%error, "System audio failed to load; returning empty waveform");
+                out.push(Vec::new());
+            }
         }
     }
 
@@ -6135,6 +6198,10 @@ async fn create_editor_instance_impl(
         }
     });
 
+    instance
+        .preview_tx
+        .send_modify(|v| *v = Some((0, EDITOR_PREVIEW_FPS, default_editor_preview_resolution())));
+
     Ok((instance, event_id))
 }