/* Copyright (c) 2012-2015, The Linux Foundataion. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of The Linux Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ #define LOG_TAG "QCameraHWI_Mem" #include #include #include #include #include #include #include "QCamera2HWI.h" #include "QCameraMem.h" extern "C" { #include } using namespace android; namespace qcamera { // QCaemra2Memory base class /*=========================================================================== * FUNCTION : QCameraMemory * * DESCRIPTION: default constructor of QCameraMemory * * PARAMETERS : * @cached : flag indicates if using cached memory * * RETURN : None *==========================================================================*/ QCameraMemory::QCameraMemory(bool cached, QCameraMemoryPool *pool, cam_stream_type_t streamType) :m_bCached(cached), mMemoryPool(pool), mStreamType(streamType) { mBufferCount = 0; memset(mMemInfo, 0, sizeof(mMemInfo)); } /*=========================================================================== * FUNCTION : ~QCameraMemory * * DESCRIPTION: deconstructor of QCameraMemory * * PARAMETERS : none * * RETURN : None *==========================================================================*/ QCameraMemory::~QCameraMemory() { } /*=========================================================================== * FUNCTION : cacheOpsInternal * * DESCRIPTION: ion related memory cache operations * * PARAMETERS : * @index : index of the buffer * @cmd : cache ops command * @vaddr : ptr to the virtual address * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraMemory::cacheOpsInternal(int index, unsigned int cmd, void *vaddr) { if (!m_bCached) { // Memory is not cached, no need for cache ops CDBG("%s: No cache ops here for uncached memory", __func__); return OK; } struct ion_flush_data cache_inv_data; struct ion_custom_data custom_data; int ret = OK; if (index >= mBufferCount) { ALOGE("%s: index %d out of bound [0, %d)", __func__, index, mBufferCount); return BAD_INDEX; } memset(&cache_inv_data, 0, sizeof(cache_inv_data)); memset(&custom_data, 0, sizeof(custom_data)); cache_inv_data.vaddr = vaddr; cache_inv_data.fd = mMemInfo[index].fd; cache_inv_data.handle = mMemInfo[index].handle; cache_inv_data.length = mMemInfo[index].size; custom_data.cmd = cmd; custom_data.arg = (unsigned long)&cache_inv_data; CDBG_HIGH("%s: addr = %p, fd = %d, handle = %lx length = %d, ION Fd = %d", __func__, cache_inv_data.vaddr, cache_inv_data.fd, (unsigned long)cache_inv_data.handle, cache_inv_data.length, mMemInfo[index].main_ion_fd); ret = ioctl(mMemInfo[index].main_ion_fd, ION_IOC_CUSTOM, &custom_data); if (ret < 0) ALOGE("%s: Cache Invalidate failed: %s\n", __func__, strerror(errno)); return ret; } /*=========================================================================== * FUNCTION : getFd * * DESCRIPTION: return file descriptor of the indexed buffer * * PARAMETERS : * @index : index of the buffer * * RETURN : file descriptor *==========================================================================*/ int QCameraMemory::getFd(int index) const { if (index >= mBufferCount) return BAD_INDEX; return mMemInfo[index].fd; } /*=========================================================================== * FUNCTION : getSize * * DESCRIPTION: return buffer size of the indexed buffer * * PARAMETERS : * @index : index of the buffer * * RETURN : buffer size *==========================================================================*/ int QCameraMemory::getSize(int index) const { if (index >= mBufferCount) return BAD_INDEX; return (int)mMemInfo[index].size; } /*=========================================================================== * FUNCTION : getCnt * * DESCRIPTION: query number of buffers allocated * * PARAMETERS : none * * RETURN : number of buffers allocated *==========================================================================*/ int QCameraMemory::getCnt() const { return mBufferCount; } /*=========================================================================== * FUNCTION : getBufDef * * DESCRIPTION: query detailed buffer information * * PARAMETERS : * @offset : [input] frame buffer offset * @bufDef : [output] reference to struct to store buffer definition * @index : [input] index of the buffer * * RETURN : none *==========================================================================*/ void QCameraMemory::getBufDef(const cam_frame_len_offset_t &offset, mm_camera_buf_def_t &bufDef, int index) const { if (!mBufferCount) { ALOGE("Memory not allocated"); return; } bufDef.fd = mMemInfo[index].fd; bufDef.frame_len = offset.frame_len; bufDef.mem_info = (void *)this; bufDef.num_planes = offset.num_planes; bufDef.buffer = getPtr(index); bufDef.buf_idx = index; /* Plane 0 needs to be set separately. Set other planes in a loop */ bufDef.planes[0].length = offset.mp[0].len; bufDef.planes[0].m.userptr = mMemInfo[index].fd; bufDef.planes[0].data_offset = offset.mp[0].offset; bufDef.planes[0].reserved[0] = 0; for (int i = 1; i < bufDef.num_planes; i++) { bufDef.planes[i].length = offset.mp[i].len; bufDef.planes[i].m.userptr = mMemInfo[i].fd; bufDef.planes[i].data_offset = offset.mp[i].offset; bufDef.planes[i].reserved[0] = bufDef.planes[i-1].reserved[0] + bufDef.planes[i-1].length; } } /*=========================================================================== * FUNCTION : alloc * * DESCRIPTION: allocate requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * @heap_id : heap id to indicate where the buffers will be allocated from * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraMemory::alloc(int count, int size, int heap_id, uint32_t secure_mode) { int rc = OK; if (mBufferCount < 0) { mBufferCount = 0; } int new_bufCnt = mBufferCount + count; if (new_bufCnt > MM_CAMERA_MAX_NUM_FRAMES) { ALOGE("%s: Buffer count %d out of bound. Max is %d", __func__, new_bufCnt, MM_CAMERA_MAX_NUM_FRAMES); return BAD_INDEX; } for (int i = mBufferCount; i < new_bufCnt; i ++) { if ( NULL == mMemoryPool ) { ALOGE("%s : No memory pool available", __func__); rc = allocOneBuffer(mMemInfo[i], heap_id, size, m_bCached, secure_mode); if (rc < 0) { ALOGE("%s: AllocateIonMemory failed", __func__); for (int j = i-1; j >= 0; j--) deallocOneBuffer(mMemInfo[j]); break; } } else { rc = mMemoryPool->allocateBuffer(mMemInfo[i], heap_id, size, m_bCached, mStreamType, secure_mode); if (rc < 0) { ALOGE("%s: Memory pool allocation failed", __func__); for (int j = i-1; j >= 0; j--) mMemoryPool->releaseBuffer(mMemInfo[j], mStreamType); break; } } } return rc; } /*=========================================================================== * FUNCTION : dealloc * * DESCRIPTION: deallocate buffers * * PARAMETERS : none * * RETURN : none *==========================================================================*/ void QCameraMemory::dealloc() { for (int i = 0; i < mBufferCount; i++) { if ( NULL == mMemoryPool ) { deallocOneBuffer(mMemInfo[i]); } else { mMemoryPool->releaseBuffer(mMemInfo[i], mStreamType); } } } /*=========================================================================== * FUNCTION : allocOneBuffer * * DESCRIPTION: impl of allocating one buffers of certain size * * PARAMETERS : * @memInfo : [output] reference to struct to store additional memory allocation info * @heap : [input] heap id to indicate where the buffers will be allocated from * @size : [input] lenght of the buffer to be allocated * @cached : [input] flag whether buffer needs to be cached * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraMemory::allocOneBuffer(QCameraMemInfo &memInfo, int heap_id, int size, bool cached, uint32_t secure_mode) { int rc = OK; struct ion_handle_data handle_data; struct ion_allocation_data alloc; struct ion_fd_data ion_info_fd; int main_ion_fd = 0; main_ion_fd = open("/dev/ion", O_RDONLY); if (main_ion_fd < 0) { ALOGE("Ion dev open failed: %s\n", strerror(errno)); goto ION_OPEN_FAILED; } memset(&alloc, 0, sizeof(alloc)); alloc.len = size; /* to make it page size aligned */ alloc.len = (alloc.len + 4095) & (~4095); alloc.align = 4096; if (cached) { alloc.flags = ION_FLAG_CACHED; } alloc.heap_mask = heap_id; if (secure_mode == SECURE) { ALOGD("%s: Allocate secure buffer\n", __func__); alloc.flags = ION_SECURE; alloc.heap_mask = ION_HEAP(ION_CP_MM_HEAP_ID); alloc.align = 1024*1024; //1 MB alignment to be able to protect later alloc.len = (alloc.len + (1024 * 1024 - 1)) & (~(1024 * 1024 -1)); } rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc); if (rc < 0) { ALOGE("ION allocation failed: %s\n", strerror(errno)); goto ION_ALLOC_FAILED; } memset(&ion_info_fd, 0, sizeof(ion_info_fd)); ion_info_fd.handle = alloc.handle; rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd); if (rc < 0) { ALOGE("ION map failed %s\n", strerror(errno)); goto ION_MAP_FAILED; } memInfo.main_ion_fd = main_ion_fd; memInfo.fd = ion_info_fd.fd; memInfo.handle = ion_info_fd.handle; memInfo.size = alloc.len; memInfo.cached = cached; memInfo.heap_id = heap_id; ALOGD("%s : ION buffer %lx with size %d allocated", __func__, (unsigned long)memInfo.handle, alloc.len); return OK; ION_MAP_FAILED: memset(&handle_data, 0, sizeof(handle_data)); handle_data.handle = ion_info_fd.handle; ioctl(main_ion_fd, ION_IOC_FREE, &handle_data); ION_ALLOC_FAILED: close(main_ion_fd); ION_OPEN_FAILED: return NO_MEMORY; } /*=========================================================================== * FUNCTION : deallocOneBuffer * * DESCRIPTION: impl of deallocating one buffers * * PARAMETERS : * @memInfo : reference to struct that stores additional memory allocation info * * RETURN : none *==========================================================================*/ void QCameraMemory::deallocOneBuffer(QCameraMemInfo &memInfo) { struct ion_handle_data handle_data; if (memInfo.fd > 0) { close(memInfo.fd); memInfo.fd = 0; } if (memInfo.main_ion_fd > 0) { memset(&handle_data, 0, sizeof(handle_data)); handle_data.handle = memInfo.handle; ioctl(memInfo.main_ion_fd, ION_IOC_FREE, &handle_data); close(memInfo.main_ion_fd); memInfo.main_ion_fd = 0; } memInfo.handle = 0; memInfo.size = 0; } /*=========================================================================== * FUNCTION : QCameraMemoryPool * * DESCRIPTION: default constructor of QCameraMemoryPool * * PARAMETERS : None * * RETURN : None *==========================================================================*/ QCameraMemoryPool::QCameraMemoryPool() { pthread_mutex_init(&mLock, NULL); } /*=========================================================================== * FUNCTION : ~QCameraMemoryPool * * DESCRIPTION: deconstructor of QCameraMemoryPool * * PARAMETERS : None * * RETURN : None *==========================================================================*/ QCameraMemoryPool::~QCameraMemoryPool() { clear(); pthread_mutex_destroy(&mLock); } /*=========================================================================== * FUNCTION : releaseBuffer * * DESCRIPTION: release one cached buffers * * PARAMETERS : * @memInfo : reference to struct that stores additional memory allocation info * @streamType: Type of stream the buffers belongs to * * RETURN : none *==========================================================================*/ void QCameraMemoryPool::releaseBuffer( struct QCameraMemory::QCameraMemInfo &memInfo, cam_stream_type_t streamType) { pthread_mutex_lock(&mLock); mPools[streamType].push_back(memInfo); pthread_mutex_unlock(&mLock); } /*=========================================================================== * FUNCTION : clear * * DESCRIPTION: clears all cached buffers * * PARAMETERS : none * * RETURN : none *==========================================================================*/ void QCameraMemoryPool::clear() { pthread_mutex_lock(&mLock); for (int i = CAM_STREAM_TYPE_DEFAULT; i < CAM_STREAM_TYPE_MAX; i++ ) { List::iterator it; it = mPools[i].begin(); for( ; it != mPools[i].end() ; it++) { QCameraMemory::deallocOneBuffer(*it); } mPools[i].clear(); } pthread_mutex_unlock(&mLock); } /*=========================================================================== * FUNCTION : findBufferLocked * * DESCRIPTION: search for a appropriate cached buffer * * PARAMETERS : * @memInfo : reference to struct that stores additional memory allocation info * @heap_id : type of heap * @size : size of the buffer * @cached : whether the buffer should be cached * @streaType: type of stream this buffer belongs to * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraMemoryPool::findBufferLocked( struct QCameraMemory::QCameraMemInfo &memInfo, int heap_id, uint32_t size, bool cached, cam_stream_type_t streamType) { int rc = NAME_NOT_FOUND; if (mPools[streamType].empty()) { return NAME_NOT_FOUND; } List::iterator it; it = mPools[streamType].begin(); for ( ; it != mPools[streamType].end() ; it++) { if ( ((*it).size >= size) && ((*it).heap_id == heap_id) && ((*it).cached == cached) ) { memInfo = *it; mPools[streamType].erase(it); rc = NO_ERROR; break; } } return rc; } /*=========================================================================== * FUNCTION : allocateBuffer * * DESCRIPTION: allocates a buffer from the memory pool, * it will re-use cached buffers if possible * * PARAMETERS : * @memInfo : reference to struct that stores additional memory allocation info * @heap_id : type of heap * @size : size of the buffer * @cached : whether the buffer should be cached * @streaType: type of stream this buffer belongs to * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraMemoryPool::allocateBuffer( struct QCameraMemory::QCameraMemInfo &memInfo, int heap_id, int size, bool cached, cam_stream_type_t streamType, int secure_mode) { int rc = NO_ERROR; pthread_mutex_lock(&mLock); rc = findBufferLocked(memInfo, heap_id, size, cached, streamType); if (NAME_NOT_FOUND == rc ) { ALOGE("%s : Buffer not found!", __func__); rc = QCameraMemory::allocOneBuffer(memInfo, heap_id, size, cached, secure_mode); } pthread_mutex_unlock(&mLock); return rc; } /*=========================================================================== * FUNCTION : QCameraHeapMemory * * DESCRIPTION: constructor of QCameraHeapMemory for ion memory used internally in HAL * * PARAMETERS : * @cached : flag indicates if using cached memory * * RETURN : none *==========================================================================*/ QCameraHeapMemory::QCameraHeapMemory(bool cached) : QCameraMemory(cached) { for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i ++) mPtr[i] = NULL; } /*=========================================================================== * FUNCTION : ~QCameraHeapMemory * * DESCRIPTION: deconstructor of QCameraHeapMemory * * PARAMETERS : none * * RETURN : none *==========================================================================*/ QCameraHeapMemory::~QCameraHeapMemory() { } /*=========================================================================== * FUNCTION : getPtr * * DESCRIPTION: return buffer pointer * * PARAMETERS : * @index : index of the buffer * * RETURN : buffer ptr *==========================================================================*/ void *QCameraHeapMemory::getPtr(int index) const { if (index >= mBufferCount) { ALOGE("index out of bound"); return (void *)BAD_INDEX; } return mPtr[index]; } /*=========================================================================== * FUNCTION : allocate * * DESCRIPTION: allocate requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraHeapMemory::allocate(int count, int size, uint32_t isSecure) { int rc = -1; int heap_mask = 0x1 << ION_IOMMU_HEAP_ID; if (isSecure == SECURE) { int heap_mask = 0x1 << ION_IOMMU_HEAP_ID; rc = alloc(count, size, heap_mask, SECURE); if (rc < 0) return rc; } else { rc = alloc(count, size, heap_mask, NON_SECURE); if (rc < 0) return rc; for (int i = 0; i < count; i ++) { void *vaddr = mmap(NULL, mMemInfo[i].size, PROT_READ | PROT_WRITE, MAP_SHARED, mMemInfo[i].fd, 0); if (vaddr == MAP_FAILED) { for (int j = i-1; j >= 0; j --) { munmap(mPtr[j], mMemInfo[j].size); mPtr[j] = NULL; deallocOneBuffer(mMemInfo[j]); } return NO_MEMORY; } else mPtr[i] = vaddr; } } if (rc == 0) { mBufferCount = count; } return OK; } /*=========================================================================== * FUNCTION : allocateMore * * DESCRIPTION: allocate more requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraHeapMemory::allocateMore(int count, int size) { int heap_mask = 0x1 << ION_IOMMU_HEAP_ID; int rc = alloc(count, size, heap_mask, NON_SECURE); if (rc < 0) return rc; for (int i = mBufferCount; i < count + mBufferCount; i ++) { void *vaddr = mmap(NULL, mMemInfo[i].size, PROT_READ | PROT_WRITE, MAP_SHARED, mMemInfo[i].fd, 0); if (vaddr == MAP_FAILED) { for (int j = i-1; j >= mBufferCount; j --) { munmap(mPtr[j], mMemInfo[j].size); mPtr[j] = NULL; deallocOneBuffer(mMemInfo[j]); } return NO_MEMORY; } else { mPtr[i] = vaddr; } } mBufferCount += count; return OK; } /*=========================================================================== * FUNCTION : deallocate * * DESCRIPTION: deallocate buffers * * PARAMETERS : none * * RETURN : none *==========================================================================*/ void QCameraHeapMemory::deallocate() { for (int i = 0; i < mBufferCount; i++) { munmap(mPtr[i], mMemInfo[i].size); mPtr[i] = NULL; } dealloc(); mBufferCount = 0; } /*=========================================================================== * FUNCTION : cacheOps * * DESCRIPTION: ion related memory cache operations * * PARAMETERS : * @index : index of the buffer * @cmd : cache ops command * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraHeapMemory::cacheOps(int index, unsigned int cmd) { if (index >= mBufferCount) return BAD_INDEX; return cacheOpsInternal(index, cmd, mPtr[index]); } /*=========================================================================== * FUNCTION : getRegFlags * * DESCRIPTION: query initial reg flags * * PARAMETERS : * @regFlags: initial reg flags of the allocated buffers * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraHeapMemory::getRegFlags(uint8_t * /*regFlags*/) const { return INVALID_OPERATION; } /*=========================================================================== * FUNCTION : getMemory * * DESCRIPTION: get camera memory * * PARAMETERS : * @index : buffer index * @metadata: flag if it's metadata * * RETURN : camera memory ptr * NULL if not supported or failed *==========================================================================*/ camera_memory_t *QCameraHeapMemory::getMemory( int /*index*/, bool /*metadata*/) const { return NULL; } /*=========================================================================== * FUNCTION : getMatchBufIndex * * DESCRIPTION: query buffer index by opaque ptr * * PARAMETERS : * @opaque : opaque ptr * @metadata: flag if it's metadata * * RETURN : buffer index if match found, * -1 if failed *==========================================================================*/ int QCameraHeapMemory::getMatchBufIndex(const void *opaque, bool metadata) const { int index = -1; if (metadata) { return -1; } for (int i = 0; i < mBufferCount; i++) { if (mPtr[i] == opaque) { index = i; break; } } return index; } /*=========================================================================== * FUNCTION : QCameraStreamMemory * * DESCRIPTION: constructor of QCameraStreamMemory * ION memory allocated directly from /dev/ion and shared with framework * * PARAMETERS : * @getMemory : camera memory request ops table * @cached : flag indicates if using cached memory * * RETURN : none *==========================================================================*/ QCameraStreamMemory::QCameraStreamMemory(camera_request_memory getMemory, bool cached, QCameraMemoryPool *pool, cam_stream_type_t streamType) :QCameraMemory(cached, pool, streamType), mGetMemory(getMemory) { for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i ++) mCameraMemory[i] = NULL; } /*=========================================================================== * FUNCTION : ~QCameraStreamMemory * * DESCRIPTION: deconstructor of QCameraStreamMemory * * PARAMETERS : none * * RETURN : none *==========================================================================*/ QCameraStreamMemory::~QCameraStreamMemory() { } /*=========================================================================== * FUNCTION : allocate * * DESCRIPTION: allocate requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraStreamMemory::allocate(int count, int size, uint32_t isSecure) { int heap_mask = 0x1 << ION_IOMMU_HEAP_ID; int rc = alloc(count, size, heap_mask, isSecure); if (rc < 0) return rc; for (int i = 0; i < count; i ++) { if (isSecure == SECURE) { mCameraMemory[i] = 0; } else { mCameraMemory[i] = mGetMemory(mMemInfo[i].fd, mMemInfo[i].size, 1, this); } } mBufferCount = count; return NO_ERROR; } /*=========================================================================== * FUNCTION : allocateMore * * DESCRIPTION: allocate more requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraStreamMemory::allocateMore(int count, int size) { int heap_mask = 0x1 << ION_IOMMU_HEAP_ID; int rc = alloc(count, size, heap_mask, NON_SECURE); if (rc < 0) return rc; for (int i = mBufferCount; i < mBufferCount + count; i++) { mCameraMemory[i] = mGetMemory(mMemInfo[i].fd, mMemInfo[i].size, 1, this); } mBufferCount += count; return NO_ERROR; } /*=========================================================================== * FUNCTION : deallocate * * DESCRIPTION: deallocate buffers * * PARAMETERS : none * * RETURN : none *==========================================================================*/ void QCameraStreamMemory::deallocate() { for (int i = 0; i < mBufferCount; i ++) { if (mCameraMemory[i]) mCameraMemory[i]->release(mCameraMemory[i]); mCameraMemory[i] = NULL; } dealloc(); mBufferCount = 0; } /*=========================================================================== * FUNCTION : cacheOps * * DESCRIPTION: ion related memory cache operations * * PARAMETERS : * @index : index of the buffer * @cmd : cache ops command * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraStreamMemory::cacheOps(int index, unsigned int cmd) { if (index >= mBufferCount) return BAD_INDEX; return cacheOpsInternal(index, cmd, mCameraMemory[index]->data); } /*=========================================================================== * FUNCTION : getRegFlags * * DESCRIPTION: query initial reg flags * * PARAMETERS : * @regFlags: initial reg flags of the allocated buffers * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraStreamMemory::getRegFlags(uint8_t *regFlags) const { for (int i = 0; i < mBufferCount; i ++) regFlags[i] = 1; return NO_ERROR; } /*=========================================================================== * FUNCTION : getMemory * * DESCRIPTION: get camera memory * * PARAMETERS : * @index : buffer index * @metadata: flag if it's metadata * * RETURN : camera memory ptr * NULL if not supported or failed *==========================================================================*/ camera_memory_t *QCameraStreamMemory::getMemory(int index, bool metadata) const { if (index >= mBufferCount || metadata) return NULL; return mCameraMemory[index]; } /*=========================================================================== * FUNCTION : getMatchBufIndex * * DESCRIPTION: query buffer index by opaque ptr * * PARAMETERS : * @opaque : opaque ptr * @metadata: flag if it's metadata * * RETURN : buffer index if match found, * -1 if failed *==========================================================================*/ int QCameraStreamMemory::getMatchBufIndex(const void *opaque, bool metadata) const { int index = -1; if (metadata) { return -1; } for (int i = 0; i < mBufferCount; i++) { if (mCameraMemory[i]->data == opaque) { index = i; break; } } return index; } /*=========================================================================== * FUNCTION : getPtr * * DESCRIPTION: return buffer pointer * * PARAMETERS : * @index : index of the buffer * * RETURN : buffer ptr *==========================================================================*/ void *QCameraStreamMemory::getPtr(int index) const { if (index >= mBufferCount) { ALOGE("index out of bound"); return (void *)BAD_INDEX; } if (mCameraMemory[index] == 0) { return NULL; } return mCameraMemory[index]->data; } /*=========================================================================== * FUNCTION : QCameraVideoMemory * * DESCRIPTION: constructor of QCameraVideoMemory * VideoStream buffers also include metadata buffers * * PARAMETERS : * @getMemory : camera memory request ops table * @cached : flag indicates if using cached ION memory * * RETURN : none *==========================================================================*/ QCameraVideoMemory::QCameraVideoMemory(camera_request_memory getMemory, bool cached) : QCameraStreamMemory(getMemory, cached) { memset(mMetadata, 0, sizeof(mMetadata)); } /*=========================================================================== * FUNCTION : ~QCameraVideoMemory * * DESCRIPTION: deconstructor of QCameraVideoMemory * * PARAMETERS : none * * RETURN : none *==========================================================================*/ QCameraVideoMemory::~QCameraVideoMemory() { } /*=========================================================================== * FUNCTION : allocate * * DESCRIPTION: allocate requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraVideoMemory::allocate(int count, int size, uint32_t isSecure) { int rc = QCameraStreamMemory::allocate(count, size, isSecure); if (rc < 0) return rc; for (int i = 0; i < count; i ++) { mMetadata[i] = mGetMemory(-1, sizeof(struct encoder_media_buffer_type), 1, this); if (!mMetadata[i]) { ALOGE("allocation of video metadata failed."); for (int j = 0; j <= i-1; j ++) mMetadata[j]->release(mMetadata[j]); QCameraStreamMemory::deallocate(); return NO_MEMORY; } struct encoder_media_buffer_type * packet = (struct encoder_media_buffer_type *)mMetadata[i]->data; packet->meta_handle = native_handle_create(1, 2); //1 fd, 1 offset and 1 size packet->buffer_type = kMetadataBufferTypeCameraSource; native_handle_t * nh = const_cast(packet->meta_handle); nh->data[0] = mMemInfo[i].fd; nh->data[1] = 0; nh->data[2] = mMemInfo[i].size; nh->data[3] = private_handle_t::PRIV_FLAGS_ITU_R_709; } mBufferCount = count; return NO_ERROR; } /*=========================================================================== * FUNCTION : allocateMore * * DESCRIPTION: allocate more requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraVideoMemory::allocateMore(int count, int size) { int rc = QCameraStreamMemory::allocateMore(count, size); if (rc < 0) return rc; for (int i = mBufferCount; i < count + mBufferCount; i ++) { mMetadata[i] = mGetMemory(-1, sizeof(struct encoder_media_buffer_type), 1, this); if (!mMetadata[i]) { ALOGE("allocation of video metadata failed."); for (int j = mBufferCount; j <= i-1; j ++) { mMetadata[j]->release(mMetadata[j]); mCameraMemory[j]->release(mCameraMemory[j]); mCameraMemory[j] = NULL; deallocOneBuffer(mMemInfo[j]);; } return NO_MEMORY; } struct encoder_media_buffer_type * packet = (struct encoder_media_buffer_type *)mMetadata[i]->data; packet->meta_handle = native_handle_create(1, 2); //1 fd, 1 offset and 1 size packet->buffer_type = kMetadataBufferTypeCameraSource; native_handle_t * nh = const_cast(packet->meta_handle); nh->data[0] = mMemInfo[i].fd; nh->data[1] = 0; nh->data[2] = mMemInfo[i].size; } mBufferCount += count; return NO_ERROR; } /*=========================================================================== * FUNCTION : deallocate * * DESCRIPTION: deallocate buffers * * PARAMETERS : none * * RETURN : none *==========================================================================*/ void QCameraVideoMemory::deallocate() { for (int i = 0; i < mBufferCount; i ++) { struct encoder_media_buffer_type * packet = (struct encoder_media_buffer_type *)mMetadata[i]->data; if (NULL != packet) { native_handle_t * nh = const_cast(packet->meta_handle); if (NULL != nh) { if (native_handle_delete(nh)) { ALOGE("Unable to delete native handle"); } } else { ALOGE("native handle not available"); } } else { ALOGE("packet not available"); } mMetadata[i]->release(mMetadata[i]); mMetadata[i] = NULL; } QCameraStreamMemory::deallocate(); mBufferCount = 0; } /*=========================================================================== * FUNCTION : getMemory * * DESCRIPTION: get camera memory * * PARAMETERS : * @index : buffer index * @metadata: flag if it's metadata * * RETURN : camera memory ptr * NULL if not supported or failed *==========================================================================*/ camera_memory_t *QCameraVideoMemory::getMemory(int index, bool metadata) const { if (index >= mBufferCount) return NULL; if (metadata) return mMetadata[index]; else return mCameraMemory[index]; } /*=========================================================================== * FUNCTION : getMatchBufIndex * * DESCRIPTION: query buffer index by opaque ptr * * PARAMETERS : * @opaque : opaque ptr * @metadata: flag if it's metadata * * RETURN : buffer index if match found, * -1 if failed *==========================================================================*/ int QCameraVideoMemory::getMatchBufIndex(const void *opaque, bool metadata) const { int index = -1; for (int i = 0; i < mBufferCount; i++) { if (metadata) { if (mMetadata[i]->data == opaque) { index = i; break; } } else { if (mCameraMemory[i]->data == opaque) { index = i; break; } } } return index; } /*=========================================================================== * FUNCTION : QCameraGrallocMemory * * DESCRIPTION: constructor of QCameraGrallocMemory * preview stream buffers are allocated from gralloc native_windoe * * PARAMETERS : * @getMemory : camera memory request ops table * * RETURN : none *==========================================================================*/ QCameraGrallocMemory::QCameraGrallocMemory(camera_request_memory getMemory) : QCameraMemory(true), mColorSpace(ITU_R_601_FR) { mMinUndequeuedBuffers = 0; mWindow = NULL; mWidth = mHeight = mStride = mScanline = 0; mFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; mGetMemory = getMemory; for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i ++) { mBufferHandle[i] = NULL; mLocalFlag[i] = BUFFER_NOT_OWNED; mPrivateHandle[i] = NULL; } } /*=========================================================================== * FUNCTION : ~QCameraGrallocMemory * * DESCRIPTION: deconstructor of QCameraGrallocMemory * * PARAMETERS : none * * RETURN : none *==========================================================================*/ QCameraGrallocMemory::~QCameraGrallocMemory() { } /*=========================================================================== * FUNCTION : setWindowInfo * * DESCRIPTION: set native window gralloc ops table * * PARAMETERS : * @window : gralloc ops table ptr * @width : width of preview frame * @height : height of preview frame * @stride : stride of preview frame * @scanline: scanline of preview frame * @foramt : format of preview image * * RETURN : none *==========================================================================*/ void QCameraGrallocMemory::setWindowInfo(preview_stream_ops_t *window, int width, int height, int stride, int scanline, int format) { mWindow = window; mWidth = width; mHeight = height; mStride = stride; mScanline = scanline; mFormat = format; } /*=========================================================================== * FUNCTION : displayBuffer * * DESCRIPTION: send received frame to display * * PARAMETERS : * @index : index of preview frame * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraGrallocMemory::displayBuffer(int index) { int err = NO_ERROR; int dequeuedIdx = BAD_INDEX; if (BUFFER_NOT_OWNED == mLocalFlag[index]) { ALOGE("%s: buffer to be enqueued is not owned", __func__); return INVALID_OPERATION; } err = mWindow->enqueue_buffer(mWindow, (buffer_handle_t *)mBufferHandle[index]); if(err != 0) { ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err); } else { CDBG("%s: enqueue_buffer hdl=%p", __func__, *mBufferHandle[index]); mLocalFlag[index] = BUFFER_NOT_OWNED; } buffer_handle_t *buffer_handle = NULL; int stride = 0; err = mWindow->dequeue_buffer(mWindow, &buffer_handle, &stride); if (err == NO_ERROR && buffer_handle != NULL) { int i; CDBG("%s: dequed buf hdl =%p", __func__, *buffer_handle); for(i = 0; i < mBufferCount; i++) { if(mBufferHandle[i] == buffer_handle) { CDBG("%s: Found buffer in idx:%d", __func__, i); mLocalFlag[i] = BUFFER_OWNED; dequeuedIdx = i; break; } } } else { CDBG_HIGH("%s: dequeue_buffer, no free buffer from display now", __func__); } return dequeuedIdx; } /*=========================================================================== * FUNCTION : allocate * * DESCRIPTION: allocate requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraGrallocMemory::allocate(int count, int /*size*/, uint32_t /*isSecure*/) { int err = 0; status_t ret = NO_ERROR; int gralloc_usage = 0; struct ion_fd_data ion_info_fd; memset(&ion_info_fd, 0, sizeof(ion_info_fd)); CDBG(" %s : E ", __func__); if (!mWindow) { ALOGE("Invalid native window"); return INVALID_OPERATION; } // Increment buffer count by min undequeued buffer. err = mWindow->get_min_undequeued_buffer_count(mWindow,&mMinUndequeuedBuffers); if (err != 0) { ALOGE("get_min_undequeued_buffer_count failed: %s (%d)", strerror(-err), -err); ret = UNKNOWN_ERROR; goto end; } err = mWindow->set_buffer_count(mWindow, count); if (err != 0) { ALOGE("set_buffer_count failed: %s (%d)", strerror(-err), -err); ret = UNKNOWN_ERROR; goto end; } err = mWindow->set_buffers_geometry(mWindow, mStride, mScanline, mFormat); if (err != 0) { ALOGE("%s: set_buffers_geometry failed: %s (%d)", __func__, strerror(-err), -err); ret = UNKNOWN_ERROR; goto end; } err = mWindow->set_crop(mWindow, 0, 0, mWidth, mHeight); if (err != 0) { ALOGE("%s: set_crop failed: %s (%d)", __func__, strerror(-err), -err); ret = UNKNOWN_ERROR; goto end; } gralloc_usage = GRALLOC_USAGE_HW_CAMERA_WRITE | GRALLOC_USAGE_PRIVATE_IOMMU_HEAP; err = mWindow->set_usage(mWindow, gralloc_usage); if(err != 0) { /* set_usage error out */ ALOGE("%s: set_usage rc = %d", __func__, err); ret = UNKNOWN_ERROR; goto end; } CDBG_HIGH("%s: usage = %d, geometry: %p, %d, %d, %d, %d, %d", __func__, gralloc_usage, mWindow, mWidth, mHeight, mStride, mScanline, mFormat); //Allocate cnt number of buffers from native window for (int cnt = 0; cnt < count; cnt++) { int stride; err = mWindow->dequeue_buffer(mWindow, &mBufferHandle[cnt], &stride); if(!err) { CDBG("dequeue buf hdl =%p", mBufferHandle[cnt]); mLocalFlag[cnt] = BUFFER_OWNED; } else { mLocalFlag[cnt] = BUFFER_NOT_OWNED; ALOGE("%s: dequeue_buffer idx = %d err = %d", __func__, cnt, err); } CDBG("%s: dequeue buf: %p\n", __func__, mBufferHandle[cnt]); if(err != 0) { ALOGE("%s: dequeue_buffer failed: %s (%d)", __func__, strerror(-err), -err); ret = UNKNOWN_ERROR; for(int i = 0; i < cnt; i++) { if(mLocalFlag[i] != BUFFER_NOT_OWNED) { err = mWindow->cancel_buffer(mWindow, mBufferHandle[i]); CDBG_HIGH("%s: cancel_buffer: hdl =%p", __func__, (*mBufferHandle[i])); } mLocalFlag[i] = BUFFER_NOT_OWNED; mBufferHandle[i] = NULL; } memset(&mMemInfo, 0, sizeof(mMemInfo)); goto end; } mPrivateHandle[cnt] = (struct private_handle_t *)(*mBufferHandle[cnt]); mMemInfo[cnt].main_ion_fd = open("/dev/ion", O_RDONLY); if (mMemInfo[cnt].main_ion_fd < 0) { ALOGE("%s: failed: could not open ion device", __func__); for(int i = 0; i < cnt; i++) { struct ion_handle_data ion_handle; memset(&ion_handle, 0, sizeof(ion_handle)); ion_handle.handle = mMemInfo[i].handle; if (ioctl(mMemInfo[i].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) { ALOGE("%s: ion free failed", __func__); } close(mMemInfo[i].main_ion_fd); if(mLocalFlag[i] != BUFFER_NOT_OWNED) { err = mWindow->cancel_buffer(mWindow, mBufferHandle[i]); CDBG_HIGH("%s: cancel_buffer: hdl =%p", __func__, (*mBufferHandle[i])); } mLocalFlag[i] = BUFFER_NOT_OWNED; mBufferHandle[i] = NULL; } memset(&mMemInfo, 0, sizeof(mMemInfo)); ret = UNKNOWN_ERROR; goto end; } else { ion_info_fd.fd = mPrivateHandle[cnt]->fd; if (ioctl(mMemInfo[cnt].main_ion_fd, ION_IOC_IMPORT, &ion_info_fd) < 0) { ALOGE("%s: ION import failed\n", __func__); for(int i = 0; i < cnt; i++) { struct ion_handle_data ion_handle; memset(&ion_handle, 0, sizeof(ion_handle)); ion_handle.handle = mMemInfo[i].handle; if (ioctl(mMemInfo[i].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) { ALOGE("ion free failed"); } close(mMemInfo[i].main_ion_fd); if(mLocalFlag[i] != BUFFER_NOT_OWNED) { err = mWindow->cancel_buffer(mWindow, mBufferHandle[i]); CDBG_HIGH("%s: cancel_buffer: hdl =%p", __func__, (*mBufferHandle[i])); } mLocalFlag[i] = BUFFER_NOT_OWNED; mBufferHandle[i] = NULL; } close(mMemInfo[cnt].main_ion_fd); memset(&mMemInfo, 0, sizeof(mMemInfo)); ret = UNKNOWN_ERROR; goto end; } } setMetaData(mPrivateHandle[cnt], UPDATE_COLOR_SPACE, &mColorSpace); mCameraMemory[cnt] = mGetMemory(mPrivateHandle[cnt]->fd, mPrivateHandle[cnt]->size, 1, (void *)this); CDBG_HIGH("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__, cnt, mPrivateHandle[cnt]->fd, mPrivateHandle[cnt]->size, mPrivateHandle[cnt]->offset); mMemInfo[cnt].fd = mPrivateHandle[cnt]->fd; mMemInfo[cnt].size = mPrivateHandle[cnt]->size; mMemInfo[cnt].handle = ion_info_fd.handle; } mBufferCount = count; //Cancel min_undequeued_buffer buffers back to the window for (int i = 0; i < mMinUndequeuedBuffers; i ++) { err = mWindow->cancel_buffer(mWindow, mBufferHandle[i]); mLocalFlag[i] = BUFFER_NOT_OWNED; } end: CDBG(" %s : X ",__func__); return ret; } /*=========================================================================== * FUNCTION : allocateMore * * DESCRIPTION: allocate more requested number of buffers of certain size * * PARAMETERS : * @count : number of buffers to be allocated * @size : lenght of the buffer to be allocated * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraGrallocMemory::allocateMore(int /*count*/, int /*size*/) { ALOGE("%s: Not implenmented yet", __func__); return UNKNOWN_ERROR; } /*=========================================================================== * FUNCTION : deallocate * * DESCRIPTION: deallocate buffers * * PARAMETERS : none * * RETURN : none *==========================================================================*/ void QCameraGrallocMemory::deallocate() { CDBG("%s: E ", __FUNCTION__); for (int cnt = 0; cnt < mBufferCount; cnt++) { mCameraMemory[cnt]->release(mCameraMemory[cnt]); struct ion_handle_data ion_handle; memset(&ion_handle, 0, sizeof(ion_handle)); ion_handle.handle = mMemInfo[cnt].handle; if (ioctl(mMemInfo[cnt].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) { ALOGE("ion free failed"); } close(mMemInfo[cnt].main_ion_fd); if(mLocalFlag[cnt] != BUFFER_NOT_OWNED) { if (mWindow) { mWindow->cancel_buffer(mWindow, mBufferHandle[cnt]); CDBG_HIGH("cancel_buffer: hdl =%p", (*mBufferHandle[cnt])); } else { ALOGE("Preview window is NULL, cannot cancel_buffer: hdl =%p", (*mBufferHandle[cnt])); } } mLocalFlag[cnt] = BUFFER_NOT_OWNED; CDBG_HIGH("put buffer %d successfully", cnt); } mBufferCount = 0; CDBG(" %s : X ",__FUNCTION__); } /*=========================================================================== * FUNCTION : cacheOps * * DESCRIPTION: ion related memory cache operations * * PARAMETERS : * @index : index of the buffer * @cmd : cache ops command * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraGrallocMemory::cacheOps(int index, unsigned int cmd) { if (index >= mBufferCount) return BAD_INDEX; return cacheOpsInternal(index, cmd, mCameraMemory[index]->data); } /*=========================================================================== * FUNCTION : getRegFlags * * DESCRIPTION: query initial reg flags * * PARAMETERS : * @regFlags: initial reg flags of the allocated buffers * * RETURN : int32_t type of status * NO_ERROR -- success * none-zero failure code *==========================================================================*/ int QCameraGrallocMemory::getRegFlags(uint8_t *regFlags) const { int i = 0; for (i = 0; i < mMinUndequeuedBuffers; i ++) regFlags[i] = 0; for (; i < mBufferCount; i ++) regFlags[i] = 1; return NO_ERROR; } /*=========================================================================== * FUNCTION : getMemory * * DESCRIPTION: get camera memory * * PARAMETERS : * @index : buffer index * @metadata: flag if it's metadata * * RETURN : camera memory ptr * NULL if not supported or failed *==========================================================================*/ camera_memory_t *QCameraGrallocMemory::getMemory(int index, bool metadata) const { if (index >= mBufferCount || metadata) return NULL; return mCameraMemory[index]; } /*=========================================================================== * FUNCTION : getMatchBufIndex * * DESCRIPTION: query buffer index by opaque ptr * * PARAMETERS : * @opaque : opaque ptr * @metadata: flag if it's metadata * * RETURN : buffer index if match found, * -1 if failed *==========================================================================*/ int QCameraGrallocMemory::getMatchBufIndex(const void *opaque, bool metadata) const { int index = -1; if (metadata) { return -1; } for (int i = 0; i < mBufferCount; i++) { if (mCameraMemory[i]->data == opaque) { index = i; break; } } return index; } /*=========================================================================== * FUNCTION : getPtr * * DESCRIPTION: return buffer pointer * * PARAMETERS : * @index : index of the buffer * * RETURN : buffer ptr *==========================================================================*/ void *QCameraGrallocMemory::getPtr(int index) const { if (index >= mBufferCount) { ALOGE("index out of bound"); return (void *)BAD_INDEX; } return mCameraMemory[index]->data; } }; //namespace qcamera