Int32 Utils_bitbufCreate(Utils_BitBufHndl * pHndl,
Bool blockOnGet, Bool blockOnPut, UInt32 numAllocPools)
{
Int32 status;
UInt32 flags;
Int i;
flags = UTILS_QUE_FLAG_NO_BLOCK_QUE;
if (blockOnGet)
flags |= UTILS_QUE_FLAG_BLOCK_QUE_GET;
if (blockOnPut)
flags |= UTILS_QUE_FLAG_BLOCK_QUE_PUT;
for (i = 0; i < numAllocPools; i++)
{
status = Utils_queCreate(&(pHndl->emptyQue[i]),
UTILS_BUF_MAX_QUE_SIZE,
pHndl->emptyQueMem[i], flags);
UTILS_assert(status == FVID2_SOK);
}
pHndl->numAllocPools = numAllocPools;
status = Utils_queCreate(&pHndl->fullQue,
UTILS_BUF_MAX_QUE_SIZE, pHndl->fullQueMem, flags);
UTILS_assert(status == FVID2_SOK);
return status;
}
static
Void DisplayLink_drvCreateFrameInfo(DisplayLink_Obj * pObj)
{
Int32 status,i;
struct DisplayLink_FrameInfoObj *frameInfo =
&pObj->frameInfo;
UTILS_COMPILETIME_ASSERT(UTILS_ARRAYSIZE(frameInfo->infoQMem) ==
UTILS_ARRAYSIZE(frameInfo->infoMem));
status =
Utils_queCreate(&frameInfo->infoQ,
UTILS_ARRAYSIZE(frameInfo->infoQMem),
&frameInfo->infoQMem[0],
UTILS_QUE_FLAG_NO_BLOCK_QUE);
UTILS_assert(status == 0);
for (i = 0; i < UTILS_ARRAYSIZE(frameInfo->infoMem);i++)
{
DisplayLink_FrameInfo *frameInfoElem;
frameInfoElem = &frameInfo->infoMem[i];
status =
Utils_quePut(&frameInfo->infoQ,frameInfoElem,
BIOS_NO_WAIT);
UTILS_assert(status == 0);
}
return;
}
static
Void DisplayLink_drvCreateRtParams(DisplayLink_Obj * pObj)
{
Int32 status;
Int i;
UTILS_COMPILETIME_ASSERT(UTILS_ARRAYSIZE(pObj->rtParams.freeQMem)
==
UTILS_ARRAYSIZE(pObj->rtParams.paramsMem));
status =
Utils_queCreate(&pObj->rtParams.freeQ,
UTILS_ARRAYSIZE(pObj->rtParams.freeQMem),
pObj->rtParams.freeQMem,
UTILS_QUE_FLAG_NO_BLOCK_QUE);
UTILS_assert(0 == status);
for (i = 0; i < UTILS_ARRAYSIZE(pObj->rtParams.paramsMem); i++)
{
DisplayLink_drvRtParams *rtParams = &pObj->rtParams.paramsMem[i];
rtParams->dispRtPrms.inFrmPrms = &rtParams->inFrmPrms;
status = Utils_quePut(&pObj->rtParams.freeQ,
rtParams,
BIOS_NO_WAIT);
UTILS_assert(0 == status);
}
}
Int32 Utils_bufCreate(Utils_BufHndl * pHndl, Bool blockOnGet, Bool blockOnPut)
{
Int32 status;
UInt32 flags;
flags = UTILS_QUE_FLAG_NO_BLOCK_QUE;
if (blockOnGet)
flags |= UTILS_QUE_FLAG_BLOCK_QUE_GET;
if (blockOnPut)
flags |= UTILS_QUE_FLAG_BLOCK_QUE_PUT;
status = Utils_queCreate(&pHndl->emptyQue,
UTILS_BUF_MAX_QUE_SIZE, pHndl->emptyQueMem, flags);
UTILS_assert(status == FVID2_SOK);
status = Utils_queCreate(&pHndl->fullQue,
UTILS_BUF_MAX_QUE_SIZE, pHndl->fullQueMem, flags);
UTILS_assert(status == FVID2_SOK);
return status;
}
Int32 AlgLink_scdAlgCreate(AlgLink_ScdObj * pObj)
{
Int32 status;
SCD_CreatePrm *pAlgCreatePrm;
pAlgCreatePrm = &pObj->algCreatePrm;
memset(pAlgCreatePrm, 0, sizeof(*pAlgCreatePrm));
AlgLink_scdAlgResetStatistics(pObj);
pObj->processFrameCount = 0;
pObj->totalTime = 0;
pAlgCreatePrm->maxWidth = SystemUtils_align(pObj->scdCreateParams.maxStride, ALG_LINK_SIMCOP_SCD_WIDTH_ALIGN);
pAlgCreatePrm->maxHeight = pObj->scdCreateParams.maxHeight;
pAlgCreatePrm->maxPitch = pAlgCreatePrm->maxWidth;
Vps_printf(" %d: SCD: Opening algorithm ... !!!\n",
Utils_getCurTimeInMsec()
);
status = SCD_open(&pObj->algObj, pAlgCreatePrm);
UTILS_assert(status==FVID2_SOK);
Vps_printf(" %d: SCD: Opening algorithm ... DONE !!!\n",
Utils_getCurTimeInMsec()
);
AlgLink_scdAlgAllocMem(pObj);
AlgLink_scdAlgChCreate(pObj);
status = Utils_dmaCreateCh(&pObj->dmaCh, UTILS_DMA_DEFAULT_EVENT_Q, 1, TRUE);
UTILS_assert(status==FVID2_SOK);
status = Utils_queCreate(&pObj->processQ,
ALG_LINK_MAX_PROCESS_FRAMES*ALG_LINK_SIMCOP_SCD_MAX_CH,
pObj->processQMem,
UTILS_QUE_FLAG_BLOCK_QUE_GET
);
UTILS_assert(status==FVID2_SOK);
AlgLink_scdAlgProcessTskSendCmd(pObj, SYSTEM_CMD_START);
return FVID2_SOK;
}
Int32 IpcFramesInLink_create(IpcFramesInLink_Obj * pObj,
IpcFramesInLinkRTOS_CreateParams * pPrm)
{
Int32 status;
System_LinkInQueParams *pInQueParams;
Int i;
#ifdef SYSTEM_DEBUG_IPC
Vps_printf(" %d: IPC_FRAMES_IN : Create in progress !!!\n",
Utils_getCurTimeInMsec());
#endif
UTILS_MEMLOG_USED_START();
memcpy(&pObj->createArgs, pPrm, sizeof(pObj->createArgs));
status =
System_ipcListMPOpen(pObj->createArgs.baseCreateParams.inQueParams.
prevLinkId, &pObj->listMPOutHndl,
&pObj->listMPInHndl);
UTILS_assert(status == FVID2_SOK);
UTILS_assert(pObj->listMPInHndl != NULL);
while(!ListMP_empty(pObj->listMPInHndl))
{
Ptr listElem =
ListMP_getHead(pObj->listMPInHndl);
if (listElem != NULL)
{
IPCFRAMESINLINK_INFO_LOG(pObj->tskId,
"InList not empty!!!"
"Stale entry:[%p]",
listElem);
}
}
status = Utils_queCreate(&pObj->outFrameBufQue,
SYSTEM_IPC_FRAMES_MAX_LIST_ELEM,
pObj->outFrameBufQueMem,
UTILS_QUE_FLAG_NO_BLOCK_QUE);
UTILS_assert(status == FVID2_SOK);
status = Utils_queCreate(&pObj->freeFrameQue,
SYSTEM_IPC_FRAMES_MAX_LIST_ELEM,
pObj->freeFrameQueMem,
UTILS_QUE_FLAG_NO_BLOCK_QUE);
UTILS_assert(status == FVID2_SOK);
for (i = 0; i < SYSTEM_IPC_FRAMES_MAX_LIST_ELEM; i++)
{
pObj->freeFrameMem[i].appData = &pObj->freeFrameInfoMem[i];
Utils_quePut(&pObj->freeFrameQue,&pObj->freeFrameMem[i],BIOS_NO_WAIT);
}
pInQueParams = &pObj->createArgs.baseCreateParams.inQueParams;
status = System_linkGetInfo(pInQueParams->prevLinkId, &pObj->inQueInfo);
UTILS_assert(status == FVID2_SOK);
IpcFramesInLink_setOutQueInfo(pObj);
IpcFramesInLink_initStats(pObj);
IpcFramesInLink_createPrdObj(pObj);
if (TRUE == pObj->createArgs.baseCreateParams.noNotifyMode)
{
if (FALSE == pObj->prd.clkStarted)
{
IpcFramesInLink_startPrdObj(pObj,
IPC_FRAMES_IN_LINK_DONE_PERIOD_MS, FALSE);
}
}
pObj->state = IPC_FRAMES_IN_LINK_STATE_ACTIVE;
UTILS_MEMLOG_USED_END(pObj->memUsed);
UTILS_MEMLOG_PRINT("IPC_FRAMES_IN",
pObj->memUsed,
UTILS_ARRAYSIZE(pObj->memUsed));
#ifdef SYSTEM_DEBUG_IPC
Vps_printf(" %d: IPC_FRAMES_IN : Create Done !!!\n", Utils_getCurTimeInMsec());
#endif
return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
Int32 IpcOutM3Link_create(IpcOutM3Link_Obj * pObj, IpcLink_CreateParams * pPrm)
{
Int32 status, elemId;
System_LinkInQueParams *pInQueParams;
System_LinkQueInfo *pInQueInfo;
IpcOutM3Link_ChObj *pChObj;
UInt32 chId;
#ifdef SYSTEM_DEBUG_IPC
Vps_printf(" %d: IPC_OUT_M3 : Create in progress !!!\n",
Utils_getCurTimeInMsec());
#endif
pObj->totalFrameCount = 0;
memcpy(&pObj->createArgs, pPrm, sizeof(pObj->createArgs));
status = System_ipcListMPReset(pObj->listMPOutHndl, pObj->listMPInHndl);
UTILS_assert(status == FVID2_SOK);
status = Utils_queCreate(&pObj->listElemQue,
SYSTEM_IPC_M3_MAX_LIST_ELEM,
pObj->listElemQueMem, UTILS_QUE_FLAG_NO_BLOCK_QUE);
UTILS_assert(status == FVID2_SOK);
for (elemId = 0; elemId < SYSTEM_IPC_M3_MAX_LIST_ELEM; elemId++)
{
status =
Utils_quePut(&pObj->listElemQue, pObj->listElem[elemId],
BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
}
pInQueParams = &pObj->createArgs.inQueParams;
status = System_linkGetInfo(pInQueParams->prevLinkId, &pObj->inQueInfo);
UTILS_assert(status == FVID2_SOK);
pInQueInfo =
&pObj->inQueInfo.queInfo[
pObj->createArgs.inQueParams.prevLinkQueId
];
UTILS_assert(pInQueInfo->numCh <= IPC_OUTM3_LINK_MAX_CH);
/* set number of input / output channels */
pObj->numCh = pInQueInfo->numCh;
IpcOutM3Link_createPrdObj(pObj);
IpcOutM3Link_resetStatistics(pObj);
for (chId = 0; chId < pObj->numCh; chId++)
{
pChObj = &pObj->chObj[chId];
pChObj->frameSkipCtx.firstTime = TRUE;
pChObj->frameSkipCtx.inputFrameRate = pObj->createArgs.inputFrameRate;
pChObj->frameSkipCtx.outputFrameRate = pObj->createArgs.outputFrameRate;
}
#ifdef SYSTEM_DEBUG_IPC
Vps_printf(" %d: IPC_OUT_M3 : Create Done !!!\n", Utils_getCurTimeInMsec());
#endif
return FVID2_SOK;
}
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;
pChObj->scdMode = ALG_LINK_SCD_DETECTMODE_DISABLE;
}
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->scdMode = ALG_LINK_SCD_DETECTMODE_MONITOR_FULL_FRAME;
pChObj->algReset = TRUE;
pChObj->skipInitialFrames = TRUE;
pChObj->startTime = 0;
pChObj->width = SystemUtils_floor(pChInfo->width, ALG_LINK_SIMCOP_SCD_WIDTH_ALIGN);
pChObj->height = pChInfo->height;
pChObj->rtPrmUpdate = FALSE;
if(pChObj->width>pObj->algCreatePrm.maxWidth)
pChObj->width = pObj->algCreatePrm.maxWidth;
if(pChObj->height>pObj->algCreatePrm.maxHeight)
pChObj->height = pObj->algCreatePrm.maxHeight;
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;
pChObj->algProcessPrm.width = pChObj->width;
pChObj->algProcessPrm.height = pChObj->height;
pChObj->algProcessPrm.pitch = SystemUtils_align(pChInfo->width, ALG_LINK_SIMCOP_SCD_WIDTH_ALIGN);
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 = pChObj->algProcessPrm.width;
pChObj->algInitMeanVarMHIPrm.height = pChObj->algProcessPrm.height;
pChObj->algInitMeanVarMHIPrm.pitch = pChObj->algProcessPrm.pitch;
pChObj->algInitMeanVarMHIPrm.pAlgImageBuf = &pChObj->algTmpImageBufs;
pChObj->algInitMeanVarMHIPrm.inAddr = NULL;
for(blockId=0; blockId<pObj->algPerChMemAllocPrm.numMemBlocks; blockId++)
{
#ifdef SYSTEM_VERBOSE_PRINTS
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]
);
#endif
pChObj->memBlockAddr[blockId] =
Utils_memAlloc(
pObj->algPerChMemAllocPrm.memBlockSize[blockId],
pObj->algPerChMemAllocPrm.memBlockAlign[blockId]
);
UTILS_assert(pChObj->memBlockAddr[blockId]!=NULL);
#ifdef SYSTEM_VERBOSE_PRINTS
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]
);
#endif
}
pChObj->algTmpImageBufs.pBkgrdMeanSQ8_7 = pChObj->memBlockAddr[0];
pChObj->algTmpImageBufs.pBkgrdVarianceSQ12_3= pChObj->memBlockAddr[1];
pChObj->algTmpImageBufs.pMHIimageUQ8_0 = pChObj->memBlockAddr[2];
{
FVID2_Frame *pFrame;
UInt32 frameId;
Int32 status;
pChObj->pPrevProcessFrame = NULL;
status = Utils_queCreate(&pChObj->freeQ,
ALG_LINK_MAX_PROCESS_FRAMES,
pChObj->freeQMem,
UTILS_QUE_FLAG_NO_BLOCK_QUE
);
UTILS_assert(status==FVID2_SOK);
pChObj->processFrameSize = pChObj->algProcessPrm.pitch*pChObj->algProcessPrm.height;
/* alloc channel process buffer memory */
for(frameId=0; frameId<ALG_LINK_MAX_PROCESS_FRAMES; frameId++)
{
pFrame = &pChObj->processFrames[frameId];
pFrame->addr[0][0] =
Utils_memAlloc(
pChObj->processFrameSize,
VPS_BUFFER_ALIGNMENT
);
UTILS_assert(pFrame->addr[0][0]!=NULL);
status = Utils_quePut(&pChObj->freeQ, pFrame, BIOS_NO_WAIT);
UTILS_assert(status==FVID2_SOK);
}
}
}
return FVID2_SOK;
}
