feat(enhanced-vision): implement BilateralFilter kernel

- vxu_bilateral_filter_impl: spatial + range Gaussian filter for U8/S16 tensors
- vxBilateralFilterNode: graph node constructor (5 params: src, diameter, sigma_space, sigma_values, dst)
- vxuBilateralFilter: immediate-mode wrapper
- Register kernel (0x38) in c_api.rs
- Add dispatch in unified_c_api.rs + output param tracking
- Builds clean, no regressions

Author: Kiriti

openvx-core/src/c_api.rs

@@ -359,6 +359,7 @@ fn register_standard_kernels(context_id: u32) {
         ("org.khronos.openvx.hough_lines_p", 0x34, 8),
         ("org.khronos.openvx.match_template", 0x2D, 4),
         ("org.khronos.openvx.lbp", 0x2E, 4),
+        ("org.khronos.openvx.bilateral_filter", 0x38, 5),
         // OpenVX 1.0.2 addition
         ("org.khronos.openvx.weighted_average", 0x40, 4),
         // OpenVX 1.1 extensions

openvx-core/src/unified_c_api.rs

@@ -638,6 +638,34 @@ fn read_scalar_enum(scalar: vx_scalar) -> Option<vx_enum> {
     }
 }
 
+fn read_scalar_i32(scalar: vx_scalar) -> Option<i32> {
+    if scalar.is_null() {
+        return None;
+    }
+    unsafe {
+        let s = &*(scalar as *const crate::c_api_data::VxCScalarData);
+        if s.data.len() >= 4 {
+            Some(i32::from_le_bytes([s.data[0], s.data[1], s.data[2], s.data[3]]))
+        } else {
+            None
+        }
+    }
+}
+
+fn read_scalar_f32(scalar: vx_scalar) -> Option<f32> {
+    if scalar.is_null() {
+        return None;
+    }
+    unsafe {
+        let s = &*(scalar as *const crate::c_api_data::VxCScalarData);
+        if s.data.len() >= 4 {
+            Some(f32::from_le_bytes([s.data[0], s.data[1], s.data[2], s.data[3]]))
+        } else {
+            None
+        }
+    }
+}
+
 fn is_image_reference(ref_id: u64) -> bool {
     if let Ok(types) = REFERENCE_TYPES.lock() {
         if let Some(ref_type) = types.get(&(ref_id as usize)) {
@@ -1090,6 +1118,7 @@ pub extern "C" fn vxVerifyGraph(graph: vx_graph) -> vx_status {
                 ("org.khronos.openvx.non_linear_filter", vec![3]), // [input, matrix, border, output]
                 // Enhanced Vision kernels
                 ("org.khronos.openvx.copy", vec![1]), // [input, output] - param 1 is output
+                ("org.khronos.openvx.bilateral_filter", vec![4]), // [src, diameter, sigma_space, sigma_values, dst]
                 ("org.khronos.openvx.non_max_suppression", vec![3]), // [input, mask, win_size, output]
                 ("org.khronos.openvx.hough_lines_p", vec![6, 7]), // [input, rho, theta, threshold, line_length, line_gap, lines_array, num_lines]
                 ("org.khronos.openvx.match_template", vec![3]), // [src, templ, matching_method, output]
@@ -3272,6 +3301,33 @@ fn dispatch_kernel_with_border_impl(
                 VX_ERROR_INVALID_PARAMETERS
             }
         }
+        // BilateralFilter (Enhanced Vision)
+        "org.khronos.openvx.bilateral_filter" => {
+            if params.len() >= 5 {
+                let src = params[0] as vx_tensor;
+                let diameter_scalar = params[1] as vx_scalar;
+                let sigma_space_scalar = params[2] as vx_scalar;
+                let sigma_values_scalar = params[3] as vx_scalar;
+                let dst = params[4] as vx_tensor;
+                if !src.is_null() && !dst.is_null() {
+                    let diameter = read_scalar_i32(diameter_scalar).unwrap_or(0);
+                    let sigma_space = read_scalar_f32(sigma_space_scalar).unwrap_or(0.0);
+                    let sigma_values = read_scalar_f32(sigma_values_scalar).unwrap_or(0.0);
+                    crate::vxu_impl::vxu_bilateral_filter_impl(
+                        unsafe { crate::c_api::vxGetContext(src as vx_reference) },
+                        src as vx_reference,
+                        diameter,
+                        sigma_space,
+                        sigma_values,
+                        dst as vx_reference,
+                    )
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            } else {
+                VX_ERROR_INVALID_PARAMETERS
+            }
+        }
         // Multiply
         "org.khronos.openvx.multiply" => {
             if params.len() >= 6 {
@@ -5148,11 +5204,11 @@ pub extern "C" fn vxRegisterPyramidLevelImage(
 }
 
 // Tensor registry
-static TENSORS: Lazy<Mutex<HashMap<usize, Arc<VxCTensor>>>> =
+pub static TENSORS: Lazy<Mutex<HashMap<usize, Arc<VxCTensor>>>> =
     Lazy::new(|| Mutex::new(HashMap::new()));
 
 // Tensor data storage (raw bytes keyed by tensor address)
-static TENSOR_DATA: Lazy<Mutex<HashMap<usize, Vec<u8>>>> =
+pub static TENSOR_DATA: Lazy<Mutex<HashMap<usize, Vec<u8>>>> =
     Lazy::new(|| Mutex::new(HashMap::new()));
 
 // Tensor context association
@@ -13258,22 +13314,61 @@ macro_rules! ev_vxu_stub {
 }
 
 // ---- Image kernels still missing ----
-ev_node_stub!(vxBilateralFilterNode(
+#[no_mangle]
+pub extern "C" fn vxBilateralFilterNode(
     graph: vx_graph,
     src: vx_tensor,
     diameter: vx_int32,
     sigma_space: vx_float32,
     sigma_values: vx_float32,
     dst: vx_tensor,
-));
-ev_vxu_stub!(vxuBilateralFilter(
-    context: vx_context,
+) -> vx_node {
+    if graph.is_null() || src.is_null() || dst.is_null() {
+        return std::ptr::null_mut();
+    }
+    let context = crate::c_api::vxGetContext(graph as vx_reference);
+    if context.is_null() {
+        return std::ptr::null_mut();
+    }
+    unsafe {
+        let mut diameter_scalar = vxCreateScalar(context, VX_TYPE_INT32, &diameter as *const _ as *const c_void);
+        let mut sigma_space_scalar = vxCreateScalar(context, VX_TYPE_FLOAT32, &sigma_space as *const _ as *const c_void);
+        let mut sigma_values_scalar = vxCreateScalar(context, VX_TYPE_FLOAT32, &sigma_values as *const _ as *const c_void);
+        if diameter_scalar.is_null() || sigma_space_scalar.is_null() || sigma_values_scalar.is_null() {
+            vxReleaseScalar(&mut diameter_scalar);
+            vxReleaseScalar(&mut sigma_space_scalar);
+            vxReleaseScalar(&mut sigma_values_scalar);
+            return std::ptr::null_mut();
+        }
+        let node = create_node_with_params(
+            graph,
+            "org.khronos.openvx.bilateral_filter",
+            &[
+                src as vx_reference,
+                diameter_scalar as vx_reference,
+                sigma_space_scalar as vx_reference,
+                sigma_values_scalar as vx_reference,
+                dst as vx_reference,
+            ],
+        );
+        vxReleaseScalar(&mut diameter_scalar);
+        vxReleaseScalar(&mut sigma_space_scalar);
+        vxReleaseScalar(&mut sigma_values_scalar);
+        node
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn vxuBilateralFilter(
+    _context: vx_context,
     src: vx_tensor,
     diameter: vx_int32,
     sigma_space: vx_float32,
     sigma_values: vx_float32,
     dst: vx_tensor,
-));
+) -> vx_status {
+    unsafe { crate::vxu_impl::vxu_bilateral_filter_impl(_context, src as vx_reference, diameter, sigma_space, sigma_values, dst as vx_reference) }
+}
 
 #[no_mangle]
 pub extern "C" fn vxLBPNode(