/******************************************************************************
* Splits a comma delimited string to a List of int Vector.
* Example string: "(10000,26623),(10000,30000)"
*******************************************************************************/
bool
ParamsManager::
splitRange(String8 const& s8Input, List< Vector<int> >& rOutput)
{
rOutput.clear();
//
if ( s8Input.isEmpty() )
{
MY_LOGW("empty string");
return false;
}
//
int endIndex, fromIndex = 1;
int endIndex_input = s8Input.length()-1;
if ( s8Input[0] != '(' || s8Input[endIndex_input] != ')' )
{
MY_LOGW("Invalid range list string=%s", s8Input.string());
return false;
}
//
do {
endIndex = s8Input.find("),(", fromIndex);
if (endIndex == -1) endIndex = endIndex_input;
//
Vector<int> vOut;
String8 const s8SubString(s8Input.string()+fromIndex, endIndex-fromIndex);
if ( splitInt(s8SubString, vOut) ) {
rOutput.push_back(vOut);
}
//
fromIndex = endIndex + 3;
} while (endIndex != endIndex_input);
//
return (rOutput.size() > 0);
}
//-----------------------------------------------------------------------------
MBOOL
CapBufMgrImp::
dequeBuf(IImageBuffer*& pImageBuffer, MBOOL const isFullSize)
{
Mutex::Autolock _l(mLock);
//
list<IImageBuffer*>::iterator it;
while(1)
{
if(mDequeBufCnt >= mDequeBufMaxNum)
{
MY_LOGW("DBC(%d) < DBMN(%d), Wait E",
mDequeBufCnt,
mDequeBufMaxNum);
mCondDequeBuf.wait(mLock);
MY_LOGW("DBC(%d), Wait X",mDequeBufCnt);
}
else
{
for(it = mlpImgBuf.begin(); it != mlpImgBuf.end(); it++)
{
if((*it)->getTimestamp() != 0)
{
break;
}
}
//
if(it == mlpImgBuf.end())
{
MY_LOGW("No buf is ready, Wait E");
mCond.wait(mLock);
MY_LOGW("Wait X");
}
else
{
break;
}
}
}
//
mDequeBufCnt++;
MY_LOGD("(%d),Buf(0x%08X),TS(%d.%06d),DBC(%d)",
isFullSize,
(MUINT32)*it,
(MUINT32)(((*it)->getTimestamp()/1000)/1000000),
(MUINT32)(((*it)->getTimestamp()/1000)%1000000),
mDequeBufCnt);
//
pImageBuffer = *it;
mlpImgBuf.erase(it);
//
return MTRUE;
}
/******************************************************************************
* REPEAT:[ dequeProvider() -> enqueProvider() ]
* dequeProvider() returns false immediately if empty.
*******************************************************************************/
bool
ImgBufQueue::
enqueProvider(ImgBufQueNode const& rNode)
{
if ( ! rNode ) {
MY_LOGW("buffer is NULL");
return false;
}
//
Mutex::Autolock _lock(mDoneImgBufQueMtx);
//
MY_LOGV_IF(
ENABLE_LOG_PER_FRAME,
"+ Que.size(%d); (CookieED/CookieDE)=(%p,%p) %s; Buffer[%s@0x%08X@%d@%s@(%d)%dx%d@%d@Timestamp(%lld)]",
mDoneImgBufQue.size(),
rNode.getCookieED(), rNode.getCookieDE(), ImgBufQueNodeStatus2Name(rNode.getStatus()),
rNode->getBufName(), rNode->getVirAddr(), rNode->getBufSize(), rNode->getImgFormat().string(),
rNode->getImgWidthStride(), rNode->getImgWidth(), rNode->getImgHeight(), rNode->getBitsPerPixel(), rNode->getTimestamp()
);
//
mDoneImgBufQue.push_back(rNode);
mDoneImgBufQueCond.broadcast();
//
return true;
}
/******************************************************************************
* It returns false if Processor is Running; call pauseProcessor() firstly
* before flushProcessor().
*******************************************************************************/
bool
ImgBufQueue::
flushProcessor()
{
Mutex::Autolock _lock_DONE(mDoneImgBufQueMtx); // + lock DONE QUE
//
if ( mbIsProcessorRunning )
{
MY_LOGW("IsProcessorRunning=1; please pause it before calling this function.");
return false;
}
//
//
Mutex::Autolock _lock_TODO(mTodoImgBufQueMtx); // + lock TODO QUE
//
MY_LOGD("TODO Que.size(%d)", mTodoImgBufQue.size());
for ( List<ImgBufQueNode>::iterator it = mTodoImgBufQue.begin(); it != mTodoImgBufQue.end(); it++ )
{
(*it).setStatus(ImgBufQueNode::eSTATUS_CANCEL);
MY_LOGD_IF(
ENABLE_LOG_PER_FRAME,
"%s: (CookieED/mi4CookieDE)=(%p/%p); Buffer[%s@0x%08X@%d@%s@(%d)%dx%d-%dBit@Timestamp(%lld)]",
ImgBufQueNodeStatus2Name((*it).getStatus()), (*it).getCookieED(), (*it).getCookieDE(),
(*it)->getBufName(), (*it)->getVirAddr(), (*it)->getBufSize(), (*it)->getImgFormat().string(),
(*it)->getImgWidthStride(), (*it)->getImgWidth(), (*it)->getImgHeight(),
(*it)->getBitsPerPixel(), (*it)->getTimestamp()
);
mDoneImgBufQue.push_back(*it);
}
//
mTodoImgBufQue.clear();
//
//
return true;
}
//-----------------------------------------------------------------------------
MBOOL
ThermalMonitorImp::
exit()
{
//Mutex::Autolock lock(mLock);
//
FUNC_START;
//
requestExit();
//
mState = STATE_EXIT;
mCond.broadcast();
//
MY_LOGD("join() E");
status_t status = join();
if( OK != status )
{
MY_LOGW("Not to wait , status[%s(%d)]", ::strerror(-status), -status);
}
MY_LOGD("join() X");
//
FUNC_END;
//
return MTRUE;
}
bool
ImgBufQueue::
dequeProcessor(Vector<ImgBufQueNode>& rvNode)
{
bool ret = false;
//
Mutex::Autolock _lock(mDoneImgBufQueMtx);
//
while ( mDoneImgBufQue.empty() && mbIsProcessorRunning )
{
status_t status = mDoneImgBufQueCond.wait(mDoneImgBufQueMtx);
if ( NO_ERROR != status )
{
MY_LOGW("wait status(%d), Que.size(%d), IsProcessorRunning(%d)", status, mDoneImgBufQue.size(), mbIsProcessorRunning);
}
}
//
if ( ! mDoneImgBufQue.empty() )
{
// If the queue is not empty, deque all buffers from the queue.
ret = true;
rvNode = mDoneImgBufQue;
mDoneImgBufQue.clear();
}
else
{
MY_LOGD_IF(ENABLE_LOG_PER_FRAME, "Empty Que");
rvNode.clear();
}
//
return ret;
}
bool
ParamsManager::
splitInt(String8 const& s8Input, Vector<int>& rOutput)
{
rOutput.clear();
//
if ( s8Input.isEmpty() )
{
MY_LOGW("empty string");
return false;
}
//
char const*start = s8Input.string();
char *end = NULL;
do {
int value = ::strtol(start, &end, 10);
if ( start == end ) {
MY_LOGW_IF(0, "no digits in str:%s", s8Input.string());
return false;
}
rOutput.push_back(value);
MY_LOGD_IF(0, "%d", value);
start = end + 1;
} while ( end && *end );
//
return (rOutput.size() > 0);
}
//-----------------------------------------------------------------------------
MBOOL
CapBufMgrImp::
popBuf(IImageBuffer*& pImageBuffer, MBOOL const isFullSize)
{
Mutex::Autolock _l(mLock);
//
if(mlpImgBuf.empty())
{
if(mbUse)
{
MY_LOGW("buf is empty");
}
return MFALSE;
}
//
list<IImageBuffer*>::iterator it = mlpImgBuf.begin();
//
MY_LOGD("(%d),Buf(0x%08X),TS(%d.%06d)",
isFullSize,
(MUINT32)*it,
(MUINT32)(((*it)->getTimestamp()/1000)/1000000),
(MUINT32)(((*it)->getTimestamp()/1000)%1000000));
//
pImageBuffer = *it;
mlpImgBuf.erase(it);
//
return MTRUE;
}
bool
BaseCamAdapter::
sendFrameToObservers(CamFrame*const frame)
{
bool ret = false;
//
if ( ! frame )
{
MY_LOGW("null frame");
return false;
}
//
switch ( frame->mType )
{
case CAMERA_MSG_PREVIEW_FRAME:
case CAMERA_MSG_POSTVIEW_FRAME:
ret = sendFrameToObservers(frame, mvFrameObservers);
break;
default:
MY_LOGE("Unsupported frame type(0x%x)", frame->mType);
break;
}
//
return ret;
}
static
MBOOL
impConstructStaticMetadata_by_SymbolName(
String8 const& s8Symbol,
Info const& rInfo,
IMetadata& rMetadata
)
{
typedef MBOOL (*PFN_T)(
IMetadata & metadata,
Info const& info
);
//
PFN_T pfn;
MBOOL ret = MTRUE;
String8 const s8LibPath = String8::format("libcam.halsensor.so");
void *handle = ::dlopen(s8LibPath.string(), RTLD_GLOBAL);
if ( ! handle )
{
char const *err_str = ::dlerror();
MY_LOGW("dlopen library=%s %s", s8LibPath.string(), err_str?err_str:"unknown");
ret = MFALSE;
goto lbExit;
}
pfn = (PFN_T)::dlsym(handle, s8Symbol.string());
if ( ! pfn ) {
MY_LOGW("%s not found", s8Symbol.string());
ret = MFALSE;
goto lbExit;
}
//
ret = pfn(rMetadata, rInfo);
MY_LOGW_IF(!ret, "%s fail", s8Symbol.string());
//
lbExit:
if ( handle )
{
::dlclose(handle);
handle = NULL;
}
return ret;
}
bool
Feature::
initFeatures_Custom_v1()
{
#warning "[TODO]"
MY_LOGW("Not implement");
// [1] Sensor
// [2] Misc
// [3] Flashlight
return false;
}
bool
BaseCamAdapter::
sendFrameToObservers(CamFrame*const frame, FrameObservers_t const& rObservers)
{
MY_LOGV_IF(ENABLE_LOG_PER_FRAME, "+ frameType(0x%x)", frame->mType);
//
cam_frame_callback callback = NULL;
//
for (uint_t i = 0; i < rObservers.size(); i++)
{
{
RWLock::AutoRLock _l(mRWLockFrameNotifier);
//
if ( i >= rObservers.size() )
{
MY_LOGW("break loop since i(%d) >= rObservers.size(%d)", i, rObservers.size());
break;
}
//
frame->mCbCookie = rObservers.keyAt(i);
callback = rObservers.valueAt(i);
}
//
MY_LOGV_IF(ENABLE_LOG_PER_FRAME,
"i(%d), (frameType, cookie, callback)=(0x%x, %p, %p)",
i, frame->mType, frame->mCbCookie, callback
);
//
if ( ! callback )
{
MY_LOGW("null callback for frameType(0x%x)", frame->mType);
continue;
}
//
frame->incRef();
callback(frame);
}
//
return true;
}
bool
querySensorInfo(int32_t const i4OpenId, String8& rs8SensorName, uint32_t& ru4SensorType, int32_t& ri4SensorFacing)
{
if ( i4OpenId == 0xFF )
{
rs8SensorName = DLSYM_MODULE_NAME_COMMON_SENSOR_ATV;
ru4SensorType = NSSensorType::eSensorType_YUV;
ri4SensorFacing = 0;
MY_LOGW("ATV sensor...return true");
return true;
}
#if '1'!=MTKCAM_HAVE_SENSOR_HAL //++++++++++++++++++++++++++++++++++++++++++
//
#warning "[FIXME] querySensorInfo()"
MY_LOGI("not use MTKCAM_HAVE_SENSOR_HAL");
rs8SensorName = "No_Sensor_Hal";
ru4SensorType = NSSensorType::eSensorType_RAW;
return true;
//
#else //MTKCAM_HAVE_SENSOR_HAL //..........................................
//
bool ret = false;
NSCam::IHalSensorList *pSensorHalList = NSCam::IHalSensorList::get();
if (pSensorHalList == NULL)
{
MY_LOGE("pSensorHalList::get fail");
pSensorHalList = NULL;
return false;
}
//
ri4SensorFacing = pSensorHalList->queryFacingDirection(i4OpenId);
rs8SensorName = pSensorHalList->queryDriverName(i4OpenId);
switch ( pSensorHalList->queryType(i4OpenId) )
{
case NSCam::NSSensorType::eYUV:
ru4SensorType = NSSensorType::eSensorType_YUV;
break;
case NSCam::NSSensorType::eRAW:
default:
ru4SensorType = NSSensorType::eSensorType_RAW;
break;
}
MY_LOGD("[OpenId:%d] type:%d <%s>", i4OpenId, ru4SensorType, rs8SensorName.string());
//
ret = true;
lbExit:
return ret;
//
#endif //MTKCAM_HAVE_SENSOR_HAL //------------------------------------------
}
bool
ImgBufQueue::
stopProcessor()
{
Mutex::Autolock _lock(mDoneImgBufQueMtx);
//
mbIsProcessorRunning = false;
mDoneImgBufQueCond.broadcast();
//
if ( ! mDoneImgBufQue.empty() ) {
MY_LOGW("intent to clear Done Que: size(%d)!=0", mDoneImgBufQue.size());
mDoneImgBufQue.clear();
}
//
return true;
}
/******************************************************************************
* Send command to camera driver.
*******************************************************************************/
status_t
BaseCamAdapter::
sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
{
status_t status = NO_ERROR;
switch (cmd)
{
case CAMERA_CMD_PLAY_RECORDING_SOUND:
break;
default:
MY_LOGW("tid(%d), bad command(0x%x), (arg1, arg2)=(0x%x, 0x%x)", ::gettid(), cmd, arg1, arg2);
status = INVALID_OPERATION;
break;
}
return status;
}
MBOOL
CamShotImp::
onNotifyCallback(CamShotNotifyInfo const& msg) const
{
MBOOL ret = MTRUE;
//
if ( mNotifyCb )
{
mNotifyCb(mpCbUser, msg);
ret = MTRUE;
}
else
{
MY_LOGW("Notify Callback is NULL");
ret = MFALSE;
}
return ret;
}
MBOOL
CamShotImp::
onDataCallback(CamShotDataInfo const& msg) const
{
MBOOL ret = MTRUE;
//
if ( mDataCb )
{
mDataCb(mpCbUser, msg);
ret = MTRUE;
}
else
{
MY_LOGW("Data Callback is NULL");
ret = MFALSE;
}
return ret;
}
//-----------------------------------------------------------------------------
MBOOL
ResourceLockImp::
Uninit(void)
{
MBOOL Result = MTRUE;
//
Mutex::Autolock lock(mLock);
//
if(mUser <= 0)
{
MY_LOGW("No user(%d)",mUser);
goto EXIT;
}
//
android_atomic_dec(&mUser);
//
if(mUser == 0)
{
MY_LOGD("Last user(%d)",mUser);
}
else
{
MY_LOGD("More user(%d)",mUser);
goto EXIT;
}
//
if(mpResMgr != NULL)
{
mpResMgr->Uninit();
mpResMgr->DestroyInstance();
mpResMgr = NULL;
}
//
if(mpPipeMgr != NULL)
{
mpPipeMgr->Uninit();
mpPipeMgr->DestroyInstance();
mpPipeMgr = NULL;
}
//
EXIT:
return Result;
}
bool
ParamsManager::
isEnabled(char const* key) const
{
if ( ! key )
{
MY_LOGW("Null key");
return false;
}
//
RWLock::AutoRLock _lock(mRWLock);
char const* p = mParameters.get(key);
//
if ( ! p ) {
MY_LOGD_IF(1, "No %s", key);
return false;
}
//
return ( ::strcmp(p, CameraParameters::TRUE) != 0 ) ? false : true;
}
status_t
MetadataProvider::
impConstructStaticMetadata_by_SymbolName(
String8 const& s8Symbol,
IMetadata &metadata
)
{
typedef status_t (*PFN_T)(
IMetadata & metadata,
Info const& info
);
//
PFN_T pfn = (PFN_T)::dlsym(RTLD_DEFAULT, s8Symbol.string());
if ( ! pfn ) {
MY_LOGW("%s not found", s8Symbol.string());
return NAME_NOT_FOUND;
}
//
status_t const status = pfn(metadata, mInfo);
MY_LOGW_IF(OK != status, "%s returns status[%s(%d)]", s8Symbol.string(), ::strerror(-status), -status);
//
return status;
}
MBOOL
EngBufHandlerImpl::
unmapPort(EBufProvider bufType)
{
Mutex::Autolock _l(mLock);
//
MBOOL isFind= MFALSE;
MUINT32 i;
list<MAP_PORT_INFO>::iterator iterMapPort;
//
for(i=0; i<EPass2Out_DST_AMOUNT; i++)
{
for(iterMapPort = mlMapPort[i].begin(); iterMapPort != mlMapPort[i].end();)
{
if((*iterMapPort).bufType == bufType)
{
MY_LOGD("bufType(%d),nodeType(%d)",
(*iterMapPort).bufType,
(*iterMapPort).nodeType);
iterMapPort = mlMapPort[i].erase(iterMapPort);
isFind = MTRUE;
break;
}
else
{
iterMapPort++;
}
}
}
//
if(!isFind)
{
MY_LOGW("Can't fin bufType(%d)",bufType);
}
//
return MTRUE;
}
MBOOL
StereoNodeImpl::
enquePass2(MUINT32 const data, IImageBuffer* const buf, MUINT32 const ext)
{
CAM_TRACE_CALL();
// get output bufffers
MUINT32 dstCount = 0, dstDataType[MAX_DST_PORT_NUM];
ImgRequest outRequest[MAX_DST_PORT_NUM];
IMEM_BUF_INFO feoRequest;
vector<MUINT32> vDataDst = getDataConnected();
MSize const srcImgSize = buf->getImgSize();
MSize const dstImgSize = getAlgoImgSize();
//
for(MUINT32 i = 0; i < vDataDst.size(); i++)
{
if ( STEREO_FEO != vDataDst[i] )
{
ICamBufHandler* pBufHdl = getBufferHandler( vDataDst[i] );
if( pBufHdl && pBufHdl->dequeBuffer( vDataDst[i], &outRequest[dstCount]) )
{
dstDataType[dstCount] = vDataDst[i];
dstCount++;
}
else
{
MY_LOGE("no dst buf (0x%x)", vDataDst[i]);
}
}
else
{
Mutex::Autolock lock(mLock);
if( mlFeBufQueue.size() == 0 )
{
MY_LOGE("no feo buf");
}
else
{
feoRequest = mlFeBufQueue.front();
mlFeBufQueue.pop_front();
//
dstDataType[dstCount] = vDataDst[i];
dstCount++;
}
}
}
if( dstCount == 0 )
{
MY_LOGW("no dst buffer, skip data(%d), buf(0x%x)", data, buf);
handleReturnBuffer(data, (MUINTPTR)buf);
return MTRUE;
}
QParams enqueParams;
StaData feoData;
MUINT32 magicNum = 0;
MVOID* pPrivateData = NULL;
MUINT32 privateDataSize = 0;
MCropRect p2InCrop;
MSize feSize = getFEImgSize();
MINT64 timestamp = 0;
//input
{
IImageBuffer const* pSrcBuf = buf;
Input src;
//
src.mPortID = mapToPortID(data);
src.mBuffer = const_cast<IImageBuffer*>(pSrcBuf);
//
mpIspSyncCtrlHw->getPass2Info(
src.mBuffer,
srcImgSize,
magicNum,
pPrivateData,
privateDataSize,
p2InCrop);
//
enqueParams.mpPrivaData = pPrivateData;
enqueParams.mFrameNo = magicNum;
//
timestamp = pSrcBuf->getTimestamp();
enqueParams.mvIn.push_back(src);
}
//
MCrpRsInfo crop1;
crop1.mGroupID = 1;
crop1.mCropRect = p2InCrop;
crop1.mResizeDst = dstImgSize;
//
MCrpRsInfo crop2;
crop2.mGroupID = 2;
crop2.mCropRect.s = dstImgSize;
MY_LOGD("data %d, buf 0x%x,va/pa(0x%x/0x%x),size(%dx%d),crop(%d,%d,%d,%d) # 0x%X, cnt %d; crop1(%d,%d,%d,%d)(%dx%d), crop2(%d,%d,%d,%d)(%dx%d)",
data, buf, buf->getBufVA(0), buf->getBufPA(0), buf->getImgSize().w, buf->getImgSize().h,
p2InCrop.p_integral.x, p2InCrop.p_integral.y, p2InCrop.s.w, p2InCrop.s.h, magicNum, muEnqFrameCnt,
crop1.mCropRect.p_integral.x, crop1.mCropRect.p_integral.y, crop1.mCropRect.s.w, crop1.mCropRect.s.h, crop1.mResizeDst.w, crop1.mResizeDst.h,
crop2.mCropRect.p_integral.x, crop2.mCropRect.p_integral.y, crop2.mCropRect.s.w, crop2.mCropRect.s.h, crop2.mResizeDst.w, crop2.mResizeDst.h);
//
// output
for( MUINT32 i = 0 ; i < dstCount ; i++ )
{
if(dstDataType[i] != STEREO_FEO)
{
IImageBuffer const* pDstBuf = outRequest[i].mBuffer;
MY_LOGD("data %d, buf 0x%x, va/pa(0x%x/0x%x), size(%dx%d), tans %d",
dstDataType[i], pDstBuf,
pDstBuf->getBufVA(0), pDstBuf->getBufPA(0),
pDstBuf->getImgSize().w, pDstBuf->getImgSize().h,
outRequest[i].mTransform);
Output dst;
dst.mPortID = mapToPortID(dstDataType[i]);
dst.mBuffer = const_cast<IImageBuffer*>(pDstBuf);
dst.mTransform = outRequest[i].mTransform;
dst.mBuffer->setTimestamp(timestamp);
//
enqueParams.mvOut.push_back(dst);
}
else
{
MINT32 idx = muEnqFrameCnt%BUF_COUNT;
mpStaParam[idx]->bufInfo.size = feoRequest.size;
mpStaParam[idx]->bufInfo.memID = feoRequest.memID;
mpStaParam[idx]->bufInfo.virtAddr = feoRequest.virtAddr;
mpStaParam[idx]->bufInfo.phyAddr = feoRequest.phyAddr;
mpStaParam[idx]->bufInfo.bufSecu = 0;
mpStaParam[idx]->bufInfo.bufCohe = 0;
mpStaParam[idx]->bufInfo.useNoncache = 0;
mpStaParam[idx]->w = feSize.w;
mpStaParam[idx]->h = feSize.h;
mpStaParam[idx]->stride = feSize.w;
mpStaParam[idx]->port_idx = FEO.index;
mpStaParam[idx]->port_type = FEO.type;
mpStaParam[idx]->port_inout = FEO.inout;
/*
feoData.bufInfo.size = feoRequest.size;
feoData.bufInfo.memID = feoRequest.memID;
feoData.bufInfo.virtAddr = feoRequest.virtAddr;
feoData.bufInfo.phyAddr = feoRequest.phyAddr;
feoData.bufInfo.bufSecu = 0;
feoData.bufInfo.bufCohe = 0;
feoData.bufInfo.useNoncache = 0;
feoData.w = FE_W;
feoData.h = FE_H;
feoData.stride = FE_W;
feoData.port_idx = FEO.index;
feoData.port_type = FEO.type;
feoData.port_inout = FEO.inout;
MY_LOGD("(0x%x)FEO:Size(%d),ID(%d),S(%dx%d,%d),VA(%p)PA(%p),Port(%d/%d/%d)",
&feoData,
feoData.bufInfo.size,
feoData.bufInfo.memID,
feoData.w,
feoData.h,
feoData.stride,
feoData.bufInfo.virtAddr,
feoData.bufInfo.phyAddr,
feoData.port_idx,
feoData.port_type,
feoData.port_inout);*/
ModuleInfo feoInfo;
feoInfo.moduleTag = (MINT32)(EFeatureModule_STA_FEO);
feoInfo.moduleStruct = reinterpret_cast<MVOID*>(mpStaParam[idx]);
enqueParams.mvModuleData.push_back(feoInfo);
mpSrzParam[idx]->in_w = crop1.mResizeDst.w;
mpSrzParam[idx]->in_h = crop1.mResizeDst.h;
mpSrzParam[idx]->out_w = getFEImgSize().w;
mpSrzParam[idx]->out_h = getFEImgSize().h;
ModuleInfo srzInfo;
srzInfo.moduleTag = (MINT32)(EFeatureModule_SRZ1);
srzInfo.moduleStruct = reinterpret_cast<MVOID*>(mpSrzParam[idx]);
enqueParams.mvModuleData.push_back(srzInfo);
MY_LOGD("[0x%x]FEO:Size(%d),ID(%d),S(%dx%d,%d),VA(%p)PA(%p),Port(%d/%d/%d);[0x%x]SRZ:in(%dx%d),out(%dx%d)",
mpStaParam[idx],
mpStaParam[idx]->bufInfo.size, mpStaParam[idx]->bufInfo.memID,
mpStaParam[idx]->w, mpStaParam[idx]->h, mpStaParam[idx]->stride,
mpStaParam[idx]->bufInfo.virtAddr, mpStaParam[idx]->bufInfo.phyAddr,
mpStaParam[idx]->port_idx, mpStaParam[idx]->port_type, mpStaParam[idx]->port_inout,
mpSrzParam[idx],
mpSrzParam[idx]->in_w, mpSrzParam[idx]->in_h, mpSrzParam[idx]->out_w, mpSrzParam[idx]->out_h);
}
}
//
enqueParams.mvCropRsInfo.push_back( crop1 );
enqueParams.mvCropRsInfo.push_back( crop2 );
//
enqueParams.mpfnCallback = pass2CbFunc;
enqueParams.mpCookie = this;
//
if( !mpIspSyncCtrlHw->lockHw(IspSyncControlHw::HW_PASS2) )
{
MY_LOGE("isp sync lock pass2 failed");
return MFALSE;
}
//
CAM_TRACE_FMT_BEGIN("enqP2:%d", muEnqFrameCnt);
if( !mpPostProcPipe->enque(enqueParams) )
{
CAM_TRACE_FMT_END();
MY_LOGE("enque pass2 failed");
AEE_ASSERT("ISP pass2 enque fail");
if( !mpIspSyncCtrlHw->unlockHw(IspSyncControlHw::HW_PASS2) )
{
MY_LOGE("isp sync unlock pass2 failed");
}
return MFALSE;
}
CAM_TRACE_FMT_END();
muEnqFrameCnt++;
FUNC_END;
return MTRUE;
}
MBOOL
EngBufHandlerImpl::
enqueBuffer(MUINT32 const data, IImageBuffer const * pImageBuffer)
{
Mutex::Autolock _l(mLock);
//
MINT32 i, bufQueIdx = mapNode2Dst(data);
ImgBufQueNode keepImgBufQueNode;
//
#if 0
MY_LOGD("data(0x%08X)",data);
#endif
//
if(bufQueIdx == -1)
{
return MFALSE;
}
//
if(bufQueIdx >= 0)
{
if(mvBufQueNode[bufQueIdx].size() > 0)
{
keepImgBufQueNode = mvBufQueNode[bufQueIdx][0];
}
else
{
MY_LOGE("mvBufQueNode[%d] size(%d) = 0",
bufQueIdx,
mvBufQueNode[bufQueIdx].size());
return MFALSE;
}
}
else
{
MY_LOGE("bufQueIdx(%d) < 0",bufQueIdx);
}
//
MUINTPTR keepAddr = (MUINTPTR)(mvBufQueNode[bufQueIdx][0].getImgBuf()->getVirAddr());
MUINTPTR enqueAddr = (MUINTPTR)(GET_IIMAGEBUFFER_BUF_VA(pImageBuffer, 0));
//
#if 0
MY_LOGD("Addr(0x%08X/0x%08X),Port(%d)",
keepAddr,
enqueAddr,
mvBufQueNode[bufQueIdx][0].getCookieDE());
#endif
//
if(keepAddr == enqueAddr)
{
MBOOL isAPClientFromFD = MFALSE;
sp<IImgBufProvider> bufProvider = NULL;
IImageBuffer* tempBuffer = const_cast<IImageBuffer*>(pImageBuffer);
//
switch(keepImgBufQueNode.getCookieDE())
{
case eBuf_Disp:
{
bufProvider = mspImgBufProvidersMgr->getDisplayPvdr();
break;
}
case eBuf_Rec:
{
bufProvider = mspImgBufProvidersMgr->getRecCBPvdr();
break;
}
case eBuf_AP:
{
bufProvider = mspImgBufProvidersMgr->getPrvCBPvdr();
const_cast<ImgBufQueNode*>(&keepImgBufQueNode)->setCookieDE(0); // 0 for preview
break;
}
case eBuf_Generic:
{
bufProvider = mspImgBufProvidersMgr->getGenericBufPvdr();
break;
}
case eBuf_FD:
{
bufProvider = mspImgBufProvidersMgr->getFDBufPvdr();
isAPClientFromFD = MTRUE;
break;
}
case eBuf_OT:
{
bufProvider = mspImgBufProvidersMgr->getOTBufPvdr();
break;
}
default:
{
MY_LOGE("unknown port(%d)",keepImgBufQueNode.getCookieDE());
return MFALSE;
}
}
//
if (bufProvider == NULL)
{
MY_LOGW("bufProvider(%d) is not available, drop it!", keepImgBufQueNode.getCookieDE());
tempBuffer->unlockBuf(LOG_TAG);
tempBuffer->decStrong(tempBuffer);
mvBufQueNode[bufQueIdx].erase(mvBufQueNode[bufQueIdx].begin());
return MTRUE;
}
else
{
const_cast<ImgBufQueNode*>(&(keepImgBufQueNode))->setStatus(ImgBufQueNode::eSTATUS_DONE);
const_cast<ImgBufQueNode*>(&(keepImgBufQueNode))->getImgBuf()->setTimestamp(pImageBuffer->getTimestamp());
//
char debugMsg[150];
sprintf(debugMsg, "buf(%p),heap(%p),VA(0x%08X),BS(%d),Id(%d),TS(%d.%06d),F(0x%08X),S(%dx%d),Str(%d,%d,%d)",
pImageBuffer,
pImageBuffer->getImageBufferHeap(),
GET_IIMAGEBUFFER_BUF_VA(pImageBuffer, 0),
( GET_IIMAGEBUFFER_BUF_SIZE(pImageBuffer, 0)+
GET_IIMAGEBUFFER_BUF_SIZE(pImageBuffer, 1)+
GET_IIMAGEBUFFER_BUF_SIZE(pImageBuffer, 2)),
pImageBuffer->getFD(0),
(MUINT32)((pImageBuffer->getTimestamp()/1000)/1000000),
(MUINT32)((pImageBuffer->getTimestamp()/1000)%1000000),
pImageBuffer->getImgFormat(),
pImageBuffer->getImgSize().w,
pImageBuffer->getImgSize().h,
GET_IIMAGEBUFFER_BUF_STRIDE_IN_BYTE(pImageBuffer, 0),
GET_IIMAGEBUFFER_BUF_STRIDE_IN_BYTE(pImageBuffer, 1),
GET_IIMAGEBUFFER_BUF_STRIDE_IN_BYTE(pImageBuffer, 2));
//
tempBuffer->unlockBuf(LOG_TAG);
tempBuffer->decStrong(tempBuffer);
//
bufProvider->enqueProvider(keepImgBufQueNode);
// only dequeue is not from APClient
if(isAPClientFromFD)
{
// If APClient exists, copy to it
sp<IImgBufProvider> pBufProvider;
pBufProvider = mspImgBufProvidersMgr->getAPClientBufPvdr();
ImgBufQueNode APClientnode;
if (pBufProvider != 0 && pBufProvider->dequeProvider(APClientnode))
{
MY_LOGD("APClient size:%d, fdClient size:%d", APClientnode.getImgBuf()->getBufSize() , keepImgBufQueNode.getImgBuf()->getBufSize());
//if ( APClientnode.getImgBuf()->getBufSize() >= keepImgBufQueNode.getImgBuf()->getBufSize())
if (1)
{
MY_LOGD("APClient addr:0x%x, FDCLient addr:0x%x", APClientnode.getImgBuf()->getVirAddr(), keepImgBufQueNode.getImgBuf()->getVirAddr());
memcpy(APClientnode.getImgBuf()->getVirAddr(),
keepImgBufQueNode.getImgBuf()->getVirAddr(),
APClientnode.getImgBuf()->getBufSize());
//keepImgBufQueNode.getImgBuf()->getBufSize());
const_cast<ImgBufQueNode*>(&APClientnode)->setStatus(ImgBufQueNode::eSTATUS_DONE);
}
else
{
MY_LOGE("APClient buffer size < FD buffer size");
const_cast<ImgBufQueNode*>(&APClientnode)->setStatus(ImgBufQueNode::eSTATUS_CANCEL);
}
//
pBufProvider->enqueProvider(APClientnode);
}
}
//
mvBufQueNode[bufQueIdx].erase(mvBufQueNode[bufQueIdx].begin());
//
#if 1
MY_LOGD("%s",debugMsg);
#endif
//
return MTRUE;
}
}
else
{
MY_LOGE("Addr(0x%X != 0x%X),Port(%d), drop it!",
keepAddr,
enqueAddr,
mvBufQueNode[bufQueIdx][0].getCookieDE());
return MFALSE;
}
}
bool
RawDumpCmdQueThread::
postCommand(IImageBuffer const * pImgBuffer)
{
FUNCTION_IN;
//
bool ret = true;
CamProfile profile(__FUNCTION__, "RawDumpCmdQueThread::postCommand");
//
{
Mutex::Autolock _l(mCmdMtx);
// add frame count for remember what frame it is.
mFrameCnt++;
//
if (NULL == pImgBuffer)
{
MY_LOGD("- Requester stop to dump: tid(%d), frame_count(%d), Q size(%d)", FREE_MEMORY_THRESHOLD, ::gettid(), mFrameCnt, mCmdQ.size());
mpCamMsgCbInfo->mNotifyCb(MTK_CAMERA_MSG_EXT_NOTIFY, MTK_CAMERA_MSG_EXT_NOTIFY_RAW_DUMP_STOPPED, 0, mpCamMsgCbInfo->mCbCookie);
return false;
}
MY_LOGD("+ tid(%d), frame_count (%d), buf_addr(%p), stride(%d), buf_size(%d), free(%d)",
::gettid(), mFrameCnt, pImgBuffer->getBufVA(0), pImgBuffer->getBufStridesInBytes(0), pImgBuffer->getBufSizeInBytes(0),
getFreeMemorySize());
//
if (!mCmdQ.empty())
{
MY_LOGD("queue is not empty, (%d) is in the head of queue, Q size (%d)", ((*mCmdQ.begin())->getFrameCnt()), mCmdQ.size());
}
// check if the memory threshold is enough
if ( FREE_MEMORY_THRESHOLD > getFreeMemorySize())
{
MY_LOGD("- Memory is under:%d: RAW DUMP IS STOPPED: tid(%d), frame_count(%d), Q size(%d)", FREE_MEMORY_THRESHOLD, ::gettid(), mFrameCnt, mCmdQ.size());
mpCamMsgCbInfo->mNotifyCb(MTK_CAMERA_MSG_EXT_NOTIFY, MTK_CAMERA_MSG_EXT_NOTIFY_RAW_DUMP_STOPPED, 0, mpCamMsgCbInfo->mCbCookie);
return false;
}
//
MUINT32 u4RealRawSize = pImgBuffer->getBufStridesInBytes(0) * pImgBuffer->getImgSize().h;
MUINT8 *pbuf = (MUINT8*) malloc (u4RealRawSize);
if (NULL == pbuf)
{
MY_LOGW("tid(%d) fail to allocate memory, frame_count (%d), buf_addr(%p), buf_size(%d)",
::gettid(), mFrameCnt, pImgBuffer->getBufVA(0), u4RealRawSize);
return false;
}
//
memcpy(pbuf,(MUINT8*)pImgBuffer->getBufVA(0), u4RealRawSize);
//
sp<RawDumpCmdCookie> cmdCookie(new RawDumpCmdCookie(mFrameCnt, new RawImageBufInfo(pImgBuffer->getImgSize().w,
pImgBuffer->getImgSize().h,
pImgBuffer->getBufStridesInBytes(0),
(MUINTPTR)pbuf,
u4RealRawSize,
pImgBuffer->getTimestamp()
)
, mspParamsMgr->getStr(MtkCameraParameters::KEY_RAW_PATH)));
mCmdQ.push_back(cmdCookie);
mCmdCond.broadcast();
MY_LOGD("- frame added: tid(%d), frame_count(%d), que size(%d)", ::gettid(), mFrameCnt, mCmdQ.size());
}
//
profile.print();
FUNCTION_OUT;
//
return ret;
}
