Consolidated fix: resolve open issues and PRs for OpenVX 1.3 sample impl

Build.py

@@ -89,6 +89,7 @@ def main():
     # Provisional extensions
     parser.add_option("--tiling", dest="tiling", help="Add -DOPENVX_USE_TILING=ON to support the tiling extension", default=False, action='store_true')
     parser.add_option("--s16", dest="s16", help="Add -DOPENVX_USE_S16=ON to have an extended support for S16", default=False, action='store_true')
+    parser.add_option("--userdataobj", dest="userdataobj", help="Add -DOPENVX_USE_USER_DATA_OBJECT=ON to support user data object extension", default=False, action='store_true')
     # Experimental features
     parser.add_option("--f16", dest="f16", help="Add -DEXPERIMENTAL_PLATFORM_SUPPORTS_16_FLOAT=ON to support VX_TYPE_FLOAT16", default=False, action='store_true')
     parser.add_option("--venum", dest="venum", help="Add -DEXPERIMENTAL_USE_VENUM=ON to build also raspberrypi 3B+ Neon target[Default False]", default=False, action='store_true')
@@ -232,6 +233,8 @@ def main():
         cmd += ['-DEXPERIMENTAL_USE_VENUM=ON']
     if options.opencl:
         cmd += ['-DEXPERIMENTAL_USE_OPENCL=ON']
+    if options.userdataobj:
+        cmd += ['-DOPENVX_USE_USER_DATA_OBJECT=ON']
     cmd = ' '.join(cmd)
 
     print( "" )

cmake_utils/CMakeFuncs.txt

@@ -94,7 +94,9 @@ endfunction ( FIND_SOURCES )
 #
 function ( FIND_NUM_PROCESSORS )
   set(PROCESSOR_COUNT_T 0)
-  if ( WIN32 )
+  if(CMAKE_CROSSCOMPILING)
+    set(PROCESSOR_COUNT_T "1")
+  elseif ( WIN32 )
     set(PROCESSOR_COUNT_T "$ENV{NUMBER_OF_PROCESSORS}")
   else ( WIN32 )
 	set(CPUINFO_FILE "/proc/cpuinfo")

cmake_utils/CMake_linux_tools.cmake

@@ -29,7 +29,9 @@ endif (CYGWIN)
 
 if(BUILD_X64)
   if (EXPERIMENTAL_USE_VENUM OR OPENVX_USE_TILING OR EXPERIMENTAL_USE_OPENCL)
-    set(ARCH_BIT "-mfpu=neon")
+    if (NOT (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64"))
+      set(ARCH_BIT "-mfpu=neon")
+    endif()
   else ()
     set(ARCH_BIT -m64 )
   endif(EXPERIMENTAL_USE_VENUM OR OPENVX_USE_TILING OR EXPERIMENTAL_USE_OPENCL)
@@ -38,7 +40,9 @@ else()
     # architecture will be according to ATOM
     set(ARCH_BIT -m32 )
   elseif (EXPERIMENTAL_USE_VENUM OR OPENVX_USE_TILING OR EXPERIMENTAL_USE_OPENCL)
-    set(ARCH_BIT "-mfpu=neon")
+    if (NOT (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64"))
+      set(ARCH_BIT "-mfpu=neon")
+    endif()
   else ()
     # need to force a more modern architecture than the degault m32 (i386).
     set(ARCH_BIT "-m32 -march=core2" )

cmake_utils/CMake_windows_tools.cmake

@@ -18,7 +18,7 @@
 
 # Compiler switches that CANNOT be modified during makefile generation
 set (ADD_C_FLAGS         "/Oi -D WINDOWS_ENABLE_CPLUSPLUS /GS")
-set (ADD_C_FLAGS_DEBUG   "-D _DEBUG /RTC1 /MTd")  #/MTd /Gm
+set (ADD_C_FLAGS_DEBUG   "-D _DEBUG /RTC1 /MTd /bigobj")  #/MTd /Gm
 set (ADD_C_FLAGS_RELEASE "/Zi /Gy -D NDEBUG /MT")# /Ob0") #/GL") #MT
 
 # Compiler switches that CAN be modified during makefile generation and configuration-independent

kernels/c_model/c_khr_nn.c

@@ -508,7 +508,7 @@ void PoolingKernelImpl(
         if (!max_pooling)
         {
             //result = conversion_24_8(result / (int16_t)(size_x * size_y));
-            result = CLAMP(result / (size_x * size_y), getMinValue(fmt), getMaxValue(fmt));
+            result = CLAMP(result / (int32_t)(size_x * size_y), getMinValue(fmt), getMaxValue(fmt));
         }
 
         const size_t output_byte_offset =

kernels/extras/extras_k.h

@@ -15,8 +15,8 @@
  * limitations under the License.
  */
 
-#ifndef _VX_EXTRAS_K_H_
-#define _VX_EXTRAS_K_H_
+#ifndef VX_EXTRAS_K_H_
+#define VX_EXTRAS_K_H_
 
 #include <VX/vx.h>
 #include <VX/vx_helper.h>

sample/framework/vx_graph.c

@@ -655,6 +655,26 @@ void ownDestructGraph(vx_reference ref)
         }
         ownRemoveNodeInt(&graph->nodes[0]);
     }
+    /* Release virtual objects scoped to this graph */
+    {
+        vx_context context = graph->base.context;
+        vx_uint32 r;
+        for (r = 0u; r < context->num_references; r++)
+        {
+            vx_reference virt_ref = context->reftable[r];
+            if (virt_ref != NULL && virt_ref->is_virtual == vx_true_e && virt_ref->scope == (vx_reference)graph)
+            {
+                if (virt_ref->external_count > 0)
+                {
+                    ownReleaseReferenceInt(&virt_ref, virt_ref->type, VX_EXTERNAL, NULL);
+                }
+                else if (virt_ref->internal_count > 0)
+                {
+                    ownDecrementReference(virt_ref, VX_INTERNAL);
+                }
+            }
+        }
+    }
     // execution lock?
     ownDestroySem(&graph->lock);
 }

sample/framework/vx_scalar.c

@@ -447,63 +447,70 @@ VX_API_ENTRY vx_status VX_API_CALL vxReadScalarValue(vx_scalar scalar, void *ptr
         return VX_ERROR_INVALID_PARAMETERS;
 
     ownSemWait(&scalar->base.lock);
-    vxPrintScalarValue(scalar);
-    switch (scalar->data_type)
+    if (scalar->data_addr != NULL && scalar->data_len != 0)
     {
-        case VX_TYPE_CHAR:
-            *(vx_char *)ptr = scalar->data.chr;
-            break;
-        case VX_TYPE_INT8:
-            *(vx_int8 *)ptr = scalar->data.s08;
-            break;
-        case VX_TYPE_UINT8:
-            *(vx_uint8 *)ptr = scalar->data.u08;
-            break;
-        case VX_TYPE_INT16:
-            *(vx_int16 *)ptr = scalar->data.s16;
-            break;
-        case VX_TYPE_UINT16:
-            *(vx_uint16 *)ptr = scalar->data.u16;
-            break;
-        case VX_TYPE_INT32:
-            *(vx_int32 *)ptr = scalar->data.s32;
-            break;
-        case VX_TYPE_UINT32:
-            *(vx_uint32 *)ptr = scalar->data.u32;
-            break;
-        case VX_TYPE_INT64:
-            *(vx_int64 *)ptr = scalar->data.s64;
-            break;
-        case VX_TYPE_UINT64:
-            *(vx_uint64 *)ptr = scalar->data.u64;
-            break;
+        memcpy(ptr, scalar->data_addr, scalar->data_len);
+    }
+    else
+    {
+        vxPrintScalarValue(scalar);
+        switch (scalar->data_type)
+        {
+            case VX_TYPE_CHAR:
+                *(vx_char *)ptr = scalar->data.chr;
+                break;
+            case VX_TYPE_INT8:
+                *(vx_int8 *)ptr = scalar->data.s08;
+                break;
+            case VX_TYPE_UINT8:
+                *(vx_uint8 *)ptr = scalar->data.u08;
+                break;
+            case VX_TYPE_INT16:
+                *(vx_int16 *)ptr = scalar->data.s16;
+                break;
+            case VX_TYPE_UINT16:
+                *(vx_uint16 *)ptr = scalar->data.u16;
+                break;
+            case VX_TYPE_INT32:
+                *(vx_int32 *)ptr = scalar->data.s32;
+                break;
+            case VX_TYPE_UINT32:
+                *(vx_uint32 *)ptr = scalar->data.u32;
+                break;
+            case VX_TYPE_INT64:
+                *(vx_int64 *)ptr = scalar->data.s64;
+                break;
+            case VX_TYPE_UINT64:
+                *(vx_uint64 *)ptr = scalar->data.u64;
+                break;
 #if OVX_SUPPORT_HALF_FLOAT
-        case VX_TYPE_FLOAT16:
-            *(vx_float16 *)ptr = scalar->data.f16;
-            break;
+            case VX_TYPE_FLOAT16:
+                *(vx_float16 *)ptr = scalar->data.f16;
+                break;
 #endif
-        case VX_TYPE_FLOAT32:
-            *(vx_float32 *)ptr = scalar->data.f32;
-            break;
-        case VX_TYPE_FLOAT64:
-            *(vx_float64 *)ptr = scalar->data.f64;
-            break;
-        case VX_TYPE_DF_IMAGE:
-            *(vx_df_image *)ptr = scalar->data.fcc;
-            break;
-        case VX_TYPE_ENUM:
-            *(vx_enum *)ptr = scalar->data.enm;
-            break;
-        case VX_TYPE_SIZE:
-            *(vx_size *)ptr = scalar->data.size;
-            break;
-        case VX_TYPE_BOOL:
-            *(vx_bool *)ptr = scalar->data.boolean;
-            break;
-        default:
-            VX_PRINT(VX_ZONE_ERROR, "some case is not covered in %s\n", __FUNCTION__);
-            status = VX_ERROR_NOT_SUPPORTED;
-            break;
+            case VX_TYPE_FLOAT32:
+                *(vx_float32 *)ptr = scalar->data.f32;
+                break;
+            case VX_TYPE_FLOAT64:
+                *(vx_float64 *)ptr = scalar->data.f64;
+                break;
+            case VX_TYPE_DF_IMAGE:
+                *(vx_df_image *)ptr = scalar->data.fcc;
+                break;
+            case VX_TYPE_ENUM:
+                *(vx_enum *)ptr = scalar->data.enm;
+                break;
+            case VX_TYPE_SIZE:
+                *(vx_size *)ptr = scalar->data.size;
+                break;
+            case VX_TYPE_BOOL:
+                *(vx_bool *)ptr = scalar->data.boolean;
+                break;
+            default:
+                VX_PRINT(VX_ZONE_ERROR, "some case is not covered in %s\n", __FUNCTION__);
+                status = VX_ERROR_NOT_SUPPORTED;
+                break;
+        }
     }
     ownSemPost(&scalar->base.lock);
     ownReadFromReference(&scalar->base);
@@ -521,64 +528,71 @@ VX_API_ENTRY vx_status VX_API_CALL vxWriteScalarValue(vx_scalar scalar, const vo
         return VX_ERROR_INVALID_PARAMETERS;
 
     ownSemWait(&scalar->base.lock);
-    switch (scalar->data_type)
+    if (scalar->data_addr != NULL && scalar->data_len != 0)
     {
-        case VX_TYPE_CHAR:
-            scalar->data.chr = *(vx_char *)ptr;
-            break;
-        case VX_TYPE_INT8:
-            scalar->data.s08 = *(vx_int8 *)ptr;
-            break;
-        case VX_TYPE_UINT8:
-            scalar->data.u08 = *(vx_uint8 *)ptr;
-            break;
-        case VX_TYPE_INT16:
-            scalar->data.s16 = *(vx_int16 *)ptr;
-            break;
-        case VX_TYPE_UINT16:
-            scalar->data.u16 = *(vx_uint16 *)ptr;
-            break;
-        case VX_TYPE_INT32:
-            scalar->data.s32 = *(vx_int32 *)ptr;
-            break;
-        case VX_TYPE_UINT32:
-            scalar->data.u32 = *(vx_uint32 *)ptr;
-            break;
-        case VX_TYPE_INT64:
-            scalar->data.s64 = *(vx_int64 *)ptr;
-            break;
-        case VX_TYPE_UINT64:
-            scalar->data.u64 = *(vx_uint64 *)ptr;
-            break;
+        memcpy(scalar->data_addr, ptr, scalar->data_len);
+    }
+    else
+    {
+        switch (scalar->data_type)
+        {
+            case VX_TYPE_CHAR:
+                scalar->data.chr = *(vx_char *)ptr;
+                break;
+            case VX_TYPE_INT8:
+                scalar->data.s08 = *(vx_int8 *)ptr;
+                break;
+            case VX_TYPE_UINT8:
+                scalar->data.u08 = *(vx_uint8 *)ptr;
+                break;
+            case VX_TYPE_INT16:
+                scalar->data.s16 = *(vx_int16 *)ptr;
+                break;
+            case VX_TYPE_UINT16:
+                scalar->data.u16 = *(vx_uint16 *)ptr;
+                break;
+            case VX_TYPE_INT32:
+                scalar->data.s32 = *(vx_int32 *)ptr;
+                break;
+            case VX_TYPE_UINT32:
+                scalar->data.u32 = *(vx_uint32 *)ptr;
+                break;
+            case VX_TYPE_INT64:
+                scalar->data.s64 = *(vx_int64 *)ptr;
+                break;
+            case VX_TYPE_UINT64:
+                scalar->data.u64 = *(vx_uint64 *)ptr;
+                break;
 #if OVX_SUPPORT_HALF_FLOAT
-        case VX_TYPE_FLOAT16:
-            scalar->data.f16 = *(vx_float16 *)ptr;
-            break;
+            case VX_TYPE_FLOAT16:
+                scalar->data.f16 = *(vx_float16 *)ptr;
+                break;
 #endif
-        case VX_TYPE_FLOAT32:
-            scalar->data.f32 = *(vx_float32 *)ptr;
-            break;
-        case VX_TYPE_FLOAT64:
-            scalar->data.f64 = *(vx_float64 *)ptr;
-            break;
-        case VX_TYPE_DF_IMAGE:
-            scalar->data.fcc = *(vx_df_image *)ptr;
-            break;
-        case VX_TYPE_ENUM:
-            scalar->data.enm = *(vx_enum *)ptr;
-            break;
-        case VX_TYPE_SIZE:
-            scalar->data.size = *(vx_size *)ptr;
-            break;
-        case VX_TYPE_BOOL:
-            scalar->data.boolean = *(vx_bool *)ptr;
-            break;
-        default:
-            VX_PRINT(VX_ZONE_ERROR, "some case is not covered in %s\n", __FUNCTION__);
-            status = VX_ERROR_NOT_SUPPORTED;
-            break;
+            case VX_TYPE_FLOAT32:
+                scalar->data.f32 = *(vx_float32 *)ptr;
+                break;
+            case VX_TYPE_FLOAT64:
+                scalar->data.f64 = *(vx_float64 *)ptr;
+                break;
+            case VX_TYPE_DF_IMAGE:
+                scalar->data.fcc = *(vx_df_image *)ptr;
+                break;
+            case VX_TYPE_ENUM:
+                scalar->data.enm = *(vx_enum *)ptr;
+                break;
+            case VX_TYPE_SIZE:
+                scalar->data.size = *(vx_size *)ptr;
+                break;
+            case VX_TYPE_BOOL:
+                scalar->data.boolean = *(vx_bool *)ptr;
+                break;
+            default:
+                VX_PRINT(VX_ZONE_ERROR, "some case is not covered in %s\n", __FUNCTION__);
+                status = VX_ERROR_NOT_SUPPORTED;
+                break;
+        }
+        vxPrintScalarValue(scalar);
     }
-    vxPrintScalarValue(scalar);
     ownSemPost(&scalar->base.lock);
     ownWroteToReference(&scalar->base);
     return status;

sample/framework/vx_tensor.c

@@ -635,7 +635,7 @@ VX_API_ENTRY vx_status VX_API_CALL vxMapTensorPatch(vx_tensor tensor, vx_size nu
     stride[0] = ownSizeOfType(tensor->data_type);
     for (vx_uint32 i = 1; i < number_of_dims; i++)
     {
-        stride[i] = stride[i - 1] * (view_end[i] - view_start[i]);
+        stride[i] = stride[i - 1] * tensor->dimensions[i - 1];
     }
     //vx_map_id * map_id, vx_size * stride, void ** ptr
     size = ComputePatchSize(view_start, view_end, number_of_dims);

sample/framework/vx_threshold.c

@@ -422,6 +422,7 @@ VX_API_ENTRY vx_threshold VX_API_CALL vxCreateThresholdForImage(vx_context conte
         VX_PRINT(VX_ZONE_ERROR, "Invalid threshold type\n");
         vxAddLogEntry(&context->base, VX_ERROR_INVALID_TYPE, "Invalid threshold type\n");
         threshold = (vx_threshold )ownGetErrorObject(context, VX_ERROR_INVALID_TYPE);
+        return threshold;
     }
 
     if ( ((vxIsValidThresholdFormat  (input_format) == vx_false_e) &&
@@ -432,6 +433,7 @@ VX_API_ENTRY vx_threshold VX_API_CALL vxCreateThresholdForImage(vx_context conte
         VX_PRINT(VX_ZONE_ERROR, "Invalid input or output format\n");
         vxAddLogEntry(&context->base, VX_ERROR_INVALID_TYPE, "Invalid input or output format\n");
         threshold = (vx_threshold )ownGetErrorObject(context, VX_ERROR_INVALID_TYPE);
+        return threshold;
     }
 
 

sample/framework/vx_xml_export.c

@@ -902,7 +902,7 @@ static vx_status vxExportToXMLThreshold(FILE* fp, vx_reference refs[], vx_uint32
     indent[i] = '\0';
 
     fprintf(fp, "%s<threshold reference=\"%u\" elemType=\"%s\" true_value=\"%d\" false_value=\"%d\"%s",
-                 indent, r, type_pairs[j].name, thresh->true_value, thresh->false_value, refNameStr);
+                 indent, r, type_pairs[j].name, thresh->true_value.S32, thresh->false_value.S32, refNameStr);
 
     if (refs[r]->is_virtual == vx_true_e) /* is not virtual in 1.0, but check anyway */
     {