毕设日志（二）Luckfox-RKMPI示例的资源管理分析

1
static void *GetMediaBuffer(void *arg) {
2
  (void)arg;
3
  printf("========%s========\n", __func__);
4
  void *pData = RK_NULL;
5
  int s32Ret;
6

7
  VENC_STREAM_S stFrame;
8
  stFrame.pstPack = (VENC_PACK_S *)malloc(sizeof(VENC_PACK_S));
9

10
  while (1) {
11

12
    // 获取编码后的H.264包
13
    s32Ret = RK_MPI_VENC_GetStream(0, &stFrame, -1);
14
    if (s32Ret == RK_SUCCESS) {
15
      if (g_rtsplive && g_rtsp_session) {
16
        pData = RK_MPI_MB_Handle2VirAddr(stFrame.pstPack->pMbBlk);
17
        rtsp_tx_video(g_rtsp_session, (uint8_t *)pData, stFrame.pstPack->u32Len,
18
                      stFrame.pstPack->u64PTS);
19
        rtsp_do_event(g_rtsplive);
20
      }
21

22
      // 资源释放，释放编码后的包
23
      s32Ret = RK_MPI_VENC_ReleaseStream(0, &stFrame);
24
      if (s32Ret != RK_SUCCESS) {
25
        RK_LOGE("RK_MPI_VENC_ReleaseStream fail %x", s32Ret);
26
      }
27
    }
28

29
    // 暂停10ms
30
    usleep(10 * 1000);
31
  }
32
  printf("\n======exit %s=======\n", __func__);
33

34
  // 线程结束时释放stFrame
35
  free(stFrame.pstPack);
36
  return NULL;
37
}

2. `VENC_STREAM_S`编码数据帧分析#

其中，主要的帧格式是VENC_STREAM_S，可以看到它封装了venc支持的编码格式

1
/* Defines the features of an stream */
2
typedef struct rkVENC_STREAM_S {
3
    VENC_PACK_S ATTRIBUTE* pstPack;            /* R; stream pack attribute*/
4
    RK_U32      ATTRIBUTE u32PackCount;        /* R; the pack number of one frame stream*/
5
    RK_U32      u32Seq;                        /* R; the list number of stream*/
6

7
    union {
8
        VENC_STREAM_INFO_H264_S   stH264Info;                        /* R; the stream info of h264*/
9
        VENC_STREAM_INFO_JPEG_S   stJpegInfo;                        /* R; the stream info of jpeg*/
10
        VENC_STREAM_INFO_H265_S   stH265Info;                        /* R; the stream info of h265*/
11
        VENC_STREAM_INFO_PRORES_S stProresInfo;                      /* R; the stream info of prores*/
12
    };
13

14
    union {
15
        VENC_STREAM_ADVANCE_INFO_H264_S   stAdvanceH264Info;         /* R; the stream info of h264*/
16
        VENC_STREAM_ADVANCE_INFO_JPEG_S   stAdvanceJpegInfo;         /* R; the stream info of jpeg*/
17
        VENC_STREAM_ADVANCE_INFO_H265_S   stAdvanceH265Info;         /* R; the stream info of h265*/
18
        VENC_STREAM_ADVANCE_INFO_PRORES_S stAdvanceProresInfo;       /* R; the stream info of prores*/
19
    };
20
} VENC_STREAM_S;

二、NPU推理线程#

1. NPU推理线程分析#

利用RK_MPI_VI_GetChnFrame从VI通道获取原始数据帧，再利用opencv-mobile进行格式转换和缩放，最后用RGN，在VENC编码前将OSD合入视频帧

格式转换：将 NV12 转换为 BGR
缩放：将图像适配模型输入的 640×640 尺寸

1
static void *RetinaProcessBuffer(void *arg) {
2

3
  // ... 变量初始化 ...
4

5
  // 这是rkmpi中最核心最原始的数据帧，用它来承接从VI通道中获取的原始图像
6
  VIDEO_FRAME_INFO_S stViFrame;
7

8
  while(1)
9
  {
10
    // 手动抓取，主动向VI的通道1（专门用于推理的）请求一帧数据
11
    s32Ret = RK_MPI_VI_GetChnFrame(0, 1, &stViFrame, -1);
12

13
    // 之后利用opencv-mobile，对数据帧进行格式转换和缩放
14
    if(s32Ret == RK_SUCCESS)
15
    {
16
      // 获取虚拟地址
17
      void *vi_data = RK_MPI_MB_Handle2VirAddr(stViFrame.stVFrame.pMbBlk);
18
      if(vi_data != RK_NULL)
19
      {
20
        // 使用cv::Mat对原始数据帧进行封装，并进行格式转换和缩放处理
21
        cv::Mat yuv420sp(disp_height + disp_height / 2, disp_width, CV_8UC1, vi_data);
22
        cv::Mat bgr(disp_height, disp_width, CV_8UC3);
23
        cv::Mat model_bgr(model_height, model_width, CV_8UC3);
24

25
        cv::cvtColor(yuv420sp, bgr, cv::COLOR_YUV420sp2BGR);
26

27
        cv::resize(bgr, model_bgr, cv::Size(model_width ,model_height), 0, 0, cv::INTER_LINEAR);
28

29
        // memcpy到RKNN输入
30
        memcpy(rknn_app_ctx.input_mems[0]->virt_addr, model_bgr.data, model_width * model_height * 3);
31

32
        // 阻塞，该函数计算结束才会返回
33
        // od_results为推理结果
34
        inference_retinaface_model(&rknn_app_ctx, &od_results);
35

36
        // 利用rgn，将osd覆盖到venc的输入数据上，实现标注
37
        // ... RGN 处理逻辑 ...
38
        }
39
      }
40
      // 释放帧资源
41
      s32Ret = RK_MPI_VI_ReleaseChnFrame(0, 1, &stViFrame);
42
    }
43
    // 暂停500ms
44
    usleep(500000);
45
    // ... 清理 RGN 资源 ...
46
  }
47
  return NULL;
48
}

2. `VIDEO_FRAME_INFO_S`原始数据帧分析#

该线程操作的数据帧：VIDEO_FRAME_INFO_S

1
typedef struct rkVIDEO_FRAME_S {
2
    MB_BLK              pMbBlk; // 底层内存块句柄，该结构体本质上是对它的一层封装
3
    RK_U32              u32Width;
4
    RK_U32              u32Height;
5
    RK_U32              u32VirWidth;
6
    RK_U32              u32VirHeight;
7
    VIDEO_FIELD_E       enField;
8
    PIXEL_FORMAT_E      enPixelFormat;
9
    VIDEO_FORMAT_E      enVideoFormat;
10
    COMPRESS_MODE_E     enCompressMode;
11
    DYNAMIC_RANGE_E     enDynamicRange;
12
    COLOR_GAMUT_E       enColorGamut;
13

14
    RK_VOID            *pVirAddr[RK_MAX_COLOR_COMPONENT]; //虚拟地址
15

16
    RK_U32              u32TimeRef;
17
    RK_U64              u64PTS;
18

19
    RK_U64              u64PrivateData;
20
    RK_U32              u32FrameFlag;     /* FRAME_FLAG_E, can be OR operation. */
21
} VIDEO_FRAME_S;
22

23
typedef struct rkVIDEO_FRAME_INFO_S {
24
    VIDEO_FRAME_S stVFrame;
25
} VIDEO_FRAME_INFO_S;

三、毕设软件设计思路#

也就是说，对于我毕业设计这个需求，我需要处理两种格式，一是VENC编码后的H.264视频流，二是从VI通道直接获取的原始数据帧。rkmpi实际上已经做了一定程度的封装了，我应该在它封装的基础上进行管理，而不是拆开它们再自己封装。

1. 使用`std::share_ptr`和自定义删除器来封装数据帧#

原始帧和编码流虽然接口不同，但是它们的使用都符合这么一个逻辑：每一次循环开始时，先获取，进行处理，再释放。对于线性场景，比如VENC编码后，交由RTSP进行推流，那么可以在循环中执行上述逻辑。

但是对于我毕设的需求来说，编码流会可能会同时用于RTSP、WebRTC推流和本地保存，那么上述逻辑就会变得复杂且难以处理。此时适合使用std::share_ptr结合自定义删除器来进行处理，不同场景共享引用计数，只有当所有引用都结束后，再结束它的生命周期，进行析构（释放资源）。

以下是对编码流的处理，原始帧类似

1
/**
2
 * @brief 编码后的视频流智能指针 (VENC 输出)
3
 *
4
 * 用于推流路径，H.264/H.265 编码后的数据包
5
 * 释放时自动调用 RK_MPI_VENC_ReleaseStream
6
 */
7
using EncodedStreamPtr = std::shared_ptr<VENC_STREAM_S>;
8

9
/**
10
 * @brief 从 VENC 通道获取编码流并包装为智能指针
11
 *
12
 * @param chn_id VENC 通道 ID
13
 * @param timeout_ms 超时时间（毫秒），-1 表示阻塞等待
14
 * @return EncodedStreamPtr 成功返回流指针，失败返回 nullptr
15
 *
16
 * @note 返回的智能指针在所有引用释放后会自动调用 RK_MPI_VENC_ReleaseStream
17
 * @note 内部会分配 VENC_PACK_S，也会在释放时一并清理
18
 */
19
inline EncodedStreamPtr acquire_encoded_stream(RK_S32 chn_id, RK_S32 timeout_ms = -1) {
20
    auto stream = new VENC_STREAM_S();
21
    stream->pstPack = new VENC_PACK_S();
22

23
    RK_S32 ret = RK_MPI_VENC_GetStream(chn_id, stream, timeout_ms);
24
    if (ret != RK_SUCCESS) {
25
        delete stream->pstPack;
26
        delete stream;
27
        return nullptr;
28
    }
29

30
    // 创建带自定义删除器的 shared_ptr
31
    return EncodedStreamPtr(stream, [chn_id](VENC_STREAM_S* p) {
32
        if (p) {
33
            RK_MPI_VENC_ReleaseStream(chn_id, p);
34
            delete p->pstPack;
35
            delete p;
36
        }
37
    });
38
}