darkkirb/android_device_lenovo_msm8937-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
android_device_lenovo_msm89.../camera/QCamera2/HAL/QCameraStream.cpp
Zhao Wei Liew 669d233045 land: Import OSS camera HAL 
CAF revision: AU_LINUX_ANDROID_LA.UM.5.1_RB1.06.00.01.192.038

Change-Id: I87589fea5e9c00c3bdc9c79cc6b2d6453c3d09b3
2017-02-12 07:26:24 +08:00

2657 lines
82 KiB
C++
Raw Blame History

/* Copyright (c) 2012-2016, The Linux Foundation. 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 "QCameraStream"
// System dependencies
#include <utils/Errors.h>
// Camera dependencies
#include "QCameraBufferMaps.h"
#include "QCamera2HWI.h"
#include "QCameraStream.h"
extern "C" {
#include "mm_camera_dbg.h"
}
#define CAMERA_MIN_ALLOCATED_BUFFERS 3
namespace qcamera {
/*===========================================================================
* FUNCTION : get_bufs
*
* DESCRIPTION: static function entry to allocate stream buffers
*
* PARAMETERS :
* @offset : offset info of stream buffers
* @num_bufs : number of buffers allocated
* @initial_reg_flag: flag to indicate if buffer needs to be registered
* at kernel initially
* @bufs : output of allocated buffers
* @ops_tbl : ptr to buf mapping/unmapping ops
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::get_bufs(
cam_frame_len_offset_t *offset,
uint8_t *num_bufs,
uint8_t **initial_reg_flag,
mm_camera_buf_def_t **bufs,
mm_camera_map_unmap_ops_tbl_t *ops_tbl,
void *user_data)
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("getBufs invalid stream pointer");
return NO_MEMORY;
}
if (stream->mStreamInfo != NULL
&& stream->mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH) {
//Batch Mode. Allocate Butch buffers
return stream->allocateBatchBufs(offset, num_bufs,
initial_reg_flag, bufs, ops_tbl);
} else {
// Plane Buffer. Allocate plane buffer
return stream->getBufs(offset, num_bufs,
initial_reg_flag, bufs, ops_tbl);
}
}
/*===========================================================================
* FUNCTION : get_bufs_deffered
*
* DESCRIPTION: static function entry to allocate deffered stream buffers
*
* PARAMETERS :
* @offset : offset info of stream buffers
* @num_bufs : number of buffers allocated
* @initial_reg_flag: flag to indicate if buffer needs to be registered
* at kernel initially
* @bufs : output of allocated buffers
* @ops_tbl : ptr to buf mapping/unmapping ops
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::get_bufs_deffered(
cam_frame_len_offset_t * /* offset */,
uint8_t *num_bufs,
uint8_t **initial_reg_flag,
mm_camera_buf_def_t **bufs,
mm_camera_map_unmap_ops_tbl_t * ops_tbl,
void *user_data)
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("getBufs invalid stream pointer");
return NO_MEMORY;
}
return stream->getBufsDeferred(NULL /*offset*/, num_bufs, initial_reg_flag, bufs,
ops_tbl);
}
/*===========================================================================
* FUNCTION : put_bufs
*
* DESCRIPTION: static function entry to deallocate stream buffers
*
* PARAMETERS :
* @ops_tbl : ptr to buf mapping/unmapping ops
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::put_bufs(
mm_camera_map_unmap_ops_tbl_t *ops_tbl,
void *user_data)
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("putBufs invalid stream pointer");
return NO_MEMORY;
}
if (stream->mStreamInfo != NULL
&& stream->mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH) {
//Batch Mode. release Butch buffers
return stream->releaseBatchBufs(ops_tbl);
} else {
// Plane Buffer. release plane buffer
return stream->putBufs(ops_tbl);
}
}
/*===========================================================================
* FUNCTION : put_bufs_deffered
*
* DESCRIPTION: static function entry to deallocate deffered stream buffers
*
* PARAMETERS :
* @ops_tbl : ptr to buf mapping/unmapping ops
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::put_bufs_deffered(
mm_camera_map_unmap_ops_tbl_t * /*ops_tbl */,
void * user_data )
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("put_bufs_deffered invalid stream pointer");
return NO_MEMORY;
}
return stream->putBufsDeffered();
}
/*===========================================================================
* FUNCTION : invalidate_buf
*
* DESCRIPTION: static function entry to invalidate a specific stream buffer
*
* PARAMETERS :
* @index : index of the stream buffer to invalidate
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::invalidate_buf(uint32_t index, void *user_data)
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("invalid stream pointer");
return NO_MEMORY;
}
if (stream->mStreamInfo->is_secure == SECURE){
return 0;
}
if (stream->mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH) {
for (int i = 0; i < stream->mBufDefs[index].user_buf.bufs_used; i++) {
uint32_t buf_idx = stream->mBufDefs[index].user_buf.buf_idx[i];
stream->invalidateBuf(buf_idx);
}
} else {
return stream->invalidateBuf(index);
}
return 0;
}
/*===========================================================================
* FUNCTION : clean_invalidate_buf
*
* DESCRIPTION: static function entry to clean invalidate a specific stream buffer
*
* PARAMETERS :
* @index : index of the stream buffer to clean invalidate
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::clean_invalidate_buf(uint32_t index, void *user_data)
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("invalid stream pointer");
return NO_MEMORY;
}
if (stream->mStreamInfo->is_secure == SECURE){
return 0;
}
if (stream->mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH) {
for (int i = 0; i < stream->mBufDefs[index].user_buf.bufs_used; i++) {
uint32_t buf_idx = stream->mBufDefs[index].user_buf.buf_idx[i];
stream->cleanInvalidateBuf(buf_idx);
}
} else {
return stream->cleanInvalidateBuf(index);
}
return 0;
}
/*===========================================================================
* FUNCTION : set_config_ops
*
* DESCRIPTION: static function update mm-interface ops functions
*
* PARAMETERS :
* @ops_tbl : ptr to buf mapping/unmapping ops
* @user_data : user data ptr of ops_tbl
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::set_config_ops(mm_camera_map_unmap_ops_tbl_t *ops_tbl,
void *user_data)
{
QCameraStream *stream = reinterpret_cast<QCameraStream *>(user_data);
if (!stream) {
LOGE("Stream invalid");
return NO_MEMORY;
}
stream->m_MemOpsTbl = *ops_tbl;
return 0;
}
/*===========================================================================
* FUNCTION : QCameraStream
*
* DESCRIPTION: constructor of QCameraStream
*
* PARAMETERS :
* @allocator : memory allocator obj
* @camHandle : camera handle
* @chId : channel handle
* @camOps : ptr to camera ops table
* @paddingInfo: ptr to padding info
* @deffered : deferred stream
* @online_rotation: rotation applied online
*
* RETURN : None
*==========================================================================*/
QCameraStream::QCameraStream(QCameraAllocator &allocator,
uint32_t camHandle, uint32_t chId,
mm_camera_ops_t *camOps, cam_padding_info_t *paddingInfo,
bool deffered, cam_rotation_t online_rotation):
mDumpFrame(0),
mDumpMetaFrame(0),
mDumpSkipCnt(0),
mStreamTimestamp(0),
mCamHandle(camHandle),
mChannelHandle(chId),
mHandle(0),
mCamOps(camOps),
mStreamInfo(NULL),
mNumBufs(0),
mNumPlaneBufs(0),
mNumBufsNeedAlloc(0),
mRegFlags(NULL),
mDataCB(NULL),
mSYNCDataCB(NULL),
mUserData(NULL),
mDataQ(releaseFrameData, this),
mStreamInfoBuf(NULL),
mMiscBuf(NULL),
mStreamBufs(NULL),
mStreamBatchBufs(NULL),
mAllocator(allocator),
mBufDefs(NULL),
mPlaneBufDefs(NULL),
mOnlineRotation(online_rotation),
mStreamBufsAcquired(false),
m_bActive(false),
mDynBufAlloc(false),
mBufAllocPid(0),
mDefferedAllocation(deffered),
wait_for_cond(false),
mAllocTaskId(0),
mMapTaskId(0),
mSyncCBEnabled(false)
{
mMemVtbl.user_data = this;
if ( !deffered ) {
mMemVtbl.get_bufs = get_bufs;
mMemVtbl.put_bufs = put_bufs;
} else {
mMemVtbl.get_bufs = get_bufs_deffered;
mMemVtbl.put_bufs = put_bufs_deffered;
}
mMemVtbl.invalidate_buf = invalidate_buf;
mMemVtbl.clean_invalidate_buf = clean_invalidate_buf;
mMemVtbl.set_config_ops = set_config_ops;
memset(&mFrameLenOffset, 0, sizeof(mFrameLenOffset));
memcpy(&mPaddingInfo, paddingInfo, sizeof(cam_padding_info_t));
memset(&mCropInfo, 0, sizeof(cam_rect_t));
memset(&m_MemOpsTbl, 0, sizeof(mm_camera_map_unmap_ops_tbl_t));
memset(&m_OutputCrop, 0, sizeof(cam_stream_parm_buffer_t));
memset(&m_ImgProp, 0, sizeof(cam_stream_parm_buffer_t));
memset(&mAllocTask, 0, sizeof(mAllocTask));
memset(&mMapTask, 0, sizeof(mMapTask));
pthread_mutex_init(&mCropLock, NULL);
pthread_mutex_init(&mParameterLock, NULL);
mCurMetaMemory = NULL;
mCurBufIndex = -1;
mCurMetaIndex = -1;
mFirstTimeStamp = 0;
memset (&mStreamMetaMemory, 0,
(sizeof(MetaMemory) * CAMERA_MIN_VIDEO_BATCH_BUFFERS));
pthread_mutex_init(&m_lock, NULL);
pthread_cond_init(&m_cond, NULL);
}
/*===========================================================================
* FUNCTION : ~QCameraStream
*
* DESCRIPTION: deconstructor of QCameraStream
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
QCameraStream::~QCameraStream()
{
pthread_mutex_destroy(&mCropLock);
pthread_mutex_destroy(&mParameterLock);
mAllocator.waitForBackgroundTask(mAllocTaskId);
mAllocator.waitForBackgroundTask(mMapTaskId);
if (mBufAllocPid != 0) {
cond_signal(true);
LOGL("Wait for buf allocation thread dead");
// Wait for the allocation of additional stream buffers
pthread_join(mBufAllocPid, NULL);
mBufAllocPid = 0;
}
if (mDefferedAllocation) {
mStreamBufsAcquired = false;
releaseBuffs();
}
unmapStreamInfoBuf();
releaseStreamInfoBuf();
if (mMiscBuf) {
unMapBuf(mMiscBuf, CAM_MAPPING_BUF_TYPE_MISC_BUF, NULL);
releaseMiscBuf();
}
// delete stream
if (mHandle > 0) {
mCamOps->delete_stream(mCamHandle, mChannelHandle, mHandle);
mHandle = 0;
}
pthread_mutex_destroy(&m_lock);
pthread_cond_destroy(&m_cond);
}
/*===========================================================================
* FUNCTION : unmapStreamInfoBuf
*
* DESCRIPTION: Unmap stream info buffer
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::unmapStreamInfoBuf()
{
int rc = NO_ERROR;
if (mStreamInfoBuf != NULL) {
rc = mCamOps->unmap_stream_buf(mCamHandle,
mChannelHandle,
mHandle,
CAM_MAPPING_BUF_TYPE_STREAM_INFO,
0,
-1);
if (rc < 0) {
LOGE("Failed to unmap stream info buffer");
}
}
return rc;
}
/*===========================================================================
* FUNCTION : releaseMiscBuf
*
* DESCRIPTION: Release misc buffers
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::releaseMiscBuf()
{
int rc = NO_ERROR;
if (mMiscBuf != NULL) {
mMiscBuf->deallocate();
delete mMiscBuf;
mMiscBuf = NULL;
}
return rc;
}
/*===========================================================================
* FUNCTION : releaseStreamInfoBuf
*
* DESCRIPTION: Release stream info buffer
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::releaseStreamInfoBuf()
{
int rc = NO_ERROR;
if (mStreamInfoBuf != NULL) {
mStreamInfoBuf->deallocate();
delete mStreamInfoBuf;
mStreamInfoBuf = NULL;
mStreamInfo = NULL;
}
return rc;
}
/*===========================================================================
* FUNCTION : deleteStream
*
* DESCRIPTION: Deletes a camera stream
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void QCameraStream::deleteStream()
{
if (mHandle > 0) {
acquireStreamBufs();
releaseBuffs();
unmapStreamInfoBuf();
mCamOps->delete_stream(mCamHandle, mChannelHandle, mHandle);
}
}
/*===========================================================================
* FUNCTION : unMapBuf
*
* DESCRIPTION: unmaps buffers
*
* PARAMETERS :
* @heapBuf : heap buffer handler
* @bufType : buffer type
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::unMapBuf(QCameraMemory *Buf,
cam_mapping_buf_type bufType, mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int32_t rc = NO_ERROR;
uint8_t cnt;
ssize_t bufSize = BAD_INDEX;
uint32_t i;
cnt = Buf->getCnt();
for (i = 0; i < cnt; i++) {
bufSize = Buf->getSize(i);
if (BAD_INDEX != bufSize) {
if (m_MemOpsTbl.unmap_ops == NULL ) {
rc = mCamOps->unmap_stream_buf(mCamHandle, mChannelHandle, mHandle,
bufType, i, -1);
} else {
rc = m_MemOpsTbl.unmap_ops(i, -1, bufType, m_MemOpsTbl.userdata);
}
if (rc < 0) {
LOGE("Failed to unmap buffer");
break;
}
} else {
LOGE("Failed to retrieve buffer size (bad index)");
rc = BAD_INDEX;
break;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : mapBufs
*
* DESCRIPTION: maps buffers
*
* PARAMETERS :
* @heapBuf : heap buffer handler
* @bufType : buffer type
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::mapBufs(QCameraMemory *Buf,
cam_mapping_buf_type bufType, mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int32_t rc = NO_ERROR;
ssize_t bufSize = BAD_INDEX;
uint32_t i = 0;
QCameraBufferMaps bufferMaps;
for (i = 0; i < Buf->getCnt(); i++) {
ssize_t bufSize = Buf->getSize(i);
if (BAD_INDEX == bufSize) {
LOGE("Failed to retrieve buffer size (bad index)");
return BAD_INDEX;
}
rc = bufferMaps.enqueue(bufType, mHandle, i /*buf index*/, -1 /*plane index*/,
0 /*cookie*/, Buf->getFd(i), bufSize);
if (rc < 0) {
LOGE("Failed to map buffers");
return BAD_INDEX;
}
}
cam_buf_map_type_list bufMapList;
rc = bufferMaps.getCamBufMapList(bufMapList);
if (rc < 0) {
LOGE("Failed to map buffers");
return BAD_INDEX;
}
if (m_MemOpsTbl.bundled_map_ops == NULL) {
rc = mCamOps->map_stream_bufs(mCamHandle, mChannelHandle, &bufMapList);
} else {
rc = m_MemOpsTbl.bundled_map_ops(&bufMapList, m_MemOpsTbl.userdata);
}
if (rc < 0) {
LOGE("Failed to map buffer");
rc = BAD_INDEX;
}
return rc;
}
/*===========================================================================
* FUNCTION : backgroundAllocate
*
* DESCRIPTION: schedule buffers to be allocated in the background
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::backgroundAllocate(void *data) {
QCameraStream *stream = (QCameraStream*)data;
int32_t rc = stream->allocateBuffers();
if (rc != NO_ERROR) {
LOGE("Error allocating buffers !!!");
}
return rc;
}
/*===========================================================================
* FUNCTION : backgroundMap
*
* DESCRIPTION: map buffers in the background
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::backgroundMap(void *data) {
QCameraStream *stream = (QCameraStream*)data;
int32_t rc = stream->mapBuffers();
if (rc != NO_ERROR) {
LOGE("Error mapping buffers !!!");
}
return rc;
}
/*===========================================================================
* FUNCTION : init
*
* DESCRIPTION: initialize stream obj
*
* PARAMETERS :
* @streamInfoBuf: ptr to buf that contains stream info
* @miscBuf : ptr to buf that contains misc bufs
* @stream_cb : stream data notify callback. Can be NULL if not needed
* @userdata : user data ptr
* @bDynallocBuf : flag to indicate if buffer allocation can be in 2 steps
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::init(QCameraHeapMemory *streamInfoBuf,
QCameraHeapMemory *miscBuf,
uint8_t minNumBuffers,
stream_cb_routine stream_cb,
void *userdata,
bool bDynallocBuf)
{
int32_t rc = OK;
// assign and map stream info memory
mStreamInfoBuf = streamInfoBuf;
mStreamInfo = reinterpret_cast<cam_stream_info_t *>(mStreamInfoBuf->getPtr(0));
mNumBufs = minNumBuffers;
mDynBufAlloc = bDynallocBuf;
// Calculate buffer size for deffered allocation
if (mDefferedAllocation) {
rc = calcOffset(mStreamInfo);
if (rc < 0) {
LOGE("Failed to calculate stream offset");
goto done;
}
mAllocTask.bgFunction = backgroundAllocate;
mAllocTask.bgArgs = this;
mAllocTaskId = mAllocator.scheduleBackgroundTask(&mAllocTask);
if (mAllocTaskId == 0) {
LOGE("Failed to schedule buffer alloction");
rc = -ENOMEM;
goto done;
}
}
mHandle = mCamOps->add_stream(mCamHandle, mChannelHandle);
if (!mHandle) {
LOGE("add_stream failed");
rc = UNKNOWN_ERROR;
goto done;
}
rc = mapBufs(mStreamInfoBuf, CAM_MAPPING_BUF_TYPE_STREAM_INFO, NULL);
if (rc < 0) {
LOGE("Failed to map stream info buffer");
goto err1;
}
mMiscBuf = miscBuf;
if (miscBuf) {
rc = mapBufs(mMiscBuf, CAM_MAPPING_BUF_TYPE_MISC_BUF, NULL);
if (rc < 0) {
LOGE("Failed to map miscellaneous buffer");
releaseMiscBuf();
goto err1;
}
}
rc = configStream();
if (rc < 0) {
LOGE("Failed to config stream ");
goto err1;
}
if (mDefferedAllocation) {
mMapTask.bgFunction = backgroundMap;
mMapTask.bgArgs = this;
mMapTaskId = mAllocator.scheduleBackgroundTask(&mMapTask);
if (mMapTaskId == 0) {
LOGE("Failed to schedule buffer alloction");
rc = -ENOMEM;
goto err1;
}
}
mDataCB = stream_cb;
mUserData = userdata;
return 0;
err1:
mCamOps->delete_stream(mCamHandle, mChannelHandle, mHandle);
mHandle = 0;
mNumBufs = 0;
done:
return rc;
}
/*===========================================================================
* FUNCTION : calcOffset
*
* DESCRIPTION: calculate frame offset based on format and padding information
*
* PARAMETERS :
* @streamInfo : stream information
*
* RETURN : int32_t type of status
* 0 -- success
* -1 -- failure
*==========================================================================*/
int32_t QCameraStream::calcOffset(cam_stream_info_t *streamInfo)
{
int32_t rc = 0;
cam_dimension_t dim = streamInfo->dim;
if (streamInfo->pp_config.feature_mask & CAM_QCOM_FEATURE_ROTATION &&
streamInfo->stream_type != CAM_STREAM_TYPE_VIDEO) {
if (streamInfo->pp_config.rotation == ROTATE_90 ||
streamInfo->pp_config.rotation == ROTATE_270) {
// rotated by 90 or 270, need to switch width and height
dim.width = streamInfo->dim.height;
dim.height = streamInfo->dim.width;
}
}
switch (streamInfo->stream_type) {
case CAM_STREAM_TYPE_PREVIEW:
case CAM_STREAM_TYPE_CALLBACK:
rc = mm_stream_calc_offset_preview(streamInfo,
&dim,
&mPaddingInfo,
&streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_POSTVIEW:
rc = mm_stream_calc_offset_post_view(streamInfo->fmt,
&dim,
&streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_SNAPSHOT:
rc = mm_stream_calc_offset_snapshot(streamInfo->fmt,
&dim,
&mPaddingInfo,
&streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_OFFLINE_PROC:
rc = mm_stream_calc_offset_postproc(streamInfo,
&mPaddingInfo,
&streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_VIDEO:
rc = mm_stream_calc_offset_video(streamInfo->fmt,
&dim, &streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_RAW:
rc = mm_stream_calc_offset_raw(streamInfo->fmt,
&dim,
&mPaddingInfo,
&streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_ANALYSIS:
rc = mm_stream_calc_offset_analysis(streamInfo->fmt,
&dim,
&mPaddingInfo,
&streamInfo->buf_planes);
break;
case CAM_STREAM_TYPE_METADATA:
rc = mm_stream_calc_offset_metadata(&dim,
&mPaddingInfo,
&streamInfo->buf_planes);
break;
default:
LOGE("not supported for stream type %d",
streamInfo->stream_type);
rc = -1;
break;
}
return rc;
}
/*===========================================================================
* FUNCTION : start
*
* DESCRIPTION: start stream. Will start main stream thread to handle stream
* related ops.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::start()
{
int32_t rc = 0;
mDataQ.init();
rc = mProcTh.launch(dataProcRoutine, this);
if (rc == NO_ERROR) {
m_bActive = true;
}
mCurMetaMemory = NULL;
mCurBufIndex = -1;
mCurMetaIndex = -1;
mFirstTimeStamp = 0;
memset (&mStreamMetaMemory, 0,
(sizeof(MetaMemory) * CAMERA_MIN_VIDEO_BATCH_BUFFERS));
return rc;
}
/*===========================================================================
* FUNCTION : stop
*
* DESCRIPTION: stop stream. Will stop main stream thread
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::stop()
{
int32_t rc = 0;
m_bActive = false;
mAllocator.waitForBackgroundTask(mAllocTaskId);
mAllocator.waitForBackgroundTask(mMapTaskId);
rc = mProcTh.exit();
return rc;
}
/*===========================================================================
* FUNCTION : syncRuntimeParams
*
* DESCRIPTION: query and sync runtime parameters like output crop
* buffer info etc.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::syncRuntimeParams()
{
int32_t ret = NO_ERROR;
memset(&m_OutputCrop, 0, sizeof(cam_stream_parm_buffer_t));
m_OutputCrop.type = CAM_STREAM_PARAM_TYPE_GET_OUTPUT_CROP;
ret = getParameter(m_OutputCrop);
if (ret != NO_ERROR) {
LOGE("stream getParameter for output crop failed");
return ret;
}
memset(&m_ImgProp, 0, sizeof(cam_stream_parm_buffer_t));
m_ImgProp.type = CAM_STREAM_PARAM_TYPE_GET_IMG_PROP;
ret = getParameter(m_ImgProp);
if (ret != NO_ERROR) {
LOGE("stream getParameter for image prop failed");
return ret;
}
return ret;
}
/*===========================================================================
* FUNCTION : processZoomDone
*
* DESCRIPTION: process zoom done event
*
* PARAMETERS :
* @previewWindoe : preview window ops table to set preview crop window
* @crop_info : crop info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::processZoomDone(preview_stream_ops_t *previewWindow,
cam_crop_data_t &crop_info)
{
int32_t rc = 0;
if (!m_bActive) {
LOGL("Stream not active");
return NO_ERROR;
}
// get stream param for crop info
for (int i = 0; i < crop_info.num_of_streams; i++) {
if (crop_info.crop_info[i].stream_id == mStreamInfo->stream_svr_id) {
pthread_mutex_lock(&mCropLock);
mCropInfo = crop_info.crop_info[i].crop;
pthread_mutex_unlock(&mCropLock);
// update preview window crop if it's preview/postview stream
if ( (previewWindow != NULL) &&
(mStreamInfo->stream_type == CAM_STREAM_TYPE_PREVIEW ||
mStreamInfo->stream_type == CAM_STREAM_TYPE_POSTVIEW) ) {
rc = previewWindow->set_crop(previewWindow,
mCropInfo.left,
mCropInfo.top,
mCropInfo.width,
mCropInfo.height);
}
break;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : processDataNotify
*
* DESCRIPTION: process stream data notify
*
* PARAMETERS :
* @frame : stream frame received
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::processDataNotify(mm_camera_super_buf_t *frame)
{
LOGD("\n");
if (mDataQ.enqueue((void *)frame)) {
return mProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
} else {
if (!m_bActive) {
LOGW("Stream thread is not active, no ops here %d", getMyType());
} else {
bufDone(frame->bufs[0]->buf_idx);
}
free(frame);
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : dataNotifySYNCCB
*
* DESCRIPTION: This function registered with interface for
* SYNC callback if SYNC callback registered.
*
* PARAMETERS :
* @recvd_frame : stream frame received
* @userdata : user data ptr
*
* RETURN : none
*==========================================================================*/
void QCameraStream::dataNotifySYNCCB(mm_camera_super_buf_t *recvd_frame,
void *userdata)
{
LOGD("\n");
QCameraStream* stream = (QCameraStream *)userdata;
if (stream == NULL ||
recvd_frame == NULL ||
recvd_frame->bufs[0] == NULL ||
recvd_frame->bufs[0]->stream_id != stream->getMyHandle()) {
LOGE("Not a valid stream to handle buf");
return;
}
if ((stream->mSyncCBEnabled) && (stream->mSYNCDataCB != NULL))
stream->mSYNCDataCB(recvd_frame, stream, stream->mUserData);
return;
}
/*===========================================================================
* FUNCTION : dataNotifyCB
*
* DESCRIPTION: callback for data notify. This function is registered with
* mm-camera-interface to handle data notify
*
* PARAMETERS :
* @recvd_frame : stream frame received
* userdata : user data ptr
*
* RETURN : none
*==========================================================================*/
void QCameraStream::dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
void *userdata)
{
LOGD("\n");
QCameraStream* stream = (QCameraStream *)userdata;
if (stream == NULL ||
recvd_frame == NULL ||
recvd_frame->bufs[0] == NULL ||
recvd_frame->bufs[0]->stream_id != stream->getMyHandle()) {
LOGE("Not a valid stream to handle buf");
return;
}
mm_camera_super_buf_t *frame =
(mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
if (frame == NULL) {
LOGE("No mem for mm_camera_buf_def_t");
stream->bufDone(recvd_frame->bufs[0]->buf_idx);
return;
}
*frame = *recvd_frame;
stream->processDataNotify(frame);
return;
}
/*===========================================================================
* FUNCTION : dataProcRoutine
*
* DESCRIPTION: function to process data in the main stream thread
*
* PARAMETERS :
* @data : user data ptr
*
* RETURN : none
*==========================================================================*/
void *QCameraStream::dataProcRoutine(void *data)
{
int running = 1;
int ret;
QCameraStream *pme = (QCameraStream *)data;
QCameraCmdThread *cmdThread = &pme->mProcTh;
cmdThread->setName("CAM_strmDatProc");
LOGD("E");
do {
do {
ret = cam_sem_wait(&cmdThread->cmd_sem);
if (ret != 0 && errno != EINVAL) {
LOGE("cam_sem_wait error (%s)",
strerror(errno));
return NULL;
}
} while (ret != 0);
// we got notified about new cmd avail in cmd queue
camera_cmd_type_t cmd = cmdThread->getCmd();
switch (cmd) {
case CAMERA_CMD_TYPE_DO_NEXT_JOB:
{
LOGH("Do next job");
mm_camera_super_buf_t *frame =
(mm_camera_super_buf_t *)pme->mDataQ.dequeue();
if (NULL != frame) {
if (pme->mDataCB != NULL) {
pme->mDataCB(frame, pme, pme->mUserData);
} else {
// no data cb routine, return buf here
pme->bufDone(frame->bufs[0]->buf_idx);
free(frame);
}
}
}
break;
case CAMERA_CMD_TYPE_EXIT:
LOGH("Exit");
/* flush data buf queue */
pme->mDataQ.flush();
running = 0;
break;
default:
break;
}
} while (running);
LOGH("X");
return NULL;
}
/*===========================================================================
* FUNCTION : bufDone
*
* DESCRIPTION: return stream buffer to kernel
*
* PARAMETERS :
* @index : index of buffer to be returned
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::bufDone(uint32_t index)
{
int32_t rc = NO_ERROR;
if (index >= mNumBufs || mBufDefs == NULL)
return BAD_INDEX;
rc = mCamOps->qbuf(mCamHandle, mChannelHandle, &mBufDefs[index]);
if (rc < 0)
return rc;
return rc;
}
/*===========================================================================
* FUNCTION : bufDone
*
* DESCRIPTION: return stream buffer to kernel
*
* PARAMETERS :
* @opaque : stream frame/metadata buf to be returned
* @isMetaData: flag if returned opaque is a metadatabuf or the real frame ptr
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::bufDone(const void *opaque, bool isMetaData)
{
int32_t rc = NO_ERROR;
int index = -1;
if ((mStreamInfo != NULL)
&& (mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH)
&& (mStreamBatchBufs != NULL)) {
index = mStreamBatchBufs->getMatchBufIndex(opaque, isMetaData);
} else if (mStreamBufs != NULL){
index = mStreamBufs->getMatchBufIndex(opaque, isMetaData);
}
if (index == -1 || index >= mNumBufs || mBufDefs == NULL) {
LOGE("Cannot find buf for opaque data = %p", opaque);
return BAD_INDEX;
}
if ((CAMERA_MIN_VIDEO_BATCH_BUFFERS > index)
&& mStreamMetaMemory[index].numBuffers > 0) {
for (int i= 0; i < mStreamMetaMemory[index].numBuffers; i++) {
uint8_t buf_idx = mStreamMetaMemory[index].buf_index[i];
bufDone((uint32_t)buf_idx);
}
mStreamMetaMemory[index].consumerOwned = FALSE;
mStreamMetaMemory[index].numBuffers = 0;
} else {
LOGH("Buffer Index = %d, Frame Idx = %d", index,
mBufDefs[index].frame_idx);
rc = bufDone((uint32_t)index);
}
return rc;
}
/*===========================================================================
* FUNCTION : getNumQueuedBuf
*
* DESCRIPTION: return queued buffer count
*
* PARAMETERS : None
*
* RETURN : queued buffer count
*==========================================================================*/
int32_t QCameraStream::getNumQueuedBuf()
{
int32_t rc = -1;
if (mHandle > 0) {
rc = mCamOps->get_queued_buf_count(mCamHandle, mChannelHandle, mHandle);
}
if (rc == -1) {
LOGE("stream is not in active state. Invalid operation");
}
return rc;
}
/*===========================================================================
* FUNCTION : getBufs
*
* DESCRIPTION: allocate stream buffers
*
* PARAMETERS :
* @offset : offset info of stream buffers
* @num_bufs : number of buffers allocated
* @initial_reg_flag: flag to indicate if buffer needs to be registered
* at kernel initially
* @bufs : output of allocated buffers
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getBufs(cam_frame_len_offset_t *offset,
uint8_t *num_bufs,
uint8_t **initial_reg_flag,
mm_camera_buf_def_t **bufs,
mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int rc = NO_ERROR;
uint8_t *regFlags;
if (!ops_tbl) {
LOGE("ops_tbl is NULL");
return INVALID_OPERATION;
}
mFrameLenOffset = *offset;
uint8_t numBufAlloc = mNumBufs;
mNumBufsNeedAlloc = 0;
if (mDynBufAlloc) {
numBufAlloc = CAMERA_MIN_ALLOCATED_BUFFERS;
if (numBufAlloc > mNumBufs) {
mDynBufAlloc = false;
numBufAlloc = mNumBufs;
} else {
mNumBufsNeedAlloc = (uint8_t)(mNumBufs - numBufAlloc);
}
}
/* For some stream types, buffer allocation may have already begun
* preemptively. If this is the case, we need to wait for the
* preemptive allocation to complete before proceeding. */
mAllocator.waitForDeferredAlloc(mStreamInfo->stream_type);
//Allocate stream buffer
mStreamBufs = mAllocator.allocateStreamBuf(mStreamInfo->stream_type,
mFrameLenOffset.frame_len, mFrameLenOffset.mp[0].stride,
mFrameLenOffset.mp[0].scanline, numBufAlloc);
if (!mStreamBufs) {
LOGE("Failed to allocate stream buffers");
return NO_MEMORY;
}
mNumBufs = (uint8_t)(numBufAlloc + mNumBufsNeedAlloc);
uint8_t numBufsToMap = mStreamBufs->getMappable();
QCameraBufferMaps bufferMaps;
for (uint32_t i = 0; i < numBufsToMap; i++) {
ssize_t bufSize = mStreamBufs->getSize(i);
if (BAD_INDEX == bufSize) {
LOGE("Failed to retrieve buffer size (bad index)");
return INVALID_OPERATION;
}
rc = bufferMaps.enqueue(CAM_MAPPING_BUF_TYPE_STREAM_BUF,
0 /*stream id*/, i /*buf index*/, -1 /*plane index*/,
0 /*cookie*/, mStreamBufs->getFd(i), bufSize);
if (rc < 0) {
LOGE("Failed to map buffers");
return BAD_INDEX;
}
}
cam_buf_map_type_list bufMapList;
rc = bufferMaps.getCamBufMapList(bufMapList);
if (rc == NO_ERROR) {
rc = ops_tbl->bundled_map_ops(&bufMapList, ops_tbl->userdata);
}
if (rc < 0) {
LOGE("map_stream_buf failed: %d", rc);
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
return INVALID_OPERATION;
}
//regFlags array is allocated by us, but consumed and freed by mm-camera-interface
regFlags = (uint8_t *)malloc(sizeof(uint8_t) * mNumBufs);
if (!regFlags) {
LOGE("Out of memory");
for (uint32_t i = 0; i < numBufsToMap; i++) {
ops_tbl->unmap_ops(i, -1, CAM_MAPPING_BUF_TYPE_STREAM_BUF, ops_tbl->userdata);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
return NO_MEMORY;
}
memset(regFlags, 0, sizeof(uint8_t) * mNumBufs);
mBufDefs = (mm_camera_buf_def_t *)malloc(mNumBufs * sizeof(mm_camera_buf_def_t));
if (mBufDefs == NULL) {
LOGE("getRegFlags failed %d", rc);
for (uint32_t i = 0; i < numBufsToMap; i++) {
ops_tbl->unmap_ops(i, -1, CAM_MAPPING_BUF_TYPE_STREAM_BUF, ops_tbl->userdata);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
free(regFlags);
regFlags = NULL;
return INVALID_OPERATION;
}
memset(mBufDefs, 0, mNumBufs * sizeof(mm_camera_buf_def_t));
for (uint32_t i = 0; i < numBufsToMap; i++) {
mStreamBufs->getBufDef(mFrameLenOffset, mBufDefs[i], i);
}
rc = mStreamBufs->getRegFlags(regFlags);
if (rc < 0) {
LOGE("getRegFlags failed %d", rc);
for (uint32_t i = 0; i < numBufsToMap; i++) {
ops_tbl->unmap_ops(i, -1, CAM_MAPPING_BUF_TYPE_STREAM_BUF, ops_tbl->userdata);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
free(mBufDefs);
mBufDefs = NULL;
free(regFlags);
regFlags = NULL;
return INVALID_OPERATION;
}
*num_bufs = mNumBufs;
*initial_reg_flag = regFlags;
*bufs = mBufDefs;
LOGH("stream type: %d, mRegFlags: 0x%x, numBufs: %d",
mStreamInfo->stream_type, regFlags, mNumBufs);
if (mNumBufsNeedAlloc > 0) {
pthread_mutex_lock(&m_lock);
wait_for_cond = TRUE;
pthread_mutex_unlock(&m_lock);
LOGH("Still need to allocate %d buffers",
mNumBufsNeedAlloc);
// start another thread to allocate the rest of buffers
pthread_create(&mBufAllocPid,
NULL,
BufAllocRoutine,
this);
pthread_setname_np(mBufAllocPid, "CAM_strmBuf");
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getBufsDeferred
*
* DESCRIPTION: allocate deferred stream buffers
*
* PARAMETERS :
* @offset : offset info of stream buffers
* @num_bufs : number of buffers allocated
* @initial_reg_flag: flag to indicate if buffer needs to be registered
* at kernel initially
* @bufs : output of allocated buffers
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getBufsDeferred(cam_frame_len_offset_t *offset,
uint8_t *num_bufs,
uint8_t **initial_reg_flag,
mm_camera_buf_def_t **bufs,
mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int32_t rc = NO_ERROR;
// wait for allocation
rc = mAllocator.waitForBackgroundTask(mAllocTaskId);
if (rc != NO_ERROR) {
LOGE("Allocation Failed");
return NO_MEMORY;
}
if (!mRegFlags || !mBufDefs) {
LOGE("reg flags or buf defs uninitialized");
return NO_MEMORY;
}
*initial_reg_flag = mRegFlags;
*num_bufs = mNumBufs;
*bufs = mBufDefs;
LOGH("stream type: %d, mRegFlags: 0x%x, numBufs: %d",
getMyType(), mRegFlags, mNumBufs);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : mapNewBuffer
*
* DESCRIPTION: map a new stream buffer
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::mapNewBuffer(uint32_t index)
{
LOGH("E - index = %d", index);
int rc = NO_ERROR;
if (mStreamBufs == NULL) {
LOGE("Invalid Operation");
return INVALID_OPERATION;
}
ssize_t bufSize = mStreamBufs->getSize(index);
if (BAD_INDEX == bufSize) {
LOGE("Failed to retrieve buffer size (bad index)");
return INVALID_OPERATION;
}
cam_buf_map_type_list bufMapList;
rc = QCameraBufferMaps::makeSingletonBufMapList(
CAM_MAPPING_BUF_TYPE_STREAM_BUF, 0 /*stream id*/, index,
-1 /*plane index*/, 0 /*cookie*/, mStreamBufs->getFd(index),
bufSize, bufMapList);
if (rc == NO_ERROR) {
rc = m_MemOpsTbl.bundled_map_ops(&bufMapList, m_MemOpsTbl.userdata);
}
if (rc < 0) {
LOGE("map_stream_buf failed: %d", rc);
rc = INVALID_OPERATION;
} else {
mStreamBufs->getBufDef(mFrameLenOffset, mBufDefs[index], index);
}
LOGH("X - rc = %d", rc);
return rc;
}
/*===========================================================================
* FUNCTION : allocateBuffers
*
* DESCRIPTION: allocate stream buffers
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::allocateBuffers()
{
int32_t rc = NO_ERROR;
mFrameLenOffset = mStreamInfo->buf_planes.plane_info;
if (mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH) {
return allocateBatchBufs(&mFrameLenOffset,
&mNumBufs, &mRegFlags,
&mBufDefs, NULL);
}
/* This allocation is running in the deferred context, so it
* is safe (and necessary) to assume any preemptive allocation
* is already complete. Therefore, no need to wait here. */
uint8_t numBufAlloc = mNumBufs;
mNumBufsNeedAlloc = 0;
if (mDynBufAlloc) {
numBufAlloc = CAMERA_MIN_ALLOCATED_BUFFERS;
if (numBufAlloc > mNumBufs) {
mDynBufAlloc = false;
numBufAlloc = mNumBufs;
} else {
mNumBufsNeedAlloc = (uint8_t)(mNumBufs - numBufAlloc);
}
}
//Allocate and map stream info buffer
mStreamBufs = mAllocator.allocateStreamBuf(mStreamInfo->stream_type,
mFrameLenOffset.frame_len,
mFrameLenOffset.mp[0].stride,
mFrameLenOffset.mp[0].scanline,
numBufAlloc);
if (!mStreamBufs) {
LOGE("Failed to allocate stream buffers");
return NO_MEMORY;
}
mNumBufs = (uint8_t)(numBufAlloc + mNumBufsNeedAlloc);
uint8_t numBufsToMap = mStreamBufs->getMappable();
//regFlags array is allocated by us,
// but consumed and freed by mm-camera-interface
mRegFlags = (uint8_t *)malloc(sizeof(uint8_t) * mNumBufs);
if (!mRegFlags) {
LOGE("Out of memory");
for (uint32_t i = 0; i < numBufsToMap; i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, NULL);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
return NO_MEMORY;
}
memset(mRegFlags, 0, sizeof(uint8_t) * mNumBufs);
size_t bufDefsSize = mNumBufs * sizeof(mm_camera_buf_def_t);
mBufDefs = (mm_camera_buf_def_t *)malloc(bufDefsSize);
if (mBufDefs == NULL) {
LOGE("getRegFlags failed %d", rc);
for (uint32_t i = 0; i < numBufsToMap; i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, NULL);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
free(mRegFlags);
mRegFlags = NULL;
return INVALID_OPERATION;
}
memset(mBufDefs, 0, bufDefsSize);
for (uint32_t i = 0; i < numBufsToMap; i++) {
mStreamBufs->getBufDef(mFrameLenOffset, mBufDefs[i], i);
}
rc = mStreamBufs->getRegFlags(mRegFlags);
if (rc < 0) {
LOGE("getRegFlags failed %d", rc);
for (uint32_t i = 0; i < numBufsToMap; i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, NULL);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
free(mBufDefs);
mBufDefs = NULL;
free(mRegFlags);
mRegFlags = NULL;
return INVALID_OPERATION;
}
if (mNumBufsNeedAlloc > 0) {
pthread_mutex_lock(&m_lock);
wait_for_cond = TRUE;
pthread_mutex_unlock(&m_lock);
LOGH("Still need to allocate %d buffers",
mNumBufsNeedAlloc);
// start another thread to allocate the rest of buffers
pthread_create(&mBufAllocPid,
NULL,
BufAllocRoutine,
this);
pthread_setname_np(mBufAllocPid, "CAM_strmBufAlloc");
}
return rc;
}
/*===========================================================================
* FUNCTION : mapBuffers
*
* DESCRIPTION: map stream buffers
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::mapBuffers()
{
int32_t rc = NO_ERROR;
QCameraBufferMaps bufferMaps;
rc = mAllocator.waitForBackgroundTask(mAllocTaskId);
if (rc != NO_ERROR) {
LOGE("Allocation Failed");
return NO_MEMORY;
}
if (mStreamBufs == NULL) {
LOGE("Stream buffers not allocated");
return UNKNOWN_ERROR;
}
uint8_t numBufsToMap = mStreamBufs->getMappable();
for (uint32_t i = 0; i < numBufsToMap; i++) {
ssize_t bufSize = mStreamBufs->getSize(i);
if (BAD_INDEX != bufSize) {
rc = bufferMaps.enqueue(CAM_MAPPING_BUF_TYPE_STREAM_BUF, mHandle,
i /*buf index*/, -1 /*plane index*/, 0 /*cookie*/,
mStreamBufs->getFd(i), bufSize);
if (rc < 0) {
LOGE("Failed to map buffers");
rc = BAD_INDEX;
break;
}
} else {
LOGE("Bad index %u", i);
rc = BAD_INDEX;
break;
}
}
cam_buf_map_type_list bufMapList;
if (rc == NO_ERROR) {
rc = bufferMaps.getCamBufMapList(bufMapList);
}
if (rc == NO_ERROR) {
rc = mapBufs(bufMapList, NULL);
}
return rc;
}
/*===========================================================================
* FUNCTION : allocateBatchBufs
*
* DESCRIPTION: allocate stream batch buffers and stream buffers
*
* PARAMETERS :
* @offset : offset info of stream buffers
* @num_bufs : number of buffers allocated
* @initial_reg_flag: flag to indicate if buffer needs to be registered
* at kernel initially
* @bufs : output of allocated buffers
* @plane_bufs : output of allocated plane buffers
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::allocateBatchBufs(cam_frame_len_offset_t *offset,
uint8_t *num_bufs, uint8_t **initial_reg_flag,
mm_camera_buf_def_t **bufs, mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int rc = NO_ERROR;
uint8_t *regFlags;
QCameraBufferMaps bufferMaps;
QCameraBufferMaps planeBufferMaps;
mFrameLenOffset = *offset;
LOGH("Batch Buffer allocation stream type = %d", getMyType());
//Allocate stream batch buffer
mStreamBatchBufs = mAllocator.allocateStreamUserBuf (mStreamInfo);
if (!mStreamBatchBufs) {
LOGE("Failed to allocate stream batch buffers");
return NO_MEMORY;
}
uint8_t numBufsToMap = mStreamBatchBufs->getMappable();
//map batch buffers
for (uint32_t i = 0; i < numBufsToMap; i++) {
rc = bufferMaps.enqueue(CAM_MAPPING_BUF_TYPE_STREAM_USER_BUF,
0 /*stream id*/, i /*buf index*/, -1 /*plane index*/,
0 /*cookie*/, mStreamBatchBufs->getFd(i), mNumBufs);
if (rc < 0) {
LOGE("Failed to map buffers");
rc = BAD_INDEX;
break;
}
}
cam_buf_map_type_list bufMapList;
if (rc == NO_ERROR) {
rc = bufferMaps.getCamBufMapList(bufMapList);
}
if (rc == NO_ERROR) {
rc = mapBufs(bufMapList, ops_tbl);
}
if (rc < 0) {
LOGE("Failed to map stream batch buffers");
mStreamBatchBufs->deallocate();
delete mStreamBatchBufs;
mStreamBatchBufs = NULL;
return NO_MEMORY;
}
/*calculate stream Buffer count*/
mNumPlaneBufs =
(mNumBufs * mStreamInfo->user_buf_info.frame_buf_cnt);
/* For some stream types, buffer allocation may have already begun
* preemptively. If this is the case, we need to wait for the
* preemptive allocation to complete before proceeding. */
mAllocator.waitForDeferredAlloc(mStreamInfo->stream_type);
//Allocate stream buffer
mStreamBufs = mAllocator.allocateStreamBuf(mStreamInfo->stream_type,
mFrameLenOffset.frame_len,mFrameLenOffset.mp[0].stride,
mFrameLenOffset.mp[0].scanline,mNumPlaneBufs);
if (!mStreamBufs) {
LOGE("Failed to allocate stream buffers");
rc = NO_MEMORY;
goto err1;
}
//Map plane stream buffers
for (uint32_t i = 0; i < mNumPlaneBufs; i++) {
ssize_t bufSize = mStreamBufs->getSize(i);
if (BAD_INDEX != bufSize) {
rc = planeBufferMaps.enqueue(CAM_MAPPING_BUF_TYPE_STREAM_BUF,
0 /*stream id*/, i /*buf index*/, -1 /*plane index*/,
0 /*cookie*/, mStreamBufs->getFd(i), bufSize);
if (rc < 0) {
LOGE("Failed to map buffers");
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
rc = INVALID_OPERATION;
goto err1;
}
} else {
LOGE("Failed to retrieve buffer size (bad index)");
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
rc = INVALID_OPERATION;
goto err1;
}
}
cam_buf_map_type_list planeBufMapList;
rc = planeBufferMaps.getCamBufMapList(planeBufMapList);
if (rc == NO_ERROR) {
rc = mapBufs(planeBufMapList, ops_tbl);
}
if (rc < 0) {
LOGE("map_stream_buf failed: %d", rc);
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
rc = INVALID_OPERATION;
goto err1;
}
LOGD("BATCH Buf Count = %d, Plane Buf Cnt = %d",
mNumBufs, mNumPlaneBufs);
//regFlags array is allocated by us, but consumed and freed by mm-camera-interface
regFlags = (uint8_t *)malloc(sizeof(uint8_t) * mNumBufs);
if (!regFlags) {
LOGE("Out of memory");
for (uint32_t i = 0; i < mNumPlaneBufs; i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, ops_tbl);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
rc = NO_MEMORY;
goto err1;
}
memset(regFlags, 0, sizeof(uint8_t) * mNumBufs);
for (uint32_t i = 0; i < mNumBufs; i++) {
regFlags[i] = 1;
}
mBufDefs = (mm_camera_buf_def_t *)malloc(mNumBufs * sizeof(mm_camera_buf_def_t));
if (mBufDefs == NULL) {
LOGE("getRegFlags failed %d", rc);
for (uint32_t i = 0; i < mNumPlaneBufs; i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, ops_tbl);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
free(regFlags);
regFlags = NULL;
rc = INVALID_OPERATION;
goto err1;
}
memset(mBufDefs, 0, mNumBufs * sizeof(mm_camera_buf_def_t));
mPlaneBufDefs = (mm_camera_buf_def_t *)
malloc(mNumPlaneBufs * (sizeof(mm_camera_buf_def_t)));
if (mPlaneBufDefs == NULL) {
LOGE("No Memory");
free(regFlags);
regFlags = NULL;
free(mBufDefs);
mBufDefs = NULL;
for (uint32_t i = 0; i < mNumPlaneBufs; i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, ops_tbl);
}
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
free(regFlags);
regFlags = NULL;
rc = INVALID_OPERATION;
goto err1;
}
memset(mPlaneBufDefs, 0,
mNumPlaneBufs * (sizeof(mm_camera_buf_def_t)));
for (uint32_t i = 0; i < mStreamInfo->num_bufs; i++) {
mStreamBatchBufs->getUserBufDef(mStreamInfo->user_buf_info,
mBufDefs[i], i, mFrameLenOffset, mPlaneBufDefs,
mStreamBufs);
}
*num_bufs = mNumBufs;
*initial_reg_flag = regFlags;
*bufs = mBufDefs;
LOGH("stream type: %d, numBufs: %d mNumPlaneBufs: %d",
mStreamInfo->stream_type, mNumBufs, mNumPlaneBufs);
return NO_ERROR;
err1:
mStreamBatchBufs->deallocate();
delete mStreamBatchBufs;
mStreamBatchBufs = NULL;
return rc;
}
/*===========================================================================
* FUNCTION : releaseBuffs
*
* DESCRIPTION: method to deallocate stream buffers
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::releaseBuffs()
{
int rc = NO_ERROR;
if (mStreamInfo->streaming_mode == CAM_STREAMING_MODE_BATCH) {
return releaseBatchBufs(NULL);
}
if ((NULL != mBufDefs) && (mStreamBufs != NULL)) {
uint8_t numBufsToUnmap = mStreamBufs->getMappable();
for (uint32_t i = 0; i < numBufsToUnmap; i++) {
rc = unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, NULL);
if (rc < 0) {
LOGE("map_stream_buf failed: %d", rc);
}
}
// mBufDefs just keep a ptr to the buffer
// mm-camera-interface own the buffer, so no need to free
mBufDefs = NULL;
memset(&mFrameLenOffset, 0, sizeof(mFrameLenOffset));
}
if (!mStreamBufsAcquired && (mStreamBufs != NULL)) {
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
}
return rc;
}
/*===========================================================================
* FUNCTION : releaseBatchBufs
*
* DESCRIPTION: method to deallocate stream buffers and batch buffers
*
* PARAMETERS :
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::releaseBatchBufs(mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int rc = NO_ERROR;
if (NULL != mPlaneBufDefs) {
for (uint32_t i = 0; i < mNumPlaneBufs; i++) {
rc = unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_BUF, i, -1, ops_tbl);
if (rc < 0) {
LOGE("map_stream_buf failed: %d", rc);
}
}
// mBufDefs just keep a ptr to the buffer
// mm-camera-interface own the buffer, so no need to free
mPlaneBufDefs = NULL;
memset(&mFrameLenOffset, 0, sizeof(mFrameLenOffset));
mNumPlaneBufs = 0;
}
if (mStreamBufs != NULL) {
mStreamBufs->deallocate();
delete mStreamBufs;
}
mBufDefs = NULL;
if (mStreamBatchBufs != NULL) {
for (uint8_t i = 0; i < mStreamBatchBufs->getCnt(); i++) {
unmapBuf(CAM_MAPPING_BUF_TYPE_STREAM_USER_BUF, i, -1, ops_tbl);
}
mStreamBatchBufs->deallocate();
delete mStreamBatchBufs;
mStreamBatchBufs = NULL;
}
return rc;
}
/*===========================================================================
* FUNCTION : BufAllocRoutine
*
* DESCRIPTION: function to allocate additional stream buffers
*
* PARAMETERS :
* @data : user data ptr
*
* RETURN : none
*==========================================================================*/
void *QCameraStream::BufAllocRoutine(void *data)
{
QCameraStream *pme = (QCameraStream *)data;
int32_t rc = NO_ERROR;
LOGH("E");
pme->cond_wait();
if (pme->mNumBufsNeedAlloc > 0) {
uint8_t numBufAlloc = (uint8_t)(pme->mNumBufs - pme->mNumBufsNeedAlloc);
rc = pme->mAllocator.allocateMoreStreamBuf(pme->mStreamBufs,
pme->mFrameLenOffset.frame_len,
pme->mNumBufsNeedAlloc);
if (rc != NO_ERROR) {
LOGE("Failed to allocate buffers");
pme->mNumBufsNeedAlloc = 0;
return NULL;
}
pme->mNumBufsNeedAlloc = 0;
QCameraBufferMaps bufferMaps;
for (uint32_t i = numBufAlloc; i < pme->mNumBufs; i++) {
ssize_t bufSize = pme->mStreamBufs->getSize(i);
if (BAD_INDEX == bufSize) {
LOGE("Failed to retrieve buffer size (bad index)");
return NULL;
}
rc = bufferMaps.enqueue(CAM_MAPPING_BUF_TYPE_STREAM_BUF,
pme->mHandle, i /*buf index*/, -1 /*plane index*/,
0 /*cookie*/, pme->mStreamBufs->getFd(i), bufSize);
if (rc < 0) {
LOGE("Failed to map buffers");
return NULL;
}
}
cam_buf_map_type_list bufMapList;
rc = bufferMaps.getCamBufMapList(bufMapList);
if (rc == NO_ERROR) {
rc = pme->m_MemOpsTbl.bundled_map_ops(&bufMapList, pme->m_MemOpsTbl.userdata);
}
if (rc != 0) {
LOGE("Failed to map buffers with return code %d", rc);
return NULL;
}
for (uint32_t i = numBufAlloc; i < pme->mNumBufs; i++) {
pme->mStreamBufs->getBufDef(pme->mFrameLenOffset, pme->mBufDefs[i], i);
pme->mCamOps->qbuf(pme->mCamHandle, pme->mChannelHandle,
&pme->mBufDefs[i]);
}
}
LOGH("X");
return NULL;
}
/*===========================================================================
* FUNCTION : cond_signal
*
* DESCRIPTION: signal if flag "wait_for_cond" is set
*
*==========================================================================*/
void QCameraStream::cond_signal(bool forceExit)
{
pthread_mutex_lock(&m_lock);
if(wait_for_cond == TRUE){
wait_for_cond = FALSE;
if (forceExit) {
mNumBufsNeedAlloc = 0;
}
pthread_cond_signal(&m_cond);
}
pthread_mutex_unlock(&m_lock);
}
/*===========================================================================
* FUNCTION : cond_wait
*
* DESCRIPTION: wait on if flag "wait_for_cond" is set
*
*==========================================================================*/
void QCameraStream::cond_wait()
{
pthread_mutex_lock(&m_lock);
while (wait_for_cond == TRUE) {
pthread_cond_wait(&m_cond, &m_lock);
}
pthread_mutex_unlock(&m_lock);
}
/*===========================================================================
* FUNCTION : putBufs
*
* DESCRIPTION: deallocate stream buffers
*
* PARAMETERS :
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::putBufs(mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
int rc = NO_ERROR;
if (mBufAllocPid != 0) {
cond_signal(true);
LOGL("wait for buf allocation thread dead");
pthread_join(mBufAllocPid, NULL);
mBufAllocPid = 0;
LOGL("return from buf allocation thread");
}
uint8_t numBufsToUnmap = mStreamBufs->getMappable();
for (uint32_t i = 0; i < numBufsToUnmap; i++) {
rc = ops_tbl->unmap_ops(i, -1, CAM_MAPPING_BUF_TYPE_STREAM_BUF, ops_tbl->userdata);
if (rc < 0) {
LOGE("map_stream_buf failed: %d", rc);
}
}
mBufDefs = NULL; // mBufDefs just keep a ptr to the buffer
// mm-camera-interface own the buffer, so no need to free
memset(&mFrameLenOffset, 0, sizeof(mFrameLenOffset));
if ( !mStreamBufsAcquired ) {
mStreamBufs->deallocate();
delete mStreamBufs;
mStreamBufs = NULL;
}
return rc;
}
/*===========================================================================
* FUNCTION : putBufsDeffered
*
* DESCRIPTION: function to deallocate deffered stream buffers
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::putBufsDeffered()
{
if (mBufAllocPid != 0) {
cond_signal(true);
LOGH("%s: wait for buf allocation thread dead", __func__);
// Wait for the allocation of additional stream buffers
pthread_join(mBufAllocPid, NULL);
mBufAllocPid = 0;
LOGH("%s: return from buf allocation thread", __func__);
}
// Deallocation of the deffered stream buffers handled separately
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : invalidateBuf
*
* DESCRIPTION: invalidate a specific stream buffer
*
* PARAMETERS :
* @index : index of the buffer to invalidate
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::invalidateBuf(uint32_t index)
{
if (mStreamBufs == NULL) {
LOGE("Invalid Operation");
return INVALID_OPERATION;
}
return mStreamBufs->invalidateCache(index);
}
/*===========================================================================
* FUNCTION : cleanInvalidateBuf
*
* DESCRIPTION: clean invalidate a specific stream buffer
*
* PARAMETERS :
* @index : index of the buffer to clean invalidate
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::cleanInvalidateBuf(uint32_t index)
{
if (mStreamBufs == NULL) {
LOGE("Invalid Operation");
return INVALID_OPERATION;
}
return mStreamBufs->cleanInvalidateCache(index);
}
/*===========================================================================
* FUNCTION : isTypeOf
*
* DESCRIPTION: helper function to determine if the stream is of the queried type
*
* PARAMETERS :
* @type : stream type as of queried
*
* RETURN : true/false
*==========================================================================*/
bool QCameraStream::isTypeOf(cam_stream_type_t type)
{
if (mStreamInfo != NULL && (mStreamInfo->stream_type == type)) {
return true;
} else {
return false;
}
}
/*===========================================================================
* FUNCTION : isOrignalTypeOf
*
* DESCRIPTION: helper function to determine if the original stream is of the
* queried type if it's reproc stream
*
* PARAMETERS :
* @type : stream type as of queried
*
* RETURN : true/false
*==========================================================================*/
bool QCameraStream::isOrignalTypeOf(cam_stream_type_t type)
{
if (mStreamInfo != NULL &&
mStreamInfo->stream_type == CAM_STREAM_TYPE_OFFLINE_PROC &&
mStreamInfo->reprocess_config.pp_type == CAM_ONLINE_REPROCESS_TYPE &&
mStreamInfo->reprocess_config.online.input_stream_type == type) {
return true;
} else if (
mStreamInfo != NULL &&
mStreamInfo->stream_type == CAM_STREAM_TYPE_OFFLINE_PROC &&
mStreamInfo->reprocess_config.pp_type == CAM_OFFLINE_REPROCESS_TYPE &&
mStreamInfo->reprocess_config.offline.input_type == type) {
return true;
} else {
return false;
}
}
/*===========================================================================
* FUNCTION : getMyType
*
* DESCRIPTION: return stream type
*
* PARAMETERS : none
*
* RETURN : stream type
*==========================================================================*/
cam_stream_type_t QCameraStream::getMyType()
{
if (mStreamInfo != NULL) {
return mStreamInfo->stream_type;
} else {
return CAM_STREAM_TYPE_DEFAULT;
}
}
/*===========================================================================
* FUNCTION : getMyOriginalType
*
* DESCRIPTION: return stream type
*
* PARAMETERS : none
*
* RETURN : stream type
*==========================================================================*/
cam_stream_type_t QCameraStream::getMyOriginalType()
{
if (mStreamInfo != NULL) {
if (mStreamInfo->stream_type == CAM_STREAM_TYPE_OFFLINE_PROC &&
mStreamInfo->reprocess_config.pp_type == CAM_ONLINE_REPROCESS_TYPE) {
return mStreamInfo->reprocess_config.online.input_stream_type;
} else if (mStreamInfo->stream_type == CAM_STREAM_TYPE_OFFLINE_PROC &&
mStreamInfo->reprocess_config.pp_type == CAM_OFFLINE_REPROCESS_TYPE) {
return mStreamInfo->reprocess_config.offline.input_type;
} else {
return mStreamInfo->stream_type;
}
} else {
return CAM_STREAM_TYPE_DEFAULT;
}
}
/*===========================================================================
* FUNCTION : getFrameOffset
*
* DESCRIPTION: query stream buffer frame offset info
*
* PARAMETERS :
* @offset : reference to struct to store the queried frame offset info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getFrameOffset(cam_frame_len_offset_t &offset)
{
if (NULL == mStreamInfo) {
return NO_INIT;
}
offset = mFrameLenOffset;
if ((ROTATE_90 == mOnlineRotation) || (ROTATE_270 == mOnlineRotation)
|| (offset.frame_len == 0) || (offset.num_planes == 0)) {
// Re-calculate frame offset in case of online rotation
cam_stream_info_t streamInfo = *mStreamInfo;
getFrameDimension(streamInfo.dim);
calcOffset(&streamInfo);
offset = streamInfo.buf_planes.plane_info;
}
return 0;
}
/*===========================================================================
* FUNCTION : getCropInfo
*
* DESCRIPTION: query crop info of the stream
*
* PARAMETERS :
* @crop : reference to struct to store the queried crop info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getCropInfo(cam_rect_t &crop)
{
pthread_mutex_lock(&mCropLock);
crop = mCropInfo;
pthread_mutex_unlock(&mCropLock);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setCropInfo
*
* DESCRIPTION: set crop info of the stream
*
* PARAMETERS :
* @crop : struct to store new crop info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::setCropInfo(cam_rect_t crop)
{
pthread_mutex_lock(&mCropLock);
mCropInfo = crop;
pthread_mutex_unlock(&mCropLock);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getFrameDimension
*
* DESCRIPTION: query stream frame dimension info
*
* PARAMETERS :
* @dim : reference to struct to store the queried frame dimension
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getFrameDimension(cam_dimension_t &dim)
{
if (mStreamInfo != NULL) {
if ((ROTATE_90 == mOnlineRotation) || (ROTATE_270 == mOnlineRotation)) {
dim.width = mStreamInfo->dim.height;
dim.height = mStreamInfo->dim.width;
} else {
dim = mStreamInfo->dim;
}
return 0;
}
return -1;
}
/*===========================================================================
* FUNCTION : getFormat
*
* DESCRIPTION: query stream format
*
* PARAMETERS :
* @fmt : reference to stream format
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getFormat(cam_format_t &fmt)
{
if (mStreamInfo != NULL) {
fmt = mStreamInfo->fmt;
return 0;
}
return -1;
}
/*===========================================================================
* FUNCTION : getMyServerID
*
* DESCRIPTION: query server stream ID
*
* PARAMETERS : None
*
* RETURN : stream ID from server
*==========================================================================*/
uint32_t QCameraStream::getMyServerID() {
if (mStreamInfo != NULL) {
return mStreamInfo->stream_svr_id;
} else {
return 0;
}
}
/*===========================================================================
* FUNCTION : acquireStreamBufs
*
* DESCRIPTION: acquire stream buffers and postpone their release.
*
* PARAMETERS : None
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::acquireStreamBufs()
{
mStreamBufsAcquired = true;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : mapBuf
*
* DESCRIPTION: map stream related buffer to backend server
*
* PARAMETERS :
* @buf_type : mapping type of buffer
* @buf_idx : index of buffer
* @plane_idx: plane index
* @fd : fd of the buffer
* @size : lenght of the buffer
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::mapBuf(uint8_t buf_type, uint32_t buf_idx,
int32_t plane_idx, int fd, size_t size, mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
cam_buf_map_type_list bufMapList;
int32_t rc = QCameraBufferMaps::makeSingletonBufMapList(
(cam_mapping_buf_type)buf_type, mHandle, buf_idx, plane_idx,
0 /*cookie*/, fd, size, bufMapList);
if (rc != NO_ERROR) {
return rc;
}
return mapBufs(bufMapList, ops_tbl);
}
/*===========================================================================
* FUNCTION : mapBufs
*
* DESCRIPTION: map stream related buffers to backend server
*
* PARAMETERS :
* @bufMapList : buffer mapping information
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::mapBufs(cam_buf_map_type_list bufMapList,
mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
if (m_MemOpsTbl.bundled_map_ops != NULL) {
return m_MemOpsTbl.bundled_map_ops(&bufMapList, m_MemOpsTbl.userdata);
} else {
return mCamOps->map_stream_bufs(mCamHandle, mChannelHandle,
&bufMapList);
}
}
/*===========================================================================
* FUNCTION : unmapBuf
*
* DESCRIPTION: unmap stream related buffer to backend server
*
* PARAMETERS :
* @buf_type : mapping type of buffer
* @buf_idx : index of buffer
* @plane_idx: plane index
* @ops_tbl : ptr to buf mapping/unmapping ops
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::unmapBuf(uint8_t buf_type, uint32_t buf_idx, int32_t plane_idx,
mm_camera_map_unmap_ops_tbl_t *ops_tbl)
{
if (ops_tbl != NULL) {
return ops_tbl->unmap_ops(buf_idx, plane_idx,
(cam_mapping_buf_type)buf_type, ops_tbl->userdata);
} else {
return mCamOps->unmap_stream_buf(mCamHandle, mChannelHandle,
mHandle, buf_type, buf_idx, plane_idx);
}
}
/*===========================================================================
* FUNCTION : setParameter
*
* DESCRIPTION: set stream based parameters
*
* PARAMETERS :
* @param : ptr to parameters to be set
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::setParameter(cam_stream_parm_buffer_t &param)
{
int32_t rc = NO_ERROR;
pthread_mutex_lock(&mParameterLock);
mStreamInfo->parm_buf = param;
rc = mCamOps->set_stream_parms(mCamHandle,
mChannelHandle,
mHandle,
&mStreamInfo->parm_buf);
if (rc == NO_ERROR) {
param = mStreamInfo->parm_buf;
}
pthread_mutex_unlock(&mParameterLock);
return rc;
}
/*===========================================================================
* FUNCTION : getParameter
*
* DESCRIPTION: get stream based parameters
*
* PARAMETERS :
* @param : ptr to parameters to be red
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::getParameter(cam_stream_parm_buffer_t &param)
{
int32_t rc = NO_ERROR;
pthread_mutex_lock(&mParameterLock);
mStreamInfo->parm_buf = param;
rc = mCamOps->get_stream_parms(mCamHandle,
mChannelHandle,
mHandle,
&mStreamInfo->parm_buf);
if (rc == NO_ERROR) {
param = mStreamInfo->parm_buf;
}
pthread_mutex_unlock(&mParameterLock);
return rc;
}
/*===========================================================================
* FUNCTION : releaseFrameData
*
* DESCRIPTION: callback function to release frame data node
*
* PARAMETERS :
* @data : ptr to post process input data
* @user_data : user data ptr (QCameraReprocessor)
*
* RETURN : None
*==========================================================================*/
void QCameraStream::releaseFrameData(void *data, void *user_data)
{
QCameraStream *pme = (QCameraStream *)user_data;
mm_camera_super_buf_t *frame = (mm_camera_super_buf_t *)data;
if (NULL != pme) {
pme->bufDone(frame->bufs[0]->buf_idx);
}
}
/*===========================================================================
* FUNCTION : configStream
*
* DESCRIPTION: send stream configuration to back end
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraStream::configStream()
{
int rc = NO_ERROR;
// Configure the stream
mm_camera_stream_config_t stream_config;
stream_config.stream_info = mStreamInfo;
stream_config.mem_vtbl = mMemVtbl;
stream_config.stream_cb_sync = NULL;
stream_config.stream_cb = dataNotifyCB;
stream_config.padding_info = mPaddingInfo;
stream_config.userdata = this;
rc = mCamOps->config_stream(mCamHandle,
mChannelHandle, mHandle, &stream_config);
if (rc < 0) {
LOGE("Failed to config stream, rc = %d", rc);
mCamOps->unmap_stream_buf(mCamHandle,
mChannelHandle,
mHandle,
CAM_MAPPING_BUF_TYPE_STREAM_INFO,
0,
-1);
return UNKNOWN_ERROR;
}
return rc;
}
/*===========================================================================
* FUNCTION : setSyncDataCB
*
* DESCRIPTION: register callback with mm-interface for this stream
*
* PARAMETERS :
@stream_cb : Callback function
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* non-zero failure code
*==========================================================================*/
int32_t QCameraStream::setSyncDataCB(stream_cb_routine data_cb)
{
int32_t rc = NO_ERROR;
if (mCamOps != NULL) {
mSYNCDataCB = data_cb;
rc = mCamOps->register_stream_buf_cb(mCamHandle,
mChannelHandle, mHandle, dataNotifySYNCCB, MM_CAMERA_STREAM_CB_TYPE_SYNC,
this);
if (rc == NO_ERROR) {
mSyncCBEnabled = TRUE;
return rc;
}
}
LOGE("Interface handle is NULL");
return UNKNOWN_ERROR;
}
}; // namespace qcamera
Reference in a new issue View git blame Copy permalink