static vx_status vxCheckBufferKernel(vx_node node, vx_reference *parameters, vx_uint32 num)
{
vx_status status = VX_SUCCESS;
if (num == 3)
{
vx_scalar buffer = (vx_buffer)parameters[0];
vx_scalar fill = (vx_scalar)parameters[1];
vx_scalar errs = (vx_scalar)parameters[2];
vx_uint8 value = 0u;
vx_size numUnits = 0ul, unitSize = 0ul, size = 0ul;
vx_uint32 errors = 0;
vx_uint8 *ptr = NULL;
vxQueryBuffer(buffer, VX_BUFFER_ATTRIBUTE_NUMUNITS, &numUnits, sizeof(numUnits));
vxQueryBuffer(buffer, VX_BUFFER_ATTRIBUTE_UNITSIZE, &unitSize, sizeof(unitSize));
vxQueryBuffer(buffer, VX_BUFFER_ATTRIBUTE_SIZE, &size, sizeof(size));
vxAccessScalarValue(fill, (void *)&value);
status = vxAccessBufferRange(buffer, 0, numUnits, (void **)&ptr);
if (status == VX_SUCCESS)
{
vx_size i = 0;
for (i = 0ul; i < size; i++)
{
if (ptr[i] != value)
{
errors++;
}
}
vxCommitScalarValue(errs, &errors);
if (errors > 0)
{
vxAddLogEntry(vxGetContext(node), VX_FAILURE, "Check buffer %p of "VX_FMT_SIZE" bytes with 0x%02x, found %u errors\n", ptr, size, value, errors);
}
status = vxCommitBufferRange(buffer, 0, numUnits, ptr);
if (status != VX_SUCCESS)
{
vxAddLogEntry(vxGetContext(node), VX_FAILURE, "Failed to set buffer range for "VX_FMT_REF"\n", buffer);
}
}
else
{
vxAddLogEntry(vxGetContext(node), VX_FAILURE, "Failed to get buffer range for "VX_FMT_REF"\n", buffer);
}
if (errors > 0)
{
status = VX_FAILURE;
}
}
return status;
}
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 vxMatrixModifyKernel(vx_node node, vx_reference *parameters, vx_uint32 num)
{
vx_status status = VX_SUCCESS;
vx_matrix in_matr = (vx_matrix)parameters[0];
vx_scalar s_width = (vx_scalar)parameters[1];
vx_scalar s_height = (vx_scalar)parameters[2];
vx_scalar s_scale = (vx_scalar)parameters[3];
vx_matrix out_matr = (vx_matrix)parameters[4];
vx_uint32 width, height;
vx_float32 scale;
status |= vxAccessScalarValue(s_width, &width);
status |= vxAccessScalarValue(s_height, &height);
status |= vxAccessScalarValue(s_scale, &scale);
if(status == VX_SUCCESS)
{
status = ModifyMatrix(in_matr, out_matr, width, height, scale);
}
else
{
VX_PRINT(VX_ZONE_ERROR, "Access scalar values failure!\n");
}
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;
}
static vx_status vxCheckImageKernel(vx_node node, vx_reference *parameters, vx_uint32 num)
{
vx_status status = VX_SUCCESS;
if (num == 3)
{
vx_image image = (vx_image)parameters[0];
vx_scalar fill = (vx_scalar)parameters[1];
vx_scalar errs = (vx_scalar)parameters[2];
packed_value_u value;
vx_uint32 planes = 0u, count = 0u, errors = 0u;
vx_uint32 x = 0u, y = 0u, p = 0u;
vx_int32 i = 0;
vx_imagepatch_addressing_t addr;
vx_rectangle rect;
value.dword[0] = 0xDEADBEEF;
vxAccessScalarValue(fill, &value.dword[0]);
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_PLANES, &planes, sizeof(planes));
rect = vxGetValidRegionImage(image);
for (p = 0u; (p < planes) && (rect); p++)
{
void *ptr = NULL;
status = vxAccessImagePatch(image, rect, p, &addr, &ptr);
if ((status == VX_SUCCESS) && (ptr))
{
for (y = 0; y < addr.dim_y; y+=addr.step_y)
{
for (x = 0; x < addr.dim_x; x+=addr.step_x)
{
vx_uint8 *pixel = vxFormatImagePatchAddress2d(ptr, x, y, &addr);
for (i = 0; i < addr.stride_x; i++)
{
count++;
if (pixel[i] != value.bytes[i])
{
errors++;
}
}
}
}
if (errors > 0)
{
vxAddLogEntry(vxGetContext(node), VX_FAILURE, "Checked %p of %u sub-pixels with 0x%08x with %u errors\n", ptr, count, value.dword, errors);
}
vxCommitScalarValue(errs, &errors);
status = vxCommitImagePatch(image, 0, p, &addr, ptr);
if (status != VX_SUCCESS)
{
vxAddLogEntry(vxGetContext(node), VX_FAILURE, "Failed to set image patch for "VX_FMT_REF"\n", image);
}
}
else
{
vxAddLogEntry(vxGetContext(node), VX_FAILURE, "Failed to get image patch for "VX_FMT_REF"\n", image);
}
}
vxReleaseRectangle(&rect);
if (errors > 0)
{
status = VX_FAILURE;
}
}
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 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;
}
