• RKMPP库快速上手--（一）RKMPP功能及使用详解

    1、MPP简介

            MPP(Media Process Platform )是Rockchip提供的一款硬件编解码媒体处理软件平台，适用于Rockchip芯片系列。它屏蔽了有关芯片的复杂底层处理，屏蔽了不同芯片的差异，为使用者提供了一组MPI统一接口。如果想达到最好的效果，必须要通过librockchip_mpp来直接编码实现编解码。

            我们可以通过gstreamer和ffmpeg的mpp插件来使用mpp硬件加速，但是这两种应用程序都会因为兼容api的原因，徒增几次无用的帧拷贝动作，并且使用的都是虚拟地址。我们知道纯物理连续地址的硬件操作是非常快的，转到虚拟地址后效率就会降低。如果想榨干芯片的性能，开发最完美的代码，纯连续的物理buffer和mpp+rga是离不开的。

            Mpp的API思路其实跟目前绝大多数的编解码库是一致的，都是queue/dequeue的队列操作方式，先设置好编解码状态，然后不停的queue/dequeue input/output buffer就可以实现编解码控制了。如果大家熟悉FFmpeg，那学习MPP会非常容易，MPP和FFmpeg的api非常相像。

            Mpp库自带了编解码的sample，但是相关文档和注释较少，本文在原有sample的基础上添加了注释，并将部分功能封装成型。

    2、MPP提供的功能

    MPP提供有以下常用功能：

    • 视频解码
    • H.265 / H.264 / H.263 / VP9 / VP8 / MPEG-4 / MPEG-2 / MPEG-1 / VC1 / MJPEG
    • 视频编码
    • H.264 / VP8 / MJPEG
    • 视频处理
    • 视频拷贝，缩放，色彩空间转换，场视频解交织（Deinterlace）

    3、MPP系统架构

    4、MPP库的MPI接口介绍

    5、MPI数据结构说明

    MppMem： 为 C 库 malloc 内存的封装。

    MppBuffer： 为硬件用的 dmabuf 内存的封装。

    MppPacket： 为一维缓存封装，可以从 MppMem 和 MppBuffer 生成，表示码流数据。

    MppFrame： 为二维帧数据封装，可以从 MppMem 和 MppBuffer 生成，表示图像数据。

    MppMeta、MppTask：输入输出用任务的高级组合接口，可以指定输入输出方式；

    使用 MppPacket 和 MppFrame 就可以简单有效的完成一般的视频编解码工作。

    以视频解码为例，码流输入端把地址和大小赋值给 MppPacket，通过 put_packet 接口输入，在输出端通过 get_frame 接口得到输入图像 MppFrame，即可完成最简单的视频解码过程。

    6、解码流程示例

    7、RK-MPP库工具介绍与使用

            MPP 提供了一些单元测试用的工具程序，这种程序可以对软硬件平台以及 MPP 库本身进行测试

    mpp_info_test

    用于读取和打印 MPP 库的版本信息，在反馈问题时，可以把打印出来信息附上。

    mpp_buffer_test

    用于测试内核的内存分配器是否正常。

    mpp_mem_test

    用于测试 C 库的内存分配器是否正常。

    mpp_runtime_test

    用于测试一些软硬件运行时环境是否正常。

    mpp_platform_test

    用于读取和测试芯片平台信息是否正常

    8、交叉编译MPP库

    unzip mpp-develop.zip && cd mpp-develop

    cd build/linux/aarch64(根据平台选择) && vim arm.linux.cross.cmake（看下是否是对应平台的交叉编译工具）

    ./arm.linux.cross.cmake && make，编译之后，动态库在mpp目录下，测试工具在test目录下

    将工具和动态库push到rk的平台上（一般rk的平台都已经自带MPP动态库了），以解码为例执行./mpi_dec_test -t 7 -i /sdcard/input.h264 -n 10

    9、mpp测试程序说明及代码示例

    mpi_enc_test：使用同步界面（轮询，出队和入队），对raw data进行编码以压缩视频。

    mpi_dec_test：使用同步接口和异步接口（decode_put_packet和decode_get_frame），将视频压缩解码为yuv格式的raw data。

    mpi_rc_test：编码使用详细的比特率控制配置。

    mpi_rc2_test：使用详细的比特率控制配置进行编码，而cfg参数则来自mpi_rc.cfg。

    mpi_test：mpi调用方法的简单描述，仅供参考

    mpp_event_trigger：事件触发测试。

    mpp_parse_cfg：mpp解析器cfg测试。

    vpu_api_test：编码或解码使用旧版接口，以便与以前的vpu接口兼容

    (1)、参考mpi_dec_test.c 写一个最简单的解码demo

    1. #include 
    2. #include "rk_mpi.h"
    3. #include "mpp_mem.h"
    4. #include "mpp_env.h"
    5. #include "mpp_time.h"
    6. #include "mpp_common.h"
    7. #include "mpi_dec_utils.h"
    8. #include "utils.h"
    9.  
    10. typedef struct 
    11. {
    12.     MppCtx          ctx;
    13.     MppApi          *mpi;
    14.     RK_U32          eos;
    15.     char            *buf;
    16.  
    17.     MppBufferGroup  frm_grp;
    18.     MppPacket       packet;
    19.     size_t          packet_size;
    20.     MppFrame        frame;
    21.  
    22.     FILE            *fp_input;
    23.     FILE            *fp_output;
    24.     RK_S32          frame_count;
    25.     RK_S32          frame_num;
    26.     size_t          max_usage;
    27. } MpiDecLoopData;
    28.  
    29. static int decode_simple(MpiDecLoopData *data)
    30. {
    31.     RK_U32 pkt_done = 0;
    32.     RK_U32 err_info = 0;
    33. 	
    34.     MPP_RET ret = MPP_OK;
    35.     MppCtx ctx  = data->ctx;
    36.     MppApi *mpi = data->mpi;
    37.     char   *buf = data->buf;
    38. 	
    39.     MppPacket packet = data->packet;
    40.     MppFrame  frame  = NULL;
    41. 	
    42.     size_t read_size = fread(buf, 1, data->packet_size, data->fp_input);
    43. 	
    44.     if (read_size != data->packet_size || feof(data->fp_input)) {
    45.         printf("found last packet\n");
    46.         data->eos = 1;
    47.     }
    48.     
    49.     mpp_packet_write(packet, 0, buf, read_size);
    50.     mpp_packet_set_pos(packet, buf);
    51.     mpp_packet_set_length(packet, read_size);
    52.  
    53.     if (data->eos){
    54.         mpp_packet_set_eos(packet);
    55.     }
    56.  
    57.     do {
    58.         if (!pkt_done) {
    59.             ret = mpi->decode_put_packet(ctx, packet);
    60.             if (MPP_OK == ret){
    61.                 pkt_done = 1;
    62. 			}
    63.         }
    64.  
    65.         do {
    66.             RK_S32 get_frm = 0;
    67.             RK_U32 frm_eos = 0;
    68.             ret = mpi->decode_get_frame(ctx, &frame);
    69.     
    70.             if (frame) {
    71.                 if (mpp_frame_get_info_change(frame)){
    72.                     RK_U32 width = mpp_frame_get_width(frame);
    73.                     RK_U32 height = mpp_frame_get_height(frame);
    74.                     RK_U32 hor_stride = mpp_frame_get_hor_stride(frame);
    75.                     RK_U32 ver_stride = mpp_frame_get_ver_stride(frame);
    76.                     RK_U32 buf_size = mpp_frame_get_buf_size(frame);								
    77.                     printf("decode_get_frame get info changed found\n");
    78.                     printf("decoder require buffer w:h [%d:%d] stride [%d:%d] buf_size %d", width, height, hor_stride, ver_stride, buf_size);        
    79.  
    80.                     if (NULL == data->frm_grp) {                       
    81.                         ret = mpp_buffer_group_get_internal(&data->frm_grp, MPP_BUFFER_TYPE_ION);
    82.                         if (ret) {
    83.                             printf("get mpp buffer group failed ret %d\n", ret);
    84.                             break;
    85.                         }							
    86.                         ret = mpi->control(ctx, MPP_DEC_SET_EXT_BUF_GROUP, data->frm_grp);
    87.                         if (ret) {
    88.                             printf("set buffer group failed ret %d\n", ret);
    89.                             break;
    90.                         }
    91.                     } else {                      
    92.                         ret = mpp_buffer_group_clear(data->frm_grp);
    93.                         if (ret){
    94.                             printf("clear buffer group failed ret %d\n", ret);
    95.                             break;
    96.                         }
    97.                     }
    98.                     
    99.                     ret = mpp_buffer_group_limit_config(data->frm_grp, buf_size, 24);
    100.                     if (ret) {
    101.                         printf("limit buffer group failed ret %d\n", ret);
    102.                         break;
    103.                     }                   
    104.                     ret = mpi->control(ctx, MPP_DEC_SET_INFO_CHANGE_READY, NULL);
    105.                     if (ret) {
    106.                         printf("info change ready failed ret %d\n", ret);
    107.                         break;
    108.                     }
    109.                 }else{
    110.                     err_info = mpp_frame_get_errinfo(frame) | mpp_frame_get_discard(frame);
    111.                     if (err_info) {
    112.                         printf("decoder_get_frame get err info:%d discard:%d.\n", mpp_frame_get_errinfo(frame), mpp_frame_get_discard(frame));
    113.                     }
    114.                     data->frame_count++;
    115.                     printf("decode_get_frame get frame %d\n", data->frame_count);
    116.                     if ( (!err_info) && (data->frame_count==data->frame_num)){
    117.                         dump_mpp_frame_to_file(frame, data->fp_output);
    118. 					}
    119. 				}
    120.                 frm_eos = mpp_frame_get_eos(frame);
    121.                 mpp_frame_deinit(&frame);
    122.                 frame = NULL;
    123.                 get_frm = 1;
    124. 			}
    125.            
    126.             if (data->frm_grp) {
    127.                 size_t usage = mpp_buffer_group_usage(data->frm_grp);
    128.                 if (usage > data->max_usage){
    129.                     data->max_usage = usage;
    130. 				}	
    131.             }
    132.          
    133.             if (data->eos && pkt_done && !frm_eos) {
    134.                 msleep(10);
    135.                 continue;
    136.             }
    137.             if (frm_eos) {
    138.                 printf("found last frame\n");
    139.                 break;
    140.             }
    141.             if (data->frame_num && data->frame_count >= data->frame_num) {
    142.                 data->eos = 1;
    143.                 break;
    144.             }
    145.             if (get_frm){
    146.                 continue;
    147. 			}
    148.             break;
    149.         } while (1);
    150.  
    151.         if (data->frame_num && data->frame_count >= data->frame_num){
    152.             data->eos = 1;
    153.             printf("reach max frame number %d\n", data->frame_count);
    154.             break;
    155.         }
    156.         if (pkt_done){
    157.             break;
    158. 		}
    159. 		
    160. 		
    161.     } while (1);
    162.  
    163.     return ret;
    164. }
    165.  
    166. int mpi_dec_test_decode(char **argv)
    167. {
    168.     MPP_RET ret         = MPP_OK;
    169.     size_t file_size 	= 0;
    170.  
    171.     MppParam param      = NULL;
    172.     RK_U32 need_split   = 1;
    173.  
    174.     MpiDecLoopData data;
    175.     memset(&data, 0, sizeof(data));
    176. 	
    177.     data.eos            = 0;
    178.     data.packet_size    = MPI_DEC_STREAM_SIZE;
    179.     data.frame_count    = 0;
    180. 	data.frame_num		= 1;
    181.  
    182.     data.fp_input = fopen(argv[1], "rb");
    183. 	data.fp_output = fopen(argv[2], "w+");
    184.     if ( (NULL == data.fp_input) || (NULL == data.fp_output) ) {
    185.         printf("failed to open input/output file \n");
    186.         goto MPP_TEST_OUT;
    187.     }
    188.  
    189. 	
    190.     data.buf = mpp_malloc(char, data.packet_size);
    191.     ret = mpp_packet_init(&data.packet, data.buf, data.packet_size);
    192. 	if(MPP_OK != ret){
    193. 		printf("mpp_packet_init error\n");
    194. 		goto MPP_TEST_OUT;
    195. 	}
    196. 	
    197. 	
    198.     ret = mpp_create(&data.ctx, &data.mpi);
    199. 	if(MPP_OK != ret){
    200. 		printf("mpp_create error\n");
    201. 		goto MPP_TEST_OUT;
    202. 	}
    203.  
    204. 	ret = mpp_init(data.ctx, MPP_CTX_DEC, MPP_VIDEO_CodingAVC);
    205.     if (MPP_OK != ret) 
    206.     {
    207.         printf("mpp_init failed\n");
    208.         goto MPP_TEST_OUT;
    209.     }
    210.  
    211.     param = &need_split;
    212. 	
    213.     ret = data.mpi->control(data.ctx, MPP_DEC_SET_PARSER_SPLIT_MODE, param);
    214.     if (MPP_OK != ret) {
    215.         printf("mpi->control failed\n");
    216.         goto MPP_TEST_OUT;
    217.     }
    218.  
    219. 	fseek(data.fp_input, 0L, SEEK_END);
    220. 	file_size = ftell(data.fp_input);
    221.     rewind(data.fp_input);
    222.     printf("input file size %ld\n", file_size);
    223.  
    224.     while (!data.eos) 
    225. 	{
    226.         decode_simple(&data);
    227.     }
    228.  
    229.     ret = data.mpi->reset(data.ctx);
    230.     if (MPP_OK != ret) 
    231.     {
    232.         printf("mpi->reset failed\n");
    233.         goto MPP_TEST_OUT;
    234.     }
    235.  
    236. MPP_TEST_OUT:
    237.     if (data.packet) {
    238.         mpp_packet_deinit(&data.packet);
    239.         data.packet = NULL;
    240.     }
    241.  
    242.     if (data.ctx) {
    243.         mpp_destroy(data.ctx);
    244.         data.ctx = NULL;
    245.     }
    246.  
    247.     if (data.buf) {
    248.         mpp_free(data.buf);
    249.         data.buf = NULL;
    250.     }
    251.  
    252.     if (data.frm_grp) {
    253.         mpp_buffer_group_put(data.frm_grp);
    254.         data.frm_grp = NULL;
    255.     }
    256.  
    257.     if (data.fp_output){
    258.         fclose(data.fp_output);
    259.         data.fp_output = NULL;
    260.     }
    261.  
    262.     if (data.fp_input) {
    263.         fclose(data.fp_input);
    264.         data.fp_input = NULL;
    265.     }
    266.  
    267.     return ret;
    268. }
    269.  
    270. int main(int argc, char **argv)
    271. {
    272.     RK_S32 ret = 0;
    273.  
    274. 	if(argc != 3 ){
    275. 		printf("please input options\n");
    276. 		return -1;
    277. 	}
    278. 	
    279.     ret = mpi_dec_test_decode(argv);
    280. 	
    281.     return ret;
    282. }

    10、测试MPP解码H264，解码输出格式为YUV420SP

    ./mpi_dec_test input.h264 out.yuv

  • 相关阅读:
    Matlab信号处理3：fft(快速傅里叶变换)标准使用方式
    信息安全软考 第二章 网络攻击原理与常用方法笔记总结
    武汉新时标文化传媒有限公司短视频中需要的平台和软件都是这样的
    【优化调度】粒子群算法求解水火电调度优化问题【含Matlab源码 1181期】
    分治算法求解：逆序对，Max Sum，棋盘覆盖，a-Good String——中山大学软件工程学院算法第四次实验课 必做+选做题
    echarts实现3d饼图
    了解 HTTPS 中间人攻击：保护你的网络安全
    AI短视频制作一本通：文本生成视频、图片生成视频、视频生成视频
    echarts点击按钮排序
    如果我在初用tomcat时，是看到这篇tomcat架构解析，是不是就不会被说菜鸡了！
  • 原文地址：https://blog.csdn.net/fanyun_01/article/details/126089171