feat: Various features + performance bits

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

@@ -28,13 +28,9 @@
 // Basically poor man's MSAA
 static GPU_SURFACE_SCALE: u32 = 4;
 
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "lowercase")]
-pub enum CameraPreviewSize {
-    #[default]
-    Sm,
-    Lg,
-}
+pub const MIN_CAMERA_SIZE: f32 = 150.0;
+pub const MAX_CAMERA_SIZE: f32 = 600.0;
+pub const DEFAULT_CAMERA_SIZE: f32 = 230.0;
 
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "lowercase")]
@@ -45,13 +41,27 @@
     Full,
 }
 
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Type)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Type)]
 pub struct CameraPreviewState {
-    size: CameraPreviewSize,
+    size: f32,
     shape: CameraPreviewShape,
     mirrored: bool,
 }
 
+impl Default for CameraPreviewState {
+    fn default() -> Self {
+        Self {
+            size: DEFAULT_CAMERA_SIZE,
+            shape: CameraPreviewShape::default(),
+            mirrored: false,
+        }
+    }
+}
+
+fn clamp_size(size: f32) -> f32 {
+    size.max(MIN_CAMERA_SIZE).min(MAX_CAMERA_SIZE)
+}
+
 pub struct CameraPreviewManager {
     store: Result<Arc<tauri_plugin_store::Store<tauri::Wry>>, String>,
     preview: Option<InitializedCameraPreview>,
@@ -70,17 +80,22 @@
 
     /// Get the current state of the camera window.
     pub fn get_state(&self) -> anyhow::Result<CameraPreviewState> {
-        Ok(self
+        let mut state: CameraPreviewState = self
             .store
             .as_ref()
             .map_err(|err| anyhow!("{err}"))?
             .get("state")
-            .and_then(|v| serde_json::from_value(v).ok().unwrap_or_default())
-            .unwrap_or_default())
+            .and_then(|v| serde_json::from_value(v).ok())
+            .unwrap_or_default();
+
+        state.size = clamp_size(state.size);
+        Ok(state)
     }
 
     /// Save the current state of the camera window.
-    pub fn set_state(&self, state: CameraPreviewState) -> anyhow::Result<()> {
+    pub fn set_state(&self, mut state: CameraPreviewState) -> anyhow::Result<()> {
+        state.size = clamp_size(state.size);
+
         let store = self.store.as_ref().map_err(|err| anyhow!("{err}"))?;
         store.set("state", serde_json::to_value(&state)?);
         store.save()?;
@@ -607,16 +622,17 @@
 
     /// Update the uniforms which hold the camera preview state
     fn update_state_uniforms(&self, state: &CameraPreviewState) {
+        let clamped_size = clamp_size(state.size);
+        let normalized_size =
+            (clamped_size - MIN_CAMERA_SIZE) / (MAX_CAMERA_SIZE - MIN_CAMERA_SIZE);
+
         let state_uniforms = StateUniforms {
             shape: match state.shape {
                 CameraPreviewShape::Round => 0.0,
                 CameraPreviewShape::Square => 1.0,
                 CameraPreviewShape::Full => 2.0,
             },
-            size: match state.size {
-                CameraPreviewSize::Sm => 0.0,
-                CameraPreviewSize::Lg => 1.0,
-            },
+            size: normalized_size,
             mirrored: if state.mirrored { 1.0 } else { 0.0 },
             _padding: 0.0,
         };
@@ -664,11 +680,7 @@
 ) -> tauri::Result<(u32, u32)> {
     trace!("CameraPreview/resize_window");
 
-    let base: f32 = if state.size == CameraPreviewSize::Sm {
-        230.0
-    } else {
-        400.0
-    };
+    let base = clamp_size(state.size);
     let window_width = if state.shape == CameraPreviewShape::Full {
         if aspect >= 1.0 { base * aspect } else { base }
     } else {

apps/desktop/src-tauri/src/camera.wgsl

@@ -124,7 +124,8 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 
     } else if (shape == 1.0) {
         // Square shape with enhanced corner anti-aliasing
-        let corner_radius = select(0.1, 0.12, size == 1.0);
+        // Interpolate corner radius based on normalized size (0-1)
+        let corner_radius = mix(0.10, 0.14, size);
         let abs_uv = abs(center_uv);
         let corner_pos = abs_uv - (1.0 - corner_radius);
         let corner_dist = length(max(corner_pos, vec2<f32>(0.0, 0.0)));
@@ -138,7 +139,8 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     } else if (shape == 2.0) {
         // Full shape with aspect ratio-corrected rounded corners
         let window_aspect = window_uniforms.window_width / window_uniforms.window_height;
-        let corner_radius = select(0.08, 0.1, size == 1.0); // radius based on size (8% for small, 10% for large)
+        // Interpolate corner radius based on normalized size (0-1)
+        let corner_radius = mix(0.08, 0.12, size);
 
         let abs_uv = abs(center_uv);
         let corner_pos = abs_uv - (1.0 - corner_radius);

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

@@ -6,10 +6,7 @@ use std::path::{Path, PathBuf};
 use tauri::{AppHandle, Manager, Url};
 use tracing::trace;
 
-use crate::{
-    App, ArcLock, apply_camera_input, apply_mic_input, recording::StartRecordingInputs,
-    windows::ShowCapWindow,
-};
+use crate::{App, ArcLock, recording::StartRecordingInputs, windows::ShowCapWindow};
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -119,8 +116,8 @@ impl DeepLinkAction {
             } => {
                 let state = app.state::<ArcLock<App>>();
 
-                apply_camera_input(app.clone(), state.clone(), camera).await?;
-                apply_mic_input(state.clone(), mic_label).await?;
+                crate::set_camera_input(app.clone(), state.clone(), camera).await?;
+                crate::set_mic_input(state.clone(), mic_label).await?;
 
                 let capture_target: ScreenCaptureTarget = match capture_mode {
                     CaptureMode::Screen(name) => cap_recording::screen_capture::list_displays()

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

@@ -331,13 +331,6 @@ impl App {
 #[specta::specta]
 #[instrument(skip(state))]
 async fn set_mic_input(state: MutableState<'_, App>, label: Option<String>) -> Result<(), String> {
-    apply_mic_input(state, label).await
-}
-
-pub(crate) async fn apply_mic_input(
-    state: MutableState<'_, App>,
-    label: Option<String>,
-) -> Result<(), String> {
     let (mic_feed, studio_handle, current_label) = {
         let app = state.read().await;
         let handle = match app.current_recording() {
@@ -421,14 +414,6 @@ async fn set_camera_input(
     app_handle: AppHandle,
     state: MutableState<'_, App>,
     id: Option<DeviceOrModelID>,
-) -> Result<(), String> {
-    apply_camera_input(app_handle, state, id).await
-}
-
-pub(crate) async fn apply_camera_input(
-    app_handle: AppHandle,
-    state: MutableState<'_, App>,
-    id: Option<DeviceOrModelID>,
 ) -> Result<(), String> {
     let app = state.read().await;
     let camera_feed = app.camera_feed.clone();
@@ -459,12 +444,39 @@ pub(crate) async fn apply_camera_input(
                 .map_err(|e| e.to_string())?;
         }
         Some(id) => {
-            camera_feed
-                .ask(feeds::camera::SetInput { id: id.clone() })
-                .await
-                .map_err(|e| e.to_string())?
-                .await
-                .map_err(|e| e.to_string())?;
+            let mut attempts = 0;
+            loop {
+                attempts += 1;
+
+                // We first ask the actor to set the input
+                // This returns a future that resolves when the camera is actually ready
+                let request = camera_feed
+                    .ask(feeds::camera::SetInput { id: id.clone() })
+                    .await
+                    .map_err(|e| e.to_string());
+
+                let result = match request {
+                    Ok(future) => future.await.map_err(|e| e.to_string()),
+                    Err(e) => Err(e),
+                };
+
+                match result {
+                    Ok(_) => break,
+                    Err(e) => {
+                        if attempts >= 3 {
+                            return Err(format!(
+                                "Failed to initialize camera after {} attempts: {}",
+                                attempts, e
+                            ));
+                        }
+                        warn!(
+                            "Failed to set camera input (attempt {}): {}. Retrying...",
+                            attempts, e
+                        );
+                        tokio::time::sleep(Duration::from_millis(500)).await;
+                    }
+                }
+            }
 
             ShowCapWindow::Camera
                 .show(&app_handle)
@@ -741,11 +753,19 @@ enum CurrentRecordingTarget {
     },
 }
 
+#[derive(Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum RecordingStatus {
+    Pending,
+    Recording,
+}
+
 #[derive(Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 struct CurrentRecording {
     target: CurrentRecordingTarget,
     mode: RecordingMode,
+    status: RecordingStatus,
 }
 
 #[tauri::command]
@@ -756,10 +776,14 @@ async fn get_current_recording(
 ) -> Result<JsonValue<Option<CurrentRecording>>, ()> {
     let state = state.read().await;
 
-    let (mode, capture_target) = match &state.recording_state {
+    let (mode, capture_target, status) = match &state.recording_state {
         RecordingState::None => return Ok(JsonValue::new(&None)),
-        RecordingState::Pending { mode, target } => (*mode, target),
-        RecordingState::Active(inner) => (inner.mode(), inner.capture_target()),
+        RecordingState::Pending { mode, target } => (*mode, target, RecordingStatus::Pending),
+        RecordingState::Active(inner) => (
+            inner.mode(),
+            inner.capture_target(),
+            RecordingStatus::Recording,
+        ),
     };
 
     let target = match capture_target {
@@ -777,7 +801,11 @@ async fn get_current_recording(
         },
     };
 
-    Ok(JsonValue::new(&Some(CurrentRecording { target, mode })))
+    Ok(JsonValue::new(&Some(CurrentRecording {
+        target,
+        mode,
+        status,
+    })))
 }
 
 #[derive(Serialize, Type, tauri_specta::Event, Clone)]
@@ -2558,8 +2586,8 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                     .flatten()
                     .unwrap_or_default();
 
-                let _ = apply_mic_input(app.state(), settings.mic_name).await;
-                let _ = apply_camera_input(app.clone(), app.state(), settings.camera_id).await;
+                let _ = set_mic_input(app.state(), settings.mic_name).await;
+                let _ = set_camera_input(app.clone(), app.state(), settings.camera_id).await;
 
                 let _ = start_recording(app.clone(), app.state(), {
                     recording::StartRecordingInputs {
@@ -2635,6 +2663,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                             .camera_feed
                                             .ask(feeds::camera::RemoveInput)
                                             .await;
+
                                         app_state.selected_mic_label = None;
                                         app_state.selected_camera_id = None;
                                         app_state.camera_in_use = false;
@@ -2695,11 +2724,18 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                             CapWindowId::Camera => {
                                 let app = app.clone();
                                 tokio::spawn(async move {
-                                    app.state::<ArcLock<App>>()
-                                        .write()
-                                        .await
-                                        .camera_preview
-                                        .on_window_close();
+                                    let state = app.state::<ArcLock<App>>();
+                                    let mut app_state = state.write().await;
+
+                                    app_state.camera_preview.on_window_close();
+
+                                    if !app_state.is_recording_active_or_pending() {
+                                        let _ = app_state
+                                            .camera_feed
+                                            .ask(feeds::camera::RemoveInput)
+                                            .await;
+                                        app_state.camera_in_use = false;
+                                    }
                                 });
                             }
                             _ => {}