[*] refactor

Author: heng30

lib/denoise/src/lib.rs

@@ -314,6 +314,7 @@ pub struct RealTimeDenoise<'a, T: SampleType = f32> {
     buffer: Vec<Vec<f32>>,
     states: Vec<Box<DenoiseState<'a>>>,
     states_output_frames: Vec<Vec<f32>>,
+    first_frame: bool,
     _marker: PhantomData<T>,
 }
 
@@ -342,6 +343,7 @@ impl<'a, T: SampleType> RealTimeDenoise<'a, T> {
             states,
             states_output_frames,
             original_sample_rate: spec.sample_rate,
+            first_frame: true,
             _marker: PhantomData,
         })
     }
@@ -400,11 +402,17 @@ impl<'a, T: SampleType> RealTimeDenoise<'a, T> {
                         .process_frame(&mut self.states_output_frames[channel], input_slice);
                 }
 
-                for sample_idx in 0..FRAME_SIZE {
-                    for channel in 0..channels {
-                        let sample = self.states_output_frames[channel][sample_idx];
-                        output.push(sample);
+                // Skip output for first frame to avoid popping artifacts from
+                // uninitialized synthesis_mem in nnnoiseless overlap-add
+                if !self.first_frame {
+                    for sample_idx in 0..FRAME_SIZE {
+                        for channel in 0..channels {
+                            let sample = self.states_output_frames[channel][sample_idx];
+                            output.push(sample);
+                        }
                     }
+                } else {
+                    self.first_frame = false;
                 }
             }
 
@@ -413,6 +421,11 @@ impl<'a, T: SampleType> RealTimeDenoise<'a, T> {
                 self.buffer[channel].drain(0..samples_to_remove);
             }
 
+            // If no output (first frame case), return None
+            if output.is_empty() {
+                return Ok(None);
+            }
+
             // Step 4: Resample back to original rate if needed
             let final_output = if self.original_sample_rate != DENOISE_SAMPLE_RATE {
                 resample_from_denoise_rate(&output, self.original_sample_rate, self.spec.channels)?
@@ -443,6 +456,10 @@ impl<'a, T: SampleType> RealTimeDenoise<'a, T> {
         self.buffer[0].len()
     }
 
+    pub fn is_first_frame(&self) -> bool {
+        self.first_frame
+    }
+
     pub fn flush(&mut self) -> Option<Vec<T>> {
         let channels = self.spec.channels as usize;
         let remaining_samples = self.buffer[0].len();

lib/record-audio/src/lib.rs

@@ -121,6 +121,7 @@ pub struct AudioRecorder {
     channels: u16,
     sample_rate: u32,
     gain_db: f32,
+    mono: bool,
 }
 
 impl Default for AudioRecorder {
@@ -140,6 +141,7 @@ impl AudioRecorder {
             channels: 2,
             sample_rate: 48000,
             gain_db: 0.0,
+            mono: false,
         }
     }
 
@@ -153,6 +155,11 @@ impl AudioRecorder {
         self
     }
 
+    pub fn with_mono(mut self, mono: bool) -> Self {
+        self.mono = mono;
+        self
+    }
+
     pub fn get_input_devices(&self) -> Result<Vec<AudioDeviceInfo>> {
         let devices = self
             .host
@@ -214,6 +221,7 @@ impl AudioRecorder {
         let samples = self.recorded_samples.clone();
         let level_sender = self.level_sender.clone();
         let channels = self.channels;
+        let mono = self.mono;
 
         let linear_gain = if self.gain_db == 0.0 {
             1.0
@@ -229,26 +237,45 @@ impl AudioRecorder {
             .build_input_stream(
                 &config,
                 move |data: &[f32], _: &cpal::InputCallbackInfo| {
-                    let gain_samples: Vec<f32> = data
-                        .iter()
-                        .map(|s| (s * linear_gain).clamp(-1.0, 1.0))
-                        .collect();
+                    let processed_samples: Vec<f32> = if mono && channels > 1 {
+                        let num_channels = channels as usize;
+                        let num_frames = data.len() / num_channels;
+                        let mut mono_samples = Vec::with_capacity(num_frames);
+
+                        for frame_idx in 0..num_frames {
+                            let start = frame_idx * num_channels;
+                            let end = (start + num_channels).min(data.len());
+                            let frame_samples = &data[start..end];
+                            let avg = frame_samples.iter().sum::<f32>() / num_channels as f32;
+                            mono_samples.push((avg * linear_gain).clamp(-1.0, 1.0));
+                        }
+                        mono_samples
+                    } else {
+                        data.iter()
+                            .map(|s| (s * linear_gain).clamp(-1.0, 1.0))
+                            .collect()
+                    };
 
                     if let Ok(mut s) = samples.lock() {
-                        s.extend_from_slice(&gain_samples);
+                        s.extend_from_slice(&processed_samples);
                     }
 
                     if let Some(sender) = &level_sender
                         && let Ok(mut buf) = level_buffer_clone.lock()
                     {
-                        buf.extend_from_slice(&gain_samples);
+                        buf.extend_from_slice(&processed_samples);
 
                         // Calculate and send level every ~100ms worth of samples
-                        let threshold = (config.sample_rate as usize / 10) * channels as usize;
+                        let threshold = if mono && channels > 1 {
+                            config.sample_rate as usize / 10
+                        } else {
+                            (config.sample_rate as usize / 10) * channels as usize
+                        };
                         if buf.len() < threshold {
                             return;
                         }
 
+                        // For level display, always show left/right even if recording mono
                         let levels: (f32, f32) = if channels > 1 {
                             let parts = split_audio_channels(buf.clone(), channels as usize);
 
@@ -301,9 +328,15 @@ impl AudioRecorder {
             Vec::new()
         };
 
+        let output_channels = if self.mono && self.channels > 1 {
+            1
+        } else {
+            self.channels
+        };
+
         Ok(RecordedAudio {
             samples,
-            channels: self.channels,
+            channels: output_channels,
             sample_rate: self.sample_rate,
         })
     }

lib/video-editor/src/filters/audio/denoise.rs

@@ -4,10 +4,11 @@ use crate::{
 };
 use denoise::{DENOISE_MODEL, RealTimeDenoise};
 use hound::{SampleFormat, WavSpec};
-use std::cell::RefCell;
+use std::{cell::RefCell, sync::Arc};
 
 thread_local! {
-    static DENOISE_STATE: RefCell<Option<RealTimeDenoise<'static, f32>>> = RefCell::new(None);
+    static DENOISE_STATE: RefCell<(Option<RealTimeDenoise<'static, f32>>, Option<usize>)>
+        = RefCell::new((None, None));
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -37,6 +38,7 @@ impl AudioFilter for DenoiseFilter {
 
         let channels = data.config.channels;
         let sample_rate = data.config.sample_rate;
+        let segment_id = Arc::as_ptr(&data.from_segment) as usize;
 
         let spec = WavSpec {
             channels,
@@ -47,23 +49,31 @@ impl AudioFilter for DenoiseFilter {
 
         DENOISE_STATE.with(|state_cell| {
             let mut state_guard = state_cell.borrow_mut();
+            let (rt, last_segment_id) = &mut *state_guard;
 
-            let needs_reinit = state_guard
-                .as_ref()
-                .map(|rt| rt.spec().channels != channels || rt.spec().sample_rate != sample_rate)
-                .unwrap_or(true);
+            // Check if we need to reinitialize:
+            // - No existing state
+            // - Segment changed (boundary crossing - causes popping artifacts)
+            // - Audio config changed
+            let needs_reinit = rt.is_none()
+                || *last_segment_id != Some(segment_id)
+                || rt.as_ref().unwrap().spec().channels != channels
+                || rt.as_ref().unwrap().spec().sample_rate != sample_rate;
 
             if needs_reinit {
-                *state_guard = Some(RealTimeDenoise::new(&DENOISE_MODEL, spec).map_err(|e| {
+                // Creating a new RealTimeDenoise resets first_frame to true,
+                // which will skip the first frame output to avoid popping
+                *rt = Some(RealTimeDenoise::new(&DENOISE_MODEL, spec).map_err(|e| {
                     crate::Error::InvalidConfig(format!("Failed to create denoise state: {}", e))
                 })?);
+                *last_segment_id = Some(segment_id);
             }
 
-            let rt = state_guard.as_mut().unwrap();
+            let rt = rt.as_mut().unwrap();
 
             match rt.process(&data.samples) {
                 Ok(Some(processed)) => data.samples = processed,
-                Ok(None) => {}
+                Ok(None) => {} // First frame skipped or insufficient samples
                 Err(e) => {
                     return Err(crate::Error::InvalidConfig(format!(
                         "Denoise processing error: {}",
@@ -76,4 +86,3 @@ impl AudioFilter for DenoiseFilter {
         })
     }
 }
-

lib/video-editor/src/filters/video/fade_in.rs

@@ -41,13 +41,8 @@ impl VideoFilter for FadeInFilter {
                 let ratio = progress_ratio_from_offset(frame_time_offset, self.duration);
 
                 buffer.par_pixels_mut().for_each(|pixel| {
-                    let [r, g, b, a] = pixel.0;
-                    pixel.0 = [
-                        (r as f32 * ratio).clamp(0.0, 255.0) as u8,
-                        (g as f32 * ratio).clamp(0.0, 255.0) as u8,
-                        (b as f32 * ratio).clamp(0.0, 255.0) as u8,
-                        a,
-                    ];
+                    // 淡入：alpha 从 0 渐变到原始值
+                    pixel.0[3] = ((pixel.0[3] as f32) * ratio).clamp(0.0, 255.0) as u8;
                 });
             }
         }

lib/video-editor/src/filters/video/fade_out.rs

@@ -54,13 +54,8 @@ impl VideoFilter for FadeOutFilter {
                 let ratio = progress_ratio_from_offset(time_until_end, self.duration);
 
                 buffer.par_pixels_mut().for_each(|pixel| {
-                    let [r, g, b, a] = pixel.0;
-                    pixel.0 = [
-                        (r as f32 * ratio).clamp(0.0, 255.0) as u8,
-                        (g as f32 * ratio).clamp(0.0, 255.0) as u8,
-                        (b as f32 * ratio).clamp(0.0, 255.0) as u8,
-                        a,
-                    ];
+                    // 淡出：alpha 从原始值渐变到 0
+                    pixel.0[3] = ((pixel.0[3] as f32) * ratio).clamp(0.0, 255.0) as u8;
                 });
             }
         }

lib/video-editor/src/filters/video/fly_in.rs

@@ -4,7 +4,7 @@ use crate::{
     filters::traits::{EasingFunction, VideoData, VideoFilter},
     tracks::video_frame_cache::VideoImage,
 };
-use image::{Rgba, RgbaImage};
+use image::{Rgba, RgbaImage, imageops};
 use rayon::prelude::*;
 use std::time::Duration;
 
@@ -87,7 +87,22 @@ impl FlyInFilter {
         }
     }
 
-    fn apply_move(&self, buffer: &mut RgbaImage, frame_time_offset: Duration) -> Result<()> {
+    fn apply_move(
+        &self,
+        buffer: &mut RgbaImage,
+        canvas_width: u32,
+        canvas_height: u32,
+        frame_time_offset: Duration,
+    ) -> Result<()> {
+        // Ensure buffer is canvas-sized (decoded frames may be smaller than canvas)
+        if buffer.width() != canvas_width || buffer.height() != canvas_height {
+            let mut canvas = RgbaImage::new(canvas_width, canvas_height);
+            let x = (canvas_width.saturating_sub(buffer.width())) / 2;
+            let y = (canvas_height.saturating_sub(buffer.height())) / 2;
+            imageops::overlay(&mut canvas, buffer, x as i64, y as i64);
+            *buffer = canvas;
+        }
+
         // Calculate ratio - after duration, stay at final position (ratio = 1.0)
         let ratio = if frame_time_offset > self.duration {
             1.0
@@ -96,7 +111,9 @@ impl FlyInFilter {
         };
         let eased_ratio = self.easing.apply(ratio);
 
-        let (width, height) = (buffer.width(), buffer.height());
+        // Use canvas dimensions for animation calculations
+        let width = canvas_width;
+        let height = canvas_height;
 
         // Calculate fly-in start position (image center just outside canvas edge)
         let start_pos = Self::calculate_entry_direction(self.move_to_position);
@@ -135,11 +152,18 @@ impl FlyInFilter {
 impl VideoFilter for FlyInFilter {
     crate::impl_default_video_filter!(FlyInFilter);
 
+    fn take_effect_in_layer_frame(&self) -> bool {
+        false // Operate on image_for_composite stream, consistent with transform
+    }
+
     fn apply(&self, data: &mut VideoData) -> Result<()> {
+        let canvas_width = data.config.output_width;
+        let canvas_height = data.config.output_height;
         let frame_time_offset = data.relative_timeline_offset;
+
         for frame in data.frames.iter_mut() {
             if let VideoImage::Image { buffer, .. } = frame {
-                self.apply_move(buffer, frame_time_offset)?;
+                self.apply_move(buffer, canvas_width, canvas_height, frame_time_offset)?;
             }
         }