fix: NonLinearFilter and Convolve ref counting + algorithm bugs

- Fix ref counting in vxConvolveNode and vxNonLinearFilterNode (dangling refs)
- Fix NonLinearFilter algorithm for MIN/MAX/MEDIAN with BOX/CROSS/DISK patterns
- Fix Convolve algorithm for identity/random kernels with proper scaling
- Handle border mode correctly for VX_BORDER_UNDEFINED
- Fix threshold data type handling in c_api_data.rs

Author: CI Bot

nlf_calc.bmp

@@ -290,6 +290,7 @@ fn register_standard_kernels(context_id: u32) {
         ("org.khronos.openvx.gaussian_3x3", 0x13, 2),
         ("org.khronos.openvx.box_3x3", 0x12, 2),
         ("org.khronos.openvx.median_3x3", 0x11, 2),
+        ("org.khronos.openvx.convolve", 0x16, 3),
         ("org.khronos.openvx.custom_convolution", 0x14, 3),
         ("org.khronos.openvx.gaussian_pyramid", 0x15, 2),
         // Morphology
@@ -1542,7 +1543,7 @@ pub extern "C" fn vxGetKernelByEnum(context: vx_context, kernel_e: vx_enum) -> v
         // 2-parameter kernels
         0x0E | 0x11 | 0x12 | 0x13 | 0x15 | 0x1C | 0x1D | 0x1E | 0x1F => 2,
         // 3-parameter kernels
-        0x01 | 0x04 | 0x05 | 0x06 | 0x10 | 0x0B | 0x0D | 0x22 | 0x29 | 0x2B => 3,
+        0x01 | 0x04 | 0x05 | 0x06 | 0x10 | 0x0B | 0x0D | 0x16 | 0x22 | 0x29 | 0x2B => 3,
         // 4-parameter kernels
         0x02 | 0x07 | 0x08 | 0x09 | 0x0A | 0x0C | 0x14 | 0x1A | 0x21 | 0x23 | 0x24 | 0x28 | 0x2C | 0x40 => 4,
         // 5-parameter kernels (fast_corners, canny_edge)

nlf_ref.bmp

@@ -280,11 +280,11 @@ pub extern "C" fn vxReleaseScalar(scalar: *mut vx_scalar) -> vx_status {
 
 /// Convolution structure for C API
 pub struct VxCConvolutionData {
-    columns: vx_size,
-    rows: vx_size,
-    scale: vx_uint32,
-    data: RwLock<Vec<i16>>,
-    context: vx_context,
+    pub columns: vx_size,
+    pub rows: vx_size,
+    pub scale: vx_uint32,
+    pub data: RwLock<Vec<i16>>,
+    pub context: vx_context,
 }
 
 /// Create a convolution

nlf_src.bmp

@@ -2788,7 +2788,8 @@ fn dispatch_kernel_with_border(kernel_name: &str, params: &[vx_reference], borde
                         unsafe { crate::c_api::vxGetContext(input as vx_reference) },
                         input,
                         conv,
-                        output
+                        output,
+                        border,
                     )
                 } else {
                     VX_ERROR_INVALID_PARAMETERS
@@ -3547,15 +3548,16 @@ pub const VX_CONTEXT_ATTRIBUTE_VERSION: vx_enum = 0x00080101;          // +0x1
 pub const VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNELS: vx_enum = 0x00080102;  // +0x2
 pub const VX_CONTEXT_ATTRIBUTE_MODULES: vx_enum = 0x00080103;        // +0x3
 pub const VX_CONTEXT_ATTRIBUTE_REFERENCES: vx_enum = 0x00080104;       // +0x4
-pub const VX_CONTEXT_ATTRIBUTE_USER_MEMORY: vx_enum = 0x00080105;      // +0x5
-pub const VX_CONTEXT_ATTRIBUTE_IMPLEMENTATION: vx_enum = 0x00080106; // +0x6
-pub const VX_CONTEXT_ATTRIBUTE_EXTENSIONS_SIZE: vx_enum = 0x00080107; // +0x7
-pub const VX_CONTEXT_ATTRIBUTE_EXTENSIONS: vx_enum = 0x00080108;       // +0x8
-pub const VX_CONTEXT_ATTRIBUTE_USER_MEMORY_FREE: vx_enum = 0x00080109; // +0x9 (callback for user memory deallocation)
-pub const VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER: vx_enum = 0x0008010A; // +0xA
-pub const VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER_POLICY: vx_enum = 0x0008010C; // +0xC
+pub const VX_CONTEXT_ATTRIBUTE_IMPLEMENTATION: vx_enum = 0x00080105; // +0x5
+pub const VX_CONTEXT_ATTRIBUTE_EXTENSIONS_SIZE: vx_enum = 0x00080106; // +0x6
+pub const VX_CONTEXT_ATTRIBUTE_EXTENSIONS: vx_enum = 0x00080107;       // +0x7
 pub const VX_CONTEXT_ATTRIBUTE_CONVOLUTION_MAX_DIMENSION: vx_enum = 0x00080108; // +0x8
 pub const VX_CONTEXT_ATTRIBUTE_OPTICAL_FLOW_MAX_WINDOW: vx_enum = 0x00080109; // +0x9
+pub const VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER: vx_enum = 0x0008010A; // +0xA
+pub const VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNEL_TABLE: vx_enum = 0x0008010B; // +0xB
+pub const VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER_POLICY: vx_enum = 0x0008010C; // +0xC
+pub const VX_CONTEXT_ATTRIBUTE_NONLINEAR_MAX_DIMENSION: vx_enum = 0x0008010D; // +0xD
+pub const VX_CONTEXT_ATTRIBUTE_MAX_TENSOR_DIMS: vx_enum = 0x0008010E; // +0xE
 
 // Context version (OpenVX 1.3.1 = 1.3)
 // Packed as (major << 8) | minor, with patch in upper bits for 1.3.x
@@ -3694,6 +3696,16 @@ pub extern "C" fn vxQueryContext(
                     VX_ERROR_INVALID_PARAMETERS
                 }
             }
+            VX_CONTEXT_ATTRIBUTE_CONVOLUTION_MAX_DIMENSION => {
+                // vx_size is expected per spec
+                if size == std::mem::size_of::<vx_size>() {
+                    // Return max convolution dimension (must be >= 9 per spec)
+                    *(ptr as *mut vx_size) = 15;
+                    VX_SUCCESS
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            }
             VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER => {
                 // vx_border_t is expected per spec
                 if size != std::mem::size_of::<vx_border_t>() {
@@ -3749,9 +3761,9 @@ pub extern "C" fn vxSetContextAttribute(
     }
 
     match attribute {
-        VX_CONTEXT_ATTRIBUTE_USER_MEMORY => {
-            // Handle user memory settings
-            VX_SUCCESS
+        VX_CONTEXT_ATTRIBUTE_IMPLEMENTATION => {
+            // Implementation string is read-only per spec
+            VX_ERROR_NOT_SUPPORTED
         }
         VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER => {
             // Handle immediate border mode - store for later use
@@ -5273,10 +5285,10 @@ pub const VX_MATRIX_PATTERN: vx_enum = 0x80b05;
 pub const VX_MATRIX_ELEMENT_SIZE: vx_enum = 0x80b06;
 
 // Convolution attributes
-pub const VX_CONVOLUTION_ROWS: vx_enum = 0x00;
-pub const VX_CONVOLUTION_COLUMNS: vx_enum = 0x01;
-pub const VX_CONVOLUTION_SCALE: vx_enum = 0x02;
-pub const VX_CONVOLUTION_SIZE: vx_enum = 0x03;
+pub const VX_CONVOLUTION_ROWS: vx_enum = 0x80C00;
+pub const VX_CONVOLUTION_COLUMNS: vx_enum = 0x80C01;
+pub const VX_CONVOLUTION_SCALE: vx_enum = 0x80C02;
+pub const VX_CONVOLUTION_SIZE: vx_enum = 0x80C03;
 
 // LUT attributes
 pub const VX_LUT_TYPE: vx_enum = 0x80700;
@@ -5628,9 +5640,47 @@ pub extern "C" fn vxQueryConvolution(
     size: usize,
 ) -> i32 {
     if conv.is_null() || ptr.is_null() {
-        return -2;
+        return VX_ERROR_INVALID_REFERENCE;
+    }
+    unsafe {
+        let c = &*(conv as *const crate::c_api_data::VxCConvolutionData);
+        match attribute {
+            VX_CONVOLUTION_ROWS => {
+                if size == std::mem::size_of::<vx_size>() {
+                    *(ptr as *mut vx_size) = c.rows;
+                    VX_SUCCESS
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            }
+            VX_CONVOLUTION_COLUMNS => {
+                if size == std::mem::size_of::<vx_size>() {
+                    *(ptr as *mut vx_size) = c.columns;
+                    VX_SUCCESS
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            }
+            VX_CONVOLUTION_SCALE => {
+                if size == std::mem::size_of::<vx_uint32>() {
+                    *(ptr as *mut vx_uint32) = c.scale;
+                    VX_SUCCESS
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            }
+            VX_CONVOLUTION_SIZE => {
+                if size == std::mem::size_of::<vx_size>() {
+                    let data_size = c.columns * c.rows * std::mem::size_of::<i16>();
+                    *(ptr as *mut vx_size) = data_size;
+                    VX_SUCCESS
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            }
+            _ => VX_ERROR_NOT_SUPPORTED
+        }
     }
-    -30
 }
 
 #[no_mangle]
@@ -5641,9 +5691,22 @@ pub extern "C" fn vxSetConvolutionAttribute(
     size: usize,
 ) -> i32 {
     if conv.is_null() || ptr.is_null() {
-        return -2;
+        return VX_ERROR_INVALID_REFERENCE;
+    }
+    unsafe {
+        let c = &mut *(conv as *mut crate::c_api_data::VxCConvolutionData);
+        match attribute {
+            VX_CONVOLUTION_SCALE => {
+                if size == std::mem::size_of::<vx_uint32>() {
+                    c.scale = *(ptr as *const vx_uint32);
+                    VX_SUCCESS
+                } else {
+                    VX_ERROR_INVALID_PARAMETERS
+                }
+            }
+            _ => VX_ERROR_NOT_SUPPORTED
+        }
     }
-    -30
 }
 
 #[no_mangle]
@@ -8795,7 +8858,7 @@ pub extern "C" fn vxuConvolve(
     conv: vx_convolution,
     output: vx_image,
 ) -> i32 {
-    crate::vxu_impl::vxu_convolve_impl(context, input, conv, output)
+    crate::vxu_impl::vxu_convolve_impl(context, input, conv, output, None)
 }
 
 #[no_mangle]
@@ -9521,7 +9584,7 @@ pub extern "C" fn vxNonLinearFilterNode(
         return std::ptr::null_mut();
     }
 
-    let function_scalar = vxCreateScalar(context, VX_TYPE_ENUM, &function as *const _ as *const c_void);
+    let mut function_scalar = vxCreateScalar(context, VX_TYPE_ENUM, &function as *const _ as *const c_void);
     if function_scalar.is_null() {
         return std::ptr::null_mut();
     }
@@ -9533,6 +9596,11 @@ pub extern "C" fn vxNonLinearFilterNode(
           matrix as vx_reference, output as vx_reference],
     );
 
+    // Release the scalar since create_node_with_params retains it via vxSetParameterByIndex
+    if !function_scalar.is_null() {
+        crate::c_api_data::vxReleaseScalar(&mut function_scalar as *mut _ as *mut vx_scalar);
+    }
+
     node
 }
 

openvx-core/src/c_api.rs

@@ -2676,35 +2676,108 @@ pub fn vxu_median3x3_impl_with_border(
 pub fn vxu_convolve_impl(
     context: vx_context,
     input: vx_image,
-    _conv: vx_convolution,
+    conv: vx_convolution,
     output: vx_image,
+    border: Option<crate::unified_c_api::vx_border_t>,
 ) -> vx_status {
-    if context.is_null() || input.is_null() || _conv.is_null() || output.is_null() {
+    if context.is_null() || input.is_null() || conv.is_null() || output.is_null() {
         return VX_ERROR_INVALID_REFERENCE;
     }
 
-    // For now, apply a simple sharpening kernel
     unsafe {
         let src = match c_image_to_rust(input) {
             Some(img) => img,
             None => return VX_ERROR_INVALID_PARAMETERS,
         };
 
-        let mut dst = match create_matching_image(output) {
-            Some(img) => img,
+        let (_, _, dst_format) = match get_image_info(output) {
+            Some(info) => info,
             None => return VX_ERROR_INVALID_PARAMETERS,
         };
 
-        // Default sharpening kernel
-        let kernel: [[i32; 3]; 3] = [
-            [0, -1, 0],
-            [-1, 5, -1],
-            [0, -1, 0],
-        ];
+        // Read convolution data
+        let conv_data = &*(conv as *const crate::c_api_data::VxCConvolutionData);
+        let cols = conv_data.columns;
+        let rows = conv_data.rows;
+        let scale = conv_data.scale;
+        if scale == 0 {
+            return VX_ERROR_INVALID_PARAMETERS;
+        }
 
-        match convolve_generic(&src, &mut dst, &kernel, BorderMode::Replicate) {
-            Ok(_) => copy_rust_to_c_image(&dst, output),
-            Err(_) => VX_ERROR_INVALID_PARAMETERS,
+        let coeffs = match conv_data.data.read() {
+            Ok(d) => d.clone(),
+            Err(_) => return VX_ERROR_INVALID_PARAMETERS,
+        };
+
+        // Determine border mode
+        let border_mode = match border {
+            Some(b) => crate::unified_c_api::border_from_vx(&Some(b)),
+            None => get_border_from_context(context),
+        };
+
+        let width = src.width;
+        let height = src.height;
+
+        // OpenVX convolve: coefficients are reversed (data[cols*rows-1-i])
+        // Kernel center is at (cols/2, rows/2)
+        let origin_x = cols / 2;
+        let origin_y = rows / 2;
+
+        if dst_format == VX_DF_IMAGE_S16 {
+            let mut dst = match Image::new(width, height, ImageFormat::GrayS16) {
+                Some(img) => img,
+                None => return VX_ERROR_INVALID_PARAMETERS,
+            };
+
+            for y in 0..height {
+                for x in 0..width {
+                    let mut sum: i32 = 0;
+                    for ky in 0..rows {
+                        for kx in 0..cols {
+                            let coeff_idx = (rows - 1 - ky) * cols + (cols - 1 - kx);
+                            let coeff = coeffs[coeff_idx] as i32;
+                            let px = x as isize + kx as isize - origin_x as isize;
+                            let py = y as isize + ky as isize - origin_y as isize;
+                            let pixel = get_pixel_bordered(&src, px, py, border_mode) as i32;
+                            sum += pixel * coeff;
+                        }
+                    }
+                    let value = sum / scale as i32;
+                    let clamped = value.clamp(i16::MIN as i32, i16::MAX as i32) as i16;
+                    dst.set_pixel_s16(x, y, clamped);
+                }
+            }
+            copy_rust_to_c_image(&dst, output)
+        } else {
+            // U8 output
+            let mut dst = match create_matching_image(output) {
+                Some(img) => img,
+                None => return VX_ERROR_INVALID_PARAMETERS,
+            };
+            let dst_data = dst.data_mut();
+
+            for y in 0..height {
+                for x in 0..width {
+                    let mut sum: i32 = 0;
+                    for ky in 0..rows {
+                        for kx in 0..cols {
+                            let coeff_idx = (rows - 1 - ky) * cols + (cols - 1 - kx);
+                            let coeff = coeffs[coeff_idx] as i32;
+                            let px = x as isize + kx as isize - origin_x as isize;
+                            let py = y as isize + ky as isize - origin_y as isize;
+                            let pixel = get_pixel_bordered(&src, px, py, border_mode) as i32;
+                            sum += pixel * coeff;
+                        }
+                    }
+                    let value = sum / scale as i32;
+                    let clamped = value.clamp(0, 255) as u8;
+                    let idx = y * width + x;
+                    if let Some(p) = dst_data.get_mut(idx) {
+                        *p = clamped;
+                    }
+                }
+            }
+            copy_rust_to_c_image(&dst, output)
         }
     }
 }
@@ -6446,9 +6519,9 @@ pub fn vxu_non_linear_filter_impl(
         return VX_ERROR_INVALID_REFERENCE;
     }
 
-    // VX_NONLINEAR_FILTER_MEDIAN = 40960
-    // VX_NONLINEAR_FILTER_MIN = 40961
-    // VX_NONLINEAR_FILTER_MAX = 40962
+    // VX_NONLINEAR_FILTER_MEDIAN = 0x16000 = 90112
+    // VX_NONLINEAR_FILTER_MIN = 0x16001 = 90113
+    // VX_NONLINEAR_FILTER_MAX = 0x16002 = 90114
 
     // Convert border mode
     let border_mode = crate::unified_c_api::border_from_vx(&border);
@@ -6510,15 +6583,15 @@ pub fn vxu_non_linear_filter_impl(
                 }
 
                 let value = match function {
-                    // VX_NONLINEAR_FILTER_MIN = 40961
-                    40961 => {
+                    // VX_NONLINEAR_FILTER_MIN = 0x16001 = 90113
+                    90113 => {
                         values.iter().copied().min().unwrap_or(0)
                     }
-                    // VX_NONLINEAR_FILTER_MAX = 40962
-                    40962 => {
+                    // VX_NONLINEAR_FILTER_MAX = 0x16002 = 90114
+                    90114 => {
                         values.iter().copied().max().unwrap_or(0)
                     }
-                    // VX_NONLINEAR_FILTER_MEDIAN = 40960 (default)
+                    // VX_NONLINEAR_FILTER_MEDIAN = 0x16000 = 90112 (default)
                     _ => {
                         values.sort_unstable();
                         values[values.len() / 2]