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

 #include <VX/vx.h>

 #include "ExynosVisionDistribution.h"

 namespace android {

 vx_status
 ExynosVisionDistribution::checkValidCreateDistribution(vx_size numBins, vx_uint32 range)
 {
     vx_status status = VX_ERROR_INVALID_PARAMETERS;

     if ((numBins != 0) && (range != 0)) {
         status = VX_SUCCESS;
     }

     return status;
 }

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

     m_memory.usage = 0;

     m_window_x = 0;
     m_offset_x = 0;
     m_range_x = 0;
     m_num_bins = 0;

 #ifdef USE_OPENCL_KERNEL
     m_cl_memory.allocated = vx_false_e;
 #endif

 }

 ExynosVisionDistribution::~ExynosVisionDistribution()
 {

 }

 void
 ExynosVisionDistribution::operator=(const ExynosVisionDistribution& src_dist)
 {
     m_num_bins = src_dist.m_num_bins;
     m_window_x = src_dist.m_window_x;
     m_offset_x = src_dist.m_offset_x;
     m_range_x = src_dist.m_range_x;
 }

 vx_status
 ExynosVisionDistribution::init(vx_size numBins, vx_int32 offset, vx_uint32 range)
 {
     vx_status status = VX_SUCCESS;

     m_num_bins = numBins;
     m_window_x = (vx_uint32)range/(vx_uint32)numBins;

     m_offset_x = offset;
     m_range_x = range;

     if ((range % numBins) != 0) {
         VXLOGW("range is not multiply of numBins");
         VXLOGW("numBins:%d, offset:%d, range:%d, m_window_x:%d", numBins, offset, range, m_window_x);
     }

     return status;
 }

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

     m_cur_res = NULL;

     memset(&m_memory, 0x0, sizeof(m_memory));

     m_window_x = 0;
     m_offset_x = 0;
     m_range_x = 0;
     m_num_bins = 0;

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

     switch (attribute) {
     case VX_DISTRIBUTION_ATTRIBUTE_DIMENSIONS:
         if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
             *(vx_size*)ptr = 1;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_DISTRIBUTION_ATTRIBUTE_RANGE:
         if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
             *(vx_uint32*)ptr = m_range_x;
         } else {
             status = VX_ERROR_INVALID_PARAMETERS;
         }
         break;
     case VX_DISTRIBUTION_ATTRIBUTE_BINS:
         if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
             *(vx_size*)ptr = (vx_size)m_num_bins;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_DISTRIBUTION_ATTRIBUTE_WINDOW:
         if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
             *(vx_uint32*)ptr = m_window_x;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_DISTRIBUTION_ATTRIBUTE_OFFSET:
         if (VX_CHECK_PARAM(ptr, size, vx_int32, 0x3))
             *(vx_int32*)ptr = m_offset_x;
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     case VX_DISTRIBUTION_ATTRIBUTE_SIZE:
         if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
             *(vx_size*)ptr = m_num_bins * sizeof(vx_int32);
         else
             status = VX_ERROR_INVALID_PARAMETERS;
         break;
     default:
         status = VX_ERROR_NOT_SUPPORTED;
         break;
     }

     return status;
 }

 vx_status
 ExynosVisionDistribution::accessDistribution(void **ptr, vx_enum usage)
 {
     vx_status status = VX_FAILURE;

     if (m_is_allocated != vx_true_e) {
         status = ((ExynosVisionDataReference*)this)->allocateMemory();
         if (status != VX_SUCCESS)
             return status;
     }

     if (ptr != NULL) {
         m_memory.usage = usage;
         if (usage != VX_READ_ONLY)
             m_memory_lock.lock();

         m_internal_lock.lock();
         if (*ptr == NULL) {
             vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
             *ptr = base_ptr;
         } else if (*ptr != NULL) {
             vx_size size = m_num_bins * sizeof(vx_int32);
             vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
             memcpy(*ptr, base_ptr, size);
         }
         m_internal_lock.unlock();

         incrementReference(VX_REF_EXTERNAL);
         status = VX_SUCCESS;
     }

     return status;
 }

 vx_status
 ExynosVisionDistribution::accessDistributionHandle(vx_int32 *fd, vx_enum usage)
 {
     vx_status status = VX_FAILURE;

     if (m_is_allocated != vx_true_e) {
         status = ((ExynosVisionDataReference*)this)->allocateMemory();
         if (status != VX_SUCCESS)
             return status;
     }

     m_memory.usage = usage;
     if (usage != VX_READ_ONLY)
         m_memory_lock.lock();

     m_internal_lock.lock();
     *fd = m_cur_res->getFd();
     m_internal_lock.unlock();

     incrementReference(VX_REF_EXTERNAL);
     status = VX_SUCCESS;

     return status;
 }

 vx_status
 ExynosVisionDistribution::commitDistribution(const void *ptr)
 {
     vx_status status = VX_FAILURE;

     if (m_is_allocated != vx_true_e) {
         status =  ((ExynosVisionDataReference*)this)->allocateMemory();
         if (status != VX_SUCCESS)
             return status;
     }

     if (ptr != NULL) {
         m_internal_lock.lock();
         vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
         if (ptr != base_ptr) {
             vx_size size = m_num_bins * sizeof(vx_int32);
             vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
             memcpy(base_ptr, ptr, size);
             VXLOGD("copied distribution from %p to %p for %d bytes\n", ptr, base_ptr, size);
         }
         m_internal_lock.unlock();

         if (m_memory.usage != VX_READ_ONLY)
             m_memory_lock.unlock();

         decrementReference(VX_REF_EXTERNAL);
         status = VX_SUCCESS;
     }

     return status;
 }

 vx_status
 ExynosVisionDistribution::commitDistributionHandle(const vx_int32 fd)
 {
     if (fd == 0) {
         return VX_ERROR_INVALID_PARAMETERS;
     }

     /* 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" array. */
             VXLOGE("Can not access a virtual array");
             return VX_ERROR_OPTIMIZED_AWAY;
         }
         /* framework trying to access a virtual image, this is ok. */
     }

     if (m_memory.usage != VX_READ_ONLY)
         m_memory_lock.unlock();

     decrementReference(VX_REF_EXTERNAL);

     return VX_SUCCESS;
 }

 vx_status
 ExynosVisionDistribution::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
 ExynosVisionDistribution::allocateResource(default_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;
     default_resource_t *memory = new default_resource_t();

     vx_size size = m_num_bins * sizeof(vx_int32);
     status = memory->alloc(m_allocator, size);
     if (status != VX_SUCCESS)
         VXLOGE("memory allocation fails at %s", getName());

     *ret_resource = memory;

     return status;
 }

 vx_status
 ExynosVisionDistribution::freeResource(default_resource_t *memory)
 {
     vx_status status = VX_SUCCESS;

     status = memory->free(m_allocator);
     if (status != VX_SUCCESS)
         VXLOGE("memory free fail, err:%d", status);
     delete memory;

     return status;
 }

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

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

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

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

 #ifdef USE_OPENCL_KERNEL
 vx_status
 ExynosVisionDistribution::getClMemoryInfo(cl_context clContext, vxcl_mem_t **memory)
 {
     vx_status status = VX_SUCCESS;
     cl_int err = 0;

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

     m_cl_memory.cl_type = CL_MEM_OBJECT_BUFFER;
     m_cl_memory.nptrs = VX_NUM_DEFAULT_PLANES;
     m_cl_memory.ndims = VX_NUM_DEFAULT_DIMS;

     m_cl_memory.ptrs[VX_CL_PLANE_0] = (vx_uint8 *)m_cur_res->getAddr();
     m_cl_memory.sizes[VX_CL_PLANE_0] = (vx_size)(m_num_bins * sizeof(vx_int32));
     m_cl_memory.hdls[VX_CL_PLANE_0] = clCreateBuffer(clContext,
                                         CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
                                         m_cl_memory.sizes[VX_CL_PLANE_0],
                                         m_cl_memory.ptrs[VX_CL_PLANE_0],
                                         &err);
     if (err != CL_SUCCESS) {
         VXLOGE("failed in clCreateBuffer : err(%d)", err);
         m_cl_memory.allocated = vx_false_e;
         *memory = NULL;
     } else {
         m_cl_memory.allocated = vx_true_e;
         *memory = &m_cl_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 "ExynosVisionDistribution"
	#include <cutils/log.h>

	#include <VX/vx.h>

	#include "ExynosVisionDistribution.h"

	namespace android {

	vx_status
	ExynosVisionDistribution::checkValidCreateDistribution(vx_size numBins, vx_uint32 range)
	{
	vx_status status = VX_ERROR_INVALID_PARAMETERS;

	if ((numBins != 0) && (range != 0)) {
	status = VX_SUCCESS;
	}

	return status;
	}

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

	m_memory.usage = 0;

	m_window_x = 0;
	m_offset_x = 0;
	m_range_x = 0;
	m_num_bins = 0;

	#ifdef USE_OPENCL_KERNEL
	m_cl_memory.allocated = vx_false_e;
	#endif

	}

	ExynosVisionDistribution::~ExynosVisionDistribution()
	{

	}

	void
	ExynosVisionDistribution::operator=(const ExynosVisionDistribution& src_dist)
	{
	m_num_bins = src_dist.m_num_bins;
	m_window_x = src_dist.m_window_x;
	m_offset_x = src_dist.m_offset_x;
	m_range_x = src_dist.m_range_x;
	}

	vx_status
	ExynosVisionDistribution::init(vx_size numBins, vx_int32 offset, vx_uint32 range)
	{
	vx_status status = VX_SUCCESS;

	m_num_bins = numBins;
	m_window_x = (vx_uint32)range/(vx_uint32)numBins;

	m_offset_x = offset;
	m_range_x = range;

	if ((range % numBins) != 0) {
	VXLOGW("range is not multiply of numBins");
	VXLOGW("numBins:%d, offset:%d, range:%d, m_window_x:%d", numBins, offset, range, m_window_x);
	}

	return status;
	}

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

	m_cur_res = NULL;

	memset(&m_memory, 0x0, sizeof(m_memory));

	m_window_x = 0;
	m_offset_x = 0;
	m_range_x = 0;
	m_num_bins = 0;

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

	switch (attribute) {
	case VX_DISTRIBUTION_ATTRIBUTE_DIMENSIONS:
	if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
	(vx_size)ptr = 1;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_DISTRIBUTION_ATTRIBUTE_RANGE:
	if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3)) {
	(vx_uint32)ptr = m_range_x;
	} else {
	status = VX_ERROR_INVALID_PARAMETERS;
	}
	break;
	case VX_DISTRIBUTION_ATTRIBUTE_BINS:
	if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
	(vx_size)ptr = (vx_size)m_num_bins;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_DISTRIBUTION_ATTRIBUTE_WINDOW:
	if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
	(vx_uint32)ptr = m_window_x;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_DISTRIBUTION_ATTRIBUTE_OFFSET:
	if (VX_CHECK_PARAM(ptr, size, vx_int32, 0x3))
	(vx_int32)ptr = m_offset_x;
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	case VX_DISTRIBUTION_ATTRIBUTE_SIZE:
	if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
	(vx_size)ptr = m_num_bins * sizeof(vx_int32);
	else
	status = VX_ERROR_INVALID_PARAMETERS;
	break;
	default:
	status = VX_ERROR_NOT_SUPPORTED;
	break;
	}

	return status;
	}

	vx_status
	ExynosVisionDistribution::accessDistribution(void **ptr, vx_enum usage)
	{
	vx_status status = VX_FAILURE;

	if (m_is_allocated != vx_true_e) {
	status = ((ExynosVisionDataReference*)this)->allocateMemory();
	if (status != VX_SUCCESS)
	return status;
	}

	if (ptr != NULL) {
	m_memory.usage = usage;
	if (usage != VX_READ_ONLY)
	m_memory_lock.lock();

	m_internal_lock.lock();
	if (*ptr == NULL) {
	vx_uint8 base_ptr = (vx_uint8 )m_cur_res->getAddr();
	*ptr = base_ptr;
	} else if (*ptr != NULL) {
	vx_size size = m_num_bins * sizeof(vx_int32);
	vx_uint8 base_ptr = (vx_uint8 )m_cur_res->getAddr();
	memcpy(*ptr, base_ptr, size);
	}
	m_internal_lock.unlock();

	incrementReference(VX_REF_EXTERNAL);
	status = VX_SUCCESS;
	}

	return status;
	}

	vx_status
	ExynosVisionDistribution::accessDistributionHandle(vx_int32 *fd, vx_enum usage)
	{
	vx_status status = VX_FAILURE;

	if (m_is_allocated != vx_true_e) {
	status = ((ExynosVisionDataReference*)this)->allocateMemory();
	if (status != VX_SUCCESS)
	return status;
	}

	m_memory.usage = usage;
	if (usage != VX_READ_ONLY)
	m_memory_lock.lock();

	m_internal_lock.lock();
	*fd = m_cur_res->getFd();
	m_internal_lock.unlock();

	incrementReference(VX_REF_EXTERNAL);
	status = VX_SUCCESS;

	return status;
	}

	vx_status
	ExynosVisionDistribution::commitDistribution(const void *ptr)
	{
	vx_status status = VX_FAILURE;

	if (m_is_allocated != vx_true_e) {
	status = ((ExynosVisionDataReference*)this)->allocateMemory();
	if (status != VX_SUCCESS)
	return status;
	}

	if (ptr != NULL) {
	m_internal_lock.lock();
	vx_uint8 base_ptr = (vx_uint8 )m_cur_res->getAddr();
	if (ptr != base_ptr) {
	vx_size size = m_num_bins * sizeof(vx_int32);
	vx_uint8 base_ptr = (vx_uint8 )m_cur_res->getAddr();
	memcpy(base_ptr, ptr, size);
	VXLOGD("copied distribution from %p to %p for %d bytes\n", ptr, base_ptr, size);
	}
	m_internal_lock.unlock();

	if (m_memory.usage != VX_READ_ONLY)
	m_memory_lock.unlock();

	decrementReference(VX_REF_EXTERNAL);
	status = VX_SUCCESS;
	}

	return status;
	}

	vx_status
	ExynosVisionDistribution::commitDistributionHandle(const vx_int32 fd)
	{
	if (fd == 0) {
	return VX_ERROR_INVALID_PARAMETERS;
	}

	/* 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" array. */
	VXLOGE("Can not access a virtual array");
	return VX_ERROR_OPTIMIZED_AWAY;
	}
	/* framework trying to access a virtual image, this is ok. */
	}

	if (m_memory.usage != VX_READ_ONLY)
	m_memory_lock.unlock();

	decrementReference(VX_REF_EXTERNAL);

	return VX_SUCCESS;
	}

	vx_status
	ExynosVisionDistribution::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
	ExynosVisionDistribution::allocateResource(default_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;
	default_resource_t *memory = new default_resource_t();

	vx_size size = m_num_bins * sizeof(vx_int32);
	status = memory->alloc(m_allocator, size);
	if (status != VX_SUCCESS)
	VXLOGE("memory allocation fails at %s", getName());

	*ret_resource = memory;

	return status;
	}

	vx_status
	ExynosVisionDistribution::freeResource(default_resource_t *memory)
	{
	vx_status status = VX_SUCCESS;

	status = memory->free(m_allocator);
	if (status != VX_SUCCESS)
	VXLOGE("memory free fail, err:%d", status);
	delete memory;

	return status;
	}

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

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

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

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

	#ifdef USE_OPENCL_KERNEL
	vx_status
	ExynosVisionDistribution::getClMemoryInfo(cl_context clContext, vxcl_mem_t **memory)
	{
	vx_status status = VX_SUCCESS;
	cl_int err = 0;

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

	m_cl_memory.cl_type = CL_MEM_OBJECT_BUFFER;
	m_cl_memory.nptrs = VX_NUM_DEFAULT_PLANES;
	m_cl_memory.ndims = VX_NUM_DEFAULT_DIMS;

	m_cl_memory.ptrs[VX_CL_PLANE_0] = (vx_uint8 *)m_cur_res->getAddr();
	m_cl_memory.sizes[VX_CL_PLANE_0] = (vx_size)(m_num_bins * sizeof(vx_int32));
	m_cl_memory.hdls[VX_CL_PLANE_0] = clCreateBuffer(clContext,
	CL_MEM_READ_WRITE \| CL_MEM_USE_HOST_PTR,
	m_cl_memory.sizes[VX_CL_PLANE_0],
	m_cl_memory.ptrs[VX_CL_PLANE_0],
	&err);
	if (err != CL_SUCCESS) {
	VXLOGE("failed in clCreateBuffer : err(%d)", err);
	m_cl_memory.allocated = vx_false_e;
	*memory = NULL;
	} else {
	m_cl_memory.allocated = vx_true_e;
	*memory = &m_cl_memory;
	}

	EXIT:
	return status;
	}
	#endif

	}; /* namespace android */