Int32 System_ipcMsgQCreate()
{
UInt32 i;
UInt32 procId;
Int32 status;
Int32 retryCount;
MessageQ_Params msgQParams;
char msgQName[64];
char ackMsgQName[64];
i=0;
while(gSystem_ipcMsgQEnableProcId[i]!=SYSTEM_PROC_MAX)
{
procId = gSystem_ipcMsgQEnableProcId[i];
if (procId != SYSTEM_PROC_INVALID)
{
System_ipcGetMsgQName(procId, msgQName, ackMsgQName);
if(procId==System_getSelfProcId())
{
/* create MsgQ */
MessageQ_Params_init(&msgQParams);
/* printf(" %u: SYSTEM: Creating MsgQ [%s] ...\n",
OSA_getCurTimeInMsec(),
msgQName
);
*/
gSystem_ipcObj.selfMsgQ = MessageQ_create(msgQName, &msgQParams);
UTILS_assert(gSystem_ipcObj.selfMsgQ!=NULL);
MessageQ_Params_init(&msgQParams);
/* printf(" %u: SYSTEM: Creating MsgQ [%s] ...\n",
OSA_getCurTimeInMsec(),
ackMsgQName
);
*/
gSystem_ipcObj.selfAckMsgQ = MessageQ_create(ackMsgQName, &msgQParams);
UTILS_assert(gSystem_ipcObj.selfMsgQ!=NULL);
}
else
{
/* open MsgQ */
retryCount=10;
while(retryCount)
{
// printf(" %u: SYSTEM: Opening MsgQ [%s] ...\n",
// OSA_getCurTimeInMsec(),
// msgQName
// );
status = MessageQ_open(msgQName, &gSystem_ipcObj.remoteProcMsgQ[procId]);
if(status==MessageQ_E_NOTFOUND)
OSA_waitMsecs(1000);
else
if(status==MessageQ_S_SUCCESS)
break;
retryCount--;
if(retryCount<=0)
UTILS_assert(0);
}
/* no need to open ack msgq,
since ack msgq id is embeeded in the received message
*/
}
}
i++;
}
return OSA_SOK;
}
Void *System_ipcMsgQTaskMain(Void *arg)
{
UInt32 prmSize;
SystemIpcMsgQ_Msg *pMsgCommon;
Void *pPrm;
Int32 status;
while(1)
{
status = MessageQ_get(gSystem_ipcObj.selfMsgQ, (MessageQ_Msg*)&pMsgCommon, OSA_TIMEOUT_FOREVER);
if(status==MessageQ_E_UNBLOCKED)
break;
if(status!=MessageQ_S_SUCCESS)
{
printf(" %u: MSGQ: MsgQ get failed !!!\n",
OSA_getCurTimeInMsec()
);
continue;
}
#if 0
printf(" %u: MSGQ: Received command [0x%04x] (prmSize = %d) for [%s][%02d] (waitAck=%d)\n",
OSA_getCurTimeInMsec(),
pMsgCommon->cmd,
pMsgCommon->prmSize,
MultiProc_getName(SYSTEM_GET_PROC_ID(pMsgCommon->linkId)),
SYSTEM_GET_LINK_ID(pMsgCommon->linkId),
pMsgCommon->waitAck
);
#endif
prmSize = pMsgCommon->prmSize;
pPrm = SYSTEM_IPC_MSGQ_MSG_PAYLOAD_PTR(pMsgCommon);
if(pMsgCommon->cmd==SYSTEM_CMD_GET_INFO)
{
UTILS_assert(prmSize == sizeof(System_LinkInfo));
pMsgCommon->status = System_linkGetInfo_local(pMsgCommon->linkId, pPrm);
}
else
{
pMsgCommon->status = System_linkControl_local(
pMsgCommon->linkId,
pMsgCommon->cmd,
pPrm,
prmSize,
pMsgCommon->waitAck
);
}
if(pMsgCommon->waitAck)
{
MessageQ_QueueId replyMsgQ;
replyMsgQ = MessageQ_getReplyQueue(pMsgCommon);
status = MessageQ_put(replyMsgQ, (MessageQ_Msg)pMsgCommon);
if(status!=MessageQ_S_SUCCESS)
{
printf(" %u: MSGQ: MsgQ Ack put failed !!!\n",
OSA_getCurTimeInMsec()
);
MessageQ_free((MessageQ_Msg)pMsgCommon);
}
}
else
{
MessageQ_free((MessageQ_Msg)pMsgCommon);
}
}
return NULL;
}
Int32 Audio_captureCreate (Void)
{
Int32 status = AUDIO_STATUS_OK;
#ifdef USE_DEFAULT_STORAGE_PATH
Int8 i;
Int8 dirName[256];
Uint8 len;
#endif
/* TVP5158 CAPTURED AUDIO DATA MAPPING*/
/* Audio data captured from the TVP5158 are interleaved*/
/* TVP5158 Daughter card has following configuration for Audio Input (Hardware pins
--------------------------------------------------------------------------------------
| AIN15 | AIN13 | AIN11 | AIN9 | AIN7 | AIN5 | AIN3 | AIN1 |
--------------------------------------------------------------------------------------
| AIN16 | AIN14 | AIN12 | AIN10 | AIN8 | AIN6 | AIN4 | AIN2 |
--------------------------------------------------------------------------------------
*/
#if (AUDIO_MAX_CHANNELS==4)
/*
Channel Mapping for 4-channels audio capture
<-----------------64bits----------------->
<-16bits->
--------------------------------------------
| S16-0 | S16-1 | S16-2 | S16-3 |
--------------------------------------------
| AIN 3 | AIN 0 | AIN 2 | AIN 1 |
--------------------------------------------
*/
audioPhyToDataIndexMap[0] = 1;
audioPhyToDataIndexMap[1] = 3;
audioPhyToDataIndexMap[2] = 2;
audioPhyToDataIndexMap[3] = 0;
#else
/*
Channel Mapping for 16-channels audio capture
<---------------------------------------------------------------------------------256bits------------------------------------------------------------------------------------>
<-16bits->
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| S16-0 | S16-1 | S16-2 | S16-3 | S16-4 | S16-5 | S16-6 | S16-7 | S16-8 | S16-9 | S16-10 | S16-11 | S16-12 | S16-13 | S16-14 | S16-15 |
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
AIN 16 | AIN 1 | AIN 3 | AIN 5 | AIN 7 | AIN 9 | AIN 11 | AIN 13 | AIN 15 | AIN 2 | AIN 4 | AIN 6 | AIN 8 | AIN 10 | AIN 12 | AIN 14 |
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
audioPhyToDataIndexMap[0] =7; //1;
audioPhyToDataIndexMap[1] =15;// 9;
audioPhyToDataIndexMap[2] =8;// 2;
audioPhyToDataIndexMap[3] =0; //10;
audioPhyToDataIndexMap[4] = 5;//3;
audioPhyToDataIndexMap[5] =13; //11;
audioPhyToDataIndexMap[6] = 6;//4;
audioPhyToDataIndexMap[7] = 14;//12;
audioPhyToDataIndexMap[8] = 3;//5;
audioPhyToDataIndexMap[9] = 11;//13;
audioPhyToDataIndexMap[10] = 4;//6;
audioPhyToDataIndexMap[11] = 12;//14;
audioPhyToDataIndexMap[12] =1;//7;
audioPhyToDataIndexMap[13] =9; //15;
audioPhyToDataIndexMap[14] =2;//8;
audioPhyToDataIndexMap[15] =10; //0;*/
/* audioPhyToDataIndexMap[0] =1;
audioPhyToDataIndexMap[1] = 9;
audioPhyToDataIndexMap[2] = 2;
audioPhyToDataIndexMap[3] =10;
audioPhyToDataIndexMap[4] = 3;
audioPhyToDataIndexMap[5] =11;
audioPhyToDataIndexMap[6] = 4;
audioPhyToDataIndexMap[7] = 12;
audioPhyToDataIndexMap[8] = 5;
audioPhyToDataIndexMap[9] = 13;
audioPhyToDataIndexMap[10] = 6;
audioPhyToDataIndexMap[11] = 14;
audioPhyToDataIndexMap[12] = 7;
audioPhyToDataIndexMap[13] =15;
audioPhyToDataIndexMap[14] = 8;
audioPhyToDataIndexMap[15] =0;*/
#endif
strcpy(audioPath, "");
#ifdef USE_DEFAULT_STORAGE_PATH
strcpy(audioPath, "/home/audio");
if(-1 == access(audioPath, 0))
{
remove(audioPath);
if( 0 != mkdir(audioPath, 0755))
{
printf ("\nAUDIO [%d] >> Audio storage dir %s not created - audio recording not possible.....\n", __LINE__, audioPath);
return AUDIO_STATUS_EFAIL;
}
}
for (i=0; i<AUDIO_MAX_CHANNELS; i++)
{
strcpy(dirName, audioPath);
len = strlen(dirName);
sprintf (&dirName[len], "/%02d", i + 1);
if(-1 == access((char *) dirName, 0))
{
if( 0 != mkdir((char *) dirName, 0755))
{
printf ("\nAUDIO [%d] >> Audio storage dir %s not created - audio recording not possible.....\n", __LINE__, dirName);
return AUDIO_STATUS_EFAIL;
}
}
}
#endif
status = Audio_thrCreate(
&captureThrHandle,
(ThrEntryFunc) Audio_recordMain,
AUDIO_CAPTURE_TSK_PRI,
AUDIO_CAPTURE_TSK_STACK_SIZE
);
printf ("\n Audio capture task created");
UTILS_assert( status==AUDIO_STATUS_OK);
return status;
}
Int32 AlgLink_scdAlgChCreate(AlgLink_ScdObj * pObj)
{
AlgLink_ScdChObj *pChObj;
AlgLink_ScdCreateParams *pCreateArgs;
AlgLink_ScdChParams *pChPrm;
System_LinkChInfo *pChInfo;
UInt32 blockId, chId, i;
pCreateArgs = &pObj->scdCreateParams;
for(chId=0; chId<ALG_LINK_SIMCOP_SCD_MAX_CH; chId++)
{
pChObj = &pObj->chObj[chId];
memset(pChObj, 0, sizeof(*pChObj));
pChObj->enableScd = FALSE;
}
for(i=0; i<pCreateArgs->numValidChForSCD; i++)
{
pChPrm = &pCreateArgs->chDefaultParams[i];
chId = pChPrm->chId;
pChObj = &pObj->chObj[chId];
pChInfo = &pObj->inQueInfo->chInfo[chId];
pChObj->enableScd = TRUE;
pChObj->skipInitialFrames = TRUE;
pChObj->startTime = 0;
pChObj->isTiledMode = FALSE;
if(pChInfo->memType==SYSTEM_MT_TILEDMEM)
pChObj->isTiledMode = TRUE;
pChObj->frameSkipContext.inputFrameRate = pCreateArgs->inputFrameRate;
pChObj->frameSkipContext.outputFrameRate = pCreateArgs->outputFrameRate;
pChObj->frameSkipContext.firstTime = TRUE;
pChObj->chId = pChPrm->chId;
pChObj->scdStatus = ALG_LINK_SCD_DETECTOR_UNAVAILABLE;
pChObj->prevScdStatus = ALG_LINK_SCD_DETECTOR_UNAVAILABLE;
pChObj->algProcessPrm.chanId = chId;
/* need 32 pixel alignment for SCD */
pChObj->algProcessPrm.width = SystemUtils_floor(pChInfo->width, 16);
pChObj->algProcessPrm.height = pChInfo->height;
pChObj->algProcessPrm.pitch = pChInfo->pitch[0];
pChObj->algProcessPrm.mode = SCD_DETECTMODE_MONITOR_FULL_FRAME;
pChObj->algProcessPrm.frmSensitivity = (SCD_Sensitivity)pChPrm->frmSensitivity;
pChObj->algProcessPrm.frmIgnoreLightsON = pChPrm->frmIgnoreLightsON;
pChObj->algProcessPrm.frmIgnoreLightsOFF = pChPrm->frmIgnoreLightsOFF;
pChObj->algProcessPrm.fps = SCD_FPS_05;
pChObj->algProcessPrm.pAlgImageBuf = &pChObj->algTmpImageBufs;
pChObj->algProcessPrm.inAddr = NULL;
pChObj->algProcessPrm.prevInAddr = NULL;
pChObj->algProcessPrm.numSecs2WaitAfterFrmAlert = pCreateArgs->numSecs2WaitAfterFrmAlert;
pChObj->algInitMeanVarMHIPrm.chanId = chId;
pChObj->algInitMeanVarMHIPrm.width = pChInfo->width;
pChObj->algInitMeanVarMHIPrm.height = pChInfo->height;
pChObj->algInitMeanVarMHIPrm.pitch = pChInfo->pitch[0];
pChObj->algInitMeanVarMHIPrm.pAlgImageBuf = &pChObj->algTmpImageBufs;
pChObj->algInitMeanVarMHIPrm.inAddr = NULL;
for(blockId=0; blockId<pObj->algPerChMemAllocPrm.numMemBlocks; blockId++)
{
Vps_printf(" %d: SCD: CH%d: MEM REQUEST %d: of size %d B (align=%d)\n",
Utils_getCurTimeInMsec(),
chId,
blockId,
pObj->algPerChMemAllocPrm.memBlockSize[blockId],
pObj->algPerChMemAllocPrm.memBlockAlign[blockId]
);
pChObj->memBlockAddr[blockId] =
Utils_memAlloc(
pObj->algPerChMemAllocPrm.memBlockSize[blockId],
pObj->algPerChMemAllocPrm.memBlockAlign[blockId]
);
UTILS_assert(pChObj->memBlockAddr[blockId]!=NULL);
Vps_printf(" %d: SCD: CH%d: MEM ALLOC %d: @ 0x%08x of size %d B (align=%d)\n",
Utils_getCurTimeInMsec(),
chId,
blockId,
pChObj->memBlockAddr[blockId],
pObj->algPerChMemAllocPrm.memBlockSize[blockId],
pObj->algPerChMemAllocPrm.memBlockAlign[blockId]
);
}
pChObj->algTmpImageBufs.pBkgrdMeanSQ8_7 = pChObj->memBlockAddr[0];
pChObj->algTmpImageBufs.pBkgrdVarianceSQ12_3= pChObj->memBlockAddr[1];
pChObj->algTmpImageBufs.pMHIimageUQ8_0 = pChObj->memBlockAddr[2];
pChObj->algTmpImageBufs.pUpdateMaskMHIUQ8_0 = pChObj->memBlockAddr[3];
}
return FVID2_SOK;
}
Int32 AlgLink_ScdalgCreate(AlgLink_ScdObj * pObj)
{
Int32 status, chId, scdChId;
SCD_createPrm algCreatePrm;
SCD_chPrm chDefaultParams[16];
AlgLink_ScdChParams *pChLinkPrm;
AlgLink_ScdchPrm *pScdChPrm;
IALG_Fxns *algFxns = (IALG_Fxns *)&SCD_TI;
// IRES_Fxns *resFxns = &SCD_TI_IRES;
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : Create in progress !!!\n",
Utils_getCurTimeInMsec());
#endif
pObj->totalFrameCount = 0;
if(pObj->createArgs.numBufPerCh == 0)
pObj->createArgs.numBufPerCh = ALG_LINK_SCD_MAX_OUT_FRAMES_PER_CH;
if(pObj->createArgs.numBufPerCh > ALG_LINK_SCD_MAX_OUT_FRAMES_PER_CH)
{
Vps_printf("\n SCDLINK: WARNING: User is asking for %d buffers per CH. But max allowed is %d. \n"
" Over riding user requested with max allowed \n\n",
pObj->createArgs.numBufPerCh, ALG_LINK_SCD_MAX_OUT_FRAMES_PER_CH
);
pObj->createArgs.numBufPerCh = ALG_LINK_SCD_MAX_OUT_FRAMES_PER_CH;
}
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : Max WxH = %d x %d, Max CH = %d, FPS = %d !!!\n",
Utils_getCurTimeInMsec(),
pObj->createArgs.maxWidth,
pObj->createArgs.maxHeight,
//pObj->createArgs.startChNoForSCD,
pObj->createArgs.numValidChForSCD,
pObj->createArgs.outputFrameRate
);
#endif
if( pObj->createArgs.numValidChForSCD > pObj->inQueInfo->numCh)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : Create ERROR - SCD channels < InQueue Channels !!!\n",
Utils_getCurTimeInMsec());
#endif
return FVID2_EFAIL;
}
algCreatePrm.maxWidth = pObj->createArgs.maxWidth;
algCreatePrm.maxHeight = pObj->createArgs.maxHeight;
algCreatePrm.maxStride = pObj->createArgs.maxStride;
algCreatePrm.maxChannels = pObj->createArgs.numValidChForSCD;
algCreatePrm.numSecs2WaitB4Init = pObj->createArgs.numSecs2WaitB4Init;
algCreatePrm.numSecs2WaitB4FrmAlert = pObj->createArgs.numSecs2WaitB4FrmAlert;
algCreatePrm.numSecs2WaitAfterFrmAlert = pObj->createArgs.numSecs2WaitAfterFrmAlert;
algCreatePrm.fps = (SCD_Fps) pObj->createArgs.outputFrameRate;
algCreatePrm.chDefaultParams = (SCD_chPrm *)&chDefaultParams[0];
for(chId=0; chId < algCreatePrm.maxChannels; chId++)
{
SCD_chPrm * chl = &(algCreatePrm.chDefaultParams[chId]);
AlgLink_ScdChParams * chPrm = &(pObj->createArgs.chDefaultParams[chId]);
if ((chPrm->mode == SCD_DETECTMODE_MONITOR_BLOCKS) ||
(chPrm->mode == SCD_DETECTMODE_MONITOR_BLOCKS_FRAME))
{
Vps_printf("Setting block configuration data \n");
chl->blkConfig = (SCD_blkChngConfig *)chPrm->blkConfig;
/*
for (blk=0; blk < chPrm->blkNumBlksInFrame; blk++)
{
chl->blkConfig[blk].sensitivity = (SCD_Sensitivity) chPrm->blkConfig[blk].sensitivity;
chl->blkConfig[blk].monitored = (UInt32) chPrm->blkConfig[blk].monitored;
}
*/
}
else
{
chl->blkConfig = NULL;
}
// The remaining parameter values filled in here do not really matter as
// they will be over-written by calls to SCD_TI_setPrms. We'll fill in
// just a few
chl->chId = chPrm->chId;
chl->mode = (SCD_Mode)chPrm->mode;
chl->width = pObj->createArgs.maxWidth;
chl->height = pObj->createArgs.maxHeight;
chl->stride = pObj->createArgs.maxStride;
chl->curFrame = NULL;
chl->frmSensitivity = (SCD_Sensitivity)chPrm->frmSensitivity;
chl->frmIgnoreLightsON = chPrm->frmIgnoreLightsON;
chl->frmIgnoreLightsOFF = chPrm->frmIgnoreLightsOFF;
chl->frmEdgeThreshold = chPrm->frmEdgeThreshold;
}
/* Create algorithm instance and get algo handle */
pObj->algHndl = DSKT2_createAlg((Int)gScratchId,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)&algCreatePrm);
if(pObj->algHndl == NULL)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : Create ERROR !!!\n",
Utils_getCurTimeInMsec());
#endif
return FVID2_EFAIL;
}
#if 0
/* Assign resources to the algorithm */
status = RMAN_assignResources((IALG_Handle)pObj->algHndl, resFxns, gScratchId);
if (status != IRES_OK) {
return FVID2_EFAIL;
}
#endif
for(scdChId = 0; scdChId<pObj->createArgs.numValidChForSCD; scdChId++)
{
pScdChPrm = &pObj->chParams[scdChId];
pChLinkPrm = &pObj->createArgs.chDefaultParams[scdChId];
pObj->chObj[scdChId].frameSkipCtx.firstTime = TRUE;
pObj->chObj[scdChId].frameSkipCtx.inputFrameRate = pObj->createArgs.inputFrameRate;
pObj->chObj[scdChId].frameSkipCtx.outputFrameRate = pObj->createArgs.outputFrameRate;
pObj->chObj[scdChId].scdChStat = ALG_LINK_SCD_DETECTOR_UNAVAILABLE;
pObj->chObj[scdChId].chId = pChLinkPrm->chId;
pScdChPrm->chId = pChLinkPrm->chId;
pScdChPrm->chBlkConfigUpdate = FALSE;
status = AlgLink_ScdalgSetChScdPrm(pScdChPrm, pChLinkPrm);
UTILS_assert(status==0);
pScdChPrm->width = pObj->inQueInfo->chInfo[pScdChPrm->chId].width +
pObj->inQueInfo->chInfo[pScdChPrm->chId].startX;
pScdChPrm->height = pObj->inQueInfo->chInfo[pScdChPrm->chId].height +
pObj->inQueInfo->chInfo[pScdChPrm->chId].startY;
pScdChPrm->stride = pObj->inQueInfo->chInfo[pScdChPrm->chId].pitch[0];
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : %d: %d x %d, In FPS = %d, Out FPS = %d!!!\n",
Utils_getCurTimeInMsec(),
pScdChPrm->chId,
pScdChPrm->width,
pScdChPrm->height,
pObj->chObj[scdChId].frameSkipCtx.inputFrameRate,
pObj->chObj[scdChId].frameSkipCtx.outputFrameRate
);
#endif
}
AlgLink_ScdresetStatistics(pObj);
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : Create Done !!!\n",
Utils_getCurTimeInMsec());
#endif
return FVID2_SOK;
}
Int32 System_ipcListMPOpen(UInt32 linkId, ListMP_Handle *pOutHndl, ListMP_Handle *pInHndl)
{
Int32 retryCount;
Int32 status;
char listMPOutName[64];
char listMPInName[64];
status = System_ipcGetListMPName(linkId, listMPOutName, listMPInName);
UTILS_assert(status==OSA_SOK);
retryCount = 10;
while(retryCount)
{
OSA_printf(" %u: SYSTEM: Opening ListMP [%s] ...\n",
OSA_getCurTimeInMsec(),
listMPOutName
);
status = ListMP_open(listMPOutName, pOutHndl);
if(status==ListMP_E_NOTFOUND)
{
OSA_printf("%s:ListMP not found",listMPOutName);
OSA_waitMsecs(1000);
}
else
{
if(status==ListMP_E_FAIL)
{
UTILS_assert(0);
}
else
{
if(status==ListMP_S_SUCCESS)
break;
}
}
retryCount--;
if(retryCount<=0)
UTILS_assert(0);
}
retryCount = 10;
while(retryCount)
{
printf(" %u: SYSTEM: Opening ListMP [%s] ...\n",
OSA_getCurTimeInMsec(),
listMPInName
);
status = ListMP_open(listMPInName, pInHndl);
if(status==ListMP_E_NOTFOUND)
OSA_waitMsecs(1000);
else
if(status==ListMP_E_FAIL)
{
UTILS_assert(0);
}
else
if(status==ListMP_S_SUCCESS)
break;
retryCount--;
if(retryCount<=0)
UTILS_assert(0);
}
return status;
}
Int32 Utils_tilerFrameAlloc(FVID2_Format * pFormat,
FVID2_Frame * pFrame, UInt16 numFrames)
{
UInt32 frameId;
/* align height to multiple of 2 */
pFormat->height = VpsUtils_align(pFormat->height, 2);
for (frameId = 0; frameId < numFrames; frameId++)
{
/* init FVID2_Frame to 0's */
memset(pFrame, 0, sizeof(*pFrame));
/* copy channelNum to FVID2_Frame from FVID2_Format */
pFrame->channelNum = pFormat->channelNum;
switch (pFormat->dataFormat)
{
case FVID2_DF_YUV422SP_UV:
/* Y plane */
pFrame->addr[0][0] =
(Ptr) SystemTiler_alloc(SYSTEM_TILER_CNT_8BIT,
pFormat->width, pFormat->height);
UTILS_assert((UInt32)(pFrame->addr[0][0]) != SYSTEM_TILER_INVALID_ADDR);
/* C plane */
pFrame->addr[0][1] =
(Ptr) SystemTiler_alloc(SYSTEM_TILER_CNT_16BIT,
pFormat->width, pFormat->height);
UTILS_assert((UInt32)(pFrame->addr[0][1]) != SYSTEM_TILER_INVALID_ADDR);
break;
case FVID2_DF_YUV420SP_UV:
/* Y plane */
pFrame->addr[0][0] =
(Ptr) SystemTiler_alloc(SYSTEM_TILER_CNT_8BIT,
pFormat->width, pFormat->height);
if ((UInt32)pFrame->addr[0][0] == SYSTEM_TILER_INVALID_ADDR)
System_memPrintHeapStatus();
UTILS_assert((UInt32)(pFrame->addr[0][0]) != SYSTEM_TILER_INVALID_ADDR);
/* C plane */
pFrame->addr[0][1] =
(Ptr) SystemTiler_alloc(SYSTEM_TILER_CNT_16BIT,
pFormat->width,
pFormat->height / 2);
if ((UInt32)pFrame->addr[0][1] == SYSTEM_TILER_INVALID_ADDR)
System_memPrintHeapStatus();
UTILS_assert((UInt32)(pFrame->addr[0][1]) != SYSTEM_TILER_INVALID_ADDR);
break;
default:
UTILS_assert(0);
break;
}
pFrame++;
}
return 0;
}
static Int32 AlgLink_createOutObj(AlgLink_Obj * pObj)
{
AlgLink_OutObj *pOutObj;
System_LinkChInfo *pOutChInfo;
Int32 status;
UInt32 bufIdx;
Int i,j,queueId,chId;
UInt32 totalBufCnt;
for(queueId = 0; queueId < ALG_LINK_MAX_OUT_QUE; queueId++)
{
pOutObj = &pObj->outObj[queueId];
pObj->outObj[queueId].numAllocPools = 1;
pOutObj->buf_size[0] = UTILS_SCD_GET_OUTBUF_SIZE();
pOutObj->buf_size[0] =
VpsUtils_align(pOutObj->buf_size[0],
SharedRegion_getCacheLineSize(SYSTEM_IPC_SR_CACHED));
status = Utils_bitbufCreate(&pOutObj->bufOutQue, TRUE, FALSE,
pObj->outObj[queueId].numAllocPools);
UTILS_assert(status == FVID2_SOK);
totalBufCnt = 0;
for (i = 0; i < pOutObj->numAllocPools; i++)
{
pOutObj->outNumBufs[i] = (pObj->scdAlg.createArgs.numValidChForSCD * pObj->scdAlg.createArgs.numBufPerCh);
for (j = 0; j < pObj->scdAlg.createArgs.numValidChForSCD; j++)
{
pOutObj->ch2poolMap[j] = i;
}
status = Utils_memBitBufAlloc(&(pOutObj->outBufs[totalBufCnt]),
pOutObj->buf_size[i],
pOutObj->outNumBufs[i]);
UTILS_assert(status == FVID2_SOK);
for (bufIdx = 0; bufIdx < pOutObj->outNumBufs[i]; bufIdx++)
{
UTILS_assert((bufIdx + totalBufCnt) < ALG_LINK_SCD_MAX_OUT_FRAMES);
pOutObj->outBufs[bufIdx + totalBufCnt].allocPoolID = i;
pOutObj->outBufs[bufIdx + totalBufCnt].doNotDisplay =
FALSE;
status =
Utils_bitbufPutEmptyBuf(&pOutObj->bufOutQue,
&pOutObj->outBufs[bufIdx +
totalBufCnt]);
UTILS_assert(status == FVID2_SOK);
}
/* align size to minimum required frame buffer alignment */
totalBufCnt += pOutObj->outNumBufs[i];
}
}
pObj->info.numQue = ALG_LINK_MAX_OUT_QUE;
for (queueId = 0u; queueId < ALG_LINK_MAX_OUT_QUE; queueId++)
{
pObj->info.queInfo[queueId].numCh = pObj->inQueInfo.numCh;
}
for (chId = 0u; chId < pObj->inQueInfo.numCh; chId++)
{
for (queueId = 0u; queueId < ALG_LINK_MAX_OUT_QUE; queueId++)
{
pOutChInfo = &pObj->info.queInfo[queueId].chInfo[chId];
pOutChInfo->bufType = SYSTEM_BUF_TYPE_VIDBITSTREAM;
pOutChInfo->codingformat = NULL;
pOutChInfo->memType = NULL;
pOutChInfo->scanFormat = pObj->inQueInfo.chInfo[chId].scanFormat;
pOutChInfo->width = pObj->inQueInfo.chInfo[chId].width;
pOutChInfo->height = pObj->inQueInfo.chInfo[chId].height;
}
}
return (status);
}
Int32 Utils_memBitBufAlloc(Bitstream_Buf * pBuf, UInt32 size, UInt16 numFrames)
{
UInt32 bufId;
Int32 status = 0;
UInt8 *pBaseAddr;
Error_Block ebObj;
Error_Block *eb = &ebObj;
Error_init(eb);
/* init Bitstream_Buf to 0's */
memset(pBuf, 0, sizeof(*pBuf));
/* align size to minimum required frame buffer alignment */
size = VpsUtils_align(size, IVACODEC_VDMA_BUFFER_ALIGNMENT);
/* allocate the memory for 'numFrames' */
/* for all 'numFrames' memory is contigously allocated */
pBaseAddr = Memory_alloc(gUtils_heapMemHandle[UTILS_MEM_VID_BITS_BUF_HEAP],
(size * numFrames), IVACODEC_VDMA_BUFFER_ALIGNMENT, eb);
#ifdef UTILS_MEM_DEBUG
Vps_printf(" UTILS: MEM: BITS ALLOC, addr = 0x%08x, size = %d bytes\n", pBaseAddr, (size * numFrames));
#endif
if (!Error_check(eb)
&&
(pBaseAddr != NULL)
&&
gUtils_memClearBuf[UTILS_MEM_VID_BITS_BUF_HEAP])
memset(pBaseAddr, 0x80, (size * numFrames));
if (pBaseAddr == NULL)
{
status = -1; /* Error in
* allocation,
* exit with error
*/
}
if (!UTILS_ISERROR(status))
{
/* init memory pointer for 'numFrames' */
for (bufId = 0; bufId < numFrames; bufId++)
{
/* copy channelNum to Bitstream_Buf from FVID2_Format */
pBuf->channelNum = bufId;
pBuf->addr = pBaseAddr;
/* On the RTOS side, we assume Virtual addr == PhyAddr */
pBuf->phyAddr = (UInt32)pBaseAddr;
pBuf->bufSize = size;
/* go to next frame */
pBuf++;
/* increment base address */
pBaseAddr += size;
}
}
UTILS_assert(status == 0);
return status;
}
