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; }