VX_API_ENTRY vx_status VX_API_CALL vxQueryArray(vx_array arr, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_ERROR_INVALID_REFERENCE;
if (vxIsValidArray(arr) == vx_true_e)
{
status = VX_SUCCESS;
switch (attribute)
{
case VX_ARRAY_ATTRIBUTE_ITEMTYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = arr->item_type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_ARRAY_ATTRIBUTE_NUMITEMS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = arr->num_items;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_ARRAY_ATTRIBUTE_CAPACITY:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = arr->capacity;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_ARRAY_ATTRIBUTE_ITEMSIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = arr->item_size;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
return status;
}
vx_status vxQueryConvolution(vx_convolution conv, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_convolution_t *convolution = (vx_convolution_t *)conv;
if (vxIsValidSpecificReference(&convolution->base.base, VX_TYPE_CONVOLUTION) == vx_false_e)
{
return VX_ERROR_INVALID_REFERENCE;
}
switch (attribute)
{
case VX_CONVOLUTION_ATTRIBUTE_ROWS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = convolution->base.rows;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONVOLUTION_ATTRIBUTE_COLUMNS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = convolution->base.columns;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONVOLUTION_ATTRIBUTE_SCALE:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = convolution->scale;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONVOLUTION_ATTRIBUTE_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = convolution->base.columns * convolution->base.rows * sizeof(vx_int16);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxSetContextAttribute(vx_context context, vx_enum attribute, const void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidContext(context) == vx_false_e)
{
status = VX_ERROR_INVALID_REFERENCE;
}
else
{
switch (attribute) {
case VX_CONTEXT_IMMEDIATE_BORDER:
if (VX_CHECK_PARAM(ptr, size, vx_border_t, 0x3))
{
vx_border_t *config = (vx_border_t *)ptr;
if (vxIsValidBorderMode(config->mode) == vx_false_e)
status = VX_ERROR_INVALID_VALUE;
else
{
context->imm_border = *config;
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_IMMEDIATE_BORDER_POLICY:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
vx_enum policy = *(vx_enum *)ptr;
if (vxIsValidBorderModePolicy(policy) == vx_false_e)
status = VX_ERROR_INVALID_VALUE;
else
{
context->imm_border_policy = policy;
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryScalar(vx_scalar scalar, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_scalar_t *pscalar = (vx_scalar_t *)scalar;
if (vxIsValidSpecificReference(&pscalar->base,VX_TYPE_SCALAR) == vx_false_e)
return VX_ERROR_INVALID_REFERENCE;
switch (attribute)
{
case VX_SCALAR_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = pscalar->data_type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryLUT(vx_lut l, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_lut_t *lut = (vx_lut_t *)l;
if (vxIsValidSpecificReference(&lut->base, VX_TYPE_LUT) == vx_false_e)
return VX_ERROR_INVALID_REFERENCE;
switch (attribute)
{
case VX_LUT_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = lut->item_type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_LUT_ATTRIBUTE_COUNT:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = lut->num_items;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_LUT_ATTRIBUTE_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = lut->num_items * lut->item_size;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
vx_status vxQueryReference(vx_reference r, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_reference_t *ref = (vx_reference_t *)r;
/* if it is not a reference and not a context */
if ((vxIsValidReference(ref) == vx_false_e) &&
(vxIsValidContext((vx_context_t *)ref) == vx_false_e)) {
return VX_ERROR_INVALID_REFERENCE;
}
switch (attribute)
{
case VX_REF_ATTRIBUTE_COUNT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = ref->external_count;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_REF_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = ref->type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
vx_status vxSetConvolutionAttribute(vx_convolution conv, vx_enum attr, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_convolution_t *convolution = (vx_convolution_t *)conv;
if (vxIsValidSpecificReference(&convolution->base.base, VX_TYPE_CONVOLUTION) == vx_false_e)
{
return VX_ERROR_INVALID_REFERENCE;
}
switch (attr)
{
case VX_CONVOLUTION_ATTRIBUTE_SCALE:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
vx_uint32 scale = *(vx_uint32 *)ptr;
if (vxIsPowerOfTwo(scale) == vx_true_e)
{
VX_PRINT(VX_ZONE_INFO, "Convolution Scale assigned to %u\n", scale);
convolution->scale = scale;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_INVALID_PARAMETERS;
break;
}
if (status != VX_SUCCESS)
{
VX_PRINT(VX_ZONE_ERROR, "Failed to set attribute on convolution! (%d)\n", status);
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryImport(vx_import import, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference((vx_reference_t *)import, VX_TYPE_IMPORT) == vx_true_e)
{
switch (attribute)
{
case VX_IMPORT_ATTRIBUTE_COUNT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = import->count;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_IMPORT_ATTRIBUTE_TYPE:
if ((size <= VX_MAX_TARGET_NAME) && (ptr != NULL))
{
*(vx_uint32 *)ptr = import->type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
else
status = VX_ERROR_INVALID_REFERENCE;
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryDistribution(vx_distribution distribution, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference(&distribution->base, VX_TYPE_DISTRIBUTION) == vx_false_e)
return VX_ERROR_INVALID_REFERENCE;
switch (attribute)
{
case VX_DISTRIBUTION_ATTRIBUTE_DIMENSIONS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size*)ptr = (vx_size)(distribution->memory.ndims - 1);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_ATTRIBUTE_RANGE:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32*)ptr = (vx_uint32)(distribution->memory.dims[0][VX_DIM_X] *
distribution->window_x);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_ATTRIBUTE_BINS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size*)ptr = (vx_size)distribution->memory.dims[0][VX_DIM_X];
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_ATTRIBUTE_WINDOW:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32*)ptr = distribution->window_x;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_ATTRIBUTE_OFFSET:
if (VX_CHECK_PARAM(ptr, size, vx_int32, 0x3))
{
*(vx_int32*)ptr = distribution->offset_x;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_ATTRIBUTE_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
vx_int32 d = distribution->memory.ndims - 1;
*(vx_size*)ptr = distribution->memory.strides[0][d] *
distribution->memory.dims[0][d];
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryParameter(vx_parameter parameter, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference(¶meter->base, VX_TYPE_PARAMETER) == vx_true_e)
{
switch (attribute)
{
case VX_PARAMETER_ATTRIBUTE_DIRECTION:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
*(vx_enum *)ptr = parameter->kernel->signature.directions[parameter->index];
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_PARAMETER_ATTRIBUTE_INDEX:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
*(vx_uint32 *)ptr = parameter->index;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_PARAMETER_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
*(vx_enum *)ptr = parameter->kernel->signature.types[parameter->index];
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_PARAMETER_ATTRIBUTE_STATE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
*(vx_enum *)ptr = (vx_enum)parameter->kernel->signature.states[parameter->index];
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_PARAMETER_ATTRIBUTE_REF:
if (VX_CHECK_PARAM(ptr, size, vx_reference, 0x3))
{
if (parameter->node)
{
vx_reference_t *ref = parameter->node->parameters[parameter->index];
/* does this object have USER access? */
if (ref)
{
/*! \internal this could potentially allow the user to break
* a currently chosen optimization! We need to alert the
* system that if a write occurs to this data, put the graph
* into an unverified state.
*/
if (ref->external_count == 0)
ref->extracted = vx_true_e;
vxIncrementReference(ref, VX_EXTERNAL);
}
*(vx_reference *)ptr = (vx_reference)ref;
}
else
status = VX_ERROR_NOT_SUPPORTED;
}
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
else
{
status = VX_ERROR_INVALID_REFERENCE;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxSetMetaFormatAttribute(vx_meta_format meta, vx_enum attribute, const void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference(&meta->base, VX_TYPE_META_FORMAT) == vx_false_e)
return VX_ERROR_INVALID_REFERENCE;
if (VX_TYPE(attribute) != meta->type) {
return VX_ERROR_INVALID_TYPE;
}
switch(attribute) {
case VX_IMAGE_FORMAT:
if (VX_CHECK_PARAM(ptr, size, vx_df_image, 0x3)) {
meta->dim.image.format = *(vx_df_image *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_IMAGE_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.image.height = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_IMAGE_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.image.width = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_ARRAY_CAPACITY:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.array.capacity = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_ARRAY_ITEMTYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.array.item_type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_PYRAMID_FORMAT:
if (VX_CHECK_PARAM(ptr, size, vx_df_image, 0x3)) {
meta->dim.pyramid.format = *(vx_df_image *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.pyramid.height = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.pyramid.width = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_LEVELS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.pyramid.levels = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_SCALE:
if (VX_CHECK_PARAM(ptr, size, vx_float32, 0x3)) {
meta->dim.pyramid.scale = *(vx_float32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_SCALAR_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.scalar.type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_MATRIX_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.matrix.type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_MATRIX_ROWS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.matrix.rows = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_MATRIX_COLUMNS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.matrix.cols = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_DISTRIBUTION_BINS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.distribution.bins = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_RANGE:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.distribution.range = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_DISTRIBUTION_OFFSET:
if (VX_CHECK_PARAM(ptr, size, vx_int32, 0x3)) {
meta->dim.distribution.offset = *(vx_int32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_REMAP_SOURCE_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.remap.src_width = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_REMAP_SOURCE_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.remap.src_height = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_REMAP_DESTINATION_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.remap.dst_width = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_REMAP_DESTINATION_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.remap.dst_height = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_LUT_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.lut.type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_LUT_COUNT:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.lut.count = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_THRESHOLD_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.threshold.type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
vx_status vxQueryKernel(vx_kernel kern, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_kernel_t *kernel = (vx_kernel_t *)kern;
if (vxIsValidSpecificReference(&kernel->base, VX_TYPE_KERNEL) == vx_true_e)
{
switch (attribute)
{
case VX_KERNEL_ATTRIBUTE_NUMPARAMS:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = kernel->signature.numParams;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_NAME:
if (ptr != NULL && size <= VX_MAX_KERNEL_NAME)
{
strncpy(ptr, kernel->name, VX_MAX_KERNEL_NAME);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_ENUM:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = kernel->enumeration;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_LOCAL_DATA_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = kernel->attributes.localDataSize;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#ifdef OPENVX_KHR_NODE_MEMORY
case VX_KERNEL_ATTRIBUTE_GLOBAL_DATA_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = kernel->attributes.globalDataSize;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_GLOBAL_DATA_PTR:
if (VX_CHECK_PARAM(ptr, size, vx_ptr_t, 0x1))
{
*(vx_ptr_t *)ptr = kernel->attributes.globalDataPtr;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#endif
#ifdef OPENVX_KHR_TILING
case VX_KERNEL_ATTRIBUTE_INPUT_NEIGHBORHOOD:
if (VX_CHECK_PARAM(ptr, size, vx_neighborhood_size_t, 0x3))
{
memcpy(ptr, &kernel->attributes.nhbdinfo, size);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_OUTPUT_TILE_BLOCK_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_tile_block_size_t, 0x3))
{
memcpy(ptr, &kernel->attributes.blockinfo, size);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#endif
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
else
{
status = VX_ERROR_INVALID_REFERENCE;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryPyramid(vx_pyramid pyramid, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference(&pyramid->base, VX_TYPE_PYRAMID) == vx_true_e)
{
switch (attribute)
{
case VX_PYRAMID_ATTRIBUTE_LEVELS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = pyramid->numLevels;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_SCALE:
if (VX_CHECK_PARAM(ptr, size, vx_float32, 0x3))
{
*(vx_float32 *)ptr = pyramid->scale;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = pyramid->width;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = pyramid->height;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_FORMAT:
if (VX_CHECK_PARAM(ptr, size, vx_df_image, 0x3))
{
*(vx_df_image *)ptr = pyramid->format;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
return status;
}
vx_status vxSetThresholdAttribute(vx_threshold t, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_threshold_t *thresh = (vx_threshold_t *)t;
if (vxIsValidSpecificReference(&thresh->base, VX_TYPE_THRESHOLD) == vx_true_e)
{
switch (attribute)
{
case VX_THRESHOLD_ATTRIBUTE_VALUE:
if (VX_CHECK_PARAM(ptr, size, vx_uint8, 0x0) &&
(thresh->type == VX_THRESHOLD_TYPE_BINARY))
{
thresh->value = *(vx_uint8 *)ptr;
vxWroteToReference(&thresh->base);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_THRESHOLD_ATTRIBUTE_LOWER:
if (VX_CHECK_PARAM(ptr, size, vx_uint8, 0x0) &&
(thresh->type == VX_THRESHOLD_TYPE_RANGE))
{
thresh->lower = *(vx_uint8 *)ptr;
vxWroteToReference(&thresh->base);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_THRESHOLD_ATTRIBUTE_UPPER:
if (VX_CHECK_PARAM(ptr, size, vx_uint8, 0x0) &&
(thresh->type == VX_THRESHOLD_TYPE_RANGE))
{
thresh->upper = *(vx_uint8 *)ptr;
vxWroteToReference(&thresh->base);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_THRESHOLD_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
vx_enum type = *(vx_enum *)ptr;
if (vxIsValidThresholdType(type) == vx_true_e)
{
thresh->type = type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
else
{
status = VX_ERROR_INVALID_REFERENCE;
}
VX_PRINT(VX_ZONE_API, "return %d\n", status);
return status;
}
vx_status vxSetKernelAttribute(vx_kernel k, vx_enum attribute, void * ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_kernel_t *kernel = (vx_kernel_t *)k;
if (vxIsValidSpecificReference(&kernel->base, VX_TYPE_KERNEL) == vx_false_e)
{
return VX_ERROR_INVALID_REFERENCE;
}
if (kernel->enabled == vx_true_e)
{
return VX_ERROR_NOT_SUPPORTED;
}
switch (attribute)
{
case VX_KERNEL_ATTRIBUTE_LOCAL_DATA_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
kernel->attributes.localDataSize = *(vx_size *)ptr;
VX_PRINT(VX_ZONE_KERNEL, "Set Local Data Size to "VX_FMT_SIZE" bytes\n", kernel->attributes.localDataSize);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_LOCAL_DATA_PTR:
if (VX_CHECK_PARAM(ptr, size, vx_ptr_t, 0x1))
{
kernel->attributes.localDataPtr = *(vx_ptr_t *)ptr;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_GLOBAL_DATA_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
kernel->attributes.globalDataSize = *(vx_size *)ptr;
VX_PRINT(VX_ZONE_KERNEL, "Set Global Data Size to "VX_FMT_SIZE" bytes\n", kernel->attributes.globalDataSize);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_GLOBAL_DATA_PTR:
if (VX_CHECK_PARAM(ptr, size, vx_ptr_t, 0x1))
{
kernel->attributes.globalDataPtr = *(vx_ptr_t *)ptr;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#ifdef OPENVX_KHR_TILING
case VX_KERNEL_ATTRIBUTE_INPUT_NEIGHBORHOOD:
if (VX_CHECK_PARAM(ptr, size, vx_neighborhood_size_t, 0x3))
{
memcpy(&kernel->attributes.nhbdinfo, ptr, size);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_OUTPUT_TILE_BLOCK_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_tile_block_size_t, 0x3))
{
memcpy(&kernel->attributes.blockinfo, ptr, size);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_KERNEL_ATTRIBUTE_BORDER:
if (VX_CHECK_PARAM(ptr, size, vx_border_mode_t, 0x3))
{
vx_border_mode_t *border = (vx_border_mode_t *)ptr;
if ((border->mode == VX_BORDER_MODE_SELF) ||
(border->mode == VX_BORDER_MODE_UNDEFINED))
{
memcpy(&kernel->attributes.borders, border, sizeof(vx_border_mode_t));
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#endif
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxQueryContext(vx_context context, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidContext(context) == vx_false_e)
{
status = VX_ERROR_INVALID_REFERENCE;
}
else
{
switch (attribute)
{
case VX_CONTEXT_VENDOR_ID:
if (VX_CHECK_PARAM(ptr, size, vx_uint16, 0x1))
{
*(vx_uint16 *)ptr = VX_ID_KHRONOS;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_VERSION:
if (VX_CHECK_PARAM(ptr, size, vx_uint16, 0x1))
{
*(vx_uint16 *)ptr = (vx_uint16)VX_VERSION;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_MODULES:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = context->num_modules;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_REFERENCES:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = context->num_references;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#if defined(EXPERIMENTAL_USE_TARGET)
case VX_CONTEXT_TARGETS:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = context->num_targets;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
#endif
case VX_CONTEXT_IMPLEMENTATION:
if (size <= VX_MAX_IMPLEMENTATION_NAME && ptr)
{
strncpy(ptr, implementation, VX_MAX_IMPLEMENTATION_NAME);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_EXTENSIONS_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = sizeof(extensions);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_EXTENSIONS:
if (size <= sizeof(extensions) && ptr)
{
strncpy(ptr, extensions, sizeof(extensions));
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_CONVOLUTION_MAX_DIMENSION:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = VX_INT_MAX_CONVOLUTION_DIM;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_NONLINEAR_MAX_DIMENSION:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = VX_INT_MAX_NONLINEAR_DIM;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
{
*(vx_size *)ptr = VX_OPTICALFLOWPYRLK_MAX_DIM;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_IMMEDIATE_BORDER:
if (VX_CHECK_PARAM(ptr, size, vx_border_t, 0x3))
{
*(vx_border_t *)ptr = context->imm_border;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_IMMEDIATE_BORDER_POLICY:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = context->imm_border_policy;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_UNIQUE_KERNELS:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
{
*(vx_uint32 *)ptr = context->num_unique_kernels;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_CONTEXT_UNIQUE_KERNEL_TABLE:
if ((size == (context->num_unique_kernels * sizeof(vx_kernel_info_t))) &&
(ptr != NULL))
{
vx_uint32 k = 0u, t = 0u, k2 = 0u, numk = 0u;
vx_kernel_info_t *table = (vx_kernel_info_t *)ptr;
for (t = 0; t < context->num_targets; t++)
{
for (k = 0u; k < VX_INT_MAX_KERNELS; k++)
{
if (context->targets[t].kernels[k].enumeration != VX_KERNEL_INVALID)
{
vx_bool found = vx_false_e;
VX_PRINT(VX_ZONE_INFO, "Checking uniqueness of %s (%d)\n", context->targets[t].kernels[k].name, context->targets[t].kernels[k].enumeration);
for (k2 = 0u; k2 < numk; k2++)
{
if (table[k2].enumeration == context->targets[t].kernels[k].enumeration)
{
found = vx_true_e;
break;
}
}
if (found == vx_false_e)
{
VX_PRINT(VX_ZONE_INFO, "Kernel %s is unique\n", context->targets[t].kernels[k].name);
table[numk].enumeration = context->targets[t].kernels[k].enumeration;
#if defined(EXPERIMENTAL_USE_TARGET) || defined(EXPERIMENTAL_USE_VARIANT)
// get the central string out
{
vx_uint32 c = 0;
strncpy(table[numk].name, context->targets[t].kernels[k].name, VX_MAX_KERNEL_NAME);
for (c = 0; table[numk].name[c] != '\0'; c++) {
if (table[numk].name[c] == ';') {
table[numk].name[c] = '\0';
break;
}
}
}
#else
strncpy(table[numk].name, context->targets[t].kernels[k].name, VX_MAX_KERNEL_NAME);
#endif
numk++;
}
}
}
}
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxSetMetaFormatAttribute(vx_meta_format meta, vx_enum attribute, const void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference(&meta->base, VX_TYPE_META_FORMAT) == vx_false_e)
return VX_ERROR_INVALID_REFERENCE;
if (VX_TYPE(attribute) != meta->type) {
return VX_ERROR_INVALID_TYPE;
}
switch(attribute) {
/**********************************************************************/
case VX_META_FORMAT_ATTRIBUTE_DELTA_RECTANGLE:
if (VX_CHECK_PARAM(ptr, size, vx_delta_rectangle_t, 0x3)) {
memcpy(&meta->dim.image.delta, ptr, size);
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_IMAGE_ATTRIBUTE_FORMAT:
if (VX_CHECK_PARAM(ptr, size, vx_df_image, 0x3)) {
meta->dim.image.format = *(vx_df_image *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_IMAGE_ATTRIBUTE_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.image.height = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_IMAGE_ATTRIBUTE_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.image.width = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_ARRAY_ATTRIBUTE_CAPACITY:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.array.capacity = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_ARRAY_ATTRIBUTE_ITEMTYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.array.item_type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_PYRAMID_ATTRIBUTE_FORMAT:
if (VX_CHECK_PARAM(ptr, size, vx_df_image, 0x3)) {
meta->dim.pyramid.format = *(vx_df_image *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.pyramid.height = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
meta->dim.pyramid.width = *(vx_uint32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_LEVELS:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
meta->dim.pyramid.levels = *(vx_size *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_PYRAMID_ATTRIBUTE_SCALE:
if (VX_CHECK_PARAM(ptr, size, vx_float32, 0x3)) {
meta->dim.pyramid.scale = *(vx_float32 *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
case VX_SCALAR_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3)) {
meta->dim.scalar.type = *(vx_enum *)ptr;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
/**********************************************************************/
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
