static vx_status VX_CALLBACK validateTensorToImageKernel(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[])
{
// check input configuration
vx_enum type;
vx_size num_dims, input_dims[4] = { 1, 1, 1, 1 };
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[0], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[0], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
if (num_dims != 4)
return VX_ERROR_INVALID_DIMENSION;
if (type != VX_TYPE_FLOAT32)
return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[0], VX_TENSOR_DIMS, input_dims, sizeof(input_dims[0])*num_dims));
if ((input_dims[2] != 3 && input_dims[2] != 1) || ((input_dims[0] & 3) != 0))
return VX_ERROR_INVALID_DIMENSION;
vx_enum scalar_type;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[2], VX_SCALAR_TYPE, &scalar_type, sizeof(scalar_type)));
if(scalar_type != VX_TYPE_FLOAT32)
return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[3], VX_SCALAR_TYPE, &scalar_type, sizeof(scalar_type)));
if(scalar_type != VX_TYPE_FLOAT32)
return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[4], VX_SCALAR_TYPE, &scalar_type, sizeof(scalar_type)));
if(scalar_type != VX_TYPE_BOOL)
return VX_ERROR_INVALID_TYPE;
// set output image configuration
vx_uint32 width = (vx_uint32)input_dims[0];
vx_uint32 height = (vx_uint32)(input_dims[1]*input_dims[3]);
vx_df_image format = (input_dims[2] == 3) ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_U8;
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[1], VX_IMAGE_WIDTH, &width, sizeof(width)));
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[1], VX_IMAGE_HEIGHT, &height, sizeof(height)));
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[1], VX_IMAGE_FORMAT, &format, sizeof(format)));
return VX_SUCCESS;
}
static vx_status vxCheckBufferInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
status = VX_SUCCESS;
}
else if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_UINT8)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status vxCheckOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
ptr->dim.scalar.type = VX_TYPE_UINT32;
if (param)
{
vx_scalar serr = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &serr, sizeof(serr));
if (serr)
{
vx_enum stype = 0;
vxQueryScalar(serr, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_UINT32)
{
ptr->dim.scalar.type = stype;
status = VX_SUCCESS;
}
}
vxReleaseParameter(¶m);
}
}
return VX_SUCCESS;
}
static vx_status VX_CALLBACK validateROIPoolingLayer(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[])
{
// check scalar type
vx_enum type;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[2], VX_SCALAR_TYPE, &type, sizeof(type)));
if(type != VX_TYPE_NN_ROI_POOL_PARAMS) return VX_ERROR_INVALID_TYPE;
// check tensor dimensions
vx_size num_dims;
vx_size input_dims[4], rois_dims[4], output_dims[4];
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[0], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[0], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
if(num_dims != 4) return VX_ERROR_INVALID_DIMENSION;
if(type != VX_TYPE_FLOAT32) return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[1], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[1], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
if(num_dims != 4) return VX_ERROR_INVALID_DIMENSION;
if(type != VX_TYPE_FLOAT32) return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[1], VX_TENSOR_DIMS, rois_dims, sizeof(rois_dims)));
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[3], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[3], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
if(num_dims != 4) return VX_ERROR_INVALID_DIMENSION;
if(type != VX_TYPE_FLOAT32) return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[3], VX_TENSOR_DIMS, output_dims, sizeof(output_dims)));
if(output_dims[3] != input_dims[3]) return VX_ERROR_INVALID_DIMENSION;
// output tensor configuration
type = VX_TYPE_FLOAT32;
num_dims = 4;
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[3], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[3], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[3], VX_TENSOR_DIMS, output_dims, sizeof(output_dims)));
return VX_SUCCESS;
}
static vx_status VX_CALLBACK vxScaleImageInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_ENUM)
{
vx_enum interp = 0;
vxReadScalarValue(scalar, &interp);
if ((interp == VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR) ||
(interp == VX_INTERPOLATION_TYPE_BILINEAR) ||
(interp == VX_INTERPOLATION_TYPE_AREA))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxHalfscaleGaussianInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_INT32)
{
vx_int32 ksize = 0;
vxReadScalarValue(scalar, &ksize);
if ((ksize == 3) || (ksize == 5))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
/************************************************************************************************************
input parameter validator.
param [in] node The handle to the node.
param [in] index The index of the parameter to validate.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_norm_InputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_SUCCESS;
vx_parameter param = vxGetParameterByIndex(node, index);
if (index == 0)
{
vx_image image;
vx_df_image df_image = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &df_image, sizeof(df_image)));
if (df_image != VX_DF_IMAGE_U8)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
else if (index == 1)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_float32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_FLOAT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 2)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_int32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_INT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
return status;
}
static vx_status VX_CALLBACK validateImageToTensorKernel(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[])
{
// check input configuration
vx_uint32 width, height;
vx_df_image format;
ERROR_CHECK_STATUS(vxQueryImage((vx_image)parameters[0], VX_IMAGE_WIDTH, &width, sizeof(width)));
ERROR_CHECK_STATUS(vxQueryImage((vx_image)parameters[0], VX_IMAGE_HEIGHT, &height, sizeof(height)));
ERROR_CHECK_STATUS(vxQueryImage((vx_image)parameters[0], VX_IMAGE_FORMAT, &format, sizeof(format)));
if(format != VX_DF_IMAGE_RGB && format != VX_DF_IMAGE_U8)
return VX_ERROR_INVALID_FORMAT;
vx_enum scalar_type;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[2], VX_SCALAR_TYPE, &scalar_type, sizeof(scalar_type)));
if(scalar_type != VX_TYPE_FLOAT32)
return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[3], VX_SCALAR_TYPE, &scalar_type, sizeof(scalar_type)));
if(scalar_type != VX_TYPE_FLOAT32)
return VX_ERROR_INVALID_TYPE;
ERROR_CHECK_STATUS(vxQueryScalar((vx_scalar)parameters[4], VX_SCALAR_TYPE, &scalar_type, sizeof(scalar_type)));
if(scalar_type != VX_TYPE_BOOL)
return VX_ERROR_INVALID_TYPE;
// check output dimensions
vx_enum type;
vx_size num_dims, output_dims[4] = { 1, 1, 1, 1 };
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[1], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[1], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
if (type != VX_TYPE_FLOAT32)
return VX_ERROR_INVALID_TYPE;
if (num_dims != 4)
return VX_ERROR_INVALID_DIMENSION;
ERROR_CHECK_STATUS(vxQueryTensor((vx_tensor)parameters[1], VX_TENSOR_DIMS, output_dims, sizeof(output_dims[0])*num_dims));
if ((output_dims[2] != 3 && output_dims[2] != 1) || output_dims[0] != (size_t)width || (output_dims[1] * output_dims[3]) != (size_t)height)
return VX_ERROR_INVALID_DIMENSION;
// set output tensor configuration
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[1], VX_TENSOR_DATA_TYPE, &type, sizeof(type)));
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[1], VX_TENSOR_NUMBER_OF_DIMS, &num_dims, sizeof(num_dims)));
ERROR_CHECK_STATUS(vxSetMetaFormatAttribute(metas[1], VX_TENSOR_DIMS, output_dims, sizeof(output_dims)));
return VX_SUCCESS;
}
// write scalar value from a string
int WriteScalarFromString(vx_scalar scalar, const char str[])
{
vx_enum type; ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
if (type == VX_TYPE_FLOAT32) {
float v = 0; (void)sscanf(str, "%g", &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_FLOAT64) {
double v = 0; (void)sscanf(str, "%lg", &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_SIZE) {
vx_size v = 0; (void)sscanf(str, VX_FMT_SIZE, &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_INT8 || type == VX_TYPE_INT16 || type == VX_TYPE_INT32 ||
type == VX_TYPE_UINT8 || type == VX_TYPE_UINT16 || type == VX_TYPE_UINT32 ||
type == VX_TYPE_CHAR || type == VX_TYPE_BOOL)
{
vx_int32 v = 0; (void)sscanf(str, "%i", &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_INT64 || type == VX_TYPE_UINT64) {
vx_int64 v = 0; (void)sscanf(str, "%" PRIi64, &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_ENUM) {
vx_enum v = ovxName2Enum(str);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_DF_IMAGE || type == VX_TYPE_STRING_AMD) {
ERROR_CHECK(vxWriteScalarValue(scalar, str));
}
else {
// unknown types will be assumed to be in hex format
vx_int64 v = 0; (void)sscanf(str, "%" PRIi64, &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
return 0;
}
vx_status vxMatrixTrace(vx_matrix matrix, vx_scalar trace) {
vx_size columns = 0u;
vx_size rows = 0u;
vx_status status = VX_SUCCESS;
vx_enum mtype = VX_TYPE_INVALID, stype = VX_TYPE_INVALID;
status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns));
status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows));
status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &mtype, sizeof(mtype));
status |= vxQueryScalar(trace, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (status != VX_SUCCESS)
return VX_ERROR_INVALID_REFERENCE;
if (mtype == VX_TYPE_INVALID || mtype != stype)
return VX_ERROR_INVALID_TYPE;
if (columns == 0 || columns != rows)
return VX_ERROR_INVALID_DIMENSION;
if (stype == VX_TYPE_INT32) {
vx_int32 mat[rows][columns];
vx_int32 t = 0;
status |= vxAccessScalarValue(trace, NULL);
status |= vxAccessMatrix(matrix, mat);
t = vxh_matrix_trace_i32(columns, rows, mat);
status |= vxCommitMatrix(matrix, NULL);
status |= vxCommitScalarValue(trace, &t);
} else if (stype == VX_TYPE_FLOAT32) {
vx_float32 mat[rows][columns];
vx_float32 t = 0.0f;
status |= vxAccessScalarValue(trace, NULL);
status |= vxAccessMatrix(matrix, mat);
t = vxh_matrix_trace_f32(columns, rows, mat);
status |= vxCommitMatrix(matrix, NULL);
status |= vxCommitScalarValue(trace, &t);
}
return status;
}
static vx_status VX_CALLBACK vxChannelExtractInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_SUCCESS;
vx_parameter param = vxGetParameterByIndex(node, index);
if (index == 0)
{
vx_image image = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(image));
if (image)
{
vx_df_image format = 0;
vx_uint32 width, height;
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
// check to make sure the input format is supported.
switch (format)
{
case VX_DF_IMAGE_RGB:
case VX_DF_IMAGE_RGBX:
case VX_DF_IMAGE_YUV4:
status = VX_SUCCESS;
break;
/* 4:2:0 */
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
case VX_DF_IMAGE_IYUV:
if (width % 2 != 0 || height % 2 != 0)
status = VX_ERROR_INVALID_DIMENSION;
else
status = VX_SUCCESS;
break;
/* 4:2:2 */
case VX_DF_IMAGE_UYVY:
case VX_DF_IMAGE_YUYV:
if (width % 2 != 0)
status = VX_ERROR_INVALID_DIMENSION;
else
status = VX_SUCCESS;
break;
default:
status = VX_ERROR_INVALID_FORMAT;
break;
}
vxReleaseImage(&image);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
}
else if (index == 1)
{
vx_scalar scalar;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum type = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_ENUM)
{
vx_enum channel = 0;
vx_parameter param0;
vxReadScalarValue(scalar, &channel);
param0 = vxGetParameterByIndex(node, 0);
if (param0)
{
vx_image image = 0;
vxQueryParameter(param0, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(image));
if (image)
{
vx_df_image format = VX_DF_IMAGE_VIRT;
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
status = VX_ERROR_INVALID_VALUE;
switch (format)
{
case VX_DF_IMAGE_RGB:
case VX_DF_IMAGE_RGBX:
if ( (channel == VX_CHANNEL_R) ||
(channel == VX_CHANNEL_G) ||
(channel == VX_CHANNEL_B) ||
(channel == VX_CHANNEL_A) ) {
status = VX_SUCCESS;
}
break;
case VX_DF_IMAGE_YUV4:
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
case VX_DF_IMAGE_IYUV:
case VX_DF_IMAGE_UYVY:
case VX_DF_IMAGE_YUYV:
if ( (channel == VX_CHANNEL_Y) ||
(channel == VX_CHANNEL_U) ||
(channel == VX_CHANNEL_V) ) {
status = VX_SUCCESS;
}
break;
default:
break;
}
vxReleaseImage(&image);
}
vxReleaseParameter(¶m0);
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
vxReleaseParameter(¶m);
return status;
}
static vx_status VX_CALLBACK vxMatrixModifyInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_matrix matrix;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &matrix, sizeof(matrix));
if (matrix)
{
vx_enum data_type = 0;
vx_size rows = 0ul, columns = 0ul;
vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &data_type, sizeof(data_type));
vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows));
vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns));
if ((data_type == VX_TYPE_FLOAT32) && (columns == 3) && (rows == 3))
{
status = VX_SUCCESS;
}
vxReleaseMatrix(&matrix);
}
vxReleaseParameter(¶m);
}
}
if (index == 1 || index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if ((status == VX_SUCCESS) && (scalar))
{
vx_enum type = VX_TYPE_INVALID;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_UINT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
if (index == 3)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if ((status == VX_SUCCESS) && (scalar))
{
vx_enum type = VX_TYPE_INVALID;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxSetParameterByIndex(vx_node node, vx_uint32 index, vx_reference value)
{
vx_status status = VX_SUCCESS;
vx_enum type = 0;
vx_enum data_type = 0;
if (vxIsValidSpecificReference(&node->base, VX_TYPE_NODE) == vx_false_e)
{
VX_PRINT(VX_ZONE_ERROR, "Supplied node was not actually a node\n");
status = VX_ERROR_INVALID_REFERENCE;
goto exit;
}
VX_PRINT(VX_ZONE_PARAMETER, "Attempting to set parameter[%u] on %s (enum:%d) to "VX_FMT_REF"\n",
index,
node->kernel->name,
node->kernel->enumeration,
value);
/* is the index out of bounds? */
if ((index >= node->kernel->signature.num_parameters) || (index >= VX_INT_MAX_PARAMS))
{
VX_PRINT(VX_ZONE_ERROR, "Invalid index %u\n", index);
status = VX_ERROR_INVALID_VALUE;
goto exit;
}
/* if it's an optional parameter, it's ok to be NULL */
if ((value == 0) && (node->kernel->signature.states[index] == VX_PARAMETER_STATE_OPTIONAL))
{
status = VX_SUCCESS;
goto exit;
}
/* if it's required, it's got to exist */
if (vxIsValidReference((vx_reference_t *)value) == vx_false_e)
{
VX_PRINT(VX_ZONE_ERROR, "Supplied value was not actually a reference\n");
status = VX_ERROR_INVALID_REFERENCE;
goto exit;
}
/* if it was a valid reference then get the type from it */
vxQueryReference(value, VX_REF_ATTRIBUTE_TYPE, &type, sizeof(type));
VX_PRINT(VX_ZONE_PARAMETER, "Query returned type %08x for ref "VX_FMT_REF"\n", type, value);
/* Check that signature type matches reference type*/
if (node->kernel->signature.types[index] != type)
{
/* Check special case where signature is a specific scalar type.
This can happen if the vxAddParameterToKernel() passes one of the scalar
vx_type_e types instead of the more generic VX_TYPE_SCALAR since the spec
doesn't specify that only VX_TYPE_SCALAR should be used for scalar types in
this function. */
if((type == VX_TYPE_SCALAR) &&
(vxQueryScalar((vx_scalar)value, VX_SCALAR_ATTRIBUTE_TYPE, &data_type, sizeof(data_type)) == VX_SUCCESS))
{
if(data_type != node->kernel->signature.types[index])
{
VX_PRINT(VX_ZONE_ERROR, "Invalid scalar type 0x%08x!\n", data_type);
status = VX_ERROR_INVALID_TYPE;
goto exit;
}
}
else
{
VX_PRINT(VX_ZONE_ERROR, "Invalid type 0x%08x!\n", type);
status = VX_ERROR_INVALID_TYPE;
goto exit;
}
}
if (node->parameters[index])
{
if (node->parameters[index]->delay!=NULL) {
// we already have a delay element here */
vx_bool res = vxRemoveAssociationToDelay(node->parameters[index], node, index);
if (res == vx_false_e) {
VX_PRINT(VX_ZONE_ERROR, "Internal error removing delay association\n");
status = VX_ERROR_INVALID_REFERENCE;
goto exit;
}
}
}
if (value->delay!=NULL) {
/* the new parameter is a delay element */
vx_bool res = vxAddAssociationToDelay(value, node, index);
if (res == vx_false_e) {
VX_PRINT(VX_ZONE_ERROR, "Internal error adding delay association\n");
status = VX_ERROR_INVALID_REFERENCE;
goto exit;
}
}
/* actual change of the node parameter */
vxNodeSetParameter(node, index, value);
/* if the node has a child graph, find out which parameter is this */
if (node->child)
{
vx_uint32 p = 0;
for (p = 0; p < node->child->numParams; p++)
{
if ((node->child->parameters[p].node == node) &&
(node->child->parameters[p].index == index))
{
status = vxSetGraphParameterByIndex((vx_graph)node->child, p, value);
break;
}
}
}
exit:
if (status == VX_SUCCESS)
{
VX_PRINT(VX_ZONE_PARAMETER, "Assigned Node[%u] %p type:%08x ref="VX_FMT_REF"\n",
index, node, type, value);
}
else
{
VX_PRINT(VX_ZONE_ERROR, "Specified: parameter[%u] type:%08x => "VX_FMT_REF"\n",
index, type, value);
VX_PRINT(VX_ZONE_ERROR, "Required: parameter[%u] dir:%d type:%08x\n",
index,
node->kernel->signature.directions[index],
node->kernel->signature.types[index]);
}
return status;
}
static vx_status VX_CALLBACK vxEuclideanNonMaxHarrisInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0) /* image */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_image img = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &img, sizeof(img));
if (img)
{
vx_df_image format = VX_DF_IMAGE_VIRT;
vxQueryImage(img, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_F32)
{
status = VX_SUCCESS;
}
vxReleaseImage(&img);
}
vxReleaseParameter(¶m);
}
}
else if (index == 1) /* strength_thresh */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_FLOAT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
else if (index == 2) /* min_distance */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_FLOAT32)
{
vx_float32 radius = 0;
vxReadScalarValue(scalar, &radius);
if ((0.0 <= radius) && (radius <= 30.0))
{
status = VX_SUCCESS;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxAddSubtractInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8 || format == VX_DF_IMAGE_S16)
status = VX_SUCCESS;
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 1)
{
vx_image images[2];
vx_parameter param[2] = {
vxGetParameterByIndex(node, 0),
vxGetParameterByIndex(node, 1),
};
vxQueryParameter(param[0], VX_PARAMETER_REF, &images[0], sizeof(images[0]));
vxQueryParameter(param[1], VX_PARAMETER_REF, &images[1], sizeof(images[1]));
if (images[0] && images[1])
{
vx_uint32 width[2], height[2];
vx_df_image format1;
vxQueryImage(images[0], VX_IMAGE_WIDTH, &width[0], sizeof(width[0]));
vxQueryImage(images[1], VX_IMAGE_WIDTH, &width[1], sizeof(width[1]));
vxQueryImage(images[0], VX_IMAGE_HEIGHT, &height[0], sizeof(height[0]));
vxQueryImage(images[1], VX_IMAGE_HEIGHT, &height[1], sizeof(height[1]));
vxQueryImage(images[1], VX_IMAGE_FORMAT, &format1, sizeof(format1));
if (width[0] == width[1] && height[0] == height[1] &&
(format1 == VX_DF_IMAGE_U8 || format1 == VX_DF_IMAGE_S16))
status = VX_SUCCESS;
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶m[0]);
vxReleaseParameter(¶m[1]);
}
else if (index == 2) /* overflow_policy: truncate or saturate. */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (vxGetStatus((vx_reference)param) == VX_SUCCESS)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_ENUM)
{
vx_enum overflow_policy = 0;
vxCopyScalar(scalar, &overflow_policy, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
if ((overflow_policy == VX_CONVERT_POLICY_WRAP) ||
(overflow_policy == VX_CONVERT_POLICY_SATURATE))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxAccumulateSquaredInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0 )
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
status = VX_SUCCESS;
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 2)
{
vx_image images[2];
vx_parameter param[2] = {
vxGetParameterByIndex(node, 0),
vxGetParameterByIndex(node, 2),
};
vxQueryParameter(param[0], VX_PARAMETER_ATTRIBUTE_REF, &images[0], sizeof(images[0]));
vxQueryParameter(param[1], VX_PARAMETER_ATTRIBUTE_REF, &images[1], sizeof(images[1]));
if (images[0] && images[1])
{
vx_uint32 width[2], height[2];
vx_df_image format[2];
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_WIDTH, &width[0], sizeof(width[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_WIDTH, &width[1], sizeof(width[1]));
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[0], sizeof(height[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[1], sizeof(height[1]));
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_FORMAT, &format[0], sizeof(format[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_FORMAT, &format[1], sizeof(format[1]));
if (width[0] == width[1] &&
height[0] == height[1] &&
format[0] == VX_DF_IMAGE_U8 &&
format[1] == VX_DF_IMAGE_S16)
{
status = VX_SUCCESS;
}
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶m[0]);
vxReleaseParameter(¶m[1]);
}
else if (index == 1) /* only weighted/squared average */
{
vx_scalar scalar = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum type = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_UINT32)
{
vx_uint32 shift = 0u;
if ((vxAccessScalarValue(scalar, &shift) == VX_SUCCESS) &&
(0 <= shift) && (shift <= 15))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxHarrisInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_image input = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if ((status == VX_SUCCESS) && (input))
{
vx_df_image format = 0;
status = vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if ((status == VX_SUCCESS) && (format == VX_DF_IMAGE_U8))
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
}
else if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar sens = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &sens, sizeof(sens));
if ((status == VX_SUCCESS) && (sens))
{
vx_enum type = 0;
vxQueryScalar(sens, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&sens);
}
vxReleaseParameter(¶m);
}
}
else if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar sens = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &sens, sizeof(sens));
if ((status == VX_SUCCESS) && (sens))
{
vx_enum type = 0;
vxQueryScalar(sens, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
vx_float32 d = 0.0f;
status = vxAccessScalarValue(sens, &d);
if ((status == VX_SUCCESS) && (1.0 <= d) && (d <= 5.0))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&sens);
}
vxReleaseParameter(¶m);
}
}
else if (index == 3)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar sens = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &sens, sizeof(sens));
if ((status == VX_SUCCESS) && (sens))
{
vx_enum type = 0;
vxQueryScalar(sens, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
vx_float32 k = 0.0f;
vxAccessScalarValue(sens, &k);
VX_PRINT(VX_ZONE_INFO, "k = %lf\n", k);
if ((0.040000f <= k) && (k < 0.150001f))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&sens);
}
vxReleaseParameter(¶m);
}
}
else if (index == 4 || index == 5)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if ((status == VX_SUCCESS) && (scalar))
{
vx_enum type = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_INT32)
{
vx_int32 size = 0;
vxAccessScalarValue(scalar, &size);
VX_PRINT(VX_ZONE_INFO, "size = %u\n", size);
if ((size == 3) || (size == 5) || (size == 7))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxMultiplyInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8 || format == VX_DF_IMAGE_S16)
status = VX_SUCCESS;
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 1)
{
vx_image images[2];
vx_parameter param[2] = {
vxGetParameterByIndex(node, 0),
vxGetParameterByIndex(node, 1),
};
vxQueryParameter(param[0], VX_PARAMETER_ATTRIBUTE_REF, &images[0], sizeof(images[0]));
vxQueryParameter(param[1], VX_PARAMETER_ATTRIBUTE_REF, &images[1], sizeof(images[1]));
if (images[0] && images[1])
{
vx_uint32 width[2], height[2];
vx_df_image format1;
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_WIDTH, &width[0], sizeof(width[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_WIDTH, &width[1], sizeof(width[1]));
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[0], sizeof(height[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[1], sizeof(height[1]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_FORMAT, &format1, sizeof(format1));
if (width[0] == width[1] && height[0] == height[1] &&
(format1 == VX_DF_IMAGE_U8 || format1 == VX_DF_IMAGE_S16))
status = VX_SUCCESS;
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶m[0]);
vxReleaseParameter(¶m[1]);
}
else if (index == 2) /* scale: must be non-negative. */
{
vx_scalar scalar = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum type = -1;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
vx_float32 scale = 0.0f;
if ((vxAccessScalarValue(scalar, &scale) == VX_SUCCESS) &&
(scale >= 0))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
else if (index == 3) /* overflow_policy: truncate or saturate. */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_ENUM)
{
vx_enum overflow_policy = 0;
vxAccessScalarValue(scalar, &overflow_policy);
if ((overflow_policy == VX_CONVERT_POLICY_WRAP) ||
(overflow_policy == VX_CONVERT_POLICY_SATURATE))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
else if (index == 4) /* rounding_policy: truncate or saturate. */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_ENUM)
{
vx_enum rouding_policy = 0;
vxAccessScalarValue(scalar, &rouding_policy);
if ((rouding_policy == VX_ROUND_POLICY_TO_ZERO) ||
(rouding_policy == VX_ROUND_POLICY_TO_NEAREST_EVEN))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
/*! \brief Calls an OpenCL kernel from OpenVX Graph.
* Steps:
* \arg Find the target
* \arg Get the vxcl context
* \arg Find the kernel (to get cl kernel information)
* \arg for each input parameter that is an object, enqueue write
* \arg wait for finish
* \arg for each parameter, SetKernelArg
* \arg call kernel
* \arg wait for finish
* \arg for each output parameter that is an object, enqueue read
* \arg wait for finish
* \note This implementation will attempt to use the External API as much as possible,
* but will cast to internal representation when needed (due to lack of API or
* need for secret information). This is not an optimal OpenCL invocation.
*/
vx_status vxclCallOpenCLKernel(vx_node node, const vx_reference *parameters, vx_uint32 num)
{
vx_status status = VX_FAILURE;
vx_context context = node->base.context;
vx_target target = (vx_target_t *)&node->base.context->targets[node->affinity];
vx_cl_kernel_description_t *vxclk = vxclFindKernel(node->kernel->enumeration);
vx_uint32 pidx, pln, didx, plidx, argidx;
cl_int err = 0;
size_t off_dim[3] = {0,0,0};
size_t work_dim[3];
//size_t local_dim[3];
cl_event writeEvents[VX_INT_MAX_PARAMS];
cl_event readEvents[VX_INT_MAX_PARAMS];
cl_int we = 0, re = 0;
vxSemWait(&target->base.lock);
// determine which platform to use
plidx = 0;
// determine which device to use
didx = 0;
/* for each input/bi data object, enqueue it and set the kernel parameters */
for (argidx = 0, pidx = 0; pidx < num; pidx++)
{
vx_reference ref = node->parameters[pidx];
vx_enum dir = node->kernel->signature.directions[pidx];
vx_enum type = node->kernel->signature.types[pidx];
vx_memory_t *memory = NULL;
switch (type)
{
case VX_TYPE_ARRAY:
memory = &((vx_array)ref)->memory;
break;
case VX_TYPE_CONVOLUTION:
memory = &((vx_convolution)ref)->base.memory;
break;
case VX_TYPE_DISTRIBUTION:
memory = &((vx_distribution)ref)->memory;
break;
case VX_TYPE_IMAGE:
memory = &((vx_image)ref)->memory;
break;
case VX_TYPE_LUT:
memory = &((vx_lut_t*)ref)->memory;
break;
case VX_TYPE_MATRIX:
memory = &((vx_matrix)ref)->memory;
break;
//case VX_TYPE_PYRAMID:
// break;
case VX_TYPE_REMAP:
memory = &((vx_remap)ref)->memory;
break;
//case VX_TYPE_SCALAR:
//case VX_TYPE_THRESHOLD:
// break;
}
if (memory) {
for (pln = 0; pln < memory->nptrs; pln++) {
if (memory->cl_type == CL_MEM_OBJECT_BUFFER) {
if (type == VX_TYPE_IMAGE) {
/* set the work dimensions */
work_dim[0] = memory->dims[pln][VX_DIM_X];
work_dim[1] = memory->dims[pln][VX_DIM_Y];
// width, height, stride_x, stride_y
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_int32), &memory->dims[pln][VX_DIM_X]);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_int32), &memory->dims[pln][VX_DIM_Y]);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_int32), &memory->strides[pln][VX_DIM_X]);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_int32), &memory->strides[pln][VX_DIM_Y]);
VX_PRINT(VX_ZONE_INFO, "Setting vx_image as Buffer with 4 parameters\n");
} else if (type == VX_TYPE_ARRAY || type == VX_TYPE_LUT) {
vx_array arr = (vx_array)ref;
// sizeof item, active count, capacity
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&arr->item_size);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&arr->num_items); // this is output?
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&arr->capacity);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_int32), &arr->memory.strides[VX_DIM_X]);
VX_PRINT(VX_ZONE_INFO, "Setting vx_buffer as Buffer with 4 parameters\n");
} else if (type == VX_TYPE_MATRIX) {
vx_matrix mat = (vx_matrix)ref;
// columns, rows
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&mat->columns);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&mat->rows);
VX_PRINT(VX_ZONE_INFO, "Setting vx_matrix as Buffer with 2 parameters\n");
} else if (type == VX_TYPE_DISTRIBUTION) {
vx_distribution dist = (vx_distribution)ref;
// num, range, offset, winsize
vx_uint32 range = dist->memory.dims[0][VX_DIM_X] * dist->window_x;
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&dist->memory.dims[VX_DIM_X]);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&range);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&dist->offset_x);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&dist->window_x);
} else if (type == VX_TYPE_CONVOLUTION) {
vx_convolution conv = (vx_convolution)ref;
// columns, rows, scale
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&conv->base.columns);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&conv->base.rows);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint32), (vx_uint32 *)&conv->scale);
}
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(cl_mem), &memory->hdls[pln]);
CL_ERROR_MSG(err, "clSetKernelArg");
if (dir == VX_INPUT || dir == VX_BIDIRECTIONAL)
{
err = clEnqueueWriteBuffer(context->queues[plidx][didx],
memory->hdls[pln],
CL_TRUE,
0,
vxComputeMemorySize(memory, pln),
memory->ptrs[pln],
0,
NULL,
&ref->event);
}
} else if (memory->cl_type == CL_MEM_OBJECT_IMAGE2D) {
vx_rectangle_t rect = {0};
vx_image image = (vx_image)ref;
vxGetValidRegionImage(image, &rect);
size_t origin[3] = {rect.start_x, rect.start_y, 0};
size_t region[3] = {rect.end_x-rect.start_x, rect.end_y-rect.start_y, 1};
/* set the work dimensions */
work_dim[0] = rect.end_x-rect.start_x;
work_dim[1] = rect.end_y-rect.start_y;
VX_PRINT(VX_ZONE_INFO, "Setting vx_image as image2d_t wd={%zu,%zu} arg:%u\n",work_dim[0], work_dim[1], argidx);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(cl_mem), &memory->hdls[pln]);
CL_ERROR_MSG(err, "clSetKernelArg");
if (err != CL_SUCCESS) {
VX_PRINT(VX_ZONE_ERROR, "Error Calling Kernel %s, parameter %u\n", node->kernel->name, pidx);
}
if (dir == VX_INPUT || dir == VX_BIDIRECTIONAL)
{
err = clEnqueueWriteImage(context->queues[plidx][didx],
memory->hdls[pln],
CL_TRUE,
origin, region,
memory->strides[pln][VX_DIM_Y],
0,
memory->ptrs[pln],
0, NULL,
&ref->event);
CL_ERROR_MSG(err, "clEnqueueWriteImage");
}
}
}
} else {
if (type == VX_TYPE_SCALAR) {
vx_value_t value; // largest platform atomic
vx_size size = 0ul;
vx_scalar sc = (vx_scalar)ref;
vx_enum stype = VX_TYPE_INVALID;
vxReadScalarValue(sc, &value);
vxQueryScalar(sc, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
size = vxSizeOfType(stype);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, size, &value);
}
else if (type == VX_TYPE_THRESHOLD) {
vx_enum ttype = 0;
vx_threshold th = (vx_threshold)ref;
vxQueryThreshold(th, VX_THRESHOLD_ATTRIBUTE_TYPE, &ttype, sizeof(ttype));
if (ttype == VX_THRESHOLD_TYPE_BINARY) {
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint8), &th->value);
} else if (ttype == VX_THRESHOLD_TYPE_RANGE) {
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint8), &th->lower);
err = clSetKernelArg(vxclk->kernels[plidx], argidx++, sizeof(vx_uint8), &th->upper);
}
}
}
}
we = 0;
for (pidx = 0; pidx < num; pidx++) {
vx_reference ref = node->parameters[pidx];
vx_enum dir = node->kernel->signature.directions[pidx];
if (dir == VX_INPUT || dir == VX_BIDIRECTIONAL) {
memcpy(&writeEvents[we++],&ref->event, sizeof(cl_event));
}
}
//local_dim[0] = 1;
//local_dim[1] = 1;
err = clEnqueueNDRangeKernel(context->queues[plidx][didx],
vxclk->kernels[plidx],
2,
off_dim,
work_dim,
NULL,
we, writeEvents, &node->base.event);
CL_ERROR_MSG(err, "clEnqueueNDRangeKernel");
/* enqueue a read on all output data */
for (pidx = 0; pidx < num; pidx++)
{
vx_reference ref = node->parameters[pidx];
vx_enum dir = node->kernel->signature.directions[pidx];
vx_enum type = node->kernel->signature.types[pidx];
if (dir == VX_OUTPUT || dir == VX_BIDIRECTIONAL)
{
vx_memory_t *memory = NULL;
switch (type)
{
case VX_TYPE_ARRAY:
memory = &((vx_array)ref)->memory;
break;
case VX_TYPE_CONVOLUTION:
memory = &((vx_convolution)ref)->base.memory;
break;
case VX_TYPE_DISTRIBUTION:
memory = &((vx_distribution)ref)->memory;
break;
case VX_TYPE_IMAGE:
memory = &((vx_image)ref)->memory;
break;
case VX_TYPE_LUT:
memory = &((vx_lut_t*)ref)->memory;
break;
case VX_TYPE_MATRIX:
memory = &((vx_matrix)ref)->memory;
break;
//case VX_TYPE_PYRAMID:
// break;
case VX_TYPE_REMAP:
memory = &((vx_remap)ref)->memory;
break;
//case VX_TYPE_SCALAR:
//case VX_TYPE_THRESHOLD:
// break;
}
if (memory) {
for (pln = 0; pln < memory->nptrs; pln++) {
if (memory->cl_type == CL_MEM_OBJECT_BUFFER) {
err = clEnqueueReadBuffer(context->queues[plidx][didx],
memory->hdls[pln],
CL_TRUE, 0, vxComputeMemorySize(memory, pln),
memory->ptrs[pln],
1, &node->base.event, &ref->event);
CL_ERROR_MSG(err, "clEnqueueReadBuffer");
} else if (memory->cl_type == CL_MEM_OBJECT_IMAGE2D) {
vx_rectangle_t rect = {0};
vx_image image = (vx_image)ref;
vxGetValidRegionImage(image, &rect);
size_t origin[3] = {rect.start_x, rect.start_y, 0};
size_t region[3] = {rect.end_x-rect.start_x, rect.end_y-rect.start_y, 1};
/* set the work dimensions */
work_dim[0] = rect.end_x-rect.start_x;
work_dim[1] = rect.end_y-rect.start_y;
err = clEnqueueReadImage(context->queues[plidx][didx],
memory->hdls[pln],
CL_TRUE,
origin, region,
memory->strides[pln][VX_DIM_Y],
0,
memory->ptrs[pln],
1, &node->base.event,
&ref->event);
CL_ERROR_MSG(err, "clEnqueueReadImage");
VX_PRINT(VX_ZONE_INFO, "Reading Image wd={%zu,%zu}\n", work_dim[0], work_dim[1]);
}
}
}
}
}
re = 0;
for (pidx = 0; pidx < num; pidx++) {
vx_reference ref = node->parameters[pidx];
vx_enum dir = node->kernel->signature.directions[pidx];
if (dir == VX_OUTPUT || dir == VX_BIDIRECTIONAL) {
memcpy(&readEvents[re++],&ref->event, sizeof(cl_event));
}
}
err = clFlush(context->queues[plidx][didx]);
CL_ERROR_MSG(err, "Flush");
VX_PRINT(VX_ZONE_TARGET, "Waiting for read events!\n");
clWaitForEvents(re, readEvents);
if (err == CL_SUCCESS)
status = VX_SUCCESS;
//exit:
VX_PRINT(VX_ZONE_API, "%s exiting %d\n", __FUNCTION__, status);
vxSemPost(&target->base.lock);
return status;
}
/*!***********************************************************************************************************
input parameter validator.
param [in] node The handle to the node.
param [in] index The index of the parameter to validate.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_SURF_Compute_InputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_SUCCESS;
vx_parameter param = vxGetParameterByIndex(node, index);
if (index == 0)
{
vx_image image;
vx_df_image df_image = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &df_image, sizeof(df_image)));
if (df_image != VX_DF_IMAGE_U8)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
if (index == 1)
{
vx_image image;
vx_df_image df_image = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &df_image, sizeof(df_image)));
if (df_image != VX_DF_IMAGE_U8)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
else if (index == 2)
{
vx_array array; vx_size size = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &array, sizeof(array)));
STATUS_ERROR_CHECK(vxQueryArray(array, VX_ARRAY_ATTRIBUTE_CAPACITY, &size, sizeof(size)));
vxReleaseArray(&array);
}
else if (index == 3)
{
vx_array array; vx_size size = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &array, sizeof(array)));
STATUS_ERROR_CHECK(vxQueryArray(array, VX_ARRAY_ATTRIBUTE_CAPACITY, &size, sizeof(size)));
vxReleaseArray(&array);
}
else if (index == 4)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_float32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_FLOAT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 5)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_int32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_INT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 6)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_int32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_INT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 7)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_bool value = vx_true_e;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if ((value != vx_true_e && value != vx_false_e) || type != VX_TYPE_BOOL)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 8)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_bool value = vx_true_e;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if ((value != vx_true_e && value != vx_false_e) || type != VX_TYPE_BOOL)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
return status;
}
// read scalar value into a string
int ReadScalarToString(vx_scalar scalar, char str[])
{
vx_enum type; ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
if (type == VX_TYPE_FLOAT32) {
float v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%g", v);
}
else if (type == VX_TYPE_FLOAT64) {
double v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%lg", v);
}
else if (type == VX_TYPE_SIZE) {
vx_size v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, VX_FMT_SIZE, v);
}
else if (type == VX_TYPE_INT8 || type == VX_TYPE_CHAR) {
vx_int8 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%d", v);
}
else if (type == VX_TYPE_INT16) {
vx_int16 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%d", v);
}
else if (type == VX_TYPE_INT32 || type == VX_TYPE_BOOL) {
vx_int32 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%d", v);
}
else if (type == VX_TYPE_INT64) {
vx_int64 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%" PRId64, v);
}
else if (type == VX_TYPE_UINT8) {
vx_uint8 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%d", v);
}
else if (type == VX_TYPE_UINT16) {
vx_uint16 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%d", v);
}
else if (type == VX_TYPE_UINT32) {
vx_uint32 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%d", v);
}
else if (type == VX_TYPE_UINT64) {
vx_uint64 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "%" PRIu64, v);
}
else if (type == VX_TYPE_ENUM) {
vx_enum v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
const char * name = ovxEnum2Name(v);
if (name) strcpy(str, name);
else sprintf(str, "0x%x", v);
}
else if (type == VX_TYPE_DF_IMAGE || type == VX_TYPE_STRING_AMD) {
str[4] = 0; // needed for VX_TYPE_DF_IMAGE
ERROR_CHECK(vxReadScalarValue(scalar, str));
}
else {
// unknown types will be printed in hex
vx_uint64 v = 0; ERROR_CHECK(vxReadScalarValue(scalar, &v));
sprintf(str, "0x%" PRIx64, v);
}
return 0;
}
