Gitiles
Code Review Sign In
LeafOS / LeafOS-Devices / android_hardware_samsung_slsi-linaro_exynos / c8caf0eed437997712c2f4dc577fa960eab9c91b / . / libvision / common / ExynosVisionImage.cpp
blob: a3826bc8fc85851e51bce412760c6b74880113c0 [file] [log] [blame]
/*
* Copyright (C) 2015, Samsung Electronics Co. LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "ExynosVisionImage"
#include <cutils/log.h>
#include <stdlib.h>
#include <VX/vx.h>
#include <VX/vx_khr_opencl.h>
#include "ExynosVisionGraph.h"
#include "ExynosVisionImage.h"
#include "ExynosVisionDelay.h"
namespace android {
static vx_bool isSupportedFourcc(vx_df_image code)
{
switch (code)
{
case VX_DF_IMAGE_RGB:
case VX_DF_IMAGE_RGBX:
case VX_DF_IMAGE_BGR:
case VX_DF_IMAGE_BGRX:
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
case VX_DF_IMAGE_UYVY:
case VX_DF_IMAGE_YUYV:
case VX_DF_IMAGE_IYUV:
case VX_DF_IMAGE_YUV4:
case VX_DF_IMAGE_U8:
case VX_DF_IMAGE_U16:
case VX_DF_IMAGE_S16:
case VX_DF_IMAGE_U32:
case VX_DF_IMAGE_S32:
case VX_DF_IMAGE_F32:
case VX_DF_IMAGE_VIRT:
return vx_true_e;
default:
VXLOGE("format 0x%08x is not supported\n", code);
return vx_false_e;
}
}
static vx_size vxSizeOfChannel(vx_df_image color)
{
vx_size size = 0ul;
if (isSupportedFourcc(color))
{
switch (color)
{
case VX_DF_IMAGE_S16:
case VX_DF_IMAGE_U16:
size = sizeof(vx_uint16);
break;
case VX_DF_IMAGE_U32:
case VX_DF_IMAGE_S32:
case VX_DF_IMAGE_F32:
size = sizeof(vx_uint32);
break;
default:
size = 1ul;
break;
}
}
return size;
}
static vx_bool vxIsOdd(vx_uint32 a)
{
if (a & 0x1)
return vx_true_e;
else
return vx_false_e;
}
static vx_bool vxIsValidDimensions(vx_uint32 width, vx_uint32 height, vx_df_image color)
{
if (vxIsOdd(width) && (color == VX_DF_IMAGE_UYVY || color == VX_DF_IMAGE_YUYV))
{
return vx_false_e;
}
else if ((vxIsOdd(width) || vxIsOdd(height)) &&
(color == VX_DF_IMAGE_IYUV || color == VX_DF_IMAGE_NV12 || color == VX_DF_IMAGE_NV21))
{
return vx_false_e;
}
return vx_true_e;
}
static vx_uint32 vxComputePatchOffset(vx_uint32 x, vx_uint32 y, const vx_imagepatch_addressing_t *addr)
{
return ((addr->stride_y * ((addr->scale_y * y)/VX_SCALE_UNITY)) +
(addr->stride_x * ((addr->scale_x * x)/VX_SCALE_UNITY)));
}
static vx_uint32 vxComputePatchRangeSize(vx_uint32 range, const vx_imagepatch_addressing_t *addr)
{
return (range * addr->stride_x * addr->scale_x) / VX_SCALE_UNITY;
}
vx_status
ExynosVisionImage::checkValidCreateImage(vx_uint32 width, vx_uint32 height, vx_df_image format)
{
vx_status status = VX_SUCCESS;
if ((width == 0) || (height == 0) ||
(isSupportedFourcc(format) == vx_false_e) || (format == VX_DF_IMAGE_VIRT))
status = VX_ERROR_INVALID_PARAMETERS;
return status;
}
vx_uint32
ExynosVisionImage::computePlaneOffset(vx_uint32 x, vx_uint32 y, vx_uint32 p)
{
vx_uint32 mem_index = m_plane_loc[p].memory_index;
vx_uint32 subplane_index = m_plane_loc[p].subplane_index;
/* parameter is a logical coordinate, not memory coordinate. For example, all planes of NV12 have a same logical coordinate range. */
return (((y * m_memory.strides[mem_index][subplane_index][VX_DIM_Y]) / m_scale[p][VX_DIM_Y]) +
((x * m_memory.strides[mem_index][subplane_index][VX_DIM_X]) / m_scale[p][VX_DIM_X]));
}
vx_uint32
ExynosVisionImage::computePlaneRangeSize(vx_uint32 range, vx_uint32 p)
{
vx_uint32 mem_index = m_plane_loc[p].memory_index;
vx_uint32 subplane_index = m_plane_loc[p].subplane_index;
return (range * m_memory.strides[mem_index][subplane_index][VX_DIM_X]) / m_scale[p][VX_DIM_X];
}
void*
ExynosVisionImage::formatImagePatchAddress1d(void *ptr, vx_uint32 index, const vx_imagepatch_addressing_t *addr)
{
vx_uint8 *new_ptr = NULL;
if (ptr && index < addr->dim_x*addr->dim_y) {
vx_uint32 x = index % addr->dim_x;
vx_uint32 y = index / addr->dim_x;
vx_uint32 offset = vxComputePatchOffset(x, y, addr);
new_ptr = (vx_uint8 *)ptr;
new_ptr = &new_ptr[offset];
}
return new_ptr;
}
void*
ExynosVisionImage::formatImagePatchAddress2d(void *ptr, vx_uint32 x, vx_uint32 y, const vx_imagepatch_addressing_t *addr)
{
vx_uint8 *new_ptr = NULL;
if (ptr && x < addr->dim_x && y < addr->dim_y) {
vx_uint32 offset = vxComputePatchOffset(x, y, addr);
new_ptr = (vx_uint8 *)ptr;
new_ptr = &new_ptr[offset];
}
return new_ptr;
}
vx_bool
ExynosVisionImage::checkImageDependenct(ExynosVisionImage *image1, ExynosVisionImage *image2)
{
vx_rectangle_t rr, rw;
memset(&rr, 0x0, sizeof(vx_rectangle_t));
memset(&rw, 0x0, sizeof(vx_rectangle_t));
ExynosVisionImage *imgr = image1->locateROI(&rr);
ExynosVisionImage *imgw = image2->locateROI(&rw);
if (imgr == imgw) {
/* check for ROI intersection */
if (rr.start_x < rw.end_x && rr.end_x > rw.start_x && rr.start_y < rw.end_y && rr.end_y > rw.start_y) {
return vx_true_e;
}
}
return vx_false_e;
}
void
ExynosVisionImage::initMemory(vx_uint32 plane_index,
vx_uint32 mem_index,
vx_uint32 subplane_index,
vx_uint32 channels,
vx_uint32 width,
vx_uint32 height)
{
m_plane_loc[plane_index].memory_index = mem_index;
m_plane_loc[plane_index].subplane_index= subplane_index;
m_memory.dims[mem_index][subplane_index][VX_DIM_C] = channels;
m_memory.dims[mem_index][subplane_index][VX_DIM_X] = width;
m_memory.dims[mem_index][subplane_index][VX_DIM_Y] = height;
}
void
ExynosVisionImage::initPlane(vx_uint32 index,
vx_uint32 channels,
vx_uint32 coordinate_scale,
vx_uint32 width,
vx_uint32 height)
{
m_scale[index][VX_DIM_C] = 1;
m_scale[index][VX_DIM_X] = coordinate_scale;
m_scale[index][VX_DIM_Y] = coordinate_scale;
m_bounds[index][VX_DIM_C][VX_BOUND_START] = 0;
m_bounds[index][VX_DIM_C][VX_BOUND_END] = channels;
m_bounds[index][VX_DIM_X][VX_BOUND_START] = 0;
m_bounds[index][VX_DIM_X][VX_BOUND_END] = width;
m_bounds[index][VX_DIM_Y][VX_BOUND_START] = 0;
m_bounds[index][VX_DIM_Y][VX_BOUND_END] = height;
}
void
ExynosVisionImage::initImage(vx_uint32 width, vx_uint32 height, vx_df_image format)
{
vx_uint32 element_size = (vx_uint32)vxSizeOfChannel(format);
m_width = width;
m_height = height;
m_format = format;
m_range = VX_CHANNEL_RANGE_FULL;
m_import_type = VX_IMPORT_TYPE_NONE;
/* when an image is allocated, it's not valid until it's been written to.
* this inverted rectangle is needed for the initial write case.
*/
m_region.start_x = width;
m_region.start_y = height;
m_region.end_x = 0;
m_region.end_y = 0;
switch (format)
{
case VX_DF_IMAGE_U8:
case VX_DF_IMAGE_U16:
case VX_DF_IMAGE_U32:
case VX_DF_IMAGE_S16:
case VX_DF_IMAGE_S32:
case VX_DF_IMAGE_F32:
m_space = VX_COLOR_SPACE_NONE;
break;
default:
m_space = VX_COLOR_SPACE_DEFAULT;
break;
}
m_memory.element_byte_size = element_size;
switch (m_format) {
case VX_DF_IMAGE_VIRT:
break;
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
m_planes = 2;
initPlane(VX_PLANE_0, 1, 1, m_width, m_height);
initPlane(VX_PLANE_1, 2, 2, m_width, m_height);
if (m_continuous) {
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 2;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 1, m_width, m_height);
initMemory(VX_PLANE_1, VX_MEM_0, 1, 2, m_width/2, m_height/2);
} else {
m_memory.memory_num = 2;
m_memory.subplane_num[VX_MEM_0] = 1;
m_memory.subplane_num[VX_MEM_1] = 1;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 1, m_width, m_height);
initMemory(VX_PLANE_1, VX_MEM_1, 0, 2, m_width/2, m_height/2);
}
break;
case VX_DF_IMAGE_RGB:
case VX_DF_IMAGE_BGR:
m_planes = 1;
initPlane(VX_PLANE_0, 3, 1, m_width, m_height);
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 1;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 3, m_width, m_height);
break;
case VX_DF_IMAGE_RGBX:
case VX_DF_IMAGE_BGRX:
m_planes = 1;
initPlane(VX_PLANE_0, 4, 1, m_width, m_height);
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 1;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 4, m_width, m_height);
break;
case VX_DF_IMAGE_UYVY:
case VX_DF_IMAGE_YUYV:
m_planes = 1;
initPlane(VX_PLANE_0, 2, 1, m_width, m_height);
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 1;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 2, m_width, m_height);
break;
case VX_DF_IMAGE_YUV4:
m_planes = 3;
initPlane(VX_PLANE_0, 1, 1, m_width, m_height);
initPlane(VX_PLANE_1, 1, 1, m_width, m_height);
initPlane(VX_PLANE_2, 1, 1, m_width, m_height);
if (m_continuous) {
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 3;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 1, m_width, m_height);
initMemory(VX_PLANE_1, VX_MEM_0, 1, 1, m_width, m_height);
initMemory(VX_PLANE_2, VX_MEM_0, 2, 1, m_width, m_height);
} else {
m_memory.memory_num = 3;
m_memory.subplane_num[VX_MEM_0] = 1;
m_memory.subplane_num[VX_MEM_1] = 1;
m_memory.subplane_num[VX_MEM_2] = 1;
initMemory(0, VX_MEM_0, 0, 1, m_width, m_height);
initMemory(1, VX_MEM_1, 0, 1, m_width, m_height);
initMemory(2, VX_MEM_2, 0, 1, m_width, m_height);
}
break;
case VX_DF_IMAGE_IYUV:
m_planes = 3;
initPlane(VX_PLANE_0, 1, 1, m_width, m_height);
initPlane(VX_PLANE_1, 1, 2, m_width, m_height);
initPlane(VX_PLANE_2, 1, 2, m_width, m_height);
if (m_continuous) {
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 3;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 1, m_width, m_height);
initMemory(VX_PLANE_1, VX_MEM_0, 1, 1, m_width/2, m_height/2);
initMemory(VX_PLANE_2, VX_MEM_0, 2, 1, m_width/2, m_height/2);
} else {
m_memory.memory_num = 3;
m_memory.subplane_num[VX_MEM_0] = 1;
m_memory.subplane_num[VX_MEM_1] = 1;
m_memory.subplane_num[VX_MEM_2] = 1;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 1, m_width, m_height);
initMemory(VX_PLANE_1, VX_MEM_1, 0, 1, m_width/2, m_height/2);
initMemory(VX_PLANE_2, VX_MEM_2, 0, 1, m_width/2, m_height/2);
}
break;
case VX_DF_IMAGE_U8:
case VX_DF_IMAGE_U16:
case VX_DF_IMAGE_S16:
case VX_DF_IMAGE_U32:
case VX_DF_IMAGE_S32:
case VX_DF_IMAGE_F32:
m_planes = 1;
initPlane(VX_PLANE_0, 1, 1, m_width, m_height);
m_memory.memory_num = 1;
m_memory.subplane_num[VX_MEM_0] = 1;
initMemory(VX_PLANE_0, VX_MEM_0, 0, 1, m_width, m_height);
break;
default:
/*! should not get here unless there's a bug in the
* vxIsSupportedFourcc call.
*/
VXLOGE("Unsupported IMAGE FORMAT!!!");
break;
}
}
ExynosVisionImage::ExynosVisionImage(ExynosVisionContext *context, ExynosVisionReference *scope, vx_bool is_virtual)
: ExynosVisionDataReference(context, VX_TYPE_IMAGE, scope, vx_true_e, is_virtual)
{
m_res_mngr = NULL;
m_cur_res = NULL;
memset(&m_memory, 0x0, sizeof(m_memory));
m_width = 0;
m_height = 0;
m_format = 0;
m_planes = 0;
m_continuous = vx_false_e;
m_space = 0;
m_range = 0;
memset(&m_plane_loc, 0x0, sizeof(m_plane_loc));
memset(&m_scale, 0x0, sizeof(m_scale));
memset(&m_bounds, 0x0, sizeof(m_bounds));
m_constant = vx_false_e;
m_region.start_x = ~(0);
m_region.start_y = ~(0);
m_region.end_x = 0;
m_region.end_y = 0;
m_import_type = VX_IMPORT_TYPE_NONE;
#ifdef USE_OPENCL_KERNEL
m_cl_memory.allocated = vx_false_e;
#endif
}
ExynosVisionImage::~ExynosVisionImage()
{
/* do nothing */
}
void
ExynosVisionImage::operator=(const ExynosVisionImage& src_image)
{
m_width = src_image.m_width;
m_height = src_image.m_height;
m_format = src_image.m_format;
m_planes = src_image.m_planes;
m_continuous = src_image.m_continuous;
m_space = src_image.m_space;
m_range = src_image.m_range;
m_import_type = src_image.m_import_type;
memcpy(&m_plane_loc, &src_image.m_plane_loc, sizeof(m_plane_loc));
memcpy(&m_scale, &src_image.m_scale, sizeof(m_scale));
memcpy(&m_bounds, &src_image.m_bounds, sizeof(m_bounds));
m_memory.memory_num = src_image.m_memory.memory_num;
memcpy(&m_memory.subplane_num, &src_image.m_memory.subplane_num, sizeof(m_memory.subplane_num));
memcpy(&m_memory.dims, &src_image.m_memory.dims, sizeof(m_memory.dims));
m_memory.element_byte_size = src_image.m_memory.element_byte_size;
}
vx_status
ExynosVisionImage::init(vx_uint32 width, vx_uint32 height, vx_df_image color)
{
if (isSupportedFourcc(color) == vx_true_e) {
if (vxIsValidDimensions(width, height, color) == vx_true_e) {
initImage(width, height, color);
} else {
VXLOGE("Requested Image Dimensions are invalid!");
getContext()->addLogEntry(this, VX_ERROR_INVALID_DIMENSION, "Requested Image Dimensions was invalid!\n");
return VX_ERROR_INVALID_DIMENSION;
}
} else {
VXLOGE("Requested Image Format was invalid!");
getContext()->addLogEntry(this, VX_ERROR_INVALID_FORMAT, "Requested Image Format was invalid!\n");
return VX_ERROR_INVALID_FORMAT;
}
return VX_SUCCESS;
}
vx_status
ExynosVisionImage::destroy(void)
{
vx_status status = VX_SUCCESS;
m_cur_res = NULL;
status = freeMemory_T<image_resource_t>(&m_res_mngr, &m_res_list);
if (status != VX_SUCCESS)
VXLOGE("free memory fails at %s, err:%d", getName(), status);
return status;
}
vx_status
ExynosVisionImage::queryImage(vx_enum attribute, void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
switch (attribute) {
case VX_IMAGE_ATTRIBUTE_FORMAT:
if (VX_CHECK_PARAM(ptr, size, vx_df_image, 0x3))
*(vx_df_image *)ptr = m_format;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_WIDTH:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
*(vx_uint32 *)ptr = m_width;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_HEIGHT:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
*(vx_uint32 *)ptr = m_height;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_PLANES:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
*(vx_size *)ptr = m_planes;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_SPACE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
*(vx_enum *)ptr = m_space;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_RANGE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
*(vx_enum *)ptr = m_range;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_SIZE:
if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
vx_size size = 0ul;
vx_uint32 m,p;
for (m = 0; m < m_memory.memory_num; m++) {
for (p = 0; p < m_memory.subplane_num[m]; p++) {
size += (abs(m_memory.strides[m][p][VX_DIM_Y]) * m_memory.dims[m][p][VX_DIM_Y]);
}
}
*(vx_size *)ptr = size;
} else {
status = VX_ERROR_INVALID_PARAMETERS;
}
break;
case VX_IMAGE_ATTRIBUTE_IMPORT:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
*(vx_enum *)ptr = m_import_type;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_MEMORIES:
if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
*(vx_uint32 *)ptr = m_memory.memory_num;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
vx_status
ExynosVisionImage::setImageAttribute(vx_enum attribute, const void *ptr, vx_size size)
{
vx_status status = VX_SUCCESS;
switch (attribute) {
case VX_IMAGE_ATTRIBUTE_SPACE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
m_space = *(vx_enum *)ptr;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
case VX_IMAGE_ATTRIBUTE_RANGE:
if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
m_range = *(vx_enum *)ptr;
else
status = VX_ERROR_INVALID_PARAMETERS;
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
vx_status
ExynosVisionImage::setDirective(vx_enum directive)
{
vx_status status = VX_SUCCESS;
switch (directive) {
/*! \todo add directive to the sample implementation */
case VX_DIRECTIVE_IMAGE_CONTINUOUS:
if (m_is_allocated == vx_true_e) {
VXLOGE("the memory of %s is already allocated", getName());
status = VX_FAILURE;
} else {
m_continuous = vx_true_e;
initImage(m_width, m_height, m_format);
status = VX_SUCCESS;
}
break;
default:
status = VX_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
vx_status
ExynosVisionImage::swapImageHandle(void *const new_ptrs[], void *prev_ptrs[], vx_size num_planes)
{
VXLOGE("%s can't support this, %p, %p, %d", getName(), new_ptrs, prev_ptrs, num_planes);
displayInfo(0, vx_true_e);
return VX_ERROR_INVALID_PARAMETERS;
}
ExynosVisionImage*
ExynosVisionImage::locateROI(vx_rectangle_t *rect)
{
if ((rect->start_x == 0) && (rect->start_y == 0) &&
(rect->end_x == 0) && (rect->end_y == 0)) {
rect->end_x = m_width;
rect->end_y = m_height;
}
if ((m_width < rect->end_x) || (m_height < rect->end_y)) {
VXLOGE("the locate of ROI is out of bound, %dx%d -> %dx%d", rect->end_x, rect->end_y, m_width, m_height);
return NULL;
}
return this;
}
vx_status
ExynosVisionImage::verifyMeta(ExynosVisionMeta *meta)
{
vx_status status = VX_SUCCESS;
vx_df_image meta_image_format;
vx_uint32 meta_image_width;
vx_uint32 meta_image_height;
status |= meta->getMetaFormatAttribute(VX_IMAGE_ATTRIBUTE_FORMAT, &meta_image_format, sizeof(meta_image_format));
status |= meta->getMetaFormatAttribute(VX_IMAGE_ATTRIBUTE_WIDTH, &meta_image_width, sizeof(meta_image_width));
status |= meta->getMetaFormatAttribute(VX_IMAGE_ATTRIBUTE_HEIGHT, &meta_image_height, sizeof(meta_image_height));
if (status != VX_SUCCESS) {
VXLOGE("get meta fail, err:%d", status);
}
if (isVirtual()) {
if (status != VX_SUCCESS) {
VXLOGE("verify meta image fail");
}
if (m_format == VX_DF_IMAGE_VIRT || m_format == meta_image_format)
{
VXLOGD3("meta_image_format:0x%x", meta_image_format);
/* we have to go set all the other dimensional information up. */
initImage(meta_image_width, meta_image_height, meta_image_format);
}
else
{
status = VX_ERROR_INVALID_FORMAT;
getContext()->addLogEntry(this, status, "invalid format %08x!\n", m_format);
VXLOGE("invalid format 0x%X", m_format);
}
} else {
/* check the data that came back from the output validator against the object */
if ((m_width != meta_image_width) ||
(m_height != meta_image_height)) {
status = VX_ERROR_INVALID_DIMENSION;
getContext()->addLogEntry(this, status, "invalid dimension %ux%u, meta %ux%u\n", m_width, m_height, meta_image_width, meta_image_height);
VXLOGE("invalid dimension %ux%u, meta %ux%u", m_width, m_height, meta_image_width, meta_image_height);
}
if (m_format != meta_image_format) {
status = VX_ERROR_INVALID_FORMAT;
getContext()->addLogEntry(this, status, "invalid format: %p, meta: %p\n", m_format, meta_image_format);
VXLOGE("invalid format: %p, meta: %p", m_format, meta_image_format);
}
}
return status;
}
vx_status
ExynosVisionImage::accessImagePatch(const vx_rectangle_t *rect,
vx_uint32 plane_index,
vx_imagepatch_addressing_t *addr,
void **ptr,
vx_enum usage)
{
vx_uint8 *p = NULL;
vx_status status = VX_FAILURE;
vx_bool mapped = vx_false_e;
vx_uint32 start_x = rect ? rect->start_x : 0u;
vx_uint32 start_y = rect ? rect->start_y : 0u;
vx_uint32 end_x = rect ? rect->end_x : 0u;
vx_uint32 end_y = rect ? rect->end_y : 0u;
vx_bool zero_area = ((((end_x - start_x) == 0) || ((end_y - start_y) == 0)) ? vx_true_e : vx_false_e);
vx_uint32 m = m_plane_loc[plane_index].memory_index;
vx_uint32 sp = m_plane_loc[plane_index].subplane_index;
/* bad parameters */
if ((usage < VX_READ_ONLY) || (VX_READ_AND_WRITE < usage) ||
(addr == NULL) || (ptr == NULL)) {
VXLOGE("usage and ptr is invalid");
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT;
}
/* bad references */
if (!rect) {
status = VX_ERROR_INVALID_REFERENCE;
goto EXIT;
}
/* determine if virtual before checking for memory */
if (m_is_virtual == vx_true_e) {
if (m_kernel_count == 0) {
/* User tried to access a "virtual" image. */
VXLOGE("Can not access a virtual image");
status = VX_ERROR_OPTIMIZED_AWAY;
goto EXIT;
}
/* framework trying to access a virtual image, this is ok. */
}
/* more bad parameters */
if (zero_area == vx_false_e &&
((plane_index >= m_planes) ||
(rect->start_x >= rect->end_x) ||
(rect->start_y >= rect->end_y))) {
VXLOGE("rect info is invalid");
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT;
}
if ((m_continuous == vx_false_e) && (plane_index >= (vx_uint32)abs(m_memory.memory_num))) {
VXLOGE("plane index is wrong");
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT;
}
/* verify has not been call yet or will not be called (immediate mode)
* this is a trick to "touch" an image so that it can be created
*/
if (m_is_allocated != vx_true_e) {
status = ((ExynosVisionDataReference*)this)->allocateMemory();
if (status != VX_SUCCESS) {
VXLOGE("memory is not allocated yet");
goto EXIT;
}
}
/* can't write to constant */
if ((m_constant == vx_true_e) && (usage != VX_READ_ONLY)) {
status = VX_ERROR_NOT_SUPPORTED;
VXLOGE("Can't write to constant data, only read");
getContext()->addLogEntry(this, status, "Can't write to constant data, only read!\n");
goto EXIT;
}
vx_uint8 *res_base_ptr;
res_base_ptr = (vx_uint8 *)(m_cur_res->itemAt(m)->getAddr());
if (res_base_ptr == NULL) {
VXLOGE("resource is null");
status = VX_ERROR_NO_MEMORY;
goto EXIT;
}
/*************************************************************************/
VXLOGD3("accessImagePatch from %s to ptr %p from {%u,%u} to {%u,%u} plane %u",
getName(), *ptr, rect->start_x, rect->start_y, rect->end_x, rect->end_y, plane_index);
if (increaseAccessCount() == 1) {
if (m_external_lock.tryLock() != NO_ERROR) {
VXLOGE("%s is locking", getName());
if (decreaseAccessCount() == 0) {
m_external_lock.unlock();
}
status = VX_FAILURE;
goto EXIT;
}
}
m_memory.usage[plane_index] = usage;
/* POSSIBILITIES:
* 1.) !*ptr && RO == MAP
* 2.) !*ptr && WO == MAP
* 3.) !*ptr && RW == MAP
* 4.) *ptr && RO||RW == COPY (UNLESS MAP)
*/
if (*ptr == NULL) {
mapped = vx_true_e;
}
/* lock the memory plane for multiple writers*/
if (usage != VX_READ_ONLY) {
m_memory_locks[plane_index].lock();
}
/* MAP mode */
if (mapped == vx_true_e) {
m_memory.access_mode[plane_index] = ACCESS_MAP_MODE;
vx_uint32 index;
p = (vx_uint8 *)(res_base_ptr + m_memory.subplane_mem_offset[m][sp]);
/* use the addressing of the internal format */
addr->dim_x = rect->end_x - rect->start_x;
addr->dim_y = rect->end_y - rect->start_y;
addr->stride_x = m_memory.strides[m][sp][VX_DIM_X];
addr->stride_y = m_memory.strides[m][sp][VX_DIM_Y];
addr->step_x = m_scale[plane_index][VX_DIM_X];
addr->step_y = m_scale[plane_index][VX_DIM_Y];
addr->scale_x = VX_SCALE_UNITY / m_scale[plane_index][VX_DIM_X];
addr->scale_y = VX_SCALE_UNITY / m_scale[plane_index][VX_DIM_Y];
VXLOGD3("%s, format:0x%x, plane:%d", getName(), m_format, plane_index);
VXLOGD3("strides[%d][%d][X]:%d, strides[%d][%d][Y]:%d", m , sp, m_memory.strides[m][sp][VX_DIM_X], m, sp, m_memory.strides[m][sp][VX_DIM_Y]);
index = vxComputePatchOffset(rect->start_x, rect->start_y, addr);
*ptr = &p[index];
status = VX_SUCCESS;
} else {
/* COPY mode */
m_memory.access_mode[plane_index] = ACCESS_COPY_MODE;
/* stride is already filled by application */
addr->dim_x = rect->end_x - rect->start_x;
addr->dim_y = rect->end_y - rect->start_y;
addr->step_x = m_scale[plane_index][VX_DIM_X];
addr->step_y = m_scale[plane_index][VX_DIM_Y];
addr->scale_x = VX_SCALE_UNITY / m_scale[plane_index][VX_DIM_X];
addr->scale_y = VX_SCALE_UNITY / m_scale[plane_index][VX_DIM_Y];
vx_uint32 x, y;
vx_uint8 *external_ptr = (vx_uint8*)*ptr;
if ((usage == VX_READ_ONLY) || (usage == VX_READ_AND_WRITE)) {
if ((vx_uint32)addr->stride_x == m_memory.strides[m][sp][VX_DIM_X]) {
/* Both have compact lines */
for (y = rect->start_y; y < rect->end_y; y+=addr->step_y) {
vx_uint32 i = computePlaneOffset(rect->start_x, y, plane_index);
vx_uint32 j = vxComputePatchOffset(0, (y - rect->start_y), addr);
vx_uint32 len = computePlaneRangeSize(addr->dim_x, plane_index);
vx_uint8 *base_ptr = (vx_uint8 *)(res_base_ptr + m_memory.subplane_mem_offset[m][sp]);
memcpy(&external_ptr[j], base_ptr+i, len);
}
} else {
/* The destination is not compact, we need to copy per element */
vx_uint8 *pDestLine = &external_ptr[0];
for (y = rect->start_y; y < rect->end_y; y+=addr->step_y) {
vx_uint8 *pDest = pDestLine;
vx_uint32 offset = computePlaneOffset(rect->start_x, y, plane_index);
vx_uint8 *base_ptr = (vx_uint8 *)(res_base_ptr + m_memory.subplane_mem_offset[m][sp]);
vx_uint8 *pSrc = base_ptr+offset;
for (x = rect->start_x; x < rect->end_x; x+=addr->step_x) {
/* One element */
memcpy(pDest, pSrc, m_memory.strides[m][sp][VX_DIM_X]);
pSrc += m_memory.strides[m][sp][VX_DIM_X];
pDest += addr->stride_x;
}
pDestLine += addr->stride_y;
}
}
VXLOGD2("Copied image into %p\n", *ptr);
}
status = VX_SUCCESS;
}
EXIT:
return status;
}
vx_status
ExynosVisionImage::commitImagePatch(vx_rectangle_t *rect,
vx_uint32 plane_index,
vx_imagepatch_addressing_t *addr,
const void *ptr)
{
vx_status status = VX_ERROR_INVALID_REFERENCE;
vx_int32 i = 0;
vx_bool external = vx_true_e; // assume that it was an allocated buffer
vx_uint32 start_x = rect ? rect->start_x : 0u;
vx_uint32 start_y = rect ? rect->start_y : 0u;
vx_uint32 end_x = rect ? rect->end_x : 0u;
vx_uint32 end_y = rect ? rect->end_y : 0u;
vx_uint8 *external_ptr = (vx_uint8 *)ptr;
vx_bool zero_area = ((((end_x - start_x) == 0) || ((end_y - start_y) == 0)) ? vx_true_e : vx_false_e);
vx_uint32 index = UINT32_MAX; // out of bounds, if given to remove, won't do anything
vx_uint32 m = m_plane_loc[plane_index].memory_index;
vx_uint32 sp = m_plane_loc[plane_index].subplane_index;
VXLOGD3("CommitImagePatch to ref(%d) from ptr %p plane %u to {%u,%u},{%u,%u}\n",
getId(), ptr, plane_index, start_x, start_y, end_x, end_y);
/* determine if virtual before checking for memory */
if (m_is_virtual == vx_true_e && zero_area == vx_false_e) {
if (m_kernel_count == 0) {
/* User tried to access a "virtual" image. */
VXLOGE("Can not access a virtual image");
status = VX_ERROR_OPTIMIZED_AWAY;
goto EXIT_ERR;
}
/* framework trying to access a virtual image, this is ok. */
}
if (zero_area == vx_true_e) {
status = VX_SUCCESS;
goto EXIT_SUCC;
}
if (m_constant == vx_true_e) {
/* we tried to modify constant data! */
VXLOGE("Can't set constant image data");
status = VX_ERROR_NOT_SUPPORTED;
/* don't modify the accessor here, it's an error case */
goto EXIT_ERR;
}
if ((plane_index >= m_planes) ||
(ptr == NULL) ||
(addr == NULL)) {
status = VX_ERROR_INVALID_PARAMETERS;
VXLOGE("some parameter is not valid, plane_index:%d, ptr:%p, addr:%p", plane_index, ptr, addr);
goto EXIT_ERR;
}
if ((m_continuous == vx_false_e) && (plane_index >= (vx_uint32)abs(m_memory.memory_num))) {
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT_ERR;
}
/* check the rectangle, it has to be in actual plane space */
if ((start_x >= end_x) || ((end_x - start_x) > addr->dim_x) ||
(start_y >= end_y) || ((end_y - start_y) > addr->dim_y) ||
(end_x > (vx_uint32)m_memory.dims[m][sp][VX_DIM_X] * (vx_uint32)m_scale[plane_index][VX_DIM_X]) ||
(end_y > (vx_uint32)m_memory.dims[m][sp][VX_DIM_Y] * (vx_uint32)m_scale[plane_index][VX_DIM_X])) {
VXLOGE("Invalid start,end coordinates! plane %u {%u,%u},{%u,%u}",
plane_index, start_x, start_y, end_x, end_y);
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT_ERR;
}
if (m_memory.usage[plane_index] == VX_READ_ONLY) {
VXLOGD2("committing image with read-only");
status = VX_SUCCESS;
goto EXIT_SUCC;
}
if (m_memory.access_mode[plane_index] == ACCESS_MAP_MODE) {
/* determine if this grows the valid region */
if (m_region.start_x > start_x)
m_region.start_x = start_x;
if (m_region.start_y > start_y)
m_region.start_y = start_y;
if (m_region.end_x < end_x)
m_region.end_x = end_x;
if (m_region.end_y < end_y)
m_region.end_y = end_y;
} else if (m_memory.access_mode[plane_index] == ACCESS_COPY_MODE) {
/* copy the patch back to the image. */
if ((vx_uint32)addr->stride_x == m_memory.strides[m][sp][VX_DIM_X]) {
/* Both source and destination have compact lines */
vx_uint32 y;
for (y = start_y; y < end_y; y+=addr->step_y) {
vx_uint32 i = computePlaneOffset(start_x, y, plane_index);
vx_uint32 j = vxComputePatchOffset(0, (y - start_y), addr);
vx_uint32 len = vxComputePatchRangeSize((end_x - start_x), addr);
vx_uint8 *base_ptr = (vx_uint8 *)(m_cur_res->itemAt(m)->getAddr() + m_memory.subplane_mem_offset[m][sp]);
VXLOGD2("%p[%u] <= %p[%u] for %u\n", base_ptr, j, external_ptr, i, len);
memcpy(base_ptr+i, &external_ptr[j], len);
}
} else {
/* The source is not compact, we need to copy per element */
vx_uint32 x, y;
vx_uint8 *pDestLine = &external_ptr[0];
for (y = start_y; y < end_y; y+=addr->step_y) {
vx_uint8 *pSrc = pDestLine;
vx_uint32 offset = computePlaneOffset(start_x, y, plane_index);
vx_uint8 *base_ptr = (vx_uint8 *)(m_cur_res->itemAt(m)->getAddr() + m_memory.subplane_mem_offset[m][sp]);
vx_uint8 *pDest = base_ptr + offset;
for (x = start_x; x < end_x; x+=addr->step_x) {
/* One element */
memcpy(pDest, pSrc, m_memory.strides[m][sp][VX_DIM_X]);
pDest += m_memory.strides[m][sp][VX_DIM_X];
pSrc += addr->stride_x;
}
pDestLine += addr->stride_y;
}
}
}
status = VX_SUCCESS;
EXIT_SUCC:
if (m_memory.usage[plane_index] != VX_READ_ONLY)
m_memory_locks[plane_index].unlock();
m_memory.access_mode[plane_index] = ACCESS_NONE;
if (decreaseAccessCount() == 0) {
m_external_lock.unlock();
}
EXIT_ERR:
return status;
}
vx_status
ExynosVisionImage::accessImageHandle(vx_uint32 plane_index,
vx_int32 *fd,
vx_rectangle_t *rect,
vx_enum usage)
{
vx_status status = VX_FAILURE;
vx_uint32 m;
/* verify has not been call yet or will not be called (immediate mode)
* this is a trick to "touch" an image so that it can be created
*/
if (m_is_allocated != vx_true_e) {
status = ((ExynosVisionDataReference*)this)->allocateMemory();
if (status != VX_SUCCESS) {
VXLOGE("memory is not allocated yet");
goto EXIT;
}
}
m = m_plane_loc[plane_index].memory_index;
/* bad parameters */
if ((usage < VX_READ_ONLY) || (VX_READ_AND_WRITE < usage)) {
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT;
}
/* determine if virtual before checking for memory */
if (m_is_virtual == vx_true_e) {
if (m_kernel_count == 0) {
/* User tried to access a "virtual" image. */
VXLOGE("Can not access a virtual image");
status = VX_ERROR_OPTIMIZED_AWAY;
goto EXIT;
}
/* framework trying to access a virtual image, this is ok. */
}
/* can't write to constant */
if ((m_constant == vx_true_e) && ((usage == VX_WRITE_ONLY) ||
(usage == VX_READ_AND_WRITE))) {
status = VX_ERROR_NOT_SUPPORTED;
VXLOGE("Can't write to constant data, only read");
getContext()->addLogEntry(this, status, "Can't write to constant data, only read!\n");
goto EXIT;
}
if (increaseAccessCount() == 1) {
if (m_external_lock.tryLock() != NO_ERROR) {
VXLOGE("%s is already locking", getName());
if (decreaseAccessCount() == 0) {
m_external_lock.unlock();
}
status = VX_FAILURE;
goto EXIT;
}
}
m_memory.usage[plane_index] = usage;
/* lock the memory plane for multiple writers*/
if (usage != VX_READ_ONLY)
m_memory_locks[plane_index].lock();
int fd_tmp;
fd_tmp = m_cur_res->itemAt(m)->getFd();
if (fd_tmp == 0) {
VXLOGE("fd is not allocated");
status = VX_FAILURE;
goto EXIT;
}
*fd = fd_tmp;
rect->start_x = 0;
rect->start_y = 0;
rect->end_x = m_width;
rect->end_y = m_height;
status = VX_SUCCESS;
EXIT:
return status;
}
vx_status
ExynosVisionImage::commitImageHandle(vx_uint32 plane_index, const vx_int32 fd)
{
if (fd == -1) {
VXLOGE("wrong fd:%d", fd);
return VX_FAILURE;
}
vx_status status = VX_ERROR_INVALID_REFERENCE;
vx_uint32 m = m_plane_loc[plane_index].memory_index;
/* determine if virtual before checking for memory */
if (m_is_virtual == vx_true_e) {
if (m_kernel_count == 0) {
/* User tried to access a "virtual" image. */
VXLOGE("Can not access a virtual image");
status = VX_ERROR_OPTIMIZED_AWAY;
goto EXIT;
}
/* framework trying to access a virtual image, this is ok. */
}
status = VX_SUCCESS;
if (m_memory.usage[plane_index] != VX_READ_ONLY)
m_memory_locks[plane_index].unlock();
m_memory.access_mode[plane_index] = ACCESS_NONE;
if (decreaseAccessCount() == 0) {
m_external_lock.unlock();
}
EXIT:
return status;
}
vx_size
ExynosVisionImage::computeImagePatchSize(const vx_rectangle_t *rect, vx_uint32 plane_index)
{
vx_size size = 0ul;
vx_uint32 start_x = 0u, start_y = 0u, end_x = 0u, end_y = 0u;
vx_uint32 m = m_plane_loc[plane_index].memory_index;
vx_uint32 sp = m_plane_loc[plane_index].subplane_index;
if (rect) {
start_x = rect->start_x;
start_y = rect->start_y;
end_x = rect->end_x;
end_y = rect->end_y;
if (m_is_allocated == vx_false_e) {
VXLOGE("Failed to allocate image");
getContext()->addLogEntry(this, VX_ERROR_NO_MEMORY, "Failed to allocate image!\n");
return 0;
}
if (plane_index < m_planes) {
vx_size numPixels = ((end_x-start_x)/m_scale[plane_index][VX_DIM_X]) *
((end_y-start_y)/m_scale[plane_index][VX_DIM_Y]);
vx_size pixelSize = m_memory.strides[m][sp][VX_DIM_X];
VXLOGD("numPixels = %d pixelSize = %d", numPixels, pixelSize);
size = numPixels * pixelSize;
} else {
VXLOGE("Plane index %u is out of bounds!", plane_index);
getContext()->addLogEntry(this, VX_ERROR_INVALID_PARAMETERS, "Plane index %u is out of bounds!", plane_index);
}
VXLOGD("image(%d) for patch {%u,%u to %u,%u} has a byte size of %d",
getId(), start_x, start_y, end_x, end_y, size);
} else {
VXLOGE("Image Reference is invalid");
}
return size;
}
vx_status
ExynosVisionImage::getValidRegionImage(vx_rectangle_t *rect)
{
vx_status status = VX_ERROR_INVALID_REFERENCE;
if (rect) {
if ((m_region.start_x <= m_region.end_x) && (m_region.start_y <= m_region.end_y)) {
rect->start_x = m_region.start_x;
rect->start_y = m_region.start_y;
rect->end_x = m_region.end_x;
rect->end_y = m_region.end_y;
} else {
rect->start_x = 0;
rect->start_y = 0;
rect->end_x = m_width;
rect->end_y = m_height;
}
status = VX_SUCCESS;
}
return status;
}
vx_status
ExynosVisionImage::getDimension(vx_uint32 *width, vx_uint32 *height)
{
*width = m_width;
*height = m_height;
return VX_SUCCESS;
}
vx_status
ExynosVisionImage::fillUniformValue(const void *value)
{
vx_status status = VX_SUCCESS;
vx_rectangle_t rect = {0, 0, m_width, m_height};
for (vx_uint32 p = 0; p < m_planes; p++) {
vx_imagepatch_addressing_t addr;
void *base = NULL;
status = accessImagePatch(&rect, p, &addr, &base, VX_WRITE_ONLY);
if (status != VX_SUCCESS) {
VXLOGE("accessing image fails, plane:%d, err:%d", p, status);
break;
}
for (vx_uint32 y = 0; y < addr.dim_y; y+=addr.step_y) {
for (vx_uint32 x = 0; x < addr.dim_x; x+=addr.step_x) {
if (m_format == VX_DF_IMAGE_U8) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = *pixel;
} else if (m_format == VX_DF_IMAGE_U16) {
vx_uint16 *pixel = (vx_uint16 *)value;
vx_uint16 *ptr = (vx_uint16*)vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = *pixel;
} else if (m_format == VX_DF_IMAGE_U32) {
vx_uint32 *pixel = (vx_uint32 *)value;
vx_uint32 *ptr = (vx_uint32*)vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = *pixel;
} else if (m_format == VX_DF_IMAGE_S16) {
vx_int16 *pixel = (vx_int16 *)value;
vx_int16 *ptr = (vx_int16*)vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = *pixel;
} else if (m_format == VX_DF_IMAGE_S32) {
vx_int32 *pixel = (vx_int32 *)value;
vx_int32 *ptr = (vx_int32*)vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = *pixel;
} else if ((m_format == VX_DF_IMAGE_RGB) ||
(m_format == VX_DF_IMAGE_RGBX)) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
ptr[0] = pixel[0];
ptr[1] = pixel[1];
ptr[2] = pixel[2];
if (m_format == VX_DF_IMAGE_RGBX)
ptr[3] = pixel[3];
} else if ((m_format == VX_DF_IMAGE_YUV4) ||
(m_format == VX_DF_IMAGE_IYUV)) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = pixel[p];
} else if ((p == 0) &&
((m_format == VX_DF_IMAGE_NV12) ||
(m_format == VX_DF_IMAGE_NV21))) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr =(vx_uint8*) vxFormatImagePatchAddress2d(base, x, y, &addr);
*ptr = pixel[0];
} else if ((p == 1) && (m_format == VX_DF_IMAGE_NV12)) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
ptr[0] = pixel[1];
ptr[1] = pixel[2];
} else if ((p == 1) && (m_format == VX_DF_IMAGE_NV21)) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
ptr[0] = pixel[2];
ptr[1] = pixel[1];
} else if (m_format == VX_DF_IMAGE_UYVY) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
if (x % 2 == 0) {
ptr[0] = pixel[1];
ptr[1] = pixel[0];
} else {
ptr[0] = pixel[2];
ptr[1] = pixel[0];
}
} else if (m_format == VX_DF_IMAGE_YUYV) {
vx_uint8 *pixel = (vx_uint8 *)value;
vx_uint8 *ptr = (vx_uint8*)vxFormatImagePatchAddress2d(base, x, y, &addr);
if (x % 2 == 0) {
ptr[0] = pixel[0];
ptr[1] = pixel[1];
} else {
ptr[0] = pixel[0];
ptr[1] = pixel[2];
}
}
}
}
status = commitImagePatch(&rect, p, &addr, base);
if (status != VX_SUCCESS) {
VXLOGE("commiting image fails, plane:%d, err:%d", p, status);
break;
}
} /* for loop */
return status;
}
void
ExynosVisionImage::copyMemoryInfo(const ExynosVisionImage *src_image)
{
memcpy(&m_memory.strides, &src_image->m_memory.strides, sizeof(m_memory.strides));
}
vx_status
ExynosVisionImage::allocateMemory(vx_enum res_type, struct resource_param *param)
{
return allocateMemory_T(res_type, param, vx_true_e, &m_res_mngr, &m_res_list, &m_cur_res);
}
vx_status
ExynosVisionImage::allocateResource(image_resource_t **ret_resource)
{
if (ret_resource == NULL) {
VXLOGE("return pointer is null at %s", getName());
return VX_ERROR_INVALID_PARAMETERS;
}
vx_status status = VX_SUCCESS;
image_resource_t*buf_vector = new image_resource_t();
vx_size plane_size = 0;
for (vx_uint32 m = 0; m < m_memory.memory_num; m++) {
vx_size memory_size = 0;
for (vx_uint32 sp = 0; sp < m_memory.subplane_num[m]; sp++) {
plane_size = m_memory.element_byte_size;
for (vx_uint32 d = 0; d < VX_DIM_MAX; d++) {
m_memory.strides[m][sp][d] = (vx_int32)plane_size;
plane_size *= (vx_size)abs(m_memory.dims[m][sp][d]);
m_memory.subplane_mem_offset[m][sp] = memory_size;
}
memory_size += plane_size;
}
if (memory_size == 0) {
VXLOGE("%s, calculating allocation size is zero", getName());
displayInfoMemory();
break;
}
ExynosVisionBufMemory *buf = new ExynosVisionBufMemory();
VXLOGD2("mem[%d] allocation size: %d", m, memory_size);
status = buf->alloc(m_allocator, memory_size);
if (status != VX_SUCCESS) {
VXLOGE("buffer allocation fails at %s", getName());
break;
}
buf_vector->push_back(buf);
}
if (status == VX_SUCCESS)
*ret_resource = buf_vector;
return status;
}
vx_status
ExynosVisionImage::freeResource(image_resource_t *buf_vector)
{
vx_status status = VX_SUCCESS;
image_resource_t::iterator buf_iter;
for(buf_iter=buf_vector->begin(); buf_iter!=buf_vector->end(); buf_iter++) {
status = (*buf_iter)->free(m_allocator);
if (status != VX_SUCCESS) {
VXLOGE("memory free fail, err:%d", status);
break;
}
delete (*buf_iter);
}
buf_vector->clear();
delete buf_vector;
return status;
}
ExynosVisionDataReference*
ExynosVisionImage::getInputShareRef(vx_uint32 frame_cnt, vx_bool *ret_data_valid)
{
return getInputShareRef_T<image_resource_t>(m_res_mngr, frame_cnt, ret_data_valid);
}
vx_status
ExynosVisionImage::putInputShareRef(vx_uint32 frame_cnt)
{
return putInputShareRef_T<image_resource_t>(m_res_mngr, frame_cnt);
}
ExynosVisionDataReference*
ExynosVisionImage::getOutputShareRef(vx_uint32 frame_cnt)
{
return getOutputShareRef_T<image_resource_t>(m_res_mngr, frame_cnt);
}
vx_status
ExynosVisionImage::putOutputShareRef(vx_uint32 frame_cnt, vx_uint32 demand_num, vx_bool data_valid)
{
return putOutputShareRef_T<image_resource_t>(m_res_mngr, frame_cnt, demand_num, data_valid);
}
vx_status
ExynosVisionImage::createCloneObject(image_resource_t *buf_vector)
{
if (m_clone_object_map[buf_vector]) {
VXLOGE("%s has already clone object of %p", getName(), buf_vector);
return VX_FAILURE;
}
ExynosVisionImage *clone_image = new ExynosVisionImageClone(getContext(), this);
*clone_image = *this;
clone_image->copyMemoryInfo(this);
clone_image->m_res_type = RESOURCE_MNGR_NULL;
clone_image->m_cur_res = buf_vector;
clone_image->m_is_allocated = vx_true_e;
m_clone_object_map[buf_vector] = clone_image;
clone_image->incrementReference(VX_REF_INTERNAL, this);
return VX_SUCCESS;
}
vx_status
ExynosVisionImage::destroyCloneObject(image_resource_t *buf_vector)
{
if (!m_clone_object_map[buf_vector]) {
VXLOGE("%s doesn't have clone object of %p", getName(), buf_vector);
return VX_FAILURE;
}
ExynosVisionDataReference *clone_object = m_clone_object_map[buf_vector];
vx_status status = ExynosVisionReference::releaseReferenceInt((ExynosVisionReference**)&clone_object, VX_REF_INTERNAL, this);
if (status != VX_SUCCESS) {
VXLOGE("release %s fails at %s", clone_object->getName(), this->getName());
}
if (clone_object != NULL) {
VXLOGE("clone_object should be destroyed when original obejct release it");
clone_object->displayInfo(0, vx_true_e);
}
m_clone_object_map.erase(buf_vector);
return VX_SUCCESS;
}
vx_status
ExynosVisionImage::registerRoiDescendant(ExynosVisionImageROI *roi_descendant)
{
vx_status status;
List<ExynosVisionImageROI*>::iterator image_iter;
for (image_iter=m_roi_descendant_list.begin(); image_iter!=m_roi_descendant_list.end(); image_iter++) {
if (ExynosVisionImage::checkImageDependenct(*image_iter, roi_descendant)) {
status = ExynosVisionDataReference::jointAlliance(*image_iter, roi_descendant);
if (status != VX_SUCCESS) {
VXLOGE("joint alliance between %s and %s fails", (*image_iter)->getName(), roi_descendant->getName());
break;
}
}
}
status = ExynosVisionDataReference::jointAlliance(this, roi_descendant);
if (status != VX_SUCCESS) {
VXLOGE("joint alliance between %s and %s fails", this->getName(), roi_descendant->getName());
}
m_roi_descendant_list.push_back(roi_descendant);
return status;
}
void
ExynosVisionImage::displayInfo(vx_uint32 tab_num, vx_bool detail_info)
{
vx_char tap[MAX_TAB_NUM];
VXLOGI("%s[Image ] %s(%p), resol:%dx%d, format:0x%x, virtual:%d, alloc:%d, refCnt:%d/%d", MAKE_TAB(tap, tab_num), getName(), this,
m_width, m_height, m_format, isVirtual(), m_is_allocated,
getInternalCnt(), getExternalCnt());
List<ExynosVisionDataReference*>::iterator ref_iter;
for (ref_iter=m_alliance_ref_list.begin(); ref_iter!=m_alliance_ref_list.end(); ref_iter++) {
VXLOGI("%s[--Image] alliance : %s", MAKE_TAB(tap, tab_num), (*ref_iter)->getName());
}
if (isDelayElement()) {
VXLOGI("%s[--Image] delay element, %s, delay phy index:%d", MAKE_TAB(tap, tab_num), getDelay()->getName(), getDelaySlotIndex());
}
LOG_FLUSH_TIME();
if ((m_res_type == RESOURCE_MNGR_SLOT) || (m_res_type == RESOURCE_MNGR_QUEUE)) {
m_res_mngr->displayBuff(tab_num+1, vx_true_e);
}
if (detail_info)
displayConn(tab_num);
}
void
ExynosVisionImage::displayInfoMemory(void)
{
VXLOGI("%s, format:0x%x, size:%d x %d", getName(), m_format, m_width, m_height);
for (vx_uint32 m=0; m<m_memory.memory_num; m++) {
VXLOGI("[m_%d] sub-planes: %d", m, m_memory.subplane_num[m]);
for (vx_uint32 sp=0; sp<m_memory.subplane_num[m]; sp++) {
VXLOGI("memory offset: %p", m_memory.subplane_mem_offset[m][sp]);
VXLOGI("dims[%d][%d] {%d, %d, %d}", m, sp, m_memory.dims[m][sp][0], m_memory.dims[m][sp][1], m_memory.dims[m][sp][2]);
VXLOGI("stride[%d][%d] {%d, %d, %d}", m, sp, m_memory.strides[m][sp][0], m_memory.strides[m][sp][1], m_memory.strides[m][sp][2]);
}
}
}
#ifdef USE_OPENCL_KERNEL
vx_status
ExynosVisionImage::getClMemoryInfo(cl_context clContext, vxcl_mem_t **memory)
{
vx_status status = VX_SUCCESS;
vx_uint32 m, p, sp;
cl_int err = CL_SUCCESS;
m_cl_memory.cl_type = CL_MEM_OBJECT_IMAGE2D;
m_cl_memory.nptrs = m_planes;
m_cl_memory.ndims = VX_DIM_MAX;
switch (m_format) {
case VX_DF_IMAGE_U8:
m_cl_memory.cl_format = {CL_LUMINANCE, CL_UNORM_INT8};
break;
case VX_DF_IMAGE_U16:
m_cl_memory.cl_format = {CL_LUMINANCE, CL_UNORM_INT16};
break;
case VX_DF_IMAGE_S16:
m_cl_memory.cl_format = {CL_LUMINANCE, CL_SIGNED_INT16};
break;
case VX_DF_IMAGE_RGB:
m_cl_memory.cl_format = {CL_RGB, CL_UNORM_INT8};
break;
case VX_DF_IMAGE_RGBX:
m_cl_memory.cl_format = {CL_RGBA, CL_UNORM_INT8};
break;
case VX_DF_IMAGE_S32:
case VX_DF_IMAGE_U32:
default:
VXLOGE("Image format(0x%X) is not supported", m_format);
err = CL_IMAGE_FORMAT_NOT_SUPPORTED;
status = VX_ERROR_INVALID_FORMAT;
goto EXIT;
}
for (m = 0; m < m_memory.memory_num; m++) {
for (p = 0, m = 0, sp = 0; sp < m_memory.subplane_num[m]; p++, sp++) {
m_cl_memory.ptrs[p] = (vx_uint8 *)(m_cur_res->itemAt(m)->getAddr() + m_memory.subplane_mem_offset[m][sp]);
vx_uint32 plane_size = m_memory.element_byte_size;
for (vx_uint32 d = 0; d < VX_DIM_MAX; d++) {
m_cl_memory.dims[p][d] = m_memory.dims[m][sp][d];
m_cl_memory.strides[p][d] = m_memory.strides[m][sp][d];
plane_size *= (vx_size)abs(m_memory.dims[m][sp][d]);
}
m_cl_memory.sizes[p] = plane_size;
m_cl_memory.hdls[p] = clCreateImage2D(clContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
&m_cl_memory.cl_format, // Image Format
m_cl_memory.dims[p][VX_DIM_X], // Image Width
m_cl_memory.dims[p][VX_DIM_Y], // Image Height
m_cl_memory.strides[p][VX_DIM_Y], //Image Row Pitch
m_cl_memory.ptrs[p], // Host Ptr
&err);
if (err != CL_SUCCESS) {
VXLOGE("failed in clCreateImage2D : err(%d)", err);
status = VX_FAILURE;
goto EXIT;
}
}
}
EXIT:
if (err != CL_SUCCESS) {
m_cl_memory.allocated = vx_false_e;
*memory = NULL;
} else {
m_cl_memory.allocated = vx_true_e;
*memory = &m_cl_memory;
}
return status;
}
#endif
ExynosVisionImageROI::ExynosVisionImageROI(ExynosVisionContext *context, ExynosVisionReference *scope)
: ExynosVisionImage(context, scope, vx_false_e)
{
memset(&m_rect_info, 0x0, sizeof(m_rect_info));
}
vx_status
ExynosVisionImageROI::destroy(void)
{
vx_status status;
if (m_roi_parent) {
status = ExynosVisionReference::releaseReferenceInt((ExynosVisionReference**)&m_roi_parent, VX_REF_INTERNAL, this);
if (status != VX_SUCCESS) {
VXLOGE("%s can't release internal count of %s", this->getName(), m_roi_parent->getName());
}
m_roi_parent = NULL;
} else {
VXLOGE("ImageROI(%s) can't have null pointer of parent", getName());
status = VX_FAILURE;
}
m_cur_res = NULL;
memset(&m_memory, 0x0, sizeof(m_memory));
m_is_allocated = vx_false_e;
return status;
}
vx_status
ExynosVisionImageROI::init(vx_uint32 width, vx_uint32 height, vx_df_image color)
{
VXLOGE("%s, roi can't support norma init(use initFromROI), width:%d, height:%d, color:%d", width, height, color);
return VX_FAILURE;
}
vx_status
ExynosVisionImageROI::registerRoiDescendant(ExynosVisionImageROI *roi_descendant)
{
/* just hand over if not progenitor */
return m_roi_parent->registerRoiDescendant(roi_descendant);
}
vx_status
ExynosVisionImageROI::initFromROI(ExynosVisionImage *parent_image, const vx_rectangle_t *rect)
{
vx_status status = VX_SUCCESS;
if (parent_image->isAllocated() == vx_false_e) {
status = ((ExynosVisionDataReference*)parent_image)->allocateMemory();
if (status != VX_SUCCESS) {
VXLOGE("can't allocated parent resource, %s", parent_image->getName());
goto EXIT;
}
}
*((ExynosVisionImage*)this) = *parent_image;
this->copyMemoryInfo(parent_image);
m_width = rect->end_x - rect->start_x;
m_height = rect->end_y - rect->start_y;
vx_uint32 parent_width, parent_height;
parent_image->getDimension(&parent_width, &parent_height);
if ((parent_width < m_width) || (parent_height < m_height)) {
VXLOGE("roi region is not valid, P(%d, %d), C(%d, %d)", parent_width, parent_height, m_width, m_height);
status = VX_ERROR_INVALID_PARAMETERS;
goto EXIT;
}
m_rect_info = *rect;
/* modify the dimensions */
for (vx_uint32 m = 0; m < m_memory.memory_num; m++) {
for (vx_uint32 p = 0; p < m_memory.subplane_num[m]; p++) {
m_memory.dims[m][p][VX_DIM_X] = m_width;
m_memory.dims[m][p][VX_DIM_Y] = m_height;
m_memory.parent_plane_offset[p] = parent_image->computePlaneOffset(rect->start_x, rect->start_y, p);
}
}
m_roi_parent = parent_image;
parent_image->incrementReference(VX_REF_INTERNAL, this);
parent_image->registerRoiDescendant(this);
/* m_cur_res is not deallocated at destroy time, so the resource be only destroyed at parent data object. */
m_res_type = RESOURCE_MNGR_NULL;
m_cur_res = NULL;
/* Creating image object from ROI can't support stream mode */
m_is_allocated = vx_true_e;
EXIT:
return status;
}
vx_status
ExynosVisionImageROI::allocateMemory(vx_enum res_type, struct resource_param *param)
{
VXLOGE("%s, roi can't allocate memory, res_type:%d, &param:%p", getName(), res_type, param);
return VX_FAILURE;
}
ExynosVisionImage*
ExynosVisionImageROI::locateROI(vx_rectangle_t *rect)
{
if ((rect->start_x == 0) && (rect->start_y == 0) &&
(rect->end_x == 0) && (rect->end_y == 0)) {
rect->end_x = m_width;
rect->end_y = m_height;
}
vx_size plane_offset = m_memory.parent_plane_offset[0];
vx_uint32 parent_shitf_y = plane_offset * m_scale[0][VX_DIM_Y] / m_memory.strides[0][0][VX_DIM_Y];
vx_uint32 parent_shift_x = (plane_offset - (parent_shitf_y * m_memory.strides[0][0][VX_DIM_Y] / m_scale[0][VX_DIM_Y])) * m_scale[0][VX_DIM_X] / m_memory.strides[0][0][VX_DIM_X];
rect->start_x += parent_shift_x;
rect->end_x += parent_shift_x;
rect->start_y += parent_shitf_y;
rect->end_y += parent_shitf_y;
return m_roi_parent->locateROI(rect);
}
vx_status
ExynosVisionImageROI::accessImagePatch(const vx_rectangle_t *rect,
vx_uint32 plane_index,
vx_imagepatch_addressing_t *addr,
void **ptr,
vx_enum usage)
{
vx_status status;
if (m_cur_res != NULL) {
VXLOGE("resource should be null");
return VX_ERROR_NO_RESOURCES;
}
vx_rectangle_t ancestor_rect = *rect;
ExynosVisionImage *ancestor = locateROI(&ancestor_rect);
if (ancestor == NULL) {
VXLOGE("getting ancestor fails");
displayInfo(0, vx_true_e);
return VX_FAILURE;
}
status = ancestor->accessImagePatch(&ancestor_rect, plane_index, addr, ptr, usage);
if (status != VX_SUCCESS) {
VXLOGE("accessing image patch fails, err:%d", status);
}
return status;
}
vx_status
ExynosVisionImageROI::commitImagePatch(vx_rectangle_t *rect,
vx_uint32 plane_index,
vx_imagepatch_addressing_t *addr,
const void *ptr)
{
vx_status status;
if (m_cur_res != NULL) {
VXLOGE("resource should be null");
return VX_ERROR_NO_RESOURCES;
}
vx_rectangle_t ancestor_rect;
memset(&ancestor_rect, 0x0, sizeof(vx_rectangle_t));
if (rect) {
ancestor_rect = *rect;
}
ExynosVisionImage *ancestor = locateROI(&ancestor_rect);
if (ancestor == NULL) {
VXLOGE("getting ancestor fails");
displayInfo(0, vx_true_e);
return VX_FAILURE;
}
status = ancestor->commitImagePatch(&ancestor_rect, plane_index, addr, ptr);
if (status != VX_SUCCESS) {
VXLOGE("accessing image patch fails, err:%d", status);
}
return status;
}
vx_status
ExynosVisionImageROI::accessImageHandle(vx_uint32 plane_index,
vx_int32 *fd,
vx_rectangle_t *rect,
vx_enum usage)
{
vx_status status;
if (m_cur_res != NULL) {
VXLOGE("resource should be null");
return VX_ERROR_NO_RESOURCES;
}
status = m_roi_parent->accessImageHandle(plane_index, fd, rect, usage);
if (status != VX_SUCCESS) {
VXLOGE("accessing image handle fails, err:%d", status);
goto EXIT;
}
if ((m_rect_info.end_x - m_rect_info.start_x) > (rect->end_x - rect->start_x) ||
(m_rect_info.end_y - m_rect_info.start_y) > (rect->end_y - rect->start_y)) {
VXLOGE("roi size is not matching, P(%d, %d), C(%d, %d)", rect->end_x - rect->start_x,
rect->end_y - rect->start_y,
m_rect_info.end_x - m_rect_info.start_x,
m_rect_info.end_y - m_rect_info.start_y);
displayInfo(0, vx_true_e);
status = VX_FAILURE;
goto EXIT;
}
rect->end_x = m_rect_info.end_x + rect->start_x;
rect->end_y = m_rect_info.end_y + rect->start_y;
rect->start_x += m_rect_info.start_x;
rect->start_y += m_rect_info.start_y;
EXIT:
return status;
}
vx_status
ExynosVisionImageROI::commitImageHandle(vx_uint32 plane_index,
const vx_int32 fd)
{
vx_status status;
if (m_cur_res != NULL) {
VXLOGE("resource should be null");
return VX_ERROR_NO_RESOURCES;
}
status = m_roi_parent->commitImageHandle(plane_index, fd);
if (status != VX_SUCCESS) {
VXLOGE("commit image handle fails, err:%d", status);
}
return status;
}
ExynosVisionDataReference*
ExynosVisionImageROI::getInputExclusiveRef(vx_uint32 frame_cnt, vx_bool *ret_data_valid)
{
if (m_res_type != RESOURCE_MNGR_NULL) {
VXLOGE("the mngr of ROI object should be null, %d, %d", frame_cnt, ret_data_valid);
*ret_data_valid = vx_false_e;
return NULL;
}
*ret_data_valid = vx_true_e;
return this;
}
vx_status
ExynosVisionImageROI::putInputExclusiveRef(vx_uint32 frame_cnt)
{
if (m_res_type != RESOURCE_MNGR_NULL) {
VXLOGE("the mngr of ROI object should be null, %d", frame_cnt);
return VX_FAILURE;
}
return VX_SUCCESS;
}
ExynosVisionDataReference*
ExynosVisionImageROI::getOutputExclusiveRef(vx_uint32 frame_cnt)
{
if (m_res_type != RESOURCE_MNGR_NULL) {
VXLOGE("the mngr of ROI object should be null, %d", frame_cnt);
return NULL;
}
return this;
}
vx_status
ExynosVisionImageROI::putOutputExclusiveRef(vx_uint32 frame_cnt, vx_bool data_valid)
{
if (m_res_type != RESOURCE_MNGR_NULL) {
VXLOGE("the mngr of ROI object should be null, %d, %d", frame_cnt, data_valid);
return VX_FAILURE;
}
return VX_SUCCESS;
}
ExynosVisionImageHandle::ExynosVisionImageHandle(ExynosVisionContext *context, ExynosVisionReference *scope)
: ExynosVisionImage(context, scope, vx_false_e)
{
}
vx_status
ExynosVisionImageHandle::destroy(void)
{
m_cur_res = NULL;
memset(&m_memory, 0x0, sizeof(m_memory));
m_is_allocated = vx_false_e;
return VX_SUCCESS;
}
vx_status
ExynosVisionImageHandle::swapImageHandle(void *const new_ptrs[], void *prev_ptrs[], vx_size num_planes)
{
if (m_external_lock.tryLock() != NO_ERROR) {
VXLOGE("%s is already locked by other object", getName());
return VX_FAILURE;
}
vx_status status = VX_SUCCESS;
if (m_planes != num_planes) {
VXLOGE("the number of planes is not equal, %d, %d", m_planes, num_planes);
status = VX_FAILURE;
goto EXIT;
}
if (m_continuous) {
vx_bool conitnuous_check = vx_false_e;
switch(m_format) {
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
if ((new_ptrs[0] == new_ptrs[1]) && (m_cur_res->size() == 1)) {
conitnuous_check = vx_true_e;
}
break;
case VX_DF_IMAGE_IYUV:
case VX_DF_IMAGE_YUV4:
if ((new_ptrs[0] == new_ptrs[1]) && (new_ptrs[1] == new_ptrs[2]) && (m_cur_res->size() == 1))
conitnuous_check = vx_true_e;
break;
}
if (conitnuous_check != vx_true_e) {
VXLOGE("%s created as continuous memory");
status = VX_FAILURE;
goto EXIT;
}
}
image_resource_t::iterator res_iter;
vx_uint32 m;
for (res_iter=m_cur_res->begin(), m=0; res_iter!=m_cur_res->end(); res_iter++, m++) {
if (m_import_type == VX_IMPORT_TYPE_HOST) {
if (prev_ptrs) {
prev_ptrs[m] = (*res_iter)->getAddr();
}
if (new_ptrs) {
(*res_iter)->import(new_ptrs[m], 0);
} else {
(*res_iter)->import(NULL, 0);
}
} else if (m_import_type == VX_IMPORT_TYPE_ION) {
if (prev_ptrs) {
prev_ptrs[m] = (void*)(long long)((*res_iter)->getFd());
}
if (new_ptrs) {
(*res_iter)->import(NULL, *((int*)&new_ptrs[m]));
} else {
(*res_iter)->import(NULL, 0);
}
} else {
VXLOGE("un-supported import type");
}
}
if (m_continuous) {
for (vx_uint32 i=0; i<num_planes; i++) {
prev_ptrs[i] = prev_ptrs[0];
}
}
EXIT:
m_external_lock.unlock();
return status;
}
vx_status
ExynosVisionImageHandle::checkContinuous(vx_df_image format, void *ptrs[])
{
switch(format) {
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
if (ptrs[0] == ptrs[1])
m_continuous = vx_true_e;
break;
case VX_DF_IMAGE_IYUV:
case VX_DF_IMAGE_YUV4:
if ((ptrs[0] == ptrs[1]) && (ptrs[1] == ptrs[2]))
m_continuous = vx_true_e;
break;
}
m_continuous = vx_false_e;
return VX_SUCCESS;
}
vx_status
ExynosVisionImageHandle::allocateMemory(vx_enum res_type, struct resource_param *param)
{
VXLOGE("%s, handle can't allocate memory, res_type:%d, &param:%p", getName(), res_type, param);
return VX_FAILURE;
}
vx_status
ExynosVisionImageHandle::importMemory(vx_imagepatch_addressing_t addrs[], void *ptrs[], vx_enum import_type)
{
EXYNOS_VISION_REF_IN();
vx_status status = VX_SUCCESS;
vx_uint32 m;
if (m_is_allocated == vx_false_e) {
VXLOGD3("%s, importing %u pointers\n", getName(), m_memory.memory_num);
m_res_type = RESOURCE_MNGR_SOLID;
image_resource_t *resource = new image_resource_t();
for (m = 0; m < m_memory.memory_num; m++) {
if (ptrs[m] == NULL || addrs[m].dim_x == 0) {
VXLOGE("importing memory information is empty, plane:%d", m);
status = VX_FAILURE;
break;
}
ExynosVisionBufMemory *buf = new ExynosVisionBufMemory();
if (import_type == VX_IMPORT_TYPE_HOST)
status = buf->import(ptrs[m], 0);
else if (import_type == VX_IMPORT_TYPE_ION)
status = buf->import(0, *((int*)&ptrs[m]));
else
status = VX_FAILURE;
if (status != VX_SUCCESS) {
VXLOGE("buffer allocation fails at %s", getName());
break;
}
if (status == VX_SUCCESS) {
m_memory.strides[m][0][VX_DIM_C] = m_memory.element_byte_size;
m_memory.strides[m][0][VX_DIM_X] = addrs[m].stride_x;
m_memory.strides[m][0][VX_DIM_Y] = addrs[m].stride_y;
m_plane_loc[m].memory_index = m;
m_plane_loc[m].subplane_index = 0;
}
resource->push_back(buf);
}
m_res_list.push_back(resource);
if (status == VX_SUCCESS) {
m_res_mngr = new ExynosVisionResSlotType<image_resource_t*>();
status = m_res_mngr->registerResource(resource);
} else {
VXLOGE("resource allocation fails at %s", getName());
}
if (status == VX_SUCCESS) {
m_res_type = RESOURCE_MNGR_SOLID;
m_cur_res = resource;
} else {
VXLOGE("buffer allocation fails, err:%d", status);
}
}
if (status == VX_SUCCESS) {
m_is_allocated = vx_true_e; /* don't let the system realloc this memory */
m_import_type = import_type;
}
EXIT:
return status;
}
ExynosVisionImageQueue::ExynosVisionImageQueue(ExynosVisionContext *context, ExynosVisionReference *scope)
: ExynosVisionImage(context, scope, vx_false_e)
{
}
vx_status
ExynosVisionImageQueue::allocateMemory(void)
{
vx_enum res_type;
struct resource_param res_param;
vx_status status = VX_SUCCESS;
if (m_is_allocated == vx_true_e) {
VXLOGE("already allocated memory %s", getName());
status = VX_FAILURE;
goto EXIT;
}
ExynosVisionReference *scope;
scope = getScope();
if (scope->getType() != VX_TYPE_GRAPH) {
VXLOGE("%s, queue data object should be belong to graph", getName());
status = VX_FAILURE;
goto EXIT;
}
if (((ExynosVisionGraph*)scope)->getExecMode() != GRAPH_EXEC_STREAM) {
VXLOGE("%s, queue data object should be belong to stream graph", getName());
status = VX_FAILURE;
goto EXIT;
}
if (getDirectInputNodeNum((ExynosVisionGraph*)scope) == 0) {
res_param.param.queue_param.direction = VX_INPUT;
} else if (getDirectOutputNodeNum((ExynosVisionGraph*)scope) == 0) {
res_param.param.queue_param.direction = VX_OUTPUT;
} else {
VXLOGE("%s, queue data object should be input or output of graph", getName());
status = VX_FAILURE;
goto EXIT;
}
res_type = RESOURCE_MNGR_QUEUE;
status = ((ExynosVisionDataReference*)this)->allocateMemory(res_type, &res_param);
if (status != VX_SUCCESS) {
VXLOGE("allocating memory fails, err:%d", status);
}
EXIT:
return status;
}
vx_status
ExynosVisionImageQueue::pushImagePatch(vx_uint32 index, void *ptrs[], vx_uint32 num_buf)
{
if (m_memory.memory_num!= num_buf) {
VXLOGE("param is not correct, expected num_buf:%d, received:%d", m_memory.memory_num, num_buf);
return VX_ERROR_INVALID_PARAMETERS;
}
if (m_res_type != RESOURCE_MNGR_QUEUE)
return VX_ERROR_INVALID_REFERENCE;
ExynosVisionGraph *graph = (ExynosVisionGraph*)getScope();
vx_status status = VX_SUCCESS;
image_resource_t *buf_vector = new image_resource_t();
for (vx_uint32 p = 0; p < m_memory.memory_num; p++) {
if (ptrs[p] == NULL) {
VXLOGE("imported buf is null");
return VX_ERROR_INVALID_PARAMETERS;
}
ExynosVisionBufMemory *buf = new ExynosVisionBufMemory();
status = buf->import(ptrs[p], 0);
if (status != VX_SUCCESS) {
VXLOGE("buffer allocation fails at %s", getName());
break;
}
buf_vector->push_back(buf);
}
if (getDirectInputNodeNum(graph) == 0) {
/* input queue type */
vx_uint32 frame_cnt = graph->requestNewFrameCnt(this);
m_res_mngr->pushResource(index, buf_vector, frame_cnt, getDirectOutputNodeNum(graph));
triggerDoneEventDirect(graph, frame_cnt);
} else if (getDirectOutputNodeNum(graph) == 0) {
/* output queue type */
m_res_mngr->pushResource(index, buf_vector);
} else {
VXLOGE("queue type object shoud be input or output of graph");
status = VX_ERROR_INVALID_GRAPH;
}
return status;
}
vx_status
ExynosVisionImageQueue::pushImageHandle(vx_uint32 index, vx_int32 fd[], vx_uint32 num_buf)
{
if (m_memory.memory_num != num_buf) {
VXLOGE("param is not correct, expected num_buf:%d, received:%d", m_memory.memory_num, num_buf);
return VX_ERROR_INVALID_PARAMETERS;
}
if (m_res_type != RESOURCE_MNGR_QUEUE)
return VX_ERROR_INVALID_REFERENCE;
ExynosVisionGraph *graph = (ExynosVisionGraph*)getScope();
vx_status status = VX_SUCCESS;
image_resource_t *buf_vector = new image_resource_t();
for (vx_uint32 p = 0; p < m_memory.memory_num; p++) {
ExynosVisionBufMemory *buf = new ExynosVisionBufMemory();
status = buf->import(NULL, fd[p]);
if (status != VX_SUCCESS) {
VXLOGE("buffer allocation fails at %s", getName());
break;
}
buf_vector->push_back(buf);
}
if (getDirectInputNodeNum(graph) == 0) {
/* input queue type */
vx_uint32 frame_cnt = graph->requestNewFrameCnt(this);
m_res_mngr->pushResource(index, buf_vector, frame_cnt, getDirectOutputNodeNum(graph));
triggerDoneEventDirect(graph, frame_cnt);
} else if (getDirectOutputNodeNum(graph) == 0) {
/* output queue type */
m_res_mngr->pushResource(index, buf_vector);
} else {
VXLOGE("queue type object shoud be input or output of graph");
status = VX_ERROR_INVALID_GRAPH;
}
return status;
}
vx_status
ExynosVisionImageQueue::popImage(vx_uint32 *ret_index, vx_bool *ret_data_valid)
{
vx_status status;
image_resource_t *buf_vector = NULL;
status = m_res_mngr->popResource(ret_index, ret_data_valid, &buf_vector);
if (status != VX_SUCCESS) {
VXLOGE("popping resource fails, err:%d", status);
return status;
}
for (vx_uint32 p = 0; p < m_memory.memory_num; p++) {
ExynosVisionBufMemory *buf = buf_vector->editItemAt(p);
delete buf;
}
delete buf_vector;
return status;
}
ExynosVisionDataReference*
ExynosVisionImageQueue::getInputExclusiveRef(vx_uint32 frame_cnt, vx_bool *ret_data_valid)
{
if (m_res_type != RESOURCE_MNGR_QUEUE) {
VXLOGE("the mngr of object object should be queue type, %d, %d", frame_cnt, ret_data_valid);
*ret_data_valid = vx_false_e;
return NULL;
}
ExynosVisionDataReference *ref = getInputExclusiveRef_T<image_resource_t>(m_res_mngr, frame_cnt, ret_data_valid, &m_cur_res);
if (*ret_data_valid == vx_false_e) {
VXLOGE("input queuing data should be valid");
displayInfo(0, vx_true_e);
}
return ref;
}
vx_status
ExynosVisionImageQueue::putInputExclusiveRef(vx_uint32 frame_cnt)
{
if (m_res_type != RESOURCE_MNGR_QUEUE) {
VXLOGE("the mngr of queue object should be queue type, %d", frame_cnt);
return VX_FAILURE;
}
return putInputExclusiveRef_T<image_resource_t>(m_res_mngr, frame_cnt, &m_cur_res);
}
ExynosVisionDataReference*
ExynosVisionImageQueue::getOutputExclusiveRef(vx_uint32 frame_cnt)
{
if (m_res_type != RESOURCE_MNGR_QUEUE) {
VXLOGE("the mngr of queue object should be queue type, %d", frame_cnt);
return NULL;
}
return getOutputExclusiveRef_T<image_resource_t>(m_res_mngr, frame_cnt, &m_cur_res);
}
vx_status
ExynosVisionImageQueue::putOutputExclusiveRef(vx_uint32 frame_cnt, vx_bool data_valid)
{
if (m_res_type != RESOURCE_MNGR_QUEUE) {
VXLOGE("the mngr of queue object should be queue type, %d", frame_cnt);
return VX_FAILURE;
}
return putOutputExclusiveRef_T<image_resource_t>(m_res_mngr, frame_cnt, &m_cur_res, data_valid);
}
ExynosVisionImageClone::ExynosVisionImageClone(ExynosVisionContext *context, ExynosVisionReference *scope)
: ExynosVisionImage(context, scope, vx_false_e)
{
}
vx_status
ExynosVisionImageClone::destroy(void)
{
m_cur_res = NULL;
memset(&m_memory, 0x0, sizeof(m_memory));
m_is_allocated = vx_false_e;
return VX_SUCCESS;
}
vx_status
ExynosVisionImageClone::allocateMemory(vx_enum res_type, struct resource_param *param)
{
VXLOGE("%s, clone can't allocate memory, res_type:%d, &param:%p", getName(), res_type, param);
return VX_FAILURE;
}
}; /* namespace android */