音视频开发

最新推荐文章于 2024-08-17 17:20:21 发布

公子小白146

最新推荐文章于 2024-08-17 17:20:21 发布

阅读量905

点赞数 22

文章标签：学习嵌入式硬件音视频

本文链接：https://blog.csdn.net/weixin_64272492/article/details/141196472

版权

通过多线程分别获取高分辨率(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采用的是标量量化技术，用数学表达式就是：FQ = 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;
}

公子小白146

关注

22
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
音视频开发

但是要注意的是，在设置QP值的时候会容易造成码率的波动，有时候画面质量提升了会导致码率大幅度提升，所以在提升画面质量的时候也需要考虑码率的情况。OSD(on-screen-display)中文名称是屏幕菜单调节显示方式，它的作用是对屏幕显示器做各种工作指标，包括：色彩、几何图形等进行调整，从而使得整个显示器得到最佳的状，最常见的OSD调试就是在屏幕上添加水印、LOGO。设置最大量化器，最大QP值，限制最差的画面(重点在运动的时候)，maxQp越小，运动时候码率就越大，质量相对越好。越精细，否则越粗糙；
复制链接

扫一扫