fix: resolve clippy lint errors in video nodes

Co-Authored-By: Claudio Costa <cstcld91@gmail.com>

Author: streamkit-devin

crates/nodes/src/containers/webm.rs

@@ -418,7 +418,7 @@ impl ProcessorNode for WebMMuxerNode {
         let mut video_rx: Option<tokio::sync::mpsc::Receiver<Packet>> = None;
 
         for (pin_name, rx) in context.inputs.drain() {
-            let is_video = context.input_types.get(&pin_name).map_or(false, |ty| {
+            let is_video = context.input_types.get(&pin_name).is_some_and(|ty| {
                 matches!(ty, PacketType::EncodedVideo(_) | PacketType::RawVideo(_))
             });
 

crates/nodes/src/video/colorbars.rs

@@ -70,8 +70,7 @@ fn parse_pixel_format(s: &str) -> Result<PixelFormat, StreamKitError> {
         "i420" => Ok(PixelFormat::I420),
         "rgba8" | "rgba" => Ok(PixelFormat::Rgba8),
         other => Err(StreamKitError::Configuration(format!(
-            "Unsupported pixel format '{}'. Use 'i420' or 'rgba8'.",
-            other
+            "Unsupported pixel format '{other}'. Use 'i420' or 'rgba8'."
         ))),
     }
 }
@@ -143,7 +142,7 @@ impl ProcessorNode for ColorBarsNode {
         let mut template = vec![0u8; total_bytes];
         match pixel_format {
             PixelFormat::I420 => {
-                generate_smpte_colorbars_i420(width, height, &mut template, &layout)
+                generate_smpte_colorbars_i420(width, height, &mut template, &layout);
             },
             PixelFormat::Rgba8 => generate_smpte_colorbars_rgba8(width, height, &mut template),
         }
@@ -231,10 +230,10 @@ impl ProcessorNode for ColorBarsNode {
                 pooled.as_mut_slice()[..total_bytes].copy_from_slice(&template);
                 match pixel_format {
                     PixelFormat::I420 => {
-                        draw_sweep_bar_i420(pooled.as_mut_slice(), width, height, &layout, seq)
+                        draw_sweep_bar_i420(pooled.as_mut_slice(), width, height, &layout, seq);
                     },
                     PixelFormat::Rgba8 => {
-                        draw_sweep_bar_rgba8(pooled.as_mut_slice(), width, height, seq)
+                        draw_sweep_bar_rgba8(pooled.as_mut_slice(), width, height, seq);
                     },
                 }
                 streamkit_core::types::VideoFrame::from_pooled(
@@ -248,7 +247,7 @@ impl ProcessorNode for ColorBarsNode {
                 let mut data = template.clone();
                 match pixel_format {
                     PixelFormat::I420 => {
-                        draw_sweep_bar_i420(&mut data, width, height, &layout, seq)
+                        draw_sweep_bar_i420(&mut data, width, height, &layout, seq);
                     },
                     PixelFormat::Rgba8 => draw_sweep_bar_rgba8(&mut data, width, height, seq),
                 }
@@ -338,7 +337,7 @@ fn draw_sweep_bar_i420(
     let chroma_w = u_plane.width as usize;
     let chroma_h = u_plane.height as usize;
     let chroma_bar_x = bar_x / 2;
-    let chroma_bar_w = (bar_width + 1) / 2; // round up
+    let chroma_bar_w = bar_width.div_ceil(2); // round up
     for row in 0..chroma_h {
         for dx in 0..chroma_bar_w {
             let col = (chroma_bar_x + dx) % chroma_w;

crates/nodes/src/video/compositor/config.rs

@@ -133,8 +133,7 @@ pub(crate) fn parse_pixel_format(s: &str) -> Result<PixelFormat, StreamKitError>
         "rgba8" | "rgba" => Ok(PixelFormat::Rgba8),
         "i420" => Ok(PixelFormat::I420),
         other => Err(StreamKitError::Configuration(format!(
-            "Unsupported output pixel format '{}'. Use 'rgba8' or 'i420'.",
-            other
+            "Unsupported output pixel format '{other}'. Use 'rgba8' or 'i420'."
         ))),
     }
 }

crates/nodes/src/video/compositor/kernel.rs

@@ -18,7 +18,7 @@ use super::pixel_ops::{blit_overlay, i420_to_rgba8_buf, scale_blit_rgba};
 // ── Compositing kernel (runs on a persistent blocking thread) ────────────────
 
 /// Snapshot of one input layer's data for the blocking compositor thread.
-pub(crate) struct LayerSnapshot {
+pub struct LayerSnapshot {
     pub data: Arc<streamkit_core::frame_pool::PooledVideoData>,
     pub width: u32,
     pub height: u32,
@@ -28,7 +28,7 @@ pub(crate) struct LayerSnapshot {
 }
 
 /// Work item sent from the async loop to the persistent compositing thread.
-pub(crate) struct CompositeWorkItem {
+pub struct CompositeWorkItem {
     pub canvas_w: u32,
     pub canvas_h: u32,
     pub layers: Vec<Option<LayerSnapshot>>,
@@ -39,7 +39,7 @@ pub(crate) struct CompositeWorkItem {
 }
 
 /// Result sent back from the compositing thread to the async loop.
-pub(crate) struct CompositeResult {
+pub struct CompositeResult {
     pub output_format: PixelFormat,
     pub rgba_data: Option<streamkit_core::frame_pool::PooledVideoData>,
     pub i420_data: Option<streamkit_core::frame_pool::PooledVideoData>,
@@ -50,7 +50,7 @@ pub(crate) struct CompositeResult {
 ///
 /// `i420_scratch` is a reusable buffer for I420→RGBA8 conversion, avoiding
 /// per-frame allocation.
-pub(crate) fn composite_frame(
+pub fn composite_frame(
     canvas_w: u32,
     canvas_h: u32,
     layers: &[Option<LayerSnapshot>],
@@ -123,7 +123,7 @@ pub(crate) fn composite_frame(
 /// - There are no image or text overlays
 ///
 /// Returns the index of the pass-through layer, or `None` if compositing is needed.
-pub(crate) fn try_i420_passthrough(
+pub fn try_i420_passthrough(
     canvas_w: u32,
     canvas_h: u32,
     layers: &[Option<LayerSnapshot>],

crates/nodes/src/video/compositor/mod.rs

@@ -322,8 +322,8 @@ impl ProcessorNode for CompositorNode {
                     // (no intermediate scratch — avoids a full extra memcpy).
                     let w = work.canvas_w as usize;
                     let h = work.canvas_h as usize;
-                    let chroma_w = (w + 1) / 2;
-                    let chroma_h = (h + 1) / 2;
+                    let chroma_w = w.div_ceil(2);
+                    let chroma_h = h.div_ceil(2);
                     let i420_size = w * h + 2 * chroma_w * chroma_h;
                     let mut i420_pooled = if let Some(ref pool) = work.video_pool {
                         pool.get(i420_size)
@@ -560,13 +560,12 @@ impl ProcessorNode for CompositorNode {
                 break;
             }
 
-            let composite_result = match result_rx.recv().await {
-                Some(r) => r,
-                None => {
-                    tracing::debug!("Compositing result channel closed");
-                    stop_reason = "compositor_thread_gone";
-                    break;
-                },
+            let composite_result = if let Some(r) = result_rx.recv().await {
+                r
+            } else {
+                tracing::debug!("Compositing result channel closed");
+                stop_reason = "compositor_thread_gone";
+                break;
             };
 
             // Build metadata from the first available input frame.

crates/nodes/src/video/compositor/overlay.rs

@@ -11,7 +11,7 @@ use streamkit_core::StreamKitError;
 
 /// A pre-decoded RGBA bitmap overlay ready for per-frame blitting.
 #[derive(Clone)]
-pub(crate) struct DecodedOverlay {
+pub struct DecodedOverlay {
     pub rgba_data: Vec<u8>,
     pub width: u32,
     pub height: u32,
@@ -20,9 +20,7 @@ pub(crate) struct DecodedOverlay {
 }
 
 /// Decode a base64-encoded image (PNG/JPEG) into an RGBA8 bitmap.
-pub(crate) fn decode_image_overlay(
-    config: &ImageOverlayConfig,
-) -> Result<DecodedOverlay, StreamKitError> {
+pub fn decode_image_overlay(config: &ImageOverlayConfig) -> Result<DecodedOverlay, StreamKitError> {
     use image::GenericImageView;
 
     use base64::Engine;
@@ -48,7 +46,7 @@ pub(crate) fn decode_image_overlay(
 }
 
 /// Rasterize a text overlay into an RGBA8 bitmap using `tiny-skia`.
-pub(crate) fn rasterize_text_overlay(config: &TextOverlayConfig) -> DecodedOverlay {
+pub fn rasterize_text_overlay(config: &TextOverlayConfig) -> DecodedOverlay {
     let w = config.rect.width.max(1);
     let h = config.rect.height.max(1);
 

crates/nodes/src/video/compositor/pixel_ops.rs

@@ -21,7 +21,7 @@ use super::overlay::DecodedOverlay;
 /// Rows are processed in parallel via `rayon` when the blit region is large
 /// enough to benefit from multi-core dispatch.
 #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss, clippy::too_many_arguments)]
-pub(crate) fn scale_blit_rgba(
+pub fn scale_blit_rgba(
     dst: &mut [u8],
     dst_width: u32,
     dst_height: u32,
@@ -165,12 +165,12 @@ fn blit_row_opaque(
             row_slice[dst_idx + 2] = sb;
             row_slice[dst_idx + 3] = 255;
         } else if sa > 0 {
-            let a16 = sa as u16;
+            let a16 = u16::from(sa);
             row_slice[dst_idx] = blend_u8(sr, row_slice[dst_idx], a16);
             row_slice[dst_idx + 1] = blend_u8(sg, row_slice[dst_idx + 1], a16);
             row_slice[dst_idx + 2] = blend_u8(sb, row_slice[dst_idx + 2], a16);
             // Composite alpha: a_out = a_src + a_dst * (1 - a_src)
-            let da = row_slice[dst_idx + 3] as u16;
+            let da = u16::from(row_slice[dst_idx + 3]);
             row_slice[dst_idx + 3] = (a16 + ((da * (255 - a16) + 128) >> 8)).min(255) as u8;
         }
     }
@@ -221,7 +221,7 @@ fn blit_row_alpha(
         }
 
         // Effective alpha: (sa * opacity) / 255, done in integer.
-        let sa_eff = ((sa as u16 * opacity_u16 + 128) >> 8).min(255) as u16;
+        let sa_eff = ((u16::from(sa) * opacity_u16 + 128) >> 8).min(255);
         if sa_eff == 255 {
             row_slice[dst_idx] = sr;
             row_slice[dst_idx + 1] = sg;
@@ -231,20 +231,15 @@ fn blit_row_alpha(
             row_slice[dst_idx] = blend_u8(sr, row_slice[dst_idx], sa_eff);
             row_slice[dst_idx + 1] = blend_u8(sg, row_slice[dst_idx + 1], sa_eff);
             row_slice[dst_idx + 2] = blend_u8(sb, row_slice[dst_idx + 2], sa_eff);
-            let da = row_slice[dst_idx + 3] as u16;
+            let da = u16::from(row_slice[dst_idx + 3]);
             row_slice[dst_idx + 3] = (sa_eff + ((da * (255 - sa_eff) + 128) >> 8)).min(255) as u8;
         }
     }
 }
 
 /// Blit a pre-decoded overlay onto the canvas (full alpha blend at the
 /// overlay's configured opacity).
-pub(crate) fn blit_overlay(
-    canvas: &mut [u8],
-    canvas_w: u32,
-    canvas_h: u32,
-    overlay: &DecodedOverlay,
-) {
+pub fn blit_overlay(canvas: &mut [u8], canvas_w: u32, canvas_h: u32, overlay: &DecodedOverlay) {
     scale_blit_rgba(
         canvas,
         canvas_w,
@@ -264,14 +259,14 @@ pub(crate) fn blit_overlay(
 /// The caller must ensure `out` has length >= `width * height * 4`.
 /// Rows are processed in parallel via `rayon`.
 #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-pub(crate) fn i420_to_rgba8_buf(data: &[u8], width: u32, height: u32, out: &mut [u8]) {
+pub fn i420_to_rgba8_buf(data: &[u8], width: u32, height: u32, out: &mut [u8]) {
     use rayon::prelude::*;
 
     let w = width as usize;
     let h = height as usize;
     let y_stride = w;
-    let chroma_w = (w + 1) / 2;
-    let chroma_h = (h + 1) / 2;
+    let chroma_w = w.div_ceil(2);
+    let chroma_h = h.div_ceil(2);
     let u_offset = y_stride * h;
     let v_offset = u_offset + chroma_w * chroma_h;
     let rgba_row_stride = w * 4;
@@ -287,9 +282,9 @@ pub(crate) fn i420_to_rgba8_buf(data: &[u8], width: u32, height: u32, out: &mut
             let v_base = v_offset + chroma_row * chroma_w;
 
             for col in 0..w {
-                let y_val = data[y_base + col] as i32;
-                let u_val = data[u_base + col / 2] as i32;
-                let v_val = data[v_base + col / 2] as i32;
+                let y_val = i32::from(data[y_base + col]);
+                let u_val = i32::from(data[u_base + col / 2]);
+                let v_val = i32::from(data[v_base + col / 2]);
 
                 let c = y_val - 16;
                 let d = u_val - 128;
@@ -309,7 +304,7 @@ pub(crate) fn i420_to_rgba8_buf(data: &[u8], width: u32, height: u32, out: &mut
 ///
 /// Prefer [`i420_to_rgba8_buf`] with a pooled buffer to avoid per-frame allocation.
 #[allow(dead_code, clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-pub(crate) fn i420_to_rgba8(data: &[u8], width: u32, height: u32) -> Vec<u8> {
+pub fn i420_to_rgba8(data: &[u8], width: u32, height: u32) -> Vec<u8> {
     let mut rgba = vec![0u8; width as usize * height as usize * 4];
     i420_to_rgba8_buf(data, width, height, &mut rgba);
     rgba
@@ -320,14 +315,14 @@ pub(crate) fn i420_to_rgba8(data: &[u8], width: u32, height: u32) -> Vec<u8> {
 /// The caller must ensure `out` has length >= `w * h + 2 * ((w+1)/2) * ((h+1)/2)`.
 /// Y, U and V planes are processed in parallel via `rayon`.
 #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-pub(crate) fn rgba8_to_i420_buf(data: &[u8], width: u32, height: u32, out: &mut [u8]) {
+pub fn rgba8_to_i420_buf(data: &[u8], width: u32, height: u32, out: &mut [u8]) {
     use rayon::prelude::*;
 
     let w = width as usize;
     let h = height as usize;
     let y_stride = w;
-    let chroma_w = (w + 1) / 2;
-    let chroma_h = (h + 1) / 2;
+    let chroma_w = w.div_ceil(2);
+    let chroma_h = h.div_ceil(2);
     let y_size = y_stride * h;
     let chroma_size = chroma_w * chroma_h;
 
@@ -341,9 +336,9 @@ pub(crate) fn rgba8_to_i420_buf(data: &[u8], width: u32, height: u32, out: &mut
 
         for col in 0..w {
             let off = rgba_base + col * 4;
-            let r = data[off] as i32;
-            let g = data[off + 1] as i32;
-            let b = data[off + 2] as i32;
+            let r = i32::from(data[off]);
+            let g = i32::from(data[off + 1]);
+            let b = i32::from(data[off + 2]);
             let y = ((66 * r + 129 * g + 25 * b + 128) >> 8) + 16;
             y_row[col] = y.clamp(0, 255) as u8;
         }
@@ -370,9 +365,9 @@ pub(crate) fn rgba8_to_i420_buf(data: &[u8], width: u32, height: u32, out: &mut
                     let cc = c0 + dc;
                     if cc < w {
                         let off = (rr * w + cc) * 4;
-                        sr += data[off] as i32;
-                        sg += data[off + 1] as i32;
-                        sb += data[off + 2] as i32;
+                        sr += i32::from(data[off]);
+                        sg += i32::from(data[off + 1]);
+                        sb += i32::from(data[off + 2]);
                         count += 1;
                     }
                 }
@@ -392,11 +387,11 @@ pub(crate) fn rgba8_to_i420_buf(data: &[u8], width: u32, height: u32, out: &mut
 ///
 /// Prefer [`rgba8_to_i420_buf`] with a pooled buffer to avoid per-frame allocation.
 #[allow(dead_code, clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-pub(crate) fn rgba8_to_i420(data: &[u8], width: u32, height: u32) -> Vec<u8> {
+pub fn rgba8_to_i420(data: &[u8], width: u32, height: u32) -> Vec<u8> {
     let w = width as usize;
     let h = height as usize;
-    let chroma_w = (w + 1) / 2;
-    let chroma_h = (h + 1) / 2;
+    let chroma_w = w.div_ceil(2);
+    let chroma_h = h.div_ceil(2);
     let total = w * h + 2 * chroma_w * chroma_h;
     let mut out = vec![0u8; total];
     rgba8_to_i420_buf(data, width, height, &mut out);

crates/nodes/src/video/mod.rs

@@ -17,13 +17,13 @@ pub mod vp9;
 
 /// Registers all available video nodes with the engine's registry.
 #[allow(clippy::missing_const_for_fn)]
-pub fn register_video_nodes(_registry: &mut NodeRegistry) {
+pub fn register_video_nodes(registry: &mut NodeRegistry) {
     #[cfg(feature = "colorbars")]
-    colorbars::register_colorbars_nodes(_registry);
+    colorbars::register_colorbars_nodes(registry);
 
     #[cfg(feature = "compositor")]
-    compositor::register_compositor_nodes(_registry);
+    compositor::register_compositor_nodes(registry);
 
     #[cfg(feature = "vp9")]
-    vp9::register_vp9_nodes(_registry);
+    vp9::register_vp9_nodes(registry);
 }