Int32 SystemTiler_freeAll(void)
{
Int32 status;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_FREE_ALL,
NULL, 0, TRUE);
return status;
}
Int32 Vsys_getIVAMap(VSYS_IVA2CHMAP_TBL_S *ivaTbl)
{
Int32 status;
status = System_linkControl(SYSTEM_LINK_ID_M3VIDEO,
SYSTEM_COMMON_CMD_GET_CH2IVAHD_MAP_TBL,
ivaTbl,
sizeof(*ivaTbl),
TRUE);
return ERROR_NONE;
}
Int32 SystemTiler_free(UInt32 tileAddr)
{
SystemCommon_TilerFree tilerFree;
Int32 status;
tilerFree.tileAddr = tileAddr;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_FREE,
&tilerFree, sizeof(tilerFree), TRUE);
return status;
}
/**
* \brief:
* Disable the specific decoder channel
* \input:
* vdecChnId -- decoder channel id
* \output:
* NA
* \return
* TI_MEDIA_SUCCESS -- while success
* ERROR_CODE -- refer for err defination
*/
Int32 Vdec_disableChn(VDEC_CHN vdecChnId)
{
DecLink_ChannelInfo params = {0};
printf("\r\nDisable Channel: %d", vdecChnId);
params.chId = vdecChnId;
System_linkControl(gVdecModuleContext.decId, DEC_LINK_CMD_DISABLE_CHANNEL,
¶ms, sizeof(params), TRUE);
return 0;
}
Int32 AVSYNC_GetSharedDataStructure()
{
Int32 status = 0;
SystemVpss_AvSyncSharedObjPtr avsyncSharedObjPtr;
status = System_linkControl( SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_GET_AVSYNC_SHAREDOBJ_PTR,
&avsyncSharedObjPtr, sizeof(avsyncSharedObjPtr), TRUE );
pAvSyncInfo_obj = Memory_translate((Ptr)avsyncSharedObjPtr.pAvSyncSharedObjPtr, Memory_XltFlags_Phys2Virt);
return status;
}
Int32 SD_Demo_blindAreaInit(UInt32 numCh)
{
int chId, winId;
for(chId = 0; chId < numCh; chId++)
{
CaptureLink_BlindInfo * blindInfo;
blindInfo = &g_blindAreaChParam[chId];
if(chId < 8)
{
blindInfo->queId = 0;
blindInfo->channelId = chId;
}
else
{
blindInfo->queId = 1;
blindInfo->channelId = chId - 8;
}
blindInfo->numBlindArea = SD_DEMO_BLIND_AREA_NUM_WINDOWS;
for(winId=0; winId < blindInfo->numBlindArea; winId++)
{
blindInfo->win[winId].enableWin = TRUE;
blindInfo->win[winId].fillColorYUYV= 0x80108010;
blindInfo->win[winId].startX = SD_DEMO_BLIND_AREA_WIN0_STARTX;
blindInfo->win[winId].startY = SD_DEMO_BLIND_AREA_WIN0_STARTY + SD_DEMO_BLIND_AREA_WIN0_STARTY * winId +( SD_DEMO_BLIND_AREA_WIN_HEIGHT * winId);
blindInfo->win[winId].width = SD_DEMO_BLIND_AREA_WIN_WIDTH;
blindInfo->win[winId].height = SD_DEMO_BLIND_AREA_WIN_HEIGHT;
}
#if 0
for(winId=0; winId < blindInfo->numBlindArea; winId++)
{
printf("chanId %d, startX %d startY %d \n",params.captureBlindInfo.channelId,
params.captureBlindInfo.win[winId].startX,
params.captureBlindInfo.win[winId].startY);
}
#endif
// Vcap_setDynamicParamChn(chId, ¶ms, VCAP_BLINDAREACONFIG);
System_linkControl(
SYSTEM_LINK_ID_CAPTURE,
CAPTURE_LINK_CMD_CONFIGURE_BLIND_AREA,
blindInfo,
sizeof(CaptureLink_BlindInfo),
TRUE
);
}
return 0;
}
/**
* \brief:
* This function gives CPU ID, board type and revision.
* \input:
* VSYS_PLATFORM_INFO_S sturcture
* \output:
* NA
* \return
* ERROR_NOERROR -- while success
* ERROR_CODE -- refer for err defination
*/
Int32 Vsys_getPlatformInfo(VSYS_PLATFORM_INFO_S *pInfo)
{
Int32 status;
SystemVpss_PlatformInfo platformInfo;
status = System_linkControl(
SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_GET_PLATFORM_INFO,
&platformInfo,
sizeof(platformInfo),
TRUE
);
UTILS_assert(status==OSA_SOK);
/* Get CPU version */
pInfo->cpuRev = platformInfo.cpuRev;
if (pInfo->cpuRev >= SYSTEM_PLATFORM_CPU_REV_MAX)
{
pInfo->cpuRev = SYSTEM_PLATFORM_CPU_REV_UNKNOWN;
}
/* Detect board */
pInfo->boardId = platformInfo.boardId;
if (pInfo->boardId >= SYSTEM_PLATFORM_BOARD_MAX)
{
pInfo->boardId = SYSTEM_PLATFORM_BOARD_UNKNOWN;
}
/* Get base board revision */
pInfo->boardRev = platformInfo.baseBoardRev;
if (pInfo->boardRev >= SYSTEM_PLATFORM_BOARD_REV_MAX)
{
pInfo->boardRev = SYSTEM_PLATFORM_BOARD_REV_UNKNOWN;
}
if (pInfo->boardId != SYSTEM_PLATFORM_BOARD_UNKNOWN)
{
/* Get daughter card revision */
pInfo->boardRev = platformInfo.dcBoardRev;
if (pInfo->boardRev >= SYSTEM_PLATFORM_BOARD_REV_MAX)
{
pInfo->boardRev = SYSTEM_PLATFORM_BOARD_REV_UNKNOWN;
}
}
return ERROR_NONE;
}
Int32 SystemTiler_freeRaw(Ptr addr, UInt32 size)
{
SystemCommon_TilerFreeRaw tilerFreeRaw;
Int32 status;
tilerFreeRaw.allocAddr = (UInt32)addr;
tilerFreeRaw.size = size;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_FREE_RAW,
&tilerFreeRaw,
sizeof(tilerFreeRaw), TRUE);
return status;
}
Int32 dup_set_chInfo(Uint32 dupLinkId, System_dupChInfo *prm)
{
Int32 status = -1;
if(dupLinkId != SYSTEM_LINK_ID_INVALID) {
status = System_linkControl(dupLinkId,
DUP_LINK_CMD_SET_INCHAN_INFO,
prm,
sizeof(*prm),
TRUE
);
}
return status;
}
Int32 select_get_outque_chinfo(Uint32 selectId, SelectLink_OutQueChInfo *prm)
{
Int32 status = -1;
if(selectId != SYSTEM_LINK_ID_INVALID) {
status = System_linkControl(selectId,
SELECT_LINK_CMD_GET_OUT_QUE_CH_INFO,
prm,
sizeof(*prm),
TRUE
);
}
return status;
}
Int32 SystemTiler_getFreeSize(SystemCommon_TilerGetFreeSize *pPrm)
{
Int32 status;
pPrm->freeSizeRaw = 0;
pPrm->freeSize8b = 0;
pPrm->freeSize16b = 0;
pPrm->freeSize32b = 0;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_GET_FREE_SIZE,
pPrm,
sizeof(*pPrm), TRUE);
return status;
}
Int32 SD_Demo_blindAreaUpdate(UInt32 numCh)
{
UInt32 winId, startX,startY,enableWin,chId;
CaptureLink_BlindInfo * blindInfo;
printf("\n In the current demo UI option input is assume to be 704x240. User can change it if needed.\n");
printf("\n User is required to give chanId, MaskWindowId and pixel coordinate. \n");
printf("\n From the given pixel coordinate pixel windows of size 50x20 is masked/unMasked\n");
chId = SD_Demo_getChId("CAPTURE", numCh);
blindInfo = &g_blindAreaChParam[chId];
winId = SD_Demo_getIntValue("Mask window number to be updated", 0, g_blindAreaChParam[chId].numBlindArea-1, 0);
enableWin = SD_Demo_getIntValue("Mask window disable/enable", 0, 1, 0);
blindInfo->win[winId].enableWin = enableWin;
if(enableWin == TRUE)
{
blindInfo->win[winId].fillColorYUYV= 0x80108010;
startX = SD_Demo_getIntValue("Mask window StartX", 0, 704, 0);;
startY = SD_Demo_getIntValue("Mask window StartY", 0, 240, 0);;
if(startX > 604)
startX = 604;
if(startY > 180)
startY = 180;
blindInfo->win[winId].startX = startX;
blindInfo->win[winId].startY = startY;
blindInfo->win[winId].width = 50;
blindInfo->win[winId].height = 20;
}
System_linkControl(
SYSTEM_LINK_ID_CAPTURE,
CAPTURE_LINK_CMD_CONFIGURE_BLIND_AREA,
blindInfo,
sizeof(CaptureLink_BlindInfo),
TRUE
);
return 0;
}
UInt32 SystemTiler_isAllocatorDisabled(void)
{
SystemCommon_TilerIsDisabled tilerAllocatorStatus;
Int32 status;
UInt32 isDisabled = TRUE;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_IS_ALLOCATOR_DISABLED,
&tilerAllocatorStatus,
sizeof(tilerAllocatorStatus), TRUE);
if (!UTILS_ISERROR(status))
{
isDisabled = tilerAllocatorStatus.isAllocatorDisabled;
}
return isDisabled;
}
void Chains_ScdPrint(UInt32 scdId)
{
AlgLink_ScdAllChFrameStatus scdAllChFrameStatus;
/**< SCD frame level status information for all CHs */
int status = System_linkControl(
scdId,
ALG_LINK_SCD_CMD_GET_ALL_CHANNEL_FRAME_STATUS,
&(scdAllChFrameStatus),
sizeof(scdAllChFrameStatus),
TRUE
);
int i;
for(i=0;i<scdAllChFrameStatus.numCh;i++)
{
printf("SCD status numCh:%d, chId %d , frmResult = %d\r\n",i,scdAllChFrameStatus.chanFrameResult[i].chId,
scdAllChFrameStatus.chanFrameResult[i].frmResult);
}
}
Ptr SystemTiler_allocRaw(UInt32 size,UInt32 align)
{
SystemCommon_TilerAllocRaw tilerAllocRaw;
Int32 status;
Ptr allocAddr = NULL;
tilerAllocRaw.size = size;
tilerAllocRaw.align = align;
tilerAllocRaw.allocAddr = NULL;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_ALLOC_RAW,
&tilerAllocRaw,
sizeof(tilerAllocRaw), TRUE);
if (!UTILS_ISERROR(status))
{
allocAddr = (Ptr)tilerAllocRaw.allocAddr;
}
return allocAddr;
}
void Vdec_setTplayConfig(VDEC_CHN vdecChnId, VDEC_TPLAY speed)
{
DecLink_TPlayConfig params = {0};
UInt32 tPlaySpeed = VDEC_TPLAY_1X;
printf("\r\nEnable Channel: %d, speed = %d", vdecChnId, speed);
params.chId = vdecChnId;
params.targetFps = 30;
tPlaySpeed = speed;
if(tPlaySpeed == VDEC_TPLAY_IFRAMEONLY)
params.inputFps = params.targetFps;
else if(tPlaySpeed == VDEC_TPLAY_HALFX || tPlaySpeed == VDEC_TPLAY_QUARTERX)
params.inputFps = params.targetFps;
else
params.inputFps = params.targetFps*tPlaySpeed;
System_linkControl(gVdecModuleContext.decId, DEC_LINK_CMD_SET_TRICKPLAYCONFIG,
¶ms, sizeof(params), TRUE);
}
UInt32 SystemTiler_alloc(UInt32 cntMode, UInt32 width, UInt32 height)
{
UInt32 tileAddr = SYSTEM_TILER_INVALID_ADDR;
SystemCommon_TilerAlloc tilerAlloc;
Int32 status;
tilerAlloc.cntMode = cntMode;
tilerAlloc.width = width;
tilerAlloc.height = height;
status = System_linkControl(SYSTEM_TILER_LINK_ID,
SYSTEM_COMMON_CMD_TILER_ALLOC,
&tilerAlloc, sizeof(tilerAlloc), TRUE);
if (UTILS_ISERROR(status))
{
tileAddr = SYSTEM_TILER_INVALID_ADDR;
}
else
{
tileAddr = tilerAlloc.tileAddr;
}
return tileAddr;
}
/**
* \brief:
* This function de-configures display controller
* \input:
* NA
* \output:
* NA
* \return
* ERROR_NOERROR -- while success
* ERROR_CODE -- refer for err defination
*/
Int32 Vsys_deConfigureDisplay()
{
Int32 status = 0;
VDIS_PARAMS_S * prm = &gVdisModuleContext.vdisConfig;
if (gVsysModuleContext.enableFastUsecaseSwitch == FALSE)
{
if(gVdisModuleContext.displayConfigInitDone == TRUE)
{
gVdisModuleContext.displayConfigInitDone = FALSE;
status = System_linkControl(
SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_GET_DISPLAYCTRL_DEINIT,
&(*prm),
sizeof(*prm),
TRUE
);
UTILS_assert(status==OSA_SOK);
}
}
return status;
}
Void MultiCh_createVdecVdis()
{
IpcBitsOutLinkHLOS_CreateParams ipcBitsOutHostPrm;
IpcBitsInLinkRTOS_CreateParams ipcBitsInVideoPrm;
DecLink_CreateParams decPrm;
IpcLink_CreateParams ipcOutVideoPrm;
IpcLink_CreateParams ipcInVpssPrm;
DupLink_CreateParams dupPrm;
static SwMsLink_CreateParams swMsPrm[VDIS_DEV_MAX];
DisplayLink_CreateParams displayPrm[VDIS_DEV_MAX];
IpcFramesOutLinkHLOS_CreateParams ipcFramesOutHostPrm;
IpcFramesInLinkRTOS_CreateParams ipcFramesInVpssFromHostPrm;
MergeLink_CreateParams mergePrm;
#ifdef TI_816X_BUILD
MpSclrLink_CreateParams mpSclrPrm;
#endif/* TI_816X_BUILD */
UInt32 i;
UInt32 enableGrpx;
Bool tilerEnable;
Bool enableVideoFrameExport;
MULTICH_INIT_STRUCT(IpcLink_CreateParams,ipcInVpssPrm);
MULTICH_INIT_STRUCT(IpcLink_CreateParams,ipcOutVideoPrm);
MULTICH_INIT_STRUCT(IpcBitsOutLinkHLOS_CreateParams,ipcBitsOutHostPrm);
MULTICH_INIT_STRUCT(IpcBitsInLinkRTOS_CreateParams,ipcBitsInVideoPrm);
MULTICH_INIT_STRUCT(DecLink_CreateParams, decPrm);
MULTICH_INIT_STRUCT(IpcFramesOutLinkHLOS_CreateParams ,ipcFramesOutHostPrm);
MULTICH_INIT_STRUCT(IpcFramesInLinkRTOS_CreateParams ,ipcFramesInVpssFromHostPrm);
for (i = 0; i < VDIS_DEV_MAX;i++)
{
MULTICH_INIT_STRUCT(DisplayLink_CreateParams,displayPrm[i]);
MULTICH_INIT_STRUCT(SwMsLink_CreateParams ,swMsPrm[i]);
}
#ifdef TI_816X_BUILD
MULTICH_INIT_STRUCT(MpSclrLink_CreateParams, mpSclrPrm);
#endif /* TI_816X_BUILD */
MultiCh_detectBoard();
System_linkControl(
SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_RESET_VIDEO_DEVICES,
NULL,
0,
TRUE
);
System_linkControl(
SYSTEM_LINK_ID_M3VIDEO,
SYSTEM_COMMON_CMD_SET_CH2IVAHD_MAP_TBL,
&systemVid_encDecIvaChMapTbl,
sizeof(SystemVideo_Ivahd2ChMap_Tbl),
TRUE
);
#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
tilerEnable = FALSE;
enableGrpx = FALSE;
#else
tilerEnable = FALSE;
enableGrpx = TRUE;
#endif
#if (tilerEnable == FALSE)
{
/* Disable tiler allocator for this usecase
* for that tiler memory can be reused for
* non-tiled allocation
*/
SystemTiler_disableAllocator();
}
#endif
enableVideoFrameExport = FALSE;
gVdecModuleContext.ipcBitsOutHLOSId = SYSTEM_HOST_LINK_ID_IPC_BITS_OUT_0;
gVdecModuleContext.ipcBitsInRTOSId = SYSTEM_VIDEO_LINK_ID_IPC_BITS_IN_0;
gVdecModuleContext.decId = SYSTEM_LINK_ID_VDEC_0;
gMultiCh_VdecVdisObj.ipcOutVideoId = SYSTEM_VIDEO_LINK_ID_IPC_OUT_M3_0;
gMultiCh_VdecVdisObj.ipcInVpssId = SYSTEM_VPSS_LINK_ID_IPC_IN_M3_0;
gMultiCh_VdecVdisObj.dupId = SYSTEM_VPSS_LINK_ID_DUP_0;
#ifdef TI_816X_BUILD
gMultiCh_VdecVdisObj.mpSclrId = SYSTEM_LINK_ID_MP_SCLR_INST_0;
gVdisModuleContext.mpSclrId = SYSTEM_LINK_ID_MP_SCLR_INST_0;
#endif /* TI_816X_BUILD */
gVdisModuleContext.swMsId[0] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_0;
gVdisModuleContext.displayId[0] = SYSTEM_LINK_ID_DISPLAY_0; // ON AND OFF CHIP HDMI
if (gVsysModuleContext.vsysConfig.numDisplays > 1)
{
gVdisModuleContext.swMsId[1] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_1;
#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
gVdisModuleContext.displayId[1] = SYSTEM_LINK_ID_DISPLAY_2; // SDTV
#else
gVdisModuleContext.displayId[1] = SYSTEM_LINK_ID_DISPLAY_1; // OFF CHIP HDMI
#endif
}
if (enableVideoFrameExport)
{
gMultiCh_VdecVdisObj.mergeId = SYSTEM_VPSS_LINK_ID_MERGE_0;
gVdisModuleContext.ipcFramesOutHostId = SYSTEM_HOST_LINK_ID_IPC_FRAMES_OUT_0;
gVdisModuleContext.ipcFramesInVpssFromHostId = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_IN_0;
}
if(enableGrpx)
{
// GRPX is enabled in Vdis_start() based on the link ID set here
gVdisModuleContext.grpxId[0] = SYSTEM_LINK_ID_GRPX_0;
#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
gVdisModuleContext.grpxId[1] = SYSTEM_LINK_ID_INVALID;
#else
gVdisModuleContext.grpxId[1] = SYSTEM_LINK_ID_GRPX_1;
#endif
}
ipcBitsOutHostPrm.baseCreateParams.outQueParams[0].nextLink= gVdecModuleContext.ipcBitsInRTOSId;
ipcBitsOutHostPrm.baseCreateParams.notifyNextLink = FALSE;
ipcBitsOutHostPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcBitsOutHostPrm.baseCreateParams.noNotifyMode = TRUE;
ipcBitsOutHostPrm.baseCreateParams.numOutQue = 1;
ipcBitsOutHostPrm.inQueInfo.numCh = gVdecModuleContext.vdecConfig.numChn;
ipcBitsOutHostPrm.bufPoolPerCh = TRUE;
for (i=0; i<ipcBitsOutHostPrm.inQueInfo.numCh; i++)
{
ipcBitsOutHostPrm.inQueInfo.chInfo[i].width =
gVdecModuleContext.vdecConfig.decChannelParams[i].maxVideoWidth;
ipcBitsOutHostPrm.inQueInfo.chInfo[i].height =
gVdecModuleContext.vdecConfig.decChannelParams[i].maxVideoHeight;
ipcBitsOutHostPrm.inQueInfo.chInfo[i].scanFormat =
SYSTEM_SF_PROGRESSIVE;
ipcBitsOutHostPrm.inQueInfo.chInfo[i].bufType = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].codingformat = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].dataFormat = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].memType = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].startX = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].startY = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].pitch[0] = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].pitch[1] = 0; // NOT USED
ipcBitsOutHostPrm.inQueInfo.chInfo[i].pitch[2] = 0; // NOT USED
ipcBitsOutHostPrm.numBufPerCh[i] = 6;
}
ipcBitsInVideoPrm.baseCreateParams.inQueParams.prevLinkId = gVdecModuleContext.ipcBitsOutHLOSId;
ipcBitsInVideoPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsInVideoPrm.baseCreateParams.outQueParams[0].nextLink = gVdecModuleContext.decId;
ipcBitsInVideoPrm.baseCreateParams.noNotifyMode = TRUE;
ipcBitsInVideoPrm.baseCreateParams.notifyNextLink = TRUE;
ipcBitsInVideoPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcBitsInVideoPrm.baseCreateParams.numOutQue = 1;
for (i=0; i<ipcBitsOutHostPrm.inQueInfo.numCh; i++)
{
if(gVdecModuleContext.vdecConfig.decChannelParams[i].isCodec == VDEC_CHN_H264)
decPrm.chCreateParams[i].format = IVIDEO_H264HP;
else if(gVdecModuleContext.vdecConfig.decChannelParams[i].isCodec == VDEC_CHN_MPEG4)
decPrm.chCreateParams[i].format = IVIDEO_MPEG4ASP;
else if(gVdecModuleContext.vdecConfig.decChannelParams[i].isCodec == VDEC_CHN_MJPEG)
decPrm.chCreateParams[i].format = IVIDEO_MJPEG;
decPrm.chCreateParams[i].numBufPerCh
= gVdecModuleContext.vdecConfig.decChannelParams[i].numBufPerCh;
decPrm.chCreateParams[i].profile = IH264VDEC_PROFILE_ANY;
decPrm.chCreateParams[i].displayDelay
= gVdecModuleContext.vdecConfig.decChannelParams[i].displayDelay;
decPrm.chCreateParams[i].dpbBufSizeInFrames = IH264VDEC_DPB_NUMFRAMES_AUTO;
decPrm.chCreateParams[i].fieldMergeDecodeEnable = FALSE;
decPrm.chCreateParams[i].targetMaxWidth =
ipcBitsOutHostPrm.inQueInfo.chInfo[i].width;
decPrm.chCreateParams[i].targetMaxHeight =
ipcBitsOutHostPrm.inQueInfo.chInfo[i].height;
decPrm.chCreateParams[i].defaultDynamicParams.targetFrameRate =
gVdecModuleContext.vdecConfig.decChannelParams[i].dynamicParam.frameRate;
decPrm.chCreateParams[i].defaultDynamicParams.targetBitRate =
gVdecModuleContext.vdecConfig.decChannelParams[i].dynamicParam.targetBitRate;
}
decPrm.inQueParams.prevLinkId = gVdecModuleContext.ipcBitsInRTOSId;
decPrm.inQueParams.prevLinkQueId = 0;
decPrm.outQueParams.nextLink = gMultiCh_VdecVdisObj.ipcOutVideoId;
decPrm.tilerEnable = tilerEnable;
ipcOutVideoPrm.inQueParams.prevLinkId = gVdecModuleContext.decId;
ipcOutVideoPrm.inQueParams.prevLinkQueId = 0;
ipcOutVideoPrm.outQueParams[0].nextLink = gMultiCh_VdecVdisObj.ipcInVpssId;
ipcOutVideoPrm.notifyNextLink = TRUE;
ipcOutVideoPrm.notifyPrevLink = TRUE;
ipcOutVideoPrm.numOutQue = 1;
ipcInVpssPrm.inQueParams.prevLinkId = gMultiCh_VdecVdisObj.ipcOutVideoId;
ipcInVpssPrm.inQueParams.prevLinkQueId = 0;
ipcInVpssPrm.notifyNextLink = TRUE;
ipcInVpssPrm.notifyPrevLink = TRUE;
ipcInVpssPrm.numOutQue = 1;
if (enableVideoFrameExport)
{
ipcFramesOutHostPrm.baseCreateParams.noNotifyMode = TRUE;
ipcFramesOutHostPrm.baseCreateParams.notifyNextLink = FALSE;
ipcFramesOutHostPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcFramesOutHostPrm.baseCreateParams.inQueParams.prevLinkId = SYSTEM_LINK_ID_INVALID;
ipcFramesOutHostPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesOutHostPrm.baseCreateParams.numOutQue = 1;
ipcFramesOutHostPrm.baseCreateParams.outQueParams[0].nextLink = gVdisModuleContext.ipcFramesInVpssFromHostId;
MultiCh_setIpcFramesOutInQueInfo(&ipcFramesOutHostPrm.inQueInfo);
ipcFramesInVpssFromHostPrm.baseCreateParams.noNotifyMode = TRUE;
ipcFramesInVpssFromHostPrm.baseCreateParams.notifyNextLink = TRUE;
ipcFramesInVpssFromHostPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcFramesInVpssFromHostPrm.baseCreateParams.inQueParams.prevLinkId = gVdisModuleContext.ipcFramesOutHostId;
ipcFramesInVpssFromHostPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesInVpssFromHostPrm.baseCreateParams.numOutQue = 1;
ipcFramesInVpssFromHostPrm.baseCreateParams.outQueParams[0].nextLink = gMultiCh_VdecVdisObj.mergeId;
ipcInVpssPrm.outQueParams[0].nextLink = gMultiCh_VdecVdisObj.mergeId;
mergePrm.numInQue = 2;
mergePrm.inQueParams[0].prevLinkId = gMultiCh_VdecVdisObj.ipcInVpssId;
mergePrm.inQueParams[0].prevLinkQueId = 0;
mergePrm.inQueParams[1].prevLinkId = gVdisModuleContext.ipcFramesInVpssFromHostId;
mergePrm.inQueParams[1].prevLinkQueId = 0;
#ifdef TI_816X_BUILD
mergePrm.outQueParams.nextLink = gMultiCh_VdecVdisObj.mpSclrId;
mergePrm.notifyNextLink = TRUE;
mpSclrPrm.inQueParams.prevLinkId = gMultiCh_VdecVdisObj.mergeId;
}
else
{
mpSclrPrm.inQueParams.prevLinkId = gMultiCh_VdecVdisObj.ipcInVpssId;
ipcInVpssPrm.outQueParams[0].nextLink = gMultiCh_VdecVdisObj.mpSclrId;
}
mpSclrPrm.pathId = MP_SCLR_LINK_SC5;
mpSclrPrm.numCh = 2;
mpSclrPrm.enableLineSkip = FALSE;
mpSclrPrm.outQueParams.nextLink = gMultiCh_VdecVdisObj.dupId;
dupPrm.inQueParams.prevLinkId = gMultiCh_VdecVdisObj.mpSclrId;
#else
mergePrm.outQueParams.nextLink = gMultiCh_VdecVdisObj.dupId;
mergePrm.notifyNextLink = TRUE;
dupPrm.inQueParams.prevLinkId = gMultiCh_VdecVdisObj.mergeId;
}
Int32 Vsys_printDetailedStatistics()
{
UInt32 devId;
if(gVcapModuleContext.captureId!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.captureId,
CAPTURE_LINK_CMD_PRINT_ADV_STATISTICS,
NULL, 0, TRUE);
}
for(devId=0; devId<MAX_SCLR_LINK; devId++)
{
if(gVcapModuleContext.sclrId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.sclrId[devId],
SCLR_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
for(devId=0; devId<MAX_NSF_LINK; devId++)
{
if(gVcapModuleContext.nsfId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.nsfId[devId],
NSF_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
OSA_waitMsecs(2000); // allow for print to complete
for(devId=0; devId<MAX_DEI_LINK; devId++)
{
if(gVcapModuleContext.deiId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.deiId[devId],
DEI_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
if (gVcapModuleContext.capSwMsId != SYSTEM_LINK_ID_INVALID)
System_linkControl(gVcapModuleContext.capSwMsId,
SYSTEM_SW_MS_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
for(devId=0; devId<VDIS_DEV_MAX; devId++)
{
if(gVdisModuleContext.swMsId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdisModuleContext.swMsId[devId],
SYSTEM_SW_MS_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
for(devId=0; devId<VDIS_DEV_MAX; devId++)
{
if(gVdisModuleContext.displayId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdisModuleContext.displayId[devId],
DISPLAY_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
for(devId=0; devId<MAX_IPC_FRAMES_LINK; devId++)
{
if(gVcapModuleContext.ipcFramesOutVpssId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.ipcFramesOutVpssId[devId],
IPCFRAMESOUTRTOS_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
OSA_waitMsecs(2000); // allow for print to complete
for(devId=0; devId<MAX_ALG_LINK; devId++)
{
if(gVcapModuleContext.dspAlgId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.dspAlgId[devId],
ALG_LINK_SCD_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
}
OSA_waitMsecs(2000); // allow for print to complete
if(gVencModuleContext.encId != SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVencModuleContext.encId,
ENC_LINK_CMD_PRINT_IVAHD_STATISTICS,
NULL, 0, TRUE);
}
else if (gVdecModuleContext.decId !=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdecModuleContext.decId,
DEC_LINK_CMD_PRINT_IVAHD_STATISTICS,
NULL, 0, TRUE);
}
if(gVencModuleContext.encId != SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVencModuleContext.encId,
ENC_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
if(gVdecModuleContext.decId != SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdecModuleContext.decId,
DEC_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
OSA_waitMsecs(2000); // allow for print to complete
#ifdef TI_816X_BUILD
if(gVdisModuleContext.mpSclrId != SYSTEM_LINK_ID_INVALID)
{
System_linkControl(SYSTEM_LINK_ID_MP_SCLR_INST_0,
MP_SCLR_LINK_CMD_PRINT_STATISTICS,
NULL, 0, TRUE);
}
#endif /* TI_816X_BUILD */
MultiCh_prfLoadPrint(TRUE,TRUE);
return ERROR_NONE;
}
Int32 Vsys_printBufferStatistics()
{
UInt32 devId;
if (gVdecModuleContext.ipcBitsOutHLOSId != SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdecModuleContext.ipcBitsOutHLOSId,
IPCBITSOUT_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
if(gVdecModuleContext.decId != SYSTEM_LINK_ID_INVALID)
{
int i;
VDEC_BUFFER_STATS_S bufStats;
bufStats.numCh = gVdecModuleContext.vdecConfig.numChn;
for (i = 0; i < gVdecModuleContext.vdecConfig.numChn;i++)
{
bufStats.chId[i] = i;
}
Vdec_getBufferStatistics(&bufStats);
printf("\r\n VDEC:Buffer Statistics");
printf("\r\n ChId | InBufCnt | OutBufCnt");
for (i = 0; i < gVdecModuleContext.vdecConfig.numChn;i++)
{
printf("\r\n %5d|%10d|%10d",
bufStats.chId[i],
bufStats.stats[i].numInBufQueCount,
bufStats.stats[i].numOutBufQueCount);
}
printf("\n");
}
if(gVcapModuleContext.captureId!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.captureId,
CAPTURE_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
for(devId=0; devId<MAX_NSF_LINK; devId++)
{
if(gVcapModuleContext.nsfId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.nsfId[devId],
NSF_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
}
for(devId=0; devId<MAX_DEI_LINK; devId++)
{
if(gVcapModuleContext.deiId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVcapModuleContext.deiId[devId],
DEI_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
}
for(devId=0; devId<VDIS_DEV_MAX; devId++)
{
if(gVdisModuleContext.swMsId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdisModuleContext.swMsId[devId],
SYSTEM_SW_MS_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
}
for(devId=0; devId<VDIS_DEV_MAX; devId++)
{
if(gVdisModuleContext.displayId[devId]!=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVdisModuleContext.displayId[devId],
DISPLAY_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
}
OSA_waitMsecs(500);
if(gVencModuleContext.encId !=SYSTEM_LINK_ID_INVALID)
{
System_linkControl(gVencModuleContext.encId,
ENC_LINK_CMD_PRINT_BUFFER_STATISTICS,
NULL, 0, TRUE);
}
OSA_waitMsecs(500);
return ERROR_NONE;
}
Int32 System_linkStart(UInt32 linkId)
{
return System_linkControl(linkId, SYSTEM_CMD_START, NULL, 0, TRUE);
}
Int32 System_linkStop(UInt32 linkId)
{
return System_linkControl(linkId, SYSTEM_CMD_STOP, NULL, 0, TRUE);
}
Void MultiCh_createVcapVdis()
{
CaptureLink_CreateParams capturePrm;
NsfLink_CreateParams nsfPrm;
DeiLink_CreateParams deiPrm[2];
NullSrcLink_CreateParams nullSrcPrm;
MergeLink_CreateParams mergePrm;
DupLink_CreateParams dupPrm;
static SwMsLink_CreateParams swMsPrm[VDIS_DEV_MAX];
DisplayLink_CreateParams displayPrm[VDIS_DEV_MAX];
CaptureLink_VipInstParams *pCaptureInstPrm;
CaptureLink_OutParams *pCaptureOutPrm;
VCAP_VIDDEC_PARAMS_S vidDecVideoModeArgs[NUM_CAPTURE_DEVICES];
UInt32 grpxId[VDIS_DEV_MAX];
UInt32 nullId;
UInt32 mergeId, dupId;
UInt32 deiOutQue;
UInt32 vipInstId;
UInt32 i;
UInt32 numSubChains;
Bool enableSdtv;
for (i = 0; i < VDIS_DEV_MAX; i++)
{
MULTICH_INIT_STRUCT(DisplayLink_CreateParams,displayPrm[i]);
MULTICH_INIT_STRUCT(SwMsLink_CreateParams ,swMsPrm[i]);
}
MultiCh_detectBoard();
System_linkControl(
SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_RESET_VIDEO_DEVICES,
NULL,
0,
TRUE
);
gVcapModuleContext.captureId = SYSTEM_LINK_ID_CAPTURE;
gVcapModuleContext.nsfId[0] = SYSTEM_LINK_ID_NSF_0;
gVcapModuleContext.deiId[0] = SYSTEM_LINK_ID_DEI_HQ_0;
gVcapModuleContext.deiId[1] = SYSTEM_LINK_ID_DEI_0;
gVcapModuleContext.nullSrcId = SYSTEM_VPSS_LINK_ID_NULL_SRC_0;
mergeId = SYSTEM_VPSS_LINK_ID_MERGE_0;
dupId = SYSTEM_VPSS_LINK_ID_DUP_0;
gVdisModuleContext.swMsId[0] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_0;
gVdisModuleContext.swMsId[1] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_1;
swMsPrm[0].numSwMsInst = 1;
swMsPrm[1].numSwMsInst = 1;
swMsPrm[0].swMsInstId[0] = SYSTEM_SW_MS_SC_INST_SC5;
swMsPrm[1].swMsInstId[0] = SYSTEM_SW_MS_SC_INST_SC5;
gVdisModuleContext.displayId[0] = SYSTEM_LINK_ID_DISPLAY_0; // ON CHIP HDMI
gVdisModuleContext.displayId[1] = SYSTEM_LINK_ID_DISPLAY_1; // OFF CHIP HDMI
gVdisModuleContext.displayId[2] = SYSTEM_LINK_ID_DISPLAY_2; // OFF CHIP HDMI
grpxId[0] = SYSTEM_LINK_ID_GRPX_0;
grpxId[1] = SYSTEM_LINK_ID_GRPX_1;
#if 0 /* Enabling graphics only for ON CHIP HDMI an OFF CHIP HDMI*/
grpxId[2] = SYSTEM_LINK_ID_GRPX_2;
#endif
nullId = SYSTEM_VPSS_LINK_ID_NULL_0;
numSubChains = 2;
deiOutQue = DEI_LINK_OUT_QUE_VIP_SC;
enableSdtv = FALSE;
CaptureLink_CreateParams_Init(&capturePrm);
capturePrm.numVipInst = 2 * numSubChains;
capturePrm.outQueParams[0].nextLink = gVcapModuleContext.nsfId[0];
capturePrm.tilerEnable = FALSE;
capturePrm.enableSdCrop = FALSE;
for(vipInstId=0; vipInstId<capturePrm.numVipInst; vipInstId++)
{
pCaptureInstPrm = &capturePrm.vipInst[vipInstId];
pCaptureInstPrm->vipInstId = (SYSTEM_CAPTURE_INST_VIP0_PORTA+vipInstId)%SYSTEM_CAPTURE_INST_MAX;
pCaptureInstPrm->videoDecoderId = SYSTEM_DEVICE_VID_DEC_TVP5158_DRV;
pCaptureInstPrm->inDataFormat = SYSTEM_DF_YUV422P;
pCaptureInstPrm->standard = SYSTEM_STD_MUX_4CH_D1;
pCaptureInstPrm->numOutput = 1;
pCaptureOutPrm = &pCaptureInstPrm->outParams[0];
pCaptureOutPrm->dataFormat = SYSTEM_DF_YUV422I_YUYV;
pCaptureOutPrm->scEnable = FALSE;
pCaptureOutPrm->scOutWidth = 0;
pCaptureOutPrm->scOutHeight = 0;
pCaptureOutPrm->outQueId = 0;
}
for(i = 0; i < NUM_CAPTURE_DEVICES; i++)
{
vidDecVideoModeArgs[i].videoIfMode = DEVICE_CAPT_VIDEO_IF_MODE_8BIT;
vidDecVideoModeArgs[i].videoDataFormat = SYSTEM_DF_YUV422P;
vidDecVideoModeArgs[i].standard = SYSTEM_STD_MUX_4CH_D1;
vidDecVideoModeArgs[i].videoCaptureMode =
DEVICE_CAPT_VIDEO_CAPTURE_MODE_MULTI_CH_PIXEL_MUX_EMBEDDED_SYNC;
vidDecVideoModeArgs[i].videoSystem =
DEVICE_VIDEO_DECODER_VIDEO_SYSTEM_AUTO_DETECT;
vidDecVideoModeArgs[i].videoCropEnable = FALSE;
vidDecVideoModeArgs[i].videoAutoDetectTimeout = -1;
}
Vcap_configVideoDecoder(vidDecVideoModeArgs, NUM_CAPTURE_DEVICES);
NsfLink_CreateParams_Init(&nsfPrm);
nsfPrm.bypassNsf = FALSE;
nsfPrm.tilerEnable = FALSE;
nsfPrm.inQueParams.prevLinkId = gVcapModuleContext.captureId;
nsfPrm.inQueParams.prevLinkQueId = 0;
nsfPrm.numOutQue = numSubChains;
nsfPrm.outQueParams[0].nextLink = gVcapModuleContext.deiId[0];
nsfPrm.outQueParams[1].nextLink = gVcapModuleContext.deiId[1];
nullSrcPrm.outQueParams.nextLink = mergeId;
nullSrcPrm.timerPeriod = 33;
nullSrcPrm.inputInfo.numCh = 16;
for(i=0; i<nullSrcPrm.inputInfo.numCh; i++)
{
System_LinkChInfo *pChInfo;
pChInfo = &nullSrcPrm.inputInfo.chInfo[i];
pChInfo->dataFormat = SYSTEM_DF_YUV420SP_UV;
pChInfo->memType = SYSTEM_MT_NONTILEDMEM;
pChInfo->startX = 48;
pChInfo->startY = 32;
pChInfo->width = 720;
pChInfo->height = 576;
pChInfo->pitch[0] = SystemUtils_align(pChInfo->width+pChInfo->startX, SYSTEM_BUFFER_ALIGNMENT);
pChInfo->pitch[1] = pChInfo->pitch[0];
pChInfo->pitch[2] = 0;
pChInfo->scanFormat = SYSTEM_SF_PROGRESSIVE;
}
for(i=0; i<numSubChains; i++)
{
Int32 chId;
DeiLink_CreateParams_Init(&deiPrm[i]);
deiPrm[i].inQueParams.prevLinkId = gVcapModuleContext.nsfId[0];
deiPrm[i].inQueParams.prevLinkQueId = i;
deiPrm[i].outQueParams[deiOutQue].nextLink = mergeId;
deiPrm[i].outQueParams[deiOutQue^1].nextLink = nullId;
deiPrm[i].enableOut[deiOutQue] = TRUE;
deiPrm[i].enableOut[deiOutQue^1] = FALSE;
deiPrm[i].tilerEnable[DEI_LINK_OUT_QUE_VIP_SC] = FALSE;
deiPrm[i].comprEnable = FALSE;
deiPrm[i].setVipScYuv422Format = FALSE;
/* DEI Path Scalar ratio is 1:2, D1 => CIF */
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].scaleMode = DEI_SCALE_MODE_RATIO;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.widthRatio.numerator = 1;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.widthRatio.denominator = 2;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.heightRatio.numerator = 1;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.heightRatio.denominator = 2;
for (chId=1; chId < DEI_LINK_MAX_CH; chId++)
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][chId] = deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0];
/* VIP Scalar ratio is 1:1 */
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].scaleMode = DEI_SCALE_MODE_RATIO;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.widthRatio.numerator = 1;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.widthRatio.denominator = 1;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.heightRatio.numerator = 1;
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.heightRatio.denominator = 1;
for (chId=1; chId < DEI_LINK_MAX_CH; chId++)
deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][chId] = deiPrm[i].outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0];
mergePrm.numInQue = numSubChains;
mergePrm.inQueParams[i].prevLinkId = gVcapModuleContext.deiId[i];
mergePrm.inQueParams[i].prevLinkQueId = deiOutQue;
mergePrm.outQueParams.nextLink = dupId;
mergePrm.notifyNextLink = TRUE;
dupPrm.inQueParams.prevLinkId = mergeId;
dupPrm.inQueParams.prevLinkQueId = 0;
dupPrm.numOutQue = numSubChains;
dupPrm.outQueParams[i].nextLink = gVdisModuleContext.swMsId[i];
dupPrm.notifyNextLink = TRUE;
}
mergePrm.numInQue = 3;
mergePrm.inQueParams[i].prevLinkId = gVcapModuleContext.nullSrcId;
mergePrm.inQueParams[i].prevLinkQueId = 0;
for(i=0; i<numSubChains; i++)
{
swMsPrm[i].inQueParams.prevLinkId = dupId;
swMsPrm[i].inQueParams.prevLinkQueId = i;
swMsPrm[i].outQueParams.nextLink = gVdisModuleContext.displayId[i];
swMsPrm[i].maxInputQueLen = SYSTEM_SW_MS_DEFAULT_INPUT_QUE_LEN;
swMsPrm[i].maxOutRes = VSYS_STD_1080P_60;
swMsPrm[i].initOutRes = gVdisModuleContext.vdisConfig.deviceParams[i].resolution;
swMsPrm[i].lineSkipMode = TRUE;
swMsPrm[i].enableLayoutGridDraw = gVdisModuleContext.vdisConfig.enableLayoutGridDraw;
MultiCh_swMsGetDefaultLayoutPrm(0, &swMsPrm[i], FALSE); /* Since only live preview is there, show it on both displays */
displayPrm[i].inQueParams[0].prevLinkId = gVdisModuleContext.swMsId[i];
displayPrm[i].inQueParams[0].prevLinkQueId = 0;
displayPrm[i].displayRes = swMsPrm[i].initOutRes;
}
if(enableSdtv)
{
dupPrm.numOutQue = 3;
dupPrm.outQueParams[2].nextLink = gVdisModuleContext.displayId[2];
}
displayPrm[2].numInputQueues = 1;
displayPrm[2].activeQueue = 0;
displayPrm[2].inQueParams[0].prevLinkId = dupId;
displayPrm[2].inQueParams[0].prevLinkQueId = 2;
displayPrm[2].displayRes = gVdisModuleContext.vdisConfig.deviceParams[VDIS_DEV_SD].resolution;
#ifndef SYSTEM_USE_VIDEO_DECODER
capturePrm.isPalMode = Vcap_isPalMode();
#endif
System_linkCreate (gVcapModuleContext.captureId, &capturePrm, sizeof(capturePrm));
System_linkCreate(gVcapModuleContext.nsfId[0] , &nsfPrm, sizeof(nsfPrm));
for(i=0; i<numSubChains; i++)
System_linkCreate(gVcapModuleContext.deiId[i] , &deiPrm[i], sizeof(deiPrm[i]));
System_linkCreate(gVcapModuleContext.nullSrcId , &nullSrcPrm, sizeof(nullSrcPrm));
System_linkCreate(mergeId , &mergePrm , sizeof(mergePrm));
System_linkCreate(dupId , &dupPrm , sizeof(dupPrm));
for(i=0; i<numSubChains; i++)
System_linkCreate(gVdisModuleContext.swMsId[i] , &swMsPrm[i], sizeof(swMsPrm[i]));
for(i=0; i<numSubChains; i++)
System_linkCreate(gVdisModuleContext.displayId[i], &displayPrm[i], sizeof(displayPrm[i]));
if(enableSdtv)
{
System_linkCreate(gVdisModuleContext.displayId[2], &displayPrm[2], sizeof(displayPrm[2]));
}
MultiCh_memPrintHeapStatus();
}
Int32 System_linkDelete(UInt32 linkId)
{
return System_linkControl(linkId, SYSTEM_CMD_DELETE, NULL, 0, TRUE);
}
/* This usecase assumes CIF/QCIF <secondary out>, MJPEG are enabled */
Void MultiCh_createProgressive8D1VcapVencVdecVdis()
{
CaptureLink_CreateParams capturePrm;
SclrLink_CreateParams sclrPrm;
NsfLink_CreateParams nsfPrm;
DeiLink_CreateParams deiPrm;
MergeLink_CreateParams mergePrm[NUM_MERGE_LINK];
DupLink_CreateParams dupPrm[NUM_DUP_LINK];
static SwMsLink_CreateParams swMsPrm[VDIS_DEV_MAX];
DisplayLink_CreateParams displayPrm[VDIS_DEV_MAX];
IpcLink_CreateParams ipcOutVpssPrm;
IpcLink_CreateParams ipcInVpssPrm;
IpcLink_CreateParams ipcOutVideoPrm;
IpcLink_CreateParams ipcInVideoPrm;
EncLink_CreateParams encPrm;
DecLink_CreateParams decPrm;
IpcBitsOutLinkHLOS_CreateParams ipcBitsOutHostPrm;
IpcBitsOutLinkRTOS_CreateParams ipcBitsOutVideoPrm;
IpcBitsInLinkHLOS_CreateParams ipcBitsInHostPrm[2];
IpcBitsInLinkRTOS_CreateParams ipcBitsInVideoPrm;
CaptureLink_VipInstParams *pCaptureInstPrm;
CaptureLink_OutParams *pCaptureOutPrm;
IpcFramesInLinkRTOS_CreateParams ipcFramesInDspPrm;
IpcFramesOutLinkRTOS_CreateParams ipcFramesOutVpssPrm;
AlgLink_CreateParams dspAlgPrm;
System_LinkInfo bitsProducerLinkInfo;
UInt32 mergeId[NUM_MERGE_LINK];
UInt32 dupId[NUM_DUP_LINK];
UInt32 ipcOutVpssId, ipcInVpssId;
UInt32 ipcOutVideoId, ipcInVideoId;
VCAP_VIDDEC_PARAMS_S vidDecVideoModeArgs[NUM_CAPTURE_DEVICES];
IpcBitsOutLinkRTOS_CreateParams ipcBitsOutDspPrm;
UInt32 ipcBitsOutDSPId;
UInt32 vipInstId;
UInt32 i, j;
Bool enableOsdAlgLink = gVsysModuleContext.vsysConfig.enableOsd;
Bool enableScdAlgLink = gVsysModuleContext.vsysConfig.enableScd;
MULTICH_INIT_STRUCT(IpcLink_CreateParams,ipcOutVpssPrm);
MULTICH_INIT_STRUCT(IpcLink_CreateParams,ipcInVpssPrm);
MULTICH_INIT_STRUCT(IpcLink_CreateParams,ipcOutVideoPrm);
MULTICH_INIT_STRUCT(IpcLink_CreateParams,ipcInVideoPrm);
MULTICH_INIT_STRUCT(IpcBitsOutLinkHLOS_CreateParams,ipcBitsOutHostPrm);
MULTICH_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams,ipcBitsOutVideoPrm);
MULTICH_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams,ipcBitsOutDspPrm);
MULTICH_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,ipcBitsInHostPrm[0]);
MULTICH_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,ipcBitsInHostPrm[1]);
MULTICH_INIT_STRUCT(IpcBitsInLinkRTOS_CreateParams,ipcBitsInVideoPrm);
MULTICH_INIT_STRUCT(DecLink_CreateParams, decPrm);
MULTICH_INIT_STRUCT(IpcFramesInLinkRTOS_CreateParams,ipcFramesInDspPrm);
MULTICH_INIT_STRUCT(IpcFramesOutLinkRTOS_CreateParams,ipcFramesOutVpssPrm);
MULTICH_INIT_STRUCT(EncLink_CreateParams, encPrm);
MULTICH_INIT_STRUCT(AlgLink_CreateParams, dspAlgPrm);
for (i = 0; i < VDIS_DEV_MAX;i++)
{
MULTICH_INIT_STRUCT(DisplayLink_CreateParams,
displayPrm[i]);
MULTICH_INIT_STRUCT(SwMsLink_CreateParams ,swMsPrm[i]);
}
MULTICH_INIT_STRUCT(SclrLink_CreateParams, sclrPrm);
MULTICH_INIT_STRUCT(NsfLink_CreateParams, nsfPrm);
MULTICH_INIT_STRUCT(DeiLink_CreateParams, deiPrm);
printf("\n********* Entered usecase 8CH <814x> Enc/Dec OSD %s SCD %s \n\n",
enableOsdAlgLink == TRUE ? "Enabled" : "Disabled",
enableScdAlgLink == TRUE ? "Enabled" : "Disabled"
);
MultiCh_detectBoard();
System_linkControl(
SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_RESET_VIDEO_DEVICES,
NULL,
0,
TRUE
);
System_linkControl(
SYSTEM_LINK_ID_M3VIDEO,
SYSTEM_COMMON_CMD_SET_CH2IVAHD_MAP_TBL,
&systemVid_encDecIvaChMapTbl,
sizeof(SystemVideo_Ivahd2ChMap_Tbl),
TRUE
);
#if (TILER_ENABLE == FALSE)
{
/* Disable tiler allocator for this usecase
* for that tiler memory can be reused for
* non-tiled allocation
*/
SystemTiler_disableAllocator();
}
#endif
vipInstId = 0;
gVcapModuleContext.captureId = SYSTEM_LINK_ID_CAPTURE;
if(enableOsdAlgLink || enableScdAlgLink)
{
dspAlgPrm.enableOSDAlg = TRUE;
gVcapModuleContext.dspAlgId[0] = SYSTEM_LINK_ID_ALG_0 ;
gVcapModuleContext.ipcFramesOutVpssId[0] = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_OUT_0;
gVcapModuleContext.ipcFramesInDspId[0] = SYSTEM_DSP_LINK_ID_IPC_FRAMES_IN_0;
if(enableScdAlgLink)
{
ipcBitsOutDSPId = SYSTEM_DSP_LINK_ID_IPC_BITS_OUT_0;
gVcapModuleContext.ipcBitsInHLOSId = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_0;
}
}
gVcapModuleContext.sclrId[0] = SYSTEM_LINK_ID_SCLR_INST_0;
gVcapModuleContext.nsfId[0] = SYSTEM_LINK_ID_NSF_0;
gVcapModuleContext.deiId[0] = SYSTEM_LINK_ID_DEI_0;
gVencModuleContext.encId = SYSTEM_LINK_ID_VENC_0;
gVdecModuleContext.decId = SYSTEM_LINK_ID_VDEC_0;
gVdisModuleContext.swMsId[0] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_0;
gVdisModuleContext.swMsId[1] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_1;
swMsPrm[0].numSwMsInst = 1;
swMsPrm[1].numSwMsInst = 1;
#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
/* use AUX scaler (SC2), since SC1 is used for DEI */
swMsPrm[0].swMsInstId[0] = SYSTEM_SW_MS_SC_INST_DEI_SC_NO_DEI;
#else
/* use MAIN scaler (SC1), since SC2 is used for DEI */
swMsPrm[0].swMsInstId[0] = SYSTEM_SW_MS_SC_INST_DEIHQ_SC_NO_DEI;
#endif
swMsPrm[1].swMsInstId[0] = SYSTEM_SW_MS_SC_INST_SC5;
gVdisModuleContext.displayId[0] = SYSTEM_LINK_ID_DISPLAY_0; /* ON AND OFF CHIP HDMI */
gVdisModuleContext.displayId[1] = SYSTEM_LINK_ID_DISPLAY_2; /* SDTV */
mergeId[LIVE_DECODE_MERGE_LINK_IDX] = SYSTEM_VPSS_LINK_ID_MERGE_0;
mergeId[D1_CIF_MERGE_LINK_IDX] = SYSTEM_VPSS_LINK_ID_MERGE_1;
dupId[CAP_DUP_LINK_IDX] = SYSTEM_VPSS_LINK_ID_DUP_0;
dupId[LIVE_DECODE_DUP_LINK_IDX] = SYSTEM_VPSS_LINK_ID_DUP_1;
ipcOutVpssId = SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0;
ipcInVideoId = SYSTEM_VIDEO_LINK_ID_IPC_IN_M3_0;
ipcOutVideoId= SYSTEM_VIDEO_LINK_ID_IPC_OUT_M3_0;
ipcInVpssId = SYSTEM_VPSS_LINK_ID_IPC_IN_M3_0;
gVencModuleContext.ipcBitsOutRTOSId = SYSTEM_VIDEO_LINK_ID_IPC_BITS_OUT_0;
if(enableScdAlgLink)
gVencModuleContext.ipcBitsInHLOSId = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_1;
else
gVencModuleContext.ipcBitsInHLOSId = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_0;
gVdecModuleContext.ipcBitsOutHLOSId = SYSTEM_HOST_LINK_ID_IPC_BITS_OUT_0;
gVdecModuleContext.ipcBitsInRTOSId = SYSTEM_VIDEO_LINK_ID_IPC_BITS_IN_0;
CaptureLink_CreateParams_Init(&capturePrm);
capturePrm.outQueParams[0].nextLink = dupId[CAP_DUP_LINK_IDX];
capturePrm.numVipInst = 2;
capturePrm.tilerEnable = FALSE;
capturePrm.numBufsPerCh = NUM_CAPTURE_BUFFERS;
capturePrm.maxBlindAreasPerCh = 4;
pCaptureInstPrm = &capturePrm.vipInst[0];
pCaptureInstPrm->vipInstId = (SYSTEM_CAPTURE_INST_VIP0_PORTA+
vipInstId)%SYSTEM_CAPTURE_INST_MAX;
pCaptureInstPrm->videoDecoderId = SYSTEM_DEVICE_VID_DEC_TVP5158_DRV;
pCaptureInstPrm->inDataFormat = SYSTEM_DF_YUV422P;
pCaptureInstPrm->standard = SYSTEM_STD_MUX_4CH_D1;
pCaptureInstPrm->numOutput = 1;
pCaptureOutPrm = &pCaptureInstPrm->outParams[0];
pCaptureOutPrm->dataFormat = SYSTEM_DF_YUV422I_YUYV;
pCaptureOutPrm->scEnable = FALSE;
pCaptureOutPrm->scOutWidth = 0;
pCaptureOutPrm->scOutHeight = 0;
pCaptureOutPrm->outQueId = 0;
pCaptureInstPrm = &capturePrm.vipInst[1];
pCaptureInstPrm->vipInstId = SYSTEM_CAPTURE_INST_VIP0_PORTB;
pCaptureInstPrm->videoDecoderId = SYSTEM_DEVICE_VID_DEC_TVP5158_DRV;
pCaptureInstPrm->inDataFormat = SYSTEM_DF_YUV422P;
pCaptureInstPrm->standard = SYSTEM_STD_MUX_4CH_D1;
pCaptureInstPrm->numOutput = 1;
pCaptureOutPrm = &pCaptureInstPrm->outParams[0];
pCaptureOutPrm->dataFormat = SYSTEM_DF_YUV422I_YUYV;
pCaptureOutPrm->scEnable = FALSE;
pCaptureOutPrm->scOutWidth = 0;
pCaptureOutPrm->scOutHeight = 0;
pCaptureOutPrm->outQueId = 0;
for(i = 0; i < NUM_CAPTURE_DEVICES; i++)
{
vidDecVideoModeArgs[i].videoIfMode = DEVICE_CAPT_VIDEO_IF_MODE_8BIT;
vidDecVideoModeArgs[i].videoDataFormat = SYSTEM_DF_YUV422P;
vidDecVideoModeArgs[i].standard = SYSTEM_STD_MUX_4CH_D1;
vidDecVideoModeArgs[i].videoCaptureMode =
DEVICE_CAPT_VIDEO_CAPTURE_MODE_MULTI_CH_PIXEL_MUX_EMBEDDED_SYNC;
vidDecVideoModeArgs[i].videoSystem =
DEVICE_VIDEO_DECODER_VIDEO_SYSTEM_AUTO_DETECT;
vidDecVideoModeArgs[i].videoCropEnable = FALSE;
vidDecVideoModeArgs[i].videoAutoDetectTimeout = -1;
}
Vcap_configVideoDecoder(vidDecVideoModeArgs, NUM_CAPTURE_DEVICES);
dupPrm[CAP_DUP_LINK_IDX].inQueParams.prevLinkId = gVcapModuleContext.captureId;
dupPrm[CAP_DUP_LINK_IDX].inQueParams.prevLinkQueId = 0;
dupPrm[CAP_DUP_LINK_IDX].notifyNextLink = TRUE;
dupPrm[CAP_DUP_LINK_IDX].numOutQue = 2;
dupPrm[CAP_DUP_LINK_IDX].outQueParams[0].nextLink = gVcapModuleContext.deiId[0];
dupPrm[CAP_DUP_LINK_IDX].outQueParams[1].nextLink = gVcapModuleContext.sclrId[0];
deiPrm.inQueParams.prevLinkId = dupId[CAP_DUP_LINK_IDX];
deiPrm.inQueParams.prevLinkQueId = 0;
/* Set Output Scaling at DEI based on ratio */
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].scaleMode = DEI_SCALE_MODE_RATIO;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.widthRatio.numerator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.widthRatio.denominator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.heightRatio.numerator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0].ratio.heightRatio.denominator = 1;
for (i=1; i < DEI_LINK_MAX_CH; i++)
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][i] = deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_DEI_SC][0];
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].scaleMode = DEI_SCALE_MODE_RATIO;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.heightRatio.numerator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.heightRatio.denominator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.widthRatio.numerator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.widthRatio.denominator = 1;
for (i=1; i < DEI_LINK_MAX_CH; i++)
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][i] = deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0];
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][0].scaleMode = DEI_SCALE_MODE_RATIO;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][0].ratio.heightRatio.numerator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][0].ratio.heightRatio.denominator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][0].ratio.widthRatio.numerator = 1;
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][0].ratio.widthRatio.denominator = 1;
for (i=1; i < DEI_LINK_MAX_CH; i++)
deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][i] = deiPrm.outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT][0];
deiPrm.enableOut[DEI_LINK_OUT_QUE_DEI_SC] = TRUE;
deiPrm.enableOut[DEI_LINK_OUT_QUE_VIP_SC] = TRUE;
deiPrm.enableOut[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT] = TRUE;
deiPrm.outputFrameRate[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT] = 1;
deiPrm.outQueParams[DEI_LINK_OUT_QUE_DEI_SC].nextLink = mergeId[LIVE_DECODE_MERGE_LINK_IDX];
deiPrm.outQueParams[DEI_LINK_OUT_QUE_VIP_SC].nextLink = mergeId[D1_CIF_MERGE_LINK_IDX];
deiPrm.outQueParams[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT].nextLink = mergeId[D1_CIF_MERGE_LINK_IDX];
deiPrm.tilerEnable[DEI_LINK_OUT_QUE_VIP_SC] = TILER_ENABLE;
deiPrm.comprEnable = FALSE;
deiPrm.setVipScYuv422Format = FALSE;
sclrPrm.enableLineSkipSc = FALSE;
sclrPrm.inputFrameRate = 30;
sclrPrm.outputFrameRate = 30;
sclrPrm.inQueParams.prevLinkId = dupId[CAP_DUP_LINK_IDX];
sclrPrm.inQueParams.prevLinkQueId = 1;
sclrPrm.outQueParams.nextLink = gVcapModuleContext.nsfId[0];
sclrPrm.scaleMode = DEI_SCALE_MODE_RATIO;
sclrPrm.outScaleFactor.ratio.heightRatio.numerator = 1;
sclrPrm.outScaleFactor.ratio.heightRatio.denominator = 2;
sclrPrm.outScaleFactor.ratio.widthRatio.numerator = 1;
sclrPrm.outScaleFactor.ratio.widthRatio.denominator = 4;
sclrPrm.tilerEnable = FALSE;
nsfPrm.bypassNsf = TRUE;
nsfPrm.tilerEnable = FALSE;
nsfPrm.inQueParams.prevLinkId = gVcapModuleContext.sclrId[0];
nsfPrm.inQueParams.prevLinkQueId = 0;
nsfPrm.numOutQue = 1;
nsfPrm.outQueParams[0].nextLink = mergeId[D1_CIF_MERGE_LINK_IDX];
nsfPrm.numBufsPerCh = NUM_NSF_BUFFERS;
nsfPrm.inputFrameRate = 30;
nsfPrm.outputFrameRate = 30;
/* Merge Q0 - D1 <from VIP-SC>, Q1 - CIF <from VIP-SC_SECONDARY>, Q2 -D1 for MJPEG <from DEI-SC> */
mergePrm[D1_CIF_MERGE_LINK_IDX].inQueParams[0].prevLinkId = gVcapModuleContext.deiId[0];
mergePrm[D1_CIF_MERGE_LINK_IDX].inQueParams[0].prevLinkQueId = DEI_LINK_OUT_QUE_VIP_SC;
mergePrm[D1_CIF_MERGE_LINK_IDX].inQueParams[1].prevLinkId = gVcapModuleContext.nsfId[0];
mergePrm[D1_CIF_MERGE_LINK_IDX].inQueParams[1].prevLinkQueId = 0;
mergePrm[D1_CIF_MERGE_LINK_IDX].inQueParams[2].prevLinkId = gVcapModuleContext.deiId[0];
mergePrm[D1_CIF_MERGE_LINK_IDX].inQueParams[2].prevLinkQueId = DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT;
mergePrm[D1_CIF_MERGE_LINK_IDX].notifyNextLink = TRUE;
mergePrm[D1_CIF_MERGE_LINK_IDX].numInQue = 3;
if (enableOsdAlgLink || enableScdAlgLink)
{
mergePrm[D1_CIF_MERGE_LINK_IDX].outQueParams.nextLink = gVcapModuleContext.ipcFramesOutVpssId[0];
ipcOutVpssPrm.inQueParams.prevLinkId = gVcapModuleContext.ipcFramesOutVpssId[0];
/* Redirect to DSP for OSD / SCD */
ipcFramesOutVpssPrm .baseCreateParams.inQueParams.prevLinkId = mergeId[D1_CIF_MERGE_LINK_IDX];
ipcFramesOutVpssPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesOutVpssPrm.baseCreateParams.outQueParams[0].nextLink = ipcOutVpssId;
ipcFramesOutVpssPrm.baseCreateParams.processLink = gVcapModuleContext.ipcFramesInDspId[0];
ipcFramesOutVpssPrm.baseCreateParams.notifyPrevLink = TRUE;
ipcFramesOutVpssPrm.baseCreateParams.notifyNextLink = TRUE;
ipcFramesOutVpssPrm.baseCreateParams.notifyProcessLink = TRUE;
ipcFramesOutVpssPrm.baseCreateParams.noNotifyMode = FALSE;
ipcFramesOutVpssPrm.baseCreateParams.numOutQue = 1;
ipcFramesInDspPrm.baseCreateParams.inQueParams.prevLinkId = gVcapModuleContext.ipcFramesOutVpssId[0];
ipcFramesInDspPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesInDspPrm.baseCreateParams.outQueParams[0].nextLink = gVcapModuleContext.dspAlgId[0];
ipcFramesInDspPrm.baseCreateParams.notifyPrevLink = TRUE;
ipcFramesInDspPrm.baseCreateParams.notifyNextLink = TRUE;
ipcFramesInDspPrm.baseCreateParams.noNotifyMode = FALSE;
ipcFramesInDspPrm.baseCreateParams.numOutQue = 1;
dspAlgPrm.inQueParams.prevLinkId = gVcapModuleContext.ipcFramesInDspId[0];
dspAlgPrm.inQueParams.prevLinkQueId = 0;
}
else
{
mergePrm[D1_CIF_MERGE_LINK_IDX].outQueParams.nextLink = ipcOutVpssId;
ipcOutVpssPrm.inQueParams.prevLinkId = mergeId[D1_CIF_MERGE_LINK_IDX];
}
ipcOutVpssPrm.inQueParams.prevLinkQueId = 0;
ipcOutVpssPrm.numOutQue = 1;
ipcOutVpssPrm.outQueParams[0].nextLink = ipcInVideoId;
ipcOutVpssPrm.notifyNextLink = TRUE;
ipcOutVpssPrm.notifyPrevLink = TRUE;
ipcOutVpssPrm.noNotifyMode = FALSE;
ipcInVideoPrm.inQueParams.prevLinkId = ipcOutVpssId;
ipcInVideoPrm.inQueParams.prevLinkQueId = 0;
ipcInVideoPrm.numOutQue = 1;
ipcInVideoPrm.outQueParams[0].nextLink = gVencModuleContext.encId;
ipcInVideoPrm.notifyNextLink = TRUE;
ipcInVideoPrm.notifyPrevLink = TRUE;
ipcInVideoPrm.noNotifyMode = FALSE;
encPrm.numBufPerCh[0] = NUM_ENCODE_D1_BUFFERS;
encPrm.numBufPerCh[1] = NUM_ENCODE_CIF_BUFFERS;
{
EncLink_ChCreateParams *pLinkChPrm;
EncLink_ChDynamicParams *pLinkDynPrm;
VENC_CHN_DYNAMIC_PARAM_S *pDynPrm;
VENC_CHN_PARAMS_S *pChPrm;
/* Primary Stream Params - D1 */
for (i=0; i<gVencModuleContext.vencConfig.numPrimaryChn; i++)
{
pLinkChPrm = &encPrm.chCreateParams[i];
pLinkDynPrm = &pLinkChPrm->defaultDynamicParams;
pChPrm = &gVencModuleContext.vencConfig.encChannelParams[i];
pDynPrm = &pChPrm->dynamicParam;
pLinkChPrm->format = IVIDEO_H264HP;
pLinkChPrm->profile = gVencModuleContext.vencConfig.h264Profile[i];
pLinkChPrm->dataLayout = IVIDEO_FIELD_SEPARATED;
pLinkChPrm->fieldMergeEncodeEnable = FALSE;
pLinkChPrm->enableAnalyticinfo = pChPrm->enableAnalyticinfo;
pLinkChPrm->enableWaterMarking = pChPrm->enableWaterMarking;
pLinkChPrm->maxBitRate = pChPrm->maxBitRate;
pLinkChPrm->encodingPreset = pChPrm->encodingPreset;
pLinkChPrm->rateControlPreset = pChPrm->rcType;
pLinkChPrm->enableSVCExtensionFlag = pChPrm->enableSVCExtensionFlag;
pLinkChPrm->numTemporalLayer = pChPrm->numTemporalLayer;
pLinkDynPrm->intraFrameInterval = pDynPrm->intraFrameInterval;
pLinkDynPrm->targetBitRate = pDynPrm->targetBitRate;
pLinkDynPrm->interFrameInterval = 1;
pLinkDynPrm->mvAccuracy = IVIDENC2_MOTIONVECTOR_QUARTERPEL;
pLinkDynPrm->inputFrameRate = pDynPrm->inputFrameRate;
pLinkDynPrm->rcAlg = pDynPrm->rcAlg;
pLinkDynPrm->qpMin = pDynPrm->qpMin;
pLinkDynPrm->qpMax = pDynPrm->qpMax;
pLinkDynPrm->qpInit = pDynPrm->qpInit;
pLinkDynPrm->vbrDuration = pDynPrm->vbrDuration;
pLinkDynPrm->vbrSensitivity = pDynPrm->vbrSensitivity;
}
if (gVsysModuleContext.vsysConfig.enableSecondaryOut == TRUE)
{
/* Secondary Out <CIF> Params */
for (i=gVencModuleContext.vencConfig.numPrimaryChn, j=VENC_PRIMARY_CHANNELS;
i<(gVencModuleContext.vencConfig.numPrimaryChn
+ gVencModuleContext.vencConfig.numSecondaryChn);
i++, j++)
{
pLinkChPrm = &encPrm.chCreateParams[i];
pLinkDynPrm = &pLinkChPrm->defaultDynamicParams;
pChPrm = &gVencModuleContext.vencConfig.encChannelParams[j];
pDynPrm = &pChPrm->dynamicParam;
pLinkChPrm->format = IVIDEO_H264HP;
pLinkChPrm->profile = gVencModuleContext.vencConfig.h264Profile[i];
pLinkChPrm->dataLayout = IVIDEO_FIELD_SEPARATED;
pLinkChPrm->fieldMergeEncodeEnable = FALSE;
pLinkChPrm->enableAnalyticinfo = pChPrm->enableAnalyticinfo;
pLinkChPrm->enableWaterMarking = pChPrm->enableWaterMarking;
pLinkChPrm->maxBitRate = pChPrm->maxBitRate;
pLinkChPrm->encodingPreset = pChPrm->encodingPreset;
pLinkChPrm->rateControlPreset = pChPrm->rcType;
pLinkChPrm->enableSVCExtensionFlag = pChPrm->enableSVCExtensionFlag;
pLinkChPrm->numTemporalLayer = pChPrm->numTemporalLayer;
pLinkDynPrm->intraFrameInterval = pDynPrm->intraFrameInterval;
pLinkDynPrm->targetBitRate = pDynPrm->targetBitRate;
pLinkDynPrm->interFrameInterval = 1;
pLinkDynPrm->mvAccuracy = IVIDENC2_MOTIONVECTOR_QUARTERPEL;
pLinkDynPrm->inputFrameRate = pDynPrm->inputFrameRate;
pLinkDynPrm->rcAlg = pDynPrm->rcAlg;
pLinkDynPrm->qpMin = pDynPrm->qpMin;
pLinkDynPrm->qpMax = pDynPrm->qpMax;
pLinkDynPrm->qpInit = pDynPrm->qpInit;
pLinkDynPrm->vbrDuration = pDynPrm->vbrDuration;
pLinkDynPrm->vbrSensitivity = pDynPrm->vbrSensitivity;
}
}
/* MJPEG Params */
if (gVsysModuleContext.vsysConfig.enableMjpegEnc == TRUE)
{
for (i=gVencModuleContext.vencConfig.numPrimaryChn + gVencModuleContext.vencConfig.numSecondaryChn;
i<(VENC_CHN_MAX); i++)
{
pLinkChPrm = &encPrm.chCreateParams[i];
pLinkDynPrm = &pLinkChPrm->defaultDynamicParams;
pChPrm = &gVencModuleContext.vencConfig.encChannelParams[i];
pDynPrm = &pChPrm->dynamicParam;
pLinkChPrm->format = IVIDEO_MJPEG;
pLinkChPrm->profile = 0;
pLinkChPrm->dataLayout = IVIDEO_FIELD_SEPARATED;
pLinkChPrm->fieldMergeEncodeEnable = FALSE;
pLinkChPrm->enableAnalyticinfo = 0;
pLinkChPrm->enableWaterMarking = 0;
pLinkChPrm->maxBitRate = 0;
pLinkChPrm->encodingPreset = 0;
pLinkChPrm->rateControlPreset = 0;
pLinkChPrm->enableSVCExtensionFlag = 0;
pLinkChPrm->numTemporalLayer = 0;
pLinkDynPrm->intraFrameInterval = 0;
pLinkDynPrm->targetBitRate = 100*1000;
pLinkDynPrm->interFrameInterval = 0;
pLinkDynPrm->mvAccuracy = 0;
pLinkDynPrm->inputFrameRate = 1;//pDynPrm->inputFrameRate;
pLinkDynPrm->qpMin = 0;
pLinkDynPrm->qpMax = 0;
pLinkDynPrm->qpInit = -1;
pLinkDynPrm->vbrDuration = 0;
pLinkDynPrm->vbrSensitivity = 0;
}
}
encPrm.inQueParams.prevLinkId = ipcInVideoId;
encPrm.inQueParams.prevLinkQueId = 0;
encPrm.outQueParams.nextLink = gVencModuleContext.ipcBitsOutRTOSId;
}
ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkId = gVencModuleContext.encId;
ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsOutVideoPrm.baseCreateParams.numOutQue = 1;
ipcBitsOutVideoPrm.baseCreateParams.outQueParams[0].nextLink = gVencModuleContext.ipcBitsInHLOSId;
MultiCh_ipcBitsInitCreateParams_BitsOutRTOS(&ipcBitsOutVideoPrm,
TRUE);
ipcBitsInHostPrm[0].baseCreateParams.inQueParams.prevLinkId = gVencModuleContext.ipcBitsOutRTOSId;
ipcBitsInHostPrm[0].baseCreateParams.inQueParams.prevLinkQueId = 0;
MultiCh_ipcBitsInitCreateParams_BitsInHLOS(&ipcBitsInHostPrm[0]);
if(enableOsdAlgLink)
{
int chId;
for(chId = 0; chId < ALG_LINK_OSD_MAX_CH; chId++)
{
AlgLink_OsdChWinParams * chWinPrm = &dspAlgPrm.osdChCreateParams[chId].chDefaultParams;
/* set osd window max width and height */
dspAlgPrm.osdChCreateParams[chId].maxWidth = EXAMPLE_OSD_WIN_MAX_WIDTH;
dspAlgPrm.osdChCreateParams[chId].maxHeight = EXAMPLE_OSD_WIN_MAX_HEIGHT;
chWinPrm->chId = chId;
chWinPrm->numWindows = 0;
}
}
if (enableScdAlgLink)
{
Int32 numBlksInFrame;
Int32 numHorzBlks, numVertBlks, chId;
Uint32 x, y, i;
//AlgLink_ScdblkChngConfig blkConfig[ALG_LINK_SCD_MAX_BLOCKS_IN_FRAME];
dspAlgPrm.enableSCDAlg = TRUE;
dspAlgPrm.outQueParams[ALG_LINK_SCD_OUT_QUE].nextLink = ipcBitsOutDSPId;
dspAlgPrm.scdCreateParams.maxWidth = 176;
dspAlgPrm.scdCreateParams.maxHeight = 144;
dspAlgPrm.scdCreateParams.maxStride = 176;
dspAlgPrm.scdCreateParams.numValidChForSCD = 8;
dspAlgPrm.scdCreateParams.numSecs2WaitB4Init = 3;
dspAlgPrm.scdCreateParams.numSecs2WaitB4FrmAlert= 1;
dspAlgPrm.scdCreateParams.inputFrameRate = 30;
dspAlgPrm.scdCreateParams.outputFrameRate = 5;
dspAlgPrm.scdCreateParams.numSecs2WaitAfterFrmAlert = 2;
dspAlgPrm.scdCreateParams.enableMotionNotify = FALSE;
dspAlgPrm.scdCreateParams.enableTamperNotify = FALSE;
// Configure array to monitor scene changes in all frame blocks, i.e., motion detection.
// Each block is fixed to be 32x10 in size,
numHorzBlks = ((dspAlgPrm.scdCreateParams.maxWidth + 0x1F ) & (~0x1F)) / 32;
if (dspAlgPrm.scdCreateParams.maxHeight == 120)
numVertBlks = dspAlgPrm.scdCreateParams.maxHeight / 10;
else
numVertBlks = dspAlgPrm.scdCreateParams.maxHeight / 12;
numBlksInFrame = numHorzBlks * numVertBlks;
for(chId = 0; chId < dspAlgPrm.scdCreateParams.numValidChForSCD; chId++)
{
AlgLink_ScdChParams * chPrm = &dspAlgPrm.scdCreateParams.chDefaultParams[chId];
chPrm->blkNumBlksInFrame = numBlksInFrame;
chPrm->chId = SCDChannelMonitor[chId];
chPrm->mode = ALG_LINK_SCD_DETECTMODE_MONITOR_BLOCKS_AND_FRAME;
chPrm->frmIgnoreLightsON = FALSE;
chPrm->frmIgnoreLightsOFF = FALSE;
chPrm->frmSensitivity = ALG_LINK_SCD_SENSITIVITY_MID;
chPrm->frmEdgeThreshold = 100;
i = 0;
for(y = 0; y < numVertBlks; y++)
{
for(x = 0; x < numHorzBlks; x++)
{
chPrm->blkConfig[i].sensitivity = ALG_LINK_SCD_SENSITIVITY_MID;
chPrm->blkConfig[i].monitored = 0;
i++;
}
}
}
ipcBitsOutDspPrm.baseCreateParams.inQueParams.prevLinkId = gVcapModuleContext.dspAlgId[0];
ipcBitsOutDspPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsOutDspPrm.baseCreateParams.numOutQue = 1;
ipcBitsOutDspPrm.baseCreateParams.outQueParams[0].nextLink = gVcapModuleContext.ipcBitsInHLOSId;
MultiCh_ipcBitsInitCreateParams_BitsOutRTOS(&ipcBitsOutDspPrm,
TRUE);
ipcBitsOutDspPrm.baseCreateParams.notifyNextLink = TRUE;
ipcBitsOutDspPrm.baseCreateParams.noNotifyMode = FALSE;
ipcBitsInHostPrm[1].baseCreateParams.inQueParams.prevLinkId = ipcBitsOutDSPId;
ipcBitsInHostPrm[1].baseCreateParams.inQueParams.prevLinkQueId = 0;
MultiCh_ipcBitsInitCreateParams_BitsInHLOSVcap(&ipcBitsInHostPrm[1]);
ipcBitsInHostPrm[1].baseCreateParams.notifyPrevLink = TRUE;
ipcBitsInHostPrm[1].baseCreateParams.noNotifyMode = FALSE;
}
else
{
dspAlgPrm.outQueParams[ALG_LINK_SCD_OUT_QUE].nextLink = SYSTEM_LINK_ID_INVALID;
}
#ifndef SYSTEM_USE_VIDEO_DECODER
capturePrm.isPalMode = Vcap_isPalMode();
#endif
System_linkCreate (gVcapModuleContext.captureId, &capturePrm, sizeof(capturePrm));
System_linkCreate(dupId[CAP_DUP_LINK_IDX], &dupPrm[CAP_DUP_LINK_IDX], sizeof(dupPrm[CAP_DUP_LINK_IDX]));
System_linkCreate(gVcapModuleContext.sclrId[0], &sclrPrm, sizeof(sclrPrm));
System_linkCreate(gVcapModuleContext.nsfId[0] , &nsfPrm, sizeof(nsfPrm));
System_linkCreate(gVcapModuleContext.deiId[0], &deiPrm, sizeof(deiPrm));
System_linkCreate(mergeId[D1_CIF_MERGE_LINK_IDX], &mergePrm[D1_CIF_MERGE_LINK_IDX], sizeof(mergePrm[D1_CIF_MERGE_LINK_IDX]));
if(enableOsdAlgLink || enableScdAlgLink)
{
System_linkCreate(gVcapModuleContext.ipcFramesOutVpssId[0], &ipcFramesOutVpssPrm, sizeof(ipcFramesOutVpssPrm));
System_linkCreate(gVcapModuleContext.ipcFramesInDspId[0], &ipcFramesInDspPrm, sizeof(ipcFramesInDspPrm));
System_linkCreate(gVcapModuleContext.dspAlgId[0] , &dspAlgPrm, sizeof(dspAlgPrm));
if(enableScdAlgLink)
{
System_linkCreate(ipcBitsOutDSPId, &ipcBitsOutDspPrm, sizeof(ipcBitsOutDspPrm));
System_linkCreate(gVcapModuleContext.ipcBitsInHLOSId, &ipcBitsInHostPrm[1], sizeof(ipcBitsInHostPrm[1]));
}
}
System_linkCreate(ipcOutVpssId , &ipcOutVpssPrm , sizeof(ipcOutVpssPrm) );
System_linkCreate(ipcInVideoId , &ipcInVideoPrm , sizeof(ipcInVideoPrm) );
System_linkCreate(gVencModuleContext.encId, &encPrm, sizeof(encPrm));
System_linkCreate(gVencModuleContext.ipcBitsOutRTOSId, &ipcBitsOutVideoPrm, sizeof(ipcBitsOutVideoPrm));
System_linkCreate(gVencModuleContext.ipcBitsInHLOSId, &ipcBitsInHostPrm[0], sizeof(ipcBitsInHostPrm[0]));
System_linkGetInfo(gVencModuleContext.ipcBitsInHLOSId,&bitsProducerLinkInfo);
OSA_assert(bitsProducerLinkInfo.numQue == 1);
ipcBitsOutHostPrm.baseCreateParams.outQueParams[0].nextLink = gVdecModuleContext.ipcBitsInRTOSId;
printf ("\n\n========bitsProducerLinkInfo============\n");
printf ("numQ %d, numCh %d\n",
bitsProducerLinkInfo.numQue,
bitsProducerLinkInfo.queInfo[0].numCh);
{
int i;
for (i=0; i<bitsProducerLinkInfo.queInfo[0].numCh; i++)
{
printf ("Ch [%d] Width %d, Height %d\n",
i,
bitsProducerLinkInfo.queInfo[0].chInfo[i].width,
bitsProducerLinkInfo.queInfo[0].chInfo[i].height
);
}
}
printf ("\n====================\n\n");
if (bitsProducerLinkInfo.queInfo[0].numCh > gVencModuleContext.vencConfig.numPrimaryChn)
bitsProducerLinkInfo.queInfo[0].numCh = gVencModuleContext.vencConfig.numPrimaryChn;
printf ("Reducing bitsProducerLinkInfo.numCh to %d\n", bitsProducerLinkInfo.queInfo[0].numCh);
MultiCh_ipcBitsInitCreateParams_BitsOutHLOS(&ipcBitsOutHostPrm,
&bitsProducerLinkInfo.queInfo[0]);
ipcBitsOutHostPrm.numBufPerCh[0] = NUM_IPC_OUT_BUFFERS;
if(gVdecModuleContext.vdecConfig.forceUseDecChannelParams)
{
/* use channel info provided by user instead of from encoder */
UInt32 chId;
System_LinkChInfo *pChInfo;
ipcBitsOutHostPrm.inQueInfo.numCh = gVdecModuleContext.vdecConfig.numChn;
for(chId=0; chId<ipcBitsOutHostPrm.inQueInfo.numCh; chId++)
{
pChInfo = &ipcBitsOutHostPrm.inQueInfo.chInfo[chId];
/* Not Used - Start */
pChInfo->bufType = 0;
pChInfo->codingformat = 0;
pChInfo->dataFormat = 0;
pChInfo->memType = 0;
pChInfo->startX = 0;
pChInfo->startY = 0;
pChInfo->pitch[0] = 0;
pChInfo->pitch[1] = 0;
pChInfo->pitch[2] = 0;
/* Not Used - End */
pChInfo->width = gVdecModuleContext.vdecConfig.decChannelParams[chId].maxVideoWidth;
pChInfo->height = gVdecModuleContext.vdecConfig.decChannelParams[chId].maxVideoHeight;
pChInfo->scanFormat = SYSTEM_SF_PROGRESSIVE;
}
}
ipcBitsInVideoPrm.baseCreateParams.inQueParams.prevLinkId = gVdecModuleContext.ipcBitsOutHLOSId;
ipcBitsInVideoPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsInVideoPrm.baseCreateParams.numOutQue = 1;
ipcBitsInVideoPrm.baseCreateParams.outQueParams[0].nextLink = gVdecModuleContext.decId;
MultiCh_ipcBitsInitCreateParams_BitsInRTOS(&ipcBitsInVideoPrm, TRUE);
for (i=0; i<gVdecModuleContext.vdecConfig.numChn; i++) {
decPrm.chCreateParams[i].format = IVIDEO_H264HP;
decPrm.chCreateParams[i].profile = IH264VDEC_PROFILE_ANY;
decPrm.chCreateParams[i].fieldMergeDecodeEnable = FALSE;
decPrm.chCreateParams[i].targetMaxWidth = ipcBitsOutHostPrm.inQueInfo.chInfo[i].width;
decPrm.chCreateParams[i].targetMaxHeight = ipcBitsOutHostPrm.inQueInfo.chInfo[i].height;
decPrm.chCreateParams[i].defaultDynamicParams.targetFrameRate = gVdecModuleContext.vdecConfig.decChannelParams[i].dynamicParam.frameRate;
decPrm.chCreateParams[i].defaultDynamicParams.targetBitRate = gVdecModuleContext.vdecConfig.decChannelParams[i].dynamicParam.targetBitRate;
decPrm.chCreateParams[i].numBufPerCh = NUM_DECODE_BUFFERS;
}
decPrm.inQueParams.prevLinkId = gVdecModuleContext.ipcBitsInRTOSId;
decPrm.inQueParams.prevLinkQueId = 0;
decPrm.outQueParams.nextLink = ipcOutVideoId;
decPrm.tilerEnable = TILER_ENABLE;
ipcOutVideoPrm.inQueParams.prevLinkId = gVdecModuleContext.decId;
ipcOutVideoPrm.inQueParams.prevLinkQueId = 0;
ipcOutVideoPrm.numOutQue = 1;
ipcOutVideoPrm.outQueParams[0].nextLink = ipcInVpssId;
ipcOutVideoPrm.notifyNextLink = TRUE;
ipcOutVideoPrm.notifyPrevLink = TRUE;
ipcOutVideoPrm.noNotifyMode = FALSE;
ipcInVpssPrm.inQueParams.prevLinkId = ipcOutVideoId;
ipcInVpssPrm.inQueParams.prevLinkQueId = 0;
ipcInVpssPrm.numOutQue = 1;
ipcInVpssPrm.outQueParams[0].nextLink = mergeId[LIVE_DECODE_MERGE_LINK_IDX];
ipcInVpssPrm.notifyNextLink = TRUE;
ipcInVpssPrm.notifyPrevLink = TRUE;
ipcInVpssPrm.noNotifyMode = FALSE;
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].numInQue = 2;
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].inQueParams[0].prevLinkId = gVcapModuleContext.deiId[0];
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].inQueParams[0].prevLinkQueId = DEI_LINK_OUT_QUE_DEI_SC;
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].inQueParams[1].prevLinkId = ipcInVpssId;
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].inQueParams[1].prevLinkQueId = 0;
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].outQueParams.nextLink = dupId[LIVE_DECODE_DUP_LINK_IDX];
mergePrm[LIVE_DECODE_MERGE_LINK_IDX].notifyNextLink = TRUE;
dupPrm[LIVE_DECODE_DUP_LINK_IDX].inQueParams.prevLinkId = mergeId[LIVE_DECODE_MERGE_LINK_IDX];
dupPrm[LIVE_DECODE_DUP_LINK_IDX].inQueParams.prevLinkQueId = 0;
dupPrm[LIVE_DECODE_DUP_LINK_IDX].numOutQue = 2;
dupPrm[LIVE_DECODE_DUP_LINK_IDX].outQueParams[0].nextLink = gVdisModuleContext.swMsId[0];
dupPrm[LIVE_DECODE_DUP_LINK_IDX].outQueParams[1].nextLink = gVdisModuleContext.swMsId[1];
dupPrm[LIVE_DECODE_DUP_LINK_IDX].notifyNextLink = TRUE;
for(i=0; i<2; i++)
{
swMsPrm[i].inQueParams.prevLinkId = dupId[LIVE_DECODE_DUP_LINK_IDX];
swMsPrm[i].inQueParams.prevLinkQueId = i;
swMsPrm[i].outQueParams.nextLink = gVdisModuleContext.displayId[i];
swMsPrm[i].maxInputQueLen = 4; // KC: changed to 4 to make the display smooth
swMsPrm[i].maxOutRes = VSYS_STD_1080P_60;
swMsPrm[i].initOutRes = gVdisModuleContext.vdisConfig.deviceParams[i].resolution;
swMsPrm[0].numOutBuf = 5;
swMsPrm[1].numOutBuf = 8;
if (i == 1)
{
swMsPrm[i].maxOutRes = VSYS_STD_PAL;
swMsPrm[i].initOutRes = gVdisModuleContext.vdisConfig.deviceParams[VDIS_DEV_SD].resolution;
}
#ifdef SYSTEM_USE_TILER
swMsPrm[i].lineSkipMode = FALSE; // Double pitch not possible in tiler mode; so Line skip not possible
#else
swMsPrm[i].lineSkipMode = TRUE; // Set to TRUE for Enable low cost scaling
#endif
swMsPrm[i].enableLayoutGridDraw = gVdisModuleContext.vdisConfig.enableLayoutGridDraw;
MultiCh_swMsGetDefaultLayoutPrm(VDIS_DEV_HDMI, &swMsPrm[0], TRUE);
MultiCh_swMsGetDefaultLayoutPrm(VDIS_DEV_SD, &swMsPrm[1], TRUE);
displayPrm[i].inQueParams[0].prevLinkId = gVdisModuleContext.swMsId[i];
displayPrm[i].inQueParams[0].prevLinkQueId = 0;
displayPrm[i].displayRes = swMsPrm[i].initOutRes;
if (i == 1)
{
displayPrm[i].displayRes = gVdisModuleContext.vdisConfig.deviceParams[VDIS_DEV_SD].resolution;
displayPrm[i].forceFieldSeparatedInputMode = TRUE;
}
}
System_linkCreate(gVdecModuleContext.ipcBitsOutHLOSId,&ipcBitsOutHostPrm,sizeof(ipcBitsOutHostPrm));
System_linkCreate(gVdecModuleContext.ipcBitsInRTOSId,&ipcBitsInVideoPrm,sizeof(ipcBitsInVideoPrm));
System_linkCreate(gVdecModuleContext.decId, &decPrm, sizeof(decPrm));
System_linkCreate(ipcOutVideoId, &ipcOutVideoPrm, sizeof(ipcOutVideoPrm));
System_linkCreate(ipcInVpssId , &ipcInVpssPrm , sizeof(ipcInVpssPrm) );
System_linkCreate(mergeId[LIVE_DECODE_MERGE_LINK_IDX], &mergePrm[LIVE_DECODE_MERGE_LINK_IDX], sizeof(mergePrm[LIVE_DECODE_MERGE_LINK_IDX]));
System_linkCreate(dupId[LIVE_DECODE_DUP_LINK_IDX], &dupPrm[LIVE_DECODE_DUP_LINK_IDX], sizeof(dupPrm[LIVE_DECODE_DUP_LINK_IDX]));
for(i=0; i<2; i++)
System_linkCreate(gVdisModuleContext.swMsId[i] , &swMsPrm[i], sizeof(swMsPrm[i]));
for(i=0; i<2; i++) /* Both tied VENCs HDMI and DVO2 are handled by single link instance */
System_linkCreate(gVdisModuleContext.displayId[i], &displayPrm[i], sizeof(displayPrm[i]));
{
MergeLink_InLinkChInfo inChInfo;
MergeLink_InLinkChInfo_Init(&inChInfo);
inChInfo.inLinkID = ipcInVpssId;
System_linkControl(mergeId[LIVE_DECODE_MERGE_LINK_IDX],
MERGE_LINK_CMD_GET_INPUT_LINK_CHINFO,
&inChInfo,
sizeof(inChInfo),
TRUE);
OSA_assert(inChInfo.numCh == gVdecModuleContext.vdecConfig.numChn);
MultiCh_setDec2DispMap(VDIS_DEV_HDMI,gVdecModuleContext.vdecConfig.numChn,0,inChInfo.startChNum);
MultiCh_setDec2DispMap(VDIS_DEV_SD,gVdecModuleContext.vdecConfig.numChn,0,inChInfo.startChNum);
}
}
Void Chains_doubleChCapScEncSend(Chains_Ctrl *chainsCfg)
{
CaptureLink_CreateParams capturePrm;
CaptureLink_VipInstParams *pCaptureInstPrm;
CaptureLink_OutParams *pCaptureOutPrm;
MergeLink_CreateParams mergePrm;
DupLink_CreateParams dupPrm;
NsfLink_CreateParams nsfPrm;
DupLink_CreateParams dup2Prm; //for two display
SwMsLink_CreateParams swMsPrm[CHAINS_SW_MS_MAX_DISPLAYS];
DisplayLink_CreateParams displayPrm[CHAINS_SW_MS_MAX_DISPLAYS];
IpcLink_CreateParams ipcOutVpssPrm;
IpcLink_CreateParams ipcInVideoPrm;
EncLink_CreateParams encPrm;
IpcBitsOutLinkRTOS_CreateParams ipcBitsOutVideoPrm;
IpcBitsInLinkHLOS_CreateParams ipcBitsInHostPrm;
UInt32 captureId, vipInstId;
UInt32 mergeId;
UInt32 dupId;
UInt32 nsfId;
UInt32 dup2Id;
UInt32 swMsId[CHAINS_SW_MS_MAX_DISPLAYS];
UInt32 displayId[CHAINS_SW_MS_MAX_DISPLAYS];
UInt32 ipcOutVpssId;
UInt32 ipcInVideoId;
UInt32 encId;
UInt32 ipcBitsOutVideoId;
UInt32 ipcBitsInHostId;
Bool enableOsdAlgLink=1;
UInt32 enableDisplay = FALSE;
/****************msg between sys and chain*****/
#if 0
int msgqid = 0;
msgqid = Msg_Init(MSG_KEY);
#endif
/*************************************/
////////////////////////////OSD///////////////////////////////////
AlgLink_CreateParams DSPLinkPrm;//guo changed to global
IpcFramesOutLinkRTOS_CreateParams ipcFramesOutVpssPrm;
IpcFramesInLinkHLOS_CreateParams ipcFramesInDspPrm;
UInt32 osdId;
UInt32 ipcFramesOutVpssId, ipcFramesInDspId;
UInt8 osdFormat[ALG_LINK_OSD_MAX_CH];
memset(osdFormat, SYSTEM_DF_YUV422I_YUYV, ALG_LINK_OSD_MAX_CH);
if (enableOsdAlgLink)
{
Chains_ipcFramesInit();//This is likely no use.
}
CHAINS_INIT_STRUCT(IpcFramesOutLinkRTOS_CreateParams ,ipcFramesOutVpssPrm);
CHAINS_INIT_STRUCT(IpcFramesInLinkHLOS_CreateParams ,ipcFramesInDspPrm);
CHAINS_INIT_STRUCT(AlgLink_CreateParams,DSPLinkPrm);
ipcFramesOutVpssId = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_OUT_0;
ipcFramesInDspId = SYSTEM_DSP_LINK_ID_IPC_FRAMES_IN_0;
osdId = SYSTEM_LINK_ID_ALG_0;
//////////////////guo2014/11/21--added for scd////////////////////////
//Scd CreateParams is contined in AlgLink_CreateParmas
NsfLink_CreateParams nsfPrm2;//SCD only supports YUV420
SclrLink_CreateParams sclrPrm;
AlgLink_CreateParams scdPrm;
IpcFramesOutLinkRTOS_CreateParams ipcFramesOutVpssPrm2; //outVpss
IpcFramesInLinkRTOS_CreateParams ipcFramesInDspPrm2; //Into Dsp
IpcBitsOutLinkRTOS_CreateParams ipcBitsOutDspPrm2;
IpcBitsInLinkHLOS_CreateParams ipcBitsInHostPrm2;
UInt32 nsfId2;
UInt32 scdId;
UInt32 sclrId;
UInt32 ipcFramesOutVpssId2;
UInt32 ipcFramesInDspId2;
UInt32 ipcBitsOutDspId2;
UInt32 ipcBitsInHostId2;
Bool enableScdAlgLink = 1;
nsfId2 = SYSTEM_LINK_ID_NSF_1;
scdId = SYSTEM_LINK_ID_ALG_1;
sclrId = SYSTEM_LINK_ID_SCLR_INST_0;
ipcFramesOutVpssId2 = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_OUT_1;
ipcFramesInDspId2 = SYSTEM_DSP_LINK_ID_IPC_FRAMES_IN_1;
ipcBitsOutDspId2 = SYSTEM_DSP_LINK_ID_IPC_BITS_OUT_0;
ipcBitsInHostId2 = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_1;
CHAINS_INIT_STRUCT(NsfLink_CreateParams, nsfPrm2);
CHAINS_INIT_STRUCT(SclrLink_CreateParams,sclrPrm);
CHAINS_INIT_STRUCT(IpcFramesOutLinkRTOS_CreateParams,ipcFramesOutVpssPrm2);
CHAINS_INIT_STRUCT(IpcFramesInLinkHLOS_CreateParams,ipcFramesInDspPrm2);
CHAINS_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams,ipcBitsOutDspPrm2);
CHAINS_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,ipcBitsInHostPrm2);
CHAINS_INIT_STRUCT(AlgLink_CreateParams,scdPrm);
Scd_bitsWriteCreate(0,ipcBitsInHostId2); //Init scd's ipcBitsInHost by:guo8113,this is ok, temporarily disabled!
//----------------end scd-----------------------------
Chains_ipcBitsInit();
UInt32 i;
char ch;
CHAINS_INIT_STRUCT(CaptureLink_CreateParams,capturePrm);
for (i=0; i<CHAINS_SW_MS_MAX_DISPLAYS; i++) {
CHAINS_INIT_STRUCT(SwMsLink_CreateParams,swMsPrm[i]);
CHAINS_INIT_STRUCT(DisplayLink_CreateParams,displayPrm[i]);
}
CHAINS_INIT_STRUCT(IpcLink_CreateParams,ipcOutVpssPrm);
CHAINS_INIT_STRUCT(IpcLink_CreateParams,ipcInVideoPrm);
CHAINS_INIT_STRUCT(NsfLink_CreateParams, nsfPrm);
CHAINS_INIT_STRUCT(EncLink_CreateParams,encPrm);
CHAINS_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams,ipcBitsOutVideoPrm);
CHAINS_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,ipcBitsInHostPrm);
captureId = SYSTEM_LINK_ID_CAPTURE;
mergeId = SYSTEM_VPSS_LINK_ID_MERGE_0;
dupId = SYSTEM_VPSS_LINK_ID_DUP_0;
nsfId = SYSTEM_LINK_ID_NSF_0;
dup2Id = SYSTEM_VPSS_LINK_ID_DUP_1;
swMsId[0] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_0;
swMsId[1] = SYSTEM_LINK_ID_SW_MS_MULTI_INST_1;
displayId[0] = SYSTEM_LINK_ID_DISPLAY_0;
displayId[1] = SYSTEM_LINK_ID_DISPLAY_1;
encId = SYSTEM_LINK_ID_VENC_0;
ipcOutVpssId = SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0;
ipcInVideoId = SYSTEM_VIDEO_LINK_ID_IPC_IN_M3_0;
ipcBitsOutVideoId = SYSTEM_VIDEO_LINK_ID_IPC_BITS_OUT_0;
ipcBitsInHostId = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_0;
System_linkControl(
SYSTEM_LINK_ID_M3VPSS,
SYSTEM_M3VPSS_CMD_RESET_VIDEO_DEVICES,
NULL, 0, TRUE );
System_linkControl(
SYSTEM_LINK_ID_M3VIDEO,
SYSTEM_COMMON_CMD_SET_CH2IVAHD_MAP_TBL,
&systemVid_encDecIvaChMapTbl,
sizeof(SystemVideo_Ivahd2ChMap_Tbl),
TRUE
);
capturePrm.numVipInst = 2;
capturePrm.tilerEnable = FALSE;
capturePrm.numBufsPerCh = 16;
capturePrm.numExtraBufs = 0;
capturePrm.maxBlindAreasPerCh = 0;
capturePrm.isPalMode = FALSE;
capturePrm.enableSdCrop = FALSE;
capturePrm.doCropInCapture = FALSE;
for(i=0; i<capturePrm.numVipInst; i++)
{
vipInstId = SYSTEM_CAPTURE_INST_VIP0_PORTA + 2*i;
pCaptureInstPrm = &capturePrm.vipInst[i];
pCaptureInstPrm->vipInstId = vipInstId%SYSTEM_CAPTURE_INST_MAX;
pCaptureInstPrm->videoDecoderId = SYSTEM_DEVICE_VID_DEC_SII9233A_DRV;
pCaptureInstPrm->inDataFormat = SYSTEM_DF_YUV422P;
pCaptureInstPrm->standard = chainsCfg->displayRes[i];
pCaptureInstPrm->numOutput = 2;
pCaptureInstPrm->numChPerOutput = 1;
pCaptureInstPrm->frameCaptureMode = FALSE;
pCaptureInstPrm->fieldsMerged = FALSE;
pCaptureOutPrm = &pCaptureInstPrm->outParams[0];
pCaptureOutPrm->dataFormat = SYSTEM_DF_YUV422I_YUYV;//nsf can change 422 to 420,because enc require 420
pCaptureOutPrm->scEnable = FALSE;
pCaptureOutPrm->scOutWidth = gChains_ctrl.channelConf[i].width;
pCaptureOutPrm->scOutHeight = gChains_ctrl.channelConf[i].height;
pCaptureOutPrm->outQueId = 0;
pCaptureOutPrm = &pCaptureInstPrm->outParams[1];
pCaptureOutPrm->dataFormat = SYSTEM_DF_YUV422I_YUYV;
pCaptureOutPrm->scEnable = FALSE;
pCaptureOutPrm->scOutWidth = gChains_ctrl.channelConf[2+i].width;
pCaptureOutPrm->scOutHeight = gChains_ctrl.channelConf[2+i].height;
pCaptureOutPrm->outQueId = 1;
}
capturePrm.outQueParams[0].nextLink = mergeId;
capturePrm.outQueParams[1].nextLink = mergeId;
System_linkCreate(captureId, &capturePrm, sizeof(capturePrm));
for (i=0; i<gChains_ctrl.channelNum; i++) {
chainsCfg->displayRes[i] = capturePrm.vipInst[i].standard;
Vsys_getResSize(chainsCfg->displayRes[i], &chainsCfg->channelConf[i].width, &chainsCfg->channelConf[i].height);
Vsys_getResRate(chainsCfg->displayRes[i], &chainsCfg->channelConf[i].frameRate);
}
mergePrm.numInQue = 2;
mergePrm.inQueParams[0].prevLinkId = captureId;
mergePrm.inQueParams[0].prevLinkQueId = 0;
mergePrm.inQueParams[1].prevLinkId = captureId;
mergePrm.inQueParams[1].prevLinkQueId = 1;
//guo---------------------------------------------------------
if (enableOsdAlgLink)
{
mergePrm.outQueParams.nextLink=ipcFramesOutVpssId;
ipcFramesOutVpssPrm.baseCreateParams.inQueParams.prevLinkId = mergeId;
ipcFramesOutVpssPrm.baseCreateParams.noNotifyMode = FALSE;
ipcFramesOutVpssPrm.baseCreateParams.notifyNextLink = TRUE;
ipcFramesOutVpssPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcFramesOutVpssPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesOutVpssPrm.baseCreateParams.outQueParams[0].nextLink = dupId;
ipcFramesOutVpssPrm.baseCreateParams.inputFrameRate = chainsCfg->channelConf[0].frameRate;
ipcFramesOutVpssPrm.baseCreateParams.outputFrameRate =chainsCfg->channelConf[0].frameRate;//
ipcFramesOutVpssPrm.baseCreateParams.processLink = ipcFramesInDspId;
ipcFramesOutVpssPrm.baseCreateParams.notifyProcessLink = FALSE;
ipcFramesInDspPrm.baseCreateParams.noNotifyMode = TRUE;
ipcFramesInDspPrm.baseCreateParams.notifyNextLink = TRUE;
ipcFramesInDspPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcFramesInDspPrm.baseCreateParams.inQueParams.prevLinkId = ipcFramesOutVpssId;
ipcFramesInDspPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesInDspPrm.baseCreateParams.outQueParams[0].nextLink = osdId;
ipcFramesInDspPrm.exportOnlyPhyAddr = FALSE;
ipcFramesInDspPrm.baseCreateParams.inputFrameRate = chainsCfg->channelConf[0].frameRate;
ipcFramesInDspPrm.baseCreateParams.outputFrameRate = chainsCfg->channelConf[0].frameRate;
ipcFramesInDspPrm.baseCreateParams.notifyProcessLink = FALSE;
Chains_ipcFramesInSetCbInfo(&ipcFramesInDspPrm); //This is likely no use.
DSPLinkPrm.inQueParams.prevLinkId=ipcFramesInDspId;
DSPLinkPrm.inQueParams.prevLinkQueId = 0;
DSPLinkPrm.enableOSDAlg=TRUE;
DSPLinkPrm.enableSCDAlg=FALSE;
//#define LOGOONLY //this is reserved for original logo only osd ,for case you will test the logo.
#ifdef LOGOONLY
Chains_OSDConfig(DSPLinkPrm);//origin logo osd is OK
#else
Demo_osdInit(4, osdFormat);
for(i=0;i< gChains_ctrl.channelNum; i++)
{
DSPLinkPrm.osdChCreateParams[i].maxWidth = CHAINS_OSD_WIN_MAX_WIDTH;
DSPLinkPrm.osdChCreateParams[i].maxHeight = CHAINS_OSD_WIN_MAX_HEIGHT;
memcpy(&(DSPLinkPrm.osdChCreateParams[i].chDefaultParams),
&g_osdChParam[i],sizeof(AlgLink_OsdChWinParams));//(dst,src,size)
}
#endif
}
else
{
mergePrm.outQueParams.nextLink = dupId;
}
//------------------------------------------------------------
mergePrm.notifyNextLink = TRUE;
if (enableOsdAlgLink)
{
dupPrm.inQueParams.prevLinkId = ipcFramesOutVpssId;
}
else
{
dupPrm.inQueParams.prevLinkId = mergeId;
}
dupPrm.inQueParams.prevLinkQueId = 0;
dupPrm.numOutQue = 2;
//guo scd--------
if(enableScdAlgLink)
{
dupPrm.numOutQue = 3; //dup's third OutQue
dupPrm.outQueParams[2].nextLink = sclrId;
sclrPrm.inQueParams.prevLinkId = dupId;
sclrPrm.inQueParams.prevLinkQueId = 2;
sclrPrm.outQueParams.nextLink = nsfId2;
sclrPrm.tilerEnable = FALSE;
sclrPrm.enableLineSkipSc = TRUE;//FALSE;
sclrPrm.inputFrameRate = 60;
sclrPrm.outputFrameRate = 60;
sclrPrm.scaleMode = DEI_SCALE_MODE_ABSOLUTE;
sclrPrm.outScaleFactor.absoluteResolution.outWidth = 352;
sclrPrm.outScaleFactor.absoluteResolution.outHeight = 240;
nsfPrm2.inQueParams.prevLinkId = sclrId;
nsfPrm2.inQueParams.prevLinkQueId = 0;
nsfPrm2.bypassNsf = TRUE;
nsfPrm2.tilerEnable = FALSE;
nsfPrm2.numOutQue = 1;
nsfPrm2.outQueParams[0].nextLink = ipcFramesOutVpssId2;
nsfPrm2.inputFrameRate = 60;
nsfPrm2.outputFrameRate = 60;
nsfPrm2.numBufsPerCh = 8;
ipcFramesOutVpssPrm2.baseCreateParams.inQueParams.prevLinkId = nsfId2;
ipcFramesOutVpssPrm2.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesOutVpssPrm2.baseCreateParams.notifyPrevLink = TRUE;
ipcFramesOutVpssPrm2.baseCreateParams.numOutQue = 1;
ipcFramesOutVpssPrm2.baseCreateParams.outQueParams[0].nextLink = ipcFramesInDspId2;
ipcFramesOutVpssPrm2.baseCreateParams.notifyNextLink = TRUE;
ipcFramesOutVpssPrm2.baseCreateParams.inputFrameRate = 60;
ipcFramesOutVpssPrm2.baseCreateParams.outputFrameRate = 2;
ipcFramesInDspPrm2.baseCreateParams.inQueParams.prevLinkId = ipcFramesOutVpssId2;
ipcFramesInDspPrm2.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcFramesInDspPrm2.baseCreateParams.numOutQue = 1;
ipcFramesInDspPrm2.baseCreateParams.outQueParams[0].nextLink = scdId;
ipcFramesInDspPrm2.baseCreateParams.notifyPrevLink = TRUE;
ipcFramesInDspPrm2.baseCreateParams.notifyNextLink = TRUE;
ipcFramesInDspPrm2.baseCreateParams.noNotifyMode = FALSE;
Int32 numBlksInFrame;
Int32 numHorzBlks, numVertBlks, chIdx;
Uint32 x, y, i;
scdPrm.inQueParams.prevLinkId = ipcFramesInDspId2;
scdPrm.inQueParams.prevLinkQueId =0;
scdPrm.enableSCDAlg = TRUE;
scdPrm.enableOSDAlg = FALSE;
scdPrm.outQueParams[ALG_LINK_SCD_OUT_QUE].nextLink = ipcBitsOutDspId2;
scdPrm.scdCreateParams.numBufPerCh = 3;
scdPrm.scdCreateParams.maxWidth = 352;
scdPrm.scdCreateParams.maxHeight = 240;//288
scdPrm.scdCreateParams.maxStride = 352;
scdPrm.scdCreateParams.numValidChForSCD = 4; //16
scdPrm.scdCreateParams.numSecs2WaitB4Init = 3;
scdPrm.scdCreateParams.numSecs2WaitB4FrmAlert = 1;
scdPrm.scdCreateParams.inputFrameRate = 2;
scdPrm.scdCreateParams.outputFrameRate = 2;
scdPrm.scdCreateParams.numSecs2WaitAfterFrmAlert = 2;
scdPrm.scdCreateParams.numSecs2Wait2MarkStableFrame = 5;
scdPrm.scdCreateParams.enableMotionNotify = FALSE;
scdPrm.scdCreateParams.enableTamperNotify = FALSE;
/* Should be applied on CIF channels whose ch numbers are 4~7 */
//scdPrm.scdCreateParams.startChNoForSCD = 16;
// Configure array to monitor scene changes in all frame blocks, i.e., motion detection.
// Each block is fixed to be 32x10 in size,
numHorzBlks = scdPrm.scdCreateParams.maxWidth / 32;
if(scdPrm.scdCreateParams.maxHeight == 240)
numVertBlks = scdPrm.scdCreateParams.maxHeight / 10;
else /* For 288 Block height becomes 12 */
numVertBlks = scdPrm.scdCreateParams.maxHeight / 12;
numBlksInFrame = numHorzBlks * numVertBlks;
for(chIdx = 0; chIdx < scdPrm.scdCreateParams.numValidChForSCD; chIdx++)
{
AlgLink_ScdChParams * chPrm = &scdPrm.scdCreateParams.chDefaultParams[chIdx];
chPrm->blkNumBlksInFrame = numBlksInFrame;
chPrm->chId = SCDChannelMonitor[chIdx];
chPrm->mode = ALG_LINK_SCD_DETECTMODE_MONITOR_BLOCKS_AND_FRAME;
chPrm->frmIgnoreLightsON = FALSE;
chPrm->frmIgnoreLightsOFF = FALSE;
chPrm->frmSensitivity = ALG_LINK_SCD_SENSITIVITY_HIGH;//ALG_LINK_SCD_SENSITIVITY_VERYHIGH;
chPrm->frmEdgeThreshold = 100;
i = 0;
for(y = 0; y < numVertBlks; y++)
{
for(x = 0; x < numHorzBlks; x++)
{
chPrm->blkConfig[i].sensitivity = ALG_LINK_SCD_SENSITIVITY_MID;
chPrm->blkConfig[i].monitored = 1;
i++;
}
}
}
ipcBitsOutDspPrm2.baseCreateParams.inQueParams.prevLinkId = scdId;
ipcBitsOutDspPrm2.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsOutDspPrm2.baseCreateParams.numOutQue = 1;
ipcBitsOutDspPrm2.baseCreateParams.noNotifyMode = FALSE;
ipcBitsOutDspPrm2.baseCreateParams.notifyNextLink = TRUE;
ipcBitsOutDspPrm2.baseCreateParams.outQueParams[0].nextLink = ipcBitsInHostId2;
ipcBitsOutDspPrm2.baseCreateParams.notifyNextLink = TRUE;
ipcBitsOutDspPrm2.baseCreateParams.noNotifyMode = FALSE;
ipcBitsInHostPrm2.baseCreateParams.inQueParams.prevLinkId = ipcBitsOutDspId2;
ipcBitsInHostPrm2.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsInHostPrm2.baseCreateParams.numOutQue = 1;
ipcBitsInHostPrm2.baseCreateParams.outQueParams[0].nextLink = SYSTEM_LINK_ID_INVALID;
Chains_ipcBitsInitCreateParams_BitsInHLOSVcap(&ipcBitsInHostPrm2);
ipcBitsInHostPrm2.baseCreateParams.notifyPrevLink = TRUE;
ipcBitsInHostPrm2.baseCreateParams.noNotifyMode = FALSE;
}
else
{
scdPrm.outQueParams[ALG_LINK_SCD_OUT_QUE].nextLink = SYSTEM_LINK_ID_INVALID;//nullId;
}
dupPrm.outQueParams[0].nextLink = nsfId;
dupPrm.outQueParams[1].nextLink = dup2Id;//to display
dupPrm.notifyNextLink = TRUE;
nsfPrm.inQueParams.prevLinkId = dupId;
nsfPrm.inQueParams.prevLinkQueId = 0;
nsfPrm.bypassNsf = FALSE;
nsfPrm.tilerEnable = TRUE;
nsfPrm.numOutQue = 1;
nsfPrm.outQueParams[0].nextLink = ipcOutVpssId;
nsfPrm.inputFrameRate = chainsCfg->channelConf[0].frameRate;
nsfPrm.outputFrameRate = chainsCfg->channelConf[0].frameRate;
nsfPrm.numBufsPerCh = 8;
ipcOutVpssPrm.inQueParams.prevLinkId = nsfId;
ipcOutVpssPrm.inQueParams.prevLinkQueId = 0;
ipcOutVpssPrm.numOutQue = 1;
ipcOutVpssPrm.numChPerOutQue[0] = 1;
ipcOutVpssPrm.outQueParams[0].nextLink = ipcInVideoId;
ipcOutVpssPrm.notifyNextLink = TRUE;
ipcOutVpssPrm.notifyPrevLink = FALSE;
ipcOutVpssPrm.noNotifyMode = FALSE;
ipcOutVpssPrm.numChPerOutQue[0] = 0;
ipcOutVpssPrm.equallyDivideChAcrossOutQues = FALSE;
ipcInVideoPrm.inQueParams.prevLinkId = ipcOutVpssId;
ipcInVideoPrm.inQueParams.prevLinkQueId = 0;
ipcInVideoPrm.numOutQue = 1;
ipcInVideoPrm.numChPerOutQue[0] = 1;
ipcInVideoPrm.outQueParams[0].nextLink = encId;
ipcInVideoPrm.notifyNextLink = TRUE;
ipcInVideoPrm.notifyPrevLink = FALSE;
ipcInVideoPrm.noNotifyMode = FALSE;
ipcInVideoPrm.numChPerOutQue[0] = 0;
ipcInVideoPrm.equallyDivideChAcrossOutQues = FALSE;
for (i=0; i<gChains_ctrl.channelNum; i++) {
encPrm.chCreateParams[i].format = chainsCfg->channelConf[i].encFormat;
encPrm.chCreateParams[i].profile = chainsCfg->channelConf[i].encProfile;
encPrm.chCreateParams[i].dataLayout = IVIDEO_FIELD_SEPARATED;
encPrm.chCreateParams[i].fieldMergeEncodeEnable = FALSE;
encPrm.chCreateParams[i].enableAnalyticinfo = FALSE;
encPrm.chCreateParams[i].enableWaterMarking = FALSE;
encPrm.chCreateParams[i].encodingPreset = XDM_USER_DEFINED;
encPrm.chCreateParams[i].rateControlPreset = IVIDEO_USER_DEFINED;
encPrm.chCreateParams[i].enableHighSpeed = FALSE;
encPrm.chCreateParams[i].defaultDynamicParams.interFrameInterval = 1;
encPrm.chCreateParams[i].defaultDynamicParams.intraFrameInterval = chainsCfg->channelConf[i].intraFrameInterval;
encPrm.chCreateParams[i].defaultDynamicParams.inputFrameRate = chainsCfg->channelConf[i].frameRate;
encPrm.chCreateParams[i].defaultDynamicParams.targetFrameRate = chainsCfg->channelConf[i].encFrameRate;
encPrm.chCreateParams[i].defaultDynamicParams.targetBitRate = chainsCfg->channelConf[i].bitRate;
encPrm.chCreateParams[i].defaultDynamicParams.mvAccuracy = IVIDENC2_MOTIONVECTOR_QUARTERPEL;
encPrm.chCreateParams[i].defaultDynamicParams.rcAlg = chainsCfg->channelConf[i].rateCtrl;
encPrm.chCreateParams[i].defaultDynamicParams.qpMin = 0;
encPrm.chCreateParams[i].defaultDynamicParams.qpMax = 51;
encPrm.chCreateParams[i].defaultDynamicParams.qpInit = -1;
encPrm.chCreateParams[i].defaultDynamicParams.vbrDuration = 8;
encPrm.chCreateParams[i].defaultDynamicParams.vbrSensitivity = 0;
}
encPrm.inQueParams.prevLinkId = ipcInVideoId;
encPrm.inQueParams.prevLinkQueId= 0;
encPrm.outQueParams.nextLink = ipcBitsOutVideoId;
encPrm.numBufPerCh[0] = 0;
ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkId = encId;
ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsOutVideoPrm.baseCreateParams.numOutQue = 1;
ipcBitsOutVideoPrm.baseCreateParams.numChPerOutQue[0] = 1;
ipcBitsOutVideoPrm.baseCreateParams.outQueParams[0].nextLink = ipcBitsInHostId;
ipcBitsOutVideoPrm.baseCreateParams.notifyNextLink = FALSE;
ipcBitsOutVideoPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcBitsOutVideoPrm.baseCreateParams.noNotifyMode = TRUE;
Chains_ipcBitsInitCreateParams_BitsOutRTOS(&ipcBitsOutVideoPrm,FALSE);
ipcBitsInHostPrm.baseCreateParams.inQueParams.prevLinkId = ipcBitsOutVideoId;
ipcBitsInHostPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
ipcBitsInHostPrm.baseCreateParams.numOutQue = 1;
ipcBitsInHostPrm.baseCreateParams.numChPerOutQue[0] = 1;
ipcBitsInHostPrm.baseCreateParams.notifyNextLink = FALSE;
ipcBitsInHostPrm.baseCreateParams.notifyPrevLink = FALSE;
ipcBitsInHostPrm.baseCreateParams.noNotifyMode = TRUE;
Chains_ipcBitsInitCreateParams_BitsInHLOS(&ipcBitsInHostPrm);
Chains_displayCtrlInit(chainsCfg->displayRes);
System_linkCreate(mergeId, &mergePrm, sizeof(mergePrm));
dup2Prm.inQueParams.prevLinkId = dupId;
dup2Prm.inQueParams.prevLinkQueId = 1;
dup2Prm.numOutQue = 2;
dup2Prm.outQueParams[0].nextLink = swMsId[0];
dup2Prm.outQueParams[1].nextLink = swMsId[1];
dup2Prm.notifyNextLink = TRUE;
for (i=0; i<2; i++) {
swMsPrm[i].numSwMsInst = 1;
swMsPrm[i].swMsInstId[0] = SYSTEM_SW_MS_SC_INST_SC5;
swMsPrm[i].inQueParams.prevLinkId = dup2Id;
swMsPrm[i].inQueParams.prevLinkQueId = i;
swMsPrm[i].outQueParams.nextLink = displayId[i];
swMsPrm[i].lineSkipMode = FALSE;
swMsPrm[i].enableLayoutGridDraw = FALSE;
swMsPrm[i].layoutPrm.outputFPS = chainsCfg->channelConf[i].frameRate;
swMsPrm[i].maxInputQueLen = SYSTEM_SW_MS_DEFAULT_INPUT_QUE_LEN;
swMsPrm[i].maxOutRes = chainsCfg->displayRes[i];
swMsPrm[i].numOutBuf = 0;
Chains_swMsSetLayoutParams(i, &swMsPrm[i]);
displayPrm[i].numInputQueues = 1;
displayPrm[i].activeQueue = 0;
displayPrm[i].inQueParams[0].prevLinkId = swMsId[i];
displayPrm[i].inQueParams[0].prevLinkQueId = 0;
displayPrm[i].displayRes = chainsCfg->displayRes[i];
displayPrm[i].forceFieldSeparatedInputMode = FALSE;
}
if(enableOsdAlgLink)
{
System_linkCreate(ipcFramesOutVpssId , &ipcFramesOutVpssPrm , sizeof(ipcFramesOutVpssPrm));
System_linkCreate(ipcFramesInDspId , &ipcFramesInDspPrm , sizeof(ipcFramesInDspPrm));
System_linkCreate(osdId,&DSPLinkPrm,sizeof(DSPLinkPrm));
}
System_linkCreate(dupId, &dupPrm, sizeof(dupPrm));
System_linkCreate(nsfId , &nsfPrm, sizeof(nsfPrm));
System_linkCreate(ipcOutVpssId, &ipcOutVpssPrm, sizeof(ipcOutVpssPrm));
System_linkCreate(ipcInVideoId, &ipcInVideoPrm, sizeof(ipcInVideoPrm));
System_linkCreate(encId, &encPrm, sizeof(encPrm));
System_linkCreate(ipcBitsOutVideoId, &ipcBitsOutVideoPrm, sizeof(ipcBitsOutVideoPrm));
System_linkCreate(ipcBitsInHostId, &ipcBitsInHostPrm, sizeof(ipcBitsInHostPrm));
//guo
if(enableScdAlgLink)
{
System_linkCreate(sclrId, &sclrPrm , sizeof(sclrPrm ));
System_linkCreate(nsfId2,&nsfPrm2,sizeof(nsfPrm2));
System_linkCreate(ipcFramesOutVpssId2 , &ipcFramesOutVpssPrm2 , sizeof(ipcFramesOutVpssPrm2));
System_linkCreate(ipcFramesInDspId2 , &ipcFramesInDspPrm2 , sizeof(ipcFramesInDspPrm2));
System_linkCreate(scdId,&scdPrm,sizeof(scdPrm));
System_linkCreate(ipcBitsOutDspId2, &ipcBitsOutDspPrm2, sizeof(ipcBitsOutDspPrm2));
System_linkCreate(ipcBitsInHostId2, &ipcBitsInHostPrm2, sizeof(ipcBitsInHostPrm2));
}
System_linkCreate(dup2Id, &dup2Prm, sizeof(dup2Prm));
for (i=0; i<2; i++) {
System_linkCreate(swMsId[i], &swMsPrm[i], sizeof(swMsPrm[i]));
System_linkCreate(displayId[i], &displayPrm[i], sizeof(displayPrm[i]));
}
//Chains_memPrintHeapStatus();
System_linkStart(encId);
for (i=0; i<2; i++) {
System_linkStart(displayId[i]);
System_linkStart(swMsId[i]);
}
grpx_init(GRPX_FORMAT_RGB888);
System_linkStart(dup2Id);
System_linkStart(nsfId);
System_linkStart(dupId);
//guo scd
System_linkStart(ipcBitsInHostId2);
System_linkStart(ipcBitsOutDspId2);
System_linkStart(scdId);
System_linkStart(ipcFramesInDspId2);
System_linkStart(ipcFramesOutVpssId2);
System_linkStart(nsfId2);
System_linkStart(sclrId);
//guo OSD
if(enableOsdAlgLink)
{
System_linkStart(osdId);
System_linkStart(ipcFramesInDspId);
System_linkStart(ipcFramesOutVpssId);
}
System_linkStart(mergeId);
System_linkStart(captureId);
//grpx_fb_draw_demo();
/***guo********poll thread ***/
pthread_t poll_t;
int res;
PollData poll={
.encId = encId,
.swMsId[0]=swMsId[0],
.swMsId[1]=swMsId[1],
.swMsPrm[0]=swMsPrm[0],
.swMsPrm[1]=swMsPrm[1]
};
res = pthread_create(&poll_t,NULL,poll_thread,(void*)&poll);
if(res!=0)
{
perror("thread creation failed");
exit(-1);
}
/************end*/
//Chains_ScdPrint(scdId);//This is only for temp test!!!
//This is for user input args
Chains_ipcBitsLocSt(); //start RTP (or Local Storage)
while(1)
{
printf("My menu:Input L to storage the video and E to stop\n"
"Input P for statistic\n");
ch = Chains_menuRunTime();
if(ch=='0')
break;
if(ch=='p')
{
MultiCh_prfLoadPrint(TRUE,TRUE);
continue;
}
if(ch == 'd')//draw
{
grpx_draw_box(500,500,500,500);//在HDMI2上画了出来
grpx_fb_draw_grid(300,300,200,100,11);
continue;
}
if(ch == 'x')
{
grpx_draw_box_exit(500,500,500,500);
grpx_fb_draw_grid_exit(300,300,200,100,11);
grpx_exit();
continue;
}
Bool switchCh = FALSE;
Bool switchLayout = FALSE;
if(ch=='L')
{
Chains_ipcBitsLocSt();
continue;
}
if(ch=='E')
{
Chains_ipcBitsLocStStop();
continue;
}
if(ch=='s')
{
switchLayout = TRUE;
Chains_swMsSwitchLayout(&swMsId, &swMsPrm, switchLayout, switchCh, 2);
//when you changed layout ,scd is disabled
gScd_ctrl.enableMotionTracking = 0;
gScd_ctrl.exitWrThr = 1;
grpx_exit();
printf("switch layout\n");
continue;
}
if(ch == 'c')
{
gScd_ctrl.enableMotionTracking = 0;
gScd_ctrl.exitWrThr = 1;
grpx_exit();
continue;
}
if(ch == '1')
{
switchCh = TRUE;
Chains_swMsSwitchLayout(&swMsId, &swMsPrm, switchLayout, switchCh, 0);
continue;
}
if(ch == 'o')
{
char ch2=Chains_menuSettingOsd();
if( (ch2 == '0')||(ch2 == '1')||(ch2 == '3'))
{
UInt32 winId = ch2-48;
g_osdChParam[0].chId = 0;
g_osdChParam[0].winPrm[winId].enableWin = 0;
System_linkControl(osdId,ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM,
&g_osdChParam[0],
sizeof(AlgLink_OsdChWinParams),
TRUE
);
continue;
}
if(ch2=='x')
{
int i=0;
for(i=0;i<4;i++)
{
g_osdChParam[i].chId = i;
g_osdChParam[i].winPrm[0].enableWin = 0;
g_osdChParam[i].winPrm[1].enableWin = 0;
g_osdChParam[i].winPrm[2].enableWin = 0;
g_osdChParam[i].winPrm[3].enableWin = 0;
System_linkControl(osdId,ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM,
&g_osdChParam[i],
sizeof(AlgLink_OsdChWinParams),
TRUE
);
continue;
}
}
if(ch2=='s')
{
int i=0;
for(i=0;i<4;i++)
{
g_osdChParam[i].chId = i;
g_osdChParam[i].winPrm[0].enableWin = 1;
g_osdChParam[i].winPrm[1].enableWin = 1;
g_osdChParam[i].winPrm[2].enableWin = 1;
g_osdChParam[i].winPrm[3].enableWin = 1;
System_linkControl(osdId,ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM,
&g_osdChParam[i],
sizeof(AlgLink_OsdChWinParams),
TRUE
);
continue;
}//end for
}///end if
}///end ch==o
}//end while1
System_linkStop(captureId);
System_linkStop(mergeId);
//guo----------------------
if(enableScdAlgLink)
{
Scd_bitsWriteStop();
System_linkStop(sclrId);
System_linkStop(nsfId2);
System_linkStop(ipcFramesOutVpssId2);
System_linkStop(ipcFramesInDspId2);
System_linkStop(scdId);
System_linkStop(ipcBitsOutDspId2);
System_linkStop(ipcBitsInHostId2);
}
if(enableOsdAlgLink)
{
Chains_ipcFramesStop();
System_linkStop(ipcFramesOutVpssId);
System_linkStop(ipcFramesInDspId);
System_linkStop(osdId);
}
//-------------------------------
System_linkStop(dupId);
System_linkStop(nsfId);
System_linkStop(dup2Id);
for (i=0; i<2; i++) {
System_linkStop(swMsId[i]);
System_linkStop(displayId[i]);
}
System_linkStop(encId);
Chains_ipcBitsStop();
System_linkStop(ipcBitsOutVideoId);
System_linkStop(ipcBitsInHostId);
System_linkDelete(captureId);
System_linkDelete(mergeId);
//guo-------------
if(enableScdAlgLink)
{
Scd_bitsWriteDelete();
System_linkDelete(sclrId);
System_linkDelete(nsfId2);
System_linkDelete(ipcFramesOutVpssId2);
System_linkDelete(ipcFramesInDspId2);
System_linkDelete(scdId);
System_linkDelete(ipcBitsOutDspId2);
System_linkDelete(ipcBitsInHostId2);
}
if(enableOsdAlgLink)
{
System_linkDelete(ipcFramesOutVpssId);
System_linkDelete(ipcFramesInDspId);
System_linkDelete(osdId);
}
//-----------------
System_linkDelete(dupId);
System_linkDelete(nsfId);
System_linkDelete(dup2Id);
for (i=0; i<2; i++) {
System_linkDelete(swMsId[i]);
System_linkDelete(displayId[i]);
}
System_linkDelete(ipcOutVpssId);
System_linkDelete(ipcInVideoId);
System_linkDelete(encId);
System_linkDelete(ipcBitsOutVideoId);
System_linkDelete(ipcBitsInHostId);
Chains_ipcBitsExit();
Chains_displayCtrlDeInit();
}
Int32 Chains_swMsSwitchLayout(
UInt32 swMsLinkId[CHAINS_SW_MS_MAX_DISPLAYS],
SwMsLink_CreateParams swMsPrm[CHAINS_SW_MS_MAX_DISPLAYS],
Bool switchLayout,
Bool switchCh,
UInt32 numDisplay)
{
UInt32 i, winId;
SwMsLink_LayoutPrm *layoutInfo;
static UInt32 curLayoutId = 0;
if(!switchLayout && !switchCh)
return OSA_SOK;
if(switchLayout == TRUE)
{
curLayoutId++;
if(curLayoutId >= CHAINS_MAX_LAYOUTS)
curLayoutId = 0;
for(i=0; i<numDisplay; i++)
{
/* If switching mosaic create entire Mosaic Layout */
Chains_swMsGenerateLayoutParams(i, curLayoutId, &swMsPrm[i]);
System_linkControl(swMsLinkId[i], SYSTEM_SW_MS_LINK_CMD_SWITCH_LAYOUT, &swMsPrm[i].layoutPrm, sizeof(swMsPrm[i].layoutPrm), TRUE);
}
}
if(switchCh == TRUE)
{
for(i=0; i<numDisplay; i++)
{
layoutInfo = &swMsPrm[i].layoutPrm;
/* For switching channel get current mosaic Layout */
System_linkControl(swMsLinkId[i], SYSTEM_SW_MS_LINK_CMD_GET_LAYOUT_PARAMS, layoutInfo, sizeof(*layoutInfo), TRUE);
printf("Display %d: Channels: ", i);
/* Populate the channel parameter for each window */
for(winId=0; winId < layoutInfo->numWin; winId++)
{
layoutInfo->winInfo[winId].channelNum
=
(layoutInfo->winInfo[winId].channelNum+1)%SYSTEM_SW_MS_MAX_CH_ID;
printf(" %d ",layoutInfo->winInfo[winId].channelNum);
}
printf("\n");
layoutInfo->onlyCh2WinMapChanged = TRUE;
/* Submit the same Layout with different window mapping */
System_linkControl(swMsLinkId[i], SYSTEM_SW_MS_LINK_CMD_SWITCH_LAYOUT, layoutInfo, sizeof(*layoutInfo), TRUE);
}
}
return OSA_SOK;
}
Int32 System_linkCreate(UInt32 linkId, Ptr createArgs, UInt32 argsSize)
{
return System_linkControl(linkId, SYSTEM_CMD_CREATE, createArgs, argsSize, TRUE);
}
Int32 AlgLink_ScdalgProcess(AlgLink_ScdObj *pScdAlgLinkObj, UInt32 chId, AlgLink_ScdResult * scdResultBuff)
{
SCD_Status chanStatus;
SCD_Result scdResult;
UInt32 chanID;
SCD_chPrm chanParam;
AlgLink_ScdchPrm * chPrm;
UInt32 blkIdx;
/* Activate the Algorithm */
DSKT2_activateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
chanID = pScdAlgLinkObj->chParams[chId].chId;
chPrm = &(pScdAlgLinkObj->chParams[chId]);
chanParam.chId = chPrm->chId;
chanParam.mode = (SCD_Mode)chPrm->mode;
chanParam.width = chPrm->width;
chanParam.height = chPrm->height;
chanParam.stride = chPrm->stride;
chanParam.curFrame = chPrm->curFrame;
chanParam.frmSensitivity = (SCD_Sensitivity)chPrm->frmSensitivity;
chanParam.frmIgnoreLightsON = chPrm->frmIgnoreLightsON;
chanParam.frmIgnoreLightsOFF = chPrm->frmIgnoreLightsOFF;
chanParam.frmEdgeThreshold = chPrm->frmEdgeThreshold;
if(chPrm->chBlkConfigUpdate == TRUE)
{
chanParam.blkConfig = (SCD_blkChngConfig *) chPrm->blkConfig;
}
else
{
chanParam.blkConfig = NULL;
}
chanStatus = SCD_TI_setPrms(pScdAlgLinkObj->algHndl, &chanParam, chanID);
if(chanStatus != SCD_NO_ERROR)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : ERROR: Alg Set Params (chanID = %d) - 0x%08X !!!\n",
Utils_getCurTimeInMsec(), chanID, chanStatus);
#endif
/* Deactivate algorithm */
DSKT2_deactivateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
return FVID2_EFAIL;
}
scdResult.frmResult = SCD_DETECTOR_NO_CHANGE;
scdResult.blkResult = (SCD_blkChngMeta *)(scdResultBuff->blkResult);
chanStatus = SCD_TI_process(pScdAlgLinkObj->algHndl, chanID, &scdResult);
/* Deactivate algorithm */
DSKT2_deactivateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
if(chanStatus != SCD_NO_ERROR)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : ERROR: Alg Process (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
return FVID2_EFAIL;
}
scdResultBuff->frmResult = (AlgLink_ScdOutput) scdResult.frmResult;
scdResultBuff->chId = chanID;
// if(pScdAlgLinkObj->createArgs.chDefaultParams[chId].mode & SCD_DETECTMODE_MONITOR_BLOCKS)
if(pScdAlgLinkObj->chParams[chId].mode & SCD_DETECTMODE_MONITOR_BLOCKS)
{
UInt32 numBlkChg;
UInt32 monitoredBlk;
UInt32 numHorzBlks, numVertBlks, numBlksInFrame, blkHeight;
AlgLink_ScdResult *pChResult = scdResultBuff;
pChResult->frmResult = ALG_LINK_SCD_DETECTOR_CHANGE;
pChResult->chId = chanID;
monitoredBlk = 0;
numBlkChg = 0;
numHorzBlks = ((pScdAlgLinkObj->chParams[chId].width + 0x1F ) & (~0x1F)) / 32; /* Rounding to make divisible by 32 */
if((pScdAlgLinkObj->chParams[chId].height%ALG_LINK_SCD_BLK_HEIGHT_MIN) == 0)/* For Block height is divisible by 10 */
blkHeight = ALG_LINK_SCD_BLK_HEIGHT_MIN;
else /* For Block height is divisible by 12 */
blkHeight = ALG_LINK_SCD_BLK_HEIGHT;
numVertBlks = pScdAlgLinkObj->chParams[chId].height / blkHeight;
numBlksInFrame = numHorzBlks * numVertBlks;
for(blkIdx = 0; blkIdx < numBlksInFrame; blkIdx++)
{
if(pScdAlgLinkObj->chParams[chId].blkConfig[blkIdx].monitored == 1)
{
monitoredBlk++;
if(scdResultBuff->blkResult[blkIdx].numPixelsChanged > MOTION_DETECTION_SENSITIVITY(ALG_LINK_SCD_BLK_WIDTH, blkHeight))
numBlkChg++;
}
}
if((monitoredBlk > 0) && (numBlkChg > (NUM_BLOCK_MOTION_DETECTION_THRESOLD(monitoredBlk))))
{
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_printf(" %d: SCD : Motion Detected (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_MOTION_DETECT, pChResult, sizeof(AlgLink_ScdResult), FALSE);
}
}
if(scdResult.frmResult == SCD_DETECTOR_CHANGE)
{
AlgLink_ScdChStatus *pChStatus = &pScdAlgLinkObj->scdChStat[chanID];
pChStatus->size = sizeof(AlgLink_ScdChStatus);
pChStatus->frmResult = (UInt32) ALG_LINK_SCD_DETECTOR_CHANGE;
pChStatus->chId = chanID;
#if 0
/* Will be used post GA */
AlgLink_ScdprocessSCDmetadata(scdResultBuff,
&(pScdAlgLinkObj->chParams[chId]),
pChStatus);
#endif
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_printf(" %d: SCD : Tamper Detected (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_TAMPER_DETECT, pChStatus, sizeof(AlgLink_ScdChStatus), FALSE);
}
return FVID2_SOK;
}
