1602 lines
49 KiB
C++
1602 lines
49 KiB
C++
|
/******************************************************************************
|
||
|
|
Copyright (C), 2001-2016, Allwinner Tech. Co., Ltd.
|
||
|
|
******************************************************************************
|
||
|
|
File Name : CveBDII.cpp
|
||
|
|
Version : Initial Draft
|
||
|
|
Author : Allwinner BU3-PD2 Team
|
||
|
|
Created : 2016/06/02
|
||
|
|
Last Modified :
|
||
|
|
Description : ise device.
|
||
|
|
Function List :
|
||
|
|
History :
|
||
|
|
******************************************************************************/
|
||
|
|
|
||
|
|
#define LOG_NDEBUG 0
|
||
|
|
#define LOG_TAG "CveBDII"
|
||
|
|
#include <utils/plat_log.h>
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <errno.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <pthread.h>
|
||
|
|
#include <stdbool.h>
|
||
|
|
#include <memory.h>
|
||
|
|
|
||
|
|
#include <SystemBase.h>
|
||
|
|
#include <ConfigOption.h>
|
||
|
|
|
||
|
|
#include <VIDEO_FRAME_INFO_S.h>
|
||
|
|
#include "mpi_sys.h"
|
||
|
|
#include "ion_memmanager.h"
|
||
|
|
|
||
|
|
#include "CveBDII.h"
|
||
|
|
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
namespace EyeseeLinux {
|
||
|
|
|
||
|
|
//#define TIME_TEST
|
||
|
|
//#define DEBUG_DATA_SAVE_OUT
|
||
|
|
|
||
|
|
status_t CveBDII::CameraProxyInfo::SetBDIICameraChnInfo(BDIICameraChnInfo *pCameraChnInfo)
|
||
|
|
{
|
||
|
|
if (mpCameraProxy != NULL)
|
||
|
|
{
|
||
|
|
delete mpCameraProxy;
|
||
|
|
mpCameraProxy = NULL;
|
||
|
|
}
|
||
|
|
if(pCameraChnInfo->mpCamera)
|
||
|
|
{
|
||
|
|
mpCameraProxy = pCameraChnInfo->mpCamera->getRecordingProxy();
|
||
|
|
mnCameraChannel = pCameraChnInfo->mnCameraChannel;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! camera == NULL");
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::CameraProxyInfo::releaseUsedFrame_l(VIDEO_FRAME_BUFFER_S *pFrame)
|
||
|
|
{
|
||
|
|
if (pFrame)
|
||
|
|
{
|
||
|
|
bool findFlag = false;
|
||
|
|
|
||
|
|
//first release v4l2 buf
|
||
|
|
mpCameraProxy->releaseRecordingFrame(mnCameraChannel, pFrame->mFrameBuf.mId);
|
||
|
|
//next release uselist node to idlelist
|
||
|
|
for (std::list<VIDEO_FRAME_BUFFER_S>::iterator it=mUsedFrameBufList.begin(); it!=mUsedFrameBufList.end(); ++it)
|
||
|
|
{
|
||
|
|
if (it->mFrameBuf.mId == pFrame->mFrameBuf.mId)
|
||
|
|
{
|
||
|
|
findFlag = true;
|
||
|
|
mIdleFrameBufList.splice(mIdleFrameBufList.end(), mUsedFrameBufList, it);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!findFlag)
|
||
|
|
{
|
||
|
|
aloge("fatal error! why frame[%d] not in cameraproxy used list??", pFrame->mFrameBuf.mId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! frame is null!");
|
||
|
|
}
|
||
|
|
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::CameraProxyInfo::releaseUsedFrame(VIDEO_FRAME_BUFFER_S *pFrame)
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mFrameBufListLock);
|
||
|
|
return releaseUsedFrame_l(pFrame);
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::CameraProxyInfo::releaseAllFrames()
|
||
|
|
{
|
||
|
|
AutoMutex lock(mFrameBufListLock);
|
||
|
|
int frameCnt = 0;
|
||
|
|
|
||
|
|
if (!mReadyFrameBufList.empty())
|
||
|
|
{
|
||
|
|
alogw("Warning! cameraProxy[%p] still has [%d]frames unhandled, release directly", mpCameraProxy, mReadyFrameBufList.size());
|
||
|
|
for (std::list<VIDEO_FRAME_BUFFER_S>::iterator it=mReadyFrameBufList.begin(); it!=mReadyFrameBufList.end(); ++it)
|
||
|
|
{
|
||
|
|
mpCameraProxy->releaseRecordingFrame(mnCameraChannel, it->mFrameBuf.mId);
|
||
|
|
frameCnt++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!mUsedFrameBufList.empty())
|
||
|
|
{
|
||
|
|
aloge("fatal error! still [%d] frame in use", mUsedFrameBufList.size());
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::CameraProxyInfo::CameraProxyInfo()
|
||
|
|
{
|
||
|
|
mFrameCounter = 0;
|
||
|
|
mpCameraProxy = NULL;
|
||
|
|
mnCameraChannel = 0;;
|
||
|
|
mIdleFrameBufList.resize(5); //guarantee enough frame number.
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::CameraProxyInfo::CameraProxyInfo(const CameraProxyInfo& ref)
|
||
|
|
{
|
||
|
|
mpCameraProxy = ref.mpCameraProxy;
|
||
|
|
mnCameraChannel = ref.mnCameraChannel;
|
||
|
|
mIdleFrameBufList = ref.mIdleFrameBufList;
|
||
|
|
mReadyFrameBufList = ref.mReadyFrameBufList;
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::CameraProxyInfo::~CameraProxyInfo()
|
||
|
|
{
|
||
|
|
releaseAllFrames();
|
||
|
|
if (mpCameraProxy != NULL)
|
||
|
|
{
|
||
|
|
delete mpCameraProxy;
|
||
|
|
mpCameraProxy = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::CameraProxyListener::CameraProxyListener(CveBDII *pCveBDII, int nCameraIndex)
|
||
|
|
{
|
||
|
|
mpCveBDII = pCveBDII;
|
||
|
|
mCameraIndex = nCameraIndex;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::CameraProxyListener::dataCallbackTimestamp(const void *pdata)
|
||
|
|
{
|
||
|
|
mpCveBDII->dataCallbackTimestamp(mCameraIndex, (const VIDEO_FRAME_BUFFER_S*)pdata);
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::DoProcessFrameThread::DoProcessFrameThread(CveBDII *pCveBDII)
|
||
|
|
: mpCveBDII(pCveBDII)
|
||
|
|
, hBDII(NULL)
|
||
|
|
, mpCostImg(NULL)
|
||
|
|
, mpDeepImg(NULL)
|
||
|
|
, mCostImagSize(0)
|
||
|
|
, mDeepImagSize(0)
|
||
|
|
, bSaveYuvOut(false)
|
||
|
|
{
|
||
|
|
mbWaitInputFrameBuf = false;
|
||
|
|
mProcessFrameThreadState = PROCESS_FRAME_STATE_LOADED;
|
||
|
|
mbThreadOK = true;
|
||
|
|
mpProcessFrameDataQueue = new EyeseeQueue(3);
|
||
|
|
//mIdleBDIINodeList.clear();
|
||
|
|
mIdleBDIINodeList.resize(5); //for BDII_FRAME_NODE_S
|
||
|
|
mImageSize = {0, 0};
|
||
|
|
if(NO_ERROR != run("BDIIProcessFrameThread"))
|
||
|
|
{
|
||
|
|
aloge("fatal error! create thread fail");
|
||
|
|
mbThreadOK = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::DoProcessFrameThread::~DoProcessFrameThread()
|
||
|
|
{
|
||
|
|
ProcessFrameThreadStop();
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypeProcessFrame_Exit;
|
||
|
|
mProcessFrameMsgQueue.queueMessage(&msg);
|
||
|
|
requestExitAndWait();
|
||
|
|
mProcessFrameMsgQueue.flushMessage();
|
||
|
|
delete mpProcessFrameDataQueue;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoProcessFrameThread::ProcessFrameThreadStart()
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
AutoMutex autoLock2(mStateLock);
|
||
|
|
|
||
|
|
if(mProcessFrameThreadState == PROCESS_FRAME_STATE_STARTED)
|
||
|
|
{
|
||
|
|
alogd("already in started");
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mProcessFrameThreadState != PROCESS_FRAME_STATE_LOADED && mProcessFrameThreadState != PROCESS_FRAME_STATE_PAUSED)
|
||
|
|
{
|
||
|
|
aloge("fatal error! can't call in state[0x%x]", mProcessFrameThreadState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
{
|
||
|
|
if ((NULL == mpCostImg) || (NULL == mpDeepImg))
|
||
|
|
{
|
||
|
|
//mpCveBDII->mParameters.getVideoSize(imagSize);
|
||
|
|
if (NULL != mpCveBDII->mCameraProxies[0].mpCameraProxy)
|
||
|
|
{
|
||
|
|
CameraParameters cameraParameters;
|
||
|
|
mpCveBDII->mCameraProxies[0].mpCameraProxy->getParameters(mpCveBDII->mCameraProxies[0].mnCameraChannel, cameraParameters);
|
||
|
|
cameraParameters.getVideoSizeOut(mImageSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned int size;
|
||
|
|
unsigned int nPhyAddr;
|
||
|
|
|
||
|
|
if (NULL == mpCostImg)
|
||
|
|
{
|
||
|
|
mCostImagSize = size = mImageSize.Width * mImageSize.Height * sizeof(AW_S32);
|
||
|
|
AW_MPI_SYS_MmzAlloc_Cached(&nPhyAddr, &mpCostImg, size);
|
||
|
|
}
|
||
|
|
if (NULL == mpDeepImg)
|
||
|
|
{
|
||
|
|
mDeepImagSize = size = mImageSize.Width * mImageSize.Height * sizeof(AW_S16);
|
||
|
|
AW_MPI_SYS_MmzAlloc_Cached(&nPhyAddr, &mpDeepImg, size);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (NULL == hBDII)
|
||
|
|
{
|
||
|
|
alogd("create BDII handle");
|
||
|
|
hBDII = AW_AI_CVE_BDII_Create();
|
||
|
|
if (NULL == hBDII)
|
||
|
|
{
|
||
|
|
aloge("create BDII fail!!");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
AW_STATUS_E status = AW_AI_CVE_BDII_Init(hBDII, &mInitParam);
|
||
|
|
if (AW_STATUS_OK != status)
|
||
|
|
{
|
||
|
|
aloge("BDII init fail, destroy it!");
|
||
|
|
AW_AI_CVE_BDII_Release(hBDII);
|
||
|
|
hBDII = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((NULL==hBDII) || (NULL==mpCostImg) || (NULL==mpDeepImg))
|
||
|
|
{
|
||
|
|
aloge("start thread fail! hBDII or img buffer NULL");
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypeProcessFrame_SetState;
|
||
|
|
msg.mPara0 = PROCESS_FRAME_STATE_STARTED;
|
||
|
|
mProcessFrameMsgQueue.queueMessage(&msg);
|
||
|
|
while(PROCESS_FRAME_STATE_STARTED != mProcessFrameThreadState)
|
||
|
|
{
|
||
|
|
mStartCompleteCond.wait(mStateLock);
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
status_t CveBDII::DoProcessFrameThread::ProcessFrameThreadPause()
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
AutoMutex autoLock2(mStateLock);
|
||
|
|
if(mProcessFrameThreadState == PROCESS_FRAME_STATE_PAUSED)
|
||
|
|
{
|
||
|
|
alogd("already in paused");
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
if(mProcessFrameThreadState != PROCESS_FRAME_STATE_STARTED)
|
||
|
|
{
|
||
|
|
aloge("fatal error! can't call in state[0x%x]", mProcessFrameThreadState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypeProcessFrame_SetState;
|
||
|
|
msg.mPara0 = PROCESS_FRAME_STATE_PAUSED;
|
||
|
|
mProcessFrameMsgQueue.queueMessage(&msg);
|
||
|
|
while(PROCESS_FRAME_STATE_PAUSED != mProcessFrameThreadState)
|
||
|
|
{
|
||
|
|
mPauseCompleteCond.wait(mStateLock);
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
status_t CveBDII::DoProcessFrameThread::ProcessFrameThreadStop()
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
{
|
||
|
|
AutoMutex autoLock2(mStateLock);
|
||
|
|
if(mProcessFrameThreadState != PROCESS_FRAME_STATE_LOADED)
|
||
|
|
{
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypeProcessFrame_SetState;
|
||
|
|
msg.mPara0 = PROCESS_FRAME_STATE_LOADED;
|
||
|
|
mProcessFrameMsgQueue.queueMessage(&msg);
|
||
|
|
while(PROCESS_FRAME_STATE_LOADED != mProcessFrameThreadState)
|
||
|
|
{
|
||
|
|
mLoadedCompleteCond.wait(mStateLock);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
{
|
||
|
|
if (NULL != mpCostImg)
|
||
|
|
{
|
||
|
|
unsigned int uPhyAddr = 0;
|
||
|
|
alogd("release costimg buf");
|
||
|
|
AW_MPI_SYS_MmzFree(uPhyAddr, mpCostImg);
|
||
|
|
mpCostImg = NULL;
|
||
|
|
}
|
||
|
|
if (NULL != mpDeepImg)
|
||
|
|
{
|
||
|
|
unsigned int uPhyAddr = 0;
|
||
|
|
alogd("release deepimg buf");
|
||
|
|
AW_MPI_SYS_MmzFree(uPhyAddr, mpDeepImg);
|
||
|
|
mpDeepImg = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (NULL != hBDII)
|
||
|
|
{
|
||
|
|
AW_STATUS_E status;
|
||
|
|
alogd("release BDII handle");
|
||
|
|
status = AW_AI_CVE_BDII_Release(hBDII);
|
||
|
|
if (AW_STATUS_ERROR == status)
|
||
|
|
{
|
||
|
|
aloge("BDII release fail!");
|
||
|
|
}
|
||
|
|
hBDII = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
mbWaitInputFrameBuf = false;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
status_t CveBDII::DoProcessFrameThread::SendMessage_InputFrameReady()
|
||
|
|
{
|
||
|
|
//mbWaitInputFrameBuf = false;
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = DoProcessFrameThread::MsgTypeProcessFrame_InputFrameAvailable;
|
||
|
|
mProcessFrameMsgQueue.queueMessage(&msg);
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
status_t CveBDII::DoProcessFrameThread::SetBDIIProcessConfigParams(AW_AI_CVE_BDII_INIT_PARA_S &Param)
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
mInitParam = Param;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoProcessFrameThread::GetBDIIProcessConfigParams(AW_AI_CVE_BDII_INIT_PARA_S &Param)
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
Param = mInitParam;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CveBDII::DoProcessFrameThread::threadLoop()
|
||
|
|
{
|
||
|
|
if(!exitPending())
|
||
|
|
{
|
||
|
|
return processFrameThread();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoProcessFrameThread::debugYuvDataOut(bool isOut, std::vector<BDIIDebugFileOutString>&vec)
|
||
|
|
{
|
||
|
|
#ifdef DEBUG_DATA_SAVE_OUT
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
if (bSaveYuvOut == isOut)
|
||
|
|
{
|
||
|
|
alogw("has already set [%d]!", isOut);
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
bSaveYuvOut = isOut;
|
||
|
|
if (!isOut)
|
||
|
|
{
|
||
|
|
for (map<string, FILE *>::iterator it = mMapFdOut.begin(); it != mMapFdOut.end(); ++it)
|
||
|
|
{
|
||
|
|
if (it->second)
|
||
|
|
{
|
||
|
|
fclose(it->second);
|
||
|
|
it->second = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mMapFdOut.clear();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (vec.size() > 0)
|
||
|
|
{
|
||
|
|
for (map<string, FILE *>::iterator it = mMapFdOut.begin(); it != mMapFdOut.end(); ++it)
|
||
|
|
{
|
||
|
|
if (it->second)
|
||
|
|
{
|
||
|
|
fclose(it->second);
|
||
|
|
it->second = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mMapFdOut.clear();
|
||
|
|
|
||
|
|
FILE *fp;
|
||
|
|
string str;
|
||
|
|
for (vector<BDIIDebugFileOutString>::iterator it = vec.begin(); it != vec.end(); ++it)
|
||
|
|
{
|
||
|
|
if (!it->fileOutStr.empty())
|
||
|
|
{
|
||
|
|
fp = fopen(it->fileOutStr.c_str(), "wb");
|
||
|
|
if (BDIIDebugFileOutString::FILE_STR_LEFT_YUV == it->fileOutStyle)
|
||
|
|
{
|
||
|
|
str = string("in_left");
|
||
|
|
}
|
||
|
|
else if (BDIIDebugFileOutString::FILE_STR_RIGHT_YUV == it->fileOutStyle)
|
||
|
|
{
|
||
|
|
str = string("in_right");
|
||
|
|
}
|
||
|
|
else if (BDIIDebugFileOutString::FILE_STR_RESULT_DEEP_YUV == it->fileOutStyle)
|
||
|
|
{
|
||
|
|
str = string("result_deep");
|
||
|
|
}
|
||
|
|
else if (BDIIDebugFileOutString::FILE_STR_RESULT_COST_YUV == it->fileOutStyle)
|
||
|
|
{
|
||
|
|
str = string("result_cost");
|
||
|
|
}
|
||
|
|
mMapFdOut.insert(make_pair(str, fp));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bSaveYuvOut = false;
|
||
|
|
aloge("input file path empty!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
#else
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoProcessFrameThread::sendFrame(VIDEO_FRAME_BUFFER_S *pFrame0, VIDEO_FRAME_BUFFER_S *pFrame1)
|
||
|
|
{
|
||
|
|
status_t ret;
|
||
|
|
AutoMutex lock(mLock);
|
||
|
|
if ((NULL ==pFrame0) || (NULL ==pFrame1))
|
||
|
|
{
|
||
|
|
return BAD_VALUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
AutoMutex nodeLock(mBDIINodeLock);
|
||
|
|
if (mIdleBDIINodeList.empty())
|
||
|
|
{
|
||
|
|
alogd("Be careful! node idlelist is empty, increase!");
|
||
|
|
BDII_FRAME_NODE_S elem;
|
||
|
|
memset(&elem, 0, sizeof(BDII_FRAME_NODE_S));
|
||
|
|
mIdleBDIINodeList.insert(mIdleBDIINodeList.end(), 5, elem);
|
||
|
|
}
|
||
|
|
BDII_FRAME_NODE_S *pFrmBuf = &mIdleBDIINodeList.front();
|
||
|
|
pFrmBuf->pFrame0 = pFrame0;
|
||
|
|
pFrmBuf->pFrame1 = pFrame1;
|
||
|
|
|
||
|
|
//when putelemdata success, process frame thread will stop receive elem data until handled the elem data over release it
|
||
|
|
//so when in handling, call sendframe() will not success
|
||
|
|
ret = mpProcessFrameDataQueue->PutElemDataValid((void*)pFrmBuf);
|
||
|
|
if (NO_ERROR != ret)
|
||
|
|
{
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
mUsedBDIINodeList.splice(mUsedBDIINodeList.end(), mIdleBDIINodeList, mIdleBDIINodeList.begin());
|
||
|
|
//alogd("only for debug! BDII frame pair pts[%lld]-[%lld]=[%lld]us!", pFrame0->mFrameBuf.VFrame.mpts, pFrame1->mFrameBuf.VFrame.mpts,
|
||
|
|
// (int64_t)(pFrame0->mFrameBuf.VFrame.mpts - pFrame1->mFrameBuf.VFrame.mpts));
|
||
|
|
while(mpProcessFrameDataQueue->GetValidElemNum() > 1)
|
||
|
|
{
|
||
|
|
//alogd("only for debug! BDII speed is slower than camera speed!");
|
||
|
|
BDII_FRAME_NODE_S *pNodebuf = (BDII_FRAME_NODE_S*)mpProcessFrameDataQueue->GetValidElemData();
|
||
|
|
//release previous elem data
|
||
|
|
mpCveBDII->mCameraProxies[0].releaseUsedFrame_l(pNodebuf->pFrame0);
|
||
|
|
mpCveBDII->mCameraProxies[1].releaseUsedFrame_l(pNodebuf->pFrame1);
|
||
|
|
//free used bdii node
|
||
|
|
bool bFind = false;
|
||
|
|
for (std::list<BDII_FRAME_NODE_S>::iterator it=mUsedBDIINodeList.begin(); it!=mUsedBDIINodeList.end(); ++it)
|
||
|
|
{
|
||
|
|
if (&(*it) == pNodebuf)
|
||
|
|
{
|
||
|
|
mIdleBDIINodeList.splice(mIdleBDIINodeList.end(), mUsedBDIINodeList, it);
|
||
|
|
bFind = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!bFind)
|
||
|
|
{
|
||
|
|
aloge("fatal error! not find BDIINodebuf[%p] in usedNodeList!", pNodebuf);
|
||
|
|
}
|
||
|
|
mpProcessFrameDataQueue->ReleaseElemData(pNodebuf);
|
||
|
|
}
|
||
|
|
|
||
|
|
AutoMutex lock2(mWaitLock);
|
||
|
|
if(mbWaitInputFrameBuf)
|
||
|
|
{
|
||
|
|
mbWaitInputFrameBuf = false;
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypeProcessFrame_InputFrameAvailable;
|
||
|
|
mProcessFrameMsgQueue.queueMessage(&msg);
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool CveBDII::DoProcessFrameThread::processFrameThread()
|
||
|
|
{
|
||
|
|
bool bRunningFlag = true;
|
||
|
|
EyeseeMessage msg;
|
||
|
|
status_t getMsgRet;
|
||
|
|
ERRORTYPE ret;
|
||
|
|
while(1)
|
||
|
|
{
|
||
|
|
PROCESS_MESSAGE:
|
||
|
|
getMsgRet = mProcessFrameMsgQueue.dequeueMessage(&msg);
|
||
|
|
if(getMsgRet == NO_ERROR)
|
||
|
|
{
|
||
|
|
if(MsgTypeProcessFrame_SetState == msg.mMsgType)
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mStateLock);
|
||
|
|
if(msg.mPara0 == mProcessFrameThreadState)
|
||
|
|
{
|
||
|
|
aloge("fatal error! same state[0x%x]", mProcessFrameThreadState);
|
||
|
|
}
|
||
|
|
else if(PROCESS_FRAME_STATE_LOADED == msg.mPara0)
|
||
|
|
{
|
||
|
|
if(PROCESS_FRAME_STATE_PAUSED == mProcessFrameThreadState || PROCESS_FRAME_STATE_STARTED == mProcessFrameThreadState)
|
||
|
|
{
|
||
|
|
//release all input frame pair
|
||
|
|
while(1)
|
||
|
|
{
|
||
|
|
BDII_FRAME_NODE_S *pNodebuf = (BDII_FRAME_NODE_S*)mpProcessFrameDataQueue->GetValidElemData();
|
||
|
|
if(pNodebuf != NULL)
|
||
|
|
{
|
||
|
|
//release frame to cameraproxy
|
||
|
|
mpCveBDII->mCameraProxies[0].releaseUsedFrame(pNodebuf->pFrame0);
|
||
|
|
mpCveBDII->mCameraProxies[1].releaseUsedFrame(pNodebuf->pFrame1);
|
||
|
|
{
|
||
|
|
bool bFind = false;
|
||
|
|
AutoMutex lock(mBDIINodeLock); //free used bdii node
|
||
|
|
for (std::list<BDII_FRAME_NODE_S>::iterator it=mUsedBDIINodeList.begin(); it!=mUsedBDIINodeList.end(); it++)
|
||
|
|
{
|
||
|
|
if (&(*it) == pNodebuf)
|
||
|
|
{
|
||
|
|
mIdleBDIINodeList.splice(mIdleBDIINodeList.end(), mUsedBDIINodeList, it);
|
||
|
|
bFind = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!bFind)
|
||
|
|
{
|
||
|
|
aloge("fatal error! not find nodeBuf[%p] in usedBDIINodeList!", pNodebuf);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
alogd("release BDII frame pair[%p] in usedBDIINodeList!", pNodebuf);
|
||
|
|
mpProcessFrameDataQueue->ReleaseElemData(pNodebuf); //enable to receiver elem data
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
AutoMutex lock(mBDIINodeLock);
|
||
|
|
if(mUsedBDIINodeList.size()!= 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error! why still has [%d]used BDII nodes", mUsedBDIINodeList.size());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! unknown state[0x%x]", mProcessFrameThreadState);
|
||
|
|
}
|
||
|
|
alogd("process frame thread state[0x%x]->loaded", mProcessFrameThreadState);
|
||
|
|
mProcessFrameThreadState = PROCESS_FRAME_STATE_LOADED;
|
||
|
|
mLoadedCompleteCond.signal();
|
||
|
|
|
||
|
|
}
|
||
|
|
else if(PROCESS_FRAME_STATE_PAUSED == msg.mPara0)
|
||
|
|
{
|
||
|
|
alogd("process frame thread state[0x%x]->paused", mProcessFrameThreadState);
|
||
|
|
mProcessFrameThreadState = PROCESS_FRAME_STATE_PAUSED;
|
||
|
|
mPauseCompleteCond.signal();
|
||
|
|
}
|
||
|
|
else if(PROCESS_FRAME_STATE_STARTED == msg.mPara0)
|
||
|
|
{
|
||
|
|
alogd("process frame thread state[0x%x]->started", mProcessFrameThreadState);
|
||
|
|
mProcessFrameThreadState = PROCESS_FRAME_STATE_STARTED;
|
||
|
|
mStartCompleteCond.signal();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! check code!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if(MsgTypeProcessFrame_InputFrameAvailable == msg.mMsgType)
|
||
|
|
{
|
||
|
|
//alogv("input frame come");
|
||
|
|
}
|
||
|
|
else if(MsgTypeProcessFrame_Exit == msg.mMsgType)
|
||
|
|
{
|
||
|
|
{
|
||
|
|
AutoMutex lock(mBDIINodeLock);
|
||
|
|
if (!mUsedBDIINodeList.empty()) //return node to camproxy
|
||
|
|
{
|
||
|
|
aloge("fatal error! usedBDII list still in use! release it");
|
||
|
|
|
||
|
|
for (std::list<BDII_FRAME_NODE_S>::iterator it=mUsedBDIINodeList.begin(); it!=mUsedBDIINodeList.end(); it++)
|
||
|
|
{
|
||
|
|
mpCveBDII->mCameraProxies[0].releaseUsedFrame(it->pFrame0);
|
||
|
|
mpCveBDII->mCameraProxies[1].releaseUsedFrame(it->pFrame1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bRunningFlag = false;
|
||
|
|
goto _exit0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("unknown msg[0x%x]!", msg.mMsgType);
|
||
|
|
}
|
||
|
|
goto PROCESS_MESSAGE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(PROCESS_FRAME_STATE_STARTED == mProcessFrameThreadState)
|
||
|
|
{
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
BDII_FRAME_NODE_S *pNodebuf = NULL;
|
||
|
|
pNodebuf = (BDII_FRAME_NODE_S*)mpProcessFrameDataQueue->GetValidElemData();
|
||
|
|
if (pNodebuf == NULL)
|
||
|
|
{
|
||
|
|
{
|
||
|
|
AutoMutex lock(mWaitLock);
|
||
|
|
if(mpProcessFrameDataQueue->GetValidElemNum() > 0)
|
||
|
|
{
|
||
|
|
alogd("Low probability! face new frame come before check again.");
|
||
|
|
goto PROCESS_MESSAGE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
mbWaitInputFrameBuf = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mProcessFrameMsgQueue.waitMessage();
|
||
|
|
goto PROCESS_MESSAGE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//disable to receiver elem data
|
||
|
|
VIDEO_FRAME_BUFFER_S *pbuf[2];
|
||
|
|
pbuf[0] = pNodebuf->pFrame0;
|
||
|
|
pbuf[1] = pNodebuf->pFrame1;
|
||
|
|
|
||
|
|
if ((NULL ==pbuf[0]) || (NULL ==pbuf[1]))
|
||
|
|
{
|
||
|
|
aloge("fatal error! video frame null!");
|
||
|
|
}
|
||
|
|
|
||
|
|
AW_STATUS_E status;
|
||
|
|
AW_IMAGE_S leftImag, rightImag;
|
||
|
|
CVE_BDII_RES_OUT_S resOutput;
|
||
|
|
|
||
|
|
resOutput.result.as16DeepImg = (AW_S16 *)mpDeepImg;
|
||
|
|
resOutput.result.as32CostImg = (AW_S32 *)mpCostImg;
|
||
|
|
|
||
|
|
leftImag.mWidth = pbuf[0]->mFrameBuf.VFrame.mWidth;
|
||
|
|
leftImag.mHeight = pbuf[0]->mFrameBuf.VFrame.mHeight;
|
||
|
|
leftImag.mpVirAddr[0] = pbuf[0]->mFrameBuf.VFrame.mpVirAddr[0];
|
||
|
|
leftImag.mStride[0] = pbuf[0]->mFrameBuf.VFrame.mWidth;
|
||
|
|
|
||
|
|
rightImag.mWidth = pbuf[1]->mFrameBuf.VFrame.mWidth;
|
||
|
|
rightImag.mHeight = pbuf[1]->mFrameBuf.VFrame.mHeight;
|
||
|
|
rightImag.mpVirAddr[0] = pbuf[1]->mFrameBuf.VFrame.mpVirAddr[0];
|
||
|
|
rightImag.mStride[0] = pbuf[1]->mFrameBuf.VFrame.mWidth;
|
||
|
|
|
||
|
|
//alogd("fram0[%d], frame1[%d]", pbuf0->mId, pbuf1->mId);
|
||
|
|
#ifdef DEBUG_DATA_SAVE_OUT
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
if (bSaveYuvOut)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
map<string, FILE *>::iterator mIt;
|
||
|
|
mIt = mMapFdOut.find("in_left");
|
||
|
|
if (mIt != mMapFdOut.end())
|
||
|
|
{
|
||
|
|
if (mIt->second)
|
||
|
|
{
|
||
|
|
fwrite(leftImag.mpVirAddr[0], leftImag.mWidth*leftImag.mHeight, 1, mIt->second);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
mIt = mMapFdOut.find("in_right");
|
||
|
|
if (mIt != mMapFdOut.end())
|
||
|
|
{
|
||
|
|
if (mIt->second)
|
||
|
|
{
|
||
|
|
fwrite(rightImag.mpVirAddr[0], rightImag.mWidth*rightImag.mHeight, 1, mIt->second);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef TIME_TEST
|
||
|
|
int64_t nStartTm = CDX_GetSysTimeUsMonotonic();
|
||
|
|
#endif
|
||
|
|
status = AW_AI_CVE_BDII_Process(hBDII, &leftImag, &rightImag, &resOutput.result);
|
||
|
|
resOutput.costImgSize = mCostImagSize;
|
||
|
|
resOutput.deepImgSize = mDeepImagSize;
|
||
|
|
resOutput.mImgSize = mImageSize;
|
||
|
|
resOutput.mPts = pbuf[0]->mFrameBuf.VFrame.mpts;
|
||
|
|
#ifdef TIME_TEST
|
||
|
|
int64_t nEndTm = CDX_GetSysTimeUsMonotonic();
|
||
|
|
alogv("CVE_BDII_Process:time used:%d us", nEndTm - nStartTm);
|
||
|
|
#endif
|
||
|
|
if (AW_STATUS_OK == status)
|
||
|
|
{
|
||
|
|
if(mpCveBDII->isMessageEnabled(CAMERA_MSG_BDII_DATA))
|
||
|
|
{
|
||
|
|
if (mpCveBDII->mpDataCallback)
|
||
|
|
{
|
||
|
|
unsigned int nCameraMsgType = 0;
|
||
|
|
nCameraMsgType |= CAMERA_MSG_BDII_DATA;
|
||
|
|
|
||
|
|
std::shared_ptr<CMediaMemory> spMem = std::make_shared<CMediaMemory>(sizeof(CVE_BDII_RES_OUT_S));
|
||
|
|
memcpy(spMem->getPointer(), &resOutput, sizeof(CVE_BDII_RES_OUT_S));
|
||
|
|
|
||
|
|
mpCveBDII->mpDataCallback->postData(nCameraMsgType, 0, spMem, sizeof(CVE_BDII_RES_OUT_S));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(mpCveBDII->mpPreviewThread)
|
||
|
|
{
|
||
|
|
mpCveBDII->mpPreviewThread->sendDeepImage(&resOutput);
|
||
|
|
}
|
||
|
|
#ifdef DEBUG_DATA_SAVE_OUT
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
if (bSaveYuvOut)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
map<string, FILE *>::iterator mIt;
|
||
|
|
mIt = mMapFdOut.find("result_deep");
|
||
|
|
if (mIt != mMapFdOut.end())
|
||
|
|
{
|
||
|
|
if (mIt->second)
|
||
|
|
{
|
||
|
|
fwrite(resOutput.result.as16DeepImg, resOutput.deepImgSize, 1, mIt->second);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
mIt = mMapFdOut.find("result_cost");
|
||
|
|
if (mIt != mMapFdOut.end())
|
||
|
|
{
|
||
|
|
if (mIt->second)
|
||
|
|
{
|
||
|
|
fwrite(resOutput.result.as32CostImg, resOutput.costImgSize, 1, mIt->second);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
else if (AW_STATUS_ERROR == status)
|
||
|
|
{
|
||
|
|
aloge("process error!");
|
||
|
|
}
|
||
|
|
else if (AW_STATUS_SKIP == status)
|
||
|
|
{
|
||
|
|
alogw("process skip!");
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i=0; i<2; i++) //release frame to cameraproxy
|
||
|
|
{
|
||
|
|
mpCveBDII->mCameraProxies[i].releaseUsedFrame(pbuf[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
AutoMutex lock(mBDIINodeLock); //free used bdii node
|
||
|
|
for (std::list<BDII_FRAME_NODE_S>::iterator it=mUsedBDIINodeList.begin(); it!=mUsedBDIINodeList.end(); it++)
|
||
|
|
{
|
||
|
|
if (&(*it) == pNodebuf)
|
||
|
|
{
|
||
|
|
mIdleBDIINodeList.splice(mIdleBDIINodeList.end(), mUsedBDIINodeList, it);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
mpProcessFrameDataQueue->ReleaseElemData(pNodebuf); //enable to receiver elem data
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
mProcessFrameMsgQueue.waitMessage();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
_exit0:
|
||
|
|
#ifdef DEBUG_DATA_SAVE_OUT
|
||
|
|
{
|
||
|
|
AutoMutex autoLock(mLock);
|
||
|
|
if (bSaveYuvOut)
|
||
|
|
{
|
||
|
|
for (map<string, FILE *>::iterator it = mMapFdOut.begin(); it != mMapFdOut.end(); ++it)
|
||
|
|
{
|
||
|
|
if (it->second)
|
||
|
|
{
|
||
|
|
fclose(it->second);
|
||
|
|
it->second = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mMapFdOut.clear();
|
||
|
|
bSaveYuvOut = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
return bRunningFlag;
|
||
|
|
}
|
||
|
|
|
||
|
|
int CveBDII::DoPreviewThread::mFrameIdCounter = 0;
|
||
|
|
CveBDII::DoPreviewThread::DoPreviewThread(CveBDII *pBDII)
|
||
|
|
: mpBDII(pBDII)
|
||
|
|
{
|
||
|
|
mHlay = MM_INVALID_LAYER;
|
||
|
|
mPreviewRotation = 0;
|
||
|
|
mpPreviewWindow = new PreviewWindow(this);
|
||
|
|
if(NULL == mpPreviewWindow)
|
||
|
|
{
|
||
|
|
aloge("fatal error! malloc preview window fail!");
|
||
|
|
}
|
||
|
|
mbWaitPreviewFrame = false;
|
||
|
|
mImageSize = {0, 0};
|
||
|
|
}
|
||
|
|
CveBDII::DoPreviewThread::~DoPreviewThread()
|
||
|
|
{
|
||
|
|
if (mpPreviewWindow != NULL)
|
||
|
|
{
|
||
|
|
delete mpPreviewWindow;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
status_t CveBDII::DoPreviewThread::startThread()
|
||
|
|
{
|
||
|
|
//prepare video frame buffer
|
||
|
|
mImageSize = {0, 0};
|
||
|
|
CameraParameters cameraParameters;
|
||
|
|
mpBDII->mCameraProxies[0].mpCameraProxy->getParameters(mpBDII->mCameraProxies[0].mnCameraChannel, cameraParameters);
|
||
|
|
cameraParameters.getVideoSizeOut(mImageSize);
|
||
|
|
mIdleFrameList.resize(4);
|
||
|
|
for(VIDEO_FRAME_BUFFER_S& i : mIdleFrameList)
|
||
|
|
{
|
||
|
|
memset(&i, 0, sizeof(VIDEO_FRAME_BUFFER_S));
|
||
|
|
i.mFrameBuf.VFrame.mWidth = mImageSize.Width;
|
||
|
|
i.mFrameBuf.VFrame.mHeight = mImageSize.Height;
|
||
|
|
i.mFrameBuf.VFrame.mPixelFormat = MM_PIXEL_FORMAT_YVU_SEMIPLANAR_420;
|
||
|
|
int nYSize = mImageSize.Width * mImageSize.Height;
|
||
|
|
if(SUCCESS != AW_MPI_SYS_MmzAlloc_Cached(&i.mFrameBuf.VFrame.mPhyAddr[0], &i.mFrameBuf.VFrame.mpVirAddr[0], nYSize))
|
||
|
|
{
|
||
|
|
aloge("fatal error! palloc fail!");
|
||
|
|
}
|
||
|
|
int nCSize = mImageSize.Width * mImageSize.Height/2;
|
||
|
|
if(SUCCESS != AW_MPI_SYS_MmzAlloc_Cached(&i.mFrameBuf.VFrame.mPhyAddr[1], &i.mFrameBuf.VFrame.mpVirAddr[1], nCSize))
|
||
|
|
{
|
||
|
|
aloge("fatal error! palloc fail!");
|
||
|
|
}
|
||
|
|
memset(i.mFrameBuf.VFrame.mpVirAddr[1], 0x80, nCSize);
|
||
|
|
AW_MPI_SYS_MmzFlushCache(i.mFrameBuf.VFrame.mPhyAddr[1], i.mFrameBuf.VFrame.mpVirAddr[1], nCSize);
|
||
|
|
i.mFrameBuf.VFrame.mOffsetTop = 0;
|
||
|
|
i.mFrameBuf.VFrame.mOffsetBottom = mImageSize.Height;
|
||
|
|
i.mFrameBuf.VFrame.mOffsetLeft = 0;
|
||
|
|
i.mFrameBuf.VFrame.mOffsetRight = mImageSize.Width;
|
||
|
|
i.mFrameBuf.mId = mFrameIdCounter++;
|
||
|
|
}
|
||
|
|
mpPreviewWindow->setPreviewWindow(mHlay);
|
||
|
|
mpPreviewWindow->setPreviewRotation(mPreviewRotation);
|
||
|
|
mpPreviewWindow->setDispBufferNum(0);
|
||
|
|
mpPreviewWindow->startPreview();
|
||
|
|
status_t ret = run("BDIIPreview");
|
||
|
|
if(ret != NO_ERROR)
|
||
|
|
{
|
||
|
|
aloge("fatal error! run thread fail!");
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::DoPreviewThread::stopThread()
|
||
|
|
{
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypePreview_Exit;
|
||
|
|
mMsgQueue.queueMessage(&msg);
|
||
|
|
join();
|
||
|
|
mMsgQueue.flushMessage();
|
||
|
|
|
||
|
|
mpPreviewWindow->stopPreview();
|
||
|
|
//free video frame buffer
|
||
|
|
AutoMutex lock(mFrameLock);
|
||
|
|
if(!mDisplayFrameList.empty())
|
||
|
|
{
|
||
|
|
aloge("fatal error! display frame list is not empty, check code!");
|
||
|
|
mIdleFrameList.splice(mIdleFrameList.end(), mDisplayFrameList);
|
||
|
|
}
|
||
|
|
if(!mReadyFrameList.empty())
|
||
|
|
{
|
||
|
|
aloge("fatal error! ready frame list is not empty, check code!");
|
||
|
|
mIdleFrameList.splice(mIdleFrameList.end(), mReadyFrameList);
|
||
|
|
}
|
||
|
|
if(!mUsingFrame.empty())
|
||
|
|
{
|
||
|
|
aloge("fatal error! using frame list is not empty, check code!");
|
||
|
|
mIdleFrameList.splice(mIdleFrameList.end(), mUsingFrame);
|
||
|
|
}
|
||
|
|
for(VIDEO_FRAME_BUFFER_S& i : mIdleFrameList)
|
||
|
|
{
|
||
|
|
AW_MPI_SYS_MmzFree(i.mFrameBuf.VFrame.mPhyAddr[0], i.mFrameBuf.VFrame.mpVirAddr[0]);
|
||
|
|
AW_MPI_SYS_MmzFree(i.mFrameBuf.VFrame.mPhyAddr[1], i.mFrameBuf.VFrame.mpVirAddr[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoPreviewThread::convertBDIIDeepImage2NV21(CVE_BDII_RES_OUT_S *pBDIIResult, VIDEO_FRAME_BUFFER_S *pFrmBuf)
|
||
|
|
{
|
||
|
|
if(pBDIIResult->mImgSize.Width != pFrmBuf->mFrameBuf.VFrame.mWidth
|
||
|
|
|| pBDIIResult->mImgSize.Height != pFrmBuf->mFrameBuf.VFrame.mHeight)
|
||
|
|
{
|
||
|
|
aloge("fatal error! BDII image size[%dx%d] is not match frameBufSize[%dx%d], can't convert!",
|
||
|
|
pBDIIResult->mImgSize.Width, pBDIIResult->mImgSize.Height,
|
||
|
|
pFrmBuf->mFrameBuf.VFrame.mWidth, pFrmBuf->mFrameBuf.VFrame.mHeight);
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
VideoFrameBufferSizeInfo stFrameSizeInfo;
|
||
|
|
getVideoFrameBufferSizeInfo(&pFrmBuf->mFrameBuf, &stFrameSizeInfo);
|
||
|
|
int nPixelNum = pBDIIResult->mImgSize.Width*pBDIIResult->mImgSize.Height;
|
||
|
|
char *img = (char*)pFrmBuf->mFrameBuf.VFrame.mpVirAddr[0];
|
||
|
|
int16_t img_d;
|
||
|
|
for (int i = 0; i < nPixelNum; ++i)
|
||
|
|
{
|
||
|
|
img_d = pBDIIResult->result.as16DeepImg[i];
|
||
|
|
if (img_d < 0)
|
||
|
|
{
|
||
|
|
img[i] = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
img_d = img_d >> 2;
|
||
|
|
if (img_d > 255)
|
||
|
|
{
|
||
|
|
img[i] = 255;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
img[i] = img_d;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
AW_MPI_SYS_MmzFlushCache(pFrmBuf->mFrameBuf.VFrame.mPhyAddr[0], pFrmBuf->mFrameBuf.VFrame.mpVirAddr[0], stFrameSizeInfo.mYSize);
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoPreviewThread::sendDeepImage(CVE_BDII_RES_OUT_S *pBDIIResult)
|
||
|
|
{
|
||
|
|
if(mHlay < 0)
|
||
|
|
{
|
||
|
|
return NO_INIT;
|
||
|
|
}
|
||
|
|
//convert to nv21 frame buffer
|
||
|
|
{
|
||
|
|
AutoMutex lock(mFrameLock);
|
||
|
|
if(mIdleFrameList.empty())
|
||
|
|
{
|
||
|
|
alogw("Be careful! No Idle frame left, discard this image!");
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
if(!mUsingFrame.empty())
|
||
|
|
{
|
||
|
|
aloge("fatal error! using frame list is not empty!");
|
||
|
|
}
|
||
|
|
mUsingFrame.splice(mUsingFrame.end(), mIdleFrameList, mIdleFrameList.begin());
|
||
|
|
}
|
||
|
|
VIDEO_FRAME_BUFFER_S *pFrmBuf = &mUsingFrame.front();
|
||
|
|
convertBDIIDeepImage2NV21(pBDIIResult, pFrmBuf);
|
||
|
|
pFrmBuf->mFrameBuf.VFrame.mpts = pBDIIResult->mPts;
|
||
|
|
{
|
||
|
|
AutoMutex lock(mFrameLock);
|
||
|
|
mReadyFrameList.splice(mReadyFrameList.end(), mUsingFrame, mUsingFrame.begin());
|
||
|
|
if(mReadyFrameList.back().mRefCnt != 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error! refCnt[%d] != 0", mReadyFrameList.back().mRefCnt);
|
||
|
|
mReadyFrameList.back().mRefCnt = 0;
|
||
|
|
}
|
||
|
|
if(!mUsingFrame.empty())
|
||
|
|
{
|
||
|
|
aloge("fatal error! using frame list is not empty!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
AutoMutex lock(mWaitLock);
|
||
|
|
if(mbWaitPreviewFrame)
|
||
|
|
{
|
||
|
|
mbWaitPreviewFrame = false;
|
||
|
|
EyeseeMessage msg;
|
||
|
|
msg.mMsgType = MsgTypePreview_InputFrameAvailable;
|
||
|
|
mMsgQueue.queueMessage(&msg);
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoPreviewThread::setDisplay(int hlay)
|
||
|
|
{
|
||
|
|
mHlay = hlay;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::DoPreviewThread::setPreviewRotation(int rotation)
|
||
|
|
{
|
||
|
|
mPreviewRotation = rotation;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CveBDII::DoPreviewThread::threadLoop()
|
||
|
|
{
|
||
|
|
if(!exitPending())
|
||
|
|
{
|
||
|
|
return previewThread();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CveBDII::DoPreviewThread::previewThread()
|
||
|
|
{
|
||
|
|
bool bRunningFlag = true;
|
||
|
|
EyeseeMessage msg;
|
||
|
|
status_t getMsgRet;
|
||
|
|
ERRORTYPE ret;
|
||
|
|
VIDEO_FRAME_BUFFER_S *pFrmbuf;
|
||
|
|
while(1)
|
||
|
|
{
|
||
|
|
PROCESS_MESSAGE:
|
||
|
|
getMsgRet = mMsgQueue.dequeueMessage(&msg);
|
||
|
|
if(getMsgRet == NO_ERROR)
|
||
|
|
{
|
||
|
|
if(DoPreviewThread::MsgTypePreview_InputFrameAvailable == msg.mMsgType)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
else if(DoPreviewThread::MsgTypePreview_Exit == msg.mMsgType)
|
||
|
|
{
|
||
|
|
bRunningFlag = false;
|
||
|
|
goto _exit0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("unknown msg[0x%x]!", msg.mMsgType);
|
||
|
|
}
|
||
|
|
goto PROCESS_MESSAGE;
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
AutoMutex lock(mFrameLock);
|
||
|
|
if(!mReadyFrameList.empty())
|
||
|
|
{
|
||
|
|
mDisplayFrameList.splice(mDisplayFrameList.end(), mReadyFrameList, mReadyFrameList.begin());
|
||
|
|
pFrmbuf = &mDisplayFrameList.back();
|
||
|
|
if(pFrmbuf->mRefCnt != 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error! refCnt[%d]!=0", pFrmbuf->mRefCnt);
|
||
|
|
}
|
||
|
|
pFrmbuf->mRefCnt = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pFrmbuf = NULL;
|
||
|
|
AutoMutex lock(mWaitLock);
|
||
|
|
mbWaitPreviewFrame = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(NULL == pFrmbuf)
|
||
|
|
{
|
||
|
|
int nWaitTime = 0; //unit:ms, 10*1000
|
||
|
|
int msgNum = mMsgQueue.waitMessage(nWaitTime);
|
||
|
|
if(msgNum <= 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error! preview thread wait message timeout[%d]ms! msgNum[%d], bWait[%d]", nWaitTime, msgNum, mbWaitPreviewFrame);
|
||
|
|
}
|
||
|
|
goto PROCESS_MESSAGE;
|
||
|
|
}
|
||
|
|
mpPreviewWindow->onNextFrameAvailable(pFrmbuf);
|
||
|
|
|
||
|
|
decreaseBufRef(pFrmbuf->mFrameBuf.mId);
|
||
|
|
//return true;
|
||
|
|
goto PROCESS_MESSAGE;
|
||
|
|
}
|
||
|
|
_exit0:
|
||
|
|
return bRunningFlag;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::DoPreviewThread::increaseBufRef(VIDEO_FRAME_BUFFER_S *pbuf)
|
||
|
|
{
|
||
|
|
AutoMutex lock(mFrameLock);
|
||
|
|
++pbuf->mRefCnt;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::DoPreviewThread::decreaseBufRef(unsigned int nBufId)
|
||
|
|
{
|
||
|
|
AutoMutex lock(mFrameLock);
|
||
|
|
bool bFind = false;
|
||
|
|
std::list<VIDEO_FRAME_BUFFER_S>::iterator itFrm;
|
||
|
|
for(std::list<VIDEO_FRAME_BUFFER_S>::iterator it = mDisplayFrameList.begin(); it != mDisplayFrameList.end(); ++it)
|
||
|
|
{
|
||
|
|
if(it->mFrameBuf.mId == nBufId)
|
||
|
|
{
|
||
|
|
if(false == bFind)
|
||
|
|
{
|
||
|
|
bFind = true;
|
||
|
|
itFrm = it;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! more than one bufId[%d]?", nBufId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(false == bFind)
|
||
|
|
{
|
||
|
|
aloge("fatal error! more than one bufId[%d]?", nBufId);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (itFrm->mRefCnt > 0 && --itFrm->mRefCnt == 0)
|
||
|
|
{
|
||
|
|
mIdleFrameList.splice(mIdleFrameList.end(), mDisplayFrameList, itFrm);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::DoPreviewThread::NotifyRenderStart()
|
||
|
|
{
|
||
|
|
if(mpBDII->mpNotifyCallback)
|
||
|
|
{
|
||
|
|
unsigned int nCameraMsgType = CAMERA_MSG_INFO; //CAMERA_MSG_COMPRESSED_IMAGE;
|
||
|
|
CameraMsgInfoType eMsgInfoType = CAMERA_INFO_RENDERING_START;
|
||
|
|
mpBDII->mpNotifyCallback->notify(nCameraMsgType, 0, eMsgInfoType, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::CveBDII(unsigned int mID)
|
||
|
|
: m_ID(mID)
|
||
|
|
, mpDataCallback(NULL)
|
||
|
|
, mpNotifyCallback(NULL)
|
||
|
|
, mpProcessFrameThread(NULL)
|
||
|
|
{
|
||
|
|
alogd("BDII Construct");
|
||
|
|
//mInitCamIndex[0] = -1;
|
||
|
|
//mInitCamIndex[1] = -1;
|
||
|
|
//mCameraProxies.clear();
|
||
|
|
//mCameraProxies.resize(2); //left & right
|
||
|
|
mMessageEnabler = 0;
|
||
|
|
mBDIIState = BDII_STATE_CONSTRUCTED;
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
mpProcessFrameThread = new DoProcessFrameThread(this);
|
||
|
|
#endif
|
||
|
|
mpPreviewThread = new DoPreviewThread(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
CveBDII::~CveBDII()
|
||
|
|
{
|
||
|
|
alogd("Destruct");
|
||
|
|
stop();
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
if (mpProcessFrameThread)
|
||
|
|
{
|
||
|
|
delete mpProcessFrameThread;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
if (mpPreviewThread)
|
||
|
|
{
|
||
|
|
delete mpPreviewThread;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::setCamera(std::vector<BDIICameraChnInfo>& cameraChannels)
|
||
|
|
{
|
||
|
|
if(cameraChannels.size() <= 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error! none camera is set!");
|
||
|
|
return BAD_VALUE;
|
||
|
|
}
|
||
|
|
if(cameraChannels.size() != 2)
|
||
|
|
{
|
||
|
|
aloge("fatal error! need two cameras!");
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mBDIIState != BDII_STATE_CONSTRUCTED)
|
||
|
|
{
|
||
|
|
aloge("setCamera in error state %d, must before prepared!", mBDIIState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
//mCameraProxies.clear();
|
||
|
|
mCameraProxies.resize(cameraChannels.size());
|
||
|
|
int i = 0;
|
||
|
|
for(std::vector<BDIICameraChnInfo>::iterator it = cameraChannels.begin(); it!= cameraChannels.end(); ++it)
|
||
|
|
{
|
||
|
|
if (BDII_CAMERA_LEFT == it->mCamStyle)
|
||
|
|
{
|
||
|
|
i = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
i = 1;
|
||
|
|
}
|
||
|
|
mCameraProxies[i].SetBDIICameraChnInfo(&(*it));
|
||
|
|
}
|
||
|
|
|
||
|
|
//get camera_params
|
||
|
|
//if (NULL != mCameraProxies[0].mpCameraProxy)
|
||
|
|
//{
|
||
|
|
// mCameraProxies[0].mpCameraProxy->getParameters(mCameraProxies[0].mnCameraChannel, mParameters);
|
||
|
|
//}
|
||
|
|
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::prepare()
|
||
|
|
{
|
||
|
|
AutoMutex lock(mLock);
|
||
|
|
status_t result;
|
||
|
|
|
||
|
|
if(mBDIIState != BDII_STATE_CONSTRUCTED)
|
||
|
|
{
|
||
|
|
aloge("prepare in error state %d", mBDIIState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
//cdx_sem_init(&mWaitReturnFrameSem, 0);
|
||
|
|
mBDIIState = BDII_STATE_PREPARED;
|
||
|
|
|
||
|
|
return NO_ERROR;
|
||
|
|
_err0:
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::start()
|
||
|
|
{
|
||
|
|
AutoMutex lock(mLock);
|
||
|
|
if (mBDIIState == BDII_STATE_STARTED)
|
||
|
|
{
|
||
|
|
alogd("already in state started");
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
if (mBDIIState != BDII_STATE_PREPARED)
|
||
|
|
{
|
||
|
|
aloge("start in error state %d", mBDIIState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
//judge if camera is set successful.
|
||
|
|
{
|
||
|
|
bool bCameraOK = true;
|
||
|
|
if (mCameraProxies.size() > 0)
|
||
|
|
{
|
||
|
|
for (std::vector<CameraProxyInfo>::iterator it=mCameraProxies.begin(); it!=mCameraProxies.end(); ++it)
|
||
|
|
{
|
||
|
|
if (NULL == it->mpCameraProxy)
|
||
|
|
{
|
||
|
|
aloge("Camera is not set yet?");
|
||
|
|
bCameraOK = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("no camera set?");
|
||
|
|
bCameraOK = false;
|
||
|
|
}
|
||
|
|
if (!bCameraOK)
|
||
|
|
{
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mCameraProxies.size() != 2)
|
||
|
|
{
|
||
|
|
aloge("fatal error! need two cameras!");
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
mBDIIState = BDII_STATE_STARTED;
|
||
|
|
|
||
|
|
if(mpPreviewThread)
|
||
|
|
{
|
||
|
|
mpPreviewThread->startThread();
|
||
|
|
}
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
mpProcessFrameThread->ProcessFrameThreadStart();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
for (unsigned int i=0; i<mCameraProxies.size(); i++)
|
||
|
|
{
|
||
|
|
mCameraProxies[i].mpCameraProxy->startRecording(
|
||
|
|
mCameraProxies[i].mnCameraChannel,
|
||
|
|
new CameraProxyListener(this, i),
|
||
|
|
m_ID);
|
||
|
|
}
|
||
|
|
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::stop_l()
|
||
|
|
{
|
||
|
|
if (mBDIIState != BDII_STATE_STARTED)
|
||
|
|
{
|
||
|
|
aloge("stop in error state %d", mBDIIState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
//stop transe camera frame
|
||
|
|
for (unsigned int i=0; i<mCameraProxies.size(); i++)
|
||
|
|
{
|
||
|
|
mCameraProxies[i].mpCameraProxy->stopRecording(
|
||
|
|
mCameraProxies[i].mnCameraChannel,
|
||
|
|
m_ID);
|
||
|
|
}
|
||
|
|
|
||
|
|
//mInitCamIndex[0] = -1;
|
||
|
|
//mInitCamIndex[1] = -1;
|
||
|
|
|
||
|
|
//stop process thread
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
mpProcessFrameThread->ProcessFrameThreadStop();
|
||
|
|
#endif
|
||
|
|
if(mpPreviewThread)
|
||
|
|
{
|
||
|
|
mpPreviewThread->stopThread();
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::stop()
|
||
|
|
{
|
||
|
|
status_t ret;
|
||
|
|
AutoMutex lock(mLock);
|
||
|
|
|
||
|
|
alogd("stop");
|
||
|
|
|
||
|
|
if(BDII_STATE_CONSTRUCTED == mBDIIState)
|
||
|
|
{
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
if(BDII_STATE_STARTED == mBDIIState)
|
||
|
|
{
|
||
|
|
ret = stop_l();
|
||
|
|
mBDIIState = BDII_STATE_CONSTRUCTED;
|
||
|
|
}
|
||
|
|
if(BDII_STATE_PREPARED == mBDIIState)
|
||
|
|
{
|
||
|
|
alogw("Be careful! stop in prepared status");
|
||
|
|
mBDIIState = BDII_STATE_CONSTRUCTED;
|
||
|
|
}
|
||
|
|
//cdx_sem_deinit(&mWaitReturnFrameSem);
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::setDisplay(int hlay)
|
||
|
|
{
|
||
|
|
if(mpPreviewThread)
|
||
|
|
{
|
||
|
|
mpPreviewThread->setDisplay(hlay);
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::setPreviewRotation(int rotation)
|
||
|
|
{
|
||
|
|
if(mpPreviewThread)
|
||
|
|
{
|
||
|
|
mpPreviewThread->setPreviewRotation(rotation);
|
||
|
|
}
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*int CveBDII::ifStartReceiveFrame(int nCameraIndex)
|
||
|
|
{
|
||
|
|
AutoMutex lock(mLock);
|
||
|
|
if (!((nCameraIndex==mInitCamIndex[0]) || (nCameraIndex==mInitCamIndex[1])))
|
||
|
|
{
|
||
|
|
if (mInitCamIndex[0] < 0)
|
||
|
|
{
|
||
|
|
mInitCamIndex[0] = nCameraIndex;
|
||
|
|
}
|
||
|
|
else if (mInitCamIndex[1] < 0)
|
||
|
|
{
|
||
|
|
mInitCamIndex[1] = nCameraIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!((mInitCamIndex[0] <0) || (mInitCamIndex[1] < 0)))
|
||
|
|
{
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}*/
|
||
|
|
|
||
|
|
void CveBDII::dataCallbackTimestamp(int nCameraIndex, const VIDEO_FRAME_BUFFER_S *pCameraFrameInfo)
|
||
|
|
{
|
||
|
|
if(NULL == pCameraFrameInfo)
|
||
|
|
{
|
||
|
|
aloge("fatal error! camera frame is NULL?");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//int startReceive = ifStartReceiveFrame(nCameraIndex);
|
||
|
|
int startReceive = 1;
|
||
|
|
|
||
|
|
CameraProxyInfo& CameraProxy = mCameraProxies[nCameraIndex];
|
||
|
|
if (startReceive)
|
||
|
|
{
|
||
|
|
CameraProxy.mFrameCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
//int frameRate = mParameters.getPreviewFrameRate();
|
||
|
|
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
if (startReceive)
|
||
|
|
{
|
||
|
|
//alogd("cam[%d], receiver frame[%d]", nCameraIndex, pCameraFrameInfo->mFrameBuf.mId);
|
||
|
|
{
|
||
|
|
AutoMutex lock(CameraProxy.mFrameBufListLock);
|
||
|
|
if(CameraProxy.mIdleFrameBufList.empty())
|
||
|
|
{
|
||
|
|
CameraProxy.mIdleFrameBufList.emplace_back();
|
||
|
|
}
|
||
|
|
if (!CameraProxy.mIdleFrameBufList.empty())
|
||
|
|
{
|
||
|
|
memcpy(&CameraProxy.mIdleFrameBufList.front(), pCameraFrameInfo, sizeof(VIDEO_FRAME_BUFFER_S));
|
||
|
|
CameraProxy.mReadyFrameBufList.splice(CameraProxy.mReadyFrameBufList.end(), CameraProxy.mIdleFrameBufList, CameraProxy.mIdleFrameBufList.begin());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! emplace_back fail?");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (std::vector<CameraProxyInfo>::iterator it = mCameraProxies.begin(); it!=mCameraProxies.end(); ++it)
|
||
|
|
{
|
||
|
|
it->mFrameBufListLock.lock();
|
||
|
|
}
|
||
|
|
int nFramePairNum = -1; //least frame number in cameraProxy.
|
||
|
|
for (std::vector<CameraProxyInfo>::iterator it = mCameraProxies.begin(); it!=mCameraProxies.end(); ++it)
|
||
|
|
{
|
||
|
|
if(-1 == nFramePairNum)
|
||
|
|
{
|
||
|
|
nFramePairNum = it->mReadyFrameBufList.size();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(nFramePairNum > (int)it->mReadyFrameBufList.size())
|
||
|
|
{
|
||
|
|
nFramePairNum = it->mReadyFrameBufList.size();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(0 == nFramePairNum)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(nFramePairNum > 1)
|
||
|
|
{
|
||
|
|
aloge("fatal error! impossible! max frame pair number is 1! check code!");
|
||
|
|
}
|
||
|
|
if(nFramePairNum > 0)
|
||
|
|
{
|
||
|
|
VIDEO_FRAME_BUFFER_S *pFram0 = &mCameraProxies[0].mReadyFrameBufList.front();
|
||
|
|
VIDEO_FRAME_BUFFER_S *pFram1 = &mCameraProxies[1].mReadyFrameBufList.front();
|
||
|
|
|
||
|
|
status_t ret = mpProcessFrameThread->sendFrame(pFram0, pFram1);
|
||
|
|
if (NO_ERROR == ret)
|
||
|
|
{
|
||
|
|
mCameraProxies[0].mUsedFrameBufList.splice(mCameraProxies[0].mUsedFrameBufList.end(), mCameraProxies[0].mReadyFrameBufList, mCameraProxies[0].mReadyFrameBufList.begin());
|
||
|
|
mCameraProxies[1].mUsedFrameBufList.splice(mCameraProxies[1].mUsedFrameBufList.end(), mCameraProxies[1].mReadyFrameBufList, mCameraProxies[1].mReadyFrameBufList.begin());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! sendFrame can't be fail, check code!");
|
||
|
|
mCameraProxies[0].mpCameraProxy->releaseRecordingFrame(mCameraProxies[0].mnCameraChannel, pFram0->mFrameBuf.mId);
|
||
|
|
mCameraProxies[1].mpCameraProxy->releaseRecordingFrame(mCameraProxies[1].mnCameraChannel, pFram1->mFrameBuf.mId);
|
||
|
|
mCameraProxies[0].mIdleFrameBufList.splice(mCameraProxies[0].mIdleFrameBufList.end(), mCameraProxies[0].mReadyFrameBufList, mCameraProxies[0].mReadyFrameBufList.begin());
|
||
|
|
mCameraProxies[1].mIdleFrameBufList.splice(mCameraProxies[1].mIdleFrameBufList.end(), mCameraProxies[1].mReadyFrameBufList, mCameraProxies[1].mReadyFrameBufList.begin());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (std::vector<CameraProxyInfo>::iterator it = mCameraProxies.begin(); it!=mCameraProxies.end(); ++it)
|
||
|
|
{
|
||
|
|
it->mFrameBufListLock.unlock();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
CameraProxy.mpCameraProxy->releaseRecordingFrame(CameraProxy.mnCameraChannel, pCameraFrameInfo->mFrameBuf.mId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::setDataListener(DataListener *pCb)
|
||
|
|
{
|
||
|
|
mpDataCallback = pCb;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::setNotifyListener(NotifyListener *pCb)
|
||
|
|
{
|
||
|
|
mpNotifyCallback = pCb;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::enableMessage(unsigned int msg_type)
|
||
|
|
{
|
||
|
|
alogv("msg_type = 0x%x", msg_type);
|
||
|
|
AutoMutex lock(&mLock);
|
||
|
|
mMessageEnabler |= msg_type;
|
||
|
|
alogv("**** Currently enabled messages:");
|
||
|
|
}
|
||
|
|
|
||
|
|
void CveBDII::disableMessage(unsigned int msg_type)
|
||
|
|
{
|
||
|
|
alogv("msg_type = 0x%x", msg_type);
|
||
|
|
|
||
|
|
AutoMutex lock(&mLock);
|
||
|
|
mMessageEnabler &= ~msg_type;
|
||
|
|
alogv("**** Currently enabled messages:");
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CveBDII::isMessageEnabled(unsigned int msg_type) //CAMERA_MSG_COMPRESSED_IMAGE
|
||
|
|
{
|
||
|
|
return mMessageEnabler & msg_type;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::setBDIIConfigParams(AW_AI_CVE_BDII_INIT_PARA_S &Param)
|
||
|
|
{
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
if (mpProcessFrameThread)
|
||
|
|
{
|
||
|
|
return mpProcessFrameThread->SetBDIIProcessConfigParams(Param);
|
||
|
|
}
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
#else
|
||
|
|
return NO_ERROR;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::getBDIIConfigParams(AW_AI_CVE_BDII_INIT_PARA_S &Param)
|
||
|
|
{
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
if (mpProcessFrameThread)
|
||
|
|
{
|
||
|
|
return mpProcessFrameThread->GetBDIIProcessConfigParams(Param);
|
||
|
|
}
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
#else
|
||
|
|
return NO_ERROR;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t CveBDII::setDebugYuvDataOut(bool saveOut, std::vector<BDIIDebugFileOutString>&vec)
|
||
|
|
{
|
||
|
|
#if (MPPCFG_BDII == OPTION_BDII_ENABLE)
|
||
|
|
if (mpProcessFrameThread)
|
||
|
|
{
|
||
|
|
return mpProcessFrameThread->debugYuvDataOut(saveOut, vec);
|
||
|
|
}
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
#else
|
||
|
|
return NO_ERROR;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
}; /* namespace EyeseeLinux */
|