libvision/common/ExynosVisionPyramid.cpp - LeafOS-Devices/android_hardware_samsung_slsi-linaro_exynos - Gitiles

 /*
  * 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 "ExynosVisionPyramid"
 #include <cutils/log.h>

 #include <VX/vx.h>

 #include "ExynosVisionPyramid.h"
 #include "ExynosVisionDelay.h"

 namespace android {

 vx_status
 ExynosVisionPyramid::checkValidCreatePyramid(vx_size levels, vx_float32 scale, vx_uint32 width, vx_uint32 height, vx_df_image format)
 {
     if ((width == 0) || (height == 0) || (format == VX_DF_IMAGE_VIRT))
         return VX_ERROR_INVALID_PARAMETERS;

     if ((scale != VX_SCALE_PYRAMID_HALF) &&
         (scale != VX_SCALE_PYRAMID_ORB))
         return VX_ERROR_INVALID_PARAMETERS;

     if (levels == 0 || levels > 8)
         return VX_ERROR_INVALID_PARAMETERS;

     return VX_SUCCESS;
 }

 ExynosVisionPyramid::ExynosVisionPyramid(ExynosVisionContext *context, ExynosVisionReference *scope, vx_bool is_virtual)
                                                                : ExynosVisionDataReference(context, VX_TYPE_PYRAMID, scope, vx_true_e, is_virtual)
 {
     m_res_mngr = NULL;
     m_cur_res = NULL;

     m_num_level = 0;
     m_scale = 0;

     m_width = 0;
     m_height = 0;
     m_format = 0;

 #ifdef USE_OPENCL_KERNEL
     m_cl_memory.allocated = vx_false_e;
 #endif
 }

 ExynosVisionPyramid::~ExynosVisionPyramid()
 {

 }

 void
 ExynosVisionPyramid::operator=(const ExynosVisionPyramid& src_pyramid)
 {
     m_num_level = src_pyramid.m_num_level;
     m_scale = src_pyramid.m_scale;

     m_width = src_pyramid.m_width;
     m_height = src_pyramid.m_height;
     m_format = src_pyramid.m_format;
 }

 vx_status
 ExynosVisionPyramid::init(vx_size levels, vx_float32 scale, vx_uint32 width, vx_uint32 height, vx_df_image format)
 {
     vx_status status = VX_SUCCESS;

     /* very first init will come in here */
     m_num_level = levels;
     m_scale = scale;

     /* these could be "virtual" values or hard values */
     m_width = width;
     m_height = height;
     m_format = format;

     return status;
 }

 vx_status
 ExynosVisionPyramid::destroy(void)
 {
     vx_status status = VX_SUCCESS;

     /* very first init will come in here */
     m_num_level = 0;
     m_scale = 0;

     /* these could be "virtual" values or hard values */
     m_width = 0;
     m_height = 0;
     m_format = 0;

     m_cur_res = NULL;

     status = freeMemory_T<pyramid_resource_t>(&m_res_mngr, &m_res_list);
     if (status != VX_SUCCESS)
         VXLOGE("free memory fails at %s, err:%d", getName(), status);

     return status;
 }

 ExynosVisionImage*
 ExynosVisionPyramid::getPyramidLevel(vx_uint32 index)
 {
     ExynosVisionImage *image = NULL;

     if (index < m_num_level) {
         if (m_is_allocated != vx_true_e) {
             vx_status status = ((ExynosVisionDataReference*)this)->allocateMemory();
             if (status != VX_SUCCESS) {
                 VXLOGE("memory is not allocated yet");
                 goto EXIT;
             }
         }

         image = m_cur_res->editItemAt(index);
         image->incrementReference(VX_REF_EXTERNAL);
     }

 EXIT:
     return image;
 }

 vx_status
 ExynosVisionPyramid::queryPyramid(vx_enum attribute, void *ptr, vx_size size)
 {
     vx_status status = VX_SUCCESS;

     switch (attribute) {
     case VX_PYRAMID_ATTRIBUTE_LEVELS:
         if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
             *(vx_size *)ptr = m_num_level;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_PYRAMID_ATTRIBUTE_SCALE:
         if (VX_CHECK_PARAM(ptr, size, vx_float32, 0x3))
             *(vx_float32 *)ptr = m_scale;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_PYRAMID_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_PYRAMID_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_PYRAMID_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;
     default:
         status = VX_ERROR_NOT_SUPPORTED;
         break;
     }

     return status;
 }

 vx_status
 ExynosVisionPyramid::verifyMeta(ExynosVisionMeta *meta)
 {
     vx_status status = VX_SUCCESS;

     vx_size num_level;
     vx_float32 scale;
     vx_uint32 width;
     vx_uint32 height;
     vx_df_image format;

     status |= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_LEVELS, &num_level, sizeof(num_level));
     status |= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_SCALE, &scale, sizeof(scale));
     status |= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_WIDTH, &width, sizeof(width));
     status |= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_HEIGHT, &height, sizeof(height));
     status |= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_FORMAT, &format, sizeof(format));
     if (status != VX_SUCCESS) {
         VXLOGE("get meta fail, err:%d", status);
     }

     if ((m_num_level != num_level) || (m_scale != scale)) {
         status = VX_ERROR_INVALID_VALUE;
         VXLOGE("Either levels (%u = %u) or scale (%lf = %lf) are invalid",
                 m_num_level, num_level,
                 m_scale, scale);
         getContext()->addLogEntry(this, status, "Either levels (%u?=%u) or scale (%lf?=%lf) are invalid\n",
                 m_num_level, num_level,
                 m_scale, scale);
         goto EXIT;
     }

     if ((m_format != VX_DF_IMAGE_VIRT) && (m_format != format)) {
         status = VX_ERROR_INVALID_FORMAT;
         VXLOGE("Invalid pyramid format %x, needs %x",
                 m_format, format);
         getContext()->addLogEntry(this, status, "Invalid pyramid format %x, needs %x\n",
                 m_format, format);
         goto EXIT;
     }

     if (((m_width != 0) && (m_width != width)) ||
         ((m_height != 0) && (m_height != height))) {
         status = VX_ERROR_INVALID_DIMENSION;
         VXLOGE("Invalid pyramid dimensions %ux%u, needs %ux%u",
                 m_width, m_height, width, height);
         getContext()->addLogEntry(this, status, "Invalid pyramid dimensions %ux%u, needs %ux%u\n",
                 m_width, m_height, width, height);
         goto EXIT;
     }

     if (isVirtual()) {
         init(m_num_level, m_scale, width, height, format);
     }

 EXIT:

     return status;
 }

 vx_status
 ExynosVisionPyramid::allocateMemory(vx_enum res_type, struct resource_param *param)
 {
     return allocateMemory_T(res_type, param, vx_false_e, &m_res_mngr, &m_res_list, &m_cur_res);
 }

 vx_status
 ExynosVisionPyramid::allocateResource(pyramid_resource_t **ret_resource)
 {
     if (ret_resource == NULL) {
         VXLOGE("pointer is null at %s", getName());
         return VX_ERROR_INVALID_PARAMETERS;
     }

     vx_status status = VX_SUCCESS;
     pyramid_resource_t *resource = new pyramid_resource_t();

     vx_uint32 w = m_width;
     vx_uint32 h = m_height;

     for (vx_uint32 i = 0; i < m_num_level; i++) {
         ExynosVisionImage *image = new ExynosVisionImage(getContext(), this, vx_false_e);
         image->incrementReference(VX_REF_INTERNAL, this);
         status = image->init(w, h, m_format);
         resource->push_back(image);

         w = (vx_uint32)ceilf((vx_float32)w * m_scale);
         h = (vx_uint32)ceilf((vx_float32)h * m_scale);

         ExynosVisionDataReference::jointAlliance(this, image);
     }

     *ret_resource = resource;

     return status;
 }

 vx_status
 ExynosVisionPyramid::freeResource(pyramid_resource_t *image_vector)
 {
     vx_status status = VX_SUCCESS;

     Vector<ExynosVisionImage*>::iterator image_iter;
     for(image_iter=image_vector->begin(); image_iter!=image_vector->end(); image_iter++) {
         if (*image_iter != NULL) {
             status = ExynosVisionReference::releaseReferenceInt((ExynosVisionReference**)&(*image_iter), VX_REF_INTERNAL, this);
             if (status != VX_SUCCESS)
                 VXLOGE("release %s fails at %s", (*image_iter)->getName(), this->getName());
         }
     }
     image_vector->clear();
     delete image_vector;

     return status;
 }

 ExynosVisionDataReference*
 ExynosVisionPyramid::getInputShareRef(vx_uint32 frame_cnt, vx_bool *ret_data_valid)
 {
     return getInputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt, ret_data_valid);
 }

 vx_status
 ExynosVisionPyramid::putInputShareRef(vx_uint32 frame_cnt)
 {
     return putInputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt);
 }

 ExynosVisionDataReference*
 ExynosVisionPyramid::getOutputShareRef(vx_uint32 frame_cnt)
 {
     return getOutputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt);
 }

 vx_status
 ExynosVisionPyramid::putOutputShareRef(vx_uint32 frame_cnt, vx_uint32 demand_num, vx_bool data_valid)
 {
     return putOutputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt, demand_num, data_valid);
 }

 void
 ExynosVisionPyramid::displayInfo(vx_uint32 tab_num, vx_bool detail_info)
 {
     vx_char tap[MAX_TAB_NUM];

     VXLOGI("%s[Pyramid] %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[--Pyram] alliance : %s", MAKE_TAB(tap, tab_num), (*ref_iter)->getName());
     }

     if (isDelayElement())
         VXLOGI("%s          delay element, %s, delay phy index:%d", MAKE_TAB(tap, tab_num), getDelay()->getName(), getDelaySlotIndex());

     LOG_FLUSH_TIME();

     if (detail_info)
         displayConn(tab_num);
 }

 }; /* namespace android */
	/*
	* 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 "ExynosVisionPyramid"
	#include <cutils/log.h>

	#include <VX/vx.h>

	#include "ExynosVisionPyramid.h"
	#include "ExynosVisionDelay.h"

	namespace android {

	vx_status
	ExynosVisionPyramid::checkValidCreatePyramid(vx_size levels, vx_float32 scale, vx_uint32 width, vx_uint32 height, vx_df_image format)
	{
	if ((width == 0) \|\| (height == 0) \|\| (format == VX_DF_IMAGE_VIRT))
	return VX_ERROR_INVALID_PARAMETERS;

	if ((scale != VX_SCALE_PYRAMID_HALF) &&
	(scale != VX_SCALE_PYRAMID_ORB))
	return VX_ERROR_INVALID_PARAMETERS;

	if (levels == 0 \|\| levels > 8)
	return VX_ERROR_INVALID_PARAMETERS;

	return VX_SUCCESS;
	}

	ExynosVisionPyramid::ExynosVisionPyramid(ExynosVisionContext context, ExynosVisionReference scope, vx_bool is_virtual)
	: ExynosVisionDataReference(context, VX_TYPE_PYRAMID, scope, vx_true_e, is_virtual)
	{
	m_res_mngr = NULL;
	m_cur_res = NULL;

	m_num_level = 0;
	m_scale = 0;

	m_width = 0;
	m_height = 0;
	m_format = 0;

	#ifdef USE_OPENCL_KERNEL
	m_cl_memory.allocated = vx_false_e;
	#endif
	}

	ExynosVisionPyramid::~ExynosVisionPyramid()
	{

	}

	void
	ExynosVisionPyramid::operator=(const ExynosVisionPyramid& src_pyramid)
	{
	m_num_level = src_pyramid.m_num_level;
	m_scale = src_pyramid.m_scale;

	m_width = src_pyramid.m_width;
	m_height = src_pyramid.m_height;
	m_format = src_pyramid.m_format;
	}

	vx_status
	ExynosVisionPyramid::init(vx_size levels, vx_float32 scale, vx_uint32 width, vx_uint32 height, vx_df_image format)
	{
	vx_status status = VX_SUCCESS;

	/* very first init will come in here */
	m_num_level = levels;
	m_scale = scale;

	/* these could be "virtual" values or hard values */
	m_width = width;
	m_height = height;
	m_format = format;

	return status;
	}

	vx_status
	ExynosVisionPyramid::destroy(void)
	{
	vx_status status = VX_SUCCESS;

	/* very first init will come in here */
	m_num_level = 0;
	m_scale = 0;

	/* these could be "virtual" values or hard values */
	m_width = 0;
	m_height = 0;
	m_format = 0;

	m_cur_res = NULL;

	status = freeMemory_T<pyramid_resource_t>(&m_res_mngr, &m_res_list);
	if (status != VX_SUCCESS)
	VXLOGE("free memory fails at %s, err:%d", getName(), status);

	return status;
	}

	ExynosVisionImage*
	ExynosVisionPyramid::getPyramidLevel(vx_uint32 index)
	{
	ExynosVisionImage *image = NULL;

	if (index < m_num_level) {
	if (m_is_allocated != vx_true_e) {
	vx_status status = ((ExynosVisionDataReference*)this)->allocateMemory();
	if (status != VX_SUCCESS) {
	VXLOGE("memory is not allocated yet");
	goto EXIT;
	}
	}

	image = m_cur_res->editItemAt(index);
	image->incrementReference(VX_REF_EXTERNAL);
	}

	EXIT:
	return image;
	}

	vx_status
	ExynosVisionPyramid::queryPyramid(vx_enum attribute, void *ptr, vx_size size)
	{
	vx_status status = VX_SUCCESS;

	switch (attribute) {
	case VX_PYRAMID_ATTRIBUTE_LEVELS:
	if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
	(vx_size )ptr = m_num_level;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_PYRAMID_ATTRIBUTE_SCALE:
	if (VX_CHECK_PARAM(ptr, size, vx_float32, 0x3))
	(vx_float32 )ptr = m_scale;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_PYRAMID_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_PYRAMID_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_PYRAMID_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;
	default:
	status = VX_ERROR_NOT_SUPPORTED;
	break;
	}

	return status;
	}

	vx_status
	ExynosVisionPyramid::verifyMeta(ExynosVisionMeta *meta)
	{
	vx_status status = VX_SUCCESS;

	vx_size num_level;
	vx_float32 scale;
	vx_uint32 width;
	vx_uint32 height;
	vx_df_image format;

	status \|= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_LEVELS, &num_level, sizeof(num_level));
	status \|= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_SCALE, &scale, sizeof(scale));
	status \|= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_WIDTH, &width, sizeof(width));
	status \|= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_HEIGHT, &height, sizeof(height));
	status \|= meta->getMetaFormatAttribute(VX_PYRAMID_ATTRIBUTE_FORMAT, &format, sizeof(format));
	if (status != VX_SUCCESS) {
	VXLOGE("get meta fail, err:%d", status);
	}

	if ((m_num_level != num_level) \|\| (m_scale != scale)) {
	status = VX_ERROR_INVALID_VALUE;
	VXLOGE("Either levels (%u = %u) or scale (%lf = %lf) are invalid",
	m_num_level, num_level,
	m_scale, scale);
	getContext()->addLogEntry(this, status, "Either levels (%u?=%u) or scale (%lf?=%lf) are invalid\n",
	m_num_level, num_level,
	m_scale, scale);
	goto EXIT;
	}

	if ((m_format != VX_DF_IMAGE_VIRT) && (m_format != format)) {
	status = VX_ERROR_INVALID_FORMAT;
	VXLOGE("Invalid pyramid format %x, needs %x",
	m_format, format);
	getContext()->addLogEntry(this, status, "Invalid pyramid format %x, needs %x\n",
	m_format, format);
	goto EXIT;
	}

	if (((m_width != 0) && (m_width != width)) \|\|
	((m_height != 0) && (m_height != height))) {
	status = VX_ERROR_INVALID_DIMENSION;
	VXLOGE("Invalid pyramid dimensions %ux%u, needs %ux%u",
	m_width, m_height, width, height);
	getContext()->addLogEntry(this, status, "Invalid pyramid dimensions %ux%u, needs %ux%u\n",
	m_width, m_height, width, height);
	goto EXIT;
	}

	if (isVirtual()) {
	init(m_num_level, m_scale, width, height, format);
	}

	EXIT:

	return status;
	}

	vx_status
	ExynosVisionPyramid::allocateMemory(vx_enum res_type, struct resource_param *param)
	{
	return allocateMemory_T(res_type, param, vx_false_e, &m_res_mngr, &m_res_list, &m_cur_res);
	}

	vx_status
	ExynosVisionPyramid::allocateResource(pyramid_resource_t **ret_resource)
	{
	if (ret_resource == NULL) {
	VXLOGE("pointer is null at %s", getName());
	return VX_ERROR_INVALID_PARAMETERS;
	}

	vx_status status = VX_SUCCESS;
	pyramid_resource_t *resource = new pyramid_resource_t();

	vx_uint32 w = m_width;
	vx_uint32 h = m_height;

	for (vx_uint32 i = 0; i < m_num_level; i++) {
	ExynosVisionImage *image = new ExynosVisionImage(getContext(), this, vx_false_e);
	image->incrementReference(VX_REF_INTERNAL, this);
	status = image->init(w, h, m_format);
	resource->push_back(image);

	w = (vx_uint32)ceilf((vx_float32)w * m_scale);
	h = (vx_uint32)ceilf((vx_float32)h * m_scale);

	ExynosVisionDataReference::jointAlliance(this, image);
	}

	*ret_resource = resource;

	return status;
	}

	vx_status
	ExynosVisionPyramid::freeResource(pyramid_resource_t *image_vector)
	{
	vx_status status = VX_SUCCESS;

	Vector<ExynosVisionImage*>::iterator image_iter;
	for(image_iter=image_vector->begin(); image_iter!=image_vector->end(); image_iter++) {
	if (*image_iter != NULL) {
	status = ExynosVisionReference::releaseReferenceInt((ExynosVisionReference*)&(image_iter), VX_REF_INTERNAL, this);
	if (status != VX_SUCCESS)
	VXLOGE("release %s fails at %s", (*image_iter)->getName(), this->getName());
	}
	}
	image_vector->clear();
	delete image_vector;

	return status;
	}

	ExynosVisionDataReference*
	ExynosVisionPyramid::getInputShareRef(vx_uint32 frame_cnt, vx_bool *ret_data_valid)
	{
	return getInputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt, ret_data_valid);
	}

	vx_status
	ExynosVisionPyramid::putInputShareRef(vx_uint32 frame_cnt)
	{
	return putInputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt);
	}

	ExynosVisionDataReference*
	ExynosVisionPyramid::getOutputShareRef(vx_uint32 frame_cnt)
	{
	return getOutputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt);
	}

	vx_status
	ExynosVisionPyramid::putOutputShareRef(vx_uint32 frame_cnt, vx_uint32 demand_num, vx_bool data_valid)
	{
	return putOutputShareRef_T<pyramid_resource_t>(m_res_mngr, frame_cnt, demand_num, data_valid);
	}

	void
	ExynosVisionPyramid::displayInfo(vx_uint32 tab_num, vx_bool detail_info)
	{
	vx_char tap[MAX_TAB_NUM];

	VXLOGI("%s[Pyramid] %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[--Pyram] alliance : %s", MAKE_TAB(tap, tab_num), (*ref_iter)->getName());
	}

	if (isDelayElement())
	VXLOGI("%s delay element, %s, delay phy index:%d", MAKE_TAB(tap, tab_num), getDelay()->getName(), getDelaySlotIndex());

	LOG_FLUSH_TIME();

	if (detail_info)
	displayConn(tab_num);
	}

	}; /* namespace android */