vx_types.h

/*
 * Copyright (c) 2012-2017 The Khronos Group Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and/or associated documentation files (the
 * "Materials"), to deal in the Materials without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Materials, and to
 * permit persons to whom the Materials are furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Materials.
 *
 * MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
 * KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
 * SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
 *    https://www.khronos.org/registry/
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

#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)

typedef hfloat   vx_float16;
#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 enum _vx_bool_e {
    vx_false_e = 0,
    vx_true_e,
} vx_bool;

typedef struct _vx_meta_format* vx_meta_format;

#define VX_TYPE_INVALID         0x000
#define VX_TYPE_CHAR            0x001
#define VX_TYPE_INT8            0x002
#define VX_TYPE_UINT8           0x003
#define VX_TYPE_INT16           0x004
#define VX_TYPE_UINT16          0x005
#define VX_TYPE_INT32           0x006
#define VX_TYPE_UINT32          0x007
#define VX_TYPE_INT64           0x008
#define VX_TYPE_UINT64          0x009
#define VX_TYPE_FLOAT32         0x00A
#define VX_TYPE_FLOAT64         0x00B
#define VX_TYPE_ENUM            0x00C
#define VX_TYPE_SIZE            0x00D
#define VX_TYPE_DF_IMAGE        0x00E
#if defined(EXPERIMENTAL_PLATFORM_SUPPORTS_16_FLOAT)
#define VX_TYPE_FLOAT16         0x00F
#endif
#define VX_TYPE_BOOL            0x010
    /* add new scalar types here */

#define VX_TYPE_SCALAR_MAX  (VX_TYPE_BOOL+1)     
#define VX_TYPE_RECTANGLE            0x020
#define VX_TYPE_KEYPOINT             0x021
#define VX_TYPE_COORDINATES2D        0x022
#define VX_TYPE_COORDINATES3D        0x023
#define VX_TYPE_USER_STRUCT_START    0x100
#define VX_TYPE_VENDOR_STRUCT_START  0x400
#define VX_TYPE_KHRONOS_OBJECT_START 0x800
#define VX_TYPE_VENDOR_OBJECT_START  0xC00
#define VX_TYPE_KHRONOS_STRUCT_MAX   VX_TYPE_USER_STRUCT_START - 1
#define VX_TYPE_USER_STRUCT_END      VX_TYPE_VENDOR_STRUCT_START - 1
#define VX_TYPE_VENDOR_STRUCT_END    VX_TYPE_KHRONOS_OBJECT_START - 1
#define VX_TYPE_KHRONOS_OBJECT_END   VX_TYPE_VENDOR_OBJECT_START - 1
#define VX_TYPE_VENDOR_OBJECT_END    0xFFF
#define VX_TYPE_REFERENCE       0x800
#define VX_TYPE_CONTEXT         0x801
#define VX_TYPE_GRAPH           0x802
#define VX_TYPE_NODE            0x803
#define VX_TYPE_KERNEL          0x804
#define VX_TYPE_PARAMETER       0x805
#define VX_TYPE_DELAY           0x806
#define VX_TYPE_LUT             0x807
#define VX_TYPE_DISTRIBUTION    0x808
#define VX_TYPE_PYRAMID         0x809
#define VX_TYPE_THRESHOLD       0x80A
#define VX_TYPE_MATRIX          0x80B
#define VX_TYPE_CONVOLUTION     0x80C
#define VX_TYPE_SCALAR          0x80D
#define VX_TYPE_ARRAY           0x80E
#define VX_TYPE_IMAGE           0x80F
#define VX_TYPE_REMAP           0x810
#define VX_TYPE_ERROR           0x811
#define VX_TYPE_META_FORMAT     0x812
#define VX_TYPE_OBJECT_ARRAY    0x813
    /* \todo add new object types here */

#define VX_STATUS_MIN                       -25
    /* add new codes here */
#define VX_ERROR_REFERENCE_NONZERO          -24
#define VX_ERROR_MULTIPLE_WRITERS           -23
#define VX_ERROR_GRAPH_ABANDONED            -22
#define VX_ERROR_GRAPH_SCHEDULED            -21
#define VX_ERROR_INVALID_SCOPE              -20
#define VX_ERROR_INVALID_NODE               -19
#define VX_ERROR_INVALID_GRAPH              -18
#define VX_ERROR_INVALID_TYPE               -17
#define VX_ERROR_INVALID_VALUE              -16
#define VX_ERROR_INVALID_DIMENSION          -15
#define VX_ERROR_INVALID_FORMAT             -14
#define VX_ERROR_INVALID_LINK               -13
#define VX_ERROR_INVALID_REFERENCE          -12
#define VX_ERROR_INVALID_MODULE             -11
#define VX_ERROR_INVALID_PARAMETERS         -10
#define VX_ERROR_OPTIMIZED_AWAY             -9
#define VX_ERROR_NO_MEMORY                  -8
#define VX_ERROR_NO_RESOURCES               -7
#define VX_ERROR_NOT_COMPATIBLE             -6
#define VX_ERROR_NOT_ALLOCATED              -5
#define VX_ERROR_NOT_SUFFICIENT             -4
#define VX_ERROR_NOT_SUPPORTED              -3
#define VX_ERROR_NOT_IMPLEMENTED            -2
#define VX_FAILURE                          -1
#define 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                      (0xFFF00000)

#define VX_TYPE_MASK                        (0x000FFF00)

#define VX_LIBRARY_MASK                     (0x000FF000)

#define VX_KERNEL_MASK                      (0x00000FFF)

#define VX_ATTRIBUTE_ID_MASK                (0x000000FF)

#define VX_ENUM_TYPE_MASK                   (0x000FF000)

#define VX_ENUM_MASK                        (0x00000FFF)

#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_SHL(A, B) (((uint32_t)(A)) << ((uint32_t)(B)))


#define VX_DF_IMAGE(a,b,c,d)                  (VX_SHL(a, 0) | VX_SHL(b, 8) | VX_SHL(c, 16) | VX_SHL(d,24))

#define VX_ATTRIBUTE_BASE(vendor, object)   (VX_SHL(vendor, 20) | VX_SHL(object, 8))

#define VX_KERNEL_BASE(vendor, lib)         (VX_SHL(vendor, 20) | VX_SHL(lib, 12))

#define VX_ENUM_BASE(vendor, id)         (VX_SHL(vendor, 20) | VX_SHL(id, 12))

#define VX_ENUM_DIRECTION       0x00 
#define VX_ENUM_ACTION          0x01 
#define VX_ENUM_HINT            0x02 
#define VX_ENUM_DIRECTIVE       0x03 
#define VX_ENUM_INTERPOLATION   0x04 
#define VX_ENUM_OVERFLOW        0x05 
#define VX_ENUM_COLOR_SPACE     0x06 
#define VX_ENUM_COLOR_RANGE     0x07 
#define VX_ENUM_PARAMETER_STATE 0x08 
#define VX_ENUM_CHANNEL         0x09 
#define VX_ENUM_CONVERT_POLICY  0x0A 
#define VX_ENUM_THRESHOLD_TYPE  0x0B 
#define VX_ENUM_BORDER          0x0C 
#define VX_ENUM_COMPARISON      0x0D 
#define VX_ENUM_MEMORY_TYPE     0x0E 
#define VX_ENUM_TERM_CRITERIA   0x0F 
#define VX_ENUM_NORM_TYPE       0x10 
#define VX_ENUM_ACCESSOR        0x11 
#define VX_ENUM_ROUND_POLICY    0x12 
#define VX_ENUM_TARGET          0x13 
#define VX_ENUM_BORDER_POLICY   0x14 
#define VX_ENUM_GRAPH_STATE     0x15 
#define VX_ENUM_NONLINEAR       0x16 
#define VX_ENUM_PATTERN         0x17 
#define VX_ENUM(vendor, id, num) (vx_enum)(VX_ENUM_BASE(vendor, id) + (uint32_t)(num))

#define VX_ENUM_KERNEL(vendor, lib, num) (vx_enum)(VX_KERNEL_BASE(vendor, lib) + (uint32_t)(num))


#define VX_ATTRIBUTE_ENUM(vendor, object, num) (vx_enum)(VX_ATTRIBUTE_BASE(vendor, object) + (uint32_t)(num))


#define VX_ACTION_CONTINUE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ACTION, 0x0))
#define VX_ACTION_ABANDON  (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ACTION, 0x1))
#define VX_INPUT (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTION, 0x0))

#define VX_OUTPUT (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTION,0x1))

#define VX_BIDIRECTIONAL (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTION, 0x2))

#define VX_HINT_PERFORMANCE_DEFAULT (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_HINT, 0x1))

#define VX_HINT_PERFORMANCE_LOW_POWER (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_HINT, 0x2))

#define VX_HINT_PERFORMANCE_HIGH_SPEED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_HINT, 0x3))

#define VX_DIRECTIVE_DISABLE_LOGGING (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE, 0x0))

#define VX_DIRECTIVE_ENABLE_LOGGING (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE, 0x1))

#define VX_DIRECTIVE_DISABLE_PERFORMANCE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE, 0x2))

#define VX_DIRECTIVE_ENABLE_PERFORMANCE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_DIRECTIVE, 0x3))


#define VX_GRAPH_STATE_UNVERIFIED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE, 0x0))

#define VX_GRAPH_STATE_VERIFIED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE, 0x1))

#define VX_GRAPH_STATE_RUNNING (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE, 0x2))

#define VX_GRAPH_STATE_ABANDONED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE, 0x3))

#define VX_GRAPH_STATE_COMPLETED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_GRAPH_STATE, 0x4))


#define VX_GRAPH_NUMNODES (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_GRAPH, 0x0))

#define VX_GRAPH_PERFORMANCE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_GRAPH, 0x2))

#define VX_GRAPH_NUMPARAMETERS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_GRAPH, 0x3))

#define VX_GRAPH_STATE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_GRAPH, 0x4))


#define VX_CONVERT_POLICY_WRAP (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CONVERT_POLICY, 0x0))

#define VX_CONVERT_POLICY_SATURATE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CONVERT_POLICY, 0x1))

#define VX_DF_IMAGE_VIRT (VX_DF_IMAGE('V','I','R','T'))

#define VX_DF_IMAGE_RGB (VX_DF_IMAGE('R','G','B','2'))

#define VX_DF_IMAGE_RGBX (VX_DF_IMAGE('R','G','B','A'))

#define VX_DF_IMAGE_NV12 (VX_DF_IMAGE('N','V','1','2'))

#define VX_DF_IMAGE_NV21 (VX_DF_IMAGE('N','V','2','1'))

#define VX_DF_IMAGE_UYVY (VX_DF_IMAGE('U','Y','V','Y'))

#define VX_DF_IMAGE_YUYV (VX_DF_IMAGE('Y','U','Y','V'))

#define VX_DF_IMAGE_IYUV (VX_DF_IMAGE('I','Y','U','V'))

#define VX_DF_IMAGE_YUV4 (VX_DF_IMAGE('Y','U','V','4'))

#define VX_DF_IMAGE_U8 (VX_DF_IMAGE('U','0','0','8'))

#define VX_DF_IMAGE_U16  (VX_DF_IMAGE('U','0','1','6'))

#define VX_DF_IMAGE_S16  (VX_DF_IMAGE('S','0','1','6'))

#define VX_DF_IMAGE_U32  (VX_DF_IMAGE('U','0','3','2'))

#define VX_DF_IMAGE_S32  (VX_DF_IMAGE('S','0','3','2'))

#define VX_TARGET_ANY (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_TARGET, 0x0000))

#define VX_TARGET_STRING (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_TARGET, 0x0001))

#define VX_TARGET_VENDOR_BEGIN (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_TARGET, 0x1000))

#define VX_REFERENCE_COUNT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REFERENCE, 0x0))

#define VX_REFERENCE_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REFERENCE,  0x1))

#define VX_REFERENCE_NAME (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REFERENCE, 0x2))


#define VX_CONTEXT_VENDOR_ID (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x0))

#define VX_CONTEXT_VERSION (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x1))

#define VX_CONTEXT_UNIQUE_KERNELS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x2))

#define VX_CONTEXT_MODULES (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x3))

#define VX_CONTEXT_REFERENCES (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT,  0x4))

#define VX_CONTEXT_IMPLEMENTATION (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x5))

#define VX_CONTEXT_EXTENSIONS_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x6))

#define VX_CONTEXT_EXTENSIONS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x7))

#define VX_CONTEXT_CONVOLUTION_MAX_DIMENSION (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x8))

#define VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0x9))

#define VX_CONTEXT_IMMEDIATE_BORDER (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0xA))

#define VX_CONTEXT_UNIQUE_KERNEL_TABLE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0xB))

#define VX_CONTEXT_IMMEDIATE_BORDER_POLICY (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0xC))

#define VX_CONTEXT_NONLINEAR_MAX_DIMENSION (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONTEXT, 0xd))

#define VX_KERNEL_PARAMETERS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_KERNEL, 0x0))

#define VX_KERNEL_NAME (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_KERNEL, 0x1))

#define VX_KERNEL_ENUM (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_KERNEL, 0x2))

#define VX_KERNEL_LOCAL_DATA_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_KERNEL, 0x3))


#define VX_NODE_STATUS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x0))

#define VX_NODE_PERFORMANCE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x1))

#define VX_NODE_BORDER (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x2))

#define VX_NODE_LOCAL_DATA_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x3))

#define VX_NODE_LOCAL_DATA_PTR (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x4))

#define VX_NODE_PARAMETERS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x5))

#define VX_NODE_IS_REPLICATED (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x6))

#define VX_NODE_REPLICATE_FLAGS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE,  0x7))

#define VX_NODE_VALID_RECT_RESET (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_NODE, 0x8))

#define VX_PARAMETER_INDEX (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PARAMETER, 0x0))

#define VX_PARAMETER_DIRECTION (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PARAMETER, 0x1))

#define VX_PARAMETER_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PARAMETER, 0x2))

#define VX_PARAMETER_STATE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PARAMETER, 0x3))

#define VX_PARAMETER_REF (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PARAMETER, 0x4))

#define VX_IMAGE_WIDTH (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x0))

#define VX_IMAGE_HEIGHT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x1))

#define VX_IMAGE_FORMAT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x2))

#define VX_IMAGE_PLANES (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x3))

#define VX_IMAGE_SPACE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x4))

#define VX_IMAGE_RANGE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x5))

#define VX_IMAGE_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x6))

#define VX_IMAGE_MEMORY_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_IMAGE, 0x7))

#define VX_SCALAR_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_SCALAR, 0x0))

#define VX_LUT_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS,VX_TYPE_LUT, 0x0))

#define VX_LUT_COUNT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS,VX_TYPE_LUT, 0x1))

#define VX_LUT_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS,VX_TYPE_LUT, 0x2))

#define VX_LUT_OFFSET (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS,VX_TYPE_LUT, 0x3))

#define VX_DISTRIBUTION_DIMENSIONS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION, 0x0))

#define VX_DISTRIBUTION_OFFSET (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION, 0x1))

#define VX_DISTRIBUTION_RANGE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION, 0x2))

#define VX_DISTRIBUTION_BINS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION, 0x3))

#define VX_DISTRIBUTION_WINDOW (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION, 0x4))

#define VX_DISTRIBUTION_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DISTRIBUTION, 0x5))

#define VX_THRESHOLD_TYPE_BINARY (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_THRESHOLD_TYPE, 0x0))

#define VX_THRESHOLD_TYPE_RANGE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_THRESHOLD_TYPE, 0x1))

#define VX_THRESHOLD_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x0))

#define VX_THRESHOLD_THRESHOLD_VALUE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x1))

#define VX_THRESHOLD_THRESHOLD_LOWER (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x2))

#define VX_THRESHOLD_THRESHOLD_UPPER (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x3))

#define VX_THRESHOLD_TRUE_VALUE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x4))

#define VX_THRESHOLD_FALSE_VALUE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x5))

#define VX_THRESHOLD_DATA_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_THRESHOLD, 0x6))

#define VX_MATRIX_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_MATRIX, 0x0))

#define VX_MATRIX_ROWS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_MATRIX, 0x1))

#define VX_MATRIX_COLUMNS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_MATRIX, 0x2))

#define VX_MATRIX_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_MATRIX, 0x3))

#define VX_MATRIX_ORIGIN (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_MATRIX, 0x4))

#define VX_MATRIX_PATTERN (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_MATRIX, 0x5))

#define VX_CONVOLUTION_ROWS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION, 0x0))

#define VX_CONVOLUTION_COLUMNS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION, 0x1))

#define VX_CONVOLUTION_SCALE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION, 0x2))

#define VX_CONVOLUTION_SIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_CONVOLUTION, 0x3))

#define VX_PYRAMID_LEVELS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PYRAMID, 0x0))

#define VX_PYRAMID_SCALE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PYRAMID, 0x1))

#define VX_PYRAMID_WIDTH (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PYRAMID, 0x2))

#define VX_PYRAMID_HEIGHT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PYRAMID, 0x3))

#define VX_PYRAMID_FORMAT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_PYRAMID, 0x4))

#define VX_REMAP_SOURCE_WIDTH (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REMAP, 0x0))

#define VX_REMAP_SOURCE_HEIGHT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REMAP, 0x1))

#define VX_REMAP_DESTINATION_WIDTH (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REMAP, 0x2))

#define VX_REMAP_DESTINATION_HEIGHT (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_REMAP, 0x3))

#define VX_ARRAY_ITEMTYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_ARRAY, 0x0))

#define VX_ARRAY_NUMITEMS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_ARRAY, 0x1))

#define VX_ARRAY_CAPACITY (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_ARRAY, 0x2))

#define VX_ARRAY_ITEMSIZE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_ARRAY, 0x3))

#define VX_OBJECT_ARRAY_ITEMTYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_OBJECT_ARRAY, 0x0))

#define VX_OBJECT_ARRAY_NUMITEMS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_OBJECT_ARRAY, 0x1))

#define VX_VALID_RECT_CALLBACK (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_META_FORMAT, 0x1))

#define VX_CHANNEL_0 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x0))

#define VX_CHANNEL_1 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x1))

#define VX_CHANNEL_2 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x2))

#define VX_CHANNEL_3 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x3))

#define VX_CHANNEL_R (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x10))

#define VX_CHANNEL_G (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x11))

#define VX_CHANNEL_B (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x12))

#define VX_CHANNEL_A (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x13))

#define VX_CHANNEL_Y (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x14))

#define VX_CHANNEL_U (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x15))

#define VX_CHANNEL_V (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_CHANNEL, 0x16))

#define VX_MEMORY_TYPE_NONE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_MEMORY_TYPE, 0x0))

#define VX_MEMORY_TYPE_HOST (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_MEMORY_TYPE, 0x1))

#define VX_INTERPOLATION_NEAREST_NEIGHBOR (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_INTERPOLATION, 0x0))

#define VX_INTERPOLATION_BILINEAR (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_INTERPOLATION, 0x1))

#define VX_INTERPOLATION_AREA (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_INTERPOLATION, 0x2))

#define VX_NONLINEAR_FILTER_MEDIAN (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_NONLINEAR, 0x0))

#define VX_NONLINEAR_FILTER_MIN (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_NONLINEAR, 0x1))

#define VX_NONLINEAR_FILTER_MAX (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_NONLINEAR, 0x2))

#define VX_PATTERN_BOX (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_PATTERN, 0x0))

#define VX_PATTERN_CROSS (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_PATTERN, 0x1))

#define VX_PATTERN_DISK (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_PATTERN, 0x2))

#define VX_PATTERN_OTHER (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_PATTERN, 0x3))

#define VX_COLOR_SPACE_NONE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE, 0x0))

#define VX_COLOR_SPACE_BT601_525 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE, 0x1))

#define VX_COLOR_SPACE_BT601_625 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE, 0x2))

#define VX_COLOR_SPACE_BT709 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_COLOR_SPACE, 0x3))

#define VX_COLOR_SPACE_DEFAULT VX_COLOR_SPACE_BT709

#define VX_CHANNEL_RANGE_FULL (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_COLOR_RANGE, 0x0))

#define VX_CHANNEL_RANGE_RESTRICTED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_COLOR_RANGE, 0x1))

#define VX_PARAMETER_STATE_REQUIRED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_PARAMETER_STATE, 0x0))

#define VX_PARAMETER_STATE_OPTIONAL (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_PARAMETER_STATE, 0x1))

#define VX_BORDER_UNDEFINED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_BORDER, 0x0))

#define VX_BORDER_CONSTANT (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_BORDER, 0x1))

#define VX_BORDER_REPLICATE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_BORDER, 0x2))

#define VX_BORDER_POLICY_DEFAULT_TO_UNDEFINED (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_BORDER_POLICY, 0x0))

#define VX_BORDER_POLICY_RETURN_ERROR (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_BORDER_POLICY, 0x1))

#define VX_TERM_CRITERIA_ITERATIONS (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_TERM_CRITERIA, 0x0))

#define VX_TERM_CRITERIA_EPSILON (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_TERM_CRITERIA, 0x1))

#define VX_TERM_CRITERIA_BOTH (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_TERM_CRITERIA, 0x2))

#define VX_NORM_L1 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_NORM_TYPE, 0x0))

#define VX_NORM_L2 (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_NORM_TYPE, 0x1))

#define VX_DELAY_TYPE (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DELAY, 0x0))

#define VX_DELAY_SLOTS (VX_ATTRIBUTE_ENUM(VX_ID_KHRONOS, VX_TYPE_DELAY, 0x1))

#define VX_READ_ONLY (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ACCESSOR, 0x1))

#define VX_WRITE_ONLY (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ACCESSOR, 0x2))

#define VX_READ_AND_WRITE (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ACCESSOR, 0x3))

#define VX_ROUND_POLICY_TO_ZERO (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ROUND_POLICY, 0x1))

#define VX_ROUND_POLICY_TO_NEAREST_EVEN (VX_ENUM(VX_ID_KHRONOS, VX_ENUM_ROUND_POLICY, 0x2))

#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_uint32 step_y;       
} vx_imagepatch_addressing_t;

#define VX_IMAGEPATCH_ADDR_INIT {0u, 0u, 0, 0, 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;

#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_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_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_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[]);

#define VX_NOGAP_X  1

#endif