[*] refactor

Author: heng30

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

@@ -5,6 +5,7 @@ pub mod fade_in;
 pub mod fade_out;
 pub mod flip;
 pub mod fly_in;
+pub mod mosaic;
 pub mod opacity;
 pub mod slide;
 pub mod transform;
@@ -18,6 +19,7 @@ pub use fade_in::FadeInFilter;
 pub use fade_out::FadeOutFilter;
 pub use flip::{FlipDirection, FlipFilter};
 pub use fly_in::FlyInFilter;
+pub use mosaic::MosaicFilter;
 pub use opacity::OpacityFilter;
 pub use slide::{SlideDirection, SlideFilter};
 pub use transform::TransformFilter;
@@ -35,6 +37,7 @@ pub fn all_filter_names() -> &'static [&'static str] {
         FlipFilter::NAME,
         FadeInFilter::NAME,
         FadeOutFilter::NAME,
+        MosaicFilter::NAME,
         BorderFilter::NAME,
         OpacityFilter::NAME,
         ChromaKeyFilter::NAME,

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

@@ -4,12 +4,13 @@ use crate::{
     tracks::video_frame_cache::VideoImage,
 };
 use image::Rgba;
+use rayon::prelude::*;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BorderFilter {
-    pub size: u32,           // border width in pixels
-    pub color: [u8; 4],      // RGBA color
-    pub corner_radius: u32,  // rounded corner radius
+    pub size: u32,          // border width in pixels
+    pub color: [u8; 4],     // RGBA color
+    pub corner_radius: u32, // rounded corner radius
 }
 
 impl Default for BorderFilter {
@@ -26,7 +27,11 @@ impl BorderFilter {
     pub const NAME: &'static str = "border";
 
     pub fn new(size: u32, color: [u8; 4], corner_radius: u32) -> Self {
-        Self { size, color, corner_radius }
+        Self {
+            size,
+            color,
+            corner_radius,
+        }
     }
 
     fn draw_border(&self, image: &mut image::RgbaImage) {
@@ -54,8 +59,9 @@ impl BorderFilter {
             let inner_top = size;
             let inner_bottom = height.saturating_sub(size);
 
-            for py in 0..height {
-                for px in 0..width {
+            image
+                .par_enumerate_pixels_mut()
+                .for_each(|(px, py, pixel)| {
                     // Check if pixel is inside the inner rectangle (not in border area)
                     let inside_inner = px >= inner_left
                         && px < inner_right
@@ -69,15 +75,14 @@ impl BorderFilter {
 
                         if in_border_h || in_border_v {
                             // In border area
-                            image.put_pixel(px, py, border_color);
+                            *pixel = border_color;
                         } else {
                             // Corner area - make transparent
-                            image.get_pixel_mut(px, py)[3] = 0;
+                            pixel[3] = 0;
                         }
                     }
                     // Inside inner rectangle - keep original pixel unchanged
-                }
-            }
+                });
         } else {
             // Rounded corners - use anti-aliased border
             self.draw_rounded_border(image, width, height, size, radius, border_color);
@@ -141,15 +146,16 @@ impl BorderFilter {
         let base_alpha = border_color[3] as f32 / 255.0;
         let border_size_f = border_size as f32;
 
-        for py in 0..height {
-            for px in 0..width {
+        image
+            .par_enumerate_pixels_mut()
+            .for_each(|(px, py, pixel)| {
                 let dist = Self::distance_to_edge(px, py, width, height, radius);
 
                 // Make pixels outside the rounded rectangle transparent
                 // (beyond the anti-aliasing zone)
                 if dist < -1.0 {
-                    image.get_pixel_mut(px, py)[3] = 0; // alpha = 0
-                    continue;
+                    pixel[3] = 0; // alpha = 0
+                    return;
                 }
 
                 // Check if pixel is in the border region or its anti-aliasing zone
@@ -169,26 +175,30 @@ impl BorderFilter {
                 };
 
                 if should_draw {
-                    Self::blend_pixel(image, px, py, border_color, base_alpha * aa_factor);
+                    Self::blend_pixel_inline(pixel, border_color, base_alpha * aa_factor);
                 }
                 // Pixels inside (dist >= border_size + 1.0) keep original content
-            }
-        }
+            });
     }
 
-    
     /// Apply rounded corner mask to make corners transparent.
     /// Used when border size is 0 but corner_radius > 0.
-    fn apply_rounded_corner_mask(&self, image: &mut image::RgbaImage, width: u32, height: u32, radius: u32) {
+    fn apply_rounded_corner_mask(
+        &self,
+        image: &mut image::RgbaImage,
+        width: u32,
+        height: u32,
+        radius: u32,
+    ) {
         let radius = radius.min(width / 2).min(height / 2);
 
-        for py in 0..height {
-            for px in 0..width {
+        image
+            .par_enumerate_pixels_mut()
+            .for_each(|(px, py, pixel)| {
                 let dist = Self::distance_to_edge(px, py, width, height, radius);
 
                 // Make pixels outside the rounded rectangle transparent
                 if dist < 0.0 {
-                    let pixel = image.get_pixel_mut(px, py);
                     let alpha = pixel[3] as f32 / 255.0;
                     let new_alpha = if dist < -1.0 {
                         0.0
@@ -198,16 +208,15 @@ impl BorderFilter {
                     };
                     pixel[3] = (new_alpha * 255.0) as u8;
                 }
-            }
-        }
+            });
     }
 
-    fn blend_pixel(image: &mut image::RgbaImage, px: u32, py: u32, color: Rgba<u8>, src_alpha: f32) {
+    /// Inline version of blend_pixel for use in parallel context
+    fn blend_pixel_inline(pixel: &mut image::Rgba<u8>, color: Rgba<u8>, src_alpha: f32) {
         if src_alpha <= 0.0 {
             return;
         }
 
-        let pixel = image.get_pixel_mut(px, py);
         let dst_alpha = pixel[3] as f32 / 255.0;
         let out_alpha = src_alpha + dst_alpha * (1.0 - src_alpha);
 
@@ -237,4 +246,5 @@ impl VideoFilter for BorderFilter {
         }
         Ok(())
     }
-}
+}
+

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

@@ -4,6 +4,7 @@ use crate::{
     tracks::video_frame_cache::VideoImage,
 };
 use image::Rgba;
+use rayon::prelude::*;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ChromaKeyFilter {
@@ -46,57 +47,37 @@ impl ChromaKeyFilter {
         }
     }
 
-    fn apply_to_buffer(&self, buffer: &mut image::RgbaImage) -> Result<()> {
-        let width = buffer.width();
-        let height = buffer.height();
+    fn apply_to_buffer(&self, buffer: &mut image::RgbaImage) {
+        let target = self.target_color;
+        let similarity_threshold = self.similarity;
+        let feather = self.feather;
 
-        for y in 0..height {
-            for x in 0..width {
-                let pixel = buffer.get_pixel_mut(x, y);
-                let current = *pixel;
-                let target = self.target_color;
+        buffer.par_pixels_mut().for_each(|pixel| {
+            let current = *pixel;
 
-                let dist = (current[0] as f32 - target[0] as f32).powi(2)
-                    + (current[1] as f32 - target[1] as f32).powi(2)
-                    + (current[2] as f32 - target[2] as f32).powi(2);
+            let dist = (current[0] as f32 - target[0] as f32).powi(2)
+                + (current[1] as f32 - target[1] as f32).powi(2)
+                + (current[2] as f32 - target[2] as f32).powi(2);
 
-                let dist_norm = dist.sqrt() / 255.0;
-                let similarity_threshold = self.similarity;
-
-                let mut a = if self.feather > 0.0 {
-                    let feather_radius = self.feather;
-
-                    let in_feather = if x >= feather_radius as u32
-                        && x < width - feather_radius as u32
-                        && y >= feather_radius as u32
-                    {
-                        ((x as f32 - feather_radius).powi(2) + (y as f32 - feather_radius).powi(2))
-                            .sqrt()
-                    } else {
-                        dist.sqrt()
-                    };
-
-                    if in_feather > 0.0 { 1.0 } else { 0.0 }
-                } else {
-                    1.0
-                };
+            let dist_norm = dist.sqrt() / 255.0;
 
+            let a = if feather > 0.0 {
+                // Feather calculation simplified for parallel context
+                // The original feather logic depended on x,y coordinates which aren't available in par_pixels_mut
+                // Use distance-based transparency instead
                 if dist_norm <= similarity_threshold {
-                    a *= 0.0;
+                    0.0
                 } else {
-                    a = 1.0 - ((dist_norm - similarity_threshold).clamp(0.0, 1.0) * 0.5);
+                    1.0 - ((dist_norm - similarity_threshold).clamp(0.0, 1.0) * 0.5)
                 }
-
-                *pixel = Rgba([
-                    current[0],
-                    current[1],
-                    current[2],
-                    (current[3] as f32 * a) as u8,
-                ]);
-            }
-        }
-
-        Ok(())
+            } else if dist_norm <= similarity_threshold {
+                0.0
+            } else {
+                1.0 - ((dist_norm - similarity_threshold).clamp(0.0, 1.0) * 0.5)
+            };
+
+            pixel.0[3] = (current[3] as f32 * a) as u8;
+        });
     }
 }
 
@@ -106,7 +87,7 @@ impl VideoFilter for ChromaKeyFilter {
     fn apply(&self, data: &mut VideoData) -> Result<()> {
         for frame in &mut data.frames {
             if let VideoImage::Image { buffer, .. } = frame {
-                self.apply_to_buffer(buffer)?;
+                self.apply_to_buffer(buffer);
             }
         }
         Ok(())

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

@@ -4,7 +4,8 @@ use crate::{
     filters::traits::{EasingFunction, VideoData, VideoFilter},
     tracks::video_frame_cache::VideoImage,
 };
-use image::RgbaImage;
+use image::{Rgba, RgbaImage};
+use rayon::prelude::*;
 use std::time::Duration;
 
 #[derive(
@@ -114,20 +115,17 @@ impl FlyInFilter {
         let original = buffer.clone();
         let mut result = RgbaImage::new(width, height);
 
-        for y in 0..height {
-            for x in 0..width {
-                let src_x = x as i32 - offset_x;
-                let src_y = y as i32 - offset_y;
-
-                let pixel = if src_x >= 0 && src_x < width as i32
-                    && src_y >= 0 && src_y < height as i32 {
-                    *original.get_pixel(src_x as u32, src_y as u32)
-                } else {
-                    image::Rgba([0, 0, 0, 0])
-                };
-                result.put_pixel(x, y, pixel);
-            }
-        }
+        result.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
+            let src_x = x as i32 - offset_x;
+            let src_y = y as i32 - offset_y;
+
+            *pixel = if src_x >= 0 && src_x < width as i32
+                && src_y >= 0 && src_y < height as i32 {
+                *original.get_pixel(src_x as u32, src_y as u32)
+            } else {
+                Rgba([0, 0, 0, 0])
+            };
+        });
 
         *buffer = result;
         Ok(())