音视频开发

通过多线程分别获取高分辨率(1920 * 1080)和低分辨率(1280 * 720)

初始化VI模块

初始化HIGH VENC模块

初始化LOW VENC模块

初始化RGA模块

绑定 VI和HIGH VENC

绑定 VI和RGA

创建线程

HIGH VENC处理

RGA处理

LOW VENC处理

销毁

QP原理的讲解

QP参数调节，指的是量化参数调节。它主要是来调节图像的细节，最终达到调节画面质量的作用。QP值和比特率成反比，QP值越小，码率越高，画面质量越好；反之QP值越大，码率越低，画面质量越低，而且随着视频源复杂度，这种反比的关系会更加明显。但是要注意的是，在设置QP值的时候会容易造成码率的波动，有时候画面质量提升了会导致码率大幅度提升，所以在提升画面质量的时候也需要考虑码率的情况。在编码中，亮度的QP最大值是51、色度的QP最大值是39，在真正开发中调节亮度的QP值为主。

QP调节一般由QStep、MinQp、MaxQp这三个参数进行调节

QStep

QStep指的是量化步长，QStep随着QP的增加而增加。每当QP值增加6，QStep增加一倍。在一般的编码器，H264/H265采用的是标量量化技术，用数学表达式就是：F Q = round(y/QStep) (FQ是量化的值、y是输入样本点编码、QStep是量化步长、round是取整函数) 。QP值越小，整体画面越精细，否则越粗糙；QP的取值范围是[0,51]，当值为0的时候表示画面最精细，当值为51的时候画面最粗糙。

minqp

设置最小量化器，限制最好的图像质量(重点在静止画面)，当QP达到这个值的时候，数值不会变。这就会使得在静止场景下，码率到达一定数量后不会进行调整。minqp越小，静止时候码率越大，质量越好，minQp取值范围是[0,48]。下面就是利用minQp做静止画面调节的细节。

maxqp

设置最大量化器，最大QP值，限制最差的画面(重点在运动的时候)，maxQp越小，运动时候码率就越大，质量相对越好。同样道理，当运动情况下到达一定码率后就不会调整，取值范围是[8,51]。下面就是利用maxQp做运动画面调节的细节。

RV1126多线程分别获取QP的VENC数据和普通VENC数据

步骤流程

VI模块初始化

普通VENC初始化

量化QP的VENC初始化

绑定VI和VENC

设置VENC模块的QP量化参数

绑定VI和QP量化的VENC模块

创建线程

通过GOP模式调节画面质量

普通GOP模式

普通GOP模式是最常见的GOP模式，它的特点就是两个I帧间隔固定的GOPSIZE，而GOPSIZE里面都是P帧或者B帧。比方说上图，GOPSIZE=5，相当于每隔5个P帧或者B帧插入一个I帧；普通的GOP模式通常适用于普通场景，比方说视频场景比较单一，没有那种运动画面、静止画面频繁切换的场景。

智能SMARTP的GOP模式

在SMART的GOP模式下，会分成两种I帧，一种是普通的I帧 、另外一种是虚拟I帧。普通的I帧主要是检测画面的静止区域，当检测到视频里面有静止画面的时候，编码器会利用长参考帧大幅度降低码率，静止画面降低码率能够有效防止画面的呼吸效应出现。

而在运动区域，则利用短参考帧进行运动估计，并插入Virtual I帧(虚拟I帧就是SMARTP)。在插入虚拟I帧的时候，可以最大拉长I帧间隔让它其提高在运动场景下的码率能够得到足够的提高，画面质量能够得到很好的改善；SMARTP模式常使用在静止画面和运动画面经常切换的场景，尤其是体育赛事。

TSVC的GOP模式

多层时域指的是编码层可以划分为多个层级，RV1126提供了RK_MPI_MB_GetTsvcLevel 获取层数，并通过层数来定制码流。举个例子，TSVC技术可以将一个普通的H264码流分割成不同的帧率、分辨率和视频质量的层数。一般而言，TSVC技术会根据目前的编码的网络情况 把视频码流分割成一个基础层和多个视频增强层，基础层为开发者提供最基本的视频质量、帧率和分辨率。基础层可以作为一个独立的层进行解码，而增强层的信息则依赖于基础层进行解码；总体来说，解码端接受的增强层数量越大，解码的视频质量就会越好。TSVC模式主要运用在网络环境不好的情况，如弱网环境、或者移动场景下比较多。

RV1126多线程获取SMARTP的GOP模式数据和普通GOP模式数据

代码显示

#include <assert.h>
#include <fcntl.h>
#include <getopt.h>
#include <pthread.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include "rkmedia_api.h"

#define PIPE_ID 0
#define VI_CHN_ID 0

#define COMMON_GOP_VENC_CHN 0
#define SMARTP_GOP_VENC_CHN 1

//获取每一帧COMMON_GOP的编码数据
void  * get_common_gop_thread(void * args)
{
    pthread_detach(pthread_self());
    FILE * common_gop_h264 = fopen("test_common_gop.h264", "w+");
    MEDIA_BUFFER mb = NULL;

    while (1)
    {
        mb = RK_MPI_SYS_GetMediaBuffer(RK_ID_VENC, COMMON_GOP_VENC_CHN, -1);
        if(!mb)
        {
            printf("Get COMMON_GOP VENC break.......\n");
            break;
        }

        printf("Get COMMON_GOP VENC Success.......\n");
        fwrite(RK_MPI_MB_GetPtr(mb), RK_MPI_MB_GetSize(mb), 1, common_gop_h264);
        RK_MPI_MB_ReleaseBuffer(mb);
    }

    return NULL;
}

//获取每一帧SMARTP_GOP的编码数据
void  * get_smartp_gop_thread(void * args)
{
    pthread_detach(pthread_self());
    FILE * smartp_gop_h264 = fopen("test_smartp_gop.h264", "w+");
    MEDIA_BUFFER mb = NULL;

    while (1)
    {
        mb = RK_MPI_SYS_GetMediaBuffer(RK_ID_VENC, SMARTP_GOP_VENC_CHN, -1);
        if(!mb)
        {
            printf("Get SMARTP_GOP VENC break.......\n");
            break;
        }

        printf("Get SMARTP_GOP VENC Success.......\n");
        fwrite(RK_MPI_MB_GetPtr(mb), RK_MPI_MB_GetSize(mb), 1, smartp_gop_h264);
        RK_MPI_MB_ReleaseBuffer(mb);
    }

    return NULL;
}



int main()
{

    int ret;
    RK_MPI_SYS_Init();

    // VI Init......
    VI_CHN_ATTR_S vi_chn_attr;
    vi_chn_attr.pcVideoNode = "rkispp_scale0";    // 设置视频设备节点路径
    vi_chn_attr.u32Width = 1920;                  // 设置分辨率的宽度
    vi_chn_attr.u32Height = 1080;                 // 设置分辨率的高度
    vi_chn_attr.enPixFmt = IMAGE_TYPE_NV12;       // 设置图像类型
    vi_chn_attr.enBufType = VI_CHN_BUF_TYPE_MMAP; // 设置VI获取类型
    vi_chn_attr.u32BufCnt = 3;                    // 设置缓冲数量
    vi_chn_attr.enWorkMode = VI_WORK_MODE_NORMAL; // 设置VI工作类型
    ret = RK_MPI_VI_SetChnAttr(PIPE_ID, VI_CHN_ID, &vi_chn_attr);
    if (ret)
    {
        printf("VI_CHN_ATTR Set Failed.....\n");
        return -1;
    }
    else
    {
        printf("VI_CHN_ATTR Set Success.....\n");
    }

    ret |= RK_MPI_VI_EnableChn(PIPE_ID, VI_CHN_ID);
    if (ret)
    {
        printf("VI_CHN_ATTR Enable Failed.....\n");
        return -1;
    }
    else
    {
        printf("VI_CHN_ATTR Enable Success.....\n");
    }

    // Common_Gop Venc Parameter
    VENC_CHN_ATTR_S common_gop_venc_attr;
    common_gop_venc_attr.stVencAttr.enType = RK_CODEC_TYPE_H264;  // 设置编码器类型
    common_gop_venc_attr.stVencAttr.imageType = IMAGE_TYPE_NV12;  // 设置编码图像类型
    common_gop_venc_attr.stVencAttr.u32PicWidth = 1920;           // 设置编码分辨率宽度
    common_gop_venc_attr.stVencAttr.u32PicHeight = 1080;          // 设置编码分辨率高度
    common_gop_venc_attr.stVencAttr.u32VirWidth = 1920;           // 设置编码分辨率虚宽
    common_gop_venc_attr.stVencAttr.u32VirHeight = 1080;          // 设置编码分辨率虚高
    common_gop_venc_attr.stVencAttr.u32Profile = 66;              // 设置编码等级
    common_gop_venc_attr.stVencAttr.enRotation = VENC_ROTATION_0; // 设置编码的旋转角度

    //********* 设置码率控制属性  *******************//
    common_gop_venc_attr.stRcAttr.enRcMode = VENC_RC_MODE_H264CBR;    // 设置H264的CBR码率控制模式
    common_gop_venc_attr.stRcAttr.stH264Cbr.u32Gop = 25;              // 设置GOP关键帧间隔
    common_gop_venc_attr.stRcAttr.stH264Cbr.u32SrcFrameRateNum = 25;  // 设置源帧率分子
    common_gop_venc_attr.stRcAttr.stH264Cbr.u32SrcFrameRateDen = 1;   // 设置源帧率分母
    common_gop_venc_attr.stRcAttr.stH264Cbr.fr32DstFrameRateNum = 25; // 设置目标帧率分子
    common_gop_venc_attr.stRcAttr.stH264Cbr.fr32DstFrameRateDen = 1;  // 设置目标帧率分母
    common_gop_venc_attr.stRcAttr.stH264Cbr.u32BitRate = 8388608;     // 设置码率大小
    ret = RK_MPI_VENC_CreateChn(COMMON_GOP_VENC_CHN, &common_gop_venc_attr);
    if (ret)
    {
        printf("Set Common_Gop Venc Attr Failed.....\n");
    }
    else
    {
        printf("Set Common_Gop Venc Attr Success.....\n");
    }

    // Common_Gop Venc Parameter
    VENC_CHN_ATTR_S smartp_gop_venc_attr;
    smartp_gop_venc_attr.stVencAttr.enType = RK_CODEC_TYPE_H264;  // 设置编码器类型
    smartp_gop_venc_attr.stVencAttr.imageType = IMAGE_TYPE_NV12;  // 设置编码图像类型
    smartp_gop_venc_attr.stVencAttr.u32PicWidth = 1920;           // 设置编码分辨率宽度
    smartp_gop_venc_attr.stVencAttr.u32PicHeight = 1080;          // 设置编码分辨率高度
    smartp_gop_venc_attr.stVencAttr.u32VirWidth = 1920;           // 设置编码分辨率虚宽
    smartp_gop_venc_attr.stVencAttr.u32VirHeight = 1080;          // 设置编码分辨率虚高
    smartp_gop_venc_attr.stVencAttr.u32Profile = 66;              // 设置编码等级
    smartp_gop_venc_attr.stVencAttr.enRotation = VENC_ROTATION_0; // 设置编码的旋转角度

    //********* 设置码率控制属性  *******************//
    smartp_gop_venc_attr.stRcAttr.enRcMode = VENC_RC_MODE_H264CBR;    // 设置H264的CBR码率控制模式
    smartp_gop_venc_attr.stRcAttr.stH264Cbr.u32Gop = 25;              // 设置GOP关键帧间隔
    smartp_gop_venc_attr.stRcAttr.stH264Cbr.u32SrcFrameRateNum = 25;  // 设置源帧率分子
    smartp_gop_venc_attr.stRcAttr.stH264Cbr.u32SrcFrameRateDen = 1;   // 设置源帧率分母
    smartp_gop_venc_attr.stRcAttr.stH264Cbr.fr32DstFrameRateNum = 25; // 设置目标帧率分子
    smartp_gop_venc_attr.stRcAttr.stH264Cbr.fr32DstFrameRateDen = 1;  // 设置目标帧率分母
    smartp_gop_venc_attr.stRcAttr.stH264Cbr.u32BitRate = 8388608;     // 设置码率大小
    ret = RK_MPI_VENC_CreateChn(SMARTP_GOP_VENC_CHN, &smartp_gop_venc_attr);
    if (ret)
    {
        printf("Set SMARTP_Gop Venc Attr Failed.....\n");
    }
    else
    {
        printf("Set SMARTP_Gop Venc Attr Success.....\n");
    }

    VENC_GOP_ATTR_S venc_gop_attr_s;
    venc_gop_attr_s.enGopMode = VENC_GOPMODE_SMARTP;//设置GOP模式为SMARTP模式
    venc_gop_attr_s.u32GopSize = 25;//设置短参考帧间隔是25
    venc_gop_attr_s.u32BgInterval = 25 * 5;//
    venc_gop_attr_s.s32IPQpDelta = 6;//设置I帧和P帧的差值是6
    venc_gop_attr_s.s32ViQpDelta = 6;//设置虚拟I帧和P帧的差值是6
    ret = RK_MPI_VENC_SetGopMode(SMARTP_GOP_VENC_CHN,&venc_gop_attr_s);
    if (ret)
    {
        printf("Set SMARTP_GOP_MODE Failed.....\n");
    }
    else
    {
        printf("Set SMARTP_GOP_MODE Success.....\n");
    }

    MPP_CHN_S vi_chn_s;
    vi_chn_s.enModId = RK_ID_VI;
    vi_chn_s.s32ChnId = VI_CHN_ID;

    MPP_CHN_S common_gop_venc_chn_s;
    common_gop_venc_chn_s.enModId = RK_ID_VENC;
    common_gop_venc_chn_s.s32ChnId = COMMON_GOP_VENC_CHN;

    MPP_CHN_S smartp_gop_venc_chn_s;
    smartp_gop_venc_chn_s.enModId = RK_ID_VENC;
    smartp_gop_venc_chn_s.s32ChnId = SMARTP_GOP_VENC_CHN;

    ret = RK_MPI_SYS_Bind(&vi_chn_s, &common_gop_venc_chn_s); //绑定VI和COMMON_GOP的VENC节点
    if (ret)
    {
        printf("Bind Vi And Common_Gop Failed.....\n");
    }
    else
    {
        printf("Bind Vi And Common_Gop Success.....\n");
    }

    ret = RK_MPI_SYS_Bind(&vi_chn_s, &smartp_gop_venc_chn_s);  //绑定VI和SMARTP_GOP的VENC节点
    if (ret)
    {
        printf("Bind Vi And Smartp_Gop Failed.....\n");
    }
    else
    {
        printf("Bind Vi And Smartp_Gop Success.....\n");
    }

    pthread_t common_gop_pid, smartp_gop_pid;
    pthread_create(&common_gop_pid, NULL, get_common_gop_thread, NULL);
    pthread_create(&common_gop_pid, NULL, get_smartp_gop_thread, NULL);

    while (1)
    {
        sleep(2);
    }

    RK_MPI_SYS_UnBind(&vi_chn_s, &common_gop_venc_chn_s);
    RK_MPI_SYS_UnBind(&vi_chn_s, &smartp_gop_venc_chn_s);
    RK_MPI_VENC_DestroyChn(COMMON_GOP_VENC_CHN);
    RK_MPI_VENC_DestroyChn(SMARTP_GOP_VENC_CHN);
    RK_MPI_VI_DisableChn(PIPE_ID, VI_CHN_ID);


    return 0;
}

OSD原理的讲解

OSD(on-screen-display)中文名称是屏幕菜单调节显示方式，它的作用是对屏幕显示器做各种工作指标，包括：色彩、几何图形等进行调整，从而使得整个显示器得到最佳的状，最常见的OSD调试就是在屏幕上添加水印、LOGO。OSD技术广泛运用在PC个人电脑、电视机顶盒、ETC屏幕显示等等，后来随着网络技术的发展OSD调节也从屏幕发展到了编码图层的叠加，换言之在编码图层也可以通过OSD的叠加方法显示出自定义的图层。

实现过程

1.视频信号处理

OSD叠加的第一个步骤，就是要对视频信号进行处理。这种信号处理就是要从模拟信号转换成数字信号，转换完成之后需要通过芯片对数字信号进行后处理工作，包括：去噪、锐化等等。

2.OSD图像的生成

视频数据经过数字信号处理后，就可以对其进行OSD图像的生成。OSD的图像包含很多种类型，比方说LOGO图形、文字、图标等，而生成OSD图像的方式一般分为软件模式和硬件模式。硬件模式是利用专门的OSD处理芯片，通过硬件的图像合成器将OSD图像和视频信号合成，整个过程CPU不去进行处理；软件模式是通过软件的图像处理算法生成OSD图像，整个过程CPU都参与处理，常用的OSD生成的框架有：OPENCV、 FFMPEG等。

3.OSD图像的叠加

最后一步就是把OSD的图像进行叠加，所谓叠加就是把OSD图像和视频信号结合在一起。OSD信号叠加一般分为两种一种是上方叠加、另外一种是下方叠加，上方叠加相当于把OSD图像显示在视频的顶部、下方叠加相当于把OSD图像显示在视频的底部。OSD叠加的原理也非常简单，就是把OSD图像的像素点和视频信号的像素点进行合成，并且在合成的过程中可以通过调整位置、大小等参数显示出来。

RV1126的OSD模块讲解

在RV1126开发OSD模块的时候，一般要使用下面的结构体分别是OSD_REGION_INFO_S 和BITMAP_S 。OSD_REGION_INFO_S主要作用是是在编码图像里面划分一个OSD区域，相当于在编码图像中空出一块空间给OSD图层来用，BITMAP_S 的作用是向OSD图层以位图的形式把具体的内容显示出来，下面是OSD_REGION_INFO和Bitmap的关系：

SDL_TTF库渲染文字并保存

运行时报的错误

上面这个错误是缺少了libSDL_ttf-2.0.so.0的库，此时要把libSDL_ttf-2.0.so.0放在/usr/lib下面

上面这个错误是缺少了libSDL-1.2.so.0的库，此时要把libSDL-1.2.so.0放在/usr/lib下面

RV1126的OSD模块和SDL_TTF结合输出H264文件

#include <assert.h>
#include <fcntl.h>
#include <getopt.h>
#include <pthread.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

// #include "common/sample_common.h"
#include "rkmedia_api.h"

#include <stdio.h>
#include "SDL.h"
#include "SDL_ttf.h"
#include <time.h>

#define CAMERA_PATH "rkispp_scale0"
#define CAMERA_ID 0
#define CAMERA_CHN 0
#define VENC_CHN 0

//对某个数值进行对齐
static int get_align16_value(int input_value, int align)
{
    int handle_value = 0;
    if (align && (input_value % align))
        handle_value = (input_value/ align + 1) * align;
    return handle_value;
}


void * bitmap_osd_handle_thread(void * args)
{
    pthread_detach(pthread_self());
    int ret ;
    TTF_Font * ttf_font;
    char *pstr = "2019-11-21 15:40:29";
    SDL_Surface * text_surface;
    SDL_Surface * convert_text_surface;
    SDL_PixelFormat * pixel_format;

    //TTF模块的初始化
    ret = TTF_Init();
    if(ret < 0)
    {
        printf("TTF_Init Failed...\n");
    }

    //打开TTF的字库
    ttf_font = TTF_OpenFont("./fzlth.ttf", 48);
    if(ttf_font == NULL)
    {
        printf("TTF_OpenFont Failed...\n");
    }

    //SDL_COLOR黑色,RGB(0,0,0)
    SDL_Color sdl_color;
    sdl_color.r = 0;
    sdl_color.g = 0;
    sdl_color.b = 0;
    text_surface = TTF_RenderText_Solid(ttf_font, pstr, sdl_color); 渲染文字

    //ARGB_8888
    pixel_format = (SDL_PixelFormat *)malloc(sizeof(SDL_PixelFormat));
    pixel_format->BitsPerPixel = 32;  //每个像素所占的比特位数 
    pixel_format->BytesPerPixel = 4; //每个像素所占的字节数 
    pixel_format->Amask = 0XFF000000;//ARGB的A掩码，A位0xff
    pixel_format->Rmask = 0X00FF0000;//ARGB的R掩码，R位0xff
    pixel_format->Gmask = 0X0000FF00;//ARGB的G掩码，G位0xff
    pixel_format->Bmask = 0X000000FF;//ARGB的B掩码，B位0xff
    convert_text_surface = SDL_ConvertSurface(text_surface, pixel_format, 0);
    if(convert_text_surface == NULL)
    {
        printf("convert_text_surface failed...\n");
    }

    BITMAP_S bitmap;//Bitmap位图结构体
    bitmap.u32Width = get_align16_value(convert_text_surface->w, 16);//Bitmap的宽度
    bitmap.u32Height = get_align16_value(convert_text_surface->h, 16);//Bitmap的高度
    bitmap.enPixelFormat = PIXEL_FORMAT_ARGB_8888;像素格式ARGB8888
    bitmap.pData = malloc((bitmap.u32Width) * (bitmap.u32Height) * pixel_format->BytesPerPixel); bitmap的data的分配大小
    memcpy(bitmap.pData, convert_text_surface->pixels, (convert_text_surface->w) * (convert_text_surface->h) *pixel_format->BytesPerPixel);bitmap的data赋值

    OSD_REGION_INFO_S rgn_info; //OSD_RGN_INFO结构体
    rgn_info.enRegionId = REGION_ID_0; //rgn的区域ID
    rgn_info.u32Width = bitmap.u32Width ; //osd的长度
    rgn_info.u32Height = bitmap.u32Height ; //osd的高度
    rgn_info.u32PosX = 128; //Osd的X轴方向
    rgn_info.u32PosY = 128; //Osd的Y轴方向
    rgn_info.u8Enable = 1; 使能OSD模块，1是使能，0为禁止。
    rgn_info.u8Inverse = 0; //禁止翻转

    ret = RK_MPI_VENC_RGN_SetBitMap(VENC_CHN, &rgn_info, &bitmap);  //设置OSD位图
    if(ret)
    {
        printf("RK_MPI_VENC_RGN_SetBitMap failed...\n");
    }
    else
    {
        printf("RK_MPI_VENC_RGN_SetBitMap Success...\n");
    }

    return NULL;
}

void * get_h264_data_thread(void * args)
{
    pthread_detach(pthread_self());
    FILE *h264_file = fopen("test_osd_venc.h264", "w+");
    MEDIA_BUFFER mb ;

    while (1)
    {
        mb = RK_MPI_SYS_GetMediaBuffer(RK_ID_VENC, VENC_CHN, -1);
        if(!mb)
        {
            printf("RK_MPI_SYS_GetMediaBuffer failed...\n");
            break;
        }

        printf("Get osd buffer success.....\n");
        fwrite(RK_MPI_MB_GetPtr(mb), RK_MPI_MB_GetSize(mb), 1, h264_file);
        RK_MPI_MB_ReleaseBuffer(mb);
    }
    
    return NULL;
}


int main()
{
    int ret;
    VI_CHN_ATTR_S vi_chn_attr;
    vi_chn_attr.pcVideoNode = CAMERA_PATH;        //设置视频设备节点路径
    vi_chn_attr.u32Width = 1920;                  //设置分辨率的宽度
    vi_chn_attr.u32Height = 1080;                 //设置分辨率的高度
    vi_chn_attr.enPixFmt = IMAGE_TYPE_NV12;       //设置图像类型
    vi_chn_attr.enBufType = VI_CHN_BUF_TYPE_MMAP; //设置VI获取类型
    vi_chn_attr.u32BufCnt = 3;                    //设置缓冲数量
    vi_chn_attr.enWorkMode = VI_WORK_MODE_NORMAL; //设置VI工作类型
    ret = RK_MPI_VI_SetChnAttr(CAMERA_ID, CAMERA_CHN, &vi_chn_attr);
    if (ret)
    {
        printf("Vi Set Attr Failed.....\n");
        return 0;
    }
    else
    {
        printf("Vi Set Attr Success.....\n");
    }

    ret = RK_MPI_VI_EnableChn(CAMERA_ID, CAMERA_CHN); // 
    if (ret)
    {
        printf("Vi Enable Attr Failed.....\n");
        return 0;
    }
    else
    {
        printf("Vi Enable Attr Success.....\n");
    }

    VENC_CHN_ATTR_S venc_chn_attr;
    memset(&venc_chn_attr, 0, sizeof(venc_chn_attr));
    venc_chn_attr.stVencAttr.enType = RK_CODEC_TYPE_H264;//设置编码器类型
    venc_chn_attr.stVencAttr.imageType = IMAGE_TYPE_NV12;//设置编码图像类型
    venc_chn_attr.stVencAttr.u32PicWidth = 1920;//设置编码分辨率宽度
    venc_chn_attr.stVencAttr.u32PicHeight = 1080;//设置编码分辨率高度
    venc_chn_attr.stVencAttr.u32VirWidth = 1920;//设置编码分辨率虚宽
    venc_chn_attr.stVencAttr.u32VirHeight = 1080;//设置编码分辨率虚高
    venc_chn_attr.stVencAttr.u32Profile = 77;//设置编码等级
    venc_chn_attr.stRcAttr.enRcMode = VENC_RC_MODE_H264CBR;//设置H264的CBR码率控制模式
    venc_chn_attr.stRcAttr.stH264Cbr.u32Gop = 25;
    venc_chn_attr.stRcAttr.stH264Cbr.u32BitRate = 2000000; // 2Mb
    venc_chn_attr.stRcAttr.stH264Cbr.fr32DstFrameRateDen = 1;//设置源帧率分母
    venc_chn_attr.stRcAttr.stH264Cbr.fr32DstFrameRateNum = 25;//设置源帧率分子
    venc_chn_attr.stRcAttr.stH264Cbr.u32SrcFrameRateDen = 1;//设置目标帧率分母
    venc_chn_attr.stRcAttr.stH264Cbr.u32SrcFrameRateNum = 25;//设置目标帧率分子
    ret = RK_MPI_VENC_CreateChn(0, &venc_chn_attr);  //VENC模块的初始化
    if (ret)
    {
        printf("ERROR: create VENC[0] error! ret=%d\n", ret);
        return 0;
    }
    else
    {
        printf("VENC SUCCESS\n");
    }

    ret = RK_MPI_VENC_RGN_Init(VENC_CHN, NULL);//RGN模块的初始化
    if(ret)
    {
        printf("Create VENC_RGN Failed .....\n");
        return 0;
    }
    else
    {
        printf("Create VENC_RGN Success .....\n");
    }


    MPP_CHN_S vi_chn_s;
    MPP_CHN_S venc_chn_s;
    vi_chn_s.enModId = RK_ID_VI;
    vi_chn_s.s32ChnId = 0;

    venc_chn_s.enModId = RK_ID_VENC;
    venc_chn_s.s32ChnId = 0;

    ret = RK_MPI_SYS_Bind(&vi_chn_s, &venc_chn_s); VI模块节点和VENC节点绑定
    if(ret)
    {
        printf("RK_MPI_SYS_Bind Failed .....\n");
    }
    else
    {
        printf("RK_MPI_SYS_Bind Success .....\n");
    }

   
    pthread_t bitmap_pid, venc_pid;
    pthread_create(&bitmap_pid, NULL, bitmap_osd_handle_thread, NULL); //创建OSD叠加线程
    pthread_create(&venc_pid, NULL, get_h264_data_thread, NULL);   //获取H264码流线程

    while (1)
    {
        sleep(2);
    }

    RK_MPI_SYS_UnBind(&vi_chn_s, &venc_chn_s);
    RK_MPI_VENC_DestroyChn(VENC_CHN);
    RK_MPI_VI_DisableChn(CAMERA_ID, CAMERA_CHN);

    return 0;
}