全志视频输入组件的使用

1.启动MPP和Glog库

示例代码：

log_init(argv[0], &stGLogConfig);

MPP_SYS_CONF_S stSysConf;
memset(&stSysConf, 0, sizeof(MPP_SYS_CONF_S));
stSysConf.nAlignWidth = 32;
AW_MPI_SYS_SetConf(&stSysConf);
ret = AW_MPI_SYS_Init();

2.获取配置文件信息

parseCmdLine(pContext, argc, argv)

3.初始化ISP

AW_MPI_SYS_Init();

4.创建VI组件

4.1 配置VI组件信息

pContext->mViAttr.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
pContext->mViAttr.memtype = V4L2_MEMORY_MMAP;
pContext->mViAttr.format.pixelformat = map_PIXEL_FORMAT_E_to_V4L2_PIX_FMT(pContext->mConfigPara.mPicFormat);
pContext->mViAttr.format.field = V4L2_FIELD_NONE;
pContext->mViAttr.format.width = pContext->mConfigPara.mPicWidth;
pContext->mViAttr.format.height = pContext->mConfigPara.mPicHeight;
pContext->mViAttr.nbufs = 3;//5;
pContext->mViAttr.nplanes = 2;
pContext->mViAttr.fps = pContext->mConfigPara.mFrameRate;
pContext->mViAttr.use_current_win = 0;
pContext->mFirstVippRunFlag = true;
pContext->mViAttr.wdr_mode = 0;
pContext->mViAttr.capturemode = V4L2_MODE_VIDEO;
pContext->mViAttr.drop_frame_num = 0;

pContext->mViAttr.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

设置缓冲区类型为视频捕获多平面模式（V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE）。多平面模式通常用于支持多个数据平面的设备，可能是在捕获时同时传输多个图像平面（例如，YUV格式的不同平面）。

pContext->mViAttr.memtype = V4L2_MEMORY_MMAP;

设置缓冲区内存类型为V4L2_MEMORY_MMAP，即通过内存映射来管理缓冲区。这是与内存映射I/O接口结合使用的方式，用于通过映射内存区域访问数据。

pContext->mViAttr.format.pixelformat = map_PIXEL_FORMAT_E_to_V4L2_PIX_FMT(pContext->mConfigPara.mPicFormat);

设置捕获图像的像素格式。map_PIXEL_FORMAT_E_to_V4L2_PIX_FMT是一个函数，它将应用程序中的图像格式（如YUV420等）映射到V4L2标准格式（如V4L2_PIX_FMT_YUYV、V4L2_PIX_FMT_NV12等）。

pContext->mViAttr.format.field = V4L2_FIELD_NONE;

设置捕获的字段类型为V4L2_FIELD_NONE，表示图像不使用交错的场。交错场模式通常用于电视信号和视频播放中，V4L2_FIELD_NONE意味着逐行扫描模式。

pContext->mViAttr.format.width = pContext->mConfigPara.mPicWidth;

设置捕获图像的宽度，来源于配置参数中的mPicWidth。

pContext->mViAttr.format.height = pContext->mConfigPara.mPicHeight;

设置捕获图像的高度，来源于配置参数中的mPicHeight。

pContext->mViAttr.nbufs = 3;

设置视频捕获的缓冲区数量为3。nbufs通常是视频缓冲区的数量，设置合适的缓冲区数量对于流畅的捕获和处理非常重要。

pContext->mViAttr.nplanes = 2;

设置每个视频缓冲区的平面数为2，通常在YUV格式下，图像会被分成多个平面（例如，一个Y平面和一个UV平面）。nplanes表示每个缓冲区中的平面数。

pContext->mViAttr.fps = pContext->mConfigPara.mFrameRate;

设置视频捕获的帧率，来源于配置参数中的mFrameRate。

pContext->mViAttr.use_current_win = 0;

设置是否使用当前窗口。通常这是与视频捕获窗口的配置相关，0表示不使用当前窗口。

pContext->mFirstVippRunFlag = true;

设置一个标志，表示这是第一次启动视频捕获过程，可能用于初始化相关资源。

pContext->mViAttr.wdr_mode = 0;

设置宽动态范围（WDR）模式为0，表示没有启用WDR功能。WDR用于在具有较大亮度范围的场景中提高图像质量。

pContext->mViAttr.capturemode = V4L2_MODE_VIDEO;

设置捕获模式为V4L2_MODE_VIDEO，表示采用标准的视频捕获模式。

pContext->mViAttr.drop_frame_num = 0;

设置丢帧数为0，表示不丢弃任何帧。

4.2 创建VIPP

AW_MPI_VI_CreateVipp(nVippIndex);

4.3 设置VIPP属性

AW_MPI_VI_SetVippAttr(nVippIndex, &pContext->mViAttr);

4.4 启动VIPP

AW_MPI_VI_EnableVipp(nVippIndex);

4.5 配置虚通道信息

VirViChnInfo *pChnInfo = &pContext->mVirViChnArray[nVippIndex][virvi_chn];
memset(pChnInfo, 0, sizeof(VirViChnInfo));
pChnInfo->mVipp = nVippIndex;
pChnInfo->mVirChn = virvi_chn;
pChnInfo->mMilliSec = 5000;  // 2000;
pChnInfo->mCaptureFrameCount = pContext->mConfigPara.mFrameCountStep1;

4.6 创建虚通道

AW_MPI_VI_CreateVirChn(ViDev, ViCh, pAttr);

4.7 设置虚通道属性

AW_MPI_VI_SetVirChnAttr(ViDev, ViCh, pAttr);

4.8 启动虚通道

AW_MPI_VI_EnableVirChn(ViDev, ViCh);

5.获取图像帧

5.1 获取图像数据

AW_MPI_VI_GetFrame(ViDev, ViCh, &pCap->mFrameInfo, pCap->mMilliSec))

5.2 释放图像帧

AW_MPI_VI_ReleaseFrame(ViDev, ViCh, &pCap->mFrameInfo);

6.停止并销毁VI组件

6.1 关闭虚通道

AW_MPI_VI_DisableVirChn(ViDev, ViCh);

6.2 关闭VIPP

AW_MPI_VI_DisableVipp(nVippIndex);

6.3 销毁VIPP

AW_MPI_VI_DestroyVipp(nVippIndex);

6.4 停止ISP

AW_MPI_ISP_Stop();

7.退出MPP

AW_MPI_SYS_Exit();

8.完整源码

cpp 复制代码

#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <pthread.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <utils/plat_log.h>
#include "media/mpi_sys.h"
#include "media/mm_comm_vi.h"
#include "media/mpi_vi.h"
#include "media/mpi_isp.h"
#include <mpi_videoformat_conversion.h>

#include <confparser.h>
#include "sample_vi_reset.h"
#include "sample_vi_reset_config.h"

#define TEST_FLIP (0)
int hal_virvi_start(VI_DEV ViDev, VI_CHN ViCh, void *pAttr)
{
    ERRORTYPE ret = -1;

    ret = AW_MPI_VI_CreateVirChn(ViDev, ViCh, pAttr);
    if(ret < 0)
    {
        aloge("Create VI Chn failed,VIDev = %d,VIChn = %d",ViDev,ViCh);
        return ret ;
    }
    ret = AW_MPI_VI_SetVirChnAttr(ViDev, ViCh, pAttr);
    if(ret < 0)
    {
        aloge("Set VI ChnAttr failed,VIDev = %d,VIChn = %d",ViDev,ViCh);
        return ret ;
    }
    ret = AW_MPI_VI_EnableVirChn(ViDev, ViCh);
    if(ret < 0)
    {
        aloge("VI Enable VirChn failed,VIDev = %d,VIChn = %d",ViDev,ViCh);
        return ret ;
    }

    return 0;
}

int hal_virvi_end(VI_DEV ViDev, VI_CHN ViCh)
{
    int ret = -1;
    ret = AW_MPI_VI_DisableVirChn(ViDev, ViCh);
    if(ret < 0)
    {
        aloge("Disable VI Chn failed,VIDev = %d,VIChn = %d",ViDev,ViCh);
        return ret ;
    }
    ret = AW_MPI_VI_DisableVirChn(ViDev, ViCh);
    if(ret < 0)
    {
        aloge("Destory VI Chn failed,VIDev = %d,VIChn = %d",ViDev,ViCh);
        return ret ;
    }
    return 0;
}

static int parseCmdLine(SampleViResetContext *pContext, int argc, char** argv)
{
    int ret = -1;

    alogd("argc=%d", argc);

    if (argc != 3)
    {
        printf("CmdLine param:\n"
                "\t-path ./sample_CodecParallel.conf\n");
        return -1;
    }

    while (*argv)
    {
       if (!strcmp(*argv, "-path"))
       {
          argv++;
          if (*argv)
          {
                ret = 0;
                if (strlen(*argv) >= MAX_FILE_PATH_SIZE)
                {
                    aloge("fatal error! file path[%s] too long:!", *argv);
                }

                if (pContext)
                {
                    strncpy(pContext->mCmdLinePara.mConfigFilePath, *argv, MAX_FILE_PATH_SIZE-1);
                    pContext->mCmdLinePara.mConfigFilePath[MAX_FILE_PATH_SIZE-1] = '\0';
                }
          }
       }
       else if(!strcmp(*argv, "-h"))
       {
            printf("CmdLine param:\n"
                "\t-path ./sample_CodecParallel.conf\n");
            break;
       }
       else if (*argv)
       {
          argv++;
       }
    }

    return ret;
}

static ERRORTYPE LoadSampleViResetConfig(SampleViResetConfig *pConfig, const char *conf_path)
{
    if (NULL == pConfig)
    {
        aloge("pConfig is NULL!");
        return FAILURE;
    }

    if (NULL == conf_path)
    {
        aloge("user not set config file!");
        return FAILURE;
    }

    pConfig->mTestCount = 0;
    pConfig->mFrameCountStep1 = 300;
    pConfig->mbRunIsp = true;
    pConfig->mIspDev = 0;
    pConfig->mVippStart = 0;
    pConfig->mVippEnd = 0;
    pConfig->mPicWidth = 1920;
    pConfig->mPicHeight = 1080;
    pConfig->mSubPicWidth = 640;
    pConfig->mSubPicHeight = 360;
    pConfig->mFrameRate = 20;
    pConfig->mPicFormat = MM_PIXEL_FORMAT_YVU_SEMIPLANAR_420;

    CONFPARSER_S stConfParser;
    if(0 > createConfParser(conf_path, &stConfParser))
    {
        aloge("load conf fail!");
        return FAILURE;
    }
    pConfig->mTestCount = GetConfParaInt(&stConfParser, SAMPLE_VI_RESET_TEST_COUNT, 0);
    alogd("mTestCount=%d", pConfig->mTestCount);

    pConfig->mVippStart = GetConfParaInt(&stConfParser, SAMPLE_VI_RESET_VIPP_ID_START, 0);
    pConfig->mVippEnd = GetConfParaInt(&stConfParser, SAMPLE_VI_RESET_VIPP_ID_END, 0);

    alogd("vi config: vipp scope=[%d,%d], captureSize:[%dx%d,%dx%d] frameRate:%d, pixelFormat:0x%x",
       pConfig->mVippStart, pConfig->mVippEnd, pConfig->mPicWidth, pConfig->mPicHeight, 
       pConfig->mSubPicWidth, pConfig->mSubPicHeight, pConfig->mFrameRate, pConfig->mPicFormat);

    destroyConfParser(&stConfParser);

    return SUCCESS;
}

static void *GetCSIFrameThread(void *pArg)
{
    VI_DEV ViDev;
    VI_CHN ViCh;
    int ret = 0;
    int i = 0, j = 0;

    VirViChnInfo *pCap = (VirViChnInfo*)pArg;
    ViDev = pCap->mVipp;
    ViCh = pCap->mVirChn;
    alogd("Cap threadid=0x%lx, ViDev = %d, ViCh = %d", pCap->mThid, ViDev, ViCh);
    int nFlipValue = 0;
    int nFlipTestCnt = 0;
    while (pCap->mCaptureFrameCount > j)
    {
        if ((ret = AW_MPI_VI_GetFrame(ViDev, ViCh, &pCap->mFrameInfo, pCap->mMilliSec)) != 0)
        {
            alogw("Vipp[%d,%d] Get Frame failed!", ViDev, ViCh);
            continue;
        }
        i++;
        if (i % 20 == 0)
        {
            time_t now;
            struct tm *timenow;
            time(&now);
            timenow = localtime(&now);
            alogd("Cap threadid=0x%lx, ViDev=%d, VirVi=%d, mpts=%lld; local time is %s", pCap->mThid, ViDev, ViCh, pCap->mFrameInfo.VFrame.mpts, asctime(timenow));
#if 0
            FILE *fd;
            char filename[128];
            sprintf(filename, "/tmp/%dx%d_%d.yuv",
                pCap->pstFrameInfo.VFrame.mWidth,
                pCap->pstFrameInfo.VFrame.mHeight,
                i);
            fd = fopen(filename, "wb+");
            fwrite(pCap->pstFrameInfo.VFrame.mpVirAddr[0],
                    pCap->pstFrameInfo.VFrame.mWidth * pCap->pstFrameInfo.VFrame.mHeight,
                    1, fd);
            fwrite(pCap->pstFrameInfo.VFrame.mpVirAddr[1],
                    pCap->pstFrameInfo.VFrame.mWidth * pCap->pstFrameInfo.VFrame.mHeight >> 1,
                    1, fd);
            fclose(fd);
#endif
        }
        AW_MPI_VI_ReleaseFrame(ViDev, ViCh, &pCap->mFrameInfo);
        j++;
#if TEST_FLIP
        if(j == pCap->mCaptureFrameCount)
        {
            j = 0;
            if(0 == ViDev)
            {
                nFlipValue = !nFlipValue;
                nFlipTestCnt++;
                AW_MPI_VI_SetVippMirror(ViDev, nFlipValue);
                AW_MPI_VI_SetVippFlip(ViDev, nFlipValue);
                alogd("vipp[%d] mirror and flip:%d, test count:%d begin.", ViDev, nFlipValue, nFlipTestCnt);
            }
        }
#endif
    }
    return NULL;
}
int RunOneVipp(VI_DEV nVippIndex, SampleViResetContext *pContext)
{
    ERRORTYPE ret = SUCCESS;
    /*Set VI Channel Attribute*/
    memset(&pContext->mViAttr, 0, sizeof(VI_ATTR_S));
    pContext->mViAttr.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    pContext->mViAttr.memtype = V4L2_MEMORY_MMAP;
    pContext->mViAttr.format.pixelformat = map_PIXEL_FORMAT_E_to_V4L2_PIX_FMT(pContext->mConfigPara.mPicFormat);
    pContext->mViAttr.format.field = V4L2_FIELD_NONE;
    alogd("nVippIndex=%d", nVippIndex);
    if(0 == nVippIndex)
    {
        pContext->mViAttr.format.width = pContext->mConfigPara.mPicWidth;
        pContext->mViAttr.format.height = pContext->mConfigPara.mPicHeight;
    }
    else
    {
        pContext->mViAttr.format.width = pContext->mConfigPara.mSubPicWidth;
        pContext->mViAttr.format.height = pContext->mConfigPara.mSubPicHeight;
    }
    pContext->mViAttr.nbufs = 3;//5; 
    pContext->mViAttr.nplanes = 2;
    pContext->mViAttr.fps = pContext->mConfigPara.mFrameRate;
    /* update configuration anyway, do not use current configuration */
    if(false == pContext->mFirstVippRunFlag)
    {
        pContext->mViAttr.use_current_win = 0; //更新视频输入属性
        pContext->mFirstVippRunFlag = true;
    }
    else
    {
        pContext->mViAttr.use_current_win = 1;
    }
    pContext->mViAttr.wdr_mode = 0;
    pContext->mViAttr.capturemode = V4L2_MODE_VIDEO;
    pContext->mViAttr.drop_frame_num = 0;
    ret = AW_MPI_VI_CreateVipp(nVippIndex);
    if(ret != SUCCESS)
    {
        aloge("fatal error! create vipp[%d] fail[0x%x]", nVippIndex, ret);
    }
    ret = AW_MPI_VI_SetVippAttr(nVippIndex, &pContext->mViAttr);
    if(ret != SUCCESS)
    {
        aloge("fatal error! set vipp attr[%d] fail[0x%x]", nVippIndex, ret);
    }
    if(pContext->mConfigPara.mbRunIsp && false == pContext->mbIspRunningFlag)
    {
        ret = AW_MPI_ISP_Run(pContext->mConfigPara.mIspDev);
        if(ret != SUCCESS)
        {
            aloge("fatal error! isp[%d] run fail[0x%x]", pContext->mConfigPara.mIspDev, ret);
        }
        pContext->mbIspRunningFlag = true;
    }
    ret = AW_MPI_VI_EnableVipp(nVippIndex);
    if(ret != SUCCESS)
    {
        aloge("fatal error! enable vipp[%d] fail[0x%x]", nVippIndex, ret);
    }
    VI_CHN virvi_chn = 0;
    for (virvi_chn = 0; virvi_chn < 1 /*MAX_VIR_CHN_NUM*/; virvi_chn++)
    {
        VirViChnInfo *pChnInfo = &pContext->mVirViChnArray[nVippIndex][virvi_chn];
        memset(pChnInfo, 0, sizeof(VirViChnInfo));
        pChnInfo->mVipp = nVippIndex;
        pChnInfo->mVirChn = virvi_chn;
        pChnInfo->mMilliSec = 5000;  // 2000; 等待时间为5000毫秒（5秒）
        pChnInfo->mCaptureFrameCount = pContext->mConfigPara.mFrameCountStep1;//指定捕获帧的计数
        ret = hal_virvi_start(nVippIndex, virvi_chn, NULL);//启动虚通道
        if(ret != 0)
        {
            aloge("virvi start failed!");
        }
        pChnInfo->mThid = 0;
        ret = pthread_create(&pChnInfo->mThid, NULL, GetCSIFrameThread, (void *)pChnInfo);
        if(0 == ret)
        {
            alogd("pthread create success, vipp[%d], virChn[%d]", pChnInfo->mVipp, pChnInfo->mVirChn);
        }
        else
        {
            aloge("fatal error! pthread_create failed, vipp[%d], virChn[%d]", pChnInfo->mVipp, pChnInfo->mVirChn);
        }
    }
    return ret;
}

int DestroyOneVipp(VI_DEV nVippIndex, SampleViResetContext *pContext)
{
    int ret = 0;
    VI_CHN virvi_chn = 0;
    for (virvi_chn = 0; virvi_chn < 1; virvi_chn++)
    {
        ret = hal_virvi_end(nVippIndex, virvi_chn);
        if(ret != 0)
        {
            aloge("fatal error! virvi[%d,%d] end failed!", nVippIndex, virvi_chn);
        }
    }
    ret = AW_MPI_VI_DisableVipp(nVippIndex);
    if(ret != SUCCESS)
    {
        aloge("fatal error! disable vipp[%d] fail", nVippIndex);
    }
    ret = AW_MPI_VI_DestroyVipp(nVippIndex);
    if(ret != SUCCESS)
    {
        aloge("fatal error! destroy vipp[%d] fail", nVippIndex);
    }
    alogd("vipp[%d] is destroyed!", nVippIndex);
    return ret;
}

int main(int argc, char *argv[])
{
    int result = 0;
    ERRORTYPE ret;
    int virvi_chn;

    GLogConfig stGLogConfig = 
    {
        .FLAGS_logtostderr = 1,
        .FLAGS_colorlogtostderr = 1,
        .FLAGS_stderrthreshold = _GLOG_INFO,
        .FLAGS_minloglevel = _GLOG_INFO,
        .FLAGS_logbuflevel = -1,
        .FLAGS_logbufsecs = 0,
        .FLAGS_max_log_size = 1,
        .FLAGS_stop_logging_if_full_disk = 1,
    };
    strcpy(stGLogConfig.LogDir, "/tmp/log");
    strcpy(stGLogConfig.InfoLogFileNameBase, "LOG-");
    strcpy(stGLogConfig.LogFileNameExtension, "IPC-");
    log_init(argv[0], &stGLogConfig);
    
	alogd("app:[%s] begin! time=%s, %s", argv[0], __DATE__, __TIME__);

    SampleViResetContext *pContext = (SampleViResetContext*)malloc(sizeof(SampleViResetContext));
    if(NULL == pContext)
    {
        aloge("fatal error! malloc fail!");
        return -1;
    }
    memset(pContext, 0, sizeof(SampleViResetContext));

    /* parse command line param */
    char *pConfigFilePath = NULL;
    if (parseCmdLine(pContext, argc, argv) != SUCCESS)
    {
        aloge("fatal error! parse cmd line fail");
        result = -1;
        goto _exit;
    }
    pConfigFilePath = pContext->mCmdLinePara.mConfigFilePath;

    /* parse config file. */
    if(LoadSampleViResetConfig(&pContext->mConfigPara, pConfigFilePath) != SUCCESS)
    {
        aloge("fatal error! no config file or parse conf file fail");
        result = -1;
        goto _exit;
    }

    MPP_SYS_CONF_S stSysConf;
    memset(&stSysConf, 0, sizeof(MPP_SYS_CONF_S));
    stSysConf.nAlignWidth = 32;
    AW_MPI_SYS_SetConf(&stSysConf);
    ret = AW_MPI_SYS_Init();
    if (ret != SUCCESS)
    {
        aloge("sys Init failed!");
        goto _exit;
    }

    while (pContext->mTestNum < pContext->mConfigPara.mTestCount || 0 == pContext->mConfigPara.mTestCount)
    {
        alogd("======================================");
        alogd("Auto Test count : %d. (MaxCount==%d)", pContext->mTestNum, pContext->mConfigPara.mTestCount);
        //system("cat /proc/meminfo | grep Committed_AS");
        alogd("======================================");
        VI_DEV nVippIndex;
        for(nVippIndex = pContext->mConfigPara.mVippStart; nVippIndex <= pContext->mConfigPara.mVippEnd; nVippIndex++)
        {
            RunOneVipp(HVIDEO(nVippIndex, 0), pContext);
        }
        
        for(nVippIndex = pContext->mConfigPara.mVippStart; nVippIndex <= pContext->mConfigPara.mVippEnd; nVippIndex++)
        {
            for (virvi_chn = 0; virvi_chn < 1; virvi_chn++)
            {
                pthread_join(pContext->mVirViChnArray[HVIDEO(nVippIndex, 0)][virvi_chn].mThid, NULL);
                alogd("vipp[%d]virChn[%d] capture thread is exit!", HVIDEO(nVippIndex, 0), virvi_chn);
            }
        }
        for(nVippIndex = pContext->mConfigPara.mVippStart; nVippIndex <= pContext->mConfigPara.mVippEnd; nVippIndex++)
        {
            DestroyOneVipp(HVIDEO(nVippIndex, 0), pContext);
        }
        if(pContext->mbIspRunningFlag)
        {
            AW_MPI_ISP_Stop(pContext->mConfigPara.mIspDev);
            alogd("isp[%d] is stopped!", pContext->mConfigPara.mIspDev);
            pContext->mbIspRunningFlag = false;
        }
        pContext->mTestNum++;
        pContext->mFirstVippRunFlag = false;
        alogd("[%d] test time is done!", pContext->mTestNum);
    }

_exit:
    free(pContext);
    alogd("%s test result: %s", argv[0], ((0==result) ? "success" : "fail"));
    return result;
}

全志 视频输入组件的使用

1.启动MPP和Glog库

2.获取配置文件信息

3.初始化ISP

4.创建VI组件

4.1 配置VI组件信息

4.2 创建VIPP

4.3 设置VIPP属性

4.4 启动VIPP

4.5 配置虚通道信息

4.6 创建虚通道

4.7 设置虚通道属性

4.8 启动虚通道

5.获取图像帧

5.1 获取图像数据

5.2 释放图像帧

6.停止并销毁VI组件

6.1 关闭虚通道

6.2 关闭VIPP

6.3 销毁VIPP

6.4 停止ISP

7.退出MPP

8.完整源码

全志视频输入组件的使用