VX_API_ENTRY vx_parameter VX_API_CALL vxGetKernelParameterByIndex(vx_kernel kernel, vx_uint32 index) { vx_parameter parameter = NULL; if (vxIsValidSpecificReference(&kernel->base, VX_TYPE_KERNEL) == vx_true_e) { if (index < VX_INT_MAX_PARAMS && index < kernel->signature.num_parameters) { parameter = (vx_parameter)vxCreateReference(kernel->base.context, VX_TYPE_PARAMETER, VX_EXTERNAL, &kernel->base.context->base); if (vxGetStatus((vx_reference)parameter) == VX_SUCCESS && parameter->base.type == VX_TYPE_PARAMETER) { parameter->index = index; parameter->node = NULL; parameter->kernel = kernel; vxIncrementReference(¶meter->kernel->base, VX_INTERNAL); } } else { vxAddLogEntry(&kernel->base, VX_ERROR_INVALID_PARAMETERS, "Index %u out of range for node %s (numparams = %u)!\n", index, kernel->name, kernel->signature.num_parameters); parameter = (vx_parameter_t *)vxGetErrorObject(kernel->base.context, VX_ERROR_INVALID_PARAMETERS); } } return parameter; }
VX_API_ENTRY vx_distribution VX_API_CALL vxCreateDistribution(vx_context context, vx_size numBins, vx_int32 offset, vx_uint32 range) { vx_distribution distribution = NULL; if (vxIsValidContext(context) == vx_true_e) { if ((numBins != 0) && (range != 0)) { distribution = (vx_distribution)vxCreateReference(context, VX_TYPE_DISTRIBUTION, VX_EXTERNAL, &context->base); if ( vxGetStatus((vx_reference)distribution) == VX_SUCCESS && distribution->base.type == VX_TYPE_DISTRIBUTION) { distribution->memory.ndims = 2; distribution->memory.nptrs = 1; distribution->memory.strides[0][VX_DIM_C] = sizeof(vx_int32); distribution->memory.dims[0][VX_DIM_C] = 1; distribution->memory.dims[0][VX_DIM_X] = (vx_int32)numBins; distribution->memory.dims[0][VX_DIM_Y] = 1; distribution->memory.cl_type = CL_MEM_OBJECT_BUFFER; distribution->window_x = (vx_uint32)range/(vx_uint32)numBins; distribution->window_y = 1; distribution->offset_x = offset; distribution->offset_y = 0; } } else { VX_PRINT(VX_ZONE_ERROR, "Invalid parameters to distribution\n"); vxAddLogEntry(&context->base, VX_ERROR_INVALID_PARAMETERS, "Invalid parameters to distribution\n"); distribution = (vx_distribution)vxGetErrorObject(context, VX_ERROR_INVALID_PARAMETERS); } } return distribution; }
vx_status vxTargetDeinit(vx_target_t *target) { vx_context context = target->base.context; if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { cl_uint p = 0, d = 0; vx_uint32 k = 0; for (p = 0; p < context->num_platforms; p++) { for (k = 0; k < num_cl_kernels; k++) { vxDecrementReference(&target->kernels[k].base, VX_INTERNAL); clReleaseKernel(cl_kernels[k]->kernels[p]); clReleaseProgram(cl_kernels[k]->program[p]); } for (d = 0; d < context->num_devices[p]; d++) { clReleaseCommandQueue(context->queues[p][d]); } clReleaseContext(context->global[p]); } } return VX_SUCCESS; }
static vx_status VX_CALLBACK vxMagnitudeOutputValidator(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, 0); if (vxGetStatus((vx_reference)param) == VX_SUCCESS) { vx_image input = 0; vxQueryParameter(param, VX_PARAMETER_REF, &input, sizeof(input)); if (input) { vx_uint32 width = 0, height = 0; vxQueryImage(input, VX_IMAGE_WIDTH, &width, sizeof(width)); vxQueryImage(input, VX_IMAGE_HEIGHT, &height, sizeof(height)); ptr->type = VX_TYPE_IMAGE; ptr->dim.image.format = VX_DF_IMAGE_S16; ptr->dim.image.width = width; ptr->dim.image.height = height; status = VX_SUCCESS; vxReleaseImage(&input); } vxReleaseParameter(¶m); } } return status; }
VX_API_ENTRY vx_lut VX_API_CALL vxCreateLUT(vx_context context, vx_enum data_type, vx_size count) { vx_lut_t *lut = NULL; if (vxIsValidContext(context) == vx_true_e) { if (data_type == VX_TYPE_UINT8) { #if defined(OPENVX_STRICT_1_0) if (count != 256) { VX_PRINT(VX_ZONE_ERROR, "Invalid parameter to LUT\n"); vxAddLogEntry(&context->base, VX_ERROR_INVALID_PARAMETERS, "Invalid parameter to LUT\n"); lut = (vx_lut_t *)vxGetErrorObject(context, VX_ERROR_INVALID_PARAMETERS); } else #endif { lut = (vx_lut_t *)vxCreateArrayInt(context, VX_TYPE_UINT8, count, vx_false_e, VX_TYPE_LUT); if (vxGetStatus((vx_reference)lut) == VX_SUCCESS && lut->base.type == VX_TYPE_LUT) { lut->num_items = count; vxPrintArray(lut); } } } #if !defined(OPENVX_STRICT_1_0) else if (data_type == VX_TYPE_UINT16) { lut = (vx_lut_t *)vxCreateArrayInt(context, VX_TYPE_UINT16, count, vx_false_e, VX_TYPE_LUT); if (vxGetStatus((vx_reference)lut) == VX_SUCCESS && lut->base.type == VX_TYPE_LUT) { lut->num_items = count; vxPrintArray(lut); } } #endif else { VX_PRINT(VX_ZONE_ERROR, "Invalid data type\n"); vxAddLogEntry(&context->base, VX_ERROR_INVALID_TYPE, "Invalid data type\n"); lut = (vx_lut_t *)vxGetErrorObject(context, VX_ERROR_INVALID_TYPE); } } return (vx_lut)lut; }
VX_API_ENTRY vx_node VX_API_CALL vxTensorAddNode(vx_graph graph, vx_tensor input1, vx_tensor input2, vx_enum policy, vx_tensor output) { vx_node node = NULL; vx_context context = vxGetContext((vx_reference)graph); if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_scalar s_policy = vxCreateScalarWithSize(context, VX_TYPE_ENUM, &policy, sizeof(policy)); if (vxGetStatus((vx_reference)s_policy) == VX_SUCCESS) { vx_reference params[] = { (vx_reference)input1, (vx_reference)input2, (vx_reference)s_policy, (vx_reference)output }; node = createNode(graph, VX_KERNEL_TENSOR_ADD, params, sizeof(params) / sizeof(params[0])); vxReleaseScalar(&s_policy); } } return node; }
VX_API_ENTRY vx_node vxROIPoolingLayer(vx_graph graph, vx_tensor input_data, vx_tensor input_rois, const vx_nn_roi_pool_params_t *roi_pool_params,vx_size size_of_roi_params, vx_tensor output_arr) { return NULL; vx_node node = NULL; vx_context context = vxGetContext((vx_reference)graph); if(vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_scalar roi_params = vxCreateScalarWithSize(context, VX_TYPE_NN_ROI_POOL_PARAMS, roi_pool_params, size_of_roi_params); if(vxGetStatus((vx_reference)roi_params) == VX_SUCCESS) { vx_reference params[] = { (vx_reference)input_data, (vx_reference)input_rois, (vx_reference)roi_params, (vx_reference)output_arr }; node = createNode(graph, VX_KERNEL_ROI_POOLING_LAYER, params, sizeof(params)/sizeof(params[0])); } vxReleaseScalar(&roi_params); } return node; }
VX_API_ENTRY vx_node VX_API_CALL vxArgmaxLayer(vx_graph graph, vx_tensor input, vx_reference output) { vx_node node = NULL; vx_context context = vxGetContext((vx_reference)graph); if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_reference params[] = { (vx_reference)input, (vx_reference)output }; node = createNode(graph, VX_KERNEL_ARGMAX_LAYER_AMD, params, sizeof(params) / sizeof(params[0])); } return node; }
vx_array vxCreateArrayInt(vx_context context, vx_enum item_type, vx_size capacity, vx_bool is_virtual, vx_enum type) { vx_array arr = (vx_array)vxCreateReference(context, type, VX_EXTERNAL, &context->base); if (vxGetStatus((vx_reference)arr) == VX_SUCCESS && arr->base.type == type) { arr->item_type = item_type; arr->item_size = vxArrayItemSize(context, item_type); arr->capacity = capacity; arr->base.is_virtual = is_virtual; vxInitArrayMemory(arr); } return arr; }
VX_API_ENTRY vx_node VX_API_CALL vxConvertImageToTensorNode(vx_graph graph, vx_image input, vx_tensor output, vx_float32 a, vx_float32 b, vx_bool reverse_channel_order) { vx_node node = NULL; vx_context context = vxGetContext((vx_reference)graph); if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_scalar s_a = vxCreateScalarWithSize(context, VX_TYPE_FLOAT32, &a, sizeof(a)); vx_scalar s_b = vxCreateScalarWithSize(context, VX_TYPE_FLOAT32, &b, sizeof(b)); vx_scalar s_order = vxCreateScalarWithSize(context, VX_TYPE_BOOL, &reverse_channel_order, sizeof(reverse_channel_order)); if(vxGetStatus((vx_reference)s_order) == VX_SUCCESS) { vx_reference params[] = { (vx_reference)input, (vx_reference)output, (vx_reference)s_a, (vx_reference)s_b, (vx_reference)s_order }; node = createNode(graph, VX_KERNEL_CONVERT_IMAGE_TO_TENSOR_AMD, params, sizeof(params) / sizeof(params[0])); vxReleaseScalar(&s_a); vxReleaseScalar(&s_b); vxReleaseScalar(&s_order); } } return node; }
//! [node] vx_node vxXYZNode(vx_graph graph, vx_image input, vx_uint32 value, vx_image output, vx_array temp) { vx_uint32 i; vx_node node = 0; vx_context context = vxGetContext((vx_reference)graph); vx_status status = vxLoadKernels(context, "xyz"); if (status == VX_SUCCESS) { //! [xyz node] vx_kernel kernel = vxGetKernelByName(context, VX_KERNEL_NAME_KHR_XYZ); if (kernel) { node = vxCreateGenericNode(graph, kernel); if (vxGetStatus((vx_reference)node) == VX_SUCCESS) { vx_status statuses[4]; vx_scalar scalar = vxCreateScalar(context, VX_TYPE_INT32, &value); statuses[0] = vxSetParameterByIndex(node, 0, (vx_reference)input); statuses[1] = vxSetParameterByIndex(node, 1, (vx_reference)scalar); statuses[2] = vxSetParameterByIndex(node, 2, (vx_reference)output); statuses[3] = vxSetParameterByIndex(node, 3, (vx_reference)temp); vxReleaseScalar(&scalar); for (i = 0; i < dimof(statuses); i++) { if (statuses[i] != VX_SUCCESS) { status = VX_ERROR_INVALID_PARAMETERS; vxReleaseNode(&node); vxReleaseKernel(&kernel); node = 0; kernel = 0; break; } } } else { vxReleaseKernel(&kernel); } } else { vxUnloadKernels(context, "xyz"); } //! [xyz node] } return node; }
vx_meta_format vxCreateMetaFormat(vx_context context) { vx_meta_format meta = NULL; if (vxIsValidContext(context) == vx_true_e) { meta = (vx_meta_format)vxCreateReference(context, VX_TYPE_META_FORMAT, VX_EXTERNAL, &context->base); if (vxGetStatus((vx_reference)meta) == VX_SUCCESS) { meta->size = sizeof(vx_meta_format_t); meta->type = VX_TYPE_INVALID; } } return meta; }
int CVxParamArray::Initialize(vx_context context, vx_graph graph, const char * desc) { // get object parameters and create object char objType[64]; const char * ioParams = ScanParameters(desc, "array|virtual-array:", "s:", objType); if (!_stricmp(objType, "array") || !_stricmp(objType, "virtual-array") || !_stricmp(objType, "array-virtual")) { // syntax: [virtual-]array:<format>,<capacity>[:<io-params>] char itemType[64]; ioParams = ScanParameters(ioParams, "<format>,<capacity>", "s,D", &itemType, &m_capacity); bool found_userStruct = false; for (auto it = m_userStructMap->begin(); it != m_userStructMap->end(); ++it){ if (strcmp(itemType, it->first.c_str()) == 0){ found_userStruct = true; m_format = it->second; } } if (found_userStruct == false){ m_format = ovxName2Enum(itemType); if (m_format == 0) { ReportError("ERROR: invalid array item type specified: %s\n", itemType); } } // create array object if (!_stricmp(objType, "virtual-array") || !_stricmp(objType, "array-virtual")) { m_array = vxCreateVirtualArray(graph, m_format, m_capacity); m_isVirtualObject = true; } else { m_array = vxCreateArray(context, m_format, m_capacity); } } else ReportError("ERROR: unsupported array type: %s\n", desc); vx_status ovxStatus = vxGetStatus((vx_reference)m_array); if (ovxStatus != VX_SUCCESS){ printf("ERROR: array creation failed => %d (%s)\n", ovxStatus, ovxEnum2Name(ovxStatus)); if (m_array) vxReleaseArray(&m_array); throw - 1; } m_vxObjRef = (vx_reference)m_array; // io initialize return InitializeIO(context, graph, m_vxObjRef, ioParams); }
int CVxParamRemap::Initialize(vx_context context, vx_graph graph, const char * desc) { // get object parameters and create object // syntax: remap:<srcWidth>,<srcHeight>,<dstWidth>,<dstHeight>[:<io-params>] char objType[64]; const char * ioParams = ScanParameters(desc, "remap:<srcWidth>,<srcHeight>,<dstWidth>,<dstHeight>", "s:d,d,d,d", objType, &m_srcWidth, &m_srcHeight, &m_dstWidth, &m_dstHeight); if (!_stricmp(objType, "remap")) { m_remap = vxCreateRemap(context, m_srcWidth, m_srcHeight, m_dstWidth, m_dstHeight); } else ReportError("ERROR: invalid remap type: %s\n", objType); vx_status ovxStatus = vxGetStatus((vx_reference)m_remap); if (ovxStatus != VX_SUCCESS){ printf("ERROR: pyramid creation failed => %d (%s)\n", ovxStatus, ovxEnum2Name(ovxStatus)); if (m_remap) vxReleaseRemap(&m_remap); throw - 1; } // io initialize return InitializeIO(context, graph, (vx_reference)m_remap, ioParams); }
int CVxParamDistribution::Initialize(vx_context context, vx_graph graph, const char * desc) { // get object parameters and create object char objType[64]; const char * ioParams = ScanParameters(desc, "distribution:<numBins>,<offset>,<range>", "s:D,d,d", objType, &m_numBins, &m_offset, &m_range); if (!_stricmp(objType, "distribution")) { m_distribution = vxCreateDistribution(context, m_numBins, m_offset, m_range); } else ReportError("ERROR: unsupported distribution type: %s\n", desc); vx_status ovxStatus = vxGetStatus((vx_reference)m_distribution); if (ovxStatus != VX_SUCCESS){ printf("ERROR: distribution creation failed => %d (%s)\n", ovxStatus, ovxEnum2Name(ovxStatus)); if (m_distribution) vxReleaseDistribution(&m_distribution); throw - 1; } m_vxObjRef = (vx_reference)m_distribution; // io initialize return InitializeIO(context, graph, m_vxObjRef, ioParams); }
//! [vxu] vx_status vxuXYZ(vx_context context, vx_image input, vx_uint32 value, vx_image output, vx_array temp) { vx_status status = VX_FAILURE; vx_graph graph = vxCreateGraph(context); if (vxGetStatus((vx_reference)graph) == VX_SUCCESS) { vx_node node = vxXYZNode(graph, input, value, output, temp); if (node) { status = vxVerifyGraph(graph); if (status == VX_SUCCESS) { status = vxProcessGraph(graph); } vxReleaseNode(&node); } vxReleaseGraph(&graph); } return status; }
int CVxParamMatrix::Initialize(vx_context context, vx_graph graph, const char * desc) { // get object parameters and create object char objType[64], data_type[64]; const char * ioParams = ScanParameters(desc, "matrix:<data-type>,<columns>,<rows>", "s:s,D,D", objType, data_type, &m_columns, &m_rows); if (!_stricmp(objType, "matrix")) { m_data_type = ovxName2Enum(data_type); m_matrix = vxCreateMatrix(context, m_data_type, m_columns, m_rows); } else ReportError("ERROR: unsupported matrix type: %s\n", desc); vx_status ovxStatus = vxGetStatus((vx_reference)m_matrix); if (ovxStatus != VX_SUCCESS){ printf("ERROR: matrix creation failed => %d (%s)\n", ovxStatus, ovxEnum2Name(ovxStatus)); if (m_matrix) vxReleaseMatrix(&m_matrix); throw - 1; } m_vxObjRef = (vx_reference)m_matrix; // io initialize return InitializeIO(context, graph, m_vxObjRef, ioParams); }
VX_API_ENTRY vx_parameter VX_API_CALL vxGetParameterByIndex(vx_node node, vx_uint32 index) { vx_parameter param = NULL; if (vxIsValidSpecificReference(&node->base, VX_TYPE_NODE) == vx_false_e) { return param; } if (node->kernel == NULL) { /* this can probably never happen */ vxAddLogEntry(&node->base, VX_ERROR_INVALID_NODE, "Node was created without a kernel! Fatal Error!\n"); param = (vx_parameter_t *)vxGetErrorObject(node->base.context, VX_ERROR_INVALID_NODE); } else { if (/*0 <= index &&*/ index < VX_INT_MAX_PARAMS && index < node->kernel->signature.num_parameters) { param = (vx_parameter)vxCreateReference(node->base.context, VX_TYPE_PARAMETER, VX_EXTERNAL, &node->base); if (vxGetStatus((vx_reference)param) == VX_SUCCESS && param->base.type == VX_TYPE_PARAMETER) { param->index = index; param->node = node; vxIncrementReference(¶m->node->base, VX_INTERNAL); param->kernel = node->kernel; vxIncrementReference(¶m->kernel->base, VX_INTERNAL); // if (node->parameters[index]) // vxIncrementReference(node->parameters[index], VX_INTERNAL); } } else { vxAddLogEntry(&node->base, VX_ERROR_INVALID_PARAMETERS, "Index %u out of range for node %s (numparams = %u)!\n", index, node->kernel->name, node->kernel->signature.num_parameters); param = (vx_parameter_t *)vxGetErrorObject(node->base.context, VX_ERROR_INVALID_PARAMETERS); } } VX_PRINT(VX_ZONE_API, "%s: returning %p\n", __FUNCTION__, param); return param; }
/*! * \brief An example of an super resolution algorithm. * \ingroup group_example */ int example_super_resolution(int argc, char *argv[]) { vx_status status = VX_SUCCESS; vx_uint32 image_index = 0, max_num_images = 4; vx_uint32 width = 640; vx_uint32 i = 0; vx_uint32 winSize = 32; vx_uint32 height = 480; vx_int32 sens_thresh = 20; vx_float32 alpha = 0.2f; vx_float32 tau = 0.5f; vx_enum criteria = VX_TERM_CRITERIA_BOTH; // lk params vx_float32 epsilon = 0.01; vx_int32 num_iterations = 10; vx_bool use_initial_estimate = vx_true_e; vx_int32 min_distance = 5; // harris params vx_float32 sensitivity = 0.04; vx_int32 gradient_size = 3; vx_int32 block_size = 3; vx_context context = vxCreateContext(); vx_scalar alpha_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &alpha); vx_scalar tau_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &tau); vx_matrix matrix_forward = vxCreateMatrix(context, VX_TYPE_FLOAT32, 3, 3); vx_matrix matrix_backwords = vxCreateMatrix(context, VX_TYPE_FLOAT32, 3, 3); vx_array old_features = vxCreateArray(context, VX_TYPE_KEYPOINT, 1000); vx_array new_features = vxCreateArray(context, VX_TYPE_KEYPOINT, 1000); vx_scalar epsilon_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &epsilon); vx_scalar num_iterations_s = vxCreateScalar(context, VX_TYPE_INT32, &num_iterations); vx_scalar use_initial_estimate_s = vxCreateScalar(context, VX_TYPE_BOOL, &use_initial_estimate); vx_scalar min_distance_s = vxCreateScalar(context, VX_TYPE_INT32, &min_distance); vx_scalar sensitivity_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &sensitivity); vx_scalar sens_thresh_s = vxCreateScalar(context, VX_TYPE_INT32, &sens_thresh); vx_scalar num_corners = vxCreateScalar(context, VX_TYPE_SIZE, NULL); if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_image images[] = { vxCreateImage(context, width, height, VX_DF_IMAGE_UYVY), // index 0: vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 1: Get Y channel vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 2: scale up to high res. vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 3: back wrap: transform to the original Image. vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 4: guassian blur vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 5: scale down vxCreateImage(context, width, height, VX_DF_IMAGE_S16), // index 6: Subtract the transformed Image with original moved Image vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_S16), // index 7: Scale Up the delta image. vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_S16), // index 8: Guassian blur the delta Image vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_S16), // index 9: forward wrap: tranform the deltas back to the high res Image vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 10: accumulate sum? vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 11: Get U channel vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 12: scale up to high res. vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 13: Get V channel vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 14: scale up to high res. vxCreateImage(context, width, height, VX_DF_IMAGE_UYVY), // index 15: output image vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 16: original y image scaled vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 17: difference image for last calculation }; vx_pyramid pyramid_new = vxCreatePyramid(context, 4, 2, width, height, VX_DF_IMAGE_U8); vx_pyramid pyramid_old = vxCreatePyramid(context, 4, 2, width, height, VX_DF_IMAGE_U8); vx_graph graphs[] = { vxCreateGraph(context), vxCreateGraph(context), vxCreateGraph(context), vxCreateGraph(context), }; vxLoadKernels(context, "openvx-debug"); if (vxGetStatus((vx_reference)graphs[0]) == VX_SUCCESS) { vxChannelExtractNode(graphs[0], images[0], VX_CHANNEL_Y, images[1]); // One iteration of super resolution calculation vxScaleImageNode(graphs[0], images[1], images[2], VX_INTERPOLATION_TYPE_BILINEAR); vxWarpPerspectiveNode(graphs[0], images[2], matrix_forward, 0, images[3]); vxGaussian3x3Node(graphs[0], images[3], images[4]); vxScaleImageNode(graphs[0], images[4], images[5], VX_INTERPOLATION_TYPE_BILINEAR); vxSubtractNode(graphs[0], images[5], images[16], VX_CONVERT_POLICY_SATURATE, images[6]); vxScaleImageNode(graphs[0], images[6], images[7], VX_INTERPOLATION_TYPE_BILINEAR); vxGaussian3x3Node(graphs[0], images[7], images[8]); vxWarpPerspectiveNode(graphs[0], images[8], matrix_backwords, 0, images[9]); vxAccumulateWeightedImageNode(graphs[0], images[9], alpha_s, images[10]); } if (vxGetStatus((vx_reference)graphs[1]) == VX_SUCCESS) { vxChannelExtractNode(graphs[1], images[0], VX_CHANNEL_Y, images[1]); // One iteration of super resolution calculation vxGaussianPyramidNode(graphs[1], images[1], pyramid_new); vxOpticalFlowPyrLKNode(graphs[1], pyramid_old, pyramid_new, old_features, old_features, new_features, criteria, epsilon_s, num_iterations_s, use_initial_estimate_s, winSize); } if (vxGetStatus((vx_reference)graphs[2]) == VX_SUCCESS) { vxChannelExtractNode(graphs[2], images[0], VX_CHANNEL_Y, images[1]); // One iteration of super resolution calculation vxHarrisCornersNode(graphs[2], images[1], sens_thresh_s, min_distance_s, sensitivity_s, gradient_size, block_size, old_features, num_corners); vxGaussianPyramidNode(graphs[2], images[1], pyramid_old); vxScaleImageNode(graphs[2], images[1], images[16], VX_INTERPOLATION_TYPE_BILINEAR); } if (vxGetStatus((vx_reference)graphs[3]) == VX_SUCCESS) { vxSubtractNode(graphs[3], images[10], images[16], VX_CONVERT_POLICY_SATURATE, images[17]); vxAccumulateWeightedImageNode(graphs[3], images[17], tau_s, images[16]); vxChannelExtractNode(graphs[3], images[16], VX_CHANNEL_U, images[11]); vxScaleImageNode(graphs[3], images[11], images[12], VX_INTERPOLATION_TYPE_BILINEAR); // upscale the u channel vxChannelExtractNode(graphs[3], images[0], VX_CHANNEL_V, images[13]); vxScaleImageNode(graphs[3], images[13], images[14], VX_INTERPOLATION_TYPE_BILINEAR); // upscale the v channel vxChannelCombineNode(graphs[3], images[10], images[12], images[14], 0, images[15]); // recombine the channels } status = VX_SUCCESS; status |= vxVerifyGraph(graphs[0]); status |= vxVerifyGraph(graphs[1]); status |= vxVerifyGraph(graphs[2]); status |= vxVerifyGraph(graphs[3]); if (status == VX_SUCCESS) { /* read the initial image in */ status |= vxuFReadImage(context, "c:\\work\\super_res\\superres_1_UYVY.yuv", images[0]); /* compute the "old" pyramid */ status |= vxProcessGraph(graphs[2]); /* for each input image, read it in and run graphs[1] and [0]. */ for (image_index = 1; image_index < max_num_images; image_index++) { char filename[256]; sprintf(filename, "c:\\work\\super_res\\superres_%d_UYVY.yuv", image_index + 1); status |= vxuFReadImage(context, filename, images[0]); status |= vxProcessGraph(graphs[1]); userCalculatePerspectiveTransformFromLK(matrix_forward, matrix_backwords, old_features, new_features); status |= vxProcessGraph(graphs[0]); } /* run the final graph */ status |= vxProcessGraph(graphs[3]); /* save the output */ status |= vxuFWriteImage(context, images[15], "superres_UYVY.yuv"); } vxReleaseGraph(&graphs[0]); vxReleaseGraph(&graphs[1]); vxReleaseGraph(&graphs[2]); vxReleaseGraph(&graphs[3]); for (i = 0; i < dimof(images); i++) { vxReleaseImage(&images[i]); } vxReleasePyramid(&pyramid_new); vxReleasePyramid(&pyramid_old); } vxReleaseMatrix(&matrix_forward); vxReleaseMatrix(&matrix_backwords); vxReleaseScalar(&alpha_s); vxReleaseScalar(&tau_s); /* Release the context last */ vxReleaseContext(&context); return status; }
static void check(vx_image img) { vxErr(vxGetStatus((vx_reference)img), "image check").check(); }
static void check(vx_context ctx) { vxErr(vxGetStatus((vx_reference)ctx), "context check").check(); }
int CVxParamTensor::Initialize(vx_context context, vx_graph graph, const char * desc) { // get object parameters and create object const char * ioParams = desc; if (!_strnicmp(desc, "tensor:", 7) || !_strnicmp(desc, "virtual-tensor:", 15)) { bool isVirtual = false; if (!_strnicmp(desc, "virtual-tensor:", 15)) { isVirtual = true; desc += 8; } char objType[64], data_type[64]; ioParams = ScanParameters(desc, "tensor:<num-of-dims>,{dims},<data-type>,<fixed-point-pos>", "s:D,L,s,d", objType, &m_num_of_dims, &m_num_of_dims, m_dims, data_type, &m_fixed_point_pos); m_data_type = ovxName2Enum(data_type); if (isVirtual) { m_tensor = vxCreateVirtualTensor(graph, m_num_of_dims, m_dims, m_data_type, m_fixed_point_pos); } else { m_tensor = vxCreateTensor(context, m_num_of_dims, m_dims, m_data_type, m_fixed_point_pos); } } else if (!_strnicmp(desc, "tensor-from-roi:", 16)) { char objType[64], masterName[64]; ioParams = ScanParameters(desc, "tensor-from-view:<tensor>,<view>", "s:s,D,L,L", objType, masterName, &m_num_of_dims, &m_num_of_dims, m_start, &m_num_of_dims, m_end); auto itMaster = m_paramMap->find(masterName); if (itMaster == m_paramMap->end()) ReportError("ERROR: tensor [%s] doesn't exist for %s\n", masterName, desc); vx_tensor masterTensor = (vx_tensor)itMaster->second->GetVxObject(); m_tensor = vxCreateTensorFromView(masterTensor, m_num_of_dims, m_start, m_end); } else if (!_strnicmp(desc, "tensor-from-handle:", 19)) { char objType[64], data_type[64], memory_type_str[64]; ioParams = ScanParameters(desc, "tensor-from-handle:<num-of-dims>,{dims},<data-type>,<fixed-point-pos>,{strides},<num-handles>,<memory-type>", "s:D,L,s,d,L,D,s", objType, &m_num_of_dims, &m_num_of_dims, m_dims, data_type, &m_fixed_point_pos, &m_num_of_dims, m_stride, &m_num_handles, memory_type_str); if(m_num_handles > MAX_BUFFER_HANDLES) ReportError("ERROR: num-handles is out of range: " VX_FMT_SIZE " (must be less than %d)\n", m_num_handles, MAX_BUFFER_HANDLES); m_data_type = ovxName2Enum(data_type); vx_uint64 memory_type = 0; if (GetScalarValueFromString(VX_TYPE_ENUM, memory_type_str, &memory_type) < 0) ReportError("ERROR: invalid memory type enum: %s\n", memory_type_str); m_memory_type = (vx_enum)memory_type; memset(m_memory_handle, 0, sizeof(m_memory_handle)); if (m_memory_type == VX_MEMORY_TYPE_HOST) { // allocate all handles on host for (vx_size active_handle = 0; active_handle < m_num_handles; active_handle++) { vx_size size = m_dims[m_num_of_dims-1] * m_stride[m_num_of_dims-1]; m_memory_handle[active_handle] = malloc(size); if (!m_memory_handle[active_handle]) ReportError("ERROR: malloc(%d) failed\n", (int)size); } } #if ENABLE_OPENCL else if (m_memory_type == VX_MEMORY_TYPE_OPENCL) { // allocate all handles on opencl cl_context opencl_context = nullptr; vx_status status = vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &opencl_context, sizeof(opencl_context)); if (status) ReportError("ERROR: vxQueryContext(*,VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT,...) failed (%d)\n", status); for (vx_size active_handle = 0; active_handle < m_num_handles; active_handle++) { vx_size size = m_dims[m_num_of_dims-1] * m_stride[m_num_of_dims-1]; cl_int err = CL_SUCCESS; m_memory_handle[active_handle] = clCreateBuffer(opencl_context, CL_MEM_READ_WRITE, size, NULL, &err); if (!m_memory_handle[active_handle] || err) ReportError("ERROR: clCreateBuffer(*,CL_MEM_READ_WRITE,%d,NULL,*) failed (%d)\n", (int)size, err); } } #endif else ReportError("ERROR: invalid memory-type enum: %s\n", memory_type_str); m_active_handle = 0; m_tensor = vxCreateTensorFromHandle(context, m_num_of_dims, m_dims, m_data_type, m_fixed_point_pos, m_stride, m_memory_handle[m_active_handle], m_memory_type); } else ReportError("ERROR: unsupported tensor type: %s\n", desc); vx_status ovxStatus = vxGetStatus((vx_reference)m_tensor); if (ovxStatus != VX_SUCCESS){ printf("ERROR: tensor creation failed => %d (%s)\n", ovxStatus, ovxEnum2Name(ovxStatus)); if (m_tensor) vxReleaseTensor(&m_tensor); throw - 1; } m_vxObjRef = (vx_reference)m_tensor; // io initialize return InitializeIO(context, graph, m_vxObjRef, ioParams); }
static vx_status VX_CALLBACK vxHalfscaleGaussianInitializer(vx_node node, const vx_reference *parameters, vx_uint32 num) { vx_status status = VX_ERROR_INVALID_PARAMETERS; if (num == 3) { vx_image input = (vx_image)parameters[0]; vx_image output = (vx_image)parameters[1]; vx_int32 kernel_size = 3; vx_convolution convolution = 0; vx_context context = vxGetContext((vx_reference)node); vx_graph graph = vxCreateGraph(context); if (vxGetStatus((vx_reference)graph) == VX_SUCCESS) { vx_uint32 i; /* We have a child-graph; we want to make sure the parent graph is recognized as a valid scope for sake of virtual image parameters. */ graph->parentGraph = node->graph; vxReadScalarValue((vx_scalar)parameters[2], &kernel_size); if (kernel_size == 3 || kernel_size == 5) { if (kernel_size == 5) { convolution = vxCreateGaussian5x5Convolution(context); } if (kernel_size == 3 || convolution) { vx_image virt = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_U8); vx_node nodes[] = { kernel_size == 3 ? vxGaussian3x3Node(graph, input, virt) : vxConvolveNode(graph, input, convolution, virt), vxScaleImageNode(graph, virt, output, VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR), }; vx_border_mode_t borders; vxQueryNode(node, VX_NODE_ATTRIBUTE_BORDER_MODE, &borders, sizeof(borders)); for (i = 0; i < dimof(nodes); i++) { vxSetNodeAttribute(nodes[i], VX_NODE_ATTRIBUTE_BORDER_MODE, &borders, sizeof(borders)); } status = VX_SUCCESS; status |= vxAddParameterToGraphByIndex(graph, nodes[0], 0); /* input image */ status |= vxAddParameterToGraphByIndex(graph, nodes[1], 1); /* output image */ status |= vxAddParameterToGraphByIndex(graph, node, 2); /* gradient size - refer to self to quiet sub-graph validator */ status |= vxVerifyGraph(graph); /* release our references, the graph will hold it's own */ for (i = 0; i < dimof(nodes); i++) { vxReleaseNode(&nodes[i]); } if (convolution) vxReleaseConvolution(&convolution); vxReleaseImage(&virt); status |= vxSetChildGraphOfNode(node, graph); } } vxReleaseGraph(&graph); } } return status; }
static vx_status VX_CALLBACK vxMinMaxLocOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr) { vx_status status = VX_ERROR_INVALID_PARAMETERS; if ((index == 1) || (index == 2)) { vx_parameter param = vxGetParameterByIndex(node, 0); if (vxGetStatus((vx_reference)param) == VX_SUCCESS) { vx_image input = 0; vxQueryParameter(param, VX_PARAMETER_REF, &input, sizeof(input)); if (input) { vx_df_image format; vx_enum type = VX_TYPE_INVALID; vxQueryImage(input, VX_IMAGE_FORMAT, &format, sizeof(format)); switch (format) { case VX_DF_IMAGE_U8: type = VX_TYPE_UINT8; break; case VX_DF_IMAGE_U16: type = VX_TYPE_UINT16; break; case VX_DF_IMAGE_U32: type = VX_TYPE_UINT32; break; case VX_DF_IMAGE_S16: type = VX_TYPE_INT16; break; case VX_DF_IMAGE_S32: type = VX_TYPE_INT32; break; default: type = VX_TYPE_INVALID; break; } if (type != VX_TYPE_INVALID) { status = VX_SUCCESS; ptr->type = VX_TYPE_SCALAR; ptr->dim.scalar.type = type; } else { status = VX_ERROR_INVALID_TYPE; } vxReleaseImage(&input); } vxReleaseParameter(¶m); } } if ((index == 3) || (index == 4)) { /* nothing to check here */ ptr->dim.array.item_type = VX_TYPE_COORDINATES2D; ptr->dim.array.capacity = 1; status = VX_SUCCESS; } if ((index == 5) || (index == 6)) { ptr->dim.scalar.type = VX_TYPE_UINT32; status = VX_SUCCESS; } return status; }
int main(int argc, char *argv[]) { vx_status status = VX_FAILURE; vx_context context = vxCreateContext(); if (argc < 2) { usage(argv[0]); goto relCtx; } vx_char *srcfilename = argv[1]; printf("src img: %s\n", srcfilename); FILE *fp = fopen(srcfilename, "r"); if (!fp) { goto relCtx; } char pgmstr[1024]; unsigned int n; n = fread(pgmstr, 1, sizeof(pgmstr), fp); if (n != sizeof(pgmstr)) { goto relClose; } const char delim = '\n'; const char *token = NULL; unsigned int width, height; // PGM P5 magic string token = strtok(pgmstr, &delim); // PGM author token = strtok(NULL, &delim); // PGM image size token = strtok(NULL, &delim); sscanf(token, "%u %u", &width, &height); printf("width:%u height:%u\n", width, height); status = vxGetStatus((vx_reference)context); if (status != VX_SUCCESS) { fprintf(stderr, "error: vxCreateContext\n"); goto relClose; } vx_rectangle_t rect = {1, 1, width + 1, height + 1}; vx_uint32 i = 0; vx_image images[] = { vxCreateImage(context, width + 2, height + 2, VX_DF_IMAGE_U8), // 0:input vxCreateImageFromROI(images[0], &rect), // 1:ROI input vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // 2:box vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // 3:gaussian vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // 4:alpha vxCreateImage(context, width, height, VX_DF_IMAGE_S16),// 5:add }; vx_float32 a = 0.5f; vx_scalar alpha = vxCreateScalar(context, VX_TYPE_FLOAT32, &a); status |= vxLoadKernels(context, "openvx-tiling"); status |= vxLoadKernels(context, "openvx-debug"); if (status != VX_SUCCESS) { fprintf(stderr, "error: vxLoadKernels %d\n", status); goto relImg; } vx_graph graph = vxCreateGraph(context); status = vxGetStatus((vx_reference)context); if (status != VX_SUCCESS) { fprintf(stderr, "error: vxGetStatus\n"); goto relKern; } ax_node_t axnodes[] = { { vxFReadImageNode(graph, srcfilename, images[1]), "Read" }, { vxTilingBoxNode(graph, images[1], images[2], 5, 5), "Box" }, { vxFWriteImageNode(graph, images[2], "ot_box.pgm"), "Write" }, { vxTilingGaussianNode(graph, images[1], images[3]), "Gaussian" }, { vxFWriteImageNode(graph, images[3], "ot_gauss.pgm"), "Write" }, { vxTilingAlphaNode(graph, images[1], alpha, images[4]), "Alpha" }, { vxFWriteImageNode(graph, images[4], "ot_alpha.pgm"), "Write" }, { vxTilingAddNode(graph, images[1], images[4], images[5]), "Add" }, { vxFWriteImageNode(graph, images[5], "ot_add.pgm"), "Write" }, }; for (i = 0; i < dimof(axnodes); i++) { if (axnodes[i].node == 0) { fprintf(stderr, "error: Failed to create node[%u]\n", i); status = VX_ERROR_INVALID_NODE; goto relNod; } } status = vxVerifyGraph(graph); if (status != VX_SUCCESS) { fprintf(stderr, "error: vxVerifyGraph %d\n", status); goto relNod; } status = vxProcessGraph(graph); if (status != VX_SUCCESS) { fprintf(stderr, "error: vxProcessGraph %d\n", status); goto relNod; } // perf timings vx_perf_t perf_node; vx_perf_t perf_graph; vxQueryGraph(graph, VX_GRAPH_ATTRIBUTE_PERFORMANCE, &perf_graph, sizeof(perf_graph)); axPrintPerf("Graph", &perf_graph); for (i = 0; i < dimof(axnodes); ++i) { vxQueryNode(axnodes[i].node, VX_NODE_ATTRIBUTE_PERFORMANCE, &perf_node, sizeof(perf_node)); axPrintPerf(axnodes[i].name, &perf_node); } relNod: for (i = 0; i < dimof(axnodes); i++) { vxReleaseNode(&axnodes[i].node); } vxReleaseGraph(&graph); relKern: relImg: for (i = 0; i < dimof(images); i++) { vxReleaseImage(&images[i]); } relClose: fclose(fp); relCtx: vxReleaseContext(&context); printf("%s::main() returns = %d\n", argv[0], status); return (int)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 vxAddSubtractOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr) { vx_status status = VX_ERROR_INVALID_PARAMETERS; if (index == 3) { /* * We need to look at both input images, but only for the format: * if either is S16 or the output type is not U8, then it's S16. * The geometry of the output image is copied from the first parameter: * the input images are known to match from input parameters validation. */ vx_parameter param[] = { vxGetParameterByIndex(node, 0), vxGetParameterByIndex(node, 1), vxGetParameterByIndex(node, index), }; if ((vxGetStatus((vx_reference)param[0]) == VX_SUCCESS) && (vxGetStatus((vx_reference)param[1]) == VX_SUCCESS) && (vxGetStatus((vx_reference)param[2]) == VX_SUCCESS)) { vx_image images[3]; vxQueryParameter(param[0], VX_PARAMETER_REF, &images[0], sizeof(images[0])); vxQueryParameter(param[1], VX_PARAMETER_REF, &images[1], sizeof(images[1])); vxQueryParameter(param[2], VX_PARAMETER_REF, &images[2], sizeof(images[2])); if (images[0] && images[1] && images[2]) { vx_uint32 width = 0, height = 0; vx_df_image informat[2] = {VX_DF_IMAGE_VIRT, VX_DF_IMAGE_VIRT}; vx_df_image outformat = VX_DF_IMAGE_VIRT; /* * When passing on the geometry to the output image, we only look at * image 0, as both input images are verified to match, at input * validation. */ vxQueryImage(images[0], VX_IMAGE_WIDTH, &width, sizeof(width)); vxQueryImage(images[0], VX_IMAGE_HEIGHT, &height, sizeof(height)); vxQueryImage(images[0], VX_IMAGE_FORMAT, &informat[0], sizeof(informat[0])); vxQueryImage(images[1], VX_IMAGE_FORMAT, &informat[1], sizeof(informat[1])); vxQueryImage(images[2], VX_IMAGE_FORMAT, &outformat, sizeof(outformat)); if (informat[0] == VX_DF_IMAGE_U8 && informat[1] == VX_DF_IMAGE_U8 && outformat == VX_DF_IMAGE_U8) { status = VX_SUCCESS; } else { outformat = VX_DF_IMAGE_S16; status = VX_SUCCESS; } ptr->type = VX_TYPE_IMAGE; ptr->dim.image.format = outformat; ptr->dim.image.width = width; ptr->dim.image.height = height; vxReleaseImage(&images[0]); vxReleaseImage(&images[1]); vxReleaseImage(&images[2]); } vxReleaseParameter(¶m[0]); vxReleaseParameter(¶m[1]); vxReleaseParameter(¶m[2]); } } return status; }
int main(int argc, char *argv[]) { vx_status status = VX_SUCCESS; vx_context context = vxCreateContext(); if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_char implementation[VX_MAX_IMPLEMENTATION_NAME]; vx_char *extensions = NULL; vx_int32 m, modules = 0; vx_uint32 k, kernels = 0; vx_uint32 p, parameters = 0; vx_uint32 a = 0; vx_uint16 vendor, version; vx_size size = 0; vx_kernel_info_t *table = NULL; // take each arg as a module name to load for (m = 1; m < argc; m++) { if (vxLoadKernels(context, argv[m]) != VX_SUCCESS) printf("Failed to load module %s\n", argv[m]); else printf("Loaded module %s\n", argv[m]); } vxPrintAllLog(context); vxRegisterHelperAsLogReader(context); vxQueryContext(context, VX_CONTEXT_VENDOR_ID, &vendor, sizeof(vendor)); vxQueryContext(context, VX_CONTEXT_VERSION, &version, sizeof(version)); vxQueryContext(context, VX_CONTEXT_IMPLEMENTATION, implementation, sizeof(implementation)); vxQueryContext(context, VX_CONTEXT_MODULES, &modules, sizeof(modules)); vxQueryContext(context, VX_CONTEXT_EXTENSIONS_SIZE, &size, sizeof(size)); printf("implementation=%s (%02x:%02x) has %u modules\n", implementation, vendor, version, modules); extensions = malloc(size); if (extensions) { vx_char *line = extensions, *token = NULL; vxQueryContext(context, VX_CONTEXT_EXTENSIONS, extensions, size); do { token = strtok(line, " "); if (token) printf("extension: %s\n", token); line = NULL; } while (token); free(extensions); } status = vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &kernels, sizeof(kernels)); if (status != VX_SUCCESS) goto exit; printf("There are %u kernels\n", kernels); size = kernels * sizeof(vx_kernel_info_t); table = malloc(size); status = vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNEL_TABLE, table, size); for (k = 0; k < kernels && table != NULL && status == VX_SUCCESS; k++) { vx_kernel kernel = vxGetKernelByEnum(context, table[k].enumeration); if (kernel && vxGetStatus((vx_reference)kernel) == VX_SUCCESS) { status = vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, ¶meters, sizeof(parameters)); printf("\t\tkernel[%u]=%s has %u parameters (%d)\n", table[k].enumeration, table[k].name, parameters, status); for (p = 0; p < parameters; p++) { vx_parameter parameter = vxGetKernelParameterByIndex(kernel, p); vx_enum type = VX_TYPE_INVALID, dir = VX_INPUT; vx_uint32 tIdx, dIdx; status = VX_SUCCESS; status |= vxQueryParameter(parameter, VX_PARAMETER_TYPE, &type, sizeof(type)); status |= vxQueryParameter(parameter, VX_PARAMETER_DIRECTION, &dir, sizeof(dir)); for (tIdx = 0; tIdx < dimof(parameter_names); tIdx++) if (parameter_names[tIdx].tenum == type) break; for (dIdx = 0; dIdx < dimof(direction_names); dIdx++) if (direction_names[dIdx].tenum == dir) break; if (status == VX_SUCCESS) printf("\t\t\tparameter[%u] type:%s dir:%s\n", p, parameter_names[tIdx].name, direction_names[dIdx].name); vxReleaseParameter(¶meter); } for (a = 0; a < dimof(attribute_names); a++) { switch (attribute_names[a].type) { case VX_TYPE_SIZE: { vx_size value = 0; if (VX_SUCCESS == vxQueryKernel(kernel, attribute_names[a].tenum, &value, sizeof(value))) printf("\t\t\tattribute[%u] %s = "VX_FMT_SIZE"\n", attribute_names[a].tenum & VX_ATTRIBUTE_ID_MASK, attribute_names[a].name, value); break; } case VX_TYPE_UINT32: { vx_uint32 value = 0; if (VX_SUCCESS == vxQueryKernel(kernel, attribute_names[a].tenum, &value, sizeof(value))) printf("\t\t\tattribute[%u] %s = %u\n", attribute_names[a].tenum & VX_ATTRIBUTE_ID_MASK, attribute_names[a].name, value); break; } default: break; } } vxReleaseKernel(&kernel); } else { printf("ERROR: kernel %s is invalid (%d) !\n", table[k].name, status); } } for (m = 1; m < argc; m++) { if (vxUnloadKernels(context, argv[m]) != VX_SUCCESS) printf("Failed to unload module %s\n", argv[m]); else printf("Unloaded module %s\n", argv[m]); } exit: if (table) free(table); vxReleaseContext(&context); } return 0; }
/*! \brief The graph factory example. * \ingroup group_example */ int main(int argc, char *argv[]) { vx_status status = VX_SUCCESS; vx_context context = vxCreateContext(); if (vxGetStatus((vx_reference)context) == VX_SUCCESS) { vx_image images[] = { vxCreateImage(context, 640, 480, VX_DF_IMAGE_U8), vxCreateImage(context, 640, 480, VX_DF_IMAGE_S16), }; vx_graph graph = vxGraphFactory(context, VX_GRAPH_FACTORY_EDGE); if (vxGetStatus((vx_reference)graph) == VX_SUCCESS) { vx_uint32 p, num = 0; status |= vxQueryGraph(graph, VX_GRAPH_ATTRIBUTE_NUMPARAMETERS, &num, sizeof(num)); if (status == VX_SUCCESS) { printf("There are %u parameters to this graph!\n", num); for (p = 0; p < num; p++) { vx_parameter param = vxGetGraphParameterByIndex(graph, p); if (param) { vx_enum dir = 0; vx_enum type = 0; status |= vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_DIRECTION, &dir, sizeof(dir)); status |= vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_TYPE, &type, sizeof(type)); printf("graph.parameter[%u] dir:%d type:%08x\n", p, dir, type); vxReleaseParameter(¶m); } else { printf("Invalid parameter retrieved from graph!\n"); } } status |= vxSetGraphParameterByIndex(graph, 0, (vx_reference)images[0]); status |= vxSetGraphParameterByIndex(graph, 1, (vx_reference)images[1]); } status |= vxVerifyGraph(graph); if (status == VX_SUCCESS) { status = vxProcessGraph(graph); if (status == VX_SUCCESS) { printf("Ran Graph!\n"); } } vxReleaseGraph(&graph); } else { printf("Failed to create graph!\n"); } vxReleaseContext(&context); } else { printf("failed to create context!\n"); } return status; }