//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AAOBufMgr::
freeBuf(BufInfo_T &rBufInfo)
{
if (m_pIMemDrv->unmapPhyAddr(&rBufInfo)) {
MY_ERR("m_pIMemDrv->unmapPhyAddr() error");
return MFALSE;
}
if (m_pIMemDrv->freeVirtBuf(&rBufInfo)) {
MY_ERR("m_pIMemDrv->freeVirtBuf() error");
return MFALSE;
}
MY_LOG("%s() memID = 0x%x\n", __FUNCTION__, rBufInfo.memID);
return MTRUE;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AAOBufMgr::
allocateBuf(BufInfo_T &rBufInfo, MUINT32 u4BufSize)
{
rBufInfo.size = u4BufSize;
if (m_pIMemDrv->allocVirtBuf(&rBufInfo)) {
MY_ERR("m_pIMemDrv->allocVirtBuf() error");
return MFALSE;
}
if (m_pIMemDrv->mapPhyAddr(&rBufInfo)) {
MY_ERR("m_pIMemDrv->mapPhyAddr() error");
return MFALSE;
}
MY_LOG("%s() memID = 0x%x\n", __FUNCTION__, rBufInfo.memID);
return MTRUE;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AEBufMgr::
freeBuf(BufInfo_T &rBufInfo)
{
#if ENABLE_AE_MVHDR_STAT
if (m_pIMemDrv->unmapPhyAddr(&rBufInfo)) {
MY_ERR("m_pIMemDrv->unmapPhyAddr() error");
return MFALSE;
}
if (m_pIMemDrv->freeVirtBuf(&rBufInfo)) {
MY_ERR("m_pIMemDrv->freeVirtBuf() error");
return MFALSE;
}
MY_LOG("%s() memID = 0x%x\n", __FUNCTION__, rBufInfo.memID);
#endif
return MTRUE;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AEBufMgr::
uninit()
{
#if ENABLE_AE_MVHDR_STAT
IMEM_BUF_INFO buf_info;
MY_LOG("[%s()] m_eSensorDev: %d, m_Users: %d \n", __FUNCTION__, m_eSensorDev, m_Users);
Mutex::Autolock lock(m_Lock);
// If no more users, return directly and do nothing.
if (m_Users <= 0)
{
return MTRUE;
}
// More than one user, so decrease one User.
android_atomic_dec(&m_Users);
if (m_Users == 0) // There is no more User after decrease one User
{
// Disable AA stat
//AAStatEnable(MFALSE);
// AAO DMA buffer uninit
//DMAUninit();
for (MINT32 i = 0; i < MAX_AAO_BUFFER_CNT; i++) {
freeBuf(m_rAAOBufInfo[i]);
}
// imem driver ininit
m_pIMemDrv->uninit();
if ( 0 != mpIspHwRegAddr ) {
munmap(mpIspHwRegAddr, CAM_ISP_RANGE);
mpIspHwRegAddr = NULL;
}
if(mfd >= 0)
{
close(mfd);
mfd = -1;
}
// Normal pipe
//m_pPipe->destroyInstance("aao_buf_mgr");
}
else // There are still some users.
{
MY_LOG_IF(m_bDebugEnable,"Still %d users \n", m_Users);
}
#endif
return MTRUE;
}
MBOOL
JpegCodec::
deallocMem(IMEM_BUF_INFO & rMemBuf)
{
IMemDrv *pIMemDrv = IMemDrv::createInstance();
CHECK_OBJECT(pIMemDrv);
//
pIMemDrv->init();
//
#if 1
if (pIMemDrv->unmapPhyAddr(&rMemBuf))
{
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
return MFALSE;
}
#endif
//
if (pIMemDrv->freeVirtBuf(&rMemBuf))
{
MY_LOGE("m_pIMemDrv->freeVirtBuf() error");
return MFALSE;
}
rMemBuf.size = 0;
//
pIMemDrv->uninit();
pIMemDrv->destroyInstance();
return MTRUE;
}
MBOOL
JpegCodec::
allocMem(IMEM_BUF_INFO & rMemBuf)
{
//
IMemDrv *pIMemDrv = IMemDrv::createInstance();
CHECK_OBJECT(pIMemDrv);
//
pIMemDrv->init();
//
if (pIMemDrv->allocVirtBuf(&rMemBuf)) {
MY_LOGE("g_pIMemDrv->allocVirtBuf() error");
return MFALSE;
}
::memset((void*)rMemBuf.virtAddr, 0 , rMemBuf.size);
#if 1
if (pIMemDrv->mapPhyAddr(&rMemBuf)) {
MY_LOGE("mpIMemDrv->mapPhyAddr() error");
return MFALSE;
}
#endif
//
pIMemDrv->uninit();
pIMemDrv->destroyInstance();
return MTRUE;
}
static MUINT32 u4X3_Cmd(int argc, char** argv)
{
//1. allocate buffer
printf("allocate buffer\n");
IMemDrv *mpIMemDrv = IMemDrv::createInstance();
mpIMemDrv->init(); //check this, see fd
IMEM_BUF_INFO mpSourceImgBuf[3];
IMEM_BUF_INFO mpTargetImgBuf[3];
for(int i=0; i<3; i++) {
//2. source image
printf("source image\n");
mpSourceImgBuf[i].size = 794 * 600 * 1.5;
if(mpIMemDrv->allocVirtBuf(&mpSourceImgBuf[i]))
return MFALSE;
uint32_t nReadSize = loadFileToBuf("/sdcard/source794x600.nv21.yuv", (uint8_t*)mpSourceImgBuf[i].virtAddr, mpSourceImgBuf[i].size);
//3. target image
printf("target image\n");
mpTargetImgBuf[i].size = 20 * 16 * 1.5;
if(mpIMemDrv->allocVirtBuf(&mpTargetImgBuf[i]))
return MFALSE;
//4. resize
printf("resize\n");
HdrShot::CDPResize_simple(
&mpSourceImgBuf[i], 794, 600, eImgFmt_NV21,
&mpTargetImgBuf[i], 20, 16, eImgFmt_NV21, 0);
char outfile[128];
sprintf(outfile, "/sdcard/target[%i].nv21.yuv.pgm", i);
saveBufToFile(outfile, (MUINT8 *)mpTargetImgBuf[i].virtAddr, mpTargetImgBuf[i].size);
}
//5. final
printf("final\n");
return 0;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AAOBufMgr::
enqueueHwBuf(BufInfo_T& rBufInfo)
{
MY_LOG_IF(m_bDebugEnable,"%s() m_eSensorDev(%d)\n", __FUNCTION__, m_eSensorDev);
MY_LOG_IF(m_bDebugEnable,"rBufInfo.virtAddr:[0x%x]/phyAddr:[0x%x] \n",rBufInfo.virtAddr,rBufInfo.phyAddr);
// add element at the end
m_rHwBufList.push_back(rBufInfo);
m_pIMemDrv->cacheSyncbyRange(IMEM_CACHECTRL_ENUM_INVALID, &rBufInfo);
return MTRUE;
}
static MUINT32 u4CDPNV21_Cmd(int argc, char** argv)
{
//1. allocate buffer
printf("allocate buffer\n");
IMemDrv *mpIMemDrv = IMemDrv::createInstance();
mpIMemDrv->init(); //check this, see fd
//2. source image
printf("source image\n");
IMEM_BUF_INFO mpSourceImgBuf;
mpSourceImgBuf.size = 1280 * 960 * 1.5;
if(mpIMemDrv->allocVirtBuf(&mpSourceImgBuf))
return MFALSE;
uint32_t nReadSize = loadFileToBuf("source.nv21.yuv", (uint8_t*)mpSourceImgBuf.virtAddr, mpSourceImgBuf.size);
//3. target image
printf("target image\n");
IMEM_BUF_INFO mpTargetImgBuf;
mpTargetImgBuf.size = 160 * 120 * 1.5;
if(mpIMemDrv->allocVirtBuf(&mpTargetImgBuf))
return MFALSE;
//4. resize
printf("resize\n");
HdrShot::CDPResize_simple(
&mpSourceImgBuf, 1280, 960, eImgFmt_NV21,
&mpTargetImgBuf, 160, 120, eImgFmt_NV21, 0);
saveBufToFile("/sdcard/target.nv21.yuv", (MUINT8 *)mpTargetImgBuf.virtAddr, mpTargetImgBuf.size);
//5. final
printf("final\n");
return 0;
}
MBOOL
StereoNodeImpl::
freeBuffers()
{
FUNC_START;
MBOOL ret = MFALSE;
list<IMEM_BUF_INFO>::iterator iter;
IMEM_BUF_INFO feo;
IMemDrv* pIMemDrv = IMemDrv::createInstance();
if ( !pIMemDrv || !pIMemDrv->init() ) {
MY_LOGE("pIMemDrv->init() error");
goto lbExit;
}
MY_LOGD("check buffer size(%d)", mlFeBufQueue.size());
for(iter = mlFeBufQueue.begin(); iter != mlFeBufQueue.end(); iter++)
{
MY_LOGD("Buffer addr(0x%x)", (*iter).virtAddr);
if(0 == (*iter).virtAddr)
{
MY_LOGE("Buffer doesn't exist");
continue;
}
if(pIMemDrv->unmapPhyAddr(&(*iter)) < 0)
{
MY_LOGE("pIMemDrv->unmapPhyAddr() error");
goto lbExit;
}
if (pIMemDrv->freeVirtBuf(&(*iter)) < 0)
{
MY_LOGE("pIMemDrv->freeVirtBuf() error");
goto lbExit;
}
}
//
ret = MTRUE;
lbExit:
if ( !pIMemDrv ) {
pIMemDrv->uninit();
pIMemDrv->destroyInstance();
}
return ret;
}
static MUINT32 u4CDPUp_Cmd(int argc, char** argv)
{
MUINT32 ret = 0;
MUINT32 mu4RunningNumber = 1;
MUINT32 u4OutputFrameNum = 3;
MUINT32 weight_table_width = 794;
MUINT32 weight_table_height = 600;
MUINT32 mu4W_dsmap = 1280;
MUINT32 mu4H_dsmap = 960;
MUINT32 mu4DownSizedWeightMapSize = mu4W_dsmap * mu4H_dsmap * 1.5;
IMEM_BUF_INFO mpWeightMapBuf[3];
IMEM_BUF_INFO mpDownSizedWeightMapBuf[3];
IMemDrv *mpIMemDrv = IMemDrv::createInstance();
mpIMemDrv->init(); //check this, see fd
for (MUINT32 i = 0; i < u4OutputFrameNum; i++)
{
//alloc mpWeightMapBuf
mpWeightMapBuf[i].size = weight_table_width * weight_table_height * 1.5;
mpIMemDrv->allocVirtBuf(&mpWeightMapBuf[i]);
#if WORKAROUND_IMEM
if (mpIMemDrv->mapPhyAddr(&mpWeightMapBuf[i])) {
MY_LOGE("mpIMemDrv->mapPhyAddr() error");
}
#endif
loadFileToBuf("/sdcard/source794x600.nv21.yuv", (uint8_t*)mpWeightMapBuf[i].virtAddr, mpWeightMapBuf[i].size);
MY_DBG("[do_DownScaleWeightMap] CDPResize %d/%d", i, u4OutputFrameNum);
//alloc mpDownSizedWeightMapBuf
mpDownSizedWeightMapBuf[i].size = mu4W_dsmap*mu4H_dsmap*1.5;
mpIMemDrv->allocVirtBuf(&mpDownSizedWeightMapBuf[i]);
#if WORKAROUND_IMEM
if (mpIMemDrv->mapPhyAddr(&mpDownSizedWeightMapBuf[i])) {
MY_LOGE("mpIMemDrv->mapPhyAddr() error");
}
#endif
//set default value
::memset((void*)mpDownSizedWeightMapBuf[i].virtAddr, 128, mu4W_dsmap*mu4H_dsmap*1.5);
ret = HdrShot::CDPResize_simple(
&mpWeightMapBuf[i], weight_table_width, weight_table_height, eImgFmt_NV21,
&mpDownSizedWeightMapBuf[i], mu4W_dsmap, mu4H_dsmap, eImgFmt_NV21, 0);
#if WORKAROUND_IMEM
if (mpIMemDrv->unmapPhyAddr(&mpWeightMapBuf[i])) {
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
}
#endif
mpIMemDrv->freeVirtBuf(&mpWeightMapBuf[i]); //????
}
for (MUINT32 i = 0; i < u4OutputFrameNum; i++)
{
char szFileName[100];
::sprintf(szFileName, HDR_DEBUG_OUTPUT_FOLDER "%04d_6_mpDownSizedWeightMapBuf[%d]_%dx%d.raw", mu4RunningNumber, i, mu4W_dsmap, mu4H_dsmap);
saveBufToFile(szFileName, (MUINT8*)mpDownSizedWeightMapBuf[i].virtAddr, mu4DownSizedWeightMapSize);
MY_VERB("[do_DownScaleWeightMap] Save %s done.", szFileName);
#if WORKAROUND_IMEM
if (mpIMemDrv->unmapPhyAddr(&mpDownSizedWeightMapBuf[i])) {
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
}
#endif
mpIMemDrv->freeVirtBuf(&mpDownSizedWeightMapBuf[i]);
}
printf("[do_DownScaleWeightMap] - t8.");
printf("[do_DownScaleWeightMap] - X. ret: %d.", ret);
mpIMemDrv->destroyInstance();
return ret;
}
static MUINT32 u4SImager_Cmd(int argc, char** argv)
{
MUINT32 u4SrcWidth = 1600;
MUINT32 u4SrcHeight = 1200;
MUINT32 u4TargetWidth = 800;
MUINT32 u4TargetHeight = 600;
int srcFmt = 0;
int dstFmt = 0;
char *filename = argv[0];
u4SrcWidth = atoi(argv[1]);
u4SrcHeight = atoi(argv[2]);
srcFmt = atoi(argv[3]);
u4TargetWidth = atoi(argv[4]);
u4TargetHeight = atoi(argv[5]);
dstFmt = atoi(argv[6]);
printf("filename = %s\n", filename);
printf("size in(%d,%d), out(%d,%d)\n", u4SrcWidth, u4SrcHeight, u4TargetWidth, u4TargetHeight);
printf("fmt in=%x, out=%x\n", srcFmt, dstFmt);
printf("SImager Test\n");
//
IMemDrv *pIMemDrv = IMemDrv::createInstance();
pIMemDrv->init();
if (NULL == pIMemDrv)
{
printf("g_pIMemDrv is NULL");
return 0;
}
//
IMEM_BUF_INFO rInMem;
rInMem.size = (u4SrcWidth * u4SrcHeight * 2+ L1_CACHE_BYTES-1) & ~(L1_CACHE_BYTES-1);
if (pIMemDrv->allocVirtBuf(&rInMem)) {
printf("g_pIMemDrv->allocVirtBuf() error");
}
#if WORKAROUND_IMEM
memset((void*)rInMem.virtAddr, 0 , rInMem.size);
if (pIMemDrv->mapPhyAddr(&rInMem)) {
printf("mpIMemDrv->mapPhyAddr() error");
}
#endif
if(!loadFileToBuf(filename, reinterpret_cast<MUINT8*>(rInMem.virtAddr), u4SrcWidth * u4SrcHeight)) {
printf("can't load image:%s\n", filename);
return 0;
}
printf("load image:%s\n", filename);
//
IMEM_BUF_INFO rOutMem;
rOutMem.size = (u4TargetWidth * u4TargetHeight * 2+ L1_CACHE_BYTES -1) & ~(L1_CACHE_BYTES-1);
if (pIMemDrv->allocVirtBuf(&rOutMem)) {
MY_LOGE("g_pIMemDrv->allocVirtBuf() error");
}
memset((void*)rOutMem.virtAddr, 128, rOutMem.size);
if (pIMemDrv->mapPhyAddr(&rOutMem)) {
MY_LOGE("mpIMemDrv->mapPhyAddr() error");
}
HdrShot::CDPResize_simple(
&rInMem, u4SrcWidth, u4SrcHeight, g_eImgFmt[srcFmt],
&rOutMem, u4TargetWidth, u4TargetHeight, g_eImgFmt[dstFmt], 0);
char suffix[8];
char prefix[8];
switch(g_eImgFmt[srcFmt]) {
case eImgFmt_YUY2: sprintf(prefix, "%s", "yuy2"); break;
case eImgFmt_NV21: sprintf(prefix, "%s", "nv21"); break;
case eImgFmt_I420: sprintf(prefix, "%s", "i420"); break;
case eImgFmt_YV16: sprintf(prefix, "%s", "yv16"); break;
case eImgFmt_JPEG: sprintf(prefix, "%s", "jpg"); break;
case eImgFmt_YV12: sprintf(prefix, "%s", "yv12"); break;
}
switch(g_eImgFmt[dstFmt]) {
case eImgFmt_YUY2: sprintf(suffix, "%s", "yuy2"); break;
case eImgFmt_NV21: sprintf(suffix, "%s", "nv21"); break;
case eImgFmt_I420: sprintf(suffix, "%s", "i420"); break;
case eImgFmt_YV16: sprintf(suffix, "%s", "yv16"); break;
case eImgFmt_JPEG: sprintf(suffix, "%s", "jpg"); break;
case eImgFmt_YV12: sprintf(suffix, "%s", "yv12"); break;
}
char outfile[128];
sprintf(outfile, "/sdcard/0001_%s_%dx%d.%s", prefix, u4TargetWidth, u4TargetHeight, suffix);
saveBufToFile(outfile, (MUINT8 *)rOutMem.virtAddr, rOutMem.size);
//!***************************************************
//! Main thread wait for exit
//!***************************************************
//
//deallocMem(rInMem);
//deallocMem(rOutMem);
if (pIMemDrv->unmapPhyAddr(&rInMem)) {
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
}
if (pIMemDrv->freeVirtBuf(&rInMem)) {
MY_LOGE("m_pIMemDrv->freeVirtBuf() error");
}
if (pIMemDrv->unmapPhyAddr(&rOutMem)) {
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
}
if (pIMemDrv->freeVirtBuf(&rOutMem)) {
MY_LOGE("m_pIMemDrv->freeVirtBuf() error");
}
//
pIMemDrv->uninit();
pIMemDrv->destroyInstance();
return 0;
}
static MUINT32 u4Y8002Y800_Cmd(int argc, char** argv)
{
MUINT32 u4SrcWidth = 1600;
MUINT32 u4SrcHeight = 1200;
MUINT32 u4TargetWidth = 160;
MUINT32 u4TargetHeight = 120;
int srcFmt = 0;
char filename[128];
sprintf(filename, "/sdcard/hdr_sample_1600x1200_%d.y", 1);
printf("SImager Test \n");
//
IMemDrv *pIMemDrv = IMemDrv::createInstance();
pIMemDrv->init();
if (NULL == pIMemDrv)
{
printf("g_pIMemDrv is NULL");
return 0;
}
//
IMEM_BUF_INFO rInMem;
rInMem.size = (u4SrcWidth * u4SrcHeight + L1_CACHE_BYTES-1) & ~(L1_CACHE_BYTES-1);
if (pIMemDrv->allocVirtBuf(&rInMem)) {
printf("g_pIMemDrv->allocVirtBuf() error");
}
#if WORKAROUND_IMEM
memset((void*)rInMem.virtAddr, 0 , rInMem.size);
if (pIMemDrv->mapPhyAddr(&rInMem)) {
printf("mpIMemDrv->mapPhyAddr() error");
}
#endif
if(!loadFileToBuf(filename, reinterpret_cast<MUINT8*>(rInMem.virtAddr), u4SrcWidth * u4SrcHeight)) {
printf("can't load image:%s\n", filename);
return 0;
}
printf("load image:%s\n", filename);
//
IMEM_BUF_INFO rOutMem;
rOutMem.size = (u4TargetWidth * u4TargetHeight + L1_CACHE_BYTES -1) & ~(L1_CACHE_BYTES-1);
if (pIMemDrv->allocVirtBuf(&rOutMem)) {
MY_LOGE("g_pIMemDrv->allocVirtBuf() error");
}
#if WORKAROUND_IMEM
//memset((void*)rOutMem.virtAddr, 0 , rOutMem.size);
memset((void*)rOutMem.virtAddr, 128, rOutMem.size);
if (pIMemDrv->mapPhyAddr(&rOutMem)) {
MY_LOGE("mpIMemDrv->mapPhyAddr() error");
}
#endif
#if 0
//
MUINT32 u4InStride[3] = {u4SrcWidth, u4SrcWidth, u4SrcWidth};
ImgBufInfo rSrcImgInfo(ImgInfo(eImgFmt_YUY2, u4SrcWidth, u4SrcHeight),
BufInfo(rInMem.size, rInMem.virtAddr, rInMem.phyAddr, rInMem.memID), u4InStride);
#endif
saveBufToFile("/sdcard/0001_input_1600x1200.y", (MUINT8 *)rInMem.virtAddr, rInMem.size);
HdrShot::CDPResize_simple(
&rInMem, u4SrcWidth, u4SrcHeight, eImgFmt_Y800,
&rOutMem, u4TargetWidth, u4TargetHeight, eImgFmt_Y800, 0);
saveBufToFile("/sdcard/0001_output_160x120.y", (MUINT8 *)rOutMem.virtAddr, rOutMem.size);
//!***************************************************
//! Main thread wait for exit
//!***************************************************
//
//deallocMem(rInMem);
//deallocMem(rOutMem);
if (pIMemDrv->unmapPhyAddr(&rInMem)) {
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
}
if (pIMemDrv->freeVirtBuf(&rInMem)) {
MY_LOGE("m_pIMemDrv->freeVirtBuf() error");
}
if (pIMemDrv->unmapPhyAddr(&rOutMem)) {
MY_LOGE("m_pIMemDrv->unmapPhyAddr() error");
}
if (pIMemDrv->freeVirtBuf(&rOutMem)) {
MY_LOGE("m_pIMemDrv->freeVirtBuf() error");
}
//
pIMemDrv->uninit();
pIMemDrv->destroyInstance();
return 0;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AAOBufMgr::
init(MINT32 const i4SensorIdx)
{
char value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("debug.aao_buf_mgr.enable", value, "0");
m_bDebugEnable = atoi(value);
// sensor index
m_i4SensorIdx = i4SensorIdx;
MY_LOG("[%s()] m_eSensorDev: %d, m_i4SensorIdx: %d, m_Users: %d \n", __FUNCTION__, m_eSensorDev, m_i4SensorIdx, m_Users);
Mutex::Autolock lock(m_Lock);
if (m_Users > 0)
{
MY_LOG("%d has created \n", m_Users);
android_atomic_inc(&m_Users);
return MTRUE;
}
// AAO statistics init
AWB_STAT_PARAM_T rAWBStatParam;
switch (m_eSensorDev)
{
case ESensorDev_Main: // Main Sensor
rAWBStatParam = getAWBStatParam<ESensorDev_Main>();
break;
case ESensorDev_MainSecond: // Main Second Sensor
rAWBStatParam = getAWBStatParam<ESensorDev_MainSecond>();
break;
case ESensorDev_Sub: // Sub Sensor
rAWBStatParam = getAWBStatParam<ESensorDev_Sub>();
break;
default:
MY_ERR("m_eSensorDev = %d", m_eSensorDev);
rAWBStatParam = getAWBStatParam<ESensorDev_Main>();
break;
}
m_u4AEStateSize = static_cast<MUINT32>(((rAWBStatParam.i4WindowNumX + 3) / 4) * 4 * rAWBStatParam.i4WindowNumY);
m_u4AEHistSize = 4 * 256;
m_u4AWBStateSize = static_cast<MUINT32>(rAWBStatParam.i4WindowNumX * rAWBStatParam.i4WindowNumY * 4);
m_u4AAOBufSize = m_u4AEStateSize + m_u4AEHistSize + m_u4AWBStateSize;
m_u4AAOXSize = m_u4AAOBufSize - 1;
MY_LOG("m_u4AEStateSize = %d", m_u4AEStateSize);
MY_LOG("m_u4AEHistSize = %d", m_u4AEHistSize);
MY_LOG("m_u4AWBStateSize = %d", m_u4AWBStateSize);
MY_LOG("m_u4AAOBufSize = %d", m_u4AAOBufSize);
MY_LOG("m_u4AAOXSize = %d", m_u4AAOXSize);
// Normal pipe
//m_pPipe = INormalPipe::createInstance(m_i4SensorIdx,"aao_buf_mgr");
// imem driver init
m_pIMemDrv->init();
// AAO DMA buffer init
// removes all elements from the list container
m_rHwBufList.clear();
// allocate and enqueue HW buffer
for (MINT32 i = 0; i < MAX_AAO_BUFFER_CNT; i++) {
m_rAAOBufInfo[i].useNoncache = 0; // improve the performance
allocateBuf(m_rAAOBufInfo[i], m_u4AAOBufSize);
enqueueHwBuf(m_rAAOBufInfo[i]);
}
//DMAInit();
// Enable AA stat
//AAStatEnable(MTRUE);
debugPrint();
android_atomic_inc(&m_Users);
return MTRUE;
}
MBOOL
StereoNodeImpl::
allocBuffers(vector<HwPortConfig_t> & lPortCfg)
{
FUNC_START;
MBOOL ret = MFALSE;
//
vector< HwPortConfig_t >::const_iterator pConfig = lPortCfg.begin();
IMemDrv* pIMemDrv = IMemDrv::createInstance();
if ( !pIMemDrv || !pIMemDrv->init() ) {
MY_LOGE("pIMemDrv->init() error");
goto lbExit;
}
for(MUINT32 i = 0; i < BUF_COUNT; ++i)
{
IMEM_BUF_INFO bufInfo;
bufInfo.size = getHWFESize().size();
if(pIMemDrv->allocVirtBuf(&bufInfo) < 0)
{
MY_LOGE("pIMemDrv->allocVirtBuf() error, i(%d)",i);
goto lbExit;
}
if(pIMemDrv->mapPhyAddr(&bufInfo) < 0)
{
MY_LOGE("pIMemDrv->mapPhyAddr() error, i(%d)",i);
goto lbExit;
}
mlFeBufQueue.push_back(bufInfo);
}
//
while( pConfig != lPortCfg.end() )
{
MUINT32 nodedatatype = mapToNodeDataType(pConfig->mPortID);
ICamBufHandler* pBufHdl = getBufferHandler(nodedatatype);
MY_LOGD("handle(%p) data(%d) S(%dx%d)F(0x%x)", pBufHdl, nodedatatype, pConfig->mSize.w, pConfig->mSize.h, pConfig->mFmt);
if( !pBufHdl )
{
MY_LOGE("no buffer hdl for data(%d)", nodedatatype);
goto lbExit;
}
//alloc buffer
AllocInfo allocinfo(pConfig->mSize.w, pConfig->mSize.h, pConfig->mFmt,
eBUFFER_USAGE_SW_MASK | eBUFFER_USAGE_HW_MASK);
if( nodedatatype == STEREO_IMG )
{
if ( !mDebugDumpGB )
allocinfo.usage = eBUFFER_USAGE_HW_RENDER|eBUFFER_USAGE_HW_TEXTURE|eBUFFER_USAGE_SW_WRITE_RARELY;
else
allocinfo.usage = eBUFFER_USAGE_HW_RENDER|eBUFFER_USAGE_HW_TEXTURE|eBUFFER_USAGE_SW_WRITE_RARELY|eBUFFER_USAGE_SW_READ_RARELY;
allocinfo.isGralloc = MTRUE;
}
for(MUINT32 i = 0; i < BUF_COUNT ; i++ )
{
if( !pBufHdl->requestBuffer(nodedatatype, allocinfo) )
{
MY_LOGE("request buffer failed: data %d", nodedatatype);
goto lbExit;
}
}
//
pConfig++;
}
//
ret = MTRUE;
lbExit:
if ( !pIMemDrv ) {
pIMemDrv->uninit();
pIMemDrv->destroyInstance();
}
if( !ret ) {
MY_LOGE("allocBuffers failed");
}
FUNC_END;
return ret;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MBOOL
AEBufMgr::
init(MINT32 const i4SensorIdx)
{
#if ENABLE_AE_MVHDR_STAT
char value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("debug.aao_buf_mgr.enable", value, "0");
m_bDebugEnable = atoi(value);
MINT32 cam_isp_addr = 0x15000000;
// sensor index
m_i4SensorIdx = i4SensorIdx;
MY_LOG("[%s()] m_eSensorDev: %d, m_i4SensorIdx: %d, m_Users: %d \n", __FUNCTION__, m_eSensorDev, m_i4SensorIdx, m_Users);
Mutex::Autolock lock(m_Lock);
if (m_Users > 0)
{
MY_LOG("%d has created \n", m_Users);
android_atomic_inc(&m_Users);
return MTRUE;
}
// AAO statistics init
AWB_STAT_PARAM_T rAWBStatParam;
switch (m_eSensorDev)
{
case ESensorDev_Main: // Main Sensor
rAWBStatParam = getAWBStatParam<ESensorDev_Main>();
break;
case ESensorDev_MainSecond: // Main Second Sensor
rAWBStatParam = getAWBStatParam<ESensorDev_MainSecond>();
break;
case ESensorDev_Sub: // Sub Sensor
rAWBStatParam = getAWBStatParam<ESensorDev_Sub>();
break;
default:
MY_ERR("m_eSensorDev = %d", m_eSensorDev);
rAWBStatParam = getAWBStatParam<ESensorDev_Main>();
break;
}
m_u4AAOBufSize = 0x280; //m_u4AEStateSize + m_u4AEHistSize + m_u4AWBStateSize;
m_u4AAOXSize = m_u4AAOBufSize - 1;
MY_LOG("m_u4AEStateSize = %d", m_u4AEStateSize);
MY_LOG("m_u4AEHistSize = %d", m_u4AEHistSize);
MY_LOG("m_u4AWBStateSize = %d", m_u4AWBStateSize);
MY_LOG("m_u4AAOBufSize = %d", m_u4AAOBufSize);
MY_LOG("m_u4AAOXSize = %d", m_u4AAOXSize);
// Normal pipe
//m_pPipe = INormalPipe::createInstance(m_i4SensorIdx,"aao_buf_mgr");
// imem driver init
m_pIMemDrv->init();
// AAO DMA buffer init
// removes all elements from the list container
m_rHwBufList.clear();
// allocate and enqueue HW buffer
for (MINT32 i = 0; i < MAX_AAO_BUFFER_CNT; i++) {
m_rAAOBufInfo[i].useNoncache = 0; // improve the performance
allocateBuf(m_rAAOBufInfo[i], m_u4AAOBufSize);
enqueueHwBuf(m_rAAOBufInfo[i]);
}
// Open isp driver
mfd = open(ISP_DEV_NAME, O_RDWR);
if (mfd < 0) {
MY_ERR("error open kernel driver, %d, %s\n", errno, strerror(errno));
return -1;
}
mpIspHwRegAddr = (unsigned long *) mmap(0, CAM_ISP_RANGE, (PROT_READ | PROT_WRITE), MAP_SHARED, mfd, cam_isp_addr);
if (mpIspHwRegAddr == MAP_FAILED) {
MY_ERR("mmap err(1), %d, %s \n", errno, strerror(errno));
return -4;
}
MY_LOG("%s() m_eSensorDev(%d) ISPAddr:0x%0x\n", __FUNCTION__, m_eSensorDev, mpIspHwRegAddr);
//DMAInit();
// Enable AA stat
//AAStatEnable(MTRUE);
debugPrint();
android_atomic_inc(&m_Users);
#endif
return MTRUE;
}
