static VALUE Kernel_enum(VALUE self) { vx_kernel kernel = (vx_kernel)DATA_PTR(self); vx_enum kenum = VX_KERNEL_INVALID; vxQueryKernel(kernel, VX_QUERY_KERNEL_ENUM, (void *)&kenum, sizeof(kenum)); return INT2FIX(kenum); }
static VALUE Kernel_name(VALUE self) { vx_kernel kernel = (vx_kernel)DATA_PTR(self); const char name[VX_MAX_KERNEL_NAME]; vxQueryKernel(kernel, VX_QUERY_KERNEL_NAME, (void *)name, sizeof(name)); return rb_str_new2(name); }
void example_explore_parameters(vx_context context, vx_kernel kernel) { vx_uint32 p, numParams = 0; vx_graph graph = vxCreateGraph(context); vx_node node = vxCreateGenericNode(graph, kernel); vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, &numParams, sizeof(numParams)); for (p = 0; p < numParams; p++) { //! [Getting the ref] vx_parameter param = vxGetParameterByIndex(node, p); vx_reference ref; vxQueryParameter(param, VX_PARAMETER_REF, &ref, sizeof(ref)); //! [Getting the ref] if (ref) { //! [Getting the type] vx_enum type; vxQueryParameter(param, VX_PARAMETER_TYPE, &type, sizeof(type)); /* cast the ref to the correct vx_<type>. Atomics are now vx_scalar */ //! [Getting the type] } vxReleaseParameter(¶m); } vxReleaseNode(&node); vxReleaseGraph(&graph); }
static VALUE Kernel_params(VALUE self) { vx_uint32 numParams = 0; vx_kernel kernel = 0; vx_status status = VX_FAILURE; Check_Type(self, T_DATA); kernel = (vx_kernel)DATA_PTR(self); status = vxQueryKernel(kernel, VX_QUERY_KERNEL_NUMPARAMS, &numParams, sizeof(numParams)); REXT_PRINT("status = %d, numParams = %u\n", status, numParams); return INT2FIX(numParams); }
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; }