VX_API_ENTRY vx_status VX_API_CALL vxReleaseReference(vx_reference *ref)
{
if(vxIsValidReference(*ref))
{
return vxReleaseReferenceInt((vx_reference *)ref, (*ref)->type, VX_EXTERNAL, NULL);
} else {
return VX_ERROR_INVALID_REFERENCE;
}
}
void vxDestructParameter(vx_reference ref)
{
vx_parameter param = (vx_parameter)ref;
if (param->node) {
if (vxIsValidSpecificReference(¶m->node->base, VX_TYPE_NODE) == vx_true_e)
{
vx_node node = (vx_node)param->node;
vxReleaseReferenceInt((vx_reference *)&node, VX_TYPE_NODE, VX_INTERNAL, NULL);
}
}
if (param->kernel) {
if (vxIsValidSpecificReference(¶m->kernel->base, VX_TYPE_KERNEL) == vx_true_e)
{
vx_kernel kernel = (vx_kernel)param->kernel;
vxReleaseReferenceInt((vx_reference *)&kernel, VX_TYPE_KERNEL, VX_INTERNAL, NULL);
}
}
}
void vxDestructPyramid(vx_reference ref)
{
vx_pyramid pyramid = (vx_pyramid)ref;
vx_uint32 i = 0;
for (i = 0; i < pyramid->numLevels; i++)
{
vxReleaseReferenceInt((vx_reference *)&pyramid->levels[i], VX_TYPE_IMAGE, VX_INTERNAL, NULL);
}
free(pyramid->levels);
}
void vxDestructImport(vx_reference ref) {
vx_uint32 i = 0;
vx_import import = (vx_import)ref;
for (i = 0; i < import->count; i++)
{
vxReleaseReferenceInt(&import->refs[i], import->refs[i]->type, VX_INTERNAL, NULL);
}
if (import->refs) {
free(import->refs);
}
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseScalar(vx_scalar *s)
{
return vxReleaseReferenceInt((vx_reference *)s, VX_TYPE_SCALAR, VX_EXTERNAL, NULL);
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseImport(vx_import *import)
{
return vxReleaseReferenceInt((vx_reference *)import, VX_TYPE_IMPORT, VX_EXTERNAL, NULL);
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseDistribution(vx_distribution *d)
{
return vxReleaseReferenceInt((vx_reference *)d, VX_TYPE_DISTRIBUTION, VX_EXTERNAL, &vxDestructDistribution);
}
vx_status vxReleaseDistributionInt(vx_distribution *distribution)
{
return vxReleaseReferenceInt((vx_reference *)distribution, VX_TYPE_DISTRIBUTION, VX_INTERNAL, &vxDestructDistribution);
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseParameter(vx_parameter *param)
{
return vxReleaseReferenceInt((vx_reference *)param, VX_TYPE_PARAMETER, VX_EXTERNAL, NULL);
}
void vxReleaseMetaFormat(vx_meta_format *pmeta)
{
vxReleaseReferenceInt((vx_reference *)pmeta, VX_TYPE_META_FORMAT, VX_EXTERNAL, NULL);
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseContext(vx_context *c)
{
vx_status status = VX_SUCCESS;
vx_context context = (c?*c:0);
vx_uint32 r,m,a;
vx_uint32 t;
if (c) *c = 0;
vxSemWait(&context_lock);
if (vxIsValidContext(context) == vx_true_e)
{
if (vxDecrementReference(&context->base, VX_EXTERNAL) == 0)
{
vxDestroyThreadpool(&context->workers);
context->proc.running = vx_false_e;
vxPopQueue(&context->proc.input);
vxJoinThread(context->proc.thread, NULL);
vxDeinitQueue(&context->proc.output);
vxDeinitQueue(&context->proc.input);
/* Deregister any log callbacks if there is any registered */
vxRegisterLogCallback(context, NULL, vx_false_e);
/*! \internal Garbage Collect All References */
/* Details:
* 1. This loop will warn of references which have not been released by the user.
* 2. It will close all internally opened error references.
* 3. It will close the external references, which in turn will internally
* close any internally dependent references that they reference, assuming the
* reference counting has been done properly in the framework.
* 4. This garbage collection must be done before the targets are released since some of
* these external references may have internal references to target kernels.
*/
for (r = 0; r < VX_INT_MAX_REF; r++)
{
vx_reference_t *ref = context->reftable[r];
/* Warnings should only come when users have not released all external references */
if (ref && ref->external_count > 0) {
VX_PRINT(VX_ZONE_WARNING,"Stale reference "VX_FMT_REF" of type %08x at external count %u, internal count %u\n",
ref, ref->type, ref->external_count, ref->internal_count);
}
/* These were internally opened during creation, so should internally close ERRORs */
if(ref && ref->type == VX_TYPE_ERROR) {
vxReleaseReferenceInt(&ref, ref->type, VX_INTERNAL, NULL);
}
/* Warning above so user can fix release external objects, but close here anyway */
while (ref && ref->external_count > 1) {
vxDecrementReference(ref, VX_EXTERNAL);
}
if (ref && ref->external_count > 0) {
vxReleaseReferenceInt(&ref, ref->type, VX_EXTERNAL, NULL);
}
}
for (m = 0; m < context->num_modules; m++)
{
if (context->modules[m].handle)
{
vxUnloadModule(context->modules[m].handle);
memset(context->modules[m].name, 0, sizeof(context->modules[m].name));
context->modules[m].handle = VX_MODULE_INIT;
}
}
/* de-initialize and unload each target */
for (t = 0u; t < context->num_targets; t++)
{
if (context->targets[t].enabled == vx_true_e)
{
context->targets[t].funcs.deinit(&context->targets[t]);
vxUnloadTarget(context, t, vx_true_e);
context->targets[t].enabled = vx_false_e;
}
}
/* Remove all outstanding accessors. */
for (a = 0; a < dimof(context->accessors); ++a)
if (context->accessors[a].used)
vxRemoveAccessor(context, a);
/* Check for outstanding mappings */
for (a = 0; a < dimof(context->memory_maps); ++a)
{
if (context->memory_maps[a].used)
{
VX_PRINT(VX_ZONE_ERROR, "Memory map %d not unmapped\n", a);
vxMemoryUnmap(context, a);
}
}
vxDestroySem(&context->memory_maps_lock);
/* By now, all external and internal references should be removed */
for (r = 0; r < VX_INT_MAX_REF; r++)
{
if(context->reftable[r])
VX_PRINT(VX_ZONE_ERROR,"Reference %d not removed\n", r);
}
#ifdef EXPERIMENTAL_USE_HEXAGON
remote_handle_close(tmp_ph);
#endif
/*! \internal wipe away the context memory first */
/* Normally destroy sem is part of release reference, but can't for context */
vxDestroySem(&((vx_reference )context)->lock);
memset(context, 0, sizeof(vx_context_t));
free((void *)context);
vxDestroySem(&global_lock);
vxSemPost(&context_lock);
vxDestroySem(&context_lock);
single_context = NULL;
return status;
}
else
{
VX_PRINT(VX_ZONE_WARNING, "Context still has %u holders\n", vxTotalReferenceCount(&context->base));
}
} else {
status = VX_ERROR_INVALID_REFERENCE;
}
vxSemPost(&context_lock);
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxReleasePyramid(vx_pyramid *pyr)
{
return vxReleaseReferenceInt((vx_reference *)pyr, VX_TYPE_PYRAMID, VX_EXTERNAL, NULL);
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseLUT(vx_lut *l)
{
return vxReleaseReferenceInt((vx_reference *)l, VX_TYPE_LUT, VX_EXTERNAL, NULL);
}
VX_API_ENTRY vx_status VX_API_CALL vxReleaseArray(vx_array *a)
{
/* NULL means standard destructor */
return vxReleaseReferenceInt((vx_reference_t **)a, VX_TYPE_ARRAY, VX_EXTERNAL, NULL);
}
