docs-6.2.1/amd_openvx/openvx/include/VX/vx_types.h Source File

docs-6.2.1/amd_openvx/openvx/include/VX/vx_types.h Source File#

MIVisionX: docs-6.2.1/amd_openvx/openvx/include/VX/vx_types.h Source File
 /*
  * Copyright (c) 2012-2020 The Khronos Group Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
  
 #ifndef _OPENVX_TYPES_H_
 #define _OPENVX_TYPES_H_
  
 #include <stdint.h>
 #include <stddef.h>
  
 #ifndef VX_API_ENTRY
 #define VX_API_ENTRY
 #endif
 #ifndef VX_API_CALL
 #if defined(_WIN32)
 #define VX_API_CALL __stdcall
 #else
 #define VX_API_CALL
 #endif
 #endif
 #ifndef VX_CALLBACK
 #if defined(_WIN32)
 #define VX_CALLBACK __stdcall
 #else
 #define VX_CALLBACK
 #endif
 #endif
  
 typedef char     vx_char;
  
 typedef uint8_t  vx_uint8;
  
 typedef uint16_t vx_uint16;
  
 typedef uint32_t vx_uint32;
  
 typedef uint64_t vx_uint64;
  
 typedef int8_t   vx_int8;
  
 typedef int16_t  vx_int16;
  
 typedef int32_t  vx_int32;
  
 typedef int64_t  vx_int64;
  
 typedef uint32_t vx_bitfield;
  
 #if defined(EXPERIMENTAL_PLATFORM_SUPPORTS_16_FLOAT)
  
 #if defined(__arm__) || defined(__arm64__)
 typedef __fp16   vx_float16;
 #else
 typedef hfloat   vx_float16;
 #endif
 #endif
  
 typedef float    vx_float32;
  
 typedef double   vx_float64;
  
 typedef struct _vx_reference *vx_reference;
  
 typedef int32_t vx_enum;
  
 typedef size_t vx_size;
  
 typedef uint32_t vx_df_image;
  
 typedef uintptr_t vx_map_id;
  
 typedef struct _vx_scalar *vx_scalar;
  
 typedef struct _vx_image *vx_image;
  
 typedef struct _vx_kernel *vx_kernel;
  
 typedef struct _vx_parameter *vx_parameter;
  
 typedef struct _vx_node *vx_node;
  
 typedef struct _vx_graph *vx_graph;
  
 typedef struct _vx_context *vx_context;
  
 typedef struct _vx_delay *vx_delay;
  
 typedef struct _vx_lut *vx_lut;
  
 typedef struct _vx_distribution *vx_distribution;
  
 typedef struct _vx_matrix *vx_matrix;
  
 typedef struct _vx_pyramid *vx_pyramid;
  
 typedef struct _vx_threshold *vx_threshold;
  
 typedef struct _vx_convolution *vx_convolution;
  
 typedef struct _vx_remap *vx_remap;
  
 typedef struct _vx_array *vx_array;
  
 typedef struct _vx_object_array *vx_object_array;
  
 typedef struct _vx_tensor_t * vx_tensor;
  
 enum vx_bool_e {
     vx_false_e = 0,
     vx_true_e,
 };
  
 typedef vx_enum vx_bool;
  
 typedef struct _vx_meta_format* vx_meta_format;
  
 enum vx_type_e {
     VX_TYPE_INVALID         = 0x000,
     VX_TYPE_CHAR            = 0x001,
     VX_TYPE_INT8            = 0x002,
     VX_TYPE_UINT8           = 0x003,
     VX_TYPE_INT16           = 0x004,
     VX_TYPE_UINT16          = 0x005,
     VX_TYPE_INT32           = 0x006,
     VX_TYPE_UINT32          = 0x007,
     VX_TYPE_INT64           = 0x008,
     VX_TYPE_UINT64          = 0x009,
     VX_TYPE_FLOAT32         = 0x00A,
     VX_TYPE_FLOAT64         = 0x00B,
     VX_TYPE_ENUM            = 0x00C,
     VX_TYPE_SIZE            = 0x00D,
     VX_TYPE_DF_IMAGE        = 0x00E,
     VX_TYPE_FLOAT16         = 0x00F,
     VX_TYPE_BOOL            = 0x010,
     VX_TYPE_RECTANGLE       = 0x020,
     VX_TYPE_KEYPOINT        = 0x021,
     VX_TYPE_COORDINATES2D   = 0x022,
     VX_TYPE_COORDINATES3D   = 0x023,
     VX_TYPE_COORDINATES2DF  = 0x024,
     /* Reserve enums that are defined in khronos extensions
         NN extensions:
         VX_TYPE_NN_CONVOLUTION_PARAMS     = 0x025,
         VX_TYPE_NN_DECONVOLUTION_PARAMS   = 0x026,
         VX_TYPE_NN_ROI_POOL_PARAMS        = 0x027,
         Classifier extension:
         VX_TYPE_CLASSIFER_MODEL           = 0x02C,
     */
     VX_TYPE_HOG_PARAMS                       = 0x028, 
     VX_TYPE_HOUGH_LINES_PARAMS               = 0x029, 
     VX_TYPE_LINE_2D                          = 0x02A, 
     VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS    = 0x02B, 
     VX_TYPE_USER_STRUCT_START    = 0x100,
     VX_TYPE_VENDOR_STRUCT_START  = 0x400,
     VX_TYPE_KHRONOS_OBJECT_START = 0x800,
     VX_TYPE_VENDOR_OBJECT_START  = 0xC00,
     VX_TYPE_KHRONOS_STRUCT_MAX   = (vx_enum)VX_TYPE_USER_STRUCT_START - 1,
     VX_TYPE_USER_STRUCT_END      = (vx_enum)VX_TYPE_VENDOR_STRUCT_START - 1,
     VX_TYPE_VENDOR_STRUCT_END    = (vx_enum)VX_TYPE_KHRONOS_OBJECT_START - 1,
     VX_TYPE_KHRONOS_OBJECT_END   = (vx_enum)VX_TYPE_VENDOR_OBJECT_START - 1,
     VX_TYPE_VENDOR_OBJECT_END    = 0xFFF,
     VX_TYPE_REFERENCE       = 0x800,
     VX_TYPE_CONTEXT         = 0x801,
     VX_TYPE_GRAPH           = 0x802,
     VX_TYPE_NODE            = 0x803,
     VX_TYPE_KERNEL          = 0x804,
     VX_TYPE_PARAMETER       = 0x805,
     VX_TYPE_DELAY           = 0x806,
     VX_TYPE_LUT             = 0x807,
     VX_TYPE_DISTRIBUTION    = 0x808,
     VX_TYPE_PYRAMID         = 0x809,
     VX_TYPE_THRESHOLD       = 0x80A,
     VX_TYPE_MATRIX          = 0x80B,
     VX_TYPE_CONVOLUTION     = 0x80C,
     VX_TYPE_SCALAR          = 0x80D,
     VX_TYPE_ARRAY           = 0x80E,
     VX_TYPE_IMAGE           = 0x80F,
     VX_TYPE_REMAP           = 0x810,
     VX_TYPE_ERROR           = 0x811,
     VX_TYPE_META_FORMAT     = 0x812,
     VX_TYPE_OBJECT_ARRAY    = 0x813,
     /* Reserved for IX and XML extensions */
     /* VX_TYPE_IMPORT          = 0x814, !< \brief A <tt>\ref vx_import</tt>. */
     VX_TYPE_TENSOR          = 0x815,
     /* \todo add new object types here */
  
 };
  
 enum vx_status_e {
     VX_STATUS_MIN                       = -(vx_int32)25,
     /* add new codes here */
     VX_ERROR_REFERENCE_NONZERO          = -(vx_int32)24,
     VX_ERROR_MULTIPLE_WRITERS           = -(vx_int32)23,
     VX_ERROR_GRAPH_ABANDONED            = -(vx_int32)22,
     VX_ERROR_GRAPH_SCHEDULED            = -(vx_int32)21,
     VX_ERROR_INVALID_SCOPE              = -(vx_int32)20,
     VX_ERROR_INVALID_NODE               = -(vx_int32)19,
     VX_ERROR_INVALID_GRAPH              = -(vx_int32)18,
     VX_ERROR_INVALID_TYPE               = -(vx_int32)17,
     VX_ERROR_INVALID_VALUE              = -(vx_int32)16,
     VX_ERROR_INVALID_DIMENSION          = -(vx_int32)15,
     VX_ERROR_INVALID_FORMAT             = -(vx_int32)14,
     VX_ERROR_INVALID_LINK               = -(vx_int32)13,
     VX_ERROR_INVALID_REFERENCE          = -(vx_int32)12,
     VX_ERROR_INVALID_MODULE             = -(vx_int32)11,
     VX_ERROR_INVALID_PARAMETERS         = -(vx_int32)10,
     VX_ERROR_OPTIMIZED_AWAY             = -(vx_int32)9,
     VX_ERROR_NO_MEMORY                  = -(vx_int32)8,
     VX_ERROR_NO_RESOURCES               = -(vx_int32)7,
     VX_ERROR_NOT_COMPATIBLE             = -(vx_int32)6,
     VX_ERROR_NOT_ALLOCATED              = -(vx_int32)5,
     VX_ERROR_NOT_SUFFICIENT             = -(vx_int32)4,
     VX_ERROR_NOT_SUPPORTED              = -(vx_int32)3,
     VX_ERROR_NOT_IMPLEMENTED            = -(vx_int32)2,
     VX_FAILURE                          = -(vx_int32)1,
     VX_SUCCESS                          =  0,
 };
  
 typedef vx_enum vx_status;
  
 typedef vx_enum vx_action;
  
 typedef vx_action (VX_CALLBACK *vx_nodecomplete_f)(vx_node node);
  
 #define VX_VENDOR_MASK                      (0xFFF00000U)
  
 #define VX_TYPE_MASK                        (0x000FFF00U)
  
 #define VX_LIBRARY_MASK                     (0x000FF000U)
  
 #define VX_KERNEL_MASK                      (0x00000FFFU)
  
 #define VX_ATTRIBUTE_ID_MASK                (0x000000FFU)
  
 #define VX_ENUM_TYPE_MASK                   (0x000FF000U)
  
 #define VX_ENUM_MASK                        (0x00000FFFU)
  
 #define VX_VENDOR(e)                        (((vx_uint32)(e) & VX_VENDOR_MASK) >> 20)
  
 #define VX_TYPE(e)                          (((vx_uint32)(e) & VX_TYPE_MASK) >> 8)
  
 #define VX_ENUM_TYPE(e)                     (((vx_uint32)(e) & VX_ENUM_TYPE_MASK) >> 12)
  
 #define VX_LIBRARY(e)                       (((vx_uint32)(e) & VX_LIBRARY_MASK) >> 12)
  
 #define VX_DF_IMAGE(a,b,c,d)                  ((vx_uint32)(vx_uint8)(a) | ((vx_uint32)(vx_uint8)(b) << 8U) | ((vx_uint32)(vx_uint8)(c) << 16U) | ((vx_uint32)(vx_uint8)(d) << 24U))
  
 #define VX_ATTRIBUTE_BASE(vendor, object)   ((vx_int32)(((vx_uint32)(vendor) << 20) | ((vx_uint32)(object) << 8)))
  
 #define VX_KERNEL_BASE(vendor, lib)         ((vx_int32)(((vx_uint32)(vendor) << 20) | ((vx_uint32)(lib) << 12)))
  
 #define VX_ENUM_BASE(vendor, id)            ((vx_int32)(((vx_uint32)(vendor) << 20) | ((vx_uint32)(id) << 12)))
  
 enum vx_enum_e {
     VX_ENUM_DIRECTION       = 0x00, 
     VX_ENUM_ACTION          = 0x01, 
     VX_ENUM_HINT            = 0x02, 
     VX_ENUM_DIRECTIVE       = 0x03, 
     VX_ENUM_INTERPOLATION   = 0x04, 
     VX_ENUM_OVERFLOW        = 0x05, 
     VX_ENUM_COLOR_SPACE     = 0x06, 
     VX_ENUM_COLOR_RANGE     = 0x07, 
     VX_ENUM_PARAMETER_STATE = 0x08, 
     VX_ENUM_CHANNEL         = 0x09, 
     VX_ENUM_CONVERT_POLICY  = 0x0A, 
     VX_ENUM_THRESHOLD_TYPE  = 0x0B, 
     VX_ENUM_BORDER          = 0x0C, 
     VX_ENUM_COMPARISON      = 0x0D, 
     VX_ENUM_MEMORY_TYPE     = 0x0E, 
     VX_ENUM_TERM_CRITERIA   = 0x0F, 
     VX_ENUM_NORM_TYPE       = 0x10, 
     VX_ENUM_ACCESSOR        = 0x11, 
     VX_ENUM_ROUND_POLICY    = 0x12, 
     VX_ENUM_TARGET          = 0x13, 
     VX_ENUM_BORDER_POLICY   = 0x14, 
     VX_ENUM_GRAPH_STATE     = 0x15, 
     VX_ENUM_NONLINEAR       = 0x16, 
     VX_ENUM_PATTERN         = 0x17, 
     VX_ENUM_LBP_FORMAT      = 0x18, 
     VX_ENUM_COMP_METRIC     = 0x19, 
 /* NN extension
     VX_ENUM_NN_ROUNDING_TYPE    = 0x1A,
     VX_ENUM_NN_POOLING_TYPE = 0x1B,
     VX_ENUM_NN_NORMALIZATION_TYPE   = 0x1C,
     VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE = 0x1D,
 */
 /* Classifier extension
     VX_ENUM_CLASSIFIER_MODEL= 0x1E,
 */
 /* IX extension
     VX_ENUM_IX_USE          = 0x1F, !< \brief How to use references in import and export. */
     VX_ENUM_SCALAR_OPERATION= 0X20  
     };
  
 enum vx_action_e {
     VX_ACTION_CONTINUE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ACTION) + 0x0,
     VX_ACTION_ABANDON  = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ACTION) + 0x1,
 };
  
 enum vx_direction_e {
     VX_INPUT = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_DIRECTION) + 0x0,
     VX_OUTPUT = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_DIRECTION) + 0x1,
 };
  
 enum vx_hint_e {
     VX_HINT_PERFORMANCE_DEFAULT = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_HINT) + 0x1,
     VX_HINT_PERFORMANCE_LOW_POWER = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_HINT) + 0x2,
     VX_HINT_PERFORMANCE_HIGH_SPEED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_HINT) + 0x3,
 };
  
 enum vx_directive_e {
     VX_DIRECTIVE_DISABLE_LOGGING = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE) + 0x0,
     VX_DIRECTIVE_ENABLE_LOGGING = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE) + 0x1,
     VX_DIRECTIVE_DISABLE_PERFORMANCE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE) + 0x2,
     VX_DIRECTIVE_ENABLE_PERFORMANCE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE) + 0x3,
 };
  
 enum vx_graph_state_e {
    VX_GRAPH_STATE_UNVERIFIED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE) + 0x0,
    VX_GRAPH_STATE_VERIFIED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE) + 0x1,
    VX_GRAPH_STATE_RUNNING = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE) + 0x2,
    VX_GRAPH_STATE_ABANDONED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE) + 0x3,
    VX_GRAPH_STATE_COMPLETED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE) + 0x4,
 };
  
 enum vx_graph_attribute_e {
     VX_GRAPH_NUMNODES = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x0,
     VX_GRAPH_PERFORMANCE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x2,
     VX_GRAPH_NUMPARAMETERS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x3,
     VX_GRAPH_STATE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_GRAPH) + 0x4,
 };
  
 enum vx_convert_policy_e {
     VX_CONVERT_POLICY_WRAP = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CONVERT_POLICY) + 0x0,
     VX_CONVERT_POLICY_SATURATE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CONVERT_POLICY) + 0x1,
 };
  
 enum vx_df_image_e {
     VX_DF_IMAGE_VIRT = VX_DF_IMAGE('V','I','R','T'),
     VX_DF_IMAGE_RGB  = VX_DF_IMAGE('R','G','B','2'),
     VX_DF_IMAGE_RGBX = VX_DF_IMAGE('R','G','B','A'),
     VX_DF_IMAGE_NV12 = VX_DF_IMAGE('N','V','1','2'),
     VX_DF_IMAGE_NV21 = VX_DF_IMAGE('N','V','2','1'),
     VX_DF_IMAGE_UYVY = VX_DF_IMAGE('U','Y','V','Y'),
     VX_DF_IMAGE_YUYV = VX_DF_IMAGE('Y','U','Y','V'),
     VX_DF_IMAGE_IYUV = VX_DF_IMAGE('I','Y','U','V'),
     VX_DF_IMAGE_YUV4 = VX_DF_IMAGE('Y','U','V','4'),
     VX_DF_IMAGE_U1 = VX_DF_IMAGE('U','0','0','1'),
     VX_DF_IMAGE_U8 = VX_DF_IMAGE('U','0','0','8'),
     VX_DF_IMAGE_U16  = VX_DF_IMAGE('U','0','1','6'),
     VX_DF_IMAGE_S16  = VX_DF_IMAGE('S','0','1','6'),
     VX_DF_IMAGE_U32  = VX_DF_IMAGE('U','0','3','2'),
     VX_DF_IMAGE_S32  = VX_DF_IMAGE('S','0','3','2'),
 };
  
 enum vx_target_e {
     VX_TARGET_ANY = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_TARGET) + 0x0000,
     VX_TARGET_STRING = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_TARGET) + 0x0001,
     VX_TARGET_VENDOR_BEGIN = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_TARGET) + 0x1000,
 };
  
 enum vx_reference_attribute_e {
     VX_REFERENCE_COUNT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REFERENCE) + 0x0,
     VX_REFERENCE_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REFERENCE) + 0x1,
     VX_REFERENCE_NAME = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REFERENCE) + 0x2,
 };
  
 enum vx_context_attribute_e {
     VX_CONTEXT_VENDOR_ID = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x0,
     VX_CONTEXT_VERSION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x1,
     VX_CONTEXT_UNIQUE_KERNELS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x2,
     VX_CONTEXT_MODULES = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x3,
     VX_CONTEXT_REFERENCES = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x4,
     VX_CONTEXT_IMPLEMENTATION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x5,
     VX_CONTEXT_EXTENSIONS_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x6,
     VX_CONTEXT_EXTENSIONS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x7,
     VX_CONTEXT_CONVOLUTION_MAX_DIMENSION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x8,
     VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0x9,
     VX_CONTEXT_IMMEDIATE_BORDER = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0xA,
     VX_CONTEXT_UNIQUE_KERNEL_TABLE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0xB,
     VX_CONTEXT_IMMEDIATE_BORDER_POLICY = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0xC,
     VX_CONTEXT_NONLINEAR_MAX_DIMENSION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0xd,
     VX_CONTEXT_MAX_TENSOR_DIMS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONTEXT) + 0xE,
 };
  
 enum vx_kernel_attribute_e {
     VX_KERNEL_PARAMETERS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x0,
     VX_KERNEL_NAME = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x1,
     VX_KERNEL_ENUM = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x2,
     VX_KERNEL_LOCAL_DATA_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x3,
 };
  
 enum vx_node_attribute_e {
     VX_NODE_STATUS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x0,
     VX_NODE_PERFORMANCE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x1,
     VX_NODE_BORDER = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x2,
     VX_NODE_LOCAL_DATA_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x3,
     VX_NODE_LOCAL_DATA_PTR = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x4,
     VX_NODE_PARAMETERS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x5,
     VX_NODE_IS_REPLICATED = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x6,
     VX_NODE_REPLICATE_FLAGS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x7,
     VX_NODE_VALID_RECT_RESET = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0x8,
 };
  
 enum vx_parameter_attribute_e {
     VX_PARAMETER_INDEX = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PARAMETER) + 0x0,
     VX_PARAMETER_DIRECTION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PARAMETER) + 0x1,
     VX_PARAMETER_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PARAMETER) + 0x2,
     VX_PARAMETER_STATE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PARAMETER) + 0x3,
     VX_PARAMETER_REF = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PARAMETER) + 0x4,
     VX_PARAMETER_META_FORMAT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PARAMETER) + 0x5,
 };
  
 enum vx_image_attribute_e {
     VX_IMAGE_WIDTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x0,
     VX_IMAGE_HEIGHT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x1,
     VX_IMAGE_FORMAT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x2,
     VX_IMAGE_PLANES = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x3,
     VX_IMAGE_SPACE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x4,
     VX_IMAGE_RANGE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x5,
     VX_IMAGE_MEMORY_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x7,
     VX_IMAGE_IS_UNIFORM = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x8,
     VX_IMAGE_UNIFORM_VALUE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_IMAGE) + 0x9,
 };
  
 enum vx_scalar_attribute_e {
     VX_SCALAR_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_SCALAR) + 0x0,
 };
  
 enum vx_scalar_operation_e {
     VX_SCALAR_OP_AND = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x0,
     VX_SCALAR_OP_OR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x1,
     VX_SCALAR_OP_XOR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x2,
     VX_SCALAR_OP_NAND = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x3,
     VX_SCALAR_OP_EQUAL = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x4,
     VX_SCALAR_OP_NOTEQUAL = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x5,
     VX_SCALAR_OP_LESS = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x6,
     VX_SCALAR_OP_LESSEQ = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x7,
     VX_SCALAR_OP_GREATER = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x8,
     VX_SCALAR_OP_GREATEREQ = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x9,
     VX_SCALAR_OP_ADD = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0xA,
     VX_SCALAR_OP_SUBTRACT = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0xB,
     VX_SCALAR_OP_MULTIPLY = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0xC,
     VX_SCALAR_OP_DIVIDE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0xD,
     VX_SCALAR_OP_MODULUS = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0xE,
     VX_SCALAR_OP_MIN = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0xF,
     VX_SCALAR_OP_MAX = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_SCALAR_OPERATION) + 0x10,
 };
  
 enum vx_lut_attribute_e {
     VX_LUT_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS,VX_TYPE_LUT) + 0x0,
     VX_LUT_COUNT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS,VX_TYPE_LUT) + 0x1,
     VX_LUT_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS,VX_TYPE_LUT) + 0x2,
     VX_LUT_OFFSET = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS,VX_TYPE_LUT) + 0x3,
 };
  
 enum vx_distribution_attribute_e {
     VX_DISTRIBUTION_DIMENSIONS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION) + 0x0,
     VX_DISTRIBUTION_OFFSET = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION) + 0x1,
     VX_DISTRIBUTION_RANGE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION) + 0x2,
     VX_DISTRIBUTION_BINS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION) + 0x3,
     VX_DISTRIBUTION_WINDOW = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION) + 0x4,
     VX_DISTRIBUTION_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION) + 0x5,
 };
  
 enum vx_threshold_type_e {
     VX_THRESHOLD_TYPE_BINARY = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_THRESHOLD_TYPE) + 0x0,
     VX_THRESHOLD_TYPE_RANGE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_THRESHOLD_TYPE) + 0x1,
 };
  
 enum vx_threshold_attribute_e {
     VX_THRESHOLD_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_THRESHOLD) + 0x0,
     VX_THRESHOLD_INPUT_FORMAT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_THRESHOLD) + 0x7,
     VX_THRESHOLD_OUTPUT_FORMAT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_THRESHOLD) + 0x8
 };
  
 enum vx_matrix_attribute_e {
     VX_MATRIX_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_MATRIX) + 0x0,
     VX_MATRIX_ROWS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_MATRIX) + 0x1,
     VX_MATRIX_COLUMNS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_MATRIX) + 0x2,
     VX_MATRIX_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_MATRIX) + 0x3,
     VX_MATRIX_ORIGIN = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_MATRIX) + 0x4,
     VX_MATRIX_PATTERN = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_MATRIX) + 0x5,
 };
  
 enum vx_convolution_attribute_e {
     VX_CONVOLUTION_ROWS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION) + 0x0,
     VX_CONVOLUTION_COLUMNS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION) + 0x1,
     VX_CONVOLUTION_SCALE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION) + 0x2,
     VX_CONVOLUTION_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION) + 0x3,
 };
  
 enum vx_pyramid_attribute_e {
     VX_PYRAMID_LEVELS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PYRAMID) + 0x0,
     VX_PYRAMID_SCALE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PYRAMID) + 0x1,
     VX_PYRAMID_WIDTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PYRAMID) + 0x2,
     VX_PYRAMID_HEIGHT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PYRAMID) + 0x3,
     VX_PYRAMID_FORMAT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_PYRAMID) + 0x4,
 };
  
 enum vx_remap_attribute_e {
     VX_REMAP_SOURCE_WIDTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REMAP) + 0x0,
     VX_REMAP_SOURCE_HEIGHT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REMAP) + 0x1,
     VX_REMAP_DESTINATION_WIDTH = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REMAP) + 0x2,
     VX_REMAP_DESTINATION_HEIGHT = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_REMAP) + 0x3,
 };
  
 enum vx_array_attribute_e {
     VX_ARRAY_ITEMTYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_ARRAY) + 0x0,
     VX_ARRAY_NUMITEMS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_ARRAY) + 0x1,
     VX_ARRAY_CAPACITY = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_ARRAY) + 0x2,
     VX_ARRAY_ITEMSIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_ARRAY) + 0x3,
 };
  
 enum vx_object_array_attribute_e {
     VX_OBJECT_ARRAY_ITEMTYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_OBJECT_ARRAY) + 0x0,
     VX_OBJECT_ARRAY_NUMITEMS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_OBJECT_ARRAY) + 0x1,
 };
 enum vx_tensor_attribute_e
 {
     VX_TENSOR_NUMBER_OF_DIMS = VX_ATTRIBUTE_BASE( VX_ID_KHRONOS, VX_TYPE_TENSOR ) + 0x0,
     VX_TENSOR_DIMS        = VX_ATTRIBUTE_BASE( VX_ID_KHRONOS, VX_TYPE_TENSOR ) + 0x1,
     VX_TENSOR_DATA_TYPE   = VX_ATTRIBUTE_BASE( VX_ID_KHRONOS, VX_TYPE_TENSOR ) + 0x2,
     VX_TENSOR_FIXED_POINT_POSITION = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_TENSOR) + 0x3
 };
  
 enum vx_meta_valid_rect_attribute_e {
     VX_VALID_RECT_CALLBACK = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_META_FORMAT) + 0x1,
 };
  
 enum vx_channel_e {
     VX_CHANNEL_0 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x0,
     VX_CHANNEL_1 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x1,
     VX_CHANNEL_2 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x2,
     VX_CHANNEL_3 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x3,
  
     VX_CHANNEL_R = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x10,
     VX_CHANNEL_G = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x11,
     VX_CHANNEL_B = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x12,
     VX_CHANNEL_A = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x13,
     VX_CHANNEL_Y = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x14,
     VX_CHANNEL_U = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x15,
     VX_CHANNEL_V = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_CHANNEL) + 0x16,
 };
  
 enum vx_memory_type_e {
     VX_MEMORY_TYPE_NONE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_MEMORY_TYPE) + 0x0,
  
     VX_MEMORY_TYPE_HOST = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_MEMORY_TYPE) + 0x1,
 };
  
 enum vx_interpolation_type_e {
     VX_INTERPOLATION_NEAREST_NEIGHBOR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_INTERPOLATION) + 0x0,
     VX_INTERPOLATION_BILINEAR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_INTERPOLATION) + 0x1,
     VX_INTERPOLATION_AREA = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_INTERPOLATION) + 0x2,
 };
  
 enum vx_non_linear_filter_e {
     VX_NONLINEAR_FILTER_MEDIAN = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NONLINEAR) + 0x0,
     VX_NONLINEAR_FILTER_MIN = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NONLINEAR) + 0x1 ,
     VX_NONLINEAR_FILTER_MAX = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NONLINEAR) + 0x2,
 };
  
 enum vx_pattern_e {
     VX_PATTERN_BOX = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_PATTERN) + 0x0,
     VX_PATTERN_CROSS = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_PATTERN) + 0x1 ,
     VX_PATTERN_DISK = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_PATTERN) + 0x2,
     VX_PATTERN_OTHER = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_PATTERN) + 0x3,
 };
  
 enum vx_color_space_e {
     VX_COLOR_SPACE_NONE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE) + 0x0,
     VX_COLOR_SPACE_BT601_525 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE) + 0x1,
     VX_COLOR_SPACE_BT601_625 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE) + 0x2,
     VX_COLOR_SPACE_BT709 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE) + 0x3,
  
     VX_COLOR_SPACE_DEFAULT = VX_COLOR_SPACE_BT709,
 };
  
 enum vx_channel_range_e {
     VX_CHANNEL_RANGE_FULL = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_COLOR_RANGE) + 0x0,
     VX_CHANNEL_RANGE_RESTRICTED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_COLOR_RANGE) + 0x1,
 };
  
 enum vx_parameter_state_e {
     VX_PARAMETER_STATE_REQUIRED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_PARAMETER_STATE) + 0x0,
     VX_PARAMETER_STATE_OPTIONAL = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_PARAMETER_STATE) + 0x1,
 };
  
 enum vx_border_e {
     VX_BORDER_UNDEFINED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_BORDER) + 0x0,
     VX_BORDER_CONSTANT = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_BORDER) + 0x1,
     VX_BORDER_REPLICATE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_BORDER) + 0x2,
 };
  
 enum vx_border_policy_e {
     VX_BORDER_POLICY_DEFAULT_TO_UNDEFINED = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_BORDER_POLICY) + 0x0,
     VX_BORDER_POLICY_RETURN_ERROR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_BORDER_POLICY) + 0x1,
 };
  
 enum vx_termination_criteria_e {
     VX_TERM_CRITERIA_ITERATIONS = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_TERM_CRITERIA) + 0x0,
     VX_TERM_CRITERIA_EPSILON = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_TERM_CRITERIA) + 0x1,
     VX_TERM_CRITERIA_BOTH = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_TERM_CRITERIA) + 0x2,
 };
  
 enum vx_norm_type_e {
     VX_NORM_L1 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NORM_TYPE) + 0x0,
     VX_NORM_L2 = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NORM_TYPE) + 0x1,
 };
  
 enum vx_delay_attribute_e {
     VX_DELAY_TYPE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DELAY) + 0x0,
     VX_DELAY_SLOTS = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_DELAY) + 0x1,
 };
  
 enum vx_accessor_e {
     VX_READ_ONLY = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ACCESSOR) + 0x1,
     VX_WRITE_ONLY = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ACCESSOR) + 0x2,
     VX_READ_AND_WRITE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ACCESSOR) + 0x3,
 };
  
 enum vx_round_policy_e {
     VX_ROUND_POLICY_TO_ZERO = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ROUND_POLICY) + 0x1,
     VX_ROUND_POLICY_TO_NEAREST_EVEN = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_ROUND_POLICY) + 0x2,
 };
  
 enum vx_lbp_format_e
 {
     VX_LBP  = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_LBP_FORMAT ) + 0x0,
     VX_MLBP = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_LBP_FORMAT ) + 0x1,
     VX_ULBP = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_LBP_FORMAT ) + 0x2
 };
  
 enum vx_comp_metric_e
 {
     VX_COMPARE_HAMMING    = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_COMP_METRIC ) + 0x0,
     VX_COMPARE_L1         = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_COMP_METRIC ) + 0x1,
     VX_COMPARE_L2         = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_COMP_METRIC ) + 0x2,
     VX_COMPARE_CCORR      = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_COMP_METRIC ) + 0x3,
     VX_COMPARE_L2_NORM    = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_COMP_METRIC ) + 0x4,
     VX_COMPARE_CCORR_NORM = VX_ENUM_BASE( VX_ID_KHRONOS, VX_ENUM_COMP_METRIC ) + 0x5
 };
  
 #if defined(_WIN32) || defined(UNDER_CE)
 #if defined(_WIN64)
 #define VX_FMT_REF  "%I64u"
 #define VX_FMT_SIZE "%I64u"
 #else
 #define VX_FMT_REF  "%lu"
 #define VX_FMT_SIZE "%lu"
 #endif
 #else
 #define VX_FMT_REF  "%p"
 #define VX_FMT_SIZE "%zu"
 #endif
 #define VX_SCALE_UNITY (1024u)
  
 typedef struct _vx_imagepatch_addressing_t {
     vx_uint32 dim_x;        
     vx_uint32 dim_y;        
     vx_int32  stride_x;     
     vx_int32  stride_y;     
     vx_uint32 scale_x;      
     vx_uint32 scale_y;      
     vx_uint32 step_x;       
     vx_uint16 step_y;       
     vx_uint16 stride_x_bits; 
 } vx_imagepatch_addressing_t;
  
 #define VX_IMAGEPATCH_ADDR_INIT {0u, 0u, 0, 0, 0u, 0u, 0u, 0u, 0u}
  
 typedef struct _vx_perf_t {
     vx_uint64 tmp;          
     vx_uint64 beg;          
     vx_uint64 end;          
     vx_uint64 sum;          
     vx_uint64 avg;          
     vx_uint64 min;          
     vx_uint64 num;          
     vx_uint64 max;          
 } vx_perf_t;
  
 typedef struct _vx_hough_lines_p_t
 {
     vx_float32 rho;
     vx_float32 theta;
     vx_int32 threshold;
     vx_int32 line_length;
     vx_int32 line_gap;
     vx_float32 theta_max;
     vx_float32 theta_min;
 } vx_hough_lines_p_t;
  
 typedef struct _vx_line2d_t
 {
     vx_float32 start_x;
     vx_float32 start_y;
     vx_float32 end_x;
     vx_float32 end_y;
 } vx_line2d_t;
  
 typedef struct _vx_tensor_matrix_multiply_params_t{
     vx_bool  transpose_input1;
     vx_bool  transpose_input2;
     vx_bool  transpose_input3;
 } vx_tensor_matrix_multiply_params_t;
  
 #define VX_PERF_INIT    {0ul, 0ul, 0ul, 0ul, 0ul, 0ul}
  
 typedef struct _vx_kernel_info_t {
     vx_enum enumeration;
  
     vx_char name[VX_MAX_KERNEL_NAME];
 } vx_kernel_info_t;
  
 #define VX_SCALE_PYRAMID_HALF       (0.5f)
  
 #define VX_SCALE_PYRAMID_ORB        ((vx_float32)0.8408964f)
  
 typedef struct _vx_keypoint_t {
     vx_int32 x;                 
     vx_int32 y;                 
     vx_float32 strength;        
     vx_float32 scale;           
     vx_float32 orientation;     
     vx_int32 tracking_status;   
     vx_float32 error;           
 } vx_keypoint_t;
  
 typedef struct _vx_rectangle_t {
     vx_uint32 start_x;          
     vx_uint32 start_y;          
     vx_uint32 end_x;            
     vx_uint32 end_y;            
 } vx_rectangle_t;
  
 typedef struct _vx_coordinates2d_t {
     vx_uint32 x;    
     vx_uint32 y;    
 } vx_coordinates2d_t;
  
 typedef struct _vx_coordinates2df_t {
     vx_float32 x;    
     vx_float32 y;    
 } vx_coordinates2df_t;
  
 typedef struct _vx_coordinates3d_t {
     vx_uint32 x;    
     vx_uint32 y;    
     vx_uint32 z;    
 } vx_coordinates3d_t;
  
 typedef union _vx_pixel_value_t {
     vx_uint8 RGB[3]; 
     vx_uint8 RGBX[4]; 
     vx_uint8 YUV[3]; 
     vx_bool U1; 
     vx_uint8 U8; 
     vx_uint16 U16; 
     vx_int16 S16; 
     vx_uint32 U32; 
     vx_int32 S32; 
     vx_uint8 reserved[16];
 } vx_pixel_value_t;
  
 typedef struct {
     vx_int32 cell_width;
     vx_int32 cell_height;
     vx_int32 block_width;
     vx_int32 block_height;
     vx_int32 block_stride;
     vx_int32 num_bins;
     vx_int32 window_width;
     vx_int32 window_height;
     vx_int32 window_stride;
     vx_float32 threshold;
 } vx_hog_t;
  
 typedef struct _vx_border_t {
     vx_enum mode;
     vx_pixel_value_t constant_value;
 } vx_border_t;
  
 typedef vx_status(VX_API_CALL *vx_publish_kernels_f)(vx_context context);
  
 typedef vx_status(VX_API_CALL *vx_unpublish_kernels_f)(vx_context context);
  
 typedef vx_status(VX_CALLBACK *vx_kernel_f)(vx_node node, const vx_reference *parameters, vx_uint32 num);
  
 typedef vx_status(VX_CALLBACK *vx_kernel_initialize_f)(vx_node node, const vx_reference *parameters, vx_uint32 num);
  
 typedef vx_status(VX_CALLBACK *vx_kernel_deinitialize_f)(vx_node node, const vx_reference *parameters, vx_uint32 num);
  
 typedef vx_status(VX_CALLBACK *vx_kernel_validate_f)(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[]);
  
 typedef vx_status(VX_CALLBACK *vx_kernel_image_valid_rectangle_f)(vx_node node, vx_uint32 index, const vx_rectangle_t* const input_valid[], vx_rectangle_t* const output_valid[]);
  
 typedef void (VX_CALLBACK *vx_log_callback_f)(vx_context context,
                                   vx_reference ref,
                                   vx_status status,
                                   const vx_char string[]);
  
 enum vx_map_flag_e {
      VX_NOGAP_X = 1,  
 };
  
 #endif