Int32 DupLink_putEmptyFrames(Utils_TskHndl * pTsk, UInt16 queId,
FVID2_FrameList * pFrameList)
{
DupLink_Obj *pObj = (DupLink_Obj *) pTsk->appData;
FVID2_FrameList freeFrameList;
UInt32 frameId;
FVID2_Frame *pFrame, *pOrgFrame;
System_FrameInfo *pFrameInfo, *pOrgFrameInfo;
Int32 status;
UTILS_assert(queId < DUP_LINK_MAX_OUT_QUE);
UTILS_assert(queId < pObj->createArgs.numOutQue);
freeFrameList.numFrames = 0;
Semaphore_pend(pObj->lock, BIOS_WAIT_FOREVER);
for (frameId = 0; frameId < pFrameList->numFrames; frameId++)
{
pFrame = pFrameList->frames[frameId];
if (pFrame == NULL)
continue;
pFrameInfo = (System_FrameInfo *) pFrame->appData;
UTILS_assert(pFrameInfo != NULL);
pOrgFrame = pFrameInfo->pDupOrgFrame;
UTILS_assert(pOrgFrame != NULL);
pOrgFrameInfo = (System_FrameInfo *) pOrgFrame->appData;
UTILS_assert(pOrgFrameInfo != NULL);
pOrgFrameInfo->dupCount--;
if (pOrgFrameInfo->dupCount == 0)
{
freeFrameList.frames[freeFrameList.numFrames] = pOrgFrame;
freeFrameList.numFrames++;
}
}
pObj->putFrameCount += freeFrameList.numFrames;
System_putLinksEmptyFrames(pObj->createArgs.inQueParams.prevLinkId,
pObj->createArgs.inQueParams.prevLinkQueId,
&freeFrameList);
Semaphore_post(pObj->lock);
status = Utils_bufPutEmpty(&pObj->outFrameQue[queId], pFrameList);
UTILS_assert(status == FVID2_SOK);
return FVID2_SOK;
}
Int32 AlgLink_algProcessData(AlgLink_Obj * pObj)
{
UInt32 frameId;
System_LinkInQueParams *pInQueParams;
FVID2_Frame *pFrame;
FVID2_FrameList frameList;
pInQueParams = &pObj->createArgs.inQueParams;
System_getLinksFullFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId, &frameList);
if (frameList.numFrames)
{
/* SCD should be done first as it requires to operate on raw YUV */
if (pObj->createArgs.enableSCDAlg)
{
AlgLink_ScdalgProcessData(&pObj->scdAlg, &frameList, &pObj->outObj[0].bufOutQue);
#if 0
if (status == FVID2_SOK)
{
/* Send-out the output bitbuffer */
System_sendLinkCmd(pObj->createArgs.outQueParams[ALG_LINK_SCD_OUT_QUE].nextLink,
SYSTEM_CMD_NEW_DATA);
}
#endif
}
for(frameId=0; frameId<frameList.numFrames; frameId++)
{
pFrame = frameList.frames[frameId];
if(pFrame->channelNum >= pObj->inQueInfo.numCh)
continue;
// do SW OSD
if (pObj->createArgs.enableOSDAlg)
{
AlgLink_OsdalgProcessFrame(&pObj->osdAlg, pFrame);
}
}
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId, &frameList);
}
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 AlgLink_putEmptyFrames(Utils_TskHndl * pTsk, UInt16 queId,
FVID2_FrameList * pBufList)
{
AlgLink_Obj *pObj = (AlgLink_Obj *) pTsk->appData;
AlgLink_CreateParams *pCreateArgs;
pCreateArgs = &pObj->createArgs;
if(queId==ALG_LINK_FRAMES_OUT_QUE)
{
System_putLinksEmptyFrames(pCreateArgs->inQueParams.prevLinkId,
pCreateArgs->inQueParams.prevLinkQueId,
pBufList);
}
return FVID2_SOK;
}
Int32 MpSclrLink_putEmptyFrames(Utils_TskHndl * pTsk, UInt16 queId,
FVID2_FrameList * pFrameList)
{
Int32 status;
UInt32 i, currIndex;
FVID2_Frame *pFrame;
FVID2_FrameList freeFrameList;
MpSclrLink_Obj *pObj = (MpSclrLink_Obj *) pTsk->appData;
status = FVID2_SOK;
/* Check if the frame belong to MP SCLR, if not put back to previous link */
currIndex = 0;
for (i = 0; i < pFrameList->numFrames; i++)
{
pFrame = pFrameList->frames[i];
if ((((System_FrameInfo *)pFrame->appData)->isMpFrame) == 0)
{
/* Frame belongs to previous link */
freeFrameList.frames[currIndex] = pFrame;
currIndex++;
}
else
{
/* This frame belongs to MP SCLR */
debugMpSclrPrintFrame(pFrame, "Next Link Return Output Frame");
status = Utils_bufPutEmptyFrame(&pObj->linkBufQ, pFrame);
}
}
if (currIndex)
{
freeFrameList.numFrames = currIndex;
status =
System_putLinksEmptyFrames(pObj->createArgs.inQueParams.prevLinkId,
pObj->createArgs.inQueParams.prevLinkQueId,
&freeFrameList);
}
return status;
}
Int32 DisplayLink_drvSwitchActiveQueue(DisplayLink_Obj * pObj,
DisplayLink_SwitchActiveQueueParams *prm)
{
Int32 status = FVID2_SOK;
DisplayLink_drvLock(pObj);
if (prm->activeQueueId < pObj->createArgs.numInputQueues)
{
if (NULL != pObj->topField)
{
System_LinkInQueParams *pInQueParams;
UInt32 freeQueueId = pObj->curActiveQueue;
FVID2_FrameList freeFrameList;
Int32 status;
UTILS_assert(freeQueueId <
pObj->createArgs.numInputQueues);
pInQueParams = &pObj->createArgs.inQueParams[freeQueueId];
freeFrameList.numFrames = 1;
freeFrameList.frames[0] = pObj->topField;
status =
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId,
&freeFrameList);
UTILS_assert(status == 0);
pObj->topField = NULL;
}
pObj->nextFid = FVID2_FID_TOP;
pObj->curActiveQueue = prm->activeQueueId;
}
else
{
status = -1;
}
DisplayLink_drvUnlock(pObj);
return status;
}
Int32 IpcOutM3Link_processFrames(IpcOutM3Link_Obj * pObj)
{
System_LinkInQueParams *pInQueParams;
FVID2_FrameList frameList;
FVID2_Frame *pFrame;
SystemIpcM3_ListElem *pListElem;
Int32 status;
Int32 frameId;
IpcOutM3Link_ChObj *pChObj;
pInQueParams = &pObj->createArgs.inQueParams;
System_getLinksFullFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId, &frameList);
pObj->freeFrameList.numFrames = 0;
if (frameList.numFrames)
{
#ifdef SYSTEM_DEBUG_IPC_RT
Vps_printf(" %d: IPC_OUT_M3 : Received %d frames !!!\n",
Utils_getCurTimeInMsec(), frameList.numFrames);
#endif
pObj->totalFrameCount += frameList.numFrames;
for (frameId = 0; frameId < frameList.numFrames; frameId++)
{
Bool doFrameDrop;
pFrame = frameList.frames[frameId];
pChObj = &pObj->chObj[pFrame->channelNum];
pChObj->inFrameRecvCount++;
doFrameDrop = Utils_doSkipFrame(&(pChObj->frameSkipCtx));
/* frame skipped due to user setting */
if(doFrameDrop)
{
pChObj->inFrameUserSkipCount++;
pObj->freeFrameList.frames[pObj->freeFrameList.numFrames] =
pFrame;
pObj->freeFrameList.numFrames++;
UTILS_assert(pObj->freeFrameList.numFrames <=
FVID2_MAX_FVID_FRAME_PTR);
continue;;
}
status =
Utils_queGet(&pObj->listElemQue, (Ptr *) & pListElem, 1,
BIOS_NO_WAIT);
if (status != FVID2_SOK)
{
/* normally this condition should not happen, if it happens
* return the frame back to its generator */
#if 0
Vps_printf(" IPC_OUT: Dropping frame\n");
#endif
pObj->freeFrameList.frames[pObj->freeFrameList.numFrames] =
pFrame;
pObj->freeFrameList.numFrames++;
UTILS_assert(pObj->freeFrameList.numFrames <=
FVID2_MAX_FVID_FRAME_PTR);
pChObj->inFrameUserSkipCount++;
continue;
}
pListElem->pFrame = pFrame;
/* no need to do cache ops since this is inter-M3 list */
status = ListMP_putTail(pObj->listMPOutHndl, &pListElem->listElem);
UTILS_assert(status == ListMP_S_SUCCESS);
pChObj->inFrameProcessCount++;
}
if (pObj->freeFrameList.numFrames)
{
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId,
&pObj->freeFrameList);
}
if (pObj->createArgs.notifyNextLink)
{
UTILS_assert(pObj->createArgs.numOutQue == 1);
System_ipcSendNotify(pObj->createArgs.outQueParams[0].nextLink);
}
if (TRUE == pObj->createArgs.noNotifyMode)
{
if (FALSE == pObj->prd.clkStarted)
{
IpcOutM3Link_startPrdObj(pObj,
IPC_M3OUT_LINK_DONE_PERIOD_MS, FALSE);
}
}
}
return FVID2_SOK;
}
Int32 DisplayLink_drvProcessData(DisplayLink_Obj * pObj)
{
FVID2_FrameList frameList;
FVID2_FrameList freeFrameList;
FVID2_FrameList displayFrameList;
UInt32 freeFrameNum, elaspedTime;
System_LinkInQueParams *pInQueParams;
FVID2_Frame *pFrame;
Int32 status;
UInt32 latency;
Int i;
UInt32 frameIdx;
elaspedTime = Utils_getCurTimeInMsec() - pObj->startTime;
if ((elaspedTime - pObj->prevTime) > 24 * 60 * 60 * 1000)
{
DisplayLink_drvPrintRtStatus(pObj, elaspedTime);
pObj->prevTime = elaspedTime;
}
if(pObj->displayInstId==0)
{
System_displayUnderflowCheck(FALSE);
}
do
{
UInt32 freeQueueId;
/* dequeue all completed frames */
status = DisplayLink_drvDeQueue(pObj,&freeFrameList,
&freeQueueId);
if (freeFrameList.numFrames)
{
pObj->inFramePutCount += freeFrameList.numFrames;
UTILS_assert(freeQueueId <
pObj->createArgs.numInputQueues);
pInQueParams = &pObj->createArgs.inQueParams[freeQueueId];
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId, &freeFrameList);
}
} while (status == FVID2_SOK);
/* Free frames queued in inactive queues immediately */
for (i = 0; i < pObj->createArgs.numInputQueues;i++)
{
if (i != pObj->curActiveQueue)
{
frameList.numFrames = 0;
pInQueParams =
&pObj->createArgs.inQueParams[i];
System_getLinksFullFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId,
&frameList);
if (frameList.numFrames)
{
pObj->inFrameGetCount += frameList.numFrames;
pObj->inFramePutCount += frameList.numFrames;
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId,
&frameList);
}
}
}
UTILS_assert(pObj->curActiveQueue < pObj->createArgs.numInputQueues);
pInQueParams = &pObj->createArgs.inQueParams[pObj->curActiveQueue];
/* que frames if any */
System_getLinksFullFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId, &frameList);
pObj->inFrameGetCount += frameList.numFrames;
freeFrameNum = 0;
DisplayLink_drvLock(pObj);
frameIdx = 0;
while((pObj->maxQueueCount)
&&
(frameIdx < frameList.numFrames))
{
pFrame = frameList.frames[frameIdx];
frameIdx++;
UTILS_assert(pFrame != NULL);
if (pFrame->channelNum == pObj->curDisplayChannelNum)
{
Bool frameReject;
UInt32 pitch0,pitch1;
pitch0 = pObj->displayFormat.pitch[0];
pitch1 = pObj->displayFormat.pitch[1];
if (DisplayLink_drvDoInputPitchDoubling(pObj))
{
pitch0 /= 2;
pitch1 /= 2;
}
UTILS_assert(DISPLAY_LINK_BLANK_FRAME_CHANNEL_NUM !=
pFrame->channelNum);
pFrame->addr[1][0] =
(UInt8 *) pFrame->addr[0][0] + pitch0;
pFrame->addr[1][1] =
(UInt8 *) pFrame->addr[0][1] + pitch1;
#ifdef SYSTEM_DEBUG_DISPLAY_RT
Vps_printf(" %d: DISPLAY: Queue %d frames\n", Utils_getCurTimeInMsec(),
displayFrameList.numFrames);
#endif
latency = Utils_getCurTimeInMsec() - pFrame->timeStamp;
if(latency>pObj->maxLatency)
pObj->maxLatency = latency;
if(latency<pObj->minLatency)
pObj->minLatency = latency;
/* queue frame for display */
displayFrameList.numFrames = 0;
DisplayLink_drvSetFrameInfo(pObj,
&pFrame,
&frameReject);
if (pFrame)
{
if (frameReject)
{
UTILS_assert(freeFrameNum <
UTILS_ARRAYSIZE(freeFrameList.frames));
/* error in queing to display, instead of asserting
release the frame and continue
*/
freeFrameList.frames[freeFrameNum] = pFrame;
freeFrameNum++;
}
else
{
displayFrameList.frames[displayFrameList.numFrames] = pFrame;
displayFrameList.numFrames++;
displayFrameList.perListCfg = NULL;
DisplayLink_drvHandleDynamicPitchChange(pObj,&displayFrameList);
DisplayLink_validateFrameList(pObj,
&displayFrameList);
pObj->queueCount += displayFrameList.numFrames;
pObj->numBufsInDriver++;
status = FVID2_queue(pObj->displayHndl,
&displayFrameList,
0);
pObj->maxQueueCount--;
if(status!=FVID2_SOK)
{
Vps_rprintf(" %d: DISPLAY (%d): Queue to driver failed !!!\n", Utils_getCurTimeInMsec(),
pObj->tskId);
UTILS_assert(freeFrameNum <
UTILS_ARRAYSIZE(freeFrameList.frames));
/* error in queing to display, instead of asserting
release the frame and continue
*/
freeFrameList.frames[freeFrameNum] = pFrame;
freeFrameNum++;
DisplayLink_drvFreeFrameInfo(pObj,
&displayFrameList);
}
}
}
}
else
{
UTILS_assert(freeFrameNum <
UTILS_ARRAYSIZE(freeFrameList.frames));
freeFrameList.frames[freeFrameNum] = pFrame;
freeFrameNum++;
}
}
DisplayLink_drvUnlock(pObj);
for (i = frameIdx; i < frameList.numFrames;i++)
{
UTILS_assert(freeFrameNum < UTILS_ARRAYSIZE(freeFrameList.frames));
freeFrameList.frames[freeFrameNum] = frameList.frames[i];
freeFrameNum++;
}
if (freeFrameNum)
{
freeFrameList.numFrames = freeFrameNum;
pObj->inFramePutCount += freeFrameList.numFrames;
System_putLinksEmptyFrames(pInQueParams->prevLinkId,
pInQueParams->prevLinkQueId, &freeFrameList);
}
return FVID2_SOK;
}
