VX_API_ENTRY vx_status VX_API_CALL vxAccessDistribution(vx_distribution distribution, void **ptr, vx_enum usage)
{
vx_status status = VX_FAILURE;
if ((vxIsValidSpecificReference(&distribution->base, VX_TYPE_DISTRIBUTION) == vx_true_e) &&
(vxAllocateMemory(distribution->base.context, &distribution->memory) == vx_true_e))
{
if (ptr != NULL)
{
vxSemWait(&distribution->base.lock);
{
vx_size size = vxComputeMemorySize(&distribution->memory, 0);
vxPrintMemory(&distribution->memory);
if (*ptr == NULL)
{
*ptr = distribution->memory.ptrs[0];
}
else if (*ptr != NULL)
{
memcpy(*ptr, distribution->memory.ptrs[0], size);
}
}
vxSemPost(&distribution->base.lock);
vxReadFromReference(&distribution->base);
}
vxIncrementReference(&distribution->base, VX_EXTERNAL);
status = VX_SUCCESS;
}
else
{
VX_PRINT(VX_ZONE_ERROR, "Not a valid object!\n");
}
return status;
}
vx_status vxAccessConvolutionCoefficients(vx_convolution conv, vx_int16 *array)
{
vx_convolution_t *convolution = (vx_convolution_t *)conv;
vx_status status = VX_ERROR_INVALID_REFERENCE;
if ((vxIsValidSpecificReference(&convolution->base.base, VX_TYPE_CONVOLUTION) == vx_true_e) &&
(vxAllocateMemory(convolution->base.base.context, &convolution->base.memory) == vx_true_e))
{
vxSemWait(&convolution->base.base.lock);
if (array)
{
vx_size size = convolution->base.memory.strides[0][1] *
convolution->base.memory.dims[0][1];
memcpy(array, convolution->base.memory.ptrs[0], size);
}
vxSemPost(&convolution->base.base.lock);
vxReadFromReference(&convolution->base.base);
vxIncrementReference(&convolution->base.base);
status = VX_SUCCESS;
}
return status;
}
VX_API_ENTRY vx_status VX_API_CALL vxAccessScalarValue(vx_scalar scalar, void *ptr)
{
vx_status status = VX_SUCCESS;
if (vxIsValidSpecificReference(&scalar->base,VX_TYPE_SCALAR) == vx_false_e)
return VX_ERROR_INVALID_REFERENCE;
if (ptr == NULL)
return VX_ERROR_INVALID_PARAMETERS;
vxSemWait(&scalar->base.lock);
vxPrintScalarValue(scalar);
switch (scalar->data_type)
{
case VX_TYPE_CHAR:
*(vx_char *)ptr = scalar->data.chr;
break;
case VX_TYPE_INT8:
*(vx_int8 *)ptr = scalar->data.s08;
break;
case VX_TYPE_UINT8:
*(vx_uint8 *)ptr = scalar->data.u08;
break;
case VX_TYPE_INT16:
*(vx_int16 *)ptr = scalar->data.s16;
break;
case VX_TYPE_UINT16:
*(vx_uint16 *)ptr = scalar->data.u16;
break;
case VX_TYPE_INT32:
*(vx_int32 *)ptr = scalar->data.s32;
break;
case VX_TYPE_UINT32:
*(vx_uint32 *)ptr = scalar->data.u32;
break;
case VX_TYPE_INT64:
*(vx_int64 *)ptr = scalar->data.s64;
break;
case VX_TYPE_UINT64:
*(vx_uint64 *)ptr = scalar->data.u64;
break;
#if OVX_SUPPORT_HALF_FLOAT
case VX_TYPE_FLOAT16:
*(vx_float16 *)ptr = scalar->data.f16;
break;
#endif
case VX_TYPE_FLOAT32:
*(vx_float32 *)ptr = scalar->data.f32;
break;
case VX_TYPE_FLOAT64:
*(vx_float64 *)ptr = scalar->data.f64;
break;
case VX_TYPE_DF_IMAGE:
*(vx_df_image *)ptr = scalar->data.fcc;
break;
case VX_TYPE_ENUM:
*(vx_enum *)ptr = scalar->data.enm;
break;
case VX_TYPE_SIZE:
*(vx_size *)ptr = scalar->data.size;
break;
case VX_TYPE_BOOL:
*(vx_bool *)ptr = scalar->data.boolean;
break;
default:
VX_PRINT(VX_ZONE_ERROR, "some case is not covered in %s\n", __FUNCTION__);
status = VX_ERROR_NOT_SUPPORTED;
break;
}
vxSemPost(&scalar->base.lock);
vxReadFromReference(&scalar->base);
return status;
}
vx_status vxQueryThreshold(vx_threshold t, vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
vx_threshold_t *thresh = (vx_threshold_t *)t;
if (vxIsValidSpecificReference(&thresh->base, VX_TYPE_THRESHOLD) == vx_true_e)
{
switch (attribute)
{
case VX_THRESHOLD_ATTRIBUTE_VALUE:
if (VX_CHECK_PARAM(ptr, size, vx_uint8, 0x0) &&
(thresh->type == VX_THRESHOLD_TYPE_BINARY))
{
*(vx_uint8 *)ptr = thresh->value;
vxReadFromReference(&thresh->base);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_THRESHOLD_ATTRIBUTE_LOWER:
if (VX_CHECK_PARAM(ptr, size, vx_uint8, 0x0) &&
(thresh->type == VX_THRESHOLD_TYPE_RANGE))
{
*(vx_uint8 *)ptr = thresh->lower;
vxReadFromReference(&thresh->base);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_THRESHOLD_ATTRIBUTE_UPPER:
if (VX_CHECK_PARAM(ptr, size, vx_uint8, 0x0) &&
(thresh->type == VX_THRESHOLD_TYPE_RANGE))
{
*(vx_uint8 *)ptr = thresh->upper;
vxReadFromReference(&thresh->base);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_THRESHOLD_ATTRIBUTE_TYPE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
{
*(vx_enum *)ptr = thresh->type;
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
}
else
{
status = VX_ERROR_INVALID_REFERENCE;
}
VX_PRINT(VX_ZONE_API, "return %d\n", status);
return status;
}
vx_status vxAccessArrayRangeInt(vx_array arr, vx_size start, vx_size end, vx_size *pStride, void **ptr, vx_enum usage)
{
vx_status status = VX_FAILURE;
/* bad parameters */
if ((usage < VX_READ_ONLY) || (VX_READ_AND_WRITE < usage) ||
(ptr == NULL) ||
(start >= end) || (end > arr->num_items))
{
return VX_ERROR_INVALID_PARAMETERS;
}
/* determine if virtual before checking for memory */
if (arr->base.is_virtual == vx_true_e)
{
if (arr->base.is_accessible == vx_false_e)
{
/* User tried to access a "virtual" array. */
VX_PRINT(VX_ZONE_ERROR, "Can not access a virtual array\n");
return VX_ERROR_OPTIMIZED_AWAY;
}
/* framework trying to access a virtual image, this is ok. */
}
/* verify has not run or will not run yet. this allows this API to "touch"
* the array to create it.
*/
if (vxAllocateArray(arr) == vx_false_e)
{
return VX_ERROR_NO_MEMORY;
}
/* POSSIBILITIES:
* 1.) !*ptr && RO == COPY-ON-READ (make ptr=alloc)
* 2.) !*ptr && WO == MAP
* 3.) !*ptr && RW == MAP
* 4.) *ptr && RO||RW == COPY (UNLESS MAP)
*/
/* MAP mode */
if (*ptr == NULL)
{
if ((usage == VX_WRITE_ONLY) || (usage == VX_READ_AND_WRITE))
{
/*-- MAP --*/
status = VX_ERROR_NO_RESOURCES;
/* lock the memory */
if(vxSemWait(&arr->memory.locks[0]) == vx_true_e)
{
vx_size offset = start * arr->item_size;
*ptr = &arr->memory.ptrs[0][offset];
if (usage != VX_WRITE_ONLY)
{
vxReadFromReference(&arr->base);
}
vxIncrementReference(&arr->base, VX_EXTERNAL);
status = VX_SUCCESS;
}
}
else
{
/*-- COPY-ON-READ --*/
vx_size size = ((end - start) * arr->item_size);
vx_uint32 a = 0u;
vx_size *stride_save = calloc(1, sizeof(vx_size));
*stride_save = arr->item_size;
if (vxAddAccessor(arr->base.context, size, usage, *ptr, &arr->base, &a, stride_save) == vx_true_e)
{
vx_size offset;
*ptr = arr->base.context->accessors[a].ptr;
offset = start * arr->item_size;
memcpy(*ptr, &arr->memory.ptrs[0][offset], size);
vxReadFromReference(&arr->base);
vxIncrementReference(&arr->base, VX_EXTERNAL);
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_NO_MEMORY;
vxAddLogEntry((vx_reference)arr, status, "Failed to allocate memory for COPY-ON-READ! Size="VX_FMT_SIZE"\n", size);
}
}
if ((status == VX_SUCCESS) && (pStride != NULL))
{
*pStride = arr->item_size;
}
}
/* COPY mode */
else
{
vx_size size = ((end - start) * arr->item_size);
vx_uint32 a = 0u;
vx_size *stride_save = calloc(1, sizeof(vx_size));
if (pStride == NULL) {
*stride_save = arr->item_size;
pStride = stride_save;
}
else {
*stride_save = *pStride;
}
if (vxAddAccessor(arr->base.context, size, usage, *ptr, &arr->base, &a, stride_save) == vx_true_e)
{
*ptr = arr->base.context->accessors[a].ptr;
status = VX_SUCCESS;
if ((usage == VX_WRITE_ONLY) || (usage == VX_READ_AND_WRITE))
{
if (vxSemWait(&arr->memory.locks[0]) == vx_false_e)
{
status = VX_ERROR_NO_RESOURCES;
}
}
if (status == VX_SUCCESS)
{
if (usage != VX_WRITE_ONLY)
{
int i;
vx_uint8 *pSrc, *pDest;
for (i = start, pDest = *ptr, pSrc = &arr->memory.ptrs[0][start * arr->item_size];
i < end;
i++, pDest += *pStride, pSrc += arr->item_size)
{
memcpy(pDest, pSrc, arr->item_size);
}
vxReadFromReference(&arr->base);
}
vxIncrementReference(&arr->base, VX_EXTERNAL);
}
}
else
{
status = VX_ERROR_NO_MEMORY;
vxAddLogEntry((vx_reference)arr, status, "Failed to allocate memory for COPY-ON-READ! Size="VX_FMT_SIZE"\n", size);
}
}
return status;
}
