Int32 AlgLink_scdAlgDoTmpFrameInit(AlgLink_ScdObj * pObj, AlgLink_ScdChObj *pChObj, FVID2_Frame *pFrame)
{
Int32 status = FVID2_SOK;
UInt32 curTime;
if(pChObj->algInitMeanVarMHIPrm.inAddr==NULL)
{
if(pChObj->isTiledMode)
{
pChObj->algInitMeanVarMHIPrm.inAddr = (Ptr)Utils_tilerAddr2CpuAddr( (UInt32)pFrame->addr[0][0] );
}
else
{
pChObj->algInitMeanVarMHIPrm.inAddr = pFrame->addr[0][0];
}
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_rprintf(" %d: SCD: CH%d: SCD_initMeanVarMHI() ... !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum
);
#endif
curTime = Utils_getCurTimeInMsec();
/* first frame */
status = SCD_initMeanVarMHI(&pObj->algObj, &pChObj->algInitMeanVarMHIPrm);
curTime = Utils_getCurTimeInMsec() - curTime;
pObj->totalTime += curTime;
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_rprintf(" %d: SCD: CH%d: SCD_initMeanVarMHI() ... DONE !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum
);
#endif
if(status!=SCD_NO_ERROR)
{
Vps_printf(" %d: SCD: CH%d: ERROR (%d) in SCD_initMeanVarMHI() !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum,
status
);
}
}
return status;
}
Int32 DisplayLink_drvPrintRtStatus(DisplayLink_Obj * pObj, UInt32 elaspedTime)
{
char *displayName[] = { "HDDAC(BP0) ", "DVO2(BP1) ", "SDDAC(SEC1)" };
Vps_rprintf(" %d: DISPLAY: %s: %d fps, Latency (Min / Max) = ( %d / %d ), Callback Interval (Min / Max) = ( %d / %d ) !!! \r\n",
Utils_getCurTimeInMsec(),
displayName[pObj->displayInstId],
pObj->cbCount*1000/elaspedTime,
pObj->minLatency,
pObj->maxLatency,
pObj->minCbTime,
pObj->maxCbTime
);
#if 1
/* reset max time */
pObj->maxCbTime = 0;
pObj->minCbTime = 0xFF;
pObj->maxLatency = 0;
pObj->minLatency = 0xFF;
#endif
if(pObj->displayInstId==0)
{
System_displayUnderflowPrint(TRUE, TRUE);
System_memPrintHeapStatus();
}
return 0;
}
Int32 DisplayLink_printBufferStatus(DisplayLink_Obj * pObj)
{
Vps_rprintf
(
" \n"
" *** Display Statistics *** \n"
"%d: DISPLAY: Rcvd from prev = %d, Returned to prev = %d, BufsInDriver = %d\r\n",
Utils_getCurTimeInMsec(), pObj->inFrameGetCount, pObj->inFramePutCount, pObj->numBufsInDriver);
return 0;
}
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;
}
Void SclrLink_tskMain(struct Utils_TskHndl * pTsk, Utils_MsgHndl * pMsg)
{
UInt32 cmd = Utils_msgGetCmd(pMsg);
Bool ackMsg, done;
Int32 status;
SclrLink_Obj *pObj;
SclrLink_ChannelInfo * channelInfo;
UInt32 flushCmds[2];
pObj = (SclrLink_Obj *) pTsk->appData;
if (cmd != SYSTEM_CMD_CREATE)
{
Utils_tskAckOrFreeMsg(pMsg, FVID2_EFAIL);
return;
}
status = SclrLink_drvCreate(pObj, Utils_msgGetPrm(pMsg));
Utils_tskAckOrFreeMsg(pMsg, status);
if (status != FVID2_SOK)
return;
done = FALSE;
ackMsg = FALSE;
while (!done)
{
status = Utils_tskRecvMsg(pTsk, &pMsg, BIOS_WAIT_FOREVER);
if (status != FVID2_SOK)
break;
cmd = Utils_msgGetCmd(pMsg);
switch (cmd)
{
case SYSTEM_CMD_NEW_DATA:
Utils_tskAckOrFreeMsg(pMsg, status);
flushCmds[0] = SYSTEM_CMD_NEW_DATA;
Utils_tskFlushMsg(pTsk, flushCmds, 1);
SclrLink_drvProcessData(pObj);
break;
case SCLR_LINK_CMD_GET_PROCESSED_DATA:
Utils_tskAckOrFreeMsg(pMsg, status);
SclrLink_drvGetProcessedData(pObj);
break;
case SYSTEM_CMD_STOP:
SclrLink_drvStop(pObj);
Utils_tskAckOrFreeMsg(pMsg, status);
break;
case SCLR_LINK_CMD_SET_FRAME_RATE:
{
SclrLink_ChFpsParams *params;
params = (SclrLink_ChFpsParams *) Utils_msgGetPrm(pMsg);
SclrLink_SetFrameRate(pObj, params);
Utils_tskAckOrFreeMsg(pMsg, status);
}
break;
case SCLR_LINK_CMD_GET_OUTPUTRESOLUTION:
{
SclrLink_chDynamicSetOutRes *params;
params = (SclrLink_chDynamicSetOutRes *) Utils_msgGetPrm(pMsg);
SclrLink_drvGetChDynamicOutputRes(pObj, params);
Utils_tskAckOrFreeMsg(pMsg, status);
}
break;
case SCLR_LINK_CMD_SET_OUTPUTRESOLUTION:
{
SclrLink_chDynamicSetOutRes *params;
params = (SclrLink_chDynamicSetOutRes *) Utils_msgGetPrm(pMsg);
SclrLink_drvSetChDynamicOutputRes(pObj, params);
Utils_tskAckOrFreeMsg(pMsg, status);
}
break;
case SCLR_LINK_CMD_SKIP_FID_TYPE:
{
SclrLink_chDynamicSkipFidType *params;
params = (SclrLink_chDynamicSkipFidType *) Utils_msgGetPrm(pMsg);
SclrLink_drvDynamicSkipFidType(pObj, params);
Utils_tskAckOrFreeMsg(pMsg, status);
}
break;
case SCLR_LINK_CMD_DISABLE_CHANNEL:
case SCLR_LINK_CMD_ENABLE_CHANNEL:
#ifdef SYSTEM_DEBUG_SCLR
Vps_rprintf(" %d: SCLR : Channel Enable/Disable in progress ... !!!\n", Utils_getCurTimeInMsec());
#endif
channelInfo = (SclrLink_ChannelInfo *) Utils_msgGetPrm(pMsg);
SclrLink_drvSetChannelInfo(pObj,channelInfo);
Utils_tskAckOrFreeMsg(pMsg, status);
#ifdef SYSTEM_DEBUG_SCLR
Vps_rprintf(" %d: SCLR : Channel Enable/Disable in progress ... DONE !!!\n", Utils_getCurTimeInMsec());
#endif
break;
case SYSTEM_CMD_DELETE:
SclrLink_drvStop(pObj);
done = TRUE;
ackMsg = TRUE;
break;
case SCLR_LINK_CMD_PRINT_STATISTICS:
SclrLink_drvPrintStatistics(pObj, TRUE);
Utils_tskAckOrFreeMsg(pMsg, status);
break;
default:
Utils_tskAckOrFreeMsg(pMsg, status);
break;
}
}
SclrLink_drvDelete(pObj);
if (ackMsg && pMsg != NULL)
Utils_tskAckOrFreeMsg(pMsg, status);
return;
}
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;
}
Int32 AlgLink_scdAlgDoProcessFrame(AlgLink_ScdObj * pObj, AlgLink_ScdChObj *pChObj, FVID2_Frame *pFrame)
{
Int32 status = FVID2_SOK;
UInt32 curTime;
Bool statusChangeDetected = FALSE;
if(pChObj->isTiledMode)
{
pChObj->algProcessPrm.inAddr = (Ptr)Utils_tilerAddr2CpuAddr( (UInt32)pFrame->addr[0][0] );
}
else
{
pChObj->algProcessPrm.inAddr = pFrame->addr[0][0];
}
if(pChObj->algProcessPrm.prevInAddr==NULL)
pChObj->algProcessPrm.prevInAddr = pChObj->algProcessPrm.inAddr;
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_rprintf(" %d: SCD: CH%d: SCD_process() ... !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum
);
#endif
curTime = Utils_getCurTimeInMsec();
status = SCD_process(&pObj->algObj, &pChObj->algProcessPrm, &pChObj->algProcessStatus);
curTime = Utils_getCurTimeInMsec() - curTime;
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_rprintf(" %d: SCD: CH%d: SCD_process() ... DONE !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum
);
#endif
if(pChObj->algProcessStatus.status!=SCD_NO_ERROR)
{
Vps_printf(" %d: SCD: CH%d: ERROR (%d) in SCD_process() !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum,
status
);
}
pChObj->scdStatus = ALG_LINK_SCD_DETECTOR_UNAVAILABLE;
if(pChObj->algProcessStatus.output==SCD_DETECTOR_NO_CHANGE)
pChObj->scdStatus = ALG_LINK_SCD_DETECTOR_NO_CHANGE;
else
if(pChObj->algProcessStatus.output==SCD_DETECTOR_CHANGE)
pChObj->scdStatus = ALG_LINK_SCD_DETECTOR_CHANGE;
if(pChObj->scdStatus==ALG_LINK_SCD_DETECTOR_CHANGE)
{
if(pChObj->prevScdStatus!=ALG_LINK_SCD_DETECTOR_CHANGE)
{
statusChangeDetected = TRUE;
Vps_rprintf(" %d: SCD: CH%d: Tamper Detected !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum
);
}
}
if(pChObj->scdStatus==ALG_LINK_SCD_DETECTOR_NO_CHANGE)
{
if(pChObj->prevScdStatus!=ALG_LINK_SCD_DETECTOR_NO_CHANGE)
{
statusChangeDetected = TRUE;
Vps_rprintf(" %d: SCD: CH%d: NO Tamper Detected !!!\n",
Utils_getCurTimeInMsec(),
pFrame->channelNum
);
}
}
pChObj->prevScdStatus = pChObj->scdStatus;
pObj->totalTime += curTime;
pChObj->algProcessPrm.prevInAddr = pChObj->algProcessPrm.inAddr;
if(statusChangeDetected)
{
if(pObj->scdCreateParams.enableTamperNotify)
{
AlgLink_ScdChStatus chStatus;
chStatus.chId = pChObj->chId;
chStatus.frmResult = pChObj->scdStatus;
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_TAMPER_DETECT, &chStatus, sizeof(AlgLink_ScdChStatus), FALSE);
}
}
return status;
}
