[*] update normally

Author: heng30

lib/recorder/src/record_speaker.rs

@@ -11,10 +11,11 @@ use pipewire::{
     stream::{StreamBox, StreamFlags, StreamListener},
 };
 use std::{
+    ops::Mul,
     path::PathBuf,
     sync::{
         Arc, Mutex,
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicI32, Ordering},
     },
     time::Duration,
 };
@@ -118,6 +119,9 @@ pub struct SpeakerRecorder {
     level_sender: Option<Arc<Sender<f32>>>,
     /// Whether to run in preview mode (no file output)
     enable_preview_mode: bool,
+
+    // [0, infinity]
+    amplification: Option<Arc<AtomicI32>>,
 }
 
 impl SpeakerRecorder {
@@ -170,9 +174,15 @@ impl SpeakerRecorder {
             stop_sig,
             level_sender,
             enable_preview_mode,
+            amplification: None,
         })
     }
 
+    pub fn with_amplification(mut self, v: Arc<AtomicI32>) -> Self {
+        self.amplification = Some(v);
+        self
+    }
+
     /// Start recording system audio output to WAV file.
     ///
     /// This method begins capturing system audio output using PipeWire monitor ports.
@@ -232,8 +242,12 @@ impl SpeakerRecorder {
 
         // Create an input stream to record the monitoring port of the output device.
         let stream = self.create_stream()?;
-        let _stream_listener =
-            Self::stream_register(&stream, writer.clone(), self.level_sender.clone())?;
+        let _stream_listener = Self::stream_register(
+            &stream,
+            writer.clone(),
+            self.level_sender.clone(),
+            self.amplification.clone(),
+        )?;
         Self::stream_connect(&stream, node_id)?;
 
         while !self.stop_sig.load(Ordering::Relaxed) {
@@ -368,6 +382,7 @@ impl SpeakerRecorder {
         stream: &StreamBox,
         writer: Arc<Mutex<Option<WavWriterType>>>,
         level_sender: Option<Arc<Sender<f32>>>,
+        amplification: Option<Arc<AtomicI32>>,
     ) -> Result<StreamListener<()>, SpeakerError> {
         let stream_listener = stream
             .add_local_listener::<()>()
@@ -392,6 +407,18 @@ impl SpeakerRecorder {
                         )
                     };
 
+                    let mut f32_sample_amplification = vec![0.0; f32_samples.len()];
+                    let f32_samples = if let Some(ref amplification) = amplification {
+                        for (index, v) in f32_samples.iter().enumerate() {
+                            f32_sample_amplification[index] =
+                                v.mul(amplification.load(Ordering::Relaxed) as f32 / 100.0);
+                        }
+
+                        &f32_sample_amplification[..]
+                    } else {
+                        f32_samples
+                    };
+
                     if let Ok(mut writer_opt) = writer.lock()
                         && let Some(ref mut wav_writer) = *writer_opt
                     {

wayshot/src/config.rs

@@ -5,7 +5,8 @@
 //! configuration file creation.
 
 use crate::slint_generatedAppWindow::{
-    SettingControl as UISettingControl, SettingRecorder as UISettingRecorder,
+    Fps as UIFps, Resolution as UIResolution, SettingControl as UISettingControl,
+    SettingRecorder as UISettingRecorder,
 };
 use anyhow::{Context, Result, bail};
 use log::debug;
@@ -114,13 +115,23 @@ pub struct Preference {
     pub is_dark: bool,
 }
 
-#[derive(Serialize, Deserialize, Default, Debug, Clone, SlintFromConvert)]
+#[derive(Serialize, Deserialize, Derivative, Debug, Clone, SlintFromConvert)]
+#[derivative(Default)]
 #[from("UISettingRecorder")]
 pub struct Recorder {
     pub save_dir: String,
     pub remove_temporary_files: bool,
+
+    #[derivative(Default(value = "fps_default()"))]
+    pub fps: UIFps,
+
+    #[derivative(Default(value = "resolution_default()"))]
+    pub resolution: UIResolution,
 }
 
+crate::impl_slint_enum_serde!(UIFps, Fps24, Fps25, Fps30);
+crate::impl_slint_enum_serde!(UIResolution, Original, P720, P1080, P2K, P4K);
+
 #[derive(Serialize, Deserialize, Debug, Clone, Derivative, SlintFromConvert)]
 #[derivative(Default)]
 #[from("UISettingControl")]
@@ -274,6 +285,14 @@ fn appid_default() -> String {
     Uuid::new_v4().to_string()
 }
 
+fn fps_default() -> UIFps {
+    UIFps::Fps25
+}
+
+fn resolution_default() -> UIResolution {
+    UIResolution::Original
+}
+
 /// Initializes the global configuration
 ///
 /// This should be called once at application startup.

wayshot/src/logic/recorder.rs

@@ -9,15 +9,25 @@ use crate::{
     toast_warn,
 };
 use anyhow::{Result, bail};
+use once_cell::sync::Lazy;
 use recorder::{AudioRecorder, SpeakerRecorder, bounded};
 use slint::{ComponentHandle, Model, SharedString, ToSharedString, VecModel, Weak};
 use std::{
     path::PathBuf,
-    sync::{Arc, atomic::AtomicBool},
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, AtomicI32, Ordering},
+    },
     thread,
 };
 
-// static CACHE: Lazy<Mutex<Cache>> = Lazy::new(|| Mutex::new(Cache::default()));
+#[derive(Default, Debug)]
+struct Cache {
+    desktop_speaker_amplification: Option<Arc<AtomicI32>>,
+    input_audio_amplification: Option<Arc<AtomicI32>>,
+}
+
+static CACHE: Lazy<Mutex<Cache>> = Lazy::new(|| Mutex::new(Cache::default()));
 
 #[macro_export]
 macro_rules! store_audio_sources {
@@ -56,7 +66,8 @@ pub fn init(ui: &AppWindow) {
     inner_init(&ui);
 
     logic_cb!(choose_save_dir, ui);
-    logic_cb!(screen_changed, ui, name);
+    logic_cb!(input_audio_amplification_changed, ui, v);
+    logic_cb!(desktop_speaker_amplification_changed, ui, v);
     logic_cb!(input_audio_changed, ui, name);
     logic_cb!(start_recording, ui);
     logic_cb!(stop_recording, ui);
@@ -70,15 +81,15 @@ fn inner_init(ui: &AppWindow) {
     store_video_sources!(ui).set_vec(vec![]);
 
     if let Err(e) = init_input_audio(&ui) {
-        toast_warn!(ui, "{e}");
+        toast_warn!(ui, format!("{e}"));
     }
 
     if let Err(e) = init_desktop_speaker(&ui) {
-        toast_warn!(ui, "{e}");
+        toast_warn!(ui, format!("{e}"));
     }
 
     if let Err(e) = init_video(&ui) {
-        toast_warn!(ui, "{e}");
+        toast_warn!(ui, format!("{e}"));
     }
 }
 
@@ -172,6 +183,16 @@ fn init_desktop_speaker(ui: &AppWindow) -> Result<()> {
             }
 
             Ok(recorder) => {
+                let amplification = Arc::new(AtomicI32::new(
+                    config::all().control.desktop_speaker_sound.max(0.0) as i32,
+                ));
+                let recorder = recorder.with_amplification(amplification.clone());
+
+                {
+                    let mut cache = CACHE.lock().unwrap();
+                    cache.desktop_speaker_amplification = Some(amplification);
+                }
+
                 if let Err(e) = recorder.start_recording() {
                     async_toast_warn(
                         ui_weak.clone(),
@@ -224,8 +245,6 @@ fn init_video(ui: &AppWindow) -> Result<()> {
         name: name.clone(),
     });
 
-    global_logic!(ui).invoke_screen_changed(name);
-
     Ok(())
 }
 
@@ -243,7 +262,16 @@ fn choose_save_dir(ui: &AppWindow) {
     });
 }
 
-fn screen_changed(ui: &AppWindow, name: SharedString) {}
+fn input_audio_amplification_changed(ui: &AppWindow, v: f32) {}
+
+fn desktop_speaker_amplification_changed(_ui: &AppWindow, v: f32) {
+    let amplification = CACHE.lock().unwrap().desktop_speaker_amplification.clone();
+    if let Some(amplification) = amplification {
+        amplification.store(v as i32, Ordering::Relaxed);
+    } else {
+        log::warn!("desktop speaker amplification is None");
+    }
+}
 
 fn input_audio_changed(ui: &AppWindow, name: SharedString) {}
 

wayshot/ui/logic.slint

@@ -1,4 +1,4 @@
-import { Store, SettingPreference, TabIndex, SettingDetailIndex, MobileSettingDetailIndex, PopupIndex, MobileTabIndex, SettingBackup, SettingRecorder, SettingControl } from "store.slint";
+import { Store, SettingPreference, TabIndex, SettingDetailIndex, MobileSettingDetailIndex, PopupIndex, MobileTabIndex, SettingBackup, SettingRecorder, SettingControl, Fps, Resolution } from "store.slint";
 
 import { SideBarEntry } from "base/def.slint";
 
@@ -75,11 +75,63 @@ export global Logic {
     callback set-setting-control(setting: SettingControl);
 
     callback choose-save-dir();
-    callback screen-changed(value: string);
     callback input-audio-changed(value: string);
+    callback input-audio-amplification-changed(value: float);
+    callback desktop-speaker-amplification-changed(value: float);
     callback start-recording();
     callback stop-recording();
     callback stop-merge-tracks();
 
+    pure public function fps-to-int(fps: Fps) -> int {
+        if (fps == Fps.Fps24) {
+            return 24;
+        } else if (fps == Fps.Fps25) {
+            return 25;
+        } else {
+            return 30;
+        }
+    }
+
+    pure public function fps-from-int(fps: int) -> Fps {
+        if (fps == 24) {
+            return Fps.Fps24;
+        } else if (fps == 25) {
+            return Fps.Fps25;
+        } else {
+            return Fps.Fps30;
+        }
+    }
+
+    pure public function resolution-to-string(res: Resolution) -> string {
+        if (res == Resolution.Original) {
+            return "Original";
+        } else if (res == Resolution.P720) {
+            return "720P";
+        } else if (res == Resolution.P1080) {
+            return "1080P";
+        } else if (res == Resolution.P2K) {
+            return "2K";
+        } else if (res == Resolution.P4K) {
+            return "4K";
+        } else {
+            return "Original";
+        }
+    }
+
+    pure public function resolution-from-string(res: string) -> Resolution {
+        if (res == "Original") {
+            return Resolution.Original;
+        } else if (res == "720P") {
+            return Resolution.P720;
+        } else if (res == "1080P") {
+            return Resolution.P1080;
+        } else if (res == "2K") {
+            return Resolution.P2K;
+        } else if (res == "4K") {
+            return Resolution.P4K;
+        } else {
+            return Resolution.Original;
+        }
+    }
     //////////////////////////////// Logic End  ////////////////////////////////
 }