cv1800b test camera VI/VENC with gc2083

main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "cvi_mipi.h"
#include "cvi_sns_ctrl.h"
#include <linux/cvi_defines.h>
#include <linux/cvi_common.h>
#include "cvi_awb_comm.h"
#include "cvi_af_comm.h"
#include "cvi_comm_isp.h"
#include "sample_comm.h"
#include "cvi_isp.h"
#include "cvi_venc.h"


static SAMPLE_VI_CONFIG_S g_stViConfig;
static SAMPLE_INI_CFG_S g_stIniCfg;
static 	SIZE_S stSize;
static int sys_vi_init(void)
{
	MMF_VERSION_S stVersion;
	SAMPLE_INI_CFG_S	   stIniCfg;
	SAMPLE_VI_CONFIG_S stViConfig;

	PIC_SIZE_E enPicSize;

	CVI_S32 s32Ret = CVI_SUCCESS;
	 LOG_LEVEL_CONF_S log_conf;

	CVI_SYS_GetVersion(&stVersion);
	SAMPLE_PRT("MMF Version:%s\n", stVersion.version);

	log_conf.enModId = CVI_ID_LOG;
	log_conf.s32Level = CVI_DBG_DEBUG;
	CVI_LOG_SetLevelConf(&log_conf);

	// Get config from ini if found.
	if (SAMPLE_COMM_VI_ParseIni(&stIniCfg)) {
		SAMPLE_PRT("Parse complete\n");
	}

	//Set sensor number
	CVI_VI_SetDevNum(stIniCfg.devNum);
	/************************************************
	 * step1:  Config VI
	 ************************************************/
	s32Ret = SAMPLE_COMM_VI_IniToViCfg(&stIniCfg, &stViConfig);
	if (s32Ret != CVI_SUCCESS)
		return s32Ret;

	memcpy(&g_stViConfig, &stViConfig, sizeof(SAMPLE_VI_CONFIG_S));
	memcpy(&g_stIniCfg, &stIniCfg, sizeof(SAMPLE_INI_CFG_S));

	/************************************************
	 * step2:  Get input size
	 ************************************************/
	s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stIniCfg.enSnsType[0], &enPicSize);
	if (s32Ret != CVI_SUCCESS) {
		CVI_TRACE_LOG(CVI_DBG_ERR, "SAMPLE_COMM_VI_GetSizeBySensor failed with %#x\n", s32Ret);
		return s32Ret;
	}

	s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
	if (s32Ret != CVI_SUCCESS) {
		CVI_TRACE_LOG(CVI_DBG_ERR, "SAMPLE_COMM_SYS_GetPicSize failed with %#x\n", s32Ret);
		return s32Ret;
	}

	/************************************************
	 * step3:  Init modules
	 ************************************************/
	s32Ret = SAMPLE_PLAT_SYS_INIT(stSize);
	if (s32Ret != CVI_SUCCESS) {
		CVI_TRACE_LOG(CVI_DBG_ERR, "sys init failed. s32Ret: 0x%x !\n", s32Ret);
		return s32Ret;
	}

	s32Ret = SAMPLE_PLAT_VI_INIT(&stViConfig);
	if (s32Ret != CVI_SUCCESS) {
		CVI_TRACE_LOG(CVI_DBG_ERR, "vi init failed. s32Ret: 0x%x !\n", s32Ret);
		return s32Ret;
	}

	return CVI_SUCCESS;
}

int camera_enc_init();

int camera_VI_init(){

	sys_vi_init();

	printf("sys_vi_inited!\n");

	camera_enc_init();

	SAMPLE_COMM_VI_DestroyIsp(&g_stViConfig);

	SAMPLE_COMM_VI_DestroyVi(&g_stViConfig);

	SAMPLE_COMM_SYS_Exit();
	return 0;
}

int camera_enc_init()
{
	VENC_PARAM_MOD_S stModParam={0};
	int s32Ret = 0;

	s32Ret = CVI_VENC_GetModParam(&stModParam);
	stModParam.enVencModType = MODTYPE_H265E;
	stModParam.stH265eModParam.enH265eVBSource = VB_SOURCE_PRIVATE;
	stModParam.stH265eModParam.u32UserDataMaxLen = 3072;
	stModParam.stH265eModParam.bSingleEsBuf = true;
	stModParam.stH265eModParam.u32SingleEsBufSize = 0; // pCic->singleEsBufSize_h265e;
	stModParam.stH265eModParam.enRefreshType = 0;

	s32Ret = CVI_VENC_SetModParam(&stModParam);
	if (s32Ret != CVI_SUCCESS) {
		CVI_VENC_ERR("CVI_VENC_SetModParam type %d failure\n", MODTYPE_H265E);
		return CVI_FAILURE;
	}
	VENC_CHN_ATTR_S venc_chn_attr={0};
	venc_chn_attr.stVencAttr.enType = PT_H265;
	venc_chn_attr.stVencAttr.u32MaxPicWidth = 1920;
	venc_chn_attr.stVencAttr.u32MaxPicHeight = 1080;
	venc_chn_attr.stVencAttr.u32PicWidth = 1920;
	venc_chn_attr.stVencAttr.u32PicHeight = 1080;
	venc_chn_attr.stVencAttr.u32BufSize = ALIGN((uint32_t)(1920 * 1080 * 1.5), 4096) *2;
	venc_chn_attr.stVencAttr.bEsBufQueueEn = CVI_H26X_ES_BUFFER_QUEUE_DEFAULT;
	venc_chn_attr.stVencAttr.bIsoSendFrmEn = CVI_H26X_ISO_SEND_FRAME_DEFAUL;
	venc_chn_attr.stVencAttr.u32Profile = 0;
	venc_chn_attr.stVencAttr.bByFrame = CVI_TRUE; // get stream mode is slice mode or
													// frame mode ?

	venc_chn_attr.stRcAttr.enRcMode = VENC_RC_MODE_H265FIXQP;
	venc_chn_attr.stRcAttr.stH265FixQp.u32Gop = CVI_H26X_GOP_DEFAULT;
	venc_chn_attr.stRcAttr.stH265FixQp.u32SrcFrameRate = 30 ;
	venc_chn_attr.stRcAttr.stH265FixQp.fr32DstFrameRate = 30;
	venc_chn_attr.stRcAttr.stH265FixQp.bVariFpsEn = false;
	venc_chn_attr.stRcAttr.stH265FixQp.u32IQp = DEF_IQP;
	venc_chn_attr.stRcAttr.stH265FixQp.u32PQp = DEF_PQP;

	s32Ret = CVI_VENC_CreateChn(0,&venc_chn_attr);

	SAMPLE_COMM_VI_Bind_VENC(0,0,0);

	VENC_RECV_PIC_PARAM_S stRecvParam;
	stRecvParam.s32RecvPicNum = 1;

	printf(" hello,world!\n");
	s32Ret = CVI_VENC_StartRecvFrame(0, &stRecvParam);
	printf(" hello,world!\n");
	VENC_CHN_STATUS_S stStat={0};
	do{
		s32Ret = CVI_VENC_QueryStatus(0, &stStat);
	}while(stStat.u32CurPacks == 0);
	printf(" hello,world! %d\n", stStat.u32CurPacks);

	VENC_STREAM_S stream;
	stream.pstPack =
		(VENC_PACK_S *)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
	if (stream.pstPack == NULL) {
		CVI_VENC_ERR("malloc memory failed!\n");
		return s32Ret;
	}
	printf("start get stream!\n");
	s32Ret = CVI_VENC_GetStream(0, &stream, 20000);
	printf("end of stream!\n");
	return s32Ret;
}


int main(){

	camera_VI_init();	
	return 0;
}