Int32 AlgLink_scdAlgSubmitFrame(AlgLink_ScdObj * pObj, AlgLink_ScdChObj *pChObj, FVID2_Frame *pFrame)
{
FVID2_Frame *pEmptyFrame;
System_LinkChInfo *pChInfo;
Utils_DmaCopy2D dmaPrm;
Int32 status;
pEmptyFrame = NULL;
Utils_queGet(&pChObj->freeQ, (Ptr*)&pEmptyFrame, 1, BIOS_NO_WAIT);
if(pEmptyFrame==NULL)
{
/* no free available for SCD, so skipping this frame */
pChObj->inFrameSkipCount++;
return FVID2_SOK;
}
/* found a free frame, do DMA copy of Y data to this frame */
pChInfo = &pObj->inQueInfo->chInfo[pFrame->channelNum];
dmaPrm.destAddr[0] = pEmptyFrame->addr[0][0];
dmaPrm.destPitch[0] = pChObj->algProcessPrm.pitch;
dmaPrm.srcAddr[0] = pFrame->addr[0][0];
dmaPrm.srcPitch[0] = pChInfo->pitch[0];
/* need to transfer only Y data, so set data format as 422I and set width = actual width / 2 */
dmaPrm.dataFormat = FVID2_DF_YUV422I_YUYV;
dmaPrm.srcStartX = 0;
dmaPrm.srcStartY = 0;
dmaPrm.destStartX = 0;
dmaPrm.destStartY = 0;
dmaPrm.width = pChObj->width/2;
dmaPrm.height = pChObj->height;
status = Utils_dmaCopy2D(&pObj->dmaCh, &dmaPrm, 1);
UTILS_assert(status==FVID2_SOK);
pEmptyFrame->channelNum = pFrame->channelNum;
status = Utils_quePut(&pObj->processQ, pEmptyFrame, BIOS_NO_WAIT);
if(status!=FVID2_SOK)
{
/* cannot submit frame now process queue is full, release frame to free Q */
pChObj->inFrameSkipCount++;
status = Utils_quePut(&pChObj->freeQ, pEmptyFrame, BIOS_NO_WAIT);
/* this assert should never occur */
UTILS_assert(status==FVID2_SOK);
return FVID2_SOK;
}
return FVID2_SOK;
}
static
Void DisplayLink_drvFreeFrameInfo(DisplayLink_Obj * pObj,
FVID2_FrameList *frameList)
{
Int i;
FVID2_Frame *frame;
DisplayLink_FrameInfo *frameInfo;
Int32 status;
for (i = 0; i < frameList->numFrames; i++)
{
frame = frameList->frames[i];
if (DISPLAY_LINK_BLANK_FRAME_CHANNEL_NUM != frame->channelNum)
{
frameInfo = frame->appData;
UTILS_assert(UTILS_ARRAYISVALIDENTRY(frameInfo,
pObj->frameInfo.infoMem));
status =
Utils_quePut(&pObj->frameInfo.infoQ,
frameInfo,
BIOS_NO_WAIT);
UTILS_assert(status == 0);
}
}
}
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_bufPutEmptyFrame(Utils_BufHndl * pHndl, FVID2_Frame * pFrame)
{
Int32 status;
UTILS_assert(pHndl != NULL);
status = Utils_quePut(&pHndl->emptyQue, pFrame, BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
return FVID2_SOK;
}
Int32 Utils_bitbufPutEmptyBuf(Utils_BitBufHndl * pHndl, Bitstream_Buf * pBuf)
{
Int32 status;
UTILS_assert(pHndl != NULL);
UTILS_assert(pBuf->allocPoolID < pHndl->numAllocPools);
status = Utils_quePut(&(pHndl->emptyQue[pBuf->allocPoolID]),
pBuf, BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
return FVID2_SOK;
}
Int32 IpcOutM3Link_releaseFrames(IpcOutM3Link_Obj * pObj)
{
System_LinkInQueParams *pInQueParams;
SystemIpcM3_ListElem *pListElem = NULL;
Int32 status;
pInQueParams = &pObj->createArgs.inQueParams;
do
{
pObj->freeFrameList.numFrames = 0;
while (pObj->freeFrameList.numFrames < FVID2_MAX_FVID_FRAME_PTR)
{
pListElem = ListMP_getHead(pObj->listMPInHndl);
if (pListElem == NULL)
break;
pObj->freeFrameList.frames[pObj->freeFrameList.numFrames] =
pListElem->pFrame;
pObj->freeFrameList.numFrames++;
UTILS_assert(pObj->freeFrameList.numFrames <=
FVID2_MAX_FVID_FRAME_PTR);
/* release ListElem back to queue */
status = Utils_quePut(&pObj->listElemQue, pListElem, BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
}
#ifdef SYSTEM_DEBUG_IPC_RT
Vps_printf(" %d: IPC_OUT_M3 : Releasing %d frames !!!\n",
Utils_getCurTimeInMsec(), pObj->freeFrameList.numFrames);
#endif
if (pObj->freeFrameList.numFrames)
{
// Vps_printf("Ipc out ret !!!\n");
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId,
&pObj->freeFrameList);
}
} while (pListElem != NULL);
return FVID2_SOK;
}
Int32 Utils_bufPutFullFrame(Utils_BufHndl * pHndl, FVID2_Frame * pFrame)
{
Int32 status;
UTILS_assert(pHndl != NULL);
status = Utils_quePut(&pHndl->fullQue, pFrame, BIOS_NO_WAIT);
if (status != FVID2_SOK)
{
#if 0
Vps_rprintf
("%d: ERROR: In Utils_bufPutFullFrame(), Utils_quePut() failed !!!\n",
Utils_getCurTimeInMsec());
#endif
}
return status;
}
Int32 Utils_bitbufPutFullBuf(Utils_BitBufHndl * pHndl, Bitstream_Buf * pBuf)
{
Int32 status;
UTILS_assert(pHndl != NULL);
status = Utils_quePut(&pHndl->fullQue, pBuf, BIOS_NO_WAIT);
if (status != FVID2_SOK)
{
#if 0
Vps_rprintf
("%d: ERROR: In Utils_bitbufPutFullBuf(), Utils_quePut() failed !!!\n",
Utils_getCurTimeInMsec());
#endif
}
return status;
}
Int32 IpcFramesInLink_processFrameBufs(IpcFramesInLink_Obj * pObj)
{
FVID2_Frame *pFrameBuf;
SystemIpcFrames_ListElem *pListElem;
UInt32 numFrameBufs;
Int32 status;
UInt32 curTime;
numFrameBufs = 0;
curTime = Utils_getCurTimeInMsec();
while (1)
{
pListElem = ListMP_getHead(pObj->listMPOutHndl);
if (pListElem == NULL)
break;
IpcFramesInLink_getFrameBuf(pObj, pListElem, &pFrameBuf);
UTILS_assert(SYSTEM_IPC_FRAMES_GET_BUFSTATE(pListElem->bufState)
== IPC_FRAMEBUF_STATE_OUTQUE);
pListElem->frameBuf.reserved[0] = curTime;
SYSTEM_IPC_FRAMES_SET_BUFOWNERPROCID(pListElem->bufState);
SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
IPC_FRAMEBUF_STATE_DEQUEUED);
pObj->stats.recvCount++;
status = Utils_quePut(&pObj->outFrameBufQue, pFrameBuf, BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
numFrameBufs++;
}
#ifdef SYSTEM_DEBUG_IPC_RT
Vps_printf(" %d: IPC_FRAMES_IN : Recevived %d framebufs !!!\n",
Utils_getCurTimeInMsec(), numFrameBufs);
#endif
if (numFrameBufs && pObj->createArgs.baseCreateParams.notifyNextLink)
{
UTILS_assert(pObj->createArgs.baseCreateParams.numOutQue == 1);
System_sendLinkCmd(pObj->createArgs.baseCreateParams.outQueParams[0].
nextLink, SYSTEM_CMD_NEW_DATA);
}
return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
Int32 Utils_bitbufPutFull(Utils_BitBufHndl * pHndl,
Bitstream_BufList * pBufList)
{
UInt32 idx;
Int32 status;
UTILS_assert(pHndl != NULL);
UTILS_assert(pBufList != NULL);
UTILS_assert(pBufList->numBufs <= FVID2_MAX_FVID_FRAME_PTR);
for (idx = 0; idx < pBufList->numBufs; idx++)
{
status =
Utils_quePut(&pHndl->fullQue, pBufList->bufs[idx], BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
}
return FVID2_SOK;
}
Int32 Utils_bufPutEmpty(Utils_BufHndl * pHndl, FVID2_FrameList * pFrameList)
{
UInt32 idx;
Int32 status;
UTILS_assert(pHndl != NULL);
UTILS_assert(pFrameList != NULL);
UTILS_assert(pFrameList->numFrames <= FVID2_MAX_FVID_FRAME_PTR);
for (idx = 0; idx < pFrameList->numFrames; idx++)
{
status =
Utils_quePut(&pHndl->emptyQue, pFrameList->frames[idx],
BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
}
return FVID2_SOK;
}
static
Void DisplayLink_drvFreeRtParams(DisplayLink_Obj * pObj,
FVID2_FrameList *freeFrameList)
{
Int32 status;
DisplayLink_drvRtParams *rtParams;
rtParams = freeFrameList->perListCfg;
if (rtParams)
{
UTILS_COMPILETIME_ASSERT(
offsetof(DisplayLink_drvRtParams,dispRtPrms) == 0);
UTILS_assert(UTILS_ARRAYISVALIDENTRY(rtParams,pObj->rtParams.paramsMem));
status = Utils_quePut(&pObj->rtParams.freeQ,
rtParams,
BIOS_NO_WAIT);
UTILS_assert(status == 0);
}
}
Int32 Utils_bitbufPutEmpty(Utils_BitBufHndl * pHndl,
Bitstream_BufList * pBufList)
{
UInt32 idx;
Int32 status;
UTILS_assert(pHndl != NULL);
UTILS_assert(pBufList != NULL);
UTILS_assert(pBufList->numBufs <= VIDBITSTREAM_MAX_BITSTREAM_BUFS);
for (idx = 0; idx < pBufList->numBufs; idx++)
{
UInt32 allocPoolID = pBufList->bufs[idx]->allocPoolID;
UTILS_assert(pBufList->bufs[idx]->allocPoolID < pHndl->numAllocPools);
status = Utils_quePut(&(pHndl->emptyQue[allocPoolID]),
pBufList->bufs[idx], BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
}
return FVID2_SOK;
}
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 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;
}
static
Int32 DisplayLink_drvDeQueue(DisplayLink_Obj * pObj,
FVID2_FrameList *freeFrameList,
UInt32 *freeQueId)
{
Int32 status,i;
FVID2_Frame *frame;
FVID2_FrameList tmpFreeFrameList;
DisplayLink_FrameInfo *frameInfo;
freeFrameList->numFrames = 0;
tmpFreeFrameList.numFrames = 0;
*freeQueId = DISPLAY_LINK_INVALID_INQUEID;
status =
FVID2_dequeue(pObj->displayHndl,&tmpFreeFrameList,0,
BIOS_NO_WAIT);
if (FVID2_SOK == status)
{
pObj->dequeCount += tmpFreeFrameList.numFrames;
if (tmpFreeFrameList.numFrames)
{
pObj->maxQueueCount++;
#ifdef SYSTEM_DEBUG_DISPLAY_RT
Vps_printf(" %d: DISPLAY: Deque %d frames\n",
Utils_getCurTimeInMsec(),
tmpFreeFrameList.numFrames);
#endif
DisplayLink_drvFreeRtParams(pObj,&tmpFreeFrameList);
}
for (i = 0; i < tmpFreeFrameList.numFrames;i++)
{
frame = tmpFreeFrameList.frames[i];
if (DISPLAY_LINK_BLANK_FRAME_CHANNEL_NUM !=
frame->channelNum)
{
frameInfo = frame->appData;
UTILS_assert(UTILS_ARRAYISVALIDENTRY(frameInfo,pObj->frameInfo.infoMem));
*freeQueId = frameInfo->activeQueueId;
if (frameInfo->isFieldPair)
{
UInt32 curTime;
curTime = Utils_getCurTimeInMsec();
UTILS_assert(freeFrameList->numFrames <
UTILS_ARRAYSIZE(freeFrameList->frames));
freeFrameList->frames[freeFrameList->numFrames] =
frameInfo->origFrame[0];
pObj->drvTopFieldLatency +=
(curTime - frameInfo->origFrame[0]->timeStamp);
pObj->numTopFields++;
freeFrameList->numFrames++;
UTILS_assert(freeFrameList->numFrames <
UTILS_ARRAYSIZE(freeFrameList->frames));
freeFrameList->frames[freeFrameList->numFrames] =
frameInfo->origFrame[1];
freeFrameList->numFrames++;
pObj->numBufsInDriver--;
}
else
{
/* If not field pair, restore original appData */
frame->appData = frameInfo->origFrameInfo;
UTILS_assert(freeFrameList->numFrames <
UTILS_ARRAYSIZE(freeFrameList->frames));
freeFrameList->frames[freeFrameList->numFrames] =
frame;
freeFrameList->numFrames++;
pObj->numBufsInDriver--;
}
status =
Utils_quePut(&pObj->frameInfo.infoQ,
frameInfo,
BIOS_NO_WAIT);
UTILS_assert(status == 0);
}
}
}
return status;
}
Int32 IpcFramesInLink_putEmptyFrames(Utils_TskHndl * pTsk, UInt16 queId,
FVID2_FrameList * pFrameBufList)
{
IpcFramesInLink_Obj *pObj = (IpcFramesInLink_Obj *) pTsk->appData;
UInt32 bufId;
FVID2_Frame *pFrameBuf;
Int32 status;
SystemIpcFrames_ListElem *pListElem = NULL;
UInt32 curTime;
System_FrameInfo *frmInfo;
#ifdef SYSTEM_DEBUG_IPC_RT
Vps_printf(" %d: IPC_FRAMES_IN : Releasing %d framebufs !!!\n",
Utils_getCurTimeInMsec(), pFrameBufList->numFrames);
#endif
if ((pFrameBufList->numFrames)
&&
(IPC_FRAMES_IN_LINK_STATE_ACTIVE == pObj->state))
{
UTILS_assert(pFrameBufList->numFrames <= FVID2_MAX_FVID_FRAME_PTR);
curTime = Utils_getCurTimeInMsec();
pObj->stats.freeCount += pFrameBufList->numFrames;
for (bufId = 0; bufId < pFrameBufList->numFrames; bufId++)
{
pFrameBuf = pFrameBufList->frames[bufId];
frmInfo = pFrameBuf->appData;
UTILS_assert(frmInfo != NULL);
pListElem = (SystemIpcFrames_ListElem *) frmInfo->pOrgListMPElem;
UTILS_assert(pListElem->frameBuf.phyAddr[0][0] ==
pFrameBuf->addr[0][0]);
UTILS_assert(UTILS_ARRAYISVALIDENTRY(pFrameBuf,pObj->freeFrameMem));
UTILS_assert(SYSTEM_IPC_FRAMES_GET_BUFSTATE(pListElem->bufState)
== IPC_FRAMEBUF_STATE_DEQUEUED);
status = Utils_quePut(&pObj->freeFrameQue,pFrameBuf,BIOS_NO_WAIT);
UTILS_assert(status == FVID2_SOK);
if (curTime > pListElem->frameBuf.reserved[0])
{
pObj->stats.totalRoundTrip += (curTime - pListElem->frameBuf.reserved[0]);
}
SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
IPC_FRAMEBUF_STATE_INQUE);
status =
ListMP_putTail(pObj->listMPInHndl, (ListMP_Elem *) pListElem);
UTILS_assert(status == ListMP_S_SUCCESS);
}
if (pObj->createArgs.baseCreateParams.notifyPrevLink)
{
// Vps_printf("593:System_ipcSendNotify,id=%d\n",pObj->createArgs.baseCreateParams.inQueParams.prevLinkId);
System_ipcSendNotify(pObj->createArgs.baseCreateParams.inQueParams.
prevLinkId);
}
}
if (IPC_FRAMES_IN_LINK_STATE_INACTIVE == pObj->state)
{
Vps_printf(" %d: IPC_FRAMES_IN:Warning! Free Frames invoked after link delete\n",
Utils_getCurTimeInMsec());
}
return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
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;
}
