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; }