• State
  • Locked Locked
  • Replies 1 reply
  • Subscribers 98 subscribers
  • Views 392 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

system_dctrl.c: dctrlTriDisplayConfig != NULL : failed !!!

Away.liu
Intellectual 890 points


HI :

  I used NVRSOURCE_04.01,

  I want to use dec_dis usecase, Once i use this setting run demo with usecase dev_dis,It runs well, when i set it to NVR  and run dvrmain,it caused a err: system_dctrl.c: dctrlTriDisplayConfig != NULL : failed !!!The setting of the vdisParams as follows.  

  May be something set to wrong,but i did not  find it.

int DVR_StartSystem(int isNTSC, int main_vout, int sub_vout, int venc_mode)
{
int i,j, layoutId, fps;
VSYS_PARAMS_S vsysParams;
//VCAP_PARAMS_S vcapParams;
//VENC_PARAMS_S vencParams;
VDEC_PARAMS_S vdecParams;
VDIS_PARAMS_S vdisParams;
VDIS_MOSAIC_S sVdMosaicParam;

Bool forceLowCostScale = FALSE;
UInt64 wallTimeBase;
AUDIO_STATE *pAudstate = &gAudio_state ;
pAudstate->pbchannel = 0;

VdecVdis_bitsRdInit();

#ifdef VDEC_VDIS_ENABLE_IPCFRAMESOUT
VdecVdis_ipcFramesCreate();
#endif

TRACE_APP("\n");
#if 0
gDemo_info.maxVcapChannels = 0;
gDemo_info.maxVdisChannels = gVdecVdis_config.fileNum;
gDemo_info.maxVencChannels = 0;
gDemo_info.maxVdecChannels = gVdecVdis_config.fileNum;

vdecParams.numChn = gVdecVdis_config.fileNum;
vdisParams.numChannels = gVdecVdis_config.fileNum;
#endif
TRACE_APP("\n");
Vsys_params_init(&vsysParams);
vsysParams.systemUseCase = VSYS_USECASE_MULTICHN_VDEC_VDIS;
vsysParams.enableCapture = FALSE;
vsysParams.enableNsf = FALSE;
vsysParams.enableEncode = FALSE;
vsysParams.enableDecode = TRUE;
vsysParams.enableNullSrc = FALSE;
vsysParams.enableAVsync = TRUE;
vsysParams.numDeis = 0;
vsysParams.numSwMs = 2;
vsysParams.numDisplays = 2;

#ifdef DEBUG_TRS_LCD_DISPLAY
TRACE_APP("\n");
// vcapParams.numChn = 3;
// vencParams.numPrimaryChn = 3;
vdecParams.numChn = 1;
vdisParams.numChannels = 1;
//vsysParams.numChs = 1;
#else
vsysParams.systemUseCase = VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC;
// vcapParams.numChn = 16;
// vencParams.numPrimaryChn = 16;
vdecParams.numChn = 16;
vdisParams.numChannels = 32;
vsysParams.numChs = 16;

#endif

#if 0
//CIF output setting///
#ifdef RTSP_STREAM_ENABLE
vsysParams.enableSecondaryOut = TRUE;
vsysParams.enableNsf = TRUE;
vencParams.numSecondaryChn = 16;
#else
vsysParams.enableSecondaryOut = FALSE;
vsysParams.enableNsf = FALSE;
vencParams.numSecondaryChn = 0;
#endif
///////////////////////

vsysParams.enableAVsync = TRUE;
vsysParams.enableMjpegEnc = FALSE;

vsysParams.enableCapture = TRUE;
vsysParams.enableNullSrc = FALSE;
vsysParams.enableOsd = TRUE;
vsysParams.enableScd = FALSE;

vsysParams.numDeis = 2;
vsysParams.numSwMs = 2;
vsysParams.numDisplays = 3;
#endif
printf ("--------------- CHANNEL DETAILS-------------\n");
// printf ("Capture Channels => %d\n", vcapParams.numChn);
// printf ("Enc Channels => Primary %d, Secondary %d\n", vencParams.numPrimaryChn, vencParams.numSecondaryChn);
printf ("Dec Channels => %d\n", vdecParams.numChn);
printf ("Disp Channels => %d\n", vdisParams.numChannels);
printf ("-------------------------------------------\n");

DVR_Override960HParamsInitSettings();
TRACE_APP("\n");
/* Override the context here as needed */
DVR_Override960HParamsVsys(&vsysParams);
TRACE_APP("\n");
Vsys_init(&vsysParams);
TRACE_APP("\n");
#if 0
/* Override the context here as needed */
for(i=0;i<MAX_DVR_CHANNELS;i++)
{
vcapParams.channelParams[i].dynamicParams.contrast = gInitSettings.camera[i].coloradjust.iContrast;
vcapParams.channelParams[i].dynamicParams.satauration = gInitSettings.camera[i].coloradjust.iSaturation;
vcapParams.channelParams[i].dynamicParams.brightness = gInitSettings.camera[i].coloradjust.iBrightness;
}

DVR_Override960HParamsVcap(&vcapParams);
Vcap_init(&vcapParams);


/* Override the context here as needed */
for(i=0;i<MAX_DVR_CHANNELS;i++)
{
switch(gInitSettings.camera[i].camrec.iFps)
{
case FRAMERATE_30_25:
if(isNTSC == CAM_NTSC)
fps = 30*1000;
else
fps = 25*1000;
break;
case FRAMERATE_15_13:
if(isNTSC == CAM_NTSC)
fps = 15*1000;
else
fps = 13*1000;
break;
case FRAMERATE_08_06:
if(isNTSC == CAM_NTSC)
fps = 8*1000;
else
fps = 6*1000;
break;
case FRAMERATE_04_03:
if(isNTSC == CAM_NTSC)
fps = 4*1000;
else
fps = 3*1000;
break;
default:
if(isNTSC == CAM_NTSC)
fps = 30*1000;
else
fps = 25*1000;
break;
}
vencParams.encChannelParams[i].dynamicParam.frameRate = fps;
vencParams.encChannelParams[i].enableAnalyticinfo = 1 ;

int bps = gInitSettings.camera[i].camrec.ikbps*1000;
if(bps >= 64000 && bps <= 4000000)
{
vencParams.encChannelParams[i].dynamicParam.targetBitRate = bps;
}

switch(gInitSettings.camera[i].camrec.iIFrameInterval)
{
case IFRAME_INTERVAL_30_25:
if(isNTSC == CAM_NTSC)
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 30;
else
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 25;
break;
case IFRAME_INTERVAL_15_13:
if(isNTSC == CAM_NTSC)
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 15;
else
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 13;
break;
case IFRAME_INTERVAL_10_6:
if(isNTSC == CAM_NTSC)
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 10;
else
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 6;
break;
case IFRAME_INTERVAL_5_3:
if(isNTSC == CAM_NTSC)
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 5;
else
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 3;
break;
case IFRAME_INTERVAL_1:
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 1;
break;
default:
if(isNTSC == CAM_NTSC)
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 30;
else
vencParams.encChannelParams[i].dynamicParam.intraFrameInterval = 25;
break;

}

if(gInitSettings.camera[i].camrec.iBitrateType == BITRATE_TYPE_CBR)
{
vencParams.encChannelParams[i].rcType = VENC_RATE_CTRL_CBR;
}
else
{
vencParams.encChannelParams[i].rcType = VENC_RATE_CTRL_VBR;
}

}
DVR_Override960HParamsVenc(&vencParams);
Venc_init(&vencParams);
#endif
//Vcap_params_init(&vcapParams);
//Venc_params_init(&vencParams);
TRACE_APP("\n");
Vdec_params_init(&vdecParams);

vdecParams.forceUseDecChannelParams = TRUE ; // Pal

for (i=0; i < vdecParams.numChn; i++)
{
vdecParams.decChannelParams[i].dynamicParam.frameRate = 30; // NOT USED
vdecParams.decChannelParams[i].dynamicParam.targetBitRate = 2 * 1000 * 1000; // NOT USED


vdecParams.decChannelParams[i].maxVideoWidth = 1920; //gVdecVdis_config.fileInfo[i].width;//720;//gInitSettings.dvrMode.width;
vdecParams.decChannelParams[i].maxVideoHeight = 1080;// gVdecVdis_config.fileInfo[i].height;//576;//gInitSettings.dvrMode.height;

TRACE_APP("i=%d vdecParams.decChannelParams[i].maxVideoWidth=%d",i,vdecParams.decChannelParams[i].maxVideoWidth);
TRACE_APP("i=%d vdecParams.decChannelParams[i].maxVideoHeight=%d",i,vdecParams.decChannelParams[i].maxVideoHeight);
/*If the codec type is missing, by default choose h264*/
vdecParams.decChannelParams[i].isCodec = VDEC_CHN_H264;
vdecParams.decChannelParams[i].displayDelay = 0;
vdecParams.decChannelParams[i].numBufPerCh = 0;
vdecParams.decChannelParams[i].tilerEnable = TRUE;
vdecParams.decChannelParams[i].enableWaterMarking = 0;
}

/* Override the context here as needed */
DVR_Override960HParamsVdec(&vdecParams);
Vdec_init(&vdecParams);

TRACE_APP("\n");
//V_dis
Vdis_params_init(&vdisParams);

gLiveDspId = gInitSettings.layout.iMainOutput;
gPlayDspId = gInitSettings.layout.iSubOutput;
TRACE_APP("gLiveDspId=%d gPlayDspId=%d \n",gLiveDspId,gPlayDspId);
/* Override the context here as needed */
vdisParams.deviceParams[gLiveDspId].resolution = DEMO_HD_DISPLAY_DEFAULT_STD;//VSYS_STD_1080P_60;
vdisParams.deviceParams[gPlayDspId].resolution = DEMO_HD_DISPLAY_DEFAULT_STD;//VSYS_STD_1080P_60;
/* Since HDCOMP and HDMI are tied together they must have same resolution */
vdisParams.deviceParams[VDIS_DEV_HDMI].resolution = vdisParams.deviceParams[gLiveDspId].resolution;
vdisParams.deviceParams[VDIS_DEV_DVO2].resolution = vdisParams.deviceParams[gPlayDspId].resolution;
vdisParams.deviceParams[VDIS_DEV_SD].resolution = VSYS_STD_NTSC;// VSYS_STD_PAL;
TRACE_APP("--------------\n");
TRACE_APP("vdisParams.deviceParams[VDIS_DEV_DVO2].resolution=%d \n",
vdisParams.deviceParams[VDIS_DEV_DVO2].resolution );
printf("vdisParams.\n",vdisParams.deviceParams[VDIS_DEV_HDMI].resolution);

TRACE_APP("--------------\n");

Vdis_tiedVencInit(VDIS_DEV_HDMI, VDIS_DEV_DVO2, &vdisParams);

switch(gInitSettings.layout.iLayoutMode)
{
case LIB_LAYOUTMODE_1:
layoutId = MULTICH_LAYOUT_MODE_1CH;
break;
case LIB_LAYOUTMODE_4:
layoutId = MULTICH_LAYOUT_MODE_2x2_4CH;
break;
case LIB_LAYOUTMODE_9:
layoutId = MULTICH_LAYOUT_MODE_3x3_9CH;
break;
case LIB_LAYOUTMODE_8:
layoutId = MULTICH_LAYOUT_MODE_1x1_8CH;
break;
case LIB_LAYOUTMODE_8_1:
layoutId = MULTICH_LAYOUT_MODE_2x2_8CH;
break;
case LIB_LAYOUTMODE_12:
layoutId = MULTICH_LAYOUT_MODE_4x3_12CH;
break;
case LIB_LAYOUTMODE_12_1:
layoutId = MULTICH_LAYOUT_MODE_12CH;
break;
case LIB_LAYOUTMODE_14:
layoutId = MULTICH_LAYOUT_MODE_14CH;
break;
case LIB_LAYOUTMODE_16:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
case LIB_LAYOUTMODE_20:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
case LIB_LAYOUTMODE_CAMFLOW:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
default:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
}

DVR_swMsGenerateLayouts(gLiveDspId, 0, MAX_CH*2, layoutId, &(vdisParams.mosaicParams[gLiveDspId]),
forceLowCostScale, vdisParams.deviceParams[gLiveDspId].resolution, 0);

vdisParams.mosaicParams[gLiveDspId].userSetDefaultSWMLayout = TRUE;
for (i=0; i<vdisParams.mosaicParams[gLiveDspId].numberOfWindows; i++)
{
gMosaicInfo_Live.chMap[i] = vdisParams.mosaicParams[gLiveDspId].chnMap[i];
}

gMosaicInfo_Live.layoutId = layoutId;
gMosaicInfo_Live.numWin = vdisParams.mosaicParams[gLiveDspId].numberOfWindows;
gMosaicInfo_Live.isCamPropMode = 0;

switch(gInitSettings.layout.iSecondLayoutMode)
{
case LIB_LAYOUTMODE_1:
layoutId = MULTICH_LAYOUT_MODE_1CH;
break;
case LIB_LAYOUTMODE_4:
layoutId = MULTICH_LAYOUT_MODE_2x2_4CH;
break;
case LIB_LAYOUTMODE_9:
layoutId = MULTICH_LAYOUT_MODE_3x3_9CH;
break;
case LIB_LAYOUTMODE_8:
layoutId = MULTICH_LAYOUT_MODE_1x1_8CH;
break;
case LIB_LAYOUTMODE_8_1:
layoutId = MULTICH_LAYOUT_MODE_2x2_8CH;
break;
case LIB_LAYOUTMODE_12:
layoutId = MULTICH_LAYOUT_MODE_4x3_12CH;
break;
case LIB_LAYOUTMODE_12_1:
layoutId = MULTICH_LAYOUT_MODE_12CH;
break;
case LIB_LAYOUTMODE_14:
layoutId = MULTICH_LAYOUT_MODE_14CH;
break;
case LIB_LAYOUTMODE_16:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
case LIB_LAYOUTMODE_20:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
case LIB_LAYOUTMODE_CAMFLOW:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;
break;
default:
layoutId = MULTICH_LAYOUT_MODE_4x4_16CH;

break;
}

if(gInitSettings.layout.iMainOutput != gInitSettings.layout.iSubOutput)
{
DVR_swMsGenerateLayouts(gPlayDspId, MAX_CH, MAX_CH*2, layoutId, &(vdisParams.mosaicParams[gPlayDspId]),

forceLowCostScale,vdisParams.deviceParams[gPlayDspId].resolution, 0);
vdisParams.mosaicParams[gPlayDspId].userSetDefaultSWMLayout = TRUE;

for (i=0; i<vdisParams.mosaicParams[gPlayDspId].numberOfWindows; i++)
{
gMosaicInfo_Play.chMap[i] = vdisParams.mosaicParams[gPlayDspId].chnMap[i];
vdisParams.mosaicParams[gPlayDspId].chnMap[i] = VDIS_CHN_INVALID;
}

gMosaicInfo_Play.layoutId = layoutId;
gMosaicInfo_Play.numWin = vdisParams.mosaicParams[gPlayDspId].numberOfWindows;
gMosaicInfo_Play.isCamPropMode = 0;
}
else
{
DVR_swMsGenerateLayouts(VDIS_DEV_HDCOMP, MAX_CH, MAX_CH*2, layoutId, &(vdisParams.mosaicParams[VDIS_DEV_HDCOMP]),

forceLowCostScale,vdisParams.deviceParams[VDIS_DEV_HDCOMP].resolution, 0);
vdisParams.mosaicParams[VDIS_DEV_HDCOMP].userSetDefaultSWMLayout = TRUE;

for (i=0; i<vdisParams.mosaicParams[VDIS_DEV_HDCOMP].numberOfWindows; i++)
{
gMosaicInfo_Play.chMap[i] = vdisParams.mosaicParams[VDIS_DEV_HDCOMP].chnMap[i];
vdisParams.mosaicParams[VDIS_DEV_HDCOMP].chnMap[i] = VDIS_CHN_INVALID;
}

gMosaicInfo_Play.layoutId = gMosaicInfo_Live.layoutId;
gMosaicInfo_Play.numWin = gMosaicInfo_Live.numWin;
gMosaicInfo_Play.isCamPropMode = 0;
}

vdisParams.enableLayoutGridDraw = FALSE;
vdisParams.tiedDevicesMask = VDIS_DEV_DVO2;

/* Override the context here as needed */
DVR_Override960HParamsVdis(&vdisParams);
Vdis_init(&vdisParams);

/* Init the application specific module which will handle bitstream exchange */
WRITER_create();
wallTimeBase = get_current_time_to_msec();
Vdis_setWallTimeBase(wallTimeBase);

/* Configure display */
Vsys_configureDisplay();


printf("=====Going to Vsys_create=========\n");
/* Create Link instances and connects compoent blocks */
Vsys_create();

#if 0
if(vsysParams.enableSecondaryOut)
{
Int32 chId;
VENC_CHN_DYNAMIC_PARAM_S params = { 0 };


for (chId=0; chId < vencParams.numPrimaryChn; chId++)
{
/* now use VIP-SC secondary output, so input to VIP-SC and VIP-SC secondary channel are both
half of the real input framerate */

/* At capture level,YUV420 D1 stream id is 1. Set for D1 channels 0 ~ MAX_CH */
Vcap_setFrameRate(chId, 1, 30, 30);

/* At capture level,YUV422 D1 stream id is 0. Set for D1 channels 0 ~ MAX_CH */
Vcap_setFrameRate(chId, 0, 60, 0);


{

Int32 i;
for (i=0; i<vdisParams.mosaicParams[gLiveDspId].numberOfWindows; i++)
{
if((vdisParams.mosaicParams[gLiveDspId].chnMap[i] == chId) && (vdisParams.mosaicParams[gLiveDspId].useLowCostScaling[i] == FALSE))
Vcap_setFrameRate(chId,0,30,30); // Arun -Vcap_setFrameRate(chId,0,60,30);
}

for (i=0; i<vdisParams.mosaicParams[gPlayDspId].numberOfWindows; i++)
{
if((vdisParams.mosaicParams[gPlayDspId].chnMap[i] == chId) && (vdisParams.mosaicParams[gPlayDspId].useLowCostScaling[i] == FALSE))
Vcap_setFrameRate(chId,0,30,30); // Arun - Vcap_setFrameRate(chId,0,60,30);
}

}


/* At capture level, CIF stream id is 2. Set for CIF channels 0 ~ MAX_CH */
Vcap_setFrameRate(chId, 2, 30, 30);

}

for(chId=0;chId<vencParams.numPrimaryChn;chId++)
{
memset(&params, 0, sizeof(params));
Venc_setInputFrameRate(chId, CIF_FPS_DEI_NTSC);

params.frameRate = CIF_FPS_DEI_NTSC;

Venc_setDynamicParam(chId, 0, &params, VENC_FRAMERATE);

if(vsysParams.enableSecondaryOut)
{
memset(&params, 0, sizeof(params));

Venc_setInputFrameRate(chId+vencParams.numPrimaryChn, CIF_FPS_DEI_NTSC);

params.frameRate = CIF_FPS_ENC_NTSC;
params.targetBitRate = CIF_BITRATE * 1000;

/* At encode level, CIF channel id is 16 ~ 31. Stream id is immaterial */
Venc_setDynamicParam(chId+vencParams.numPrimaryChn, 0, &params, VENC_FRAMERATE);
}
if (vencParams.numTertiaryChn)
{
memset(&params, 0, sizeof(params));

Venc_setInputFrameRate(chId+(vencParams.numPrimaryChn*3), CIF_FPS_DEI_NTSC);

params.frameRate = CIF_FPS_ENC_NTSC;
params.targetBitRate = 125 * 1000;

/* At encode level, CIF channel id is 16 ~ 31. Stream id is immaterial */
Venc_setDynamicParam(chId+(vencParams.numPrimaryChn*3), 0, &params, VENC_FRAMERATE);
}
}

}
#endif

/* Start components in reverse order */
Vdis_start();
Vdec_start();
// Venc_start();
//Vcap_start();

//Vdis_stopDrv(VDIS_DEV_HDMI);
// Vdis_stopDrv(VDIS_DEV_DVO2);

Vdis_startDrv(VDIS_DEV_HDMI);
Vdis_startDrv(VDIS_DEV_DVO2);

#if 0
isNTSC = Vcap_detectVideoInfo();

if(isNTSC == VSYS_STD_PAL)
{
printf("\nFirst Camera connected is of PAL type\n");
printf("\nFirst Camera connected is of PAL type\n");
printf("\nFirst Camera connected is of PAL type\n");

}
else if(isNTSC == VSYS_STD_NTSC)
{
printf("\nFirst Camera connected is of NTSC type\n");
printf("\nFirst Camera connected is of NTSC type\n");
printf("\nFirst Camera connected is of NTSC type\n");

}
DVR_GetSourceStatus();
{
UInt32 chId;

VCAP_VIDEO_SOURCE_STATUS_S videoSourceStatus;
VCAP_VIDEO_SOURCE_CH_STATUS_S *pChStatus;
VENC_CHN_DYNAMIC_PARAM_S params = { 0 };

Vcap_getVideoSourceStatus( &videoSourceStatus );

for(chId=0; chId<videoSourceStatus.numChannels; chId++)
{
pChStatus = &videoSourceStatus.chStatus[chId];

if(pChStatus->isVideoDetect)
{
if(pChStatus->frameHeight == 288)
{
memset(&params, 0, sizeof(params));

Venc_setInputFrameRate(chId, CIF_FPS_DEI_PAL);

switch(gInitSettings.camera[chId].camrec.iFps)
{
case FRAMERATE_30_25:
params.frameRate = 25;
break;
case FRAMERATE_15_13:
params.frameRate = 13;
break;
case FRAMERATE_08_06:
params.frameRate = 6;
break;
case FRAMERATE_04_03:
params.frameRate = 3;
break;
default:
params.frameRate = 25;
break;
}

Venc_setDynamicParam(chId, 0, &params, VENC_FRAMERATE);

if(vsysParams.enableSecondaryOut)
{
memset(&params, 0, sizeof(params));

Venc_setInputFrameRate(chId+vencParams.numPrimaryChn, CIF_FPS_DEI_PAL);

params.frameRate = CIF_FPS_ENC_PAL;
params.targetBitRate = CIF_BITRATE * 1000;
Venc_setDynamicParam(chId+vencParams.numPrimaryChn, 0, &params, VENC_FRAMERATE);
}
}
else if(pChStatus->frameHeight == 240)
{
memset(&params, 0, sizeof(params));
Venc_setInputFrameRate(chId, CIF_FPS_DEI_NTSC);

switch(gInitSettings.camera[chId].camrec.iFps)
{
case FRAMERATE_30_25:
params.frameRate = 30;
break;
case FRAMERATE_15_13:
params.frameRate = 15;
break;
case FRAMERATE_08_06:
params.frameRate = 8;
break;
case FRAMERATE_04_03:
params.frameRate = 4;
break;
default:
params.frameRate = 30;
break;
}

Venc_setDynamicParam(chId, 0, &params, VENC_FRAMERATE);

if(vsysParams.enableSecondaryOut)
{
memset(&params, 0, sizeof(params));

Venc_setInputFrameRate(chId+vencParams.numPrimaryChn, CIF_FPS_DEI_NTSC);

params.frameRate = CIF_FPS_ENC_NTSC;
params.targetBitRate = CIF_BITRATE * 1000;

Venc_setDynamicParam(chId+vencParams.numPrimaryChn, 0, &params, VENC_FRAMERATE);
}
}
}
else
{
printf (" DEMO: %2d: No video detected at CH [%d,%d] !!!\n",
chId, pChStatus->vipInstId, pChStatus->chId);

}
}
}

{
VCAP_CHN_DYNAMIC_PARAM_S params;

for(i = 0; i<MAX_DVR_CHANNELS; i++)
{
memset(&params, 0, sizeof(params));


for(j = 0; j < ALG_LINK_OSD_MAX_WINDOWS; j++)
{
g_osdChParam[i].winPrm[j].enableWin = 0;
/* max value check below need to be fixed below based upon capture max width and height*/
}

params.osdChWinPrm = &g_osdChParam[i];

Vcap_setDynamicParamChn(i, &params, VCAP_OSDWINPRM);

DVR_setCaptureResolution(i, gInitSettings.camera[i].camrec.iResolution);
}
}
#endif
for(i=0;i<MAX_DVR_CHANNELS;i++)
{
if(gInitSettings.camera[i].iEnable == 0)
DVR_SetCameraEnable(i, gInitSettings.camera[i].iEnable);
if(gInitSettings.playbackcamera[i].iEnable == 0)
DVR_SetCameraEnable(MAX_CH+i, gInitSettings.playbackcamera[i].iEnable);
}

grpx_fb_start();

DVR_SetSpotChannel(gInitSettings.iSpotOutputCh);

DVR_setOff_GRPX() ;

if(gInitSettings.layout.iMainOutput != VDIS_DEV_HDMI)
{
DVR_SwitchDisplay(gInitSettings.layout.iMainOutput, gInitSettings.layout.iSubOutput, 1);
}

printf("\n ===============Switch Display Done========================= \n");

if(gInitSettings.maindisplayoutput.iResolution != DC_MODE_1080P_60)
{
DVR_SetDisplayRes(gInitSettings.layout.iMainOutput, gInitSettings.maindisplayoutput.iResolution, 0);
}

printf("\n ===============Main Output Resolution Switch Done========== \n");
if(gInitSettings.subdisplayoutput.iResolution != DC_MODE_1080P_60)
{
DVR_SetDisplayRes(gInitSettings.layout.iSubOutput, gInitSettings.subdisplayoutput.iResolution, 0);
}

printf("\n ===============Sub Output Resolution Switch Done=========== \n");

DVR_setOff_GRPX() ;

DVR_SetMosaicLayout(LIB_LAYOUTMODE_16); //Arun

#ifdef DVRAPP_960H_ENABLE
DVR_SetMosaicLayout(LIB_LAYOUTMODE_16);
DVR_SetPlaybackMosaicLayout(LIB_LAYOUTMODE_4);
#endif /* DVRAPP_960H_ENABLE */

#ifdef AUDIO_STREAM_ENABLE
DVR_setAudioInputParams(AUDIO_SAMPLE_RATE_DEFAULT, gInitSettings.audioin.iVolume);

Audio_playStart(gInitSettings.audioout.iDevId);
Audio_playSetVolume(gInitSettings.audioout.iVolume*10);

Audio_captureStart();

sleep(1);
#endif
printf("\n ================DVR_StartSystem Done===================== \n");

return 0;
}

---------------------------------------------------------------

  • 0
    TI__Guru 59700 points

    Only VPS_DC_VENC_HDMI | VPS_DC_VENC_HDCOMP (HDMI tied with HDCOMP) and VPS_DC_VENC_DVO2 | VPS_DC_VENC_HDCOMP (DVO2 tied with HDCOMP)

    tied venc configuration mesh is predefined in DVRRDK system_dctrl.c. HDMI tied with DVO2 is not supported by default. You have to modify system_dctrl.c to support this.