Merge branch 'main' into perf/median3x3

Author: simonCatBot

openvx-core/src/kernel_fast_paths.rs

@@ -0,0 +1,224 @@
+//! Fast-path kernel implementations that avoid per-pixel get_pixel() overhead.
+//!
+//! These are called from `vxu_impl.rs` after C images have been converted to
+//! Rust `Image` objects.  Keeping them in a separate module means we can grow
+//! this file without shifting the binary layout of hot functions inside
+//! `vxu_impl.rs` (Add, AbsDiff, etc.).
+
+use crate::vxu_impl::{Image, ImageFormat};
+use crate::VxStatus;
+
+/// Optimised ChannelCombine for RGB (interleaved R-G-B).
+pub fn channel_combine_rgb(
+    r: &Image,
+    g: &Image,
+    b: &Image,
+    dst: &mut Image,
+) -> Result<(), VxStatus> {
+    let width = dst.width();
+    let height = dst.height();
+    let pixels = width * height;
+
+    let r_data = r.data();
+    let g_data = g.data();
+    let b_data = b.data();
+    let dst_data = dst.data_mut();
+
+    // Bounds checks – the caller already verified dimensions match.
+    if r_data.len() < pixels || g_data.len() < pixels || b_data.len() < pixels {
+        return Err(VxStatus::ErrorInvalidDimension);
+    }
+    if dst_data.len() < pixels * 3 {
+        return Err(VxStatus::ErrorInvalidDimension);
+    }
+
+    // Interleave three planes into one RGB buffer.
+    for y in 0..height {
+        let src_base = y * width;
+        let dst_base = y * width * 3;
+        for x in 0..width {
+            let s = src_base + x;
+            let d = dst_base + x * 3;
+            dst_data[d] = r_data[s];
+            dst_data[d + 1] = g_data[s];
+            dst_data[d + 2] = b_data[s];
+        }
+    }
+    Ok(())
+}
+
+/// Optimised ChannelCombine for RGBX (interleaved R-G-B-X).
+pub fn channel_combine_rgbx(
+    r: &Image,
+    g: &Image,
+    b: &Image,
+    a: &Image,
+    dst: &mut Image,
+) -> Result<(), VxStatus> {
+    let width = dst.width();
+    let height = dst.height();
+    let pixels = width * height;
+
+    let r_data = r.data();
+    let g_data = g.data();
+    let b_data = b.data();
+    let a_data = a.data();
+    let dst_data = dst.data_mut();
+
+    if r_data.len() < pixels || g_data.len() < pixels || b_data.len() < pixels || a_data.len() < pixels {
+        return Err(VxStatus::ErrorInvalidDimension);
+    }
+    if dst_data.len() < pixels * 4 {
+        return Err(VxStatus::ErrorInvalidDimension);
+    }
+
+    for y in 0..height {
+        let src_base = y * width;
+        let dst_base = y * width * 4;
+        for x in 0..width {
+            let s = src_base + x;
+            let d = dst_base + x * 4;
+            dst_data[d] = r_data[s];
+            dst_data[d + 1] = g_data[s];
+            dst_data[d + 2] = b_data[s];
+            dst_data[d + 3] = a_data[s];
+        }
+    }
+    Ok(())
+}
+
+/// Optimised 3×3 convolution for U8 output with Undefined border.
+/// `coeffs` are given in **OpenVX order** (already reversed by the caller).
+pub fn convolve_3x3_u8_undefined(
+    src: &Image,
+    coeffs: &[i16],
+    scale: i32,
+    dst: &mut Image,
+) -> Result<(), VxStatus> {
+    let width = src.width();
+    let height = src.height();
+    let src_data = src.data();
+    let dst_data = dst.data_mut();
+
+    if width < 3 || height < 3 {
+        // Too small for a 3×3 kernel – caller should fall back to generic path.
+        return Err(VxStatus::ErrorInvalidDimension);
+    }
+
+    let w = width as isize;
+    let row = |y: usize| &src_data[y * width..(y + 1) * width];
+
+    // Inner region: no bounds checks needed.
+    for y in 1..height - 1 {
+        let ym1 = row(y - 1);
+        let y0 = row(y);
+        let yp1 = row(y + 1);
+        let dst_row = &mut dst_data[y * width..(y + 1) * width];
+
+        for x in 1..width - 1 {
+            let mut sum: i32 = 0;
+            // Row -1
+            sum += ym1[x - 1] as i32 * coeffs[0] as i32;
+            sum += ym1[x] as i32 * coeffs[1] as i32;
+            sum += ym1[x + 1] as i32 * coeffs[2] as i32;
+            // Row  0
+            sum += y0[x - 1] as i32 * coeffs[3] as i32;
+            sum += y0[x] as i32 * coeffs[4] as i32;
+            sum += y0[x + 1] as i32 * coeffs[5] as i32;
+            // Row +1
+            sum += yp1[x - 1] as i32 * coeffs[6] as i32;
+            sum += yp1[x] as i32 * coeffs[7] as i32;
+            sum += yp1[x + 1] as i32 * coeffs[8] as i32;
+
+            let val = (sum / scale).clamp(0, 255) as u8;
+            dst_row[x] = val;
+        }
+    }
+
+    // Edge handling (first/last row, first/last column) – for Undefined border
+    // we replicate the nearest valid pixel, which is what Khronos reference does
+    // for edges when border mode is Undefined.
+    // Top row
+    let y0 = 0;
+    let dst_row = &mut dst_data[y0 * width..(y0 + 1) * width];
+    for x in 0..width {
+        let mut sum: i32 = 0;
+        for ky in 0..3 {
+            let py = if y0 + ky == 0 { 0 } else { y0 + ky - 1 };
+            let src_row = row(py);
+            for kx in 0..3 {
+                let px = if x + kx == 0 { 0 } else if x + kx >= width { width - 1 } else { x + kx - 1 };
+                let c = coeffs[ky * 3 + kx] as i32;
+                sum += src_row[px] as i32 * c;
+            }
+        }
+        dst_row[x] = (sum / scale).clamp(0, 255) as u8;
+    }
+
+    // Bottom row
+    let ylast = height - 1;
+    let dst_row = &mut dst_data[ylast * width..(ylast + 1) * width];
+    for x in 0..width {
+        let mut sum: i32 = 0;
+        for ky in 0..3 {
+            let py = if ylast + ky >= height + 1 { height - 1 } else if ylast + ky == 0 { 0 } else { ylast + ky - 1 };
+            let src_row = row(py);
+            for kx in 0..3 {
+                let px = if x + kx == 0 { 0 } else if x + kx >= width { width - 1 } else { x + kx - 1 };
+                let c = coeffs[ky * 3 + kx] as i32;
+                sum += src_row[px] as i32 * c;
+            }
+        }
+        dst_row[x] = (sum / scale).clamp(0, 255) as u8;
+    }
+
+    // First & last column for inner rows
+    for y in 1..height - 1 {
+        let ym1 = row(y - 1);
+        let y0 = row(y);
+        let yp1 = row(y + 1);
+        let dst_row = &mut dst_data[y * width..(y + 1) * width];
+
+        // x = 0
+        {
+            let mut sum: i32 = 0;
+            for ky in 0..3 {
+                let py = y + ky - 1;
+                let src_row = match ky {
+                    0 => ym1,
+                    1 => y0,
+                    2 => yp1,
+                    _ => unreachable!(),
+                };
+                for kx in 0..3 {
+                    let px = if kx == 0 { 0 } else { kx - 1 };
+                    let c = coeffs[ky * 3 + kx] as i32;
+                    sum += src_row[px] as i32 * c;
+                }
+            }
+            dst_row[0] = (sum / scale).clamp(0, 255) as u8;
+        }
+
+        // x = width - 1
+        {
+            let mut sum: i32 = 0;
+            let xlast = width - 1;
+            for ky in 0..3 {
+                let src_row = match ky {
+                    0 => ym1,
+                    1 => y0,
+                    2 => yp1,
+                    _ => unreachable!(),
+                };
+                for kx in 0..3 {
+                    let px = if xlast + kx >= width + 1 { width - 1 } else { xlast + kx - 1 };
+                    let c = coeffs[ky * 3 + kx] as i32;
+                    sum += src_row[px] as i32 * c;
+                }
+            }
+            dst_row[xlast] = (sum / scale).clamp(0, 255) as u8;
+        }
+    }
+
+    Ok(())
+}

openvx-core/src/lib.rs

@@ -8,6 +8,7 @@ pub mod simd_kernels;
 pub mod types;
 pub mod unified_c_api;
 pub mod vxu_impl;
+pub mod kernel_fast_paths;
 
 pub use c_api::vx_status;
 pub use context::{Context, KernelTrait};