devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RK3568笔记十二：Zlmedia拉流显示测试_rkmedia拉流

作者：小丑西瓜9 | 2024-03-25 10:58:35

赞

踩

rkmedia拉流

若该文为原创文章，转载请注明原文出处。

Zlmediakit功能很强大，测试一下拉流，在通过解码显示。

一、环境

1、平台：rk3568

2、开发板:ATK-RK3568正点原子板子

3、环境：buildroot

测试的代码在GitHub - airockchip/rknpu2

main_video.cc主要功能是通过Zlmedia拉取RTSP流，并解码，然后重新编码保存成视频，所以直接在例子上修改程序，增加DRM显示。

二、编译

1、修改交叉工具链

修改build-linux_RK3566_RK3568.sh，

2、增加DRM显示程序

screen_test.cc

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/time.h>
  5. #include <dlfcn.h>
  6. #include <vector>
  7. #include <string>
  8.  
  9. #include "rga_func.h"
  10. #include "rknn_api.h"
  11.  
  12.  
  13. #include "RgaUtils.h"
  14. #include "im2d.h"
  15. #include "opencv2/core/core.hpp"
  16. #include "opencv2/imgcodecs.hpp"
  17. #include "opencv2/imgproc.hpp"
  18. #include <opencv2/opencv.hpp>
  19. #include "rga.h"
  20. #include <xf86drm.h>
  21. #include <xf86drmMode.h>
  22. #include "dev.h"
  23. #include "bo.h"
  24.  
  25. #include "screen_test.h"
  26.  
  27.  
  28.  
  29. static sp_dev *mDev;
  30. #define OUTPUT_DEVICE_LCD 1
  31.  
  32. static drmModeConnectorPtr lcdConnectorPtr = nullptr;
  33. static struct sp_crtc *lcdCRPtr;
  34. static drmModeEncoderPtr lcdEncoderPtr = nullptr;
  35. static uint32_t lcdCrtcId = 0;
  36. static drmModeModeInfoPtr lcdModInfoPtr;
  37.  
  38.  
  39. // 内部使用的函数原型声明
  40. static void get_connector(uint8_t outpuDevice);
  41. static void get_encoder(uint8_t outpuDevice);
  42. static void get_crtc(void);
  43. static int init_screens();
  44.  
  45.  
  46.  
  47. static void get_connector(uint8_t outpuDevice)
  48. {
  49.     int i, j = 0;
  50.     int ret = 0;
  51.  
  52.     printf("mDev->num_connectors = %d\n", mDev->num_connectors);
  53.     for (j = 0; j < mDev->num_connectors; j++)
  54.     {
  55.         // name 是分辨率信息
  56.         printf("connector name:%d\n", j);
  57.         printf("connector_type:%d\n", j);
  58.         printf("connector_type_id:%d\n", j);
  59.         printf("connector status:%d\n", j);
  60.         // 对应不同的输出设备, 指定不同的connector跟encoder
  61.         if (outpuDevice == OUTPUT_DEVICE_LCD)
  62.         {
  63.             if (mDev->connectors[j]->connector_type == DRM_MODE_CONNECTOR_DSI &&
  64.                 mDev->connectors[j]->connection == DRM_MODE_CONNECTED)
  65.             {
  66.                 lcdConnectorPtr = mDev->connectors[j];
  67.             }
  68.         }
  69.        
  70.     }
  71. }
  72.  
  73. static void get_encoder(uint8_t outpuDevice)
  74. {
  75.     int i;
  76.     for (i = 0; i < mDev->num_encoders; i++)
  77.     {
  78.         if (outpuDevice == OUTPUT_DEVICE_LCD)
  79.         {
  80.             if (mDev->encoders[i]->encoder_type == DRM_MODE_ENCODER_DSI)
  81.             {
  82.                 lcdEncoderPtr = mDev->encoders[i];
  83.                 lcdCrtcId = lcdEncoderPtr->crtc_id;
  84.             }
  85.         }
  86.        
  87.     }
  88. }
  89.  
  90. static void get_crtc(void)
  91. {
  92.     int j;
  93.  
  94.     printf("lcd crtc id:%d\n", lcdCrtcId);
  95.  
  96.     for (j = 0; j < mDev->num_crtcs; j++)
  97.     {
  98.  
  99.         printf("encoderPtr->crtc_id:%d\n", mDev->crtcs[j].crtc->crtc_id);
  100.         printf("mode_valid:%d\n", mDev->crtcs[j].crtc->mode_valid);
  101.         printf("mode_name:%s\n", mDev->crtcs[j].crtc->mode.name);
  102.         if (mDev->crtcs[j].crtc->crtc_id == lcdCrtcId && mDev->crtcs[j].crtc->mode_valid)
  103.         {
  104.             lcdCRPtr = &mDev->crtcs[j];
  105.         }
  106.        
  107.     }
  108. }
  109.  
  110.  
  111. static int init_screens()
  112. {
  113.     int ret = 0;
  114.     
  115.     // 获取lcd connector
  116.     get_connector(OUTPUT_DEVICE_LCD);
  117.  
  118.     if (!lcdConnectorPtr)
  119.     {
  120.         printf("failed to get hdmi connector or encoder.\n");
  121.         return -1;
  122.     }
  123.  
  124.     printf("lcd connector id:%d\n", lcdConnectorPtr->connector_id);
  125.  
  126.     // 获取lcd encoder
  127.     get_encoder(OUTPUT_DEVICE_LCD);
  128.  
  129.  
  130.     if (!lcdEncoderPtr)
  131.     {
  132.         printf("failed to get encoder.\n");
  133.         return -2;
  134.     }
  135.  
  136.     printf("lcd encoder id:%d\n", lcdEncoderPtr->encoder_id);
  137.  
  138.     // 获取一下显示分辨率之类
  139.     lcdModInfoPtr = &lcdConnectorPtr->modes[0];
  140.  
  141.     // 把connector的encoder id赋值为encoder的id
  142.     lcdConnectorPtr->encoder_id = lcdEncoderPtr->encoder_id;
  143.  
  144.     // 获取lcd crtc
  145.     get_crtc();
  146.     if (!lcdCRPtr)
  147.     {
  148.         printf("failed to get crtc.\n");
  149.         return -3;
  150.     }
  151.  
  152.     if (lcdCRPtr->scanout)
  153.     {
  154.         printf("crtc already in use\n");
  155.         return -4;
  156.     }
  157.  
  158.     printf("lcd crtc id:%d\n", lcdCRPtr->crtc->crtc_id);
  159.  
  160.     // allset
  161.     // 获取bo, 只需要输入分辨率即可.
  162.     lcdCRPtr->scanout = create_sp_bo(mDev, lcdModInfoPtr->hdisplay, lcdModInfoPtr->vdisplay, 24, 32, DRM_FORMAT_XRGB8888, 0);
  163.     if (!lcdCRPtr->scanout)
  164.     {
  165.         printf("failed to create new scanout bo\n");
  166.         return -5;
  167.     }
  168.  
  169.  
  170.     printf("fill test color\n");
  171.  
  172.     fill_bo(lcdCRPtr->scanout, 0xff, 0xff, 0x0, 0x0);
  173.  
  174.     ret = drmModeSetCrtc(mDev->fd, lcdEncoderPtr->crtc_id, lcdCRPtr->scanout->fb_id, 0, 0, &lcdConnectorPtr->connector_id, 1, lcdModInfoPtr);
  175.     if (ret)
  176.     {
  177.         printf("failed to set crtc mode ret=%d\n", ret);
  178.         return -6;
  179.     }
  180.     lcdCRPtr->crtc = drmModeGetCrtc(mDev->fd, lcdCRPtr->crtc->crtc_id);
  181.     memcpy(&lcdCRPtr->crtc->mode, lcdModInfoPtr, sizeof(*lcdModInfoPtr));
  182.  
  183.     return 0;
  184. }
  185.  
  186.  
  187.  
  188. int drm_dis_init(void)
  189. {
  190. 	 int ret = 0;
  191.     int i = 0;
  192.     printf("create sp dev\n");
  193.     // 创建显示设备
  194.     mDev = create_sp_dev();
  195.     if (!mDev)
  196.     {
  197.         printf("failed to exec create_sp_dev.\n");
  198.         return -10;
  199.     }
  200.  
  201.     printf("init_screen\n");
  202.  
  203.     // 初始化屏幕
  204.     ret = init_screens();
  205.     if (ret != 0)
  206.     {
  207.         printf("failed to exec initialize_screens.\n");
  208.         return -11;
  209.     }
  210.     return 0;
  211. }
  212.  
  213. void draw_lcd_screen_rgb_960(uint8_t *data, uint32_t dataSize)
  214. {
  215.     uint32_t colIdx = 0;
  216.     uint32_t rowIdx = 0;
  217.     uint8_t *dataPtr = data;
  218.     for (rowIdx = 0; rowIdx < 1280; rowIdx++)
  219.     {
  220.         uint8_t *rowPtr = (uint8_t *)lcdCRPtr->scanout->map_addr + rowIdx * lcdCRPtr->scanout->pitch;
  221.         for (colIdx = 0; colIdx < 720; colIdx++)
  222.         {
  223.             uint8_t *pixel = rowPtr + colIdx * 4;   // bgr
  224.             #if 1
  225.             pixel[0] = *dataPtr;         
  226.             dataPtr++;
  227.             pixel[1] = *dataPtr;
  228.             dataPtr++;
  229.             pixel[2] = *dataPtr;
  230.             dataPtr++;
  231.             pixel[3] = 0xff;
  232.             #else  // bgra
  233.             pixel[0] = 0xff;   // B
  234.             dataPtr++;
  235.             pixel[1] = 0x00;   //G 
  236.             dataPtr++;
  237.             pixel[2] = 0x00;   //R
  238.             dataPtr++;
  239.             pixel[3] = 0xFF;
  240.             #endif
  241.         }
  242.     }
  243. }
  244.  
  245.  
  246.  
  247. void draw_lcd_screen_rgb_dynamic(uint8_t *data, uint32_t dataSize, uint8_t screenNum, uint8_t rows, uint8_t cols)
  248. {
  249.     if (rows == 0 || cols == 0 || screenNum >= rows * cols)
  250.     {
  251.         return; // 避免除零错误和数组越界
  252.     }
  253.  
  254.     uint32_t startRowIdx, startColIdx;
  255.     uint32_t screenWidth = LCD_SCREEN_WIDTH / cols;
  256.     uint32_t screenHeight = LCD_SCREEN_HEIGHT / rows;
  257.  
  258.     // 计算起始行和列索引
  259.     startRowIdx = (screenNum / cols) * screenHeight; // 根据屏幕编号计算起始行索引
  260.     startColIdx = (screenNum % cols) * screenWidth;  // 根据屏幕编号计算起始列索引
  261.  
  262.     uint32_t rowIdx, colIdx;
  263.     uint8_t *dataPtr = data;
  264.     for (rowIdx = startRowIdx; rowIdx < startRowIdx + screenHeight; rowIdx++)
  265.     {
  266.         uint8_t *rowPtr = (uint8_t *)lcdCRPtr->scanout->map_addr + rowIdx * lcdCRPtr->scanout->pitch;
  267.         for (colIdx = startColIdx; colIdx < startColIdx + screenWidth; colIdx++)
  268.         {
  269.             uint8_t *pixel = rowPtr + colIdx * 4;
  270.             memcpy(pixel, dataPtr, 4);
  271.             dataPtr += 4;
  272.         }
  273.     }
  274. }
  275.  
  276.  
  277. void draw_lcd_screen_rgb_nine(uint8_t *data, uint32_t dataSize, uint8_t part)
  278. {
  279.     uint32_t startRowIdx, startColIdx;
  280.     uint32_t partWidth = LCD_SCREEN_WIDTH / 3;
  281.     uint32_t partHeight = LCD_SCREEN_HEIGHT / 3;
  282.  
  283.     // 计算起始行和列索引
  284.     startRowIdx = (part / 3) * partHeight; // 根据部分的行来计算起始行索引
  285.     startColIdx = (part % 3) * partWidth;  // 根据部分的列来计算起始列索引
  286.  
  287.     uint32_t rowIdx, colIdx;
  288.     uint8_t *dataPtr = data;
  289.     for (rowIdx = startRowIdx; rowIdx < startRowIdx + partHeight; rowIdx++)
  290.     {
  291.         uint8_t *rowPtr = (uint8_t *)lcdCRPtr->scanout->map_addr + rowIdx * lcdCRPtr->scanout->pitch;
  292.         for (colIdx = startColIdx; colIdx < startColIdx + partWidth; colIdx++)
  293.         {
  294.             uint8_t *pixel = rowPtr + colIdx * 4;
  295.             memcpy(pixel, dataPtr, 4);
  296.             dataPtr += 4;
  297.         }
  298.     }
  299. }
  300.  
  301.  
  302. void draw_lcd_screen_rgb_quarter(uint8_t *data, uint32_t dataSize, uint8_t quarter)
  303. {
  304.     uint32_t startRowIdx, startColIdx;
  305.     switch (quarter)
  306.     {
  307.     case 0: // 左上角
  308.         startRowIdx = 0;
  309.         startColIdx = 0;
  310.         break;
  311.     case 1: // 右上角
  312.         startRowIdx = 0;
  313.         startColIdx = LCD_SCREEN_WIDTH / 2;
  314.         break;
  315.     case 2: // 左下角
  316.         startRowIdx = LCD_SCREEN_HEIGHT / 2;
  317.         startColIdx = 0;
  318.         break;
  319.     case 3: // 右下角
  320.         startRowIdx = LCD_SCREEN_HEIGHT / 2;
  321.         startColIdx = LCD_SCREEN_WIDTH / 2;
  322.         break;
  323.     default: // 默认为左上角
  324.         startRowIdx = 0;
  325.         startColIdx = 0;
  326.         break;
  327.     }
  328.  
  329.     uint32_t rowIdx, colIdx;
  330.     uint8_t *dataPtr = data;
  331.     for (rowIdx = startRowIdx; rowIdx < startRowIdx + LCD_SCREEN_HEIGHT / 2; rowIdx++)
  332.     {
  333.         uint8_t *rowPtr = (uint8_t *)lcdCRPtr->scanout->map_addr + rowIdx * lcdCRPtr->scanout->pitch;
  334.         for (colIdx = startColIdx; colIdx < startColIdx + LCD_SCREEN_WIDTH / 2; colIdx++)
  335.         {
  336.             uint8_t *pixel = rowPtr + colIdx * 4;
  337.             memcpy(pixel, dataPtr, 4);
  338.             dataPtr += 4;
  339.         }
  340.     }
  341. }
  342.  
  343. void draw_lcd_screen_rgb(uint8_t *data, uint32_t dataSize)
  344. {
  345.  
  346.     uint32_t colIdx = 0;
  347.     uint32_t rowIdx = 0;
  348.     uint8_t *dataPtr = data;
  349.     for (rowIdx = 0; rowIdx < LCD_SCREEN_WIDTH; rowIdx++)
  350.     {
  351.         uint8_t *rowPtr = (uint8_t *)lcdCRPtr->scanout->map_addr + rowIdx * lcdCRPtr->scanout->pitch;
  352.         for (colIdx = 0; colIdx < LCD_SCREEN_HEIGHT; colIdx++)
  353.         {
  354.             uint8_t *pixel = rowPtr + colIdx * 4;
  355.             memcpy(pixel, dataPtr, 4);
  356.             dataPtr += 4;
  357. #if 0
  358.             uint8_t *pixel = rowPtr + colIdx * 4;
  359.             pixel[0] = *dataPtr;
  360.             dataPtr++;
  361.             pixel[1] = *dataPtr;
  362.             dataPtr++;
  363.             pixel[2] = *dataPtr;
  364.             dataPtr++;
  365.             pixel[3] = 0xff;
  366. #endif
  367.         }
  368.     }
  369. }
  370.

3、格式转换显示

使用的是正点原子的5.5寸屏，在调试过程中，一直卡在显示部分，后面才发现，正点原子使用的是竖屏，横屏显示会出现问题。

修改mpp_decoder_frame_callback函数，解码后的格式是420_SP，需要转成BGRA8888格式才能显示，使用RGA转换格式

  1. memset(&src_rect, 0, sizeof(src_rect));
  2.   memset(&dst_rect, 0, sizeof(dst_rect));
  3.   memset(&src1, 0, sizeof(src1));
  4.   memset(&dst1, 0, sizeof(dst1));
  5.   printf("resize with RGA!\n");
  6.   resize_buf = (unsigned char *)malloc(1280 * 720 * 3);
  7.   memset(resize_buf, 0, 1280 * 720 * 3);
  8.   printf("=========> width_stride: %d, height_stride: %d\n", width_stride, height_stride);
  9.   src1 = wrapbuffer_virtualaddr((unsigned char *)mpp_frame_addr, width_stride, height_stride, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride);
  10.   dst1 = wrapbuffer_virtualaddr((unsigned char*)resize_buf, 720, 1280, RK_FORMAT_BGR_888);
  11.   ret = imcheck(src1, dst1, src_rect, dst_rect);
  12.   if (IM_STATUS_NOERROR != ret) {
  13.     printf("%d, check error! %s", __LINE__, imStrError((IM_STATUS)ret));
  14.     free(resize_buf);
  15.     return ;
  16.   }
  17.   IM_STATUS STATUS = imresize(src1, dst1);
  18. 	
  19. 	
  20.   //MySaveBmp("out.bmp", (unsigned char *)resize_buf, 1280, 720);
  21.   // 显示在屏目上。
  22.   printf("draw_lcd_screen_rgb_960==============>\n");
  23.   draw_lcd_screen_rgb_960((uint8_t *)resize_buf, 1280 * 720 * 3);
  24.   printf("draw_lcd_screen_rgb_960 ok\n");
  25.   free(resize_buf);

需要注意 dst1 = wrapbuffer_virtualaddr((unsigned char*)resize_buf, 720, 1280, RK_FORMAT_BGR_888);，原本图片是1280*720，需要对调才能正常显示。

三、推流

先准备一个1280*720的视频，使用的是FFMPEG方式推流，但直接推流是无法拉流的，所以先启动一个RTSP服务器。

服务器下载地址Releases · aler9/rtsp-simple-server · GitHub

  • 启动rtsp-simple-server

下载完成后解压缩然后执行里面的rtsp-simple-server.exe

ffmpeg推流直接使用命令

ffmpeg -re -stream_loop -1 -i test.mp4 -c copy -f rtsp rtsp://192.168.0.107:8554/stream

四、程序解析

  1. // Copyright (c) 2023 by Rockchip Electronics Co., Ltd. All Rights Reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //     http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14.  
  15. /*-------------------------------------------
  16.                 Includes
  17. -------------------------------------------*/
  18. #include <dlfcn.h>
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <unistd.h>
  23. #include <sys/time.h>
  24.  
  25. #include "im2d.h"
  26. #include "rga.h"
  27. #include "RgaUtils.h"
  28.  
  29. #include "rknn_api.h"
  30. #include "postprocess.h"
  31.  
  32. #include "utils/mpp_decoder.h"
  33. #include "utils/mpp_encoder.h"
  34. #include "utils/drawing.h"
  35. #include "im2d_buffer.h"
  36. #include "screen_test.h"
  37. #if defined(BUILD_VIDEO_RTSP)
  38. #include "mk_mediakit.h"
  39.  
  40. #endif
  41.  
  42. #define OUT_VIDEO_PATH "out.h264"
  43.  
  44. #define LOG_TAG "MPP_API"
  45.  
  46. static FILE *g_save_nv12;    // nv12 
  47.  
  48. typedef struct {
  49.   rknn_context rknn_ctx;
  50.   rknn_input_output_num io_num;
  51.   rknn_tensor_attr* input_attrs;
  52.   rknn_tensor_attr* output_attrs;
  53.   int model_channel;
  54.   int model_width;
  55.   int model_height;
  56.   FILE* out_fp;
  57.   MppDecoder* decoder;
  58.   MppEncoder* encoder;
  59. } rknn_app_context_t;
  60.  
  61. typedef struct {
  62.   int width;
  63.   int height;
  64.   int width_stride;
  65.   int height_stride;
  66.   int format;
  67.   char* virt_addr;
  68.   int fd;
  69. } image_frame_t;
  70.  
  71. /*-------------------------------------------
  72.                   Functions
  73. -------------------------------------------*/
  74.  
  75. static void dump_tensor_attr(rknn_tensor_attr* attr)
  76. {
  77.   printf("  index=%d, name=%s, n_dims=%d, dims=[%d, %d, %d, %d], n_elems=%d, size=%d, fmt=%s, type=%s, qnt_type=%s, "
  78.          "zp=%d, scale=%f\n",
  79.          attr->index, attr->name, attr->n_dims, attr->dims[0], attr->dims[1], attr->dims[2], attr->dims[3],
  80.          attr->n_elems, attr->size, get_format_string(attr->fmt), get_type_string(attr->type),
  81.          get_qnt_type_string(attr->qnt_type), attr->zp, attr->scale);
  82. }
  83.  
  84. double __get_us(struct timeval t) { return (t.tv_sec * 1000000 + t.tv_usec); }
  85.  
  86. static unsigned char* load_data(FILE* fp, size_t ofst, size_t sz)
  87. {
  88.   unsigned char* data;
  89.   int ret;
  90.  
  91.   data = NULL;
  92.  
  93.   if (NULL == fp) {
  94.     return NULL;
  95.   }
  96.  
  97.   ret = fseek(fp, ofst, SEEK_SET);
  98.   if (ret != 0) {
  99.     printf("blob seek failure.\n");
  100.     return NULL;
  101.   }
  102.  
  103.   data = (unsigned char*)malloc(sz);
  104.   if (data == NULL) {
  105.     printf("buffer malloc failure.\n");
  106.     return NULL;
  107.   }
  108.   ret = fread(data, 1, sz, fp);
  109.   return data;
  110. }
  111.  
  112. static unsigned char* read_file_data(const char* filename, int* model_size)
  113. {
  114.   FILE* fp;
  115.   unsigned char* data;
  116.  
  117.   fp = fopen(filename, "rb");
  118.   if (NULL == fp) {
  119.     printf("Open file %s failed.\n", filename);
  120.     return NULL;
  121.   }
  122.  
  123.   fseek(fp, 0, SEEK_END);
  124.   int size = ftell(fp);
  125.  
  126.   data = load_data(fp, 0, size);
  127.  
  128.   fclose(fp);
  129.  
  130.   *model_size = size;
  131.   return data;
  132. }
  133.  
  134. static int write_data_to_file(const char *path, char *data, unsigned int size) {
  135.   FILE *fp;
  136.  
  137.   fp = fopen(path, "w");
  138.   if(fp == NULL) {
  139.     printf("open error: %s", path);
  140.     return -1;
  141.   }
  142.  
  143.   fwrite(data, 1, size, fp);
  144.   fflush(fp);
  145.  
  146.   fclose(fp);
  147.   return 0;
  148. }
  149.  
  150. static int init_model(const char* model_path, rknn_app_context_t* app_ctx) {
  151.   int ret;
  152.   rknn_context ctx;
  153.  
  154.   /* Create the neural network */
  155.   printf("Loading mode...\n");
  156.   int model_data_size = 0;
  157.   unsigned char* model_data = read_file_data(model_path, &model_data_size);
  158.   if (model_data == NULL) {
  159.     return -1;
  160.   }
  161.  
  162.   ret = rknn_init(&ctx, model_data, model_data_size, 0, NULL);
  163.   if (ret < 0) {
  164.     printf("rknn_init error ret=%d\n", ret);
  165.     return -1;
  166.   }
  167.  
  168.   if (model_data) {
  169.     free(model_data);
  170.   }
  171.  
  172.   rknn_sdk_version version;
  173.   ret = rknn_query(ctx, RKNN_QUERY_SDK_VERSION, &version, sizeof(rknn_sdk_version));
  174.   if (ret < 0) {
  175.     printf("rknn_query RKNN_QUERY_SDK_VERSION error ret=%d\n", ret);
  176.     return -1;
  177.   }
  178.   printf("sdk version: %s driver version: %s\n", version.api_version, version.drv_version);
  179.  
  180.   ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &app_ctx->io_num, sizeof(rknn_input_output_num));
  181.   if (ret < 0) {
  182.     printf("rknn_query RKNN_QUERY_IN_OUT_NUM error ret=%d\n", ret);
  183.     return -1;
  184.   }
  185.   printf("model input num: %d, output num: %d\n", app_ctx->io_num.n_input, app_ctx->io_num.n_output);
  186.  
  187.   rknn_tensor_attr* input_attrs = (rknn_tensor_attr*)malloc(app_ctx->io_num.n_input * sizeof(rknn_tensor_attr));
  188.   memset(input_attrs, 0, sizeof(input_attrs));
  189.   for (int i = 0; i < app_ctx->io_num.n_input; i++) {
  190.     input_attrs[i].index = i;
  191.     ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr));
  192.     if (ret < 0) {
  193.       printf("rknn_query RKNN_QUERY_INPUT_ATTR error ret=%d\n", ret);
  194.       return -1;
  195.     }
  196.     dump_tensor_attr(&(input_attrs[i]));
  197.   }
  198.  
  199.   rknn_tensor_attr* output_attrs = (rknn_tensor_attr*)malloc(app_ctx->io_num.n_output * sizeof(rknn_tensor_attr));
  200.   memset(output_attrs, 0, sizeof(output_attrs));
  201.   for (int i = 0; i < app_ctx->io_num.n_output; i++) {
  202.     output_attrs[i].index = i;
  203.     ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr));
  204.     if (ret < 0) {
  205.       printf("rknn_query RKNN_QUERY_OUTPUT_ATTR error ret=%d\n", ret);
  206.       return -1;
  207.     }
  208.     dump_tensor_attr(&(output_attrs[i]));
  209.   }
  210.  
  211.   app_ctx->input_attrs = input_attrs;
  212.   app_ctx->output_attrs = output_attrs;
  213.   app_ctx->rknn_ctx = ctx;
  214.  
  215.   if (input_attrs[0].fmt == RKNN_TENSOR_NCHW) {
  216.     printf("model is NCHW input fmt\n");
  217.     app_ctx->model_channel = input_attrs[0].dims[1];
  218.     app_ctx->model_height  = input_attrs[0].dims[2];
  219.     app_ctx->model_width   = input_attrs[0].dims[3];
  220.   } else {
  221.     printf("model is NHWC input fmt\n");
  222.     app_ctx->model_height  = input_attrs[0].dims[1];
  223.     app_ctx->model_width   = input_attrs[0].dims[2];
  224.     app_ctx->model_channel = input_attrs[0].dims[3];
  225.   }
  226.   printf("model input height=%d, width=%d, channel=%d\n", app_ctx->model_height, app_ctx->model_width, app_ctx->model_channel);
  227.  
  228.   return 0;
  229. }
  230.  
  231. static int release_model(rknn_app_context_t* app_ctx) {
  232.   if (app_ctx->rknn_ctx != NULL) {
  233.     rknn_destroy(app_ctx->rknn_ctx);
  234.   }
  235.   free(app_ctx->input_attrs);
  236.   free(app_ctx->output_attrs);
  237.   deinitPostProcess();
  238.   return 0;
  239. }
  240.  
  241. static int inference_model(rknn_app_context_t* app_ctx, image_frame_t* img, detect_result_group_t* detect_result) {
  242.   int ret;
  243.   rknn_context ctx = app_ctx->rknn_ctx;
  244.   int model_width = app_ctx->model_width;
  245.   int model_height = app_ctx->model_height;
  246.   int model_channel = app_ctx->model_channel;
  247.  
  248.   struct timeval start_time, stop_time;
  249.   const float    nms_threshold      = NMS_THRESH;
  250.   const float    box_conf_threshold = BOX_THRESH;
  251.   // You may not need resize when src resulotion equals to dst resulotion
  252.   void* resize_buf = nullptr;
  253.   // init rga context
  254.   rga_buffer_t src;
  255.   rga_buffer_t dst;
  256.   im_rect      src_rect;
  257.   im_rect      dst_rect;
  258.   memset(&src_rect, 0, sizeof(src_rect));
  259.   memset(&dst_rect, 0, sizeof(dst_rect));
  260.   memset(&src, 0, sizeof(src));
  261.   memset(&dst, 0, sizeof(dst));
  262.  
  263.   printf("input image %dx%d stride %dx%d format=%d\n", img->width, img->height, img->width_stride, img->height_stride, img->format);
  264.  
  265.   float scale_w = (float)model_width / img->width;
  266.   float scale_h = (float)model_height / img->height;
  267.  
  268.   rknn_input inputs[1];
  269.   memset(inputs, 0, sizeof(inputs));
  270.   inputs[0].index        = 0;
  271.   inputs[0].type         = RKNN_TENSOR_UINT8;
  272.   inputs[0].size         = model_width * model_height * model_channel;
  273.   inputs[0].fmt          = RKNN_TENSOR_NHWC;
  274.   inputs[0].pass_through = 0;
  275.  
  276.   printf("resize with RGA!\n");
  277.   resize_buf = malloc(model_width * model_height * model_channel);
  278.   memset(resize_buf, 0, model_width * model_height * model_channel);
  279.  
  280.   src = wrapbuffer_virtualaddr((void*)img->virt_addr, img->width, img->height, img->format, img->width_stride, img->height_stride);
  281.   dst = wrapbuffer_virtualaddr((void*)resize_buf, model_width, model_height, RK_FORMAT_RGB_888);
  282.   ret = imcheck(src, dst, src_rect, dst_rect);
  283.   if (IM_STATUS_NOERROR != ret) {
  284.     printf("%d, check error! %s", __LINE__, imStrError((IM_STATUS)ret));
  285.     return -1;
  286.   }
  287.   IM_STATUS STATUS = imresize(src, dst);
  288.  
  289.   inputs[0].buf = resize_buf;
  290.  
  291.   gettimeofday(&start_time, NULL);
  292.   rknn_inputs_set(ctx, app_ctx->io_num.n_input, inputs);
  293.  
  294.   rknn_output outputs[app_ctx->io_num.n_output];
  295.   memset(outputs, 0, sizeof(outputs));
  296.   for (int i = 0; i < app_ctx->io_num.n_output; i++) {
  297.     outputs[i].want_float = 0;
  298.   }
  299.  
  300.   ret = rknn_run(ctx, NULL);
  301.   ret = rknn_outputs_get(ctx, app_ctx->io_num.n_output, outputs, NULL);
  302.   gettimeofday(&stop_time, NULL);
  303.   printf("once run use %f ms\n", (__get_us(stop_time) - __get_us(start_time)) / 1000);
  304.  
  305.   printf("post process config: box_conf_threshold = %.2f, nms_threshold = %.2f\n", box_conf_threshold, nms_threshold);
  306.  
  307.   std::vector<float> out_scales;
  308.   std::vector<int32_t> out_zps;
  309.   for (int i = 0; i < app_ctx->io_num.n_output; ++i) {
  310.     out_scales.push_back(app_ctx->output_attrs[i].scale);
  311.     out_zps.push_back(app_ctx->output_attrs[i].zp);
  312.   }
  313.  
  314.   post_process((int8_t*)outputs[0].buf, (int8_t*)outputs[1].buf, (int8_t*)outputs[2].buf, model_height, model_width,
  315.                box_conf_threshold, nms_threshold, scale_w, scale_h, out_zps, out_scales, detect_result);
  316.   ret = rknn_outputs_release(ctx, app_ctx->io_num.n_output, outputs);
  317.  
  318.   if (resize_buf) {
  319.     free(resize_buf);
  320.   }
  321.   return 0;
  322. }
  323.  
  324.  
  325. typedef struct                       /**** BMP file info structure ****/  
  326. {  
  327.     unsigned int   biSize;           /* Size of info header */  
  328.     int            biWidth;          /* Width of image */  
  329.     int            biHeight;         /* Height of image */  
  330.     unsigned short biPlanes;         /* Number of color planes */  
  331.     unsigned short biBitCount;       /* Number of bits per pixel */  
  332.     unsigned int   biCompression;    /* Type of compression to use */  
  333.     unsigned int   biSizeImage;      /* Size of image data */  
  334.     int            biXPelsPerMeter;  /* X pixels per meter */  
  335.     int            biYPelsPerMeter;  /* Y pixels per meter */  
  336.     unsigned int   biClrUsed;        /* Number of colors used */  
  337.     unsigned int   biClrImportant;   /* Number of important colors */  
  338. } BITMAPINFOHEADER;
  339.  
  340. typedef struct                       /**** BMP file header structure ****/  
  341. {  
  342.     unsigned int   bfSize;           /* Size of file */  
  343.     unsigned short bfReserved1;      /* Reserved */  
  344.     unsigned short bfReserved2;      /* ... */  
  345.     unsigned int   bfOffBits;        /* Offset to bitmap data */  
  346. } BITMAPFILEHEADER; 
  347.  
  348.  
  349. void MySaveBmp(const char *filename,unsigned char *rgbbuf,int width,int height)  
  350. {  
  351.     BITMAPFILEHEADER bfh;  
  352.     BITMAPINFOHEADER bih;  
  353.     /* 
  354.      * Magic number for file. It does not fit in the header structure due to 
  355.      * alignment requirements, so put it outside 
  356.      * 文件的魔术字，由于对齐的需要，没办法将魔术字作为BITMAPFILEHEADER的成员，所以
  357.      * 这里将魔术字放在BITMAPFILEHEADER开头外面的位置。
  358.      */  
  359.     unsigned short bfType=0x4d42;    //'BM'             
  360.     bfh.bfReserved1 = 0;  
  361.     bfh.bfReserved2 = 0;  
  362.     bfh.bfSize = 2/* 2B魔术字 */+sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)+width*height*3;  
  363.     bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);  
  364.   
  365.     bih.biSize = sizeof(BITMAPINFOHEADER);  
  366.     bih.biWidth = width;  
  367.     bih.biHeight = height;  
  368.     bih.biPlanes = 1;  
  369.     bih.biBitCount = 24;  
  370.     bih.biCompression = 0;  
  371.     bih.biSizeImage = 0;  
  372.     bih.biXPelsPerMeter = 5000;  
  373.     bih.biYPelsPerMeter = 5000;  
  374.     bih.biClrUsed = 0;  
  375.     bih.biClrImportant = 0;  
  376.   
  377.     FILE *file = fopen(filename, "wb");  
  378.     if (!file)  
  379.     {  
  380.         printf("Could not write file\n");  
  381.         return;  
  382.     }  
  383.   
  384.     /*Write headers*/  
  385.     fwrite(&bfType,sizeof(bfType),1,file);  
  386.     fwrite(&bfh,sizeof(bfh),1, file);  
  387.     fwrite(&bih,sizeof(bih),1, file);  
  388.   
  389.     fwrite(rgbbuf,width*height*3,1,file);  
  390.     fclose(file);  
  391. }
  392.  
  393. // MPP解码回调函数
  394. void mpp_decoder_frame_callback(void* userdata, int width_stride, int height_stride, int width, int height, int format, int fd, void* data) {
  395.  
  396.   rknn_app_context_t* ctx = (rknn_app_context_t*)userdata;
  397.  
  398.   int ret = 0;
  399.   static int frame_index = 0;
  400.   frame_index++;
  401.  
  402.   void* mpp_frame = NULL;
  403.   int mpp_frame_fd = 0;
  404.   void* mpp_frame_addr = NULL;
  405.   int mpp_frame_size;
  406.   int enc_data_size;
  407.  
  408.   rga_buffer_t origin;
  409.   rga_buffer_t src;
  410.  
  411.   rga_buffer_t src1;
  412.   rga_buffer_t dst1;
  413.   unsigned char *resize_buf = nullptr;
  414.  
  415.   im_rect      src_rect;
  416.   im_rect      dst_rect;
  417.  
  418.   // 编码器初始化
  419.   if (ctx->encoder == NULL) {
  420.     MppEncoder* mpp_encoder = new MppEncoder();
  421.     MppEncoderParams enc_params;
  422.     memset(&enc_params, 0, sizeof(MppEncoderParams));
  423.     enc_params.width = width;
  424.     enc_params.height = height;
  425.     enc_params.hor_stride = width_stride;
  426.     enc_params.ver_stride = height_stride;
  427.     enc_params.fmt = MPP_FMT_YUV420SP;
  428.     //enc_params.type = MPP_VIDEO_CodingHEVC;
  429.     //Note: rk3562只能支持h264格式的视频流
  430.     enc_params.type = MPP_VIDEO_CodingAVC;
  431.     mpp_encoder->Init(enc_params, NULL);
  432.  
  433.     ctx->encoder = mpp_encoder;
  434.   }
  435.  
  436.   int enc_buf_size = ctx->encoder->GetFrameSize();
  437.   char* enc_data = (char*)malloc(enc_buf_size);
  439.   // 图片格式
  440.   image_frame_t img;
  441.   img.width = width;
  442.   img.height = height;
  443.   img.width_stride = width_stride;
  444.   img.height_stride = height_stride;
  445.   img.fd = fd;
  446.   img.virt_addr = (char*)data;
  447.   img.format = RK_FORMAT_YCbCr_420_SP;
  448.   detect_result_group_t detect_result;
  449.   memset(&detect_result, 0, sizeof(detect_result_group_t));
  450.   // RKNN推理
  451.   ret = inference_model(ctx, &img, &detect_result);
  452.   if (ret != 0) 
  453.   {
  454.     printf("inference model fail\n");
  455.  
  456.     if(enc_data)
  457.       free(enc_data);
  458.  
  459.     return ;
  460.   }
  461.  
  462.   mpp_frame = ctx->encoder->GetInputFrameBuffer();
  463.   mpp_frame_fd = ctx->encoder->GetInputFrameBufferFd(mpp_frame);
  464.   mpp_frame_addr = ctx->encoder->GetInputFrameBufferAddr(mpp_frame);
  465.   mpp_frame_size = ctx->encoder->GetFrameSize();
  466.   // 图片格式转换
  467.   // Copy To another buffer avoid to modify mpp decoder buffer
  468.   printf("wrapbuffer_fd==> width: %d, height: %d\n", width, height);
  469.   origin = wrapbuffer_fd(fd, width, height, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride);
  470.   src = wrapbuffer_fd(mpp_frame_fd, width, height, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride);
  471.   imcopy(origin, src);
  472.  
  473.   // Draw objects
  474.   for (int i = 0; i < detect_result.count; i++) {
  475.     detect_result_t* det_result = &(detect_result.results[i]);
  476.     printf("%s @ (%d %d %d %d) %f\n", det_result->name, det_result->box.left, det_result->box.top,
  477.            det_result->box.right, det_result->box.bottom, det_result->prop);
  478.     int x1 = det_result->box.left;
  479.     int y1 = det_result->box.top;
  480.     int x2 = det_result->box.right;
  481.     int y2 = det_result->box.bottom;
  482.     // 画框
  483.     draw_rectangle_yuv420sp((unsigned char*)mpp_frame_addr, width_stride, height_stride, x1, y1, x2-x1+1, y2-y1+1, 0x00FF0000, 4);
  484.   }
  485.   
  486.   //  保存原始视频流
  487.   #if 0
  488.         if (g_save_nv12) {
  489.           fwrite((unsigned char*)mpp_frame_addr, 1, mpp_frame_size, g_save_nv12);
  490.           printf("#Save len-%d to %s\n", mpp_frame_size, g_save_nv12);
  491.         }
  492.   #endif
  493.  
  494.   // 格式转换，420_SP转成BGR888
  495.   memset(&src_rect, 0, sizeof(src_rect));
  496.   memset(&dst_rect, 0, sizeof(dst_rect));
  497.   memset(&src1, 0, sizeof(src1));
  498.   memset(&dst1, 0, sizeof(dst1));
  499.   printf("resize with RGA!\n");
  500.   resize_buf = (unsigned char *)malloc(1280 * 720 * 3);
  501.   memset(resize_buf, 0, 1280 * 720 * 3);
  502.   printf("=========> width_stride: %d, height_stride: %d\n", width_stride, height_stride);
  503.   src1 = wrapbuffer_virtualaddr((unsigned char *)mpp_frame_addr, width_stride, height_stride, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride);
  504.   dst1 = wrapbuffer_virtualaddr((unsigned char*)resize_buf, 720, 1280, RK_FORMAT_BGR_888);
  505.   ret = imcheck(src1, dst1, src_rect, dst_rect);
  506.   if (IM_STATUS_NOERROR != ret) {
  507.     printf("%d, check error! %s", __LINE__, imStrError((IM_STATUS)ret));
  508.     free(resize_buf);
  509.     return ;
  510.   }
  511.   IM_STATUS STATUS = imresize(src1, dst1);
  512. 	
  513. 	
  514.   //MySaveBmp("out.bmp", (unsigned char *)resize_buf, 1280, 720);
  515.   // 显示在屏目上。
  516.   printf("draw_lcd_screen_rgb_960==============>\n");
  517.   draw_lcd_screen_rgb_960((uint8_t *)resize_buf, 1280 * 720 * 3);
  518.   printf("draw_lcd_screen_rgb_960 ok\n");
  519.   free(resize_buf);
  520.  
  521.   printf("waite get char to next step!\n");
  522.   //getchar();
  523.  
  524.   printf("====>Encode\n");
  525.   // Encode to file
  526.   // Write header on first frame
  527.   if (frame_index == 1) {
  528.     enc_data_size = ctx->encoder->GetHeader(enc_data, enc_buf_size);
  529.     fwrite(enc_data, 1, enc_data_size, ctx->out_fp);
  530.   }
  531.   printf("====>GetHeader ok\n");
  532.   memset(enc_data, 0, enc_buf_size);
  533.   enc_data_size = ctx->encoder->Encode(mpp_frame, enc_data, enc_buf_size);
  534.   printf("====>Encode ok\n");
  535.   fwrite(enc_data, 1, enc_data_size, ctx->out_fp);
  536.  
  537.   if (enc_data != nullptr) 
  538.     {
  539.       free(enc_data);
  540.     }
  541.   printf("fwrite ok\n");
  542.  
  543.  
  544.  
  545. }
  546.  
  547. int process_video_file(rknn_app_context_t* ctx, const char* path)
  548. {
  549.   int video_size;
  550.   char* video_data = (char*)read_file_data(path, &video_size);
  551.   char* video_data_end = video_data + video_size;
  552.   printf("read video size=%d\n", video_size);
  553.  
  554.   const int SIZE = 8192;
  555.   char* video_data_ptr = video_data;
  557.   do {
  558.       int pkt_eos = 0;
  559.       int size = SIZE;
  560.       if (video_data_ptr + size >= video_data_end) {
  561.           pkt_eos = 1;
  562.           size = video_data_end - video_data_ptr;
  563.       }
  564.  
  565.       ctx->decoder->Decode((uint8_t*)video_data_ptr, size, pkt_eos);
  566.  
  567.       video_data_ptr += size;
  568.  
  569.       if (video_data_ptr >= video_data_end) {
  570.           printf("reset decoder\n");
  571.           break;
  572.       }
  573.  
  574.       // LOGD("video_data_ptr=%p video_data_end=%p", video_data_ptr, video_data_end);
  575.       // usleep(10*1000);
  576.   } while (1);
  577.  
  578.   return 0;
  579. }
  580.  
  581. #if defined(BUILD_VIDEO_RTSP)
  582. void API_CALL on_track_frame_out(void *user_data, mk_frame frame) {
  583.   rknn_app_context_t *ctx = (rknn_app_context_t *) user_data;
  584.   printf("on_track_frame_out ctx=%p\n", ctx);
  585.   const char* data = mk_frame_get_data(frame);
  586.   size_t size = mk_frame_get_data_size(frame);
  587.   printf("decoder=%p\n", ctx->decoder);
  588.   ctx->decoder->Decode((uint8_t*)data, size, 0);
  589. }
  590.  
  591. void API_CALL on_mk_play_event_func(void *user_data, int err_code, const char *err_msg, mk_track tracks[],
  592.                                     int track_count) {
  593.   rknn_app_context_t *ctx = (rknn_app_context_t *) user_data;
  594.   if (err_code == 0) {
  595.       //success
  596.       printf("play success!");
  597.       int i;
  598.       for (i = 0; i < track_count; ++i) {
  599.           if (mk_track_is_video(tracks[i])) {
  600.               log_info("got video track: %s", mk_track_codec_name(tracks[i]));
  601.               //监听track数据回调
  602.               mk_track_add_delegate(tracks[i], on_track_frame_out, user_data);
  603.           }
  604.       }
  605.   } else {
  606.       printf("play failed: %d %s", err_code, err_msg);
  607.   }
  608. }
  609.  
  610. void API_CALL on_mk_shutdown_func(void *user_data, int err_code, const char *err_msg, mk_track tracks[], int track_count) {
  611.   printf("play interrupted: %d %s", err_code, err_msg);
  612. }
  613.  
  614. // 下面为Zlmeidia拉流处理
  615. int process_video_rtsp(rknn_app_context_t* ctx, const char* url)
  616. {
  617.   mk_config config;
  618.   memset(&config, 0, sizeof(mk_config));
  619.   config.log_mask = LOG_CONSOLE;
  620.   mk_env_init(&config);
  621.   mk_player player = mk_player_create();
  622.   mk_player_set_on_result(player, on_mk_play_event_func, ctx);
  623.   mk_player_set_on_shutdown(player, on_mk_shutdown_func, ctx);
  624.   mk_player_play(player, url);
  625.  
  626.   printf("enter any key to exit\n");
  627.   getchar();
  628.  
  629.   if (player) {
  630.       mk_player_release(player);
  631.   }
  632.   return 0;
  633. }
  634. #endif
  635.  
  636. /*-------------------------------------------
  637.                   Main Functions
  638. -------------------------------------------*/
  639. int main(int argc, char** argv)
  640. {
  641.   int status = 0;
  642.   int ret;
  643.  
  644.   if (argc != 4) {
  645.     printf("Usage: %s <rknn_model> <video_path> <video_type 264/265> \n", argv[0]);
  646.     return -1;
  647.   }
  648.  
  649.   char* model_name = (char*)argv[1];
  650.   char* video_name = argv[2];
  651.   int video_type = atoi(argv[3]);
  652.  
  653.   rknn_app_context_t app_ctx;
  654.   memset(&app_ctx, 0, sizeof(rknn_app_context_t));
  655.  
  656.   ret = init_model(model_name, &app_ctx);
  657.   if (ret != 0) {
  658.     printf("init model fail\n");
  659.     return -1;
  660.   }
  661.  
  662.   // MPP解码器
  663.   if (app_ctx.decoder == NULL) {
  664.     MppDecoder* decoder = new MppDecoder();
  665.     decoder->Init(video_type, 30, &app_ctx);
  666.     decoder->SetCallback(mpp_decoder_frame_callback);
  667.     app_ctx.decoder = decoder;
  668.   }
  669.  
  670.   // 视频保存
  671.   if (app_ctx.out_fp == NULL) {
  672.     FILE* fp = fopen(OUT_VIDEO_PATH, "w");
  673.     if(fp == NULL) {
  674.         printf("open %s error\n", OUT_VIDEO_PATH);
  675.         return -1;
  676.     }
  677.     app_ctx.out_fp = fp;
  678.   }
  679.   
  680.   // NV12保存
  681.   g_save_nv12 = fopen("output.nv12", "w");
  682.   if (!g_save_nv12)
  683.     printf("#VENC TEST:: Open ./output.nv12 failed!\n");
  684.  
  685.   printf("app_ctx=%p decoder=%p\n", &app_ctx, app_ctx.decoder);
  686.  
  687.   // 判断是不是RTSP流还是文件
  688.   if (strncmp(video_name, "rtsp", 4) == 0) {
  689. #if defined(BUILD_VIDEO_RTSP)
  690.         // DRM初始化
  691.         drm_dis_init();
  692.         // 拉流处理
  693.         process_video_rtsp(&app_ctx, video_name);
  694. #else
  695.         printf("rtsp no support\n");
  696. #endif
  697.   } else {
  698.     // 文件流处理
  699.     process_video_file(&app_ctx, video_name);
  700.   }
  701.  
  702.   printf("waiting finish\n");
  703.   usleep(3*1000*1000);
  704.  
  705.   // release
  706.   fflush(app_ctx.out_fp);
  707.   fclose(app_ctx.out_fp);
  708.  
  709.   if (app_ctx.decoder != nullptr) {
  710.     delete(app_ctx.decoder);
  711.     app_ctx.decoder = nullptr;
  712.   }
  713.   if (app_ctx.encoder != nullptr) {
  714.     delete(app_ctx.encoder);
  715.     app_ctx.encoder = nullptr;
  716.   }
  717.  
  718.   release_model(&app_ctx);
  719.  
  720.   return 0;
  721. }

通过Zlmedia很方便的拉取RTSP流，并解码显示。使用DRM是为了多路显示。OPENCV只会显示一路，不知道怎么拼接流显示。

如有侵权，或需要完整代码，请及时联系博主。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号