rkmedia 中的行人检测

已于 2023-08-12 09:47:06 修改
阅读量5.5k 收藏 33
点赞数 2
分类专栏： DeepLearning Rockchip 文章标签： NPU 人工智能 嵌入式
于 2020-12-26 11:20:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiran103/article/details/111722288
版权

RKMedia 是瑞芯微提供的媒体处理方案，可支持应用软件快速开发。rkmedia为 C 接口，其实现均在easymedia中。后者提供 C++ 接口。
rkmedia中的行人检测示例，执行的操作为：

  • 配置两个 RTSP 会话，初始化媒体处理平台；
  • GetMediaBuffer 线程获取缓存并调用 rockx 进行检测跟踪；
  • MainStream 线程绘制结果。

rkmedia_vi_person_detect_venc_rtsp_test.c

Created with Raphaël 2.3.0 main argv load_cfg create_rtsp_demo RK_MPI_SYS_Init SAMPLE_COMMON_VI_Start SAMPLE_COMMON_VENC_Start RK_MPI_VI_StartStream RK_MPI_SYS_Bind rtsp_set_video rtsp_get_reltime rtsp_get_ntptime rtsp_sync_video_ts create_rknn_list GetMediaBuffer MainStream sig_proc RK_MPI_SYS_GetMediaBuffer rtsp_tx_video RK_MPI_MB_ReleaseBuffer rtsp_do_event RK_MPI_SYS_UnBind RK_MPI_VI_DisableChn RK_MPI_VENC_DestroyChn rtsp_del_demo destory_rknn_list End

通过命令行传入配置文件。
load_cfg 加载 RTSP 会话配置。

  if (argc != 2) {
    printf("You must input the file of cfg.\n");
    printf("example file: oem/usr/share/rtsp-nn.cfg.\n");
    return -1;
  }
  load_cfg(argv[1]);

create_rtsp_demo 初始化 rtsp。
RK_MPI_SYS_Init 初始化各种类型的通道数组。

  // init rtsp
  printf("init rtsp\n");
  g_rtsplive = create_rtsp_demo(554);

  // init mpi
  printf("init mpi\n");
  RK_MPI_SYS_Init();

逐一创建会话，绑定输入通道。
其中第二个通道设置为VI_WORK_MODE_GOD_MODE用于 RKNN 处理。
SAMPLE_COMMON_VI_Start 设置通道属性并启动。
SAMPLE_COMMON_VENC_Start 启动视频流编码，海思中对应函数为SAMPLE_COMM_VENC_Start。
调用 RK_MPI_VI_StartStream 开启视频流，或者调用 RK_MPI_SYS_Bind 将数据源绑定到数据接收者。
rtsp_set_video 设置编码信息。
rtsp_get_reltime
rtsp_get_ntptime
rtsp_sync_video_ts

  // create session
  for (int i = 0; i < cfg.session_count; i++) {
    cfg.session_cfg[i].session =
        rtsp_new_session(g_rtsplive, cfg.session_cfg[i].path);

    // VI create
    printf("VI create\n");
    cfg.session_cfg[i].stViChn.enModId = RK_ID_VI;
    cfg.session_cfg[i].stViChn.s32ChnId = i;
    if (i == RK_NN_INDEX)
      SAMPLE_COMMON_VI_Start(&cfg.session_cfg[i], VI_WORK_MODE_GOD_MODE);
    else
      SAMPLE_COMMON_VI_Start(&cfg.session_cfg[i], VI_WORK_MODE_NORMAL);
    // VENC create
    printf("VENC create\n");
    cfg.session_cfg[i].stVenChn.enModId = RK_ID_VENC;
    cfg.session_cfg[i].stVenChn.s32ChnId = i;
    SAMPLE_COMMON_VENC_Start(&cfg.session_cfg[i]);
    if (i == DRAW_INDEX)
      RK_MPI_VI_StartStream(0, cfg.session_cfg[i].stViChn.s32ChnId);
    else
      RK_MPI_SYS_Bind(&cfg.session_cfg[i].stViChn,
                      &cfg.session_cfg[i].stVenChn);

    // rtsp video
    printf("rtsp video\n");
    switch (cfg.session_cfg[i].video_type) {
    case RK_CODEC_TYPE_H264:
      rtsp_set_video(cfg.session_cfg[i].session, RTSP_CODEC_ID_VIDEO_H264, NULL,
                     0);
      break;
    case RK_CODEC_TYPE_H265:
      rtsp_set_video(cfg.session_cfg[i].session, RTSP_CODEC_ID_VIDEO_H265, NULL,
                     0);
      break;
    default:
      printf("video codec not support.\n");
      break;
    }

    rtsp_sync_video_ts(cfg.session_cfg[i].session, rtsp_get_reltime(),
                       rtsp_get_ntptime());
  }

create_rknn_list 创建 rknn_list 列表。
在线程中调用 GetMediaBuffer 获取缓存并调用 rockx 进行检测跟踪。
另一线程中调用 MainStream 绘制结果。

  create_rknn_list(&rknn_list_);
  // Get the sub-stream buffer for humanoid recognition
  pthread_t read_thread;
  pthread_create(&read_thread, NULL, GetMediaBuffer, NULL);
  // The mainstream draws a box asynchronously based on the recognition result
  pthread_t main_stream_thread;
  pthread_create(&main_stream_thread, NULL, MainStream, NULL);

设置SIGINT信号的处理函数为 sig_proc。
调用 RK_MPI_SYS_GetMediaBuffer 获得 MEDIA_BUFFER。
rtsp_tx_video
RK_MPI_MB_ReleaseBuffer 释放缓存。
rtsp_do_event

  signal(SIGINT, sig_proc);
  while (g_flag_run) {
    for (int i = 0; i < cfg.session_count; i++) {
      MEDIA_BUFFER buffer;
      // send video buffer
      buffer = RK_MPI_SYS_GetMediaBuffer(
          RK_ID_VENC, cfg.session_cfg[i].stVenChn.s32ChnId, 0);
      if (buffer) {
        rtsp_tx_video(cfg.session_cfg[i].session, RK_MPI_MB_GetPtr(buffer),
                      RK_MPI_MB_GetSize(buffer),
                      RK_MPI_MB_GetTimestamp(buffer));
        RK_MPI_MB_ReleaseBuffer(buffer);
      }
    }
    rtsp_do_event(g_rtsplive);
  }

RK_MPI_SYS_UnBind 解除通道间的绑定。
RK_MPI_VI_DisableChn 关闭输入通道。
RK_MPI_VENC_DestroyChn 销毁编码通道。
rtsp_del_demo
destory_rknn_list

  for (int i = 0; i < cfg.session_count; i++) {
    if (i != DRAW_INDEX)
      RK_MPI_SYS_UnBind(&cfg.session_cfg[i].stViChn,
                        &cfg.session_cfg[i].stVenChn);
    RK_MPI_VI_DisableChn(0, cfg.session_cfg[i].stViChn.s32ChnId);
    RK_MPI_VENC_DestroyChn(cfg.session_cfg[i].stVenChn.s32ChnId);
  }
  rtsp_del_demo(g_rtsplive);
  destory_rknn_list(&rknn_list_);
  return 0;

load_cfg

cfg为全局变量，demo_cfg 类型，保存多个 Session 信息。MPP_CHN_S

  // cfgline:
  // path=%s video_type=%d width=%u height=%u
  FILE *fp = fopen(cfg_file, "r");
  char line[1024];
  int count = 0;

  if (!fp) {
    fprintf(stderr, "open %s failed\n", cfg_file);
    return -1;
  }

  memset(&cfg, 0, sizeof(cfg));
  while (fgets(line, sizeof(line) - 1, fp)) {
    const char *p;
    // char codec_type[20];
    memset(&cfg.session_cfg[count], 0, sizeof(cfg.session_cfg[count]));

    if (line[0] == '#')
      continue;
    p = strstr(line, "path=");
    if (!p)
      continue;
    if (sscanf(p, "path=%s", cfg.session_cfg[count].path) != 1)
      continue;

    if ((p = strstr(line, "video_type="))) {
      if (sscanf(p,
                 "video_type=%d width=%u height=%u image_type=%u video_path=%s",
                 &cfg.session_cfg[count].video_type,
                 &cfg.session_cfg[count].u32Width,
                 &cfg.session_cfg[count].u32Height,
                 &cfg.session_cfg[count].enImageType,
                 cfg.session_cfg[count].videopath) == 0) {
        printf("parse video file failed %s.\n", p);
      }
    }
    if (cfg.session_cfg[count].video_type != RK_CODEC_TYPE_NONE) {
      count++;
    } else {
      printf("parse line %s failed\n", line);
    }
  }
  cfg.session_count = count;
  fclose(fp);
  dump_cfg();
  return count;

RK_MPI_SYS_Init

LOG_INIT 初始化日志级别。
Reset_Channel_Table 初始化通道属性。

  LOG_INIT();

  Reset_Channel_Table(g_vi_chns, VI_MAX_CHN_NUM, RK_ID_VI);
  Reset_Channel_Table(g_venc_chns, VENC_MAX_CHN_NUM, RK_ID_VENC);
  Reset_Channel_Table(g_ai_chns, AI_MAX_CHN_NUM, RK_ID_AI);
  Reset_Channel_Table(g_aenc_chns, AENC_MAX_CHN_NUM, RK_ID_AENC);
  Reset_Channel_Table(g_ao_chns, AO_MAX_CHN_NUM, RK_ID_AO);
  Reset_Channel_Table(g_algo_md_chns, ALGO_MD_MAX_CHN_NUM, RK_ID_ALGO_MD);
  Reset_Channel_Table(g_algo_od_chns, ALGO_OD_MAX_CHN_NUM, RK_ID_ALGO_OD);
  Reset_Channel_Table(g_rga_chns, RGA_MAX_CHN_NUM, RK_ID_RGA);
  Reset_Channel_Table(g_adec_chns, ADEC_MAX_CHN_NUM, RK_ID_ADEC);
  Reset_Channel_Table(g_vo_chns, VO_MAX_CHN_NUM, RK_ID_VO);

  return RK_ERR_SYS_OK;

LOG_INIT

getenv 获取环境变量。
通过环境变量来设置日志级别。

  char *ptr = NULL;

  rkmedia_log_method = LOG_METHOD_PRINT;
#ifdef RKMEDIA_SUPPORT_MINILOG
  ptr = getenv("RKMEDIA_LOG_METHOD");
  if (ptr && strstr(ptr, "MINILOG")) {
    fprintf(stderr, "##RKMEDIA Method: MINILOG\n");
    __minilog_log_init("RKMEDIA", NULL, false, false, "RKMEDIA", "0.1");
    rkmedia_log_method = LOG_METHOD_MINILOG;
  } else {
    fprintf(stderr, "##RKMEDIA Method: PRINT\n");
    rkmedia_log_method = LOG_METHOD_PRINT;
  }
#endif //#ifdef RKMEDIA_SUPPORT_MINILOG

  ptr = getenv("RKMEDIA_LOG_LEVEL");
  if (ptr && strstr(ptr, "DBG")) {
    fprintf(stderr, "##RKMEDIA Log level: DBG\n");
    rkmedia_log_level = LOG_LEVEL_DBG;
  } else {
    fprintf(stderr, "##RKMEDIA Log level: INFO\n");
    rkmedia_log_level = LOG_LEVEL_INFO;
  }

SAMPLE_COMMON_VI_Start
SAMPLE_COMMON_VI_Start
RK_MPI_VI_SetChnAttr
RK_MPI_VI_EnableChn

RK_MPI_VI_SetChnAttr 设置全局变量g_vi_chns中对应的通道属性。
RK_MPI_VI_EnableChn 设置相应符号来启动通道。

  VI_CHN_ATTR_S vi_chn_attr;

  vi_chn_attr.u32BufCnt = 3;
  vi_chn_attr.u32Width = session->u32Width;
  vi_chn_attr.u32Height = session->u32Height;
  vi_chn_attr.enWorkMode = mode;
  vi_chn_attr.pcVideoNode = session->videopath;
  vi_chn_attr.enPixFmt = session->enImageType;

  RK_MPI_VI_SetChnAttr(0, session->stViChn.s32ChnId, &vi_chn_attr);
  RK_MPI_VI_EnableChn(0, session->stViChn.s32ChnId);

RK_MPI_VI_SetChnAttr

设置全局变量g_vi_chns中对应的通道属性。在通道关闭条件下才能设置。

  if ((ViPipe < 0) || (ViChn < 0) || (ViChn > VI_MAX_CHN_NUM))
    return -RK_ERR_VI_INVALID_CHNID;

  if (!pstChnAttr || !pstChnAttr->pcVideoNode)
    return -RK_ERR_VI_ILLEGAL_PARAM;

  g_vi_mtx.lock();
  if (g_vi_chns[ViChn].status != CHN_STATUS_CLOSED) {
    g_vi_mtx.unlock();
    return -RK_ERR_VI_BUSY;
  }

  memcpy(&g_vi_chns[ViChn].vi_attr.attr, pstChnAttr, sizeof(VI_CHN_ATTR_S));
  g_vi_chns[ViChn].status = CHN_STATUS_READY;
  g_vi_mtx.unlock();

  return RK_ERR_SYS_OK;

RK_MPI_VI_EnableChn

在CHN_STATUS_READY时可以启动。

  if ((ViPipe < 0) || (ViChn < 0) || (ViChn > VI_MAX_CHN_NUM))
    return -RK_ERR_VI_INVALID_CHNID;

  g_vi_mtx.lock();
  if (g_vi_chns[ViChn].status != CHN_STATUS_READY) {
    g_vi_mtx.unlock();
    return (g_vi_chns[ViChn].status > CHN_STATUS_READY) ? -RK_ERR_VI_EXIST
                                                        : -RK_ERR_VI_NOT_CONFIG;
  }

  LOG("\n%s %s: Enable VI[%d:%d]:%s, %dx%d Start...\n", LOG_TAG, __func__,
      ViPipe, ViChn, g_vi_chns[ViChn].vi_attr.attr.pcVideoNode,
      g_vi_chns[ViChn].vi_attr.attr.u32Width,
      g_vi_chns[ViChn].vi_attr.attr.u32Height);

PARAM_STRING_APPEND 追加键和字符值到字符串。
PARAM_STRING_APPEND_TO 追加数值。
JoinFlowParam 拼接参数。

  // Reading yuv from camera
  std::string flow_name = "source_stream";
  std::string flow_param;
  PARAM_STRING_APPEND(flow_param, KEY_NAME, "v4l2_capture_stream");
  std::string stream_param;
  PARAM_STRING_APPEND_TO(stream_param, KEY_USE_LIBV4L2, 1);
  PARAM_STRING_APPEND_TO(stream_param, KEY_CAMERA_ID, ViPipe);
  PARAM_STRING_APPEND(stream_param, KEY_DEVICE,
                      g_vi_chns[ViChn].vi_attr.attr.pcVideoNode);
  PARAM_STRING_APPEND(stream_param, KEY_V4L2_CAP_TYPE,
                      KEY_V4L2_C_TYPE(VIDEO_CAPTURE));
  if (g_vi_chns[ViChn].vi_attr.attr.enBufType == VI_CHN_BUF_TYPE_MMAP) {
    PARAM_STRING_APPEND(stream_param, KEY_V4L2_MEM_TYPE,
                        KEY_V4L2_M_TYPE(MEMORY_MMAP));
  } else {
    PARAM_STRING_APPEND(stream_param, KEY_V4L2_MEM_TYPE,
                        KEY_V4L2_M_TYPE(MEMORY_DMABUF));
  }
  PARAM_STRING_APPEND_TO(stream_param, KEY_FRAMES,
                         g_vi_chns[ViChn].vi_attr.attr.u32BufCnt);
  PARAM_STRING_APPEND(
      stream_param, KEY_OUTPUTDATATYPE,
      ImageTypeToString(g_vi_chns[ViChn].vi_attr.attr.enPixFmt));
  PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_WIDTH,
                         g_vi_chns[ViChn].vi_attr.attr.u32Width);
  PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_HEIGHT,
                         g_vi_chns[ViChn].vi_attr.attr.u32Height);
  flow_param = easymedia::JoinFlowParam(flow_param, 1, stream_param);
  LOGD("\n#VI: v4l2 source flow param:\n%s\n", flow_param.c_str());

REFLECTOR 宏添加相应前缀。FlowReflector::Create 创建一个 Flow 对象。
尝试3次。

  RK_S8 s8RetryCnt = 3;
  while (s8RetryCnt > 0) {
    g_vi_chns[ViChn].rkmedia_flow = easymedia::REFLECTOR(
        Flow)::Create<easymedia::Flow>(flow_name.c_str(), flow_param.c_str());
    if (g_vi_chns[ViChn].rkmedia_flow)
      break; // Stop while
    LOG("WARN: VI[%d]:\"%s\" buffer may be occupied by other modules or apps, "
        "try again...\n",
        ViChn, g_vi_chns[ViChn].vi_attr.attr.pcVideoNode);
    s8RetryCnt--;
    msleep(50);
  }

  if (!g_vi_chns[ViChn].rkmedia_flow) {
    g_vi_mtx.unlock();
    return -RK_ERR_VI_BUSY;
  }

RkmediaChnInitBuffer 设置相应通道缓存的符号。

  g_vi_chns[ViChn].luma_buf_mtx.lock();
  g_vi_chns[ViChn].luma_buf_quit = false;
  g_vi_chns[ViChn].luma_buf_start = false;
  g_vi_chns[ViChn].luma_buf_mtx.unlock();

  RkmediaChnInitBuffer(&g_vi_chns[ViChn]);
  g_vi_chns[ViChn].rkmedia_flow->SetOutputCallBack(&g_vi_chns[ViChn],
                                                   FlowOutputCallback);
  g_vi_chns[ViChn].status = CHN_STATUS_OPEN;

  g_vi_mtx.unlock();
  LOG("\n%s %s: Enable VI[%d:%d]:%s, %dx%d End...\n", LOG_TAG, __func__, ViPipe,
      ViChn, g_vi_chns[ViChn].vi_attr.attr.pcVideoNode,
      g_vi_chns[ViChn].vi_attr.attr.u32Width,
      g_vi_chns[ViChn].vi_attr.attr.u32Height);

  return RK_ERR_SYS_OK;

SAMPLE_COMMON_VENC_Start

设置属性并调整为就绪状态。

  if ((ViPipe < 0) || (ViChn < 0) || (ViChn > VI_MAX_CHN_NUM))
    return -RK_ERR_VI_INVALID_CHNID;

  if (!pstChnAttr || !pstChnAttr->pcVideoNode)
    return -RK_ERR_VI_ILLEGAL_PARAM;

  g_vi_mtx.lock();
  if (g_vi_chns[ViChn].status != CHN_STATUS_CLOSED) {
    g_vi_mtx.unlock();
    return -RK_ERR_VI_BUSY;
  }

  memcpy(&g_vi_chns[ViChn].vi_attr.attr, pstChnAttr, sizeof(VI_CHN_ATTR_S));
  g_vi_chns[ViChn].status = CHN_STATUS_READY;
  g_vi_mtx.unlock();

  return RK_ERR_SYS_OK;

RK_MPI_VI_StartStream

Flow::StartStream 中waite_down_flow拼错了。

  if ((ViPipe < 0) || (ViChn < 0) || (ViChn > VI_MAX_CHN_NUM))
    return -RK_ERR_VI_INVALID_CHNID;

  g_vi_mtx.lock();
  if (g_vi_chns[ViChn].status < CHN_STATUS_OPEN) {
    g_vi_mtx.unlock();
    return -RK_ERR_VI_BUSY;
  }

  if (!g_vi_chns[ViChn].rkmedia_flow) {
    g_vi_mtx.unlock();
    return -RK_ERR_VI_NOTREADY;
  }

  g_vi_chns[ViChn].rkmedia_flow->StartStream();
  g_vi_mtx.unlock();

  return RK_ERR_SYS_OK;

RK_MPI_SYS_Bind
RK_MPI_SYS_Bind
Flow::AddDownFlow
Flow::SetOutputCallBack

根据源通道的模式和 id 从相应数组中取出 Flow 对象。

  std::shared_ptr<easymedia::Flow> src;
  std::shared_ptr<easymedia::Flow> sink;
  RkmediaChannel *src_chn = NULL;
  RkmediaChannel *dst_chn = NULL;

  if (!pstSrcChn || !pstDestChn)
    return -RK_ERR_SYS_ILLEGAL_PARAM;

  LOG("\n%s %s: Bind Mode[%d]:Chn[%d] to Mode[%d]:Chn[%d]...\n", LOG_TAG,
      __func__, pstSrcChn->enModId, pstSrcChn->s32ChnId, pstDestChn->enModId,
      pstDestChn->s32ChnId);

  switch (pstSrcChn->enModId) {
  case RK_ID_VI:
    src = g_vi_chns[pstSrcChn->s32ChnId].rkmedia_flow;
    src_chn = &g_vi_chns[pstSrcChn->s32ChnId];
    break;
  case RK_ID_VENC:
    src = g_venc_chns[pstSrcChn->s32ChnId].rkmedia_flow;
    src_chn = &g_venc_chns[pstSrcChn->s32ChnId];
    break;
  case RK_ID_AI:
    src = g_ai_chns[pstSrcChn->s32ChnId].rkmedia_flow;
    src_chn = &g_ai_chns[pstSrcChn->s32ChnId];
    break;
  case RK_ID_AENC:
    src = g_aenc_chns[pstSrcChn->s32ChnId].rkmedia_flow;
    src_chn = &g_aenc_chns[pstSrcChn->s32ChnId];
    break;
  case RK_ID_RGA:
    src = g_rga_chns[pstSrcChn->s32ChnId].rkmedia_flow;
    src_chn = &g_rga_chns[pstSrcChn->s32ChnId];
    break;
  case RK_ID_ADEC:
    src = g_adec_chns[pstSrcChn->s32ChnId].rkmedia_flow;
    src_chn = &g_adec_chns[pstSrcChn->s32ChnId];
    break;
  default:
    return -RK_ERR_SYS_NOT_SUPPORT;
  }

  if ((src_chn->status < CHN_STATUS_OPEN) || (!src)) {
    LOG("ERROR: %s Src Mode[%d]:Chn[%d] is not ready!\n", __func__,
        pstSrcChn->enModId, pstSrcChn->s32ChnId);
    return -RK_ERR_SYS_NOTREADY;
  }

  switch (pstDestChn->enModId) {
  case RK_ID_VENC:
    sink = g_venc_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_venc_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_AO:
    sink = g_ao_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_ao_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_AENC:
    sink = g_aenc_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_aenc_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_ALGO_MD:
    sink = g_algo_md_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_algo_md_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_ALGO_OD:
    sink = g_algo_od_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_algo_od_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_RGA:
    sink = g_rga_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_rga_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_ADEC:
    sink = g_adec_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_adec_chns[pstDestChn->s32ChnId];
    break;
  case RK_ID_VO:
    sink = g_vo_chns[pstDestChn->s32ChnId].rkmedia_flow;
    dst_chn = &g_vo_chns[pstDestChn->s32ChnId];
    break;
  default:
    return -RK_ERR_SYS_NOT_SUPPORT;
  }

  if ((dst_chn->status < CHN_STATUS_OPEN) || (!sink)) {
    LOG("ERROR: %s Dst Mode[%d]:Chn[%d] is not ready!\n", __func__,
        pstDestChn->enModId, pstDestChn->s32ChnId);
    return -RK_ERR_SYS_NOTREADY;
  }

Flow::AddDownFlow 绑定流。
Flow::SetOutputCallBack 设置输出的回调函数。

  // Rkmedia flow bind
  src->AddDownFlow(sink, 0, 0);
  // Generally, after the previous Chn is bound to the next stage,
  // FlowOutputCallback will be disabled.Because the VI needs to calculate
  // the brightness, the VI still retains the FlowOutputCallback after
  // binding the lower-level Chn.
  if (src_chn->mode_id != RK_ID_VI)
    src->SetOutputCallBack(NULL, NULL);

  // change status frome OPEN to BIND.
  src_chn->status = CHN_STATUS_BIND;
  src_chn->bind_ref++;
  dst_chn->status = CHN_STATUS_BIND;
  dst_chn->bind_ref++;

  return RK_ERR_SYS_OK;

GetMediaBuffer

Created with Raphaël 2.3.0 GetMediaBuffer rockx_create_config rockx_add_config rockx_create RK_MPI_SYS_GetMediaBuffer RK_MPI_MB_GetSize RK_MPI_MB_GetPtr rockx_person_detect rockx_object_track RK_MPI_MB_ReleaseBuffer rockx_image_release rockx_destroy End

从会话中获取帧尺寸，默认格式为 NV12。
librockx.so中会有其运行时路径信息。

  printf("#Start %s thread, arg:%p\n", __func__, arg);
  // rockx
  rockx_ret_t rockx_ret;
  rockx_handle_t object_det_handle;
  rockx_image_t input_image;
  input_image.height = cfg.session_cfg[RK_NN_INDEX].u32Height;
  input_image.width = cfg.session_cfg[RK_NN_INDEX].u32Width;
  input_image.pixel_format = ROCKX_PIXEL_FORMAT_YUV420SP_NV12;
  input_image.is_prealloc_buf = 1;
  // create a object detection handle
  rockx_config_t *config = rockx_create_config();
  rockx_add_config(config, ROCKX_CONFIG_RKNN_RUNTIME_PATH,
                   RKNN_RUNTIME_LIB_PATH);
  rockx_ret = rockx_create(&object_det_handle, ROCKX_MODULE_PERSON_DETECTION_V2,
                           config, sizeof(rockx_config_t));
  if (rockx_ret != ROCKX_RET_SUCCESS) {
    printf("init rockx module ROCKX_MODULE_PERSON_DETECTION_V2 error %d\n",
           rockx_ret);
    return NULL;
  }
  printf("ROCKX_MODULE_PERSON_DETECTION_V2 rockx_create success\n");
  // create rockx_object_array_t for store result
  rockx_object_array_t person_array;
  memset(&person_array, 0, sizeof(person_array));

  // create a object track handle
  rockx_handle_t object_track_handle;
  rockx_ret =
      rockx_create(&object_track_handle, ROCKX_MODULE_OBJECT_TRACK, NULL, 0);
  if (rockx_ret != ROCKX_RET_SUCCESS) {
    printf("init rockx module ROCKX_MODULE_OBJECT_DETECTION error %d\n",
           rockx_ret);
  }

调用 RK_MPI_SYS_GetMediaBuffer 获得 MEDIA_BUFFER。
RK_MPI_MB_GetSize 获取大小。
RK_MPI_MB_GetPtr 获取虚拟指针。
getCurrentTimeMsec 记录当前时间，实现略繁琐。
跟踪功能不需要图像。
RK_MPI_MB_ReleaseBuffer 释放帧缓存。

  MEDIA_BUFFER buffer = NULL;
  while (g_flag_run) {
    buffer = RK_MPI_SYS_GetMediaBuffer(RK_ID_VI, RK_NN_INDEX, -1);
    if (!buffer) {
      continue;
    }

    // printf("Get Frame:ptr:%p, fd:%d, size:%zu, mode:%d, channel:%d, "
    //        "timestamp:%lld\n",
    //        RK_MPI_MB_GetPtr(buffer), RK_MPI_MB_GetFD(buffer),
    //        RK_MPI_MB_GetSize(buffer),
    //        RK_MPI_MB_GetModeID(buffer), RK_MPI_MB_GetChannelID(buffer),
    //        RK_MPI_MB_GetTimestamp(buffer));
    input_image.size = RK_MPI_MB_GetSize(buffer);
    input_image.data = RK_MPI_MB_GetPtr(buffer);
    // detect object
    long nn_before_time = getCurrentTimeMsec();
    rockx_ret = rockx_person_detect(object_det_handle, &input_image,
                                    &person_array, NULL);
    if (rockx_ret != ROCKX_RET_SUCCESS)
      printf("rockx_person_detect error %d\n", rockx_ret);
    long nn_after_time = getCurrentTimeMsec();
    printf("Algorithm time-consuming is %ld\n",
           (nn_after_time - nn_before_time));
    // printf("person_array.count is %d\n", person_array.count);

    rockx_object_array_t out_track_objects;
    rockx_ret = rockx_object_track(object_track_handle, input_image.width,
                                   input_image.height, 10, &person_array,
                                   &out_track_objects);
    if (rockx_ret != ROCKX_RET_SUCCESS)
      printf("rockx_object_track error %d\n", rockx_ret);
    // process result
    if (person_array.count > 0) {
      rknn_list_push(rknn_list_, getCurrentTimeMsec(), person_array);
      int size = rknn_list_size(rknn_list_);
      if (size >= MAX_RKNN_LIST_NUM)
        rknn_list_drop(rknn_list_);
      // printf("size is %d\n", size);
    }
    RK_MPI_MB_ReleaseBuffer(buffer);
  }
  // release
  rockx_image_release(&input_image);
  rockx_destroy(object_track_handle);
  rockx_destroy(object_det_handle);

  return NULL;

RK_MPI_SYS_GetMediaBuffer
RK_MPI_SYS_GetMediaBuffer
RkmediaChnPopBuffer

根据模式从相应的通道数组中取出 RkmediaChannel

  RkmediaChannel *target_chn = NULL;

  switch (enModID) {
  case RK_ID_VI:
    if (s32ChnID < 0 || s32ChnID >= VI_MAX_CHN_NUM) {
      LOG("ERROR: %s invalid VI ChnID[%d]\n", __func__, s32ChnID);
      return NULL;
    }
    target_chn = &g_vi_chns[s32ChnID];
    break;
  case RK_ID_VENC:
    if (s32ChnID < 0 || s32ChnID >= VENC_MAX_CHN_NUM) {
      LOG("ERROR: %s invalid AENC ChnID[%d]\n", __func__, s32ChnID);
      return NULL;
    }
    target_chn = &g_venc_chns[s32ChnID];
    break;
  case RK_ID_AI:
    if (s32ChnID < 0 || s32ChnID >= AI_MAX_CHN_NUM) {
      LOG("ERROR: %s invalid AI ChnID[%d]\n", __func__, s32ChnID);
      return NULL;
    }
    target_chn = &g_ai_chns[s32ChnID];
    break;
  case RK_ID_AENC:
    if (s32ChnID < 0 || s32ChnID > AENC_MAX_CHN_NUM) {
      LOG("ERROR: %s invalid AENC ChnID[%d]\n", __func__, s32ChnID);
      return NULL;
    }
    target_chn = &g_aenc_chns[s32ChnID];
    break;
  case RK_ID_RGA:
    if (s32ChnID < 0 || s32ChnID > RGA_MAX_CHN_NUM) {
      LOG("ERROR: %s invalid RGA ChnID[%d]\n", __func__, s32ChnID);
      return NULL;
    }
    target_chn = &g_rga_chns[s32ChnID];
    break;
  case RK_ID_ADEC:
    if (s32ChnID < 0 || s32ChnID > ADEC_MAX_CHN_NUM) {
      LOG("ERROR: %s invalid RGA ChnID[%d]\n", __func__, s32ChnID);
      return NULL;
    }
    target_chn = &g_adec_chns[s32ChnID];
    break;
  default:
    LOG("ERROR: %s invalid modeID[%d]\n", __func__, enModID);
    return NULL;
  }

  if (target_chn->status < CHN_STATUS_OPEN) {
    LOG("ERROR: %s Mode[%d]:Chn[%d] in status[%d], "
        "this operation is not allowed!\n",
        __func__, enModID, s32ChnID, target_chn->status);
    return NULL;
  }

RkmediaChnPopBuffer 从缓存列表中取头元素。

  return RkmediaChnPopBuffer(target_chn, s32MilliSec);

RkmediaChnPopBuffer

RkmediaPopPipFd 读取指定的 fd。

  if (!ptrChn)
    return NULL;

  std::unique_lock<std::mutex> lck(ptrChn->buffer_mtx);
  if (ptrChn->buffer_list.empty()) {
    if (s32MilliSec < 0 && !ptrChn->buffer_cond_quit) {
      ptrChn->buffer_cond.wait(lck);
    } else if (s32MilliSec > 0) {
      if (ptrChn->buffer_cond.wait_for(
              lck, std::chrono::milliseconds(s32MilliSec)) ==
          std::cv_status::timeout) {
        LOG("INFO: %s: Mode[%d]:Chn[%d] get mediabuffer timeout!\n", __func__,
            ptrChn->mode_id, ptrChn->chn_id);
        return NULL;
      }
    } else {
      return NULL;
    }
  }

  MEDIA_BUFFER mb = NULL;
  if (!ptrChn->buffer_list.empty()) {
    if (ptrChn->wake_fd[0] > 0)
      RkmediaPopPipFd(ptrChn->wake_fd[0]);
    mb = ptrChn->buffer_list.front();
    ptrChn->buffer_list.pop_front();
  }

  return mb;

RK_MPI_MB_GetSize

内部类型为 MEDIA_BUFFER_IMPLE

  if (!mb)
    return 0;

  MEDIA_BUFFER_IMPLE *mb_impl = (MEDIA_BUFFER_IMPLE *)mb;
  return mb_impl->size;

RK_MPI_MB_GetPtr

  if (!mb)
    return NULL;

  MEDIA_BUFFER_IMPLE *mb_impl = (MEDIA_BUFFER_IMPLE *)mb;
  return mb_impl->ptr;

RK_MPI_MB_ReleaseBuffer

  MEDIA_BUFFER_IMPLE *mb_impl = (MEDIA_BUFFER_IMPLE *)mb;
  if (!mb)
    return -RK_ERR_SYS_ILLEGAL_PARAM;

  if (mb_impl->rkmedia_mb)
    mb_impl->rkmedia_mb.reset();

  delete mb_impl;
  return RK_ERR_SYS_OK;

MainStream

Created with Raphaël 2.3.0 MainStream RK_MPI_SYS_GetMediaBuffer rknn_list_size rknn_list_pop RK_MPI_MB_GetPtr nv12_border RK_MPI_SYS_SendMediaBuffer RK_MPI_MB_ReleaseBuffer End

计算横纵坐标的缩放系数。

  MEDIA_BUFFER buffer;
  float x_rate = (float)cfg.session_cfg[DRAW_INDEX].u32Width /
                 (float)cfg.session_cfg[RK_NN_INDEX].u32Width;
  float y_rate = (float)cfg.session_cfg[DRAW_INDEX].u32Height /
                 (float)cfg.session_cfg[RK_NN_INDEX].u32Height;
  printf("x_rate is %f, y_rate is %f\n", x_rate, y_rate);

调用 RK_MPI_SYS_GetMediaBuffer 获得 MEDIA_BUFFER。

rknn_list_size 返回列表大小。
rknn_list_pop 弹出队列的首元素。
计算显示帧上的矩形框，nv12_border 绘制。
RK_MPI_SYS_SendMediaBuffer
RK_MPI_MB_ReleaseBuffer

  while (g_flag_run) {
    buffer = RK_MPI_SYS_GetMediaBuffer(
        RK_ID_VI, cfg.session_cfg[DRAW_INDEX].stViChn.s32ChnId, -1);
    if (!buffer)
      continue;
    // draw
    if (rknn_list_size(rknn_list_)) {
      long time_before;
      rockx_object_array_t person_array;
      memset(&person_array, 0, sizeof(person_array));
      rknn_list_pop(rknn_list_, &time_before, &person_array);
      // printf("time interval is %ld\n", getCurrentTimeMsec() - time_before);

      for (int j = 0; j < person_array.count; j++) {
        // printf("person_array.count is %d\n", person_array.count);
        // const char *cls_name =
        // OBJECT_DETECTION_LABELS_91[person_array.object[j].cls_idx];
        // int left = person_array.object[j].box.left;
        // int top = person_array.object[j].box.top;
        // int right = person_array.object[j].box.right;
        // int bottom = person_array.object[j].box.bottom;
        // float score = person_array.object[j].score;
        // printf("box=(%d %d %d %d) cls_name=%s, score=%f\n", left, top, right,
        // bottom, cls_name, score);

        int x = person_array.object[j].box.left * x_rate;
        int y = person_array.object[j].box.top * y_rate;
        int w = (person_array.object[j].box.right -
                 person_array.object[j].box.left) *
                x_rate;
        int h = (person_array.object[j].box.bottom -
                 person_array.object[j].box.top) *
                y_rate;
        if (x < 0)
          x = 0;
        if (y < 0)
          y = 0;
        while ((uint32_t)(x + w) >= cfg.session_cfg[DRAW_INDEX].u32Width) {
          w -= 16;
        }
        while ((uint32_t)(y + h) >= cfg.session_cfg[DRAW_INDEX].u32Height) {
          h -= 16;
        }
        printf("border=(%d %d %d %d)\n", x, y, w, h);
        nv12_border((char *)RK_MPI_MB_GetPtr(buffer),
                    cfg.session_cfg[DRAW_INDEX].u32Width,
                    cfg.session_cfg[DRAW_INDEX].u32Height, x, y, w, h, 0, 0,
                    255);
      }
    }
    // send from VI to VENC
    RK_MPI_SYS_SendMediaBuffer(
        RK_ID_VENC, cfg.session_cfg[DRAW_INDEX].stVenChn.s32ChnId, buffer);
    RK_MPI_MB_ReleaseBuffer(buffer);
  }

  return NULL;

nv12_border

颜色转换成 YUV 值，填充4个内壁。

  /* Set up the rectangle border size */
  const int border = 5;

  /* RGB convert YUV */
  int Y, U, V;
  Y = 0.299 * R + 0.587 * G + 0.114 * B;
  U = -0.1687 * R + 0.3313 * G + 0.5 * B + 128;
  V = 0.5 * R - 0.4187 * G - 0.0813 * B + 128;
  /* Locking the scope of rectangle border range */
  int j, k;
  for (j = rect_y; j < rect_y + rect_h; j++) {
    for (k = rect_x; k < rect_x + rect_w; k++) {
      if (k < (rect_x + border) || k > (rect_x + rect_w - border) ||
          j < (rect_y + border) || j > (rect_y + rect_h - border)) {
        /* Components of YUV's storage address index */
        int y_index = j * pic_w + k;
        int u_index =
            (y_index / 2 - pic_w / 2 * ((j + 1) / 2)) * 2 + pic_w * pic_h;
        int v_index = u_index + 1;
        /* set up YUV's conponents value of rectangle border */
        pic[y_index] = Y;
        pic[u_index] = U;
        pic[v_index] = V;
      }
    }
  }

  return 0;

RK_MPI_SYS_SendMediaBuffer

RkmediaChannel
获得目标通道和锁。

  RkmediaChannel *target_chn = NULL;
  std::mutex *target_mutex = NULL;

  switch (enModID) {
  case RK_ID_VENC:
    if (s32ChnID < 0 || s32ChnID >= VENC_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_venc_chns[s32ChnID];
    target_mutex = &g_venc_mtx;
    break;
  case RK_ID_AENC:
    if (s32ChnID < 0 || s32ChnID > AENC_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_aenc_chns[s32ChnID];
    target_mutex = &g_aenc_mtx;
    break;
  case RK_ID_ALGO_MD:
    if (s32ChnID < 0 || s32ChnID > ALGO_MD_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_algo_md_chns[s32ChnID];
    target_mutex = &g_algo_md_mtx;
    break;
  case RK_ID_ALGO_OD:
    if (s32ChnID < 0 || s32ChnID > ALGO_OD_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_algo_od_chns[s32ChnID];
    target_mutex = &g_algo_od_mtx;
    break;
  case RK_ID_ADEC:
    if (s32ChnID < 0 || s32ChnID > ADEC_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_adec_chns[s32ChnID];
    target_mutex = &g_adec_mtx;
    break;
  case RK_ID_AO:
    if (s32ChnID < 0 || s32ChnID > AO_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_ao_chns[s32ChnID];
    target_mutex = &g_ao_mtx;
    break;
  case RK_ID_RGA:
    if (s32ChnID < 0 || s32ChnID > RGA_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_rga_chns[s32ChnID];
    target_mutex = &g_rga_mtx;
    break;
  case RK_ID_VO:
    if (s32ChnID < 0 || s32ChnID > VO_MAX_CHN_NUM)
      return -RK_ERR_SYS_ILLEGAL_PARAM;
    target_chn = &g_vo_chns[s32ChnID];
    target_mutex = &g_vo_mtx;
    break;
  default:
    return -RK_ERR_SYS_NOT_SUPPORT;
  }

Flow::SendInput

  MEDIA_BUFFER_IMPLE *mb = (MEDIA_BUFFER_IMPLE *)buffer;
  target_mutex->lock();
  if (target_chn->rkmedia_flow) {
    target_chn->rkmedia_flow->SendInput(mb->rkmedia_mb, 0);
  } else {
    target_mutex->unlock();
    return -RK_ERR_SYS_NOT_PERM;
  }

  target_mutex->unlock();
  return RK_ERR_SYS_OK;

参考资料：

图波列夫
关注
  • 2
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
RTSP服务传送音视频演示Demo源码
12-30
建立RTSP标准协议传送服务，解析SDP信息，传送H264+AAC音视频数据流。 支持VLC点播。注意：点播节目名称默认为live，举例：“rtsp://service ip/live"。 源码支持H264\H263\MP4V\AAC\MP4A\MP4ALatm\AMR等数据格式，演示Demo仅实现了H264+AAC文件解析。 主要解析部分代码参考自VLC、Live555、FFMPEG。
瑞芯微关于RKMEDIA框架的RKNN例子解析（二）
ff94315的博客
02-15 1571
总的来说，就是模型加载后一直循环，取VI的帧数据，这边有点不解，为啥在RGA有能力处理颜色转换的情况下要用软件处理？我想过内存拷贝速度的问题，但是应该软件和硬件处理没啥速度上的区别，有大佬清楚原因不？这部分代码我就不写注释了，大家先看英文注释吧，我在这理一下这部分做了什么。接上回，接下来就到了大家关心的RKNN部分的操作啦，接下来看代码。
rkmedia使用记录
最新发布
qq_39200110的博客
02-07 439
【代码】rkmedia使用记录。
RKmedia测试程序
09-02
RKmedia测试程序
基于瑞芯微RKmedia开发的人脸和车牌识别的SDK及使用说明.7z
12-13
基于RKmedia的人脸和车牌识别的SDK及使用说明.7z 人脸检测&识别 对于人脸部分，SDK 提供了以下能力： 人脸检测 1.1 人脸是否带口罩判定 1.2 人脸角度检测 人脸识别 2.1 1:1 识别 2.2 1:N 识别 用户重识别 对于车牌部分，SDK 提供了以下能力： 车辆检测 车牌检测（蓝牌、绿牌、黄牌[含双层黄牌]、白牌、黑牌等） 车牌识别
uvc_mjpeg_test_tool.zip
07-13
UVC 循环获取所以mjpeg格式,并拍照保存,内附readme,告之如何修改
OV7725调试笔记
07-18
最近一阵子在调试OV7725摄像头！ 摄像头的调试花费的时间太长了，大概用了两个星期，然而实际上解决问题，最主要是靠几天前晚上那张时序图。
训练自己的yolov5样本, 并部署到rv1126 ＜四＞
zunly的博客
12-06 1803
将yolov5部署到rv1126，并通过rtsp观看效果
【正点原子Linux连载】第五章 RKMedia编译和使用 摘自【正点原子】ATK-DLRV1126系统开发手册
weixin_55796564的博客
02-03 3508
1）实验平台：正点原子RV1126 Linux开发板 2）平台购买地址：https://detail.tmall.com/item.htm?id=692176265749 3）全套实验源码+手册+视频下载地址： http://www.openedv.com/thread-340252-1-1.html5.1 RKMedia编译 Rkmedia是RK官方封装一层简易的API，把RGA、MPP、RKNN等等这些接口封装成高级的接口。在SDK官方的源码目录下，运行以下命令进行跳转： cd external/rkm
训练自己的yolov5样本, 并部署到rv1126 ＜五＞
zunly的博客
12-06 1645
将yolov5的模型推理部署到rv1126
rkmedia的视频采集、编码、推流与保存以及相关API和例程解析
qq_58288010的博客
12-15 1842
RKMedia的作用包括采集音频数据（PCM格式）、对音频进行编码（AAC格式）、采集视频数据（YUV或NV12格式）、对视频进行编码（YUV转H264格式）等。此外，RKMedia还可以进行视频裁剪、检测摄像头是否有遮挡、视频合成、视频分解、视频录制等操作。在RKMedia中，还有一些专用的名词，如VI（视频采集通道）、VENC（视频编码）、VDEC（视频解码）、AI（音频采集）、AO（音频输出）、AENC（音频编码）、ADEC（音频解码）和MD（移动侦测）。通过RKMedia，开发者可以方便地进行音视频
基于rkmedia API实现视频H264编码运行瑞芯微RV1126源码(带操作说明).zip
06-01
基于rkmedia API实现视频H264编码运行瑞芯微RV1126源码(带操作说明).zip 【概述】 本程序参考 RV1109/RV1126 SDK 中的 external/rkmedia/examples 代码，演示使用 rkmedia API 做视频编码处理的流程。在 RV1109/RV1126 板子运行此程序，将持续从摄像头获取数据，编码为H.264，并写入文件中；当按下 ctrl+c 时程序终止运行并退出。 【编译】 可在 Rockchip RV1109/RV1126 SDK 的 buildroot 编译此程序。 【运行】 demo_h264_rkmedia 最终被安装到系统的 /usr/bin 目录，重新打包根文件系统固件并烧录可在设备运行程序。 也可以直接从 buildroot/output 中将 demo_h264_rkmedia 复制出来，使用 adb 或者其他方法把 demo_h264_rkmedia 放置到设备上。
rkmedia 调试笔记
热门推荐
Yumin's Blog
11-23 1万+
RKMedia 是 Rockchip 在 RV1109/RV1126 上推出的新一代音视频开发框架。RKMedia提供了一种媒体处理方案，可支持应用软件快速开发。RKMedia在各模块基础API上做进一步封装，简化了应用开发难度。
关于RV1126开发板 摄像头数据在qt显示
qq_37797583的博客
01-13 1192
rv1126开发板获取摄像头图像在qt显示
【边缘设备】yolov5训练与rknn模型导出并在RK3588部署~1.环境准备（亲测有效）
08-16 2298
在翻阅了网络上很多资料后，发现很多版本的信息比匹配。花了一周的时间配置环境，以及环境验证，然后写了这篇长文。有过程，有代码，有经验，欢迎大家批评指正。
海思3559 sample解析：venc
快跑Bug来啦！
06-25 2363
  分析完vio的例程后瞬间信心满满，自信的去找大佬请求分配任务了，“简简单单”几个步骤，照着葫芦画瓢，调调参数，对应位置具体分析具体修改，美好光明的“大路”清晰明朗啊！   年轻人，too young too naive啊要真是这么简单，用芯片大炮打蚊子吗？   可是看起来就是很简单啊，属性挨个配置，一绑定，巴拉巴拉   那如果不绑定呢？需要自己加算法修改呢?怎么获取图像，怎么输出？假如要做个人脸识别呢？ 有没有感觉到越简单的流程好像越不自由，很多都没法自己掌控，想自己随需求修改的更多，自然就没那么容
瑞芯微关于RKMEDIA框架的RKNN例子解析（一）
ff94315的博客
02-15 1897
对于熟悉海思开发框架的亲们来说，入门rk的rkmedia框架并不难，甚至可以说只要简单熟悉下API就行，因为开发的思路基本都一样，都是基于模块、通道的，并且参数很多也是傻瓜化配置，并不像海思一样各个参数都需要精准配置，例程相对来说也比海思要好读。第一步就是找到main函数，前面一大堆杂七杂八的入参解析暂时先不看，找到初始化vi的部分（前面的初始化rtsp服务的后面再说）接下来开启vi的采集，并把venc通道bind上vi，然后就是杂七杂八初始化RTSP服务器，第一条通道就这么建好了。
rkmedia的使用
Linux驱动相关内容及Android开发
11-29 986
RKMedia的核心思想是把各个硬件资源独立成模块，模块开放出输入和输出端通过绑定的方式控制流从某个模块流出并且流入另外一个模块一般由sensor传到CIF处理得到raw数据，如果需要ISP模块处理，就要再继续转交到ISP 和ISPP得到最终的YUV数据。代码目录：external/rkmedia/examples/本文以rkmedia_vi_vo_test.c为例，还有许多的例程，大家可以自行研究。具体地解释一下代码的功能。
RKMEDIA使用简介
未定的博客
11-29 3860
rv1126/rv1109 rkmedia使用介绍
rkmedia rkmpp
08-20
rkmedia是 Rockchip 公司自主研发的一款媒体服务框架，它提供了基于硬件加速的音视频处理能力，能够满足多媒体应用的需求。rkmedia支持多个音视频编解码格式，包括H.264、H.265、VP9等，能够实现高效的多媒体数据处理。 而rkmpp则是Rockchip公司为处理媒体数据而开发的多媒体框架，它使用了硬件加速的方式，提供了高效的图像和视频处理能力。rkmpp支持多种图像和视频处理操作，如图像旋转、缩放、色彩空间转换、视频编解码等，可以满足各种多媒体应用的需求。 使用rkmedia和rkmpp，我们可以实现高效的多媒体数据处理和应用开发。比如，我们可以利用rkmedia和rkmpp来开发音视频播放器、图像处理应用、视频编辑软件等。同时，rkmedia和rkmpp还可以提供硬件加速的能力，提高多媒体应用的性能和效率。 总之，rkmedia和rkmpp是Rockchip公司提供的用于处理多媒体数据的框架和工具，它们提供了高效的音视频和图像处理能力，可以用于开发各种多媒体应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值