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