libvision/common/ExynosVisionConvolution.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 "ExynosVisionConvolution"
 #include <cutils/log.h>

 #include <VX/vx.h>

 #include "ExynosVisionConvolution.h"

 namespace android {

 static int isodd(size_t a)
 {
     return (int)(a & 1);
 }

 static vx_bool vxIsPowerOfTwo(vx_uint32 a)
 {
     if (a == 0)
         return vx_false_e;
     else if ((a & ((a) - 1)) == 0)
         return vx_true_e;
     else
         return vx_false_e;
 }

 vx_status
 ExynosVisionConvolution::checkValidCreateConvolution(vx_size columns, vx_size rows)
 {
     vx_status status = VX_SUCCESS;

     if (!(isodd(columns) && columns >= 3 && isodd(rows) && rows >= 3)) {
         VXLOGE("failed to create convolution, invalid dimensions");
         status = VX_ERROR_INVALID_DIMENSION;
     }

     return status;
 }

 ExynosVisionConvolution::ExynosVisionConvolution(ExynosVisionContext *context, ExynosVisionReference *scope)
                                                                : ExynosVisionDataReference(context, VX_TYPE_CONVOLUTION, scope, vx_true_e, vx_false_e)
 {
     m_res_mngr = NULL;
     m_cur_res = NULL;

     m_columns = 0;
     m_rows = 0;
     m_scale = 0;

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

 ExynosVisionConvolution::~ExynosVisionConvolution()
 {

 }

 void
 ExynosVisionConvolution::operator=(const ExynosVisionConvolution& src_conv)
 {
     m_columns = src_conv.m_columns;
     m_rows = src_conv.m_rows;

     m_scale = src_conv.m_scale;
 }

 vx_status
 ExynosVisionConvolution::init(vx_size columns, vx_size rows)
 {
     vx_status status = VX_SUCCESS;

     m_columns = columns;
     m_rows = rows;

     m_scale = 1;

     return status;
 }

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

     m_cur_res = NULL;

     m_columns = 0;
     m_rows = 0;
     m_scale = 0;

     status = freeMemory_T<convolution_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
 ExynosVisionConvolution::queryConvolution(vx_enum attribute, void *ptr, vx_size size)
 {
     vx_status status = VX_SUCCESS;

     if (m_is_allocated != vx_true_e) {
         status = ((ExynosVisionDataReference*)this)->allocateMemory();
         if (status != VX_SUCCESS) {
             VXLOGE("allocating memory fails");
             return VX_FAILURE;
         }
     }

     switch (attribute) {
     case VX_CONVOLUTION_ATTRIBUTE_ROWS:
         m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_ROWS, ptr, size);
         break;
     case VX_CONVOLUTION_ATTRIBUTE_COLUMNS:
         m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_COLUMNS, ptr, size);
         break;
     case VX_CONVOLUTION_ATTRIBUTE_SCALE:
         if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
             *(vx_uint32 *)ptr = m_scale;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_CONVOLUTION_ATTRIBUTE_SIZE:
         vx_size columns;
         vx_size rows;
         status = m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_COLUMNS,  &columns, sizeof(columns));
         status |= m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_ROWS,  &rows, sizeof(rows));
         if ((VX_CHECK_PARAM(ptr, size, vx_size, 0x3) && (status == VX_SUCCESS)))
             *(vx_size *)ptr = columns * rows * sizeof(vx_int16);
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     default:
         status = VX_ERROR_NOT_SUPPORTED;
         break;
     }

     return status;
 }

 vx_status
 ExynosVisionConvolution::setConvolutionAttribute(vx_enum attribute, const void *ptr, vx_size size)
 {
     vx_status status = VX_SUCCESS;

     switch (attribute) {
     case VX_CONVOLUTION_ATTRIBUTE_SCALE:
         if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
             vx_uint32 scale = *(vx_uint32 *)ptr;
             if (vxIsPowerOfTwo(scale) == vx_true_e) {
                 VXLOGD3("convolution scale assigned to %u", scale);
                 m_scale = scale;
             } else  {
                 VXLOGE("convolution scale should be power of two, scale:%d", scale);
                 status = VX_ERROR_INVALID_VALUE;
             }
         } else {
             status = VX_ERROR_INVALID_PARAMETERS;
         }
         break;
     default:
         status = VX_ERROR_INVALID_PARAMETERS;
         break;
     }

     return status;
 }

 vx_status
 ExynosVisionConvolution::readConvolutionCoefficients(vx_int16 *array)
 {
     vx_status status = VX_SUCCESS;

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

     status = m_cur_res->readMatrix(array);
     if (status != VX_SUCCESS)
         VXLOGE("read matrix(%s) fails, err:%d", m_cur_res->getName(), status);

 EXIT:
     return status;
 }

 vx_status
 ExynosVisionConvolution::writeConvolutionCoefficients(const vx_int16 *array)
 {
     vx_status status = VX_SUCCESS;

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

     status = m_cur_res->writeMatrix(array);
     if (status != VX_SUCCESS)
         VXLOGE("read matrix(%s) fails, err:%d", m_cur_res->getName(), status);

 EXIT:
     return status;
 }

 vx_status
 ExynosVisionConvolution::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
 ExynosVisionConvolution::allocateResource(convolution_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;

     ExynosVisionMatrix *matrix = new ExynosVisionMatrix(getContext(), this);
     status = matrix->getCreationStatus();
     if (status != VX_SUCCESS) {
         VXLOGE("matrix object creation fails, err:%d", status);
         delete matrix;
         goto EXIT;
     }

     status = matrix->init(VX_TYPE_INT16, m_columns, m_rows);
     if (status != VX_SUCCESS) {
         VXLOGE("matrix object init fails, err:%d", status);
         delete matrix;
         goto EXIT;
     }

     *ret_resource = matrix;
     matrix->incrementReference(VX_REF_INTERNAL, this);

 EXIT:

     return status;
 }

 vx_status
 ExynosVisionConvolution::freeResource(convolution_resource_t *array)
 {
     vx_status status = VX_SUCCESS;

     status = ExynosVisionReference::releaseReferenceInt((ExynosVisionReference**)&array, VX_REF_INTERNAL, this);
     if (status != VX_SUCCESS)
         VXLOGE("release %s fails at %s", array->getName(), this->getName());

     return status;
 }

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

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

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

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

 #ifdef USE_OPENCL_KERNEL

 vx_status
 ExynosVisionConvolution::getClMemoryInfo(cl_context clContext, vxcl_mem_t **memory)
 {
     vx_status status = VX_SUCCESS;

     if (m_is_allocated != vx_true_e) {
         status = ((ExynosVisionDataReference*)this)->allocateMemory();
         if (status != VX_SUCCESS) {
             VXLOGE("allocating memory fails at %s, err:%d", getName(), status);
             goto EXIT;
         }
     }

     status = m_cur_res->getClMemoryInfo(clContext, memory);

 EXIT:
     return status;
 }
 #endif
 }; /* 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 "ExynosVisionConvolution"
	#include <cutils/log.h>

	#include <VX/vx.h>

	#include "ExynosVisionConvolution.h"

	namespace android {

	static int isodd(size_t a)
	{
	return (int)(a & 1);
	}

	static vx_bool vxIsPowerOfTwo(vx_uint32 a)
	{
	if (a == 0)
	return vx_false_e;
	else if ((a & ((a) - 1)) == 0)
	return vx_true_e;
	else
	return vx_false_e;
	}

	vx_status
	ExynosVisionConvolution::checkValidCreateConvolution(vx_size columns, vx_size rows)
	{
	vx_status status = VX_SUCCESS;

	if (!(isodd(columns) && columns >= 3 && isodd(rows) && rows >= 3)) {
	VXLOGE("failed to create convolution, invalid dimensions");
	status = VX_ERROR_INVALID_DIMENSION;
	}

	return status;
	}

	ExynosVisionConvolution::ExynosVisionConvolution(ExynosVisionContext context, ExynosVisionReference scope)
	: ExynosVisionDataReference(context, VX_TYPE_CONVOLUTION, scope, vx_true_e, vx_false_e)
	{
	m_res_mngr = NULL;
	m_cur_res = NULL;

	m_columns = 0;
	m_rows = 0;
	m_scale = 0;

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

	ExynosVisionConvolution::~ExynosVisionConvolution()
	{

	}

	void
	ExynosVisionConvolution::operator=(const ExynosVisionConvolution& src_conv)
	{
	m_columns = src_conv.m_columns;
	m_rows = src_conv.m_rows;

	m_scale = src_conv.m_scale;
	}

	vx_status
	ExynosVisionConvolution::init(vx_size columns, vx_size rows)
	{
	vx_status status = VX_SUCCESS;

	m_columns = columns;
	m_rows = rows;

	m_scale = 1;

	return status;
	}

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

	m_cur_res = NULL;

	m_columns = 0;
	m_rows = 0;
	m_scale = 0;

	status = freeMemory_T<convolution_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
	ExynosVisionConvolution::queryConvolution(vx_enum attribute, void *ptr, vx_size size)
	{
	vx_status status = VX_SUCCESS;

	if (m_is_allocated != vx_true_e) {
	status = ((ExynosVisionDataReference*)this)->allocateMemory();
	if (status != VX_SUCCESS) {
	VXLOGE("allocating memory fails");
	return VX_FAILURE;
	}
	}

	switch (attribute) {
	case VX_CONVOLUTION_ATTRIBUTE_ROWS:
	m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_ROWS, ptr, size);
	break;
	case VX_CONVOLUTION_ATTRIBUTE_COLUMNS:
	m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_COLUMNS, ptr, size);
	break;
	case VX_CONVOLUTION_ATTRIBUTE_SCALE:
	if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
	(vx_uint32 )ptr = m_scale;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_CONVOLUTION_ATTRIBUTE_SIZE:
	vx_size columns;
	vx_size rows;
	status = m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns));
	status \|= m_cur_res->queryMatrix(VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows));
	if ((VX_CHECK_PARAM(ptr, size, vx_size, 0x3) && (status == VX_SUCCESS)))
	(vx_size )ptr = columns * rows * sizeof(vx_int16);
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	default:
	status = VX_ERROR_NOT_SUPPORTED;
	break;
	}

	return status;
	}

	vx_status
	ExynosVisionConvolution::setConvolutionAttribute(vx_enum attribute, const void *ptr, vx_size size)
	{
	vx_status status = VX_SUCCESS;

	switch (attribute) {
	case VX_CONVOLUTION_ATTRIBUTE_SCALE:
	if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
	vx_uint32 scale = (vx_uint32 )ptr;
	if (vxIsPowerOfTwo(scale) == vx_true_e) {
	VXLOGD3("convolution scale assigned to %u", scale);
	m_scale = scale;
	} else {
	VXLOGE("convolution scale should be power of two, scale:%d", scale);
	status = VX_ERROR_INVALID_VALUE;
	}
	} else {
	status = VX_ERROR_INVALID_PARAMETERS;
	}
	break;
	default:
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	}

	return status;
	}

	vx_status
	ExynosVisionConvolution::readConvolutionCoefficients(vx_int16 *array)
	{
	vx_status status = VX_SUCCESS;

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

	status = m_cur_res->readMatrix(array);
	if (status != VX_SUCCESS)
	VXLOGE("read matrix(%s) fails, err:%d", m_cur_res->getName(), status);

	EXIT:
	return status;
	}

	vx_status
	ExynosVisionConvolution::writeConvolutionCoefficients(const vx_int16 *array)
	{
	vx_status status = VX_SUCCESS;

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

	status = m_cur_res->writeMatrix(array);
	if (status != VX_SUCCESS)
	VXLOGE("read matrix(%s) fails, err:%d", m_cur_res->getName(), status);

	EXIT:
	return status;
	}

	vx_status
	ExynosVisionConvolution::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
	ExynosVisionConvolution::allocateResource(convolution_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;

	ExynosVisionMatrix *matrix = new ExynosVisionMatrix(getContext(), this);
	status = matrix->getCreationStatus();
	if (status != VX_SUCCESS) {
	VXLOGE("matrix object creation fails, err:%d", status);
	delete matrix;
	goto EXIT;
	}

	status = matrix->init(VX_TYPE_INT16, m_columns, m_rows);
	if (status != VX_SUCCESS) {
	VXLOGE("matrix object init fails, err:%d", status);
	delete matrix;
	goto EXIT;
	}

	*ret_resource = matrix;
	matrix->incrementReference(VX_REF_INTERNAL, this);

	EXIT:

	return status;
	}

	vx_status
	ExynosVisionConvolution::freeResource(convolution_resource_t *array)
	{
	vx_status status = VX_SUCCESS;

	status = ExynosVisionReference::releaseReferenceInt((ExynosVisionReference**)&array, VX_REF_INTERNAL, this);
	if (status != VX_SUCCESS)
	VXLOGE("release %s fails at %s", array->getName(), this->getName());

	return status;
	}

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

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

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

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

	#ifdef USE_OPENCL_KERNEL

	vx_status
	ExynosVisionConvolution::getClMemoryInfo(cl_context clContext, vxcl_mem_t **memory)
	{
	vx_status status = VX_SUCCESS;

	if (m_is_allocated != vx_true_e) {
	status = ((ExynosVisionDataReference*)this)->allocateMemory();
	if (status != VX_SUCCESS) {
	VXLOGE("allocating memory fails at %s, err:%d", getName(), status);
	goto EXIT;
	}
	}

	status = m_cur_res->getClMemoryInfo(clContext, memory);

	EXIT:
	return status;
	}
	#endif
	}; /* namespace android */