static int video_DigitalZoom(int nChn, int nRatioX, int nRatioY, int nRatioW, int nRatioH, unsigned char bLive )
{
static unsigned char s_bZoom[MAX_CAM_CH];
if(nChn < MAX_CAM_CH){
int i = 0;
VO_ZOOM_RATIO_S stZoomRatio = {0};
if(!s_bZoom[nChn]){
if(0 == nRatioX && 0 == nRatioY && 1000 == nRatioW && 1000 == nRatioH){
// needless to zoom
return 0;
}
stZoomRatio.u32XRatio = nRatioX;
stZoomRatio.u32YRatio = nRatioY;
stZoomRatio.u32WRatio = nRatioW;
stZoomRatio.u32HRatio = nRatioH;
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], nChn, &stZoomRatio));
}
s_bZoom[nChn] = TRUE;
}else{
// all zeroes is recover
memset(&stZoomRatio, 0, sizeof(stZoomRatio));
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], nChn, &stZoomRatio));
}
s_bZoom[nChn] = FALSE;
}
return 0;
}
return -1;
}
static void video_ClearDigitalZoom(int nChn)
{
int i = 0;
VO_ZOOM_ATTR_S stBaseZoom;
VO_ZOOM_RATIO_S stZoomRatio;
memset(&stZoomRatio, 0, sizeof(stZoomRatio));
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], nChn, &stZoomRatio)); // very important
}
video_GetZoom(nChn, &stBaseZoom, NULL);
if(VIDEO_IsLiveMode()){
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInWindow(VO_DEV_ID[i], nChn, &stBaseZoom));
}
// VIDEO_TRACE("clear zoom @ ch%d [%d,%d,%d,%d]", nChn, stBaseZoom.stZoomRect.s32X, stBaseZoom.stZoomRect.s32Y, stBaseZoom.stZoomRect.u32Width, stBaseZoom.stZoomRect.u32Height);
}else{
memset(&stBaseZoom.stZoomRect, 0, sizeof(stBaseZoom.stZoomRect));
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInWindow(VO_DEV_ID[i], nChn, &stBaseZoom));
}
}
memset(&s_stVideo.astDigitalZoomRatio[nChn], 0, sizeof(s_stVideo.astDigitalZoomRatio[nChn]));
s_stVideo.abDigitalZoom[nChn] = FALSE;
}
static void video_InputDestroy()
{
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi2
DVR_ASSERT(HI_MPI_VI_DisableChn(2, 0));
DVR_ASSERT(HI_MPI_VI_Disable(2));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi0
DVR_ASSERT(HI_MPI_VI_DisableChn(0, 0));
DVR_ASSERT(HI_MPI_VI_Disable(0));
}
static int avenc_AEncDestroy()
{
int i = 0;
for(i = 0; i < AVENC_AUDIO_MAX_CH; ++i){
// unbind AENC
DVR_ASSERT(HI_MPI_AENC_UnBindAi(i, AIN_DEV, i));
// destroy aenc chn
DVR_ASSERT(HI_MPI_AENC_DestroyChn(i));
if(AUDIO_IsCapLiveLoop()){
DVR_ASSERT(HI_MPI_AI_DisableChn(AIN_DEV, i));
}
}
return 0;
}
static void video_OutputDestroy()
{
int i = 0, ii = 0;
for(i = 0; i < sizeof(VO_DEV_ID) / sizeof(VO_DEV_ID[0]); ++i){
// enable vo channel
for(ii = 0; ii < VIDEO_GetMaxDiv(); ++ii){
DVR_ASSERT(HI_MPI_VO_DisableChn(VO_DEV_ID[i], ii));
}
// disable video layer
DVR_ASSERT(HI_MPI_VO_DisableVideoLayer(VO_DEV_ID[i]));
}
video_ScreenExit();
s_stVideo.bOutput = FALSE;
}
static void video_InputDestroy()
{
int i = 0;
// vi0 1-16 ch cif input 1d1
// vi1 1-16 ch selecting input 1d1
// vi2 17-20 ch d1 input 4d1
// vi3 21-24 ch d1 input 4d1
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi3
for(i = 0; i < 4; ++i){
DVR_ASSERT(HI_MPI_VI_DisableChn(3, i));
}
DVR_ASSERT(HI_MPI_VI_Disable(3));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi2
for(i = 0; i < 4; ++i){
DVR_ASSERT(HI_MPI_VI_DisableChn(2, i));
}
DVR_ASSERT(HI_MPI_VI_Disable(2));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi1
DVR_ASSERT(HI_MPI_VI_DisableChn(1, 0));
DVR_ASSERT(HI_MPI_VI_Disable(1));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi0
DVR_ASSERT(HI_MPI_VI_DisableChn(0, 0));
DVR_ASSERT(HI_MPI_VI_Disable(0));
}
static void video_OutputDestroy()
{
int i = 0, ii = 0;
for(i = 0; i < sizeof(VO_DEV_ID) / sizeof(VO_DEV_ID[0]); ++i){
// enable vo channel
for(ii = MAX_CAM_CH; ii >= 0; --ii){
video_BindOutput(VO_DEV_ID[i], ii, FALSE);
DVR_ASSERT(HI_MPI_VO_DisableChn(VO_DEV_ID[i], ii));
}
// disable video layer
DVR_ASSERT(HI_MPI_VO_DisableVideoLayer(VO_DEV_ID[i]));
}
video_ScreenExit();
s_stVideo.bOutput = FALSE;
}
static void video_ClearDigitalZoom(int nChn)
{
int i = 0;
VO_ZOOM_RATIO_S stZoomRatio;
VO_ZOOM_ATTR_S stZoomRect;
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
memset(&stZoomRatio, 0, sizeof(stZoomRatio));
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], nChn, &stZoomRatio));
DVR_ASSERT(HI_MPI_VO_GetZoomInWindow(VO_DEV_ID[i], nChn, &stZoomRect));
memset(&stZoomRect.stZoomRect, 0, sizeof(stZoomRect.stZoomRect));
DVR_ASSERT(HI_MPI_VO_SetZoomInWindow(VO_DEV_ID[i], nChn, &stZoomRect));
}
memset(&s_stVideo.astDigitalZoomRatio[nChn], 0, sizeof(s_stVideo.astDigitalZoomRatio[nChn]));
s_stVideo.abDigitalZoom[nChn] = FALSE;
}
static void video_InputDestroy()
{
int nDev = 0;
int i = 0, ii = 0;
for(ii = 0; ii < MAX_CAM_CH; ii += 4) {
if(VIMAP_Get(ii, &nDev, NULL) < 0) {
continue;
}
for(i = 0; i < 4; ++i) {
DVR_ASSERT(HI_MPI_VI_DisableChn(nDev, i));
}
DVR_ASSERT(HI_MPI_VI_Disable(nDev));
}
}
static void video_InputDestroy()
{
int ii, jj;
// vi0 1-4 ch cif input 4d1
// vi1 5-8 ch cif input 4d1
// vi2 9-12 ch cif input 4d1
// vi3 13-16 ch cif input 4d1
////////////////////////////////////////////////////////////////
for(ii = 0; ii < 4; ii ++) {
for(jj = 0; jj < 4; ++ jj){
DVR_ASSERT(HI_MPI_VI_DisableChn(ii, jj));
}
DVR_ASSERT(HI_MPI_VI_Disable(ii));
}
}
static void avenc_VideoPreProc(int nVeGrp, int nChn)
{
int const nWidth = 352;
int const nHeight = (VOUT_PAL == g_pstSysEnv->GetStandard(g_pstSysEnv)) ? 288 : 240;
// source size
if(nChn < 16){
// all is cif
VIDEO_PREPROC_CONF_S stPreProcConf;
DVR_ASSERT(HI_MPI_VPP_GetConf(nVeGrp, &stPreProcConf));
stPreProcConf.stClipAttr[0].stClipRect.u32Width = 352;
stPreProcConf.stClipAttr[0].stClipRect.u32Height = (VOUT_PAL == g_pstSysEnv->GetStandard(g_pstSysEnv)) ? 288 : 240;
stPreProcConf.stClipAttr[0].stClipRect.s32X= 0;
stPreProcConf.stClipAttr[0].stClipRect.s32Y = (stPreProcConf.stClipAttr[0].stClipRect.u32Height + 2) * (nChn % 8);
stPreProcConf.stClipAttr[0].u32SrcWidth = 352; // field width
stPreProcConf.stClipAttr[0].u32SrcHeight = (8 * stPreProcConf.stClipAttr[0].stClipRect.u32Height + 7 * 2) * 2; // half field height
stPreProcConf.stClipAttr[0].u32ClipMode = (nChn < 8) ? VIDEO_FIELD_BOTTOM : VIDEO_FIELD_TOP;
DVR_ASSERT(HI_MPI_VPP_SetConf(nVeGrp, &stPreProcConf));
}
}
static void video_CheckDigitalZoomD1(int nChn)
{
int i = 0;
VO_ZOOM_RATIO_S stZoomRatio = {0};
stZoomRatio.u32XRatio = s_stVideo.astDigitalZoomRatio[nChn].nRatioX;
stZoomRatio.u32YRatio = s_stVideo.astDigitalZoomRatio[nChn].nRatioY;
stZoomRatio.u32WRatio = s_stVideo.astDigitalZoomRatio[nChn].nRatioW;
stZoomRatio.u32HRatio = s_stVideo.astDigitalZoomRatio[nChn].nRatioH;
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], SPECIAL_D1_CH, &stZoomRatio));
}
}
static void video_DisplayD1(int nVoDev, int nChn, unsigned char bDisplay)
{
static int s_nDispViDev = -1;
static int s_nDispViChn = -1;
static int s_nDispVoChn = -1;
VI_CHN_ATTR_S stViChnAttr;
// input reset
// dont try to change input the original setting of d1 channel
if(bDisplay){
if(!(-1 == s_nDispViDev && -1 == s_nDispViChn)){
if(s_nDispVoChn >= MAX_D1_CNT){
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_CIF_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
}
DVR_ASSERT(HI_MPI_VO_SetChnField(nVoDev, nChn, VO_FIELD_BOTTOM));
}
if(nChn >= MAX_D1_CNT){
if(0 == VIMAP_Get(nChn, &s_nDispViDev, &s_nDispViChn)){
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_D1_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
s_nDispVoChn = nChn;
}
}
DVR_ASSERT(HI_MPI_VO_SetChnField(nVoDev, nChn, VO_FIELD_BOTH));
}else{
if(!(-1 == s_nDispViDev && -1 == s_nDispViChn)){
if(nChn >= MAX_D1_CNT){
// reset field setting
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_CIF_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
s_nDispViDev = -1;
s_nDispViChn = -1;
}
s_nDispVoChn = -1;
}
DVR_ASSERT(HI_MPI_VO_SetChnField(nVoDev, nChn, VO_FIELD_BOTTOM));
}
}
static void avenc_AEncInit()
{
#define AENC_G711A_USE
//#define AENC_ADPCM_USE
//#define AENC_LPCM_USE
int i = 0;
#if defined(AENC_G711A_USE)
AENC_ATTR_G711_S stAencG711A = {0};
AENC_CHN_ATTR_S stAencAttr = {.enType = PT_G711A, .pValue = &stAencG711A,};
#elif defined(AENC_ADPCM_USE)
AENC_ATTR_ADPCM_S stAencADPCM = {.enADPCMType = ADPCM_TYPE_DVI4, };
AENC_CHN_ATTR_S stAencAttr = {.enType = PT_ADPCMA, .pValue = &stAencADPCM,};
#elif defined(AENC_LPCM_USE)
AENC_ATTR_LPCM_S stAencLPCM = {0};
AENC_CHN_ATTR_S stAencAttr = {.enType = PT_LPCM, .pValue = &stAencLPCM,};
#else
#error "Audio Encode Format Not Supported"
#endif
// stAencAttr.u32BufSize = 8;
// stAencAttr.u32BufSize = MAX_AUDIO_FRAME_NUM; // ver 050 faq 1.6.3
stAencAttr.u32BufSize = 5;
// hisilicon SDK
for(i = 0; i < AVENC_AUDIO_MAX_CH; ++i){
if(g_pstSysEnv->GetEncMode(g_pstSysEnv, i) == MODE_AUDIO_VIDEO){
if(AUDIO_IsCapLiveLoop()){
// if with audio live loop
// audio live init here
DVR_ASSERT(HI_MPI_AI_EnableChn(AIN_DEV, i));
}
// create aenc chn
DVR_ASSERT(HI_MPI_AENC_CreateChn(i, &stAencAttr));
// bind AENC to AI channel
DVR_ASSERT(HI_MPI_AENC_BindAi(i, AIN_DEV, i));
}
}
}
static void video_InputDestroy()
{
int nDev = 0;
int i = 0;
#if (MAX_CAM_CH > 4)
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi2
nDev = 2;
for(i = 0; i < 4; ++i){
DVR_ASSERT(HI_MPI_VI_DisableChn(nDev, i));
}
DVR_ASSERT(HI_MPI_VI_Disable(nDev));
#endif
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi0
nDev = 0;
for(i = 0; i < 4; ++i){
DVR_ASSERT(HI_MPI_VI_DisableChn(nDev, i));
}
DVR_ASSERT(HI_MPI_VI_Disable(nDev));
}
static void video_InputInit()
{
int i = 0, ii = 0;
// init sdk
{
int nDev = 0;
int nChnCnt = 0;
VI_PUB_ATTR_S stViDevAttr;
VI_CHN_ATTR_S stViChnAttr;
int const vi_fps = (VIDEO_IS_PAL() ? 25 : 30);
// vi0 1-4 ch cif input 4d1
// vi2 5-8 ch d1 input 4d1
// device attributes
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_4D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// channel attributes
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.stCapRect.u32Height = (VIDEO_IS_PAL() ? 288 : 240);
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
VI_CIF_ATTR_CONF(&stViChnAttr);
for(ii = 0; ii < MAX_CAM_CH; ii += 4) {
if(VIMAP_Get(ii, &nDev, NULL) < 0) {
continue;
}
DVR_ASSERT(HI_MPI_VI_Disable(nDev));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(nDev, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(nDev));
for(i = 0; i < 4; ++i) {
if(nChnCnt++ < MAX_D1_CNT){
VI_D1_ATTR_CONF(&stViChnAttr);
}else{
VI_CIF_ATTR_CONF(&stViChnAttr);
}
DVR_ASSERT(HI_MPI_VI_SetChnAttr(nDev, i, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(nDev, i));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(nDev, i, vi_fps));
DVR_ASSERT(HI_MPI_VI_SetFrameRate(nDev, i, vi_fps));
}
}
}
}
// if arg=NULL, time stamp will sync to system clock
int SYSTEM_SetTime(struct timeval* pstVal)
{
int nRet = 0;
unsigned long long u64Pts = 0;
struct timeval stVal = {0};
if(pstVal){
stVal = *pstVal;
nRet = settimeofday(pstVal, NULL);
assert(0 == nRet);
write_rtc(pstVal->tv_sec);
sleep(2);
}else{
gettimeofday(&stVal, NULL);
}
u64Pts = stVal.tv_sec;
u64Pts *= 1000000;
u64Pts += stVal.tv_usec;
DVR_ASSERT(HI_MPI_SYS_InitPtsBase(u64Pts));
return 0;
}
static void video_InputInit()
{
int ii, jj;
VI_PUB_ATTR_S stViDevAttr;
VI_CHN_ATTR_S stViChnAttr;
// vi0 1-4 ch cif input 4d1
// vi1 5-8 ch cif input 4d1
// vi2 9-12 ch cif input 4d1
// vi3 13-16 ch cif input 4d1
////////////////////////////////////////////////////////////////
// vi
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_4D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// 4d1 input
stViChnAttr.stCapRect.u32Width = 704;
stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT;
stViChnAttr.stCapRect.s32X = VI_X_OFFSET;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enCapSel = VO_FIELD_BOTTOM;
stViChnAttr.bDownScale = HI_TRUE;
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
for(ii = 0; ii < 4; ii ++) {
// interface
DVR_ASSERT(HI_MPI_VI_Disable(ii));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(ii, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(ii));
for(jj = 0; jj < 4; jj ++) {
DVR_ASSERT(HI_MPI_VI_SetChnAttr(ii, jj, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(ii, jj));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(ii, jj, MAX_CIF_LIVE_FPS));
DVR_ASSERT(HI_MPI_VI_SetFrameRate(ii, jj, MAX_CIF_LIVE_FPS));
}
}
}
int SYSTEM_Init()
{
int BSizW = VIDEO_IS_960() ?VRES_SIZE_W_EF :VRES_SIZE_W_SD;
int BSizH = VIDEO_IS_PAL() ?VRES_SIZE_H_PL :VRES_SIZE_H_NT;
int ii = 0;
VB_CONF_S stVbConf = {0};
MPP_SYS_CONF_S stSysConf = {0};
memset(&stVbConf, 0, sizeof(stVbConf));
#ifdef _NVR
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[0].u32BlkSize = 352 * 288 * 2;
stVbConf.astCommPool[0].u32BlkCnt = 4;
#elif defined(_EXT_HDDVR)
#if (MAX_CAM_CH == 4) && defined(_HI3520D_EXT)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
//stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 2;
//stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
//ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (VRES_SIZE_W_HD1080P/2) * VRES_SIZE_W_HD720P * 3 / 2;// 1280*720*2 , 1280*960*1.5( 1080* 960* 1.5)
stVbConf.astCommPool[ii].u32BlkCnt = 7 * MAX_CAM_CH - 1;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH - 2;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
#elif (MAX_CAM_CH == 4)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD1080P * VRES_SIZE_H_HD1080P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 6 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
#endif
#if (MAX_CAM_CH == 8) && defined(SDK_PLATFORM_HI3521)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD1080P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (VRES_SIZE_W_HD1080P/2) * VRES_SIZE_H_HD1080P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 5 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 2 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 2 * MAX_CAM_CH;
ii ++;
#elif (MAX_CAM_CH == 8)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD1080P * VRES_SIZE_H_HD1080P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 2 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD1080P * VRES_SIZE_H_HD1080P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 2 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P* 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD1080P * VRES_SIZE_H_HD1080P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD1080P * VRES_SIZE_H_HD1080P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P* 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 1 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 1 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
#endif
#if (MAX_CAM_CH == 16) && defined(SDK_PLATFORM_HI3531)
#ifdef _HVR
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
if (JCONF_BNC_CAM() > 0) {
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * ((JCONF_BNC_CAM()+1)/2*2)/2;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * ((JCONF_BNC_CAM()+1)/2*2)/2;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = (VRES_SIZE_W_HD1080P/2) * VRES_SIZE_H_HD1080P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 5 * ((JCONF_BNC_CAM()+1)/2*2)/2;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (VRES_SIZE_W_HD1080P/2) * VRES_SIZE_H_HD1080P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 5 * ((JCONF_BNC_CAM()+1)/2*2)/2;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * JCONF_BNC_CAM();
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * JCONF_BNC_CAM();
ii ++;
}
if (JCONF_BNC_CAM() == 0) {
stVbConf.astCommPool[ii].u32BlkSize = (1920 * 1080) * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (1280 * 960) * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (720 * 576) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 6;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (352 * 288) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 6;
ii ++;
}
#else
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 2;
stVbConf.astCommPool[ii].u32BlkCnt = 3 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = VRES_SIZE_W_HD720P * VRES_SIZE_H_HD720P * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = (BSizW) * (BSizH) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
#endif
#endif
#elif defined(_JA2024NC)
// stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 704 * 576 * 2; // 4*4CIF live vi0
// stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 4 * 16;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 384 * 4636 * 2; // 16CIF live must be YUV422 2bpp
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 12;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 704 * 576 * 2; // D1 live(1-16) vi1
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 8;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 384 * 288 * 2; // 4CIF live vi3 (17-20)
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 8 * 4;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 384 * 288 * 2; // 4CIF live vi4 (21-24)
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 8 * 4;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 704 * 576 * 2; // 1D1 live vi3/4 (17-24)
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 8;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 384 * 288 * 3 / 2; // VENC main stream
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 6 * MAX_CAM_CH;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 384 * 288 * 3 / 2; // VENC sub stream
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 6 * MAX_CAM_CH;
++stVbConf.u32MaxPoolCnt;
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkSize = 384 * 288 * 3 / 2; // VENC cell-phonme stream
stVbConf.astCommPool[stVbConf.u32MaxPoolCnt].u32BlkCnt = 6;
++stVbConf.u32MaxPoolCnt;
#elif defined(_JA2032NC)
stVbConf.u32MaxPoolCnt = 7;
stVbConf.astCommPool[0].u32BlkSize = 384 * 4636 * 2; // 16CIF live must be YUV422 2bpp
stVbConf.astCommPool[0].u32BlkCnt = 12;
stVbConf.astCommPool[1].u32BlkSize = 384 * 4636 * 2; // 16CIF live must be YUV422 2bpp
stVbConf.astCommPool[1].u32BlkCnt = 12;
stVbConf.astCommPool[2].u32BlkSize = 704 * 576 * 2; // D1 live(1-8) vi1
stVbConf.astCommPool[2].u32BlkCnt = 5;
stVbConf.astCommPool[3].u32BlkSize = 704 * 576 * 2; // D1 live(9-16) vi3
stVbConf.astCommPool[3].u32BlkCnt = 5;
stVbConf.astCommPool[4].u32BlkSize = 384 * 288 * 2; // VENC main stream
stVbConf.astCommPool[4].u32BlkCnt = 5 * MAX_CAM_CH;
stVbConf.astCommPool[5].u32BlkSize = 384 * 288 * 2; // VENC sub stream
stVbConf.astCommPool[5].u32BlkCnt = 5 * MAX_CAM_CH;
stVbConf.astCommPool[6].u32BlkSize = 384 * 288 * 2; // VENC cell-phonme stream
stVbConf.astCommPool[6].u32BlkCnt = 5;
//stVbConf.astCommPool[7].u32BlkSize = 704 * 576 * 2; // D1 live(9-16) vi3
//stVbConf.astCommPool[7].u32BlkCnt = 2;
#elif defined(_JA7216CX) || defined(_JA7216NC)
stVbConf.u32MaxPoolCnt = 6;
// // from tongli
// stVbConf.astCommPool[0].u32BlkSize = 3339968;
// stVbConf.astCommPool[0].u32BlkCnt = 10;
// stVbConf.astCommPool[1].u32BlkSize = 813056;
// stVbConf.astCommPool[1].u32BlkCnt = 10;
// stVbConf.astCommPool[2].u32BlkSize = 214016;
// stVbConf.astCommPool[2].u32BlkCnt = 40;
// from yangyi
stVbConf.astCommPool[0].u32BlkSize = 384 * 4636 * 2; // 16CIF live must be YUV422 2bpp
stVbConf.astCommPool[0].u32BlkCnt = 12;
stVbConf.astCommPool[1].u32BlkSize = 704 * 576 * 2; // D1 live(1-8) vi1
stVbConf.astCommPool[1].u32BlkCnt = 5;
stVbConf.astCommPool[2].u32BlkSize = 704 * 576 * 2; // D1 live(9-16) vi3
stVbConf.astCommPool[2].u32BlkCnt = 5;
stVbConf.astCommPool[3].u32BlkSize = 384 * 288 * 2; // VENC main stream
stVbConf.astCommPool[3].u32BlkCnt = 5 * MAX_CAM_CH;
stVbConf.astCommPool[4].u32BlkSize = 384 * 288 * 2; // VENC sub stream
stVbConf.astCommPool[4].u32BlkCnt = 5 * MAX_CAM_CH;
stVbConf.astCommPool[5].u32BlkSize = 384 * 288 * 2; // VENC cell-phonme stream
stVbConf.astCommPool[5].u32BlkCnt = 5;
#elif defined(_JA2016CX) || defined(_JA2016NC) || defined(_JA2016ICX)
stVbConf.u32MaxPoolCnt = 6;
stVbConf.astCommPool[0].u32BlkSize = 704 * 576 * 2; // D1 for full screen live
stVbConf.astCommPool[0].u32BlkCnt = 5 * (MAX_D1_CNT + 1);
stVbConf.astCommPool[1].u32BlkSize = 352 * 288 * 2; // cif for live
stVbConf.astCommPool[1].u32BlkCnt = 5 * (MAX_CIF_CNT - MAX_D1_CNT);
stVbConf.astCommPool[2].u32BlkSize = 704 * 576 * 3 / 2; // cif for main stream venc
stVbConf.astCommPool[2].u32BlkCnt = 4 * MAX_D1_CNT;
stVbConf.astCommPool[3].u32BlkSize = 352 * 288 * 3 / 2; // cif for sub stream venc
stVbConf.astCommPool[3].u32BlkCnt = 4 * (MAX_CIF_CNT - MAX_D1_CNT);
stVbConf.astCommPool[4].u32BlkSize = 352 * 288 * 3 / 2; // cif for sub stream venc
stVbConf.astCommPool[4].u32BlkCnt = 4 * MAX_CAM_CH;
stVbConf.astCommPool[5].u32BlkSize = 352 * 288 * 3 / 2; // VENC cell-phonme stream
stVbConf.astCommPool[5].u32BlkCnt = 4;
#elif defined(_JA2008NC)
stVbConf.u32MaxPoolCnt = 6;
stVbConf.astCommPool[0].u32BlkSize = 704 * 576 * 2; // D1 for full screen live
stVbConf.astCommPool[0].u32BlkCnt = 5 * (MAX_D1_CNT + 1);
stVbConf.astCommPool[1].u32BlkSize = 352 * 288 * 2; // cif for live
stVbConf.astCommPool[1].u32BlkCnt = 5 * (MAX_CIF_CNT - MAX_D1_CNT);
stVbConf.astCommPool[2].u32BlkSize = 704 * 576 * 3 / 2; // cif for main stream venc
stVbConf.astCommPool[2].u32BlkCnt = 4 * MAX_D1_CNT;
stVbConf.astCommPool[3].u32BlkSize = 352 * 288 * 3 / 2; // cif for sub stream venc
stVbConf.astCommPool[3].u32BlkCnt = 4 * (MAX_CIF_CNT - MAX_D1_CNT);
stVbConf.astCommPool[4].u32BlkSize = 352 * 288 * 3 / 2; // cif for sub stream venc
stVbConf.astCommPool[4].u32BlkCnt = 4 * MAX_CAM_CH;
stVbConf.astCommPool[5].u32BlkSize = 352 * 288 * 3 / 2; // VENC cell-phonme stream
stVbConf.astCommPool[5].u32BlkCnt = 4;
#elif defined(_JA9204RN)
stVbConf.u32MaxPoolCnt = 5;
stVbConf.astCommPool[0].u32BlkSize = 960 * 576 * 3 / 2; // D1 for full screen live
stVbConf.astCommPool[0].u32BlkCnt = 5 * (MAX_D1_CNT + 1);
stVbConf.astCommPool[1].u32BlkSize = 480 * 288 * 3 / 2; // cif for live
stVbConf.astCommPool[1].u32BlkCnt = 5 * (MAX_CIF_CNT - MAX_D1_CNT);
stVbConf.astCommPool[2].u32BlkSize = 960 * 576 * 3 / 2; // cif for main stream venc
stVbConf.astCommPool[2].u32BlkCnt = 4 * MAX_D1_CNT;
stVbConf.astCommPool[3].u32BlkSize = 480 * 288 * 3 / 2; // cif for sub stream venc
stVbConf.astCommPool[3].u32BlkCnt = 4 * (MAX_CIF_CNT - MAX_D1_CNT);
stVbConf.astCommPool[4].u32BlkSize = 480 * 288 * 3 / 2; // cif for sub stream venc
stVbConf.astCommPool[4].u32BlkCnt = 4 * MAX_CAM_CH;
#elif defined(_JA3116TW)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 1.5 * (MAX_D1_CNT) * (VIDEO_IS_PAL() ?1 :1.2f);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * (MAX_D1_CNT + 1) * (VIDEO_IS_PAL() ?1 :1.2f);
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 2.5 * (MAX_CAM_CH + 1) * (VIDEO_IS_PAL() ?1 :1.2f);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 2 * (MAX_CAM_CH + 1) * (VIDEO_IS_PAL() ?1 :1.2f);
strcpy(stVbConf.astCommPool[ii ++].acMmzName, MMZ_ZONE_NAME1);
#elif defined(_JA2104) || defined(_JA2106) || defined(_JA2116)
#if defined(_HI3520D_RAM_LITE) && (MAX_CAM_CH == 4)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_D1_CNT + 2;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * (MAX_CIF_CNT - MAX_D1_CNT) + 3 * MAX_CAM_CH + 2;
ii ++;
#elif defined(_HI3520D_RAM_LITE) && (MAX_CAM_CH == 8)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * (MAX_D1_CNT + 1);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * (MAX_CIF_CNT - MAX_D1_CNT) + 2 * MAX_CAM_CH;
ii ++;
#elif defined(_HI3515A_EXT) && defined(_JA2104)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 9 * (MAX_D1_CNT + 1);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 6 * (MAX_CIF_CNT - MAX_D1_CNT) + 10 * (MAX_CAM_CH);
ii ++;
#elif defined(_HI3520D_EXT) && defined(_JA2104)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2; // D1 for full screen live
stVbConf.astCommPool[ii].u32BlkCnt = 7 * (MAX_D1_CNT + 1);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2; // cif for live
stVbConf.astCommPool[ii].u32BlkCnt = 6 * (MAX_CIF_CNT - MAX_D1_CNT);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2; // cif for live
stVbConf.astCommPool[ii].u32BlkCnt = 4 * (MAX_CAM_CH);
ii ++;
#else
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2; // D1 for full screen live
stVbConf.astCommPool[ii].u32BlkCnt = 5 * (MAX_D1_CNT + 1) + 3;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2; // cif for live
stVbConf.astCommPool[ii].u32BlkCnt = 6 * (MAX_CIF_CNT - MAX_D1_CNT) + 4 * (MAX_CAM_CH);
ii ++;
#endif
#elif defined(_JA2108) || defined(_JA2116D)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 12 * (MAX_D1_CNT + 1);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 12 * (MAX_CIF_CNT - MAX_D1_CNT);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2; // cif for live
stVbConf.astCommPool[ii].u32BlkCnt = 5 * (MAX_CAM_CH);
ii ++;
#elif defined(_JA2124) || defined(_JA2132)
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[ii].u32BlkSize = 720 * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 9 * ((MAX_CAM_CH/16) * 4);
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = BSizW * BSizH * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 6 * ((MAX_CAM_CH%16)/4)+6;
ii ++;
stVbConf.astCommPool[ii].u32BlkSize = (BSizW/2) * (BSizH/2) * 3 / 2;
stVbConf.astCommPool[ii].u32BlkCnt = 4 * MAX_CAM_CH;
ii ++;
#else
stVbConf.u32MaxPoolCnt = VB_MAX_POOLS;
stVbConf.astCommPool[0].u32BlkSize = 704 * 576 * 3 / 2;
stVbConf.astCommPool[0].u32BlkCnt = 8 * (MAX_D1_CNT);
stVbConf.astCommPool[1].u32BlkSize = 352 * 288 * 3 / 2;
stVbConf.astCommPool[1].u32BlkCnt = 8 * (MAX_CIF_CNT - MAX_D1_CNT) + 2;
#endif
SYSTEM_Destroy();
SYSTEM_SetTime(NULL);
DVR_ASSERT(HI_MPI_VB_SetConf(&stVbConf));
DVR_ASSERT(HI_MPI_VB_Init());
stSysConf.u32AlignWidth = 16;
DVR_ASSERT(HI_MPI_SYS_SetConf(&stSysConf));
DVR_ASSERT(HI_MPI_SYS_Init());
return 0;
}
void SYSTEM_Destroy()
{
DVR_ASSERT(HI_MPI_SYS_Exit());
DVR_ASSERT(HI_MPI_VB_Exit());
}
static void video_Division(int nVoDev, int nScrWidth, int nScrHeight, int nDiv, int nPage, unsigned char bD1)
{
int i = 0;
int nGrid = 1;
VO_CHN_ATTR_S stVoChnAttr;
int nLocate = 0;
int nChWidth = 0;
int nChHeight = 0;
int nOffsetX = (VO_ORIGIN_WIDTH - nScrWidth) / 2;
int nOffsetY = (VO_ORIGIN_HEIGHT - nScrHeight) / 2;
int nBlankW = 0;
int nBlankH = 0;
if(-1 == nDiv){
nDiv = VIDEO_GetMaxDiv();
}
switch(nDiv)
{
case 1: nGrid = 1; break;
case 4: nGrid = 2; break;
case 9: nGrid = 3; break;
case 16: nGrid = 4; break;
case 25: nGrid = 5; break;
default:
return;
}
if(nVoDev == VO_CVBS_DEVICE) {
nOffsetX = s_stVideo.ScrnEdges[1].nEdgeX;
nOffsetY = s_stVideo.ScrnEdges[1].nEdgeY;
nScrWidth = s_stVideo.ScrnEdges[1].nEdgeW;
nScrHeight = s_stVideo.ScrnEdges[1].nEdgeH;
}
nChWidth = nScrWidth / nGrid;
nChHeight = nScrHeight / nGrid;
nChWidth &= ~(2-1); // 2 alignment
nChHeight &= ~(2-1); // 2 alignment
nBlankW = nScrWidth % nChWidth;
nBlankH = nScrHeight % nChHeight;
for(i = 0, nLocate = 0; i < VIDEO_GetMaxDiv(); ++i){
stVoChnAttr.stRect.s32X = nOffsetX + (((nLocate % nDiv) % nGrid) * nChWidth) & ~(2-1); // 2 alignment
stVoChnAttr.stRect.s32Y = nOffsetY + (((nLocate % nDiv) / nGrid) * nChHeight) & ~(2-1); // 2 alignment
//VIDEO_TRACE("vo(%d,%d) (x,y)=%d,%d, [w,h]=%d,%d", nVoDev, i, stVoChnAttr.stRect.s32X, stVoChnAttr.stRect.s32Y, stVoChnAttr.stRect.u32Width, stVoChnAttr.stRect.u32Height);
if((nGrid - 1) == (nLocate % nGrid)){
// the right side
stVoChnAttr.stRect.u32Width = nChWidth + nBlankW;
}else{
// for osd bar
stVoChnAttr.stRect.u32Width = nChWidth - 2;
}
if((nGrid - 1) == (nLocate / nGrid)){
stVoChnAttr.stRect.u32Height = nChHeight + nBlankH;
}else{
// for osd bar
stVoChnAttr.stRect.u32Height = nChHeight - 2;
}
stVoChnAttr.u32Priority = 1;
stVoChnAttr.bZoomEnable = HI_TRUE;
stVoChnAttr.bDeflicker = (0 == nVoDev) ? HI_FALSE : HI_TRUE;
DVR_ASSERT(HI_MPI_VO_SetChnAttr(nVoDev, i, &stVoChnAttr));
if(VO_CHN_IS_ONTOP(nDiv, nPage, i)){
++nLocate;
DVR_ASSERT(HI_MPI_VO_ChnShow(nVoDev, i));
}else{
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, i));
}
}
}
static void video_OutputInit()
{
int i = 0, ii = 0;
int const nMaxFps = MAX_D1_CNT ? MAX_D1_LIVE_FPS : MAX_CIF_LIVE_FPS;
VO_VIDEO_LAYER_ATTR_S stVgaLayerAttr;
VO_VIDEO_LAYER_ATTR_S stCvbsLayerAttr;
// vga output
{
VGA_RESOLUTION const enRes = g_pstSysEnv->GetVGAResolution(g_pstSysEnv);
stVgaLayerAttr.stImageSize.u32Width = VO_ORIGIN_WIDTH;
stVgaLayerAttr.stImageSize.u32Height = VO_ORIGIN_HEIGHT;
stVgaLayerAttr.stDispRect.s32X = 0;
stVgaLayerAttr.stDispRect.s32Y = 0;
switch(enRes) {
case VGA_800x600:
stVgaLayerAttr.stDispRect.u32Width = 800;
stVgaLayerAttr.stDispRect.u32Height = 600;
break;
default:
case VGA_1024x768:
stVgaLayerAttr.stDispRect.u32Width = 1024;
stVgaLayerAttr.stDispRect.u32Height = 768;
break;
case VGA_1280x1024:
stVgaLayerAttr.stDispRect.u32Width = 1280;
stVgaLayerAttr.stDispRect.u32Height = 1024;
break;
case VGA_1366x768:
stVgaLayerAttr.stDispRect.u32Width = 1366;
stVgaLayerAttr.stDispRect.u32Height = 768;
break;
case VGA_1440x900:
stVgaLayerAttr.stDispRect.u32Width = 1440;
stVgaLayerAttr.stDispRect.u32Height = 900;
break;
}
stVgaLayerAttr.u32DispFrmRt = nMaxFps;
stVgaLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVgaLayerAttr.s32PiPChn = VO_DEFAULT_CHN;
}
// cvbs
{
stCvbsLayerAttr.stImageSize.u32Width = VO_ORIGIN_WIDTH;
stCvbsLayerAttr.stImageSize.u32Height = VO_ORIGIN_HEIGHT;
stCvbsLayerAttr.stDispRect.s32X = 0;
stCvbsLayerAttr.stDispRect.s32Y = 0;
stCvbsLayerAttr.stDispRect.u32Width = VO_ORIGIN_WIDTH;
stCvbsLayerAttr.stDispRect.u32Height = VO_ORIGIN_HEIGHT;
stCvbsLayerAttr.u32DispFrmRt = nMaxFps;
stCvbsLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stCvbsLayerAttr.s32PiPChn = VO_DEFAULT_CHN;
}
{
// configuration active
const VO_VIDEO_LAYER_ATTR_S astVideoLayerAttr[] = {stVgaLayerAttr, stCvbsLayerAttr};
video_ScreenInit();
for(i = 0; i < sizeof(VO_DEV_ID) / sizeof(VO_DEV_ID[0]); ++i){
//DVR_ASSERT(HI_MPI_VO_SetDispBufLen(nDev, MAX_CAM_CH));
DVR_ASSERT(HI_MPI_VO_SetVideoLayerAttr(VO_DEV_ID[i], &astVideoLayerAttr[i]));
DVR_ASSERT(HI_MPI_VO_EnableVideoLayer(VO_DEV_ID[i]));
// setup division
video_Division(VO_DEV_ID[i], s_stVideo.nScrWidth[i], s_stVideo.nScrHeight[i], -1, 0, FALSE);
// enable vo channel
for(ii = 0; ii < VIDEO_GetMaxDiv(); ++ii){
DVR_ASSERT(HI_MPI_VO_SetChnField(VO_DEV_ID[i], ii, VO_FIELD_BOTTOM));
DVR_ASSERT(HI_MPI_VO_EnableChn(VO_DEV_ID[i], ii));
if(ii < MAX_CAM_CH){
video_BindOutput(VO_DEV_ID[i], ii, TRUE);
}else{
DVR_ASSERT(HI_MPI_VO_SENDFRAME(VO_DEV_ID[i], ii, s_pstLogoPic));
}
}
}
}
s_stVideo.bOutput = TRUE;
}
static void video_DisplayD1(int nVoDev, int nChn, unsigned char bDisplay)
{
int i = 0, ii = 0;
static int s_nDispViDev = -1;
static int s_nDispViChn = -1;
VI_CHN_ATTR_S stViChnAttr;
if(bDisplay){
for(i = 0; i < VIDEO_GetMaxDiv(); ++i){
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, i));
}
}
if(bDisplay){
// unbind last full channel first
if(!(-1 == s_nDispViDev && -1 == s_nDispViChn)){
DVR_ASSERT(HI_MPI_VI_UnBindOutput(s_nDispViDev, s_nDispViChn, nVoDev, SPECIAL_D1_CH));
}
DVR_ASSERT(HI_MPI_VO_ClearChnBuffer(nVoDev, SPECIAL_D1_CH, HI_TRUE));
if(nChn < 16){
int fd = open(VIDEO_DEV, O_RDWR);
if(fd > 0){
// set ad configuration
video_preview_t stPreview = {0};
stPreview.chn = nChn; // switch to this channel @ ad
ioctl(fd, VIDEO_DRV_SET_LIVE_CHN, &stPreview);
close(fd);
fd = -1;
}
// redefine device
s_nDispViDev = 1;
s_nDispViChn = 0;
}else if(nChn < 24){
// reset field to both not downscale
if(0 == VIMAP_Get(nChn, &s_nDispViDev, &s_nDispViChn)){
}
}else{
;
}
if(s_stVideo.nLossStat & (1<<nChn)){
// VIDEO_TRACE("Send User Pic");
DVR_ASSERT(HI_MPI_VO_SENDFRAME(nVoDev, SPECIAL_D1_CH, VIDEO_GetUserPic(nChn)));
}else{
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_D1_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_BindOutput(s_nDispViDev, s_nDispViChn, nVoDev, SPECIAL_D1_CH));
usleep(40000);
}
DVR_ASSERT(HI_MPI_VO_ChnShow(nVoDev, SPECIAL_D1_CH));
}else{
if(!(-1 == s_nDispViDev && -1 == s_nDispViChn)){
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_CIF_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_UnBindOutput(s_nDispViDev, s_nDispViChn, nVoDev, SPECIAL_D1_CH));
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, SPECIAL_D1_CH));
if(nVoDev > 0){
s_nDispViDev = -1;
s_nDispViChn = -1;
}
}
}
}
static void video_InputInit()
{
int i = 0;
// init sdk
{
VI_PUB_ATTR_S stViDevAttr;
VI_CHN_ATTR_S stViChnAttr;
// vi0 1-16 ch cif input 1d1
// vi1 1-16 ch selecting input 1d1
// vi2 17-20 ch d1 input 4d1
// vi3 21-24 ch d1 input 4d1
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi0
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_1D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// channel attribute
stViChnAttr.stCapRect.s32X = 0;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.stCapRect.u32Width = VI_CIF_WIDTH;
stViChnAttr.stCapRect.u32Height = 8 * VI_CIF_HEIGHT + 7 * 2; // half field height combo frame
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enCapSel = VI_CAPSEL_BOTH;
stViChnAttr.bDownScale = HI_FALSE;
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
DVR_ASSERT(HI_MPI_VI_Disable(0));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(0, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(0));
DVR_ASSERT(HI_MPI_VI_SetChnAttr(0, 0, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(0, 0));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(0, 0, MAX_CIF_LIVE_FPS));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi1
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_1D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// channel attribute
stViChnAttr.stCapRect.u32Width = 704;
stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT;
stViChnAttr.stCapRect.s32X = 8;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enCapSel = VI_CAPSEL_BOTH;
stViChnAttr.bDownScale = HI_FALSE;
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
// interface
DVR_ASSERT(HI_MPI_VI_Disable(1));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(1, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(1));
DVR_ASSERT(HI_MPI_VI_SetChnAttr(1, 0, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(1, 0));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(1, 0, MAX_D1_LIVE_FPS));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi2
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_4D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// cif input
stViChnAttr.stCapRect.u32Width = 704;
stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT;
stViChnAttr.stCapRect.s32X = 8;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enCapSel = VI_CAPSEL_BOTTOM;
stViChnAttr.bDownScale = HI_TRUE;
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
// interface
DVR_ASSERT(HI_MPI_VI_Disable(2));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(2, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(2));
for(i = 0; i < 4; ++i){
DVR_ASSERT(HI_MPI_VI_SetChnAttr(2, i, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(2, i));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(2, i, MAX_CIF_LIVE_FPS));
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi3
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_4D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// cif input
stViChnAttr.stCapRect.u32Width = 704;
stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT;
stViChnAttr.stCapRect.s32X = 8;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enCapSel = VI_CAPSEL_BOTTOM;
stViChnAttr.bDownScale = HI_TRUE;
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
// interface
DVR_ASSERT(HI_MPI_VI_Disable(3));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(3, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(3));
for(i = 0; i < 4; ++i){
DVR_ASSERT(HI_MPI_VI_SetChnAttr(3, i, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(3, i));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(3, i, MAX_CIF_LIVE_FPS));
}
}
}
static void video_OutputInit()
{
int i = 0, ii = 0;
int const nMaxFps = MAX_D1_CNT ? MAX_D1_LIVE_FPS : MAX_CIF_LIVE_FPS;
VO_VIDEO_LAYER_ATTR_S stVgaLayerAttr;
VO_VIDEO_LAYER_ATTR_S stCvbsLayerAttr;
// vga output
{
VGA_RESOLUTION const enRes = g_pstSysEnv->GetVGAResolution(g_pstSysEnv);
stVgaLayerAttr.stImageSize.u32Width = VO_ORIGIN_WIDTH;
stVgaLayerAttr.stImageSize.u32Height = VO_ORIGIN_HEIGHT;
stVgaLayerAttr.stDispRect.s32X = 0;
stVgaLayerAttr.stDispRect.s32Y = 0;
switch(enRes) {
case VGA_800x600:
stVgaLayerAttr.stDispRect.u32Width = 800;
stVgaLayerAttr.stDispRect.u32Height = 600;
break;
default:
case VGA_1024x768:
stVgaLayerAttr.stDispRect.u32Width = 1024;
stVgaLayerAttr.stDispRect.u32Height = 768;
break;
case VGA_1280x1024:
stVgaLayerAttr.stDispRect.u32Width = 1280;
stVgaLayerAttr.stDispRect.u32Height = 1024;
break;
case VGA_1366x768:
stVgaLayerAttr.stDispRect.u32Width = 1366;
stVgaLayerAttr.stDispRect.u32Height = 768;
break;
case VGA_1440x900:
stVgaLayerAttr.stDispRect.u32Width = 1440;
stVgaLayerAttr.stDispRect.u32Height = 900;
break;
}
stVgaLayerAttr.u32DispFrmRt = nMaxFps;
stVgaLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVgaLayerAttr.s32PiPChn = VO_DEFAULT_CHN;
}
// cvbs
{
stCvbsLayerAttr.stImageSize.u32Width = VO_ORIGIN_WIDTH;
stCvbsLayerAttr.stImageSize.u32Height = VO_ORIGIN_HEIGHT;
stCvbsLayerAttr.stDispRect.s32X = 0;
stCvbsLayerAttr.stDispRect.s32Y = 0;
stCvbsLayerAttr.stDispRect.u32Width = VO_ORIGIN_WIDTH;
stCvbsLayerAttr.stDispRect.u32Height = VO_ORIGIN_HEIGHT;
stCvbsLayerAttr.u32DispFrmRt = nMaxFps;
stCvbsLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stCvbsLayerAttr.s32PiPChn = VO_DEFAULT_CHN;
}
{
// configuration active
const VO_VIDEO_LAYER_ATTR_S astVideoLayerAttr[] = {stVgaLayerAttr, stCvbsLayerAttr};
video_ScreenInit();
for(i = 0; i < sizeof(VO_DEV_ID) / sizeof(VO_DEV_ID[0]); ++i){
//DVR_ASSERT(HI_MPI_VO_SetDispBufLen(nDev, MAX_CAM_CH));
DVR_ASSERT(HI_MPI_VO_SetVideoLayerAttr(VO_DEV_ID[i], &astVideoLayerAttr[i]));
DVR_ASSERT(HI_MPI_VO_EnableVideoLayer(VO_DEV_ID[i]));
// setup division
video_Division(VO_DEV_ID[i], s_stVideo.nScrWidth[i], s_stVideo.nScrHeight[i], VIDEO_GetMaxDiv(), 0, FALSE);
// 1 - 16 digital zoom
// 17 - 20 bind directly
// 21 - 24 bind directly
VO_DISPLAY_FIELD_E enDisplayField;
// enable vo channel
for(ii = 0; ii < VIDEO_GetMaxDiv() + 1; ++ii){
if(ii < 16){
// for vi0 1-16
// digital zoom
VO_ZOOM_ATTR_S stZoomAttr;
memset(&stZoomAttr, 0, sizeof(stZoomAttr));
stZoomAttr.enField = VIDEO_FIELD_FRAME;
stZoomAttr.stZoomRect.u32Width = VI_CIF_WIDTH;
stZoomAttr.stZoomRect.u32Height = VI_CIF_HEIGHT;
stZoomAttr.stZoomRect.s32X = 0;
stZoomAttr.stZoomRect.s32Y = (ii % 8) * (stZoomAttr.stZoomRect.u32Height + 2);
VIDEO_TRACE("ch=%d zoom [%d,%d,%d,%d]", ii, stZoomAttr.stZoomRect.s32X, stZoomAttr.stZoomRect.s32Y, stZoomAttr.stZoomRect.u32Width, stZoomAttr.stZoomRect.u32Height);
DVR_ASSERT(HI_MPI_VO_SetZoomInWindow(VO_DEV_ID[i], ii, &stZoomAttr));
enDisplayField = (ii >= 8) ? VO_FIELD_TOP : VO_FIELD_BOTTOM;
}else if(ii < 20){
// for vi2 ch1-4
enDisplayField = VO_FIELD_BOTTOM;
}else if(ii < 24){
// for vi3 ch1-4
enDisplayField = VO_FIELD_BOTTOM;
}else if(24 == ii){
enDisplayField = VO_FIELD_BOTH;
}else if(25 == ii){
// for ch1-16 d1 live
enDisplayField = VO_FIELD_BOTH;
}
DVR_ASSERT(HI_MPI_VO_SetChnField(VO_DEV_ID[i], ii, enDisplayField));
DVR_ASSERT(HI_MPI_VO_EnableChn(VO_DEV_ID[i], ii));
if(ii < MAX_CAM_CH){
video_BindOutput(VO_DEV_ID[i], ii, TRUE);
}else if(ii < SPECIAL_D1_CH){
DVR_ASSERT(HI_MPI_VO_SENDFRAME(VO_DEV_ID[i], ii, s_pstLogoPic));
}
}
}
}
s_stVideo.bOutput = TRUE;
}
static void video_InputInit()
{
// int i = 0;
// init sdk
{
VI_PUB_ATTR_S stViDevAttr;
VI_CHN_ATTR_S stViChnAttr;
// vi0 1-16 ch cif input 1d1
// vi2 1-16 ch d1 input mutex d1 live
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi0
stViDevAttr.enInputMode = VI_MODE_BT656;
stViDevAttr.enWorkMode = VI_WORK_MODE_1D1;
stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC);
// channel attribute
stViChnAttr.stCapRect.s32X = 0;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.stCapRect.u32Width = VI_CIF_WIDTH;
stViChnAttr.stCapRect.u32Height = 8 * VI_CIF_HEIGHT + 7 * 2; // half field height combo frame
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.enCapSel = VI_CAPSEL_BOTH;
stViChnAttr.bDownScale = HI_FALSE;
stViChnAttr.bHighPri = HI_FALSE;
stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
DVR_ASSERT(HI_MPI_VI_Disable(0));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(0, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(0));
DVR_ASSERT(HI_MPI_VI_SetChnAttr(0, 0, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(0, 0));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(0, 0, MAX_CIF_LIVE_FPS));
DVR_ASSERT(HI_MPI_VI_SetFrameRate(0, 0, MAX_CIF_LIVE_FPS));
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// vi2 must be d1
stViChnAttr.enCapSel = VI_CAPSEL_BOTH;
stViChnAttr.bDownScale = HI_FALSE;
stViChnAttr.stCapRect.s32Y = 0;
stViChnAttr.stCapRect.u32Height = VIDEO_IS_PAL() ? 288 : 240;
stViChnAttr.bChromaResample = HI_FALSE;
stViChnAttr.bHighPri = HI_FALSE;
VI_CIF_ATTR_CONF(&stViChnAttr);
// vi2
DVR_ASSERT(HI_MPI_VI_Disable(2));
DVR_ASSERT(HI_MPI_VI_SetPubAttr(2, &stViDevAttr));
DVR_ASSERT(HI_MPI_VI_Enable(2));
DVR_ASSERT(HI_MPI_VI_SetChnAttr(2, 0, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_EnableChn(2, 0));
DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(2, 0, MAX_D1_LIVE_FPS));
DVR_ASSERT(HI_MPI_VI_SetFrameRate(2, 0, MAX_D1_LIVE_FPS));
}
}
static void video_Division(int nVoDev, int nScrWidth, int nScrHeight, int nDiv, int nPage, unsigned char bLive)
{
int i = 0;
int nGrid = 1;
VO_CHN_ATTR_S stVoChnAttr;
int nLocate = 0;
int nChWidth = 0;
int nChHeight = 0;
int nOffsetX = (VO_ORIGIN_WIDTH - nScrWidth) / 2;
int nOffsetY = (VO_ORIGIN_HEIGHT - nScrHeight) / 2;
int nBlankW = 0;
int nBlankH = 0;
int nBeginCh = nDiv * nPage;
int nEndCh = MAX_CAM_CH >= (nBeginCh + nDiv) ? MAX_CAM_CH : (nBeginCh + nDiv);
// if(!bD1 && 1 == nDiv){
// // full screen is ready all the time at this solution
// return;
// }
switch(nDiv)
{
case 1: nGrid = 1; break;
case 4: nGrid = 2; break;
case 9: nGrid = 3; break;
case 16: nGrid = 4; break;
case 25: nGrid = 5; break;
default:
return;
}
if(nVoDev == VO_CVBS_DEVICE) {
nOffsetX = s_stVideo.ScrnEdges[1].nEdgeX;
nOffsetY = s_stVideo.ScrnEdges[1].nEdgeY;
nScrWidth = s_stVideo.ScrnEdges[1].nEdgeW;
nScrHeight = s_stVideo.ScrnEdges[1].nEdgeH;
}
// full d1 for live only
stVoChnAttr.stRect.s32X = nOffsetX;
stVoChnAttr.stRect.s32Y = nOffsetY;
stVoChnAttr.stRect.u32Width = nScrWidth;
stVoChnAttr.stRect.u32Height = nScrHeight;
stVoChnAttr.u32Priority = 1;
stVoChnAttr.bZoomEnable = HI_TRUE;
stVoChnAttr.bDeflicker = HI_FALSE;
DVR_ASSERT(HI_MPI_VO_SetChnAttr(nVoDev, MAX_CAM_CH, &stVoChnAttr));
if(1 == nDiv && bLive){
DVR_ASSERT(HI_MPI_VO_ChnShow(nVoDev, MAX_CAM_CH));
}else{
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, MAX_CAM_CH));
}
nChWidth = nScrWidth / nGrid;
nChHeight = nScrHeight / nGrid;
nChWidth &= ~(2-1); // 2 alignment
nChHeight &= ~(2-1); // 2 alignment
nBlankW = nScrWidth % nChWidth;
nBlankH = nScrHeight % nChHeight;
for(i = 0, nLocate = 0; i < nEndCh; ++i){
int const nChn = i % MAX_CAM_CH;
unsigned char bShow = FALSE;
if(i >= nBeginCh && i < (nBeginCh + nDiv) && (nDiv > 1 || !bLive)){
// need to show
bShow = TRUE;
// live not full division mode
// playback all the mode
stVoChnAttr.stRect.s32X = (nOffsetX + (((nLocate % nDiv) % nGrid) * nChWidth)) & ~(2-1); // 2 alignment
stVoChnAttr.stRect.s32Y = (nOffsetY + (((nLocate % nDiv) / nGrid) * nChHeight)) & ~(2-1); // 2 alignment
if((nGrid - 1) == (nLocate % nGrid)){
// the right side
stVoChnAttr.stRect.u32Width = nChWidth + nBlankW;
}else{
// for osd bar
stVoChnAttr.stRect.u32Width = nChWidth - 2;
}
if((nGrid - 1) == (nLocate / nGrid)){
// the bottom
stVoChnAttr.stRect.u32Height = nChHeight + nBlankH;
}else{
// for osd bar
stVoChnAttr.stRect.u32Height = nChHeight - 2;
}
stVoChnAttr.u32Priority = 0;
stVoChnAttr.bZoomEnable = HI_TRUE;
stVoChnAttr.bDeflicker = (0 == nVoDev) ? HI_FALSE : HI_TRUE;
++nLocate;
}else{
bShow = FALSE;
stVoChnAttr.stRect.s32X = 0;
stVoChnAttr.stRect.s32Y = 0;
stVoChnAttr.stRect.u32Width = VI_CIF_WIDTH;
stVoChnAttr.stRect.u32Height = VI_CIF_HEIGHT;
stVoChnAttr.u32Priority = 0;
stVoChnAttr.bZoomEnable = HI_FALSE;
stVoChnAttr.bDeflicker = HI_FALSE;
}
// VIDEO_TRACE("vo(%d,%d) (x,y)=%d,%d, [w,h]=%d,%d", nVoDev, i, stVoChnAttr.stRect.s32X, stVoChnAttr.stRect.s32Y, stVoChnAttr.stRect.u32Width, stVoChnAttr.stRect.u32Height);
DVR_ASSERT(HI_MPI_VO_SetChnAttr(nVoDev, nChn, &stVoChnAttr));
if(bShow){
DVR_ASSERT(HI_MPI_VO_ChnShow(nVoDev, nChn));
}else{
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, nChn));
}
}
}
static void video_DisplayD1(int nVoDev, int nChn, unsigned char bDisplay)
{
static int s_nDispViDev = -1;
static int s_nDispViChn = -1;
VI_CHN_ATTR_S stViChnAttr;
if(bDisplay){
int i = 0;
for(i = 0; i < MAX_CAM_CH; ++i){
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, i));
}
}
if(bDisplay){
static int s_nLastFull = -1; // prevent to bind twice
if(-1 == s_nLastFull || nChn != s_nLastFull){
int fd = open(VIDEO_DEV, O_RDWR);
VIDEO_TRACE("%s fd = %d", __func__, fd);
if(fd > 0){
// set ad configuration
video_preview_t stPreview = {0};
stPreview.chn = nChn; // switch to this channel @ ad
ioctl(fd, VIDEO_DRV_SET_LIVE_CHN, &stPreview);
close(fd);
fd = -1;
}
}
// unbind last full channel first
if(!(-1 == s_nDispViDev && -1 == s_nDispViChn)){
DVR_ASSERT(HI_MPI_VI_UnBindOutput(s_nDispViDev, s_nDispViChn, nVoDev, MAX_CAM_CH));
}
// bind to d1 special live connect
s_nDispViDev = 2;
s_nDispViChn = 0;
DVR_ASSERT(HI_MPI_VO_ClearChnBuffer(nVoDev, MAX_CAM_CH, HI_TRUE));
if(s_stVideo.nLossStat & (1<<nChn)){
DVR_ASSERT(HI_MPI_VO_SENDFRAME(nVoDev, MAX_CAM_CH, VIDEO_GetUserPic(nChn)));
}else{
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_D1_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
DVR_ASSERT(HI_MPI_VI_BindOutput(s_nDispViDev, s_nDispViChn, nVoDev, MAX_CAM_CH));
}
usleep(40000);
DVR_ASSERT(HI_MPI_VO_ChnShow(nVoDev, MAX_CAM_CH));
video_CheckDigitalZoomD1(nChn);
}else{
if(!(-1 == s_nDispViDev && -1 == s_nDispViChn)){
DVR_ASSERT(HI_MPI_VO_ChnHide(nVoDev, MAX_CAM_CH));
// printf("unbind output (%d,%d) to (%d,%d)", s_nDispViDev, s_nDispViChn, nVoDev, MAX_CAM_CH);
DVR_ASSERT(HI_MPI_VI_UnBindOutput(s_nDispViDev, s_nDispViChn, nVoDev, MAX_CAM_CH));
DVR_ASSERT(HI_MPI_VI_GetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
VI_CIF_ATTR_CONF(&stViChnAttr);
DVR_ASSERT(HI_MPI_VI_SetChnAttr(s_nDispViDev, s_nDispViChn, &stViChnAttr));
s_nDispViDev = -1;
s_nDispViChn = -1;
}
}
}
static int video_DigitalZoom(int nChn, int nRatioX, int nRatioY, int nRatioW, int nRatioH, unsigned char bLive)
{
int i, ii;
VO_ZOOM_ATTR_S stBaseZoom;
if(bLive){
int x, y, w, h;
video_GetZoom(nChn, &stBaseZoom, NULL);
x = stBaseZoom.stZoomRect.s32X;
y = stBaseZoom.stZoomRect.s32Y;
w = stBaseZoom.stZoomRect.u32Width;
h = stBaseZoom.stZoomRect.u32Height;
if(!s_stVideo.abDigitalZoom[nChn]){
if(0 == nRatioX && 0 == nRatioY && 1000 == nRatioW && 1000 == nRatioH){
// needless to zoom
return 0;
}
s_stVideo.astDigitalZoomRatio[nChn].nRatioX = nRatioX;
s_stVideo.astDigitalZoomRatio[nChn].nRatioY = nRatioY;
s_stVideo.astDigitalZoomRatio[nChn].nRatioW = nRatioW;
s_stVideo.astDigitalZoomRatio[nChn].nRatioH = nRatioH;
stBaseZoom.stZoomRect.s32X = x + (nRatioX * w / 1000);
stBaseZoom.stZoomRect.s32Y = y + (nRatioY * h / 1000);
stBaseZoom.stZoomRect.u32Width = nRatioW * w / 1000;
stBaseZoom.stZoomRect.u32Height = nRatioH * h / 1000;
stBaseZoom.stZoomRect.s32X &= ~0xf; // aligned 16 pixels
stBaseZoom.stZoomRect.s32Y &= ~0xf; // aligned 16 pixels
stBaseZoom.stZoomRect.u32Width &= ~1;
stBaseZoom.stZoomRect.u32Height &= ~1;
VIDEO_TRACE("ch=%d zoom [%d,%d,%d,%d]", ii, stBaseZoom.stZoomRect.s32X,stBaseZoom.stZoomRect.s32Y, stBaseZoom.stZoomRect.u32Width, stBaseZoom.stZoomRect.u32Height);
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInWindow(VO_DEV_ID[i], nChn, &stBaseZoom));
}
if(1 == s_stVideo.nCurDivi && nChn == s_stVideo.nCurPage){
video_CheckDigitalZoomD1(nChn);
}
s_stVideo.abDigitalZoom[nChn] = TRUE;
}else{
// all zeroes is recover
memset(&s_stVideo.astDigitalZoomRatio[nChn], 0, sizeof(s_stVideo.astDigitalZoomRatio[nChn]));
s_stVideo.abDigitalZoom[nChn] = FALSE;
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInWindow(VO_DEV_ID[i], nChn, &stBaseZoom));
video_CheckDigitalZoomD1(nChn);
}
}
}else{
// return 0;
VO_ZOOM_RATIO_S stZoomRatio = {0};
if(!s_stVideo.abDigitalZoom[nChn]){
if(0 == nRatioX && 0 == nRatioY && 1000 == nRatioW && 1000 == nRatioH){
// needless to zoom
return 0;
}
s_stVideo.astDigitalZoomRatio[nChn].nRatioX = stZoomRatio.u32XRatio = nRatioX;
s_stVideo.astDigitalZoomRatio[nChn].nRatioY = stZoomRatio.u32YRatio = nRatioY;
s_stVideo.astDigitalZoomRatio[nChn].nRatioW = stZoomRatio.u32WRatio = nRatioW;
s_stVideo.astDigitalZoomRatio[nChn].nRatioH = stZoomRatio.u32HRatio = nRatioH;
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], nChn, &stZoomRatio));
}
s_stVideo.abDigitalZoom[nChn] = TRUE;
}else{
// all zeroes is recover
memset(&stZoomRatio, 0, sizeof(stZoomRatio));
for(i = 0; i < sizeof(VO_DEV_ID)/sizeof(VO_DEV_ID[0]); ++i){
DVR_ASSERT(HI_MPI_VO_SetZoomInRatio(VO_DEV_ID[i], nChn, &stZoomRatio));
}
memset(&s_stVideo.astDigitalZoomRatio[nChn], 0, sizeof(s_stVideo.astDigitalZoomRatio[nChn]));
s_stVideo.abDigitalZoom[nChn] = FALSE;
}
}
return 0;
}
