The OpenVX Specification  2b213f9
Basic Features

## Detailed Description

The basic parts of OpenVX needed for computation.

Types in OpenVX intended to be derived from the C99 Section 7.18 standard definition of fixed width types.

## Modules

Objects
Defines the basic objects within OpenVX.

## Data Structures

struct  vx_coordinates2d_t
The 2D Coordinates structure. More...

struct  vx_coordinates3d_t
The 3D Coordinates structure. More...

struct  vx_keypoint_t
The keypoint data structure. More...

struct  vx_rectangle_t
The rectangle data structure that is shared with the users. The area of the rectangle can be computed as (end_x-start_x)*(end_y-start_y). More...

## Macros

#define VX_API_CALL
Defines calling convention for OpenVX API.

#define VX_ATTRIBUTE_BASE(vendor, object)   (((vendor) << 20) | (object << 8))
Defines the manner in which to combine the Vendor and Object IDs to get the base value of the enumeration.

An object's attribute ID is within the range of $$[0,2^{8}-1]$$ (inclusive).

#define VX_CALLBACK
Defines calling convention for user callbacks.

#define VX_DF_IMAGE(a, b, c, d)   ((a) | (b << 8) | (c << 16) | (d << 24))
Converts a set of four chars into a uint32_t container of a VX_DF_IMAGE code. More...

#define VX_ENUM_BASE(vendor, id)   (((vendor) << 20) | (id << 12))
Defines the manner in which to combine the Vendor and Object IDs to get the base value of the enumeration. More...

A generic enumeration list can have values between $$[0,2^{12}-1]$$ (inclusive).

#define VX_ENUM_TYPE(e)   (((vx_uint32)e & VX_ENUM_TYPE_MASK) >> 12)
A macro to extract the enum type from an enumerated value.

A type of enumeration. The valid range is between $$[0,2^{8}-1]$$ (inclusive).

#define VX_FMT_REF   "%p"
Use to aid in debugging values in OpenVX.

#define VX_FMT_SIZE   "%zu"
Use to aid in debugging values in OpenVX.

#define VX_KERNEL_BASE(vendor, lib)   (((vendor) << 20) | (lib << 12))
Defines the manner in which to combine the Vendor and Library IDs to get the base value of the enumeration.

An individual kernel in a library has its own unique ID within $$[0,2^{12}-1]$$ (inclusive).

#define VX_LIBRARY(e)   (((vx_uint32)e & VX_LIBRARY_MASK) >> 12)
A macro to extract the kernel library enumeration from a enumerated kernel value.

A library is a set of vision kernels with its own ID supplied by a vendor. The vendor defines the library ID. The range is $$[0,2^{8}-1]$$ inclusive.

#define VX_MAX_LOG_MESSAGE_LEN   (1024)
Defines the length of a message buffer to copy from the log, including the trailing zero.

#define VX_SCALE_UNITY   (1024u)
Use to indicate the 1:1 ratio in Q22.10 format.

#define VX_TYPE(e)   (((vx_uint32)e & VX_TYPE_MASK) >> 8)
A macro to extract the type from an enumerated attribute value.

A type mask removes the scalar/object type from the attribute. It is 3 nibbles in size and is contained between the third and second byte. More...

#define VX_VENDOR(e)   (((vx_uint32)e & VX_VENDOR_MASK) >> 20)
A macro to extract the vendor ID from the enumerated value.

Vendor IDs are 2 nibbles in size and are located in the upper byte of the 4 bytes of an enumeration.

#define VX_VERSION   VX_VERSION_1_1
Defines the OpenVX Version Number.

#define VX_VERSION_1_0   (VX_VERSION_MAJOR(1) | VX_VERSION_MINOR(0))
Defines the predefined version number for 1.0.

#define VX_VERSION_1_1   (VX_VERSION_MAJOR(1) | VX_VERSION_MINOR(1))
Defines the predefined version number for 1.1.

#define VX_VERSION_MAJOR(x)   ((x & 0xFF) << 8)
Defines the major version number macro.

#define VX_VERSION_MINOR(x)   ((x & 0xFF) << 0)
Defines the minor version number macro.

## Typedefs

typedef char vx_char
An 8 bit ASCII character.

typedef uint32_t vx_df_image
Used to hold a VX_DF_IMAGE code to describe the pixel format and color space.

typedef int32_t vx_enum
Sets the standard enumeration type size to be a fixed quantity. More...

typedef float vx_float32
A 32-bit float value.

typedef double vx_float64
A 64-bit float value (aka double).

typedef int16_t vx_int16
A 16-bit signed value.

typedef int32_t vx_int32
A 32-bit signed value.

typedef int64_t vx_int64
A 64-bit signed value.

typedef int8_t vx_int8
An 8-bit signed value.

typedef size_t vx_size
A wrapper of size_t to keep the naming convention uniform.

typedef vx_enum vx_status
A formal status type with known fixed size. More...

typedef uint16_t vx_uint16
A 16-bit unsigned value.

typedef uint32_t vx_uint32
A 32-bit unsigned value.

typedef uint64_t vx_uint64
A 64-bit unsigned value.

typedef uint8_t vx_uint8
An 8-bit unsigned value.

## Enumerations

enum  vx_bool {
vx_false_e = 0,
vx_true_e
}
A Boolean value. This allows 0 to be FALSE, as it is in C, and any non-zero to be TRUE. More...

enum  vx_channel_e {
VX_CHANNEL_0 = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x0,
VX_CHANNEL_1 = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x1,
VX_CHANNEL_2 = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x2,
VX_CHANNEL_3 = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x3,
VX_CHANNEL_R = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x10,
VX_CHANNEL_G = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x11,
VX_CHANNEL_B = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x12,
VX_CHANNEL_A = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x13,
VX_CHANNEL_Y = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x14,
VX_CHANNEL_U = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x15,
VX_CHANNEL_V = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CHANNEL << 12)) + 0x16
}
The channel enumerations for channel extractions. More...

enum  vx_convert_policy_e {
VX_CONVERT_POLICY_WRAP = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CONVERT_POLICY << 12)) + 0x0,
VX_CONVERT_POLICY_SATURATE = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_CONVERT_POLICY << 12)) + 0x1
}
The Conversion Policy Enumeration. More...

enum  vx_df_image_e {
VX_DF_IMAGE_VIRT = (( 'V' ) | ( 'I' << 8) | ( 'R' << 16) | ( 'T' << 24)),
VX_DF_IMAGE_RGB = (( 'R' ) | ( 'G' << 8) | ( 'B' << 16) | ( '2' << 24)),
VX_DF_IMAGE_RGBX = (( 'R' ) | ( 'G' << 8) | ( 'B' << 16) | ( 'A' << 24)),
VX_DF_IMAGE_NV12 = (( 'N' ) | ( 'V' << 8) | ( '1' << 16) | ( '2' << 24)),
VX_DF_IMAGE_NV21 = (( 'N' ) | ( 'V' << 8) | ( '2' << 16) | ( '1' << 24)),
VX_DF_IMAGE_UYVY = (( 'U' ) | ( 'Y' << 8) | ( 'V' << 16) | ( 'Y' << 24)),
VX_DF_IMAGE_YUYV = (( 'Y' ) | ( 'U' << 8) | ( 'Y' << 16) | ( 'V' << 24)),
VX_DF_IMAGE_IYUV = (( 'I' ) | ( 'Y' << 8) | ( 'U' << 16) | ( 'V' << 24)),
VX_DF_IMAGE_YUV4 = (( 'Y' ) | ( 'U' << 8) | ( 'V' << 16) | ( '4' << 24)),
VX_DF_IMAGE_U8 = (( 'U' ) | ( '0' << 8) | ( '0' << 16) | ( '8' << 24)),
VX_DF_IMAGE_U16 = (( 'U' ) | ( '0' << 8) | ( '1' << 16) | ( '6' << 24)),
VX_DF_IMAGE_S16 = (( 'S' ) | ( '0' << 8) | ( '1' << 16) | ( '6' << 24)),
VX_DF_IMAGE_U32 = (( 'U' ) | ( '0' << 8) | ( '3' << 16) | ( '2' << 24)),
VX_DF_IMAGE_S32 = (( 'S' ) | ( '0' << 8) | ( '3' << 16) | ( '2' << 24))
}
Based on the VX_DF_IMAGE definition. More...

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
}
The set of supported enumerations in OpenVX. More...

enum  vx_interpolation_type_e {
VX_INTERPOLATION_NEAREST_NEIGHBOR = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_INTERPOLATION << 12)) + 0x0,
VX_INTERPOLATION_BILINEAR = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_INTERPOLATION << 12)) + 0x1,
VX_INTERPOLATION_AREA = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_INTERPOLATION << 12)) + 0x2
}
The image reconstruction filters supported by image resampling operations. More...

enum  vx_non_linear_filter_e {
VX_NONLINEAR_FILTER_MEDIAN = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_NONLINEAR << 12)) + 0x0,
VX_NONLINEAR_FILTER_MIN = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_NONLINEAR << 12)) + 0x1,
VX_NONLINEAR_FILTER_MAX = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_NONLINEAR << 12)) + 0x2
}
An enumeration of non-linear filter functions. More...

enum  vx_pattern_e {
VX_PATTERN_BOX = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_PATTERN << 12)) + 0x0,
VX_PATTERN_CROSS = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_PATTERN << 12)) + 0x1,
VX_PATTERN_DISK = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_PATTERN << 12)) + 0x2,
VX_PATTERN_OTHER = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_PATTERN << 12)) + 0x3
}
An enumeration of matrix patterns. See vxCreateMatrixFromPattern  More...

enum  vx_status_e {
VX_STATUS_MIN = -25,
VX_ERROR_REFERENCE_NONZERO = -24,
VX_ERROR_MULTIPLE_WRITERS = -23,
VX_ERROR_GRAPH_ABANDONED = -22,
VX_ERROR_GRAPH_SCHEDULED = -21,
VX_ERROR_INVALID_SCOPE = -20,
VX_ERROR_INVALID_NODE = -19,
VX_ERROR_INVALID_GRAPH = -18,
VX_ERROR_INVALID_TYPE = -17,
VX_ERROR_INVALID_VALUE = -16,
VX_ERROR_INVALID_DIMENSION = -15,
VX_ERROR_INVALID_FORMAT = -14,
VX_ERROR_INVALID_REFERENCE = -12,
VX_ERROR_INVALID_MODULE = -11,
VX_ERROR_INVALID_PARAMETERS = -10,
VX_ERROR_OPTIMIZED_AWAY = -9,
VX_ERROR_NO_MEMORY = -8,
VX_ERROR_NO_RESOURCES = -7,
VX_ERROR_NOT_COMPATIBLE = -6,
VX_ERROR_NOT_ALLOCATED = -5,
VX_ERROR_NOT_SUFFICIENT = -4,
VX_ERROR_NOT_SUPPORTED = -3,
VX_ERROR_NOT_IMPLEMENTED = -2,
VX_FAILURE = -1,
VX_SUCCESS = 0
}
The enumeration of all status codes. More...

enum  vx_target_e {
VX_TARGET_ANY = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_TARGET << 12)) + 0x0000,
VX_TARGET_STRING = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_TARGET << 12)) + 0x0001,
VX_TARGET_VENDOR_BEGIN = ((( VX_ID_KHRONOS ) << 20) | ( VX_ENUM_TARGET << 12)) + 0x1000
}
The Target Enumeration. More...

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_BOOL = 0x010,
VX_TYPE_SCALAR_MAX,
VX_TYPE_RECTANGLE = 0x020,
VX_TYPE_KEYPOINT = 0x021,
VX_TYPE_COORDINATES2D = 0x022,
VX_TYPE_COORDINATES3D = 0x023,
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_TYPE_USER_STRUCT_START - 1,
VX_TYPE_USER_STRUCT_END = VX_TYPE_VENDOR_STRUCT_START - 1,
VX_TYPE_VENDOR_STRUCT_END = VX_TYPE_KHRONOS_OBJECT_START - 1,
VX_TYPE_KHRONOS_OBJECT_END = 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
}
The type enumeration lists all the known types in OpenVX. More...

enum  vx_vendor_id_e {
VX_ID_KHRONOS = 0x000,
VX_ID_TI = 0x001,
VX_ID_QUALCOMM = 0x002,
VX_ID_NVIDIA = 0x003,
VX_ID_ARM = 0x004,
VX_ID_BDTI = 0x005,
VX_ID_RENESAS = 0x006,
VX_ID_VIVANTE = 0x007,
VX_ID_XILINX = 0x008,
VX_ID_AXIS = 0x009,
VX_ID_MOVIDIUS = 0x00A,
VX_ID_SAMSUNG = 0x00B,
VX_ID_FREESCALE = 0x00C,
VX_ID_AMD = 0x00D,
VX_ID_INTEL = 0x00F,
VX_ID_MARVELL = 0x010,
VX_ID_MEDIATEK = 0x011,
VX_ID_ST = 0x012,
VX_ID_CEVA = 0x013,
VX_ID_ITSEEZ = 0x014,
VX_ID_IMAGINATION =0x015,
VX_ID_NXP = 0x016,
VX_ID_VIDEANTIS = 0x017,
VX_ID_SYNOPSYS = 0x018,
VX_ID_HUAWEI = 0x01A,
VX_ID_USER = 0xFFE,
VX_ID_MAX = 0xFFF,
VX_ID_DEFAULT = VX_ID_MAX
}
The Vendor ID of the Implementation. As new vendors submit their implementations, this enumeration will grow. More...

## Functions

vx_status VX_API_CALL vxGetStatus (vx_reference reference)
Provides a generic API to return status values from Object constructors if they fail. More...

## Data Structure Documentation

 struct vx_coordinates2d_t

The 2D Coordinates structure.

Definition at line 1483 of file vx_types.h.

Data Fields
vx_uint32 x The X coordinate.
vx_uint32 y The Y coordinate.
 struct vx_coordinates3d_t

The 3D Coordinates structure.

Definition at line 1491 of file vx_types.h.

Data Fields
vx_uint32 x The X coordinate.
vx_uint32 y The Y coordinate.
vx_uint32 z The Z coordinate.
 struct vx_keypoint_t

The keypoint data structure.

Definition at line 1460 of file vx_types.h.

Data Fields
vx_int32 x The x coordinate.
vx_int32 y The y coordinate.
vx_float32 strength The strength of the keypoint. Its definition is specific to the corner detector.
vx_float32 scale Initialized to 0 by corner detectors.
vx_float32 orientation Initialized to 0 by corner detectors.
vx_int32 tracking_status A zero indicates a lost point. Initialized to 1 by corner detectors.
vx_float32 error A tracking method specific error. Initialized to 0 by corner detectors.
 struct vx_rectangle_t

The rectangle data structure that is shared with the users. The area of the rectangle can be computed as (end_x-start_x)*(end_y-start_y).

Definition at line 1473 of file vx_types.h.

Data Fields
vx_uint32 start_x The Start X coordinate.
vx_uint32 start_y The Start Y coordinate.
vx_uint32 end_x The End X coordinate.
vx_uint32 end_y The End Y coordinate.

## Macro Definition Documentation

A type mask removes the scalar/object type from the attribute. It is 3 nibbles in size and is contained between the third and second byte.

vx_type_e

Definition at line 456 of file vx_types.h.

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

Converts a set of four chars into a uint32_t container of a VX_DF_IMAGE code.

Note
Use a vx_df_image variable to hold the value.

Definition at line 509 of file vx_types.h.

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

Defines the manner in which to combine the Vendor and Object IDs to get the base value of the enumeration.

From any enumerated value (with exceptions), the vendor, and enumeration type should be extractable. Those types that are exceptions are vx_vendor_id_e, vx_type_e, vx_enum_e, vx_df_image_e, and vx_bool.

Definition at line 533 of file vx_types.h.

## Typedef Documentation

 typedef int32_t vx_enum

Sets the standard enumeration type size to be a fixed quantity.

All enumerable fields must use this type as the container to enforce enumeration ranges and sizeof() operations.

Definition at line 160 of file vx_types.h.

 typedef vx_enum vx_status

A formal status type with known fixed size.

vx_status_e

Definition at line 428 of file vx_types.h.

## Enumeration Type Documentation

 enum vx_bool

A Boolean value. This allows 0 to be FALSE, as it is in C, and any non-zero to be TRUE.

if (ret) printf("true!\n");
ret = vx_false_e;
if (!ret) printf("false!\n");

This would print both strings.

Enumerator
vx_false_e

The "false" value.

vx_true_e

The "true" value.

Definition at line 301 of file vx_types.h.

 enum vx_type_e

The type enumeration lists all the known types in OpenVX.

Enumerator
VX_TYPE_INVALID

An invalid type value. When passed an error must be returned.

VX_TYPE_CHAR

A vx_char.

VX_TYPE_INT8

A vx_int8.

VX_TYPE_UINT8

A vx_uint8.

VX_TYPE_INT16

A vx_int16.

VX_TYPE_UINT16

A vx_uint16.

VX_TYPE_INT32

A vx_int32.

VX_TYPE_UINT32

A vx_uint32.

VX_TYPE_INT64

A vx_int64.

VX_TYPE_UINT64

A vx_uint64.

VX_TYPE_FLOAT32

A vx_float32.

VX_TYPE_FLOAT64

A vx_float64.

VX_TYPE_ENUM

A vx_enum. Equivalent in size to a vx_int32.

VX_TYPE_SIZE

A vx_size.

VX_TYPE_DF_IMAGE

A vx_df_image.

VX_TYPE_BOOL

A vx_bool.

VX_TYPE_SCALAR_MAX

A floating value for comparison between OpenVX scalars and OpenVX structs.

VX_TYPE_RECTANGLE

A vx_rectangle_t.

VX_TYPE_KEYPOINT

A vx_keypoint_t.

VX_TYPE_COORDINATES2D

A vx_coordinates2d_t.

VX_TYPE_COORDINATES3D

A vx_coordinates3d_t.

VX_TYPE_USER_STRUCT_START

A user-defined struct base index.

VX_TYPE_VENDOR_STRUCT_START

A vendor-defined struct base index.

VX_TYPE_KHRONOS_OBJECT_START

A Khronos defined object base index.

VX_TYPE_VENDOR_OBJECT_START

A vendor defined object base index.

VX_TYPE_KHRONOS_STRUCT_MAX

A value for comparison between Khronos defined structs and user structs.

VX_TYPE_USER_STRUCT_END

A value for comparison between user structs and vendor structs.

VX_TYPE_VENDOR_STRUCT_END

A value for comparison between vendor structs and Khronos defined objects.

VX_TYPE_KHRONOS_OBJECT_END

A value for comparison between Khronos defined objects and vendor structs.

VX_TYPE_VENDOR_OBJECT_END

A value used for bound checking of vendor objects.

VX_TYPE_REFERENCE

A vx_reference.

VX_TYPE_CONTEXT

A vx_context.

VX_TYPE_GRAPH

A vx_graph.

VX_TYPE_NODE

A vx_node.

VX_TYPE_KERNEL

A vx_kernel.

VX_TYPE_PARAMETER

A vx_parameter.

VX_TYPE_DELAY

A vx_delay.

VX_TYPE_LUT

A vx_lut.

VX_TYPE_DISTRIBUTION

A vx_distribution.

VX_TYPE_PYRAMID

A vx_pyramid.

VX_TYPE_THRESHOLD

A vx_threshold.

VX_TYPE_MATRIX

A vx_matrix.

VX_TYPE_CONVOLUTION

A vx_convolution.

VX_TYPE_SCALAR

A vx_scalar. when needed to be completely generic for kernel validation.

VX_TYPE_ARRAY

A vx_array.

VX_TYPE_IMAGE

A vx_image.

VX_TYPE_REMAP

A vx_remap.

VX_TYPE_ERROR

An error object which has no type.

VX_TYPE_META_FORMAT

A vx_meta_format.

VX_TYPE_OBJECT_ARRAY

A vx_object_array.

Definition at line 322 of file vx_types.h.

 enum vx_status_e

The enumeration of all status codes.

vx_status.
Enumerator
VX_STATUS_MIN

Indicates the lower bound of status codes in VX. Used for bounds checks only.

VX_ERROR_REFERENCE_NONZERO

Indicates that an operation did not complete due to a reference count being non-zero.

VX_ERROR_MULTIPLE_WRITERS

Indicates that the graph has more than one node outputting to the same data object. This is an invalid graph structure.

VX_ERROR_GRAPH_ABANDONED

Indicates that the graph is stopped due to an error or a callback that abandoned execution.

VX_ERROR_GRAPH_SCHEDULED

Indicates that the supplied graph already has been scheduled and may be currently executing.

VX_ERROR_INVALID_SCOPE

Indicates that the supplied parameter is from another scope and cannot be used in the current scope.

VX_ERROR_INVALID_NODE

Indicates that the supplied node could not be created.

VX_ERROR_INVALID_GRAPH

Indicates that the supplied graph has invalid connections (cycles).

VX_ERROR_INVALID_TYPE

Indicates that the supplied type parameter is incorrect.

VX_ERROR_INVALID_VALUE

Indicates that the supplied parameter has an incorrect value.

VX_ERROR_INVALID_DIMENSION

Indicates that the supplied parameter is too big or too small in dimension.

VX_ERROR_INVALID_FORMAT

Indicates that the supplied parameter is in an invalid format.

Indicates that the link is not possible as specified. The parameters are incompatible.

VX_ERROR_INVALID_REFERENCE

Indicates that the reference provided is not valid.

VX_ERROR_INVALID_MODULE

This is returned from vxLoadKernels when the module does not contain the entry point.

VX_ERROR_INVALID_PARAMETERS

Indicates that the supplied parameter information does not match the kernel contract.

VX_ERROR_OPTIMIZED_AWAY

Indicates that the object refered to has been optimized out of existence.

VX_ERROR_NO_MEMORY

Indicates that an internal or implicit allocation failed. Typically catastrophic. After detection, deconstruct the context.

vxVerifyGraph.
VX_ERROR_NO_RESOURCES

Indicates that an internal or implicit resource can not be acquired (not memory). This is typically catastrophic. After detection, deconstruct the context.

vxVerifyGraph.
VX_ERROR_NOT_COMPATIBLE

Indicates that the attempt to link two parameters together failed due to type incompatibilty.

VX_ERROR_NOT_ALLOCATED

Indicates to the system that the parameter must be allocated by the system.

VX_ERROR_NOT_SUFFICIENT

Indicates that the given graph has failed verification due to an insufficient number of required parameters, which cannot be automatically created. Typically this indicates required atomic parameters.

vxVerifyGraph.
VX_ERROR_NOT_SUPPORTED

Indicates that the requested set of parameters produce a configuration that cannot be supported. Refer to the supplied documentation on the configured kernels.

vx_kernel_e. This is also returned if a function to set an attribute is called on a Read-only attribute.
VX_ERROR_NOT_IMPLEMENTED

Indicates that the requested kernel is missing.

vx_kernel_e vxGetKernelByName.
VX_FAILURE

Indicates a generic error code, used when no other describes the error.

VX_SUCCESS

No error.

Definition at line 394 of file vx_types.h.

 enum vx_enum_e

The set of supported enumerations in OpenVX.

These can be extracted from enumerated values using VX_ENUM_TYPE.

Enumerator
VX_ENUM_DIRECTION

Parameter Direction.

VX_ENUM_ACTION

Action Codes.

VX_ENUM_HINT

Hint Values.

VX_ENUM_DIRECTIVE

Directive Values.

VX_ENUM_INTERPOLATION

Interpolation Types.

VX_ENUM_OVERFLOW

Overflow Policies.

VX_ENUM_COLOR_SPACE

Color Space.

VX_ENUM_COLOR_RANGE

Color Space Range.

VX_ENUM_PARAMETER_STATE

Parameter State.

VX_ENUM_CHANNEL

Channel Name.

VX_ENUM_CONVERT_POLICY

Convert Policy.

VX_ENUM_THRESHOLD_TYPE

Threshold Type List.

VX_ENUM_BORDER

Border Mode List.

VX_ENUM_COMPARISON

Comparison Values.

VX_ENUM_MEMORY_TYPE

The memory type enumeration.

VX_ENUM_TERM_CRITERIA

A termination criteria.

VX_ENUM_NORM_TYPE

A norm type.

VX_ENUM_ACCESSOR

An accessor flag type.

VX_ENUM_ROUND_POLICY

Rounding Policy.

VX_ENUM_TARGET

Target.

VX_ENUM_BORDER_POLICY

Unsupported Border Mode Policy List.

VX_ENUM_GRAPH_STATE

Graph attribute states.

VX_ENUM_NONLINEAR

Non-linear function list.

VX_ENUM_PATTERN

Matrix pattern enumeration.

Definition at line 539 of file vx_types.h.

 enum vx_convert_policy_e

The Conversion Policy Enumeration.

Enumerator
VX_CONVERT_POLICY_WRAP

Results are the least significant bits of the output operand, as if stored in two's complement binary format in the size of its bit-depth.

VX_CONVERT_POLICY_SATURATE

Results are saturated to the bit depth of the output operand.

Definition at line 663 of file vx_types.h.

 enum vx_df_image_e

Based on the VX_DF_IMAGE definition.

Note
Use vx_df_image to contain these values.
Enumerator
VX_DF_IMAGE_VIRT

A virtual image of no defined type.

VX_DF_IMAGE_RGB

A single plane of 24-bit pixel as 3 interleaved 8-bit units of R then G then B data. This uses the BT709 full range by default.

VX_DF_IMAGE_RGBX

A single plane of 32-bit pixel as 4 interleaved 8-bit units of R then G then B data, then a don't care byte. This uses the BT709 full range by default.

VX_DF_IMAGE_NV12

A 2-plane YUV format of Luma (Y) and interleaved UV data at 4:2:0 sampling. This uses the BT709 full range by default.

VX_DF_IMAGE_NV21

A 2-plane YUV format of Luma (Y) and interleaved VU data at 4:2:0 sampling. This uses the BT709 full range by default.

VX_DF_IMAGE_UYVY

A single plane of 32-bit macro pixel of U0, Y0, V0, Y1 bytes. This uses the BT709 full range by default.

VX_DF_IMAGE_YUYV

A single plane of 32-bit macro pixel of Y0, U0, Y1, V0 bytes. This uses the BT709 full range by default.

VX_DF_IMAGE_IYUV

A 3 plane of 8-bit 4:2:0 sampled Y, U, V planes. This uses the BT709 full range by default.

VX_DF_IMAGE_YUV4

A 3 plane of 8 bit 4:4:4 sampled Y, U, V planes. This uses the BT709 full range by default.

VX_DF_IMAGE_U8

A single plane of unsigned 8-bit data. The range of data is not specified, as it may be extracted from a YUV or generated.

VX_DF_IMAGE_U16

A single plane of unsigned 16-bit data. The range of data is not specified, as it may be extracted from a YUV or generated.

VX_DF_IMAGE_S16

A single plane of signed 16-bit data. The range of data is not specified, as it may be extracted from a YUV or generated.

VX_DF_IMAGE_U32

A single plane of unsigned 32-bit data. The range of data is not specified, as it may be extracted from a YUV or generated.

VX_DF_IMAGE_S32

A single plane of unsigned 32-bit data. The range of data is not specified, as it may be extracted from a YUV or generated.

Definition at line 676 of file vx_types.h.

 enum vx_target_e

The Target Enumeration.

Enumerator
VX_TARGET_ANY

Any available target. An OpenVX implementation must support at least one target associated with this value.

VX_TARGET_STRING

Target, explicitly specified by its (case-insensitive) name string.

VX_TARGET_VENDOR_BEGIN

Start of Vendor specific target enumerates.

Definition at line 742 of file vx_types.h.

 enum vx_channel_e

The channel enumerations for channel extractions.

vxChannelExtractNode
vxuChannelExtract
VX_KERNEL_CHANNEL_EXTRACT
Enumerator
VX_CHANNEL_0

Used by formats with unknown channel types.

VX_CHANNEL_1

Used by formats with unknown channel types.

VX_CHANNEL_2

Used by formats with unknown channel types.

VX_CHANNEL_3

Used by formats with unknown channel types.

VX_CHANNEL_R

Use to extract the RED channel, no matter the byte or packing order.

VX_CHANNEL_G

Use to extract the GREEN channel, no matter the byte or packing order.

VX_CHANNEL_B

Use to extract the BLUE channel, no matter the byte or packing order.

VX_CHANNEL_A

Use to extract the ALPHA channel, no matter the byte or packing order.

VX_CHANNEL_Y

Use to extract the LUMA channel, no matter the byte or packing order.

VX_CHANNEL_U

Use to extract the Cb/U channel, no matter the byte or packing order.

VX_CHANNEL_V

Use to extract the Cr/V/Value channel, no matter the byte or packing order.

Definition at line 1110 of file vx_types.h.

The image reconstruction filters supported by image resampling operations.

The edge of a pixel is interpreted as being aligned to the edge of the image. The value for an output pixel is evaluated at the center of that pixel.

This means, for example, that an even enlargement of a factor of two in nearest-neighbor interpolation will replicate every source pixel into a 2x2 quad in the destination, and that an even shrink by a factor of two in bilinear interpolation will create each destination pixel by average a 2x2 quad of source pixels.

Samples that cross the boundary of the source image have values determined by the border mode - see vx_border_e and VX_NODE_BORDER.

vxuScaleImage
vxScaleImageNode
VX_KERNEL_SCALE_IMAGE
vxuWarpAffine
vxWarpAffineNode
VX_KERNEL_WARP_AFFINE
vxuWarpPerspective
vxWarpPerspectiveNode
VX_KERNEL_WARP_PERSPECTIVE
Enumerator
VX_INTERPOLATION_NEAREST_NEIGHBOR

Output values are defined to match the source pixel whose center is nearest to the sample position.

VX_INTERPOLATION_BILINEAR

Output values are defined by bilinear interpolation between the pixels whose centers are closest to the sample position, weighted linearly by the distance of the sample from the pixel centers.

VX_INTERPOLATION_AREA

Output values are determined by averaging the source pixels whose areas fall under the area of the destination pixel, projected onto the source image.

Definition at line 1170 of file vx_types.h.

An enumeration of non-linear filter functions.

Enumerator
VX_NONLINEAR_FILTER_MEDIAN

Nonlinear median filter.

VX_NONLINEAR_FILTER_MIN

Nonlinear Erode.

VX_NONLINEAR_FILTER_MAX

Nonlinear Dilate.

Definition at line 1184 of file vx_types.h.

 enum vx_pattern_e

An enumeration of matrix patterns. See vxCreateMatrixFromPattern

Enumerator
VX_PATTERN_BOX

Box pattern matrix.

VX_PATTERN_CROSS

Cross pattern matrix.

VX_PATTERN_DISK

A square matrix (rows = columns = size)

VX_PATTERN_OTHER

Matrix with any pattern othern than above.

Definition at line 1196 of file vx_types.h.

 enum vx_vendor_id_e

The Vendor ID of the Implementation. As new vendors submit their implementations, this enumeration will grow.

Enumerator
VX_ID_KHRONOS

The Khronos Group.

VX_ID_TI

Texas Instruments, Inc.

VX_ID_QUALCOMM

Qualcomm, Inc.

VX_ID_NVIDIA

NVIDIA Corporation.

VX_ID_ARM

ARM Ltd.

VX_ID_BDTI

Berkley Design Technology, Inc.

VX_ID_RENESAS

Renasas Electronics.

VX_ID_VIVANTE

Vivante Corporation.

VX_ID_XILINX

Xilinx Inc.

VX_ID_AXIS

Axis Communications.

VX_ID_MOVIDIUS

Movidius Ltd.

VX_ID_SAMSUNG

Samsung Electronics.

VX_ID_FREESCALE

Freescale Semiconductor.

VX_ID_AMD

VX_ID_INTEL

Intel Corporation.

VX_ID_MARVELL

Marvell Technology Group Ltd.

VX_ID_MEDIATEK

MediaTek, Inc.

VX_ID_ST

STMicroelectronics.

VX_ID_CEVA

CEVA DSP.

VX_ID_ITSEEZ

Itseez, Inc.

VX_ID_IMAGINATION

Imagination Technologies.

VX_ID_NXP

NXP Semiconductors.

VX_ID_VIDEANTIS

Videantis.

VX_ID_SYNOPSYS

Synopsys.

VX_ID_HUAWEI

Huawei.

VX_ID_USER

For use by vxAllocateUserKernelId and vxAllocateUserKernelLibraryId.

VX_ID_DEFAULT

For use by all Kernel authors until they can obtain an assigned ID.

Definition at line 36 of file vx_vendors.h.

## Function Documentation

 vx_status VX_API_CALL vxGetStatus ( vx_reference reference )

Provides a generic API to return status values from Object constructors if they fail.

Note
Users do not need to strictly check every object creator as the errors should properly propagate and be detected during verification time or run-time.
vx_image img = vxCreateImage(context, 639, 480, VX_DF_IMAGE_UYVY);
// status == VX_ERROR_INVALID_DIMENSIONS
Precondition
Appropriate Object Creator function.
Postcondition
Appropriate Object Release function.
Parameters
 [in] reference The reference to check for construction errors.
Returns
A vx_status_e enumeration.
Return values
 VX_SUCCESS No error. * Some error occurred, please check enumeration list and constructor.