海思3559a_基于sample_venc使用双sensor并保存两路的视频文件到目录下-优快云博客

本文链接：https://blog.youkuaiyun.com/panaohan/article/details/144913320
sdk的sample文件示例venc，单独拷贝一份，专门用作双sensor保存视频
主要改动如下：
在这里插入图片描述
sample_venc源码如下：
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>

#include "sample_comm.h"

//#define SUPPORT_PRORES
/******************************************************************************
* function : show usage
******************************************************************************/
void SAMPLE_VENC_Usage(char* sPrgNm)
{
    printf("Usage : %s [index] \n", sPrgNm);
    printf("index:\n");
    printf("\t  0) H.265e@4K@120fps + H264e@1080p@30fps.\n");
    printf("\t  1) H.265e@4K@60fps + H264e@4K@60fp.\n");
    printf("\t  2) Lowdelay:H.265e@4K@30fps.\n");
    printf("\t  3) IntraRefresh:H.265e@4K@60fps + H264e@4K@60fps.\n");
    printf("\t  4) Qpmap:H.265e@4K + H264e@4K@60fps.\n");
    printf("\t  5) Mjpeg@4K@60fps +Jpeg@4K.\n");

    return;
}

/******************************************************************************
* function : to process abnormal case
******************************************************************************/
void SAMPLE_VENC_HandleSig(HI_S32 signo)
{
    if (SIGINT == signo || SIGTERM == signo)
    {
        SAMPLE_COMM_VENC_StopGetStream();
        SAMPLE_COMM_VENC_StopSendQpmapFrame();
        SAMPLE_COMM_All_ISP_Stop();
        SAMPLE_COMM_SYS_Exit();
        printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
    }
    exit(-1);
}

/******************************************************************************
* function : to process abnormal case - the case of stream venc
******************************************************************************/
void SAMPLE_VENC_StreamHandleSig(HI_S32 signo)
{

    if (SIGINT == signo || SIGTERM == signo)
    {
        SAMPLE_COMM_SYS_Exit();
        printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
    }

    exit(0);
}

VENC_GOP_MODE_E SAMPLE_VENC_GetGopMode(void)
{
    char c;
    VENC_GOP_MODE_E enGopMode = 0;

Begin_Get:

    printf("please input choose gop mode!\n");
    printf("\t 0) NORMALP.\n");
    printf("\t 1) DUALP.\n");
    printf("\t 2) SMARTP.\n");
    printf("\t 3) ADVSMARTP\n");
    printf("\t 4) BIPREDB\n");

    while((c = getchar()) != '\n' && c != EOF)
    switch(c)
    {
        case '0':
            enGopMode = VENC_GOPMODE_NORMALP;
            break;
        case '1':
            enGopMode = VENC_GOPMODE_DUALP;
            break;
        case '2':
            enGopMode = VENC_GOPMODE_SMARTP;
        break;
        case '3':
            enGopMode = VENC_GOPMODE_ADVSMARTP;
            break;
        case '4':
            enGopMode = VENC_GOPMODE_BIPREDB;
            break;
        default:
            SAMPLE_PRT("input rcmode: %c, is invaild!\n",c);
            goto Begin_Get;
    }

    return enGopMode;
}

SAMPLE_RC_E SAMPLE_VENC_GetRcMode(void)
{
    char c;
    SAMPLE_RC_E  enRcMode = 0;

Begin_Get:

    printf("please input choose rc mode!\n");
    printf("\t c) cbr.\n");
    printf("\t v) vbr.\n");
    printf("\t a) avbr.\n");
    printf("\t f) fixQp\n");

    while((c = getchar()) != '\n' && c != EOF)
    switch(c)
    {
        case 'c':
            enRcMode = SAMPLE_RC_CBR;
            break;
        case 'v':
            enRcMode = SAMPLE_RC_VBR;
            break;
        case 'a':
            enRcMode = SAMPLE_RC_AVBR;
        break;
        case 'f':
            enRcMode = SAMPLE_RC_FIXQP;
            break;
        default:
            SAMPLE_PRT("input rcmode: %c, is invaild!\n",c);
            goto Begin_Get;
    }
    return enRcMode;
}


HI_S32 SAMPLE_VENC_SYS_Init(HI_U32 u32SupplementConfig,SAMPLE_SNS_TYPE_E  enSnsType)
{
    HI_S32 s32Ret;
    HI_U64 u64BlkSize;
    VB_CONFIG_S stVbConf;
    PIC_SIZE_E enSnsSize;
    SIZE_S     stSnsSize;

    memset(&stVbConf, 0, sizeof(VB_CONFIG_S));

    SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor start!");
    s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
        return s32Ret;
    }

    SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize start!  %d" ,enSnsSize);
    s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
        return s32Ret;
    }

    u64BlkSize = COMMON_GetPicBufferSize(stSnsSize.u32Width, stSnsSize.u32Height, PIXEL_FORMAT_YVU_SEMIPLANAR_422, DATA_BITWIDTH_10, COMPRESS_MODE_NONE,DEFAULT_ALIGN);
    stVbConf.astCommPool[0].u64BlkSize   = u64BlkSize;
    stVbConf.astCommPool[0].u32BlkCnt    = 15;

    stVbConf.astCommPool[2].u64BlkSize   = u64BlkSize;
    stVbConf.astCommPool[2].u32BlkCnt    = 15;

    u64BlkSize = COMMON_GetPicBufferSize(1920, 1080, PIXEL_FORMAT_YVU_SEMIPLANAR_422, DATA_BITWIDTH_10, COMPRESS_MODE_NONE,DEFAULT_ALIGN);
    stVbConf.astCommPool[1].u64BlkSize   = u64BlkSize;
    stVbConf.astCommPool[1].u32BlkCnt    = 15;

    stVbConf.astCommPool[3].u64BlkSize   = u64BlkSize;
    stVbConf.astCommPool[3].u32BlkCnt    = 15;

    stVbConf.u32MaxPoolCnt = 4;

    if(0 == u32SupplementConfig)
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_Init start! ");
        s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
    }
    else
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_InitWithVbSupplement start! %d ",u32SupplementConfig);
        s32Ret = SAMPLE_COMM_SYS_InitWithVbSupplement(&stVbConf,u32SupplementConfig);
    }
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
        return s32Ret;
    }

    return HI_SUCCESS;
}

HI_VOID SAMPLE_VENC_SetDCFInfo(VI_PIPE ViPipe)
{
    ISP_DCF_INFO_S stIspDCF;

    HI_MPI_ISP_GetDCFInfo(ViPipe, &stIspDCF);

    //description: Thumbnail test
    strncpy((char *)stIspDCF.stIspDCFConstInfo.au8ImageDescription,"Thumbnail test",DCF_DRSCRIPTION_LENGTH);
    //manufacturer: Hisilicon
    strncpy((char *)stIspDCF.stIspDCFConstInfo.au8Make,"Hisilicon",DCF_DRSCRIPTION_LENGTH);
    //model number: Hisilicon IP Camera
    strncpy((char *)stIspDCF.stIspDCFConstInfo.au8Model,"Hisilicon IP Camera",DCF_DRSCRIPTION_LENGTH);
    //firmware version: v.1.1.0
    strncpy((char *)stIspDCF.stIspDCFConstInfo.au8Software,"v.1.1.0",DCF_DRSCRIPTION_LENGTH);


    stIspDCF.stIspDCFConstInfo.u32FocalLength             = 0x00640001;
    stIspDCF.stIspDCFConstInfo.u8Contrast                 = 5;
    stIspDCF.stIspDCFConstInfo.u8CustomRendered           = 0;
    stIspDCF.stIspDCFConstInfo.u8FocalLengthIn35mmFilm    = 1;
    stIspDCF.stIspDCFConstInfo.u8GainControl              = 1;
    stIspDCF.stIspDCFConstInfo.u8LightSource              = 1;
    stIspDCF.stIspDCFConstInfo.u8MeteringMode             = 1;
    stIspDCF.stIspDCFConstInfo.u8Saturation               = 1;
    stIspDCF.stIspDCFConstInfo.u8SceneCaptureType         = 1;
    stIspDCF.stIspDCFConstInfo.u8SceneType                = 0;
    stIspDCF.stIspDCFConstInfo.u8Sharpness                = 5;
    stIspDCF.stIspDCFUpdateInfo.u32ISOSpeedRatings         = 500;
    stIspDCF.stIspDCFUpdateInfo.u32ExposureBiasValue       = 5;
    stIspDCF.stIspDCFUpdateInfo.u32ExposureTime            = 0x00010004;
    stIspDCF.stIspDCFUpdateInfo.u32FNumber                 = 0x0001000f;
    stIspDCF.stIspDCFUpdateInfo.u8WhiteBalance             = 1;
    stIspDCF.stIspDCFUpdateInfo.u8ExposureMode             = 0;
    stIspDCF.stIspDCFUpdateInfo.u8ExposureProgram          = 1;
    stIspDCF.stIspDCFUpdateInfo.u32MaxApertureValue        = 0x00010001;

    HI_MPI_ISP_SetDCFInfo(ViPipe, &stIspDCF);

    return;
}

HI_S32 SAMPLE_VENC_VI_Init_two( SAMPLE_VI_CONFIG_S *pstViConfig, HI_BOOL bLowDelay, HI_U32 u32SupplementConfig)
{
    HI_S32              s32Ret;
    SAMPLE_SNS_TYPE_E   enSnsType;
    ISP_CTRL_PARAM_S    stIspCtrlParam;
    HI_U32              u32FrameRate;

    pstViConfig->s32WorkingViNum       = 2;  /* 当前工作通道为1 个 上边设置的有关硬件通道，下边进行软件通道说明*/
    pstViConfig->astViInfo[0].stDevInfo.ViDev     = 0; /* 软件采集通道-输入信息 ViDev */
    pstViConfig->astViInfo[0].stPipeInfo.aPipe[0] = 0;  /*  */
    pstViConfig->astViInfo[0].stChnInfo.ViChn     = 0;
    pstViConfig->astViInfo[0].stChnInfo.enDynamicRange = DYNAMIC_RANGE_SDR8;
    pstViConfig->astViInfo[0].stChnInfo.enPixFormat    = PIXEL_FORMAT_YVU_SEMIPLANAR_420;

    pstViConfig->astViInfo[1].stDevInfo.ViDev     = 2; /* 软件采集通道-输入信息 ViDev */
    pstViConfig->astViInfo[1].stPipeInfo.aPipe[0] = 1;  /*  */
    pstViConfig->astViInfo[1].stChnInfo.ViChn     = 1;
    pstViConfig->astViInfo[1].stChnInfo.enDynamicRange = DYNAMIC_RANGE_SDR8;
    pstViConfig->astViInfo[1].stChnInfo.enPixFormat    = PIXEL_FORMAT_YVU_SEMIPLANAR_420;

    SAMPLE_PRT("enSnsType :%d!",enSnsType);
    enSnsType = pstViConfig->astViInfo[0].stSnsInfo.enSnsType;  /* 8路的值都已经赋值进去了 */

    pstViConfig->as32WorkingViId[0]                         = 0;
    pstViConfig->astViInfo[0].stSnsInfo.MipiDev            = 0;
    pstViConfig->astViInfo[0].stSnsInfo.s32BusId           = 1;  /**重新设置了IIC总线 ？？？ */
    pstViConfig->astViInfo[0].stDevInfo.enWDRMode          = WDR_MODE_NONE;
    pstViConfig->astViInfo[0].stPipeInfo.enMastPipeMode     = VI_OFFLINE_VPSS_OFFLINE;

    pstViConfig->astViInfo[0].stPipeInfo.aPipe[0]          = 0;
    pstViConfig->astViInfo[0].stPipeInfo.aPipe[1]          = -1;
    pstViConfig->astViInfo[0].stPipeInfo.aPipe[2]          = -1;
    pstViConfig->astViInfo[0].stPipeInfo.aPipe[3]          = -1;

    pstViConfig->astViInfo[0].stChnInfo.ViChn              = 0;
    pstViConfig->astViInfo[0].stChnInfo.enPixFormat        = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
    pstViConfig->astViInfo[0].stChnInfo.enDynamicRange     = DYNAMIC_RANGE_SDR8;
    pstViConfig->astViInfo[0].stChnInfo.enVideoFormat      = VIDEO_FORMAT_LINEAR;
    pstViConfig->astViInfo[0].stChnInfo.enCompressMode     = COMPRESS_MODE_SEG;//COMPRESS_MODE_SEG; 段压缩视频格式 每256b进行压缩


    pstViConfig->as32WorkingViId[1]                         = 1;
    pstViConfig->astViInfo[1].stSnsInfo.MipiDev            = 2;
    pstViConfig->astViInfo[1].stSnsInfo.s32BusId           = 0;  /**重新设置了IIC总线 ？？？ */
    pstViConfig->astViInfo[1].stDevInfo.enWDRMode          = WDR_MODE_NONE;
    pstViConfig->astViInfo[1].stPipeInfo.enMastPipeMode     = VI_OFFLINE_VPSS_OFFLINE;

    pstViConfig->astViInfo[1].stPipeInfo.aPipe[0]          = 1;
    pstViConfig->astViInfo[1].stPipeInfo.aPipe[1]          = -1;
    pstViConfig->astViInfo[1].stPipeInfo.aPipe[2]          = -1;
    pstViConfig->astViInfo[1].stPipeInfo.aPipe[3]          = -1;

    pstViConfig->astViInfo[1].stChnInfo.ViChn              = 0;
    pstViConfig->astViInfo[1].stChnInfo.enPixFormat        = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
    pstViConfig->astViInfo[1].stChnInfo.enDynamicRange     = DYNAMIC_RANGE_SDR8;
    pstViConfig->astViInfo[1].stChnInfo.enVideoFormat      = VIDEO_FORMAT_LINEAR;
    pstViConfig->astViInfo[1].stChnInfo.enCompressMode     = COMPRESS_MODE_SEG;//COMPRESS_MODE_SEG; 段压缩视频格式 每256b进行压缩
  
    s32Ret = SAMPLE_VENC_SYS_Init(u32SupplementConfig,enSnsType); //主要是针对缓存池进行了初始化 --初始化了4个
    if(s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("Init SYS err for %#x!\n", s32Ret);
        return s32Ret;
    }

   
    SAMPLE_COMM_VI_GetFrameRateBySensor(enSnsType, &u32FrameRate); /** 获取速率 */

    SAMPLE_PRT("HI_MPI_ISP_GetCtrlParam start!");
    s32Ret = HI_MPI_ISP_GetCtrlParam(pstViConfig->astViInfo[0].stPipeInfo.aPipe[0], &stIspCtrlParam); /* 一般情况下 aPipe[0]  VI_PIPE ViPipe ，驱动靠这个是设置的IIC 看是否变更此项内容*/
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("HI_MPI_ISP_GetCtrlParam failed with %d!\n", s32Ret);
        return s32Ret;
    }
    stIspCtrlParam.u32StatIntvl  = u32FrameRate/30; 

    SAMPLE_PRT("HI_MPI_ISP_SetCtrlParam start!");
    s32Ret = HI_MPI_ISP_SetCtrlParam(pstViConfig->astViInfo[0].stPipeInfo.aPipe[0], &stIspCtrlParam); //设置ISP参数
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("HI_MPI_ISP_SetCtrlParam failed with %d!\n", s32Ret);
        return s32Ret;
    }
    
    ///
    //设置第二路信息
    s32Ret = HI_MPI_ISP_GetCtrlParam(pstViConfig->astViInfo[1].stPipeInfo.aPipe[0], &stIspCtrlParam);
    stIspCtrlParam.u32StatIntvl  = u32FrameRate/30; 
    s32Ret = HI_MPI_ISP_SetCtrlParam(pstViConfig->astViInfo[1].stPipeInfo.aPipe[0], &stIspCtrlParam); //设置ISP参数


    /
    SAMPLE_PRT("SAMPLE_COMM_VI_StartVi start!");
    s32Ret = SAMPLE_COMM_VI_StartVi(pstViConfig); //开启VI功能
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_COMM_SYS_Exit();
        SAMPLE_PRT("SAMPLE_COMM_VI_StartVi failed with %d!\n", s32Ret);
        return s32Ret;
    }

    return HI_SUCCESS;
}

HI_S32 SAMPLE_VENC_VPSS_Init(VPSS_GRP VpssGrp, HI_BOOL* pabChnEnable, DYNAMIC_RANGE_E enDynamicRange,PIXEL_FORMAT_E enPixelFormat,SIZE_S stSize[],SAMPLE_SNS_TYPE_E enSnsType)
{
    HI_S32 i;
    HI_S32 s32Ret;
    PIC_SIZE_E      enSnsSize;
    SIZE_S          stSnsSize;
    VPSS_GRP_ATTR_S stVpssGrpAttr;
    VPSS_CHN_ATTR_S stVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];

    s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
        return s32Ret;
    }

    s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
        return s32Ret;
    }


    stVpssGrpAttr.enDynamicRange = enDynamicRange;
    stVpssGrpAttr.enPixelFormat  = enPixelFormat;
    stVpssGrpAttr.u32MaxW        = stSnsSize.u32Width;
    stVpssGrpAttr.u32MaxH        = stSnsSize.u32Height;
    stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
    stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;


    for(i=0; i<VPSS_MAX_PHY_CHN_NUM; i++)
    {
        if(HI_TRUE == pabChnEnable[i])
        {
            stVpssChnAttr[i].u32Width                     = stSize[i].u32Width;
            stVpssChnAttr[i].u32Height                    = stSize[i].u32Height;
            stVpssChnAttr[i].enChnMode                    = VPSS_CHN_MODE_USER;
            stVpssChnAttr[i].enCompressMode               = COMPRESS_MODE_NONE;//COMPRESS_MODE_SEG;
            stVpssChnAttr[i].enDynamicRange               = enDynamicRange;
            stVpssChnAttr[i].enPixelFormat                = enPixelFormat;
            stVpssChnAttr[i].stFrameRate.s32SrcFrameRate  = -1;
            stVpssChnAttr[i].stFrameRate.s32DstFrameRate  = -1;
            stVpssChnAttr[i].u32Depth                     = 0;
            stVpssChnAttr[i].bMirror                      = HI_FALSE;
            stVpssChnAttr[i].bFlip                        = HI_FALSE;
            stVpssChnAttr[i].enVideoFormat                = VIDEO_FORMAT_LINEAR;
            stVpssChnAttr[i].stAspectRatio.enMode         = ASPECT_RATIO_NONE;
        }
    }

    s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, pabChnEnable,&stVpssGrpAttr,stVpssChnAttr);
    if(s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("start VPSS fail for %#x!\n", s32Ret);
    }

    return s32Ret;
}


HI_S32 SAMPLE_VENC_CheckSensor(SAMPLE_SNS_TYPE_E   enSnsType,SIZE_S  stSize)
{
    HI_S32 s32Ret;
    SIZE_S          stSnsSize;
    PIC_SIZE_E      enSnsSize;

    s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
        return s32Ret;
    }
    s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
        return s32Ret;
    }

    if((stSnsSize.u32Width < stSize.u32Width) || (stSnsSize.u32Height < stSize.u32Height))
    {
        SAMPLE_PRT("Sensor size is (%d,%d), but encode chnl is (%d,%d) !\n",
            stSnsSize.u32Width,stSnsSize.u32Height,stSize.u32Width,stSize.u32Height);
        return HI_FAILURE;
    }

    return HI_SUCCESS;
}


/******************************************************************************
* function :  H.265e@4K@120fps + H264e@1080p@30fps
******************************************************************************/
HI_S32 SAMPLE_VENC_4K120(void)
{
    HI_S32 i;
    HI_S32 s32Ret;
    SIZE_S          stSize[4];
    PIC_SIZE_E      enSize[4]     = {PIC_3840x2160, PIC_1080P ,PIC_3840x2160, PIC_1080P};
    HI_S32          s32ChnNum     = 4;
    VENC_CHN        VencChn[4]    = {0,1,2,3};
    HI_U32          u32Profile[4] = {0,1,0,1}; //编码等级
    PAYLOAD_TYPE_E  enPayLoad[4]  = {PT_H265, PT_H264,PT_H265, PT_H264};
    VENC_GOP_MODE_E enGopMode;
    VENC_GOP_ATTR_S stGopAttr;
    SAMPLE_RC_E     enRcMode;

    VI_DEV          ViDev        = 2;
    VI_PIPE         ViPipe       = 0;
    VI_CHN          ViChn        = 0;
    SAMPLE_VI_CONFIG_S stViConfig;

    VPSS_GRP        VpssGrp        = 0;
    VPSS_CHN        VpssChn[2]     = {0,1};
    HI_BOOL         abChnEnable[4] = {1,1,0,0};

    HI_U32 u32SupplementConfig = HI_FALSE;

    // zy根据名称设置对应尺寸大小 
    for(i=0; i<s32ChnNum; i++)
    {
        s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSize[i], &stSize[i]);
        if (HI_SUCCESS != s32Ret)
        {
            SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
            return s32Ret;
        }
    }

    SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
    SAMPLE_PRT("SAMPLE_COMM_VI_GetSensorInfo  is ok\n");
    if(SAMPLE_SNS_TYPE_BUTT == stViConfig.astViInfo[0].stSnsInfo.enSnsType)
    {
        SAMPLE_PRT("Not set SENSOR%d_TYPE !\n",0);
        return HI_FAILURE;
    }

    s32Ret = SAMPLE_VENC_CheckSensor(stViConfig.astViInfo[0].stSnsInfo.enSnsType,stSize[0]);
    if(s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("Check Sensor err!\n");
        return HI_FAILURE;
    }
    SAMPLE_PRT("SAMPLE_VENC_CheckSensor  is ok\n");

///进行输入///

    stViConfig.s32WorkingViNum       = 2;  /* 当前工作通道为1 个 上边设置的有关硬件通道，下边进行软件通道说明*/
    stViConfig.astViInfo[0].stDevInfo.ViDev     = 0; /* 软件采集通道-输入信息 ViDev */
    stViConfig.astViInfo[0].stPipeInfo.aPipe[0] = 0;  /*  */
    stViConfig.astViInfo[0].stChnInfo.ViChn     = 0;
    stViConfig.astViInfo[0].stChnInfo.enDynamicRange = DYNAMIC_RANGE_SDR8;
    stViConfig.astViInfo[0].stChnInfo.enPixFormat    = PIXEL_FORMAT_YVU_SEMIPLANAR_420;

    stViConfig.astViInfo[1].stDevInfo.ViDev     = 2; /* 软件采集通道-输入信息 ViDev */
    stViConfig.astViInfo[1].stPipeInfo.aPipe[0] = 1;  /*  */
    stViConfig.astViInfo[1].stChnInfo.ViChn     = 1;
    stViConfig.astViInfo[1].stChnInfo.enDynamicRange = DYNAMIC_RANGE_SDR8;
    stViConfig.astViInfo[1].stChnInfo.enPixFormat    = PIXEL_FORMAT_YVU_SEMIPLANAR_420;

    SAMPLE_PRT("SAMPLE_VENC_VI_Init  -- 直接进行双路配置 start\n");
    s32Ret = SAMPLE_VENC_VI_Init_two(&stViConfig, HI_FALSE,u32SupplementConfig);
    if(s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("Init VI err for %#x!\n", s32Ret);
        return HI_FAILURE;
    }
    SAMPLE_PRT("SAMPLE_VENC_VPSS_Init  start\n");

    s32Ret = SAMPLE_VENC_VPSS_Init(VpssGrp,abChnEnable,DYNAMIC_RANGE_SDR8,PIXEL_FORMAT_YVU_SEMIPLANAR_420,stSize,stViConfig.astViInfo[0].stSnsInfo.enSnsType);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Init VPSS err for %#x!\n", s32Ret);
        goto EXIT_VI_STOP;
    }
    SAMPLE_PRT("SAMPLE_COMM_VI_Bind_VPSS  start\n");
    s32Ret = SAMPLE_COMM_VI_Bind_VPSS(0, 0, VpssGrp); // SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
    if(s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("VI Bind VPSS err for %#x!\n", s32Ret);
        goto EXIT_VPSS_STOP;
    }
    // // 开启两路VPSS///
    s32Ret = SAMPLE_VENC_VPSS_Init(1,abChnEnable,DYNAMIC_RANGE_SDR8,PIXEL_FORMAT_YVU_SEMIPLANAR_420,stSize,stViConfig.astViInfo[1].stSnsInfo.enSnsType);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Init VPSS err for %#x!\n", s32Ret);
        goto EXIT_VI_STOP;
    }
    SAMPLE_PRT("SAMPLE_COMM_VI_Bind_VPSS  start\n");
    s32Ret = SAMPLE_COMM_VI_Bind_VPSS(1, 0, 1); //s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
    if(s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("VI Bind VPSS err for %#x!\n", s32Ret);
        goto EXIT_VPSS_STOP;
    }    

    /** 上述设置两路不同的vpss 绑定不同a pipi通道  */
   /******************************************
    start stream venc
    ******************************************/

    // enRcMode = SAMPLE_VENC_GetRcMode();
    // enGopMode = SAMPLE_VENC_GetGopMode();
    enRcMode =  SAMPLE_RC_CBR ;
    enGopMode = VENC_GOPMODE_NORMALP;

    s32Ret = SAMPLE_COMM_VENC_GetGopAttr(enGopMode,&stGopAttr); //根据VENC_GOPMODE_NORMALP 设置压缩比
    if (HI_SUCCESS != s32Ret)
    { 
        SAMPLE_PRT("Venc Get GopAttr for %#x!\n", s32Ret);
        goto EXIT_VI_VPSS_UNBIND;
    }

   /***encode h.265 设置venc的值 **/
    s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enPayLoad[0],enSize[0], enRcMode,u32Profile[0],&stGopAttr); //enPayLoad[0] 数据格式
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Venc Start failed for %#x!\n", s32Ret);
        goto EXIT_VI_VPSS_UNBIND;
    }

    s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn[0],VencChn[0]);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Venc Get GopAttr failed for %#x!\n", s32Ret);
        goto EXIT_VENC_H265_STOP;
    }

    /***encode h.264 **/
    s32Ret = SAMPLE_COMM_VENC_Start(VencChn[1], enPayLoad[1], enSize[1], enRcMode,u32Profile[1],&stGopAttr);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Venc Start failed for %#x!\n", s32Ret);
        goto EXIT_VENC_H265_UnBind;
    }

    s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn[1],VencChn[1]);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Venc bind Vpss failed for %#x!\n", s32Ret);
        goto EXIT_VENC_H264_STOP;
    }


    // 开启两路编码器 zy new
    s32Ret = SAMPLE_COMM_VENC_Start(2, enPayLoad[0],enSize[0], enRcMode,u32Profile[0],&stGopAttr);
    s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(1, VpssChn[0],2);
    s32Ret = SAMPLE_COMM_VENC_Start(3, enPayLoad[1], enSize[1], enRcMode,u32Profile[1],&stGopAttr);
    s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(1, VpssChn[1],3);
    /******************************************
     stream save process
    ******************************************/
    s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn,s32ChnNum);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("Start Venc failed!\n");
        goto EXIT_VENC_H264_UnBind;
    }

    printf("please press twice ENTER to exit this sample\n");
    getchar();
    getchar();

    /******************************************
     exit process
    ******************************************/
    SAMPLE_COMM_VENC_StopGetStream();

EXIT_VENC_H264_UnBind:
    SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp,VpssChn[1],VencChn[1]);
    SAMPLE_COMM_VPSS_UnBind_VENC(1,VpssChn[1],VencChn[3]);
EXIT_VENC_H264_STOP:
    SAMPLE_COMM_VENC_Stop(VencChn[1]);
    SAMPLE_COMM_VENC_Stop(VencChn[3]);
EXIT_VENC_H265_UnBind:
    SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp,VpssChn[0],VencChn[0]);
    SAMPLE_COMM_VPSS_UnBind_VENC(1,VpssChn[0],VencChn[2]);
EXIT_VENC_H265_STOP:
    SAMPLE_COMM_VENC_Stop(VencChn[0]);
    SAMPLE_COMM_VENC_Stop(VencChn[2]);
EXIT_VI_VPSS_UNBIND:
    SAMPLE_COMM_VI_UnBind_VPSS(ViPipe,ViChn,VpssGrp);
    SAMPLE_COMM_VI_UnBind_VPSS(1, 1, 1);
EXIT_VPSS_STOP:
    SAMPLE_COMM_VPSS_Stop(VpssGrp,abChnEnable);
    SAMPLE_COMM_VPSS_Stop(1,abChnEnable);
EXIT_VI_STOP:
    SAMPLE_COMM_VI_StopVi(&stViConfig);
    SAMPLE_COMM_SYS_Exit();

    return s32Ret;
}

/******************************************************************************
* function    : main()
* Description : video venc sample
******************************************************************************/
#ifdef __HuaweiLite__
    int app_main(int argc, char *argv[])
#else
    int main(int argc, char *argv[])
#endif
{
    HI_S32 s32Ret;
    HI_U32 u32Index;

    // if (argc < 2)
    // {
    //     SAMPLE_VENC_Usage(argv[0]);
    //     return HI_FAILURE;
    // }
//     u32Index = atoi(argv[1]);

#ifndef __HuaweiLite__
    signal(SIGINT, SAMPLE_VENC_HandleSig);
    signal(SIGTERM, SAMPLE_VENC_HandleSig);
#endif
    s32Ret = SAMPLE_VENC_4K120();
    return s32Ret;
}

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */