system audio capture (#359)

* system audio start

* load system audio into memory

* audio mixing

* wip audio mixer

* audio mixing and playback works

* windows impl + fix instant mode audio in quicktime

* fix api

* feature flag system audio

* correct system audio flag

* remove decode_audio

Author: Brendonovich

Cargo.lock

@@ -179,7 +179,6 @@ impl Export {
             &segments,
             fps,
             XY::new(1920, 1080),
-            true,
         )
         .await
         .unwrap();

apps/cli/src/main.rs

@@ -17,8 +17,11 @@ pub struct RecordStart {
     /// ID of the microphone to record
     #[arg(long)]
     mic: Option<u32>,
+    /// Whether to capture system audio
     #[arg(long)]
+    system_audio: bool,
     /// Path to save the '.cap' project to
+    #[arg(long)]
     path: Option<PathBuf>,
     /// Maximum fps to record at (max 60)
     #[arg(long)]
@@ -77,6 +80,7 @@ impl RecordStart {
                 camera_label: camera.as_ref().map(|c| c.camera_info.human_name()),
                 audio_input_name: None,
                 mode: RecordingMode::Studio,
+                capture_system_audio: self.system_audio,
             },
             camera.map(|c| Arc::new(Mutex::new(c))),
             None,

apps/cli/src/record.rs

@@ -71,12 +71,6 @@ pub async fn export_video(
         }
     }
 
-    let is_upgraded = AuthStore::get(&app)
-        .ok()
-        .flatten()
-        .map(|auth| auth.is_upgraded())
-        .unwrap_or(false);
-
     let exporter = cap_export::Exporter::new(
         modified_project,
         output_path.clone(),
@@ -93,7 +87,6 @@ pub async fn export_video(
         &editor_instance.segments,
         fps,
         resolution_base,
-        is_upgraded,
     )
     .await
     .map_err(|e| {

apps/desktop/output.mp3

@@ -188,6 +188,7 @@ impl App {
         });
 
         self.recording_options.mode = new_options.mode;
+        self.recording_options.capture_system_audio = new_options.capture_system_audio;
 
         match CapWindowId::Camera.get(&self.handle) {
             Some(window) if new_options.camera_label().is_none() => {
@@ -884,22 +885,11 @@ impl EditorStateChanged {
 #[tauri::command]
 #[specta::specta]
 async fn start_playback(
-    app: AppHandle,
     editor_instance: WindowEditorInstance,
     fps: u32,
     resolution_base: XY<u32>,
 ) -> Result<(), String> {
-    editor_instance
-        .start_playback(
-            fps,
-            resolution_base,
-            AuthStore::get(&app)
-                .ok()
-                .flatten()
-                .map(|s| s.is_upgraded())
-                .unwrap_or(false),
-        )
-        .await;
+    editor_instance.start_playback(fps, resolution_base).await;
 
     Ok(())
 }
@@ -1950,10 +1940,13 @@ async fn update_auth_plan(app: AppHandle) {
     AuthStore::update_auth_plan(&app).await.ok();
 }
 
-pub type DynLoggingLayer =
-    Box<dyn tracing_subscriber::Layer<tracing_subscriber::Registry> + Send + Sync>;
-type LoggingHandle =
-    tracing_subscriber::reload::Handle<Option<DynLoggingLayer>, tracing_subscriber::Registry>;
+pub type FilteredRegistry = tracing_subscriber::layer::Layered<
+    tracing_subscriber::filter::FilterFn<fn(m: &tracing::Metadata) -> bool>,
+    tracing_subscriber::Registry,
+>;
+
+pub type DynLoggingLayer = Box<dyn tracing_subscriber::Layer<FilteredRegistry> + Send + Sync>;
+type LoggingHandle = tracing_subscriber::reload::Handle<Option<DynLoggingLayer>, FilteredRegistry>;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub async fn run(recording_logging_handle: LoggingHandle) {
@@ -2138,6 +2131,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                         camera_label: None,
                         audio_input_name: None,
                         mode: RecordingMode::Studio,
+                        capture_system_audio: false,
                     },
                     current_recording: None,
                     recording_logging_handle,

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

@@ -4,7 +4,7 @@
 use std::sync::Arc;
 
 use cap_desktop::DynLoggingLayer;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer};
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 fn main() {
     // We have to hold onto the ClientInitGuard until the very end
@@ -42,18 +42,16 @@ fn main() {
 
     let (layer, handle) = tracing_subscriber::reload::Layer::new(None::<DynLoggingLayer>);
 
-    tracing_subscriber::registry()
-        // .with(tracing_subscriber::filter::filter_fn(|v| {
-        //     v.target().starts_with("cap_")
-        // }))
+    let registry = tracing_subscriber::registry().with(tracing_subscriber::filter::filter_fn(
+        (|v| v.target().starts_with("cap_")) as fn(&tracing::Metadata) -> bool,
+    ));
+
+    registry
         .with(layer)
         .with(
             tracing_subscriber::fmt::layer()
                 .with_ansi(true)
-                .with_target(true)
-                .with_filter(tracing_subscriber::filter::filter_fn(|v| {
-                    v.target().starts_with("cap_")
-                })),
+                .with_target(true),
         )
         .init();
 

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

@@ -104,17 +104,5 @@ pub fn send_notification(app: &tauri::AppHandle, notification_type: Notification
         .show()
         .ok();
 
-    println!(
-        "Sending notification: Title: '{}', Body: '{}', Error: {}",
-        title, body, is_error
-    );
-
     AppSounds::Notification.play();
-
-    // let _ = NewNotification {
-    //     title: title.to_string(),
-    //     body: body.to_string(),
-    //     is_error,
-    // }
-    // .emit(app);
 }

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

@@ -877,9 +877,6 @@ impl ProgressiveUploadTask {
                     match tokio::fs::metadata(&file_path).await {
                         Ok(metadata) => {
                             if metadata.len() < MIN_PART_SIZE {
-                                println!(
-                                "Waiting for file to grow to at least 5MB before starting upload"
-                            );
                                 sleep(Duration::from_millis(500)).await;
                                 continue;
                             } else {