本文讲述如何使用RKNN SDK，如何将转换成RKLLM格式部署到RK3576/RK3588上利用NPU进行硬件加速推理。
一、开发环境
1、硬件平台：
- SoC: Rockchip RK3588S
- CPU: Quad-core ARM Cortex-A76(up to 2.4GHz) and quad-core Cortex-A55 CPU (up to 1.8GHz)
- GPU: Mali-G610 MP4, compatible with OpenGLES 1.1, 2.0, and 3.2, OpenCL up to 2.2 and Vulkan1.2
- VPU: 8K@60fps H.265 and VP9 decoder, 8K@30fps H.264 decoder, 4K@60fps AV1 decoder, 8K@30fps H.264 and H.265 encoder
- NPU: 6TOPs, supports INT4/INT8/INT16/FP16
- RAM: 64-bit 8GB LPDDR4X at 2133MHz
- Flash: 32GB eMMC, at HS400 mode
2、软件平台：
操作系统：debian-bullseye-desktop-arm64
NPU 驱动版本
$ sudo cat /sys/kernel/debug/rknpu/version
RKNPU driver: v0.8.2二、运行RKNN示例程序
1、下载并安装RKNN运行时库
cd ~
export GIT_SSL_NO_VERIFY=1
git clone https://github.com/airockchip/rknn-toolkit2.git
cd rknn-toolkit2/rknpu2
sudo cp ./runtime/Linux/librknn_api/aarch64/* /usr/lib
sudo cp ./runtime/Linux/rknn_server/aarch64/usr/bin/* /usr/bin/
sudo cp ./runtime/Linux/librknn_api/include/* /usr/include/2、检查rknn版本
$ strings /usr/bin/rknn_server |grep 'build@'
$ strings /usr/lib/librknnrt.so |grep 'librknnrt version:'
3、安装C++编译环境
#安装编译工具
sudo apt-get update
sudo apt-get install -y gcc g++ make cmake
#设置链接库
cd ~/rknn-toolkit2/rknpu2/examples/3rdparty/mpp/Linux/aarch64
rm -f librockchip_mpp.so librockchip_mpp.so.1
ln -s librockchip_mpp.so.0 librockchip_mpp.so
ln -s librockchip_mpp.so.0 librockchip_mpp.so.1
#设置编译环境及编译程序
cd ~/rknn-toolkit2/rknpu2/examples/rknn_yolov5_demo
chmod +x ./build-linux.sh
sudo ln -s /usr/bin/gcc /usr/bin/aarch64-gcc
sudo ln -s /usr/bin/g++ /usr/bin/aarch64-g++
export GCC_COMPILER=aarch64
./build-linux.sh -t rk3588 -a aarch64 -b Release
cd install/rknn_yolov5_demo_Linux4、运行YOLOv5图片示例
测试程序目录：
rknn-toolkit2/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux
rockchip官方测试程序源码不需要修改，直接运行。
#运行测试程序
./rknn_yolov5_demo model/RK3588/yolov5s-640-640.rknn model/test.jpg原测试目录中有bus.jpeg的图片，如要测试其他图片自行上传到对应目录。
5、运行YOLOv5视频示例
测试程序目录：
rknn-toolkit2/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux
测试程序运行参数要求：
Usage: ./rknn_yolov5_video_demo <rknn_model> <video_path> <video_type 264/265>
rockchip官方测试程序对输入的视频文件只有终端的文字输出，如果要视频显示画面输出源码需要修改添加opencv输出显示功能。
测试源文件目录：rknn-toolkit2/rknpu2/examples/rknn_yolov5_demo/src
安装opencv开发环境：
sudo apt install libopencv-dev opencv-data pkg-config -ymain_video源文件：
// Copyright (c) 2023 by Rockchip Electronics Co., Ltd. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*-------------------------------------------
Includes
-------------------------------------------*/
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
// +++ 添加显示功能：引入OpenCV头文件 +++
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "im2d.h"
#include "rga.h"
#include "RgaUtils.h"
#include "rknn_api.h"
#include "postprocess.h"
#include "utils/mpp_decoder.h"
#include "utils/mpp_encoder.h"
#include "utils/drawing.h"
#if defined(BUILD_VIDEO_RTSP)
#include "mk_mediakit.h"
#endif
#define OUT_VIDEO_PATH "out.h264"
// +++ 添加显示功能：定义显示窗口名称 +++
#define DISPLAY_WINDOW_NAME "RKNN YOLOv5 Video Detection"
typedef struct
{
rknn_context rknn_ctx;
rknn_input_output_num io_num;
rknn_tensor_attr *input_attrs;
rknn_tensor_attr *output_attrs;
int model_channel;
int model_width;
int model_height;
FILE *out_fp;
MppDecoder *decoder;
MppEncoder *encoder;
} rknn_app_context_t;
typedef struct
{
int width;
int height;
int width_stride;
int height_stride;
int format;
char *virt_addr;
int fd;
} image_frame_t;
/*-------------------------------------------
Functions
-------------------------------------------*/
static void dump_tensor_attr(rknn_tensor_attr *attr)
{
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, "
"zp=%d, scale=%f\n",
attr->index, attr->name, attr->n_dims, attr->dims[0], attr->dims[1], attr->dims[2], attr->dims[3],
attr->n_elems, attr->size, get_format_string(attr->fmt), get_type_string(attr->type),
get_qnt_type_string(attr->qnt_type), attr->zp, attr->scale);
}
double __get_us(struct timeval t) { return (t.tv_sec * 1000000 + t.tv_usec); }
static unsigned char *load_data(FILE *fp, size_t ofst, size_t sz)
{
unsigned char *data;
int ret;
data = NULL;
if (NULL == fp)
{
return NULL;
}
ret = fseek(fp, ofst, SEEK_SET);
if (ret != 0)
{
printf("blob seek failure.\n");
return NULL;
}
data = (unsigned char *)malloc(sz);
if (data == NULL)
{
printf("buffer malloc failure.\n");
return NULL;
}
ret = fread(data, 1, sz, fp);
return data;
}
static unsigned char *read_file_data(const char *filename, int *model_size)
{
FILE *fp;
unsigned char *data;
fp = fopen(filename, "rb");
if (NULL == fp)
{
printf("Open file %s failed.\n", filename);
return NULL;
}
fseek(fp, 0, SEEK_END);
int size = ftell(fp);
data = load_data(fp, 0, size);
fclose(fp);
*model_size = size;
return data;
}
static int write_data_to_file(const char *path, char *data, unsigned int size)
{
FILE *fp;
fp = fopen(path, "w");
if (fp == NULL)
{
printf("open error: %s", path);
return -1;
}
fwrite(data, 1, size, fp);
fflush(fp);
fclose(fp);
return 0;
}
static int init_model(const char *model_path, rknn_app_context_t *app_ctx)
{
int ret;
rknn_context ctx;
/* Create the neural network */
printf("Loading mode...\n");
int model_data_size = 0;
unsigned char *model_data = read_file_data(model_path, &model_data_size);
if (model_data == NULL)
{
return -1;
}
ret = rknn_init(&ctx, model_data, model_data_size, 0, NULL);
if (ret < 0)
{
printf("rknn_init error ret=%d\n", ret);
return -1;
}
if (model_data)
{
free(model_data);
}
rknn_sdk_version version;
ret = rknn_query(ctx, RKNN_QUERY_SDK_VERSION, &version, sizeof(rknn_sdk_version));
if (ret < 0)
{
printf("rknn_query RKNN_QUERY_SDK_VERSION error ret=%d\n", ret);
return -1;
}
printf("sdk version: %s driver version: %s\n", version.api_version, version.drv_version);
ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &app_ctx->io_num, sizeof(rknn_input_output_num));
if (ret < 0)
{
printf("rknn_query RKNN_QUERY_IN_OUT_NUM error ret=%d\n", ret);
return -1;
}
printf("model input num: %d, output num: %d\n", app_ctx->io_num.n_input, app_ctx->io_num.n_output);
rknn_tensor_attr *input_attrs = (rknn_tensor_attr *)malloc(app_ctx->io_num.n_input * sizeof(rknn_tensor_attr));
memset(input_attrs, 0, app_ctx->io_num.n_input * sizeof(rknn_tensor_attr));
for (int i = 0; i < app_ctx->io_num.n_input; i++)
{
input_attrs[i].index = i;
ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr));
if (ret < 0)
{
printf("rknn_query RKNN_QUERY_INPUT_ATTR error ret=%d\n", ret);
return -1;
}
dump_tensor_attr(&(input_attrs[i]));
}
rknn_tensor_attr *output_attrs = (rknn_tensor_attr *)malloc(app_ctx->io_num.n_output * sizeof(rknn_tensor_attr));
memset(output_attrs, 0, app_ctx->io_num.n_output * sizeof(rknn_tensor_attr));
for (int i = 0; i < app_ctx->io_num.n_output; i++)
{
output_attrs[i].index = i;
ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr));
if (ret < 0)
{
printf("rknn_query RKNN_QUERY_OUTPUT_ATTR error ret=%d\n", ret);
return -1;
}
dump_tensor_attr(&(output_attrs[i]));
}
app_ctx->input_attrs = input_attrs;
app_ctx->output_attrs = output_attrs;
app_ctx->rknn_ctx = ctx;
if (input_attrs[0].fmt == RKNN_TENSOR_NCHW)
{
printf("model is NCHW input fmt\n");
app_ctx->model_channel = input_attrs[0].dims[1];
app_ctx->model_height = input_attrs[0].dims[2];
app_ctx->model_width = input_attrs[0].dims[3];
}
else
{
printf("model is NHWC input fmt\n");
app_ctx->model_height = input_attrs[0].dims[1];
app_ctx->model_width = input_attrs[0].dims[2];
app_ctx->model_channel = input_attrs[0].dims[3];
}
printf("model input height=%d, width=%d, channel=%d\n", app_ctx->model_height, app_ctx->model_width, app_ctx->model_channel);
// +++ 添加显示功能：初始化OpenCV显示窗口 +++
cv::namedWindow(DISPLAY_WINDOW_NAME, cv::WINDOW_NORMAL);
cv::resizeWindow(DISPLAY_WINDOW_NAME, 1280, 720); // 调整窗口大小，适配显示器
return 0;
}
static int release_model(rknn_app_context_t *app_ctx)
{
if (app_ctx->rknn_ctx != 0)
{
rknn_destroy(app_ctx->rknn_ctx);
}
free(app_ctx->input_attrs);
free(app_ctx->output_attrs);
deinitPostProcess();
// +++ 添加显示功能：释放显示窗口 +++
cv::destroyWindow(DISPLAY_WINDOW_NAME);
return 0;
}
static int inference_model(rknn_app_context_t *app_ctx, image_frame_t *img, detect_result_group_t *detect_result)
{
int ret;
rknn_context ctx = app_ctx->rknn_ctx;
int model_width = app_ctx->model_width;
int model_height = app_ctx->model_height;
int model_channel = app_ctx->model_channel;
struct timeval start_time, stop_time;
const float nms_threshold = NMS_THRESH;
const float box_conf_threshold = BOX_THRESH;
// You may not need resize when src resulotion equals to dst resulotion
void *resize_buf = nullptr;
// init rga context
rga_buffer_t src;
rga_buffer_t dst;
im_rect src_rect;
im_rect dst_rect;
memset(&src_rect, 0, sizeof(src_rect));
memset(&dst_rect, 0, sizeof(dst_rect));
memset(&src, 0, sizeof(src));
memset(&dst, 0, sizeof(dst));
printf("input image %dx%d stride %dx%d format=%d\n", img->width, img->height, img->width_stride, img->height_stride, img->format);
float scale_w = (float)model_width / img->width;
float scale_h = (float)model_height / img->height;
rknn_input inputs[1];
memset(inputs, 0, sizeof(inputs));
inputs[0].index = 0;
inputs[0].type = RKNN_TENSOR_UINT8;
inputs[0].size = model_width * model_height * model_channel;
inputs[0].fmt = RKNN_TENSOR_NHWC;
inputs[0].pass_through = 0;
printf("resize with RGA!\n");
resize_buf = malloc(model_width * model_height * model_channel);
memset(resize_buf, 0, model_width * model_height * model_channel);
src = wrapbuffer_virtualaddr((void *)img->virt_addr, img->width, img->height, img->format, img->width_stride, img->height_stride);
dst = wrapbuffer_virtualaddr((void *)resize_buf, model_width, model_height, RK_FORMAT_RGB_888);
ret = imcheck(src, dst, src_rect, dst_rect);
if (IM_STATUS_NOERROR != ret)
{
printf("%d, check error! %s", __LINE__, imStrError((IM_STATUS)ret));
return -1;
}
IM_STATUS STATUS = imresize(src, dst);
inputs[0].buf = resize_buf;
gettimeofday(&start_time, NULL);
rknn_inputs_set(ctx, app_ctx->io_num.n_input, inputs);
rknn_output outputs[app_ctx->io_num.n_output];
memset(outputs, 0, sizeof(outputs));
for (int i = 0; i < app_ctx->io_num.n_output; i++)
{
outputs[i].index = i;
outputs[i].want_float = 0;
}
ret = rknn_run(ctx, NULL);
ret = rknn_outputs_get(ctx, app_ctx->io_num.n_output, outputs, NULL);
gettimeofday(&stop_time, NULL);
printf("once run use %f ms\n", (__get_us(stop_time) - __get_us(start_time)) / 1000);
printf("post process config: box_conf_threshold = %.2f, nms_threshold = %.2f\n", box_conf_threshold, nms_threshold);
std::vector<float> out_scales;
std::vector<int32_t> out_zps;
for (int i = 0; i < app_ctx->io_num.n_output; ++i)
{
out_scales.push_back(app_ctx->output_attrs[i].scale);
out_zps.push_back(app_ctx->output_attrs[i].zp);
}
BOX_RECT pads;
memset(&pads, 0, sizeof(BOX_RECT));
post_process((int8_t *)outputs[0].buf, (int8_t *)outputs[1].buf, (int8_t *)outputs[2].buf, model_height, model_width,
box_conf_threshold, nms_threshold, pads, scale_w, scale_h, out_zps, out_scales, detect_result);
ret = rknn_outputs_release(ctx, app_ctx->io_num.n_output, outputs);
if (resize_buf)
{
free(resize_buf);
}
return 0;
}
void mpp_decoder_frame_callback(void *userdata, int width_stride, int height_stride, int width, int height, int format, int fd, void *data)
{
rknn_app_context_t *ctx = (rknn_app_context_t *)userdata;
int ret = 0;
static int frame_index = 0;
frame_index++;
void *mpp_frame = NULL;
int mpp_frame_fd = 0;
void *mpp_frame_addr = NULL;
int enc_data_size;
rga_buffer_t origin;
rga_buffer_t src;
// +++ 修复：提前声明显示相关变量（移到goto跳转前） +++
cv::Mat yuv_frame, bgr_frame;
if (ctx->encoder == NULL)
{
MppEncoder *mpp_encoder = new MppEncoder();
MppEncoderParams enc_params;
memset(&enc_params, 0, sizeof(MppEncoderParams));
enc_params.width = width;
enc_params.height = height;
enc_params.hor_stride = width_stride;
enc_params.ver_stride = height_stride;
enc_params.fmt = MPP_FMT_YUV420SP;
// enc_params.type = MPP_VIDEO_CodingHEVC;
// Note: rk3562只能支持h264格式的视频流
enc_params.type = MPP_VIDEO_CodingAVC;
mpp_encoder->Init(enc_params, NULL);
ctx->encoder = mpp_encoder;
}
int enc_buf_size = ctx->encoder->GetFrameSize();
char *enc_data = (char *)malloc(enc_buf_size);
image_frame_t img;
img.width = width;
img.height = height;
img.width_stride = width_stride;
img.height_stride = height_stride;
img.fd = fd;
img.virt_addr = (char *)data;
img.format = RK_FORMAT_YCbCr_420_SP;
detect_result_group_t detect_result;
memset(&detect_result, 0, sizeof(detect_result_group_t));
ret = inference_model(ctx, &img, &detect_result);
if (ret != 0)
{
printf("inference model fail\n");
goto RET; // 此处跳转不会跨越变量初始化（yuv_frame/bgr_frame已提前声明）
}
mpp_frame = ctx->encoder->GetInputFrameBuffer();
mpp_frame_fd = ctx->encoder->GetInputFrameBufferFd(mpp_frame);
mpp_frame_addr = ctx->encoder->GetInputFrameBufferAddr(mpp_frame);
// Copy To another buffer avoid to modify mpp decoder buffer
origin = wrapbuffer_fd(fd, width, height, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride);
src = wrapbuffer_fd(mpp_frame_fd, width, height, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride);
imcopy(origin, src);
/*
// Draw objects
for (int i = 0; i < detect_result.count; i++)
{
detect_result_t *det_result = &(detect_result.results[i]);
printf("%s @ (%d %d %d %d) %f\n", det_result->name, det_result->box.left, det_result->box.top,
det_result->box.right, det_result->box.bottom, det_result->prop);
int x1 = det_result->box.left;
int y1 = det_result->box.top;
int x2 = det_result->box.right;
int y2 = det_result->box.bottom;
draw_rectangle_yuv420sp((unsigned char *)mpp_frame_addr, width_stride, height_stride, x1, y1, x2 - x1 + 1, y2 - y1 + 1, 0x00FF0000, 4);
}
*/
// +++ 显示功能：初始化Mat变量（此时goto已不会跨越初始化） +++
// 1. 将YUV420SP数据转换为OpenCV的Mat格式
yuv_frame = cv::Mat(height * 3 / 2, width, CV_8UC1, (unsigned char *)mpp_frame_addr);
// 2. YUV420SP(NV12)转BGR（RK3588的Mpp输出是NV12格式）
cv::cvtColor(yuv_frame, bgr_frame, cv::COLOR_YUV2BGR_NV12);
// Draw objects
for (int i = 0; i < detect_result.count; i++)
{
detect_result_t *det_result = &(detect_result.results[i]);
printf("%s @ (%d %d %d %d) %f\n", det_result->name, det_result->box.left, det_result->box.top,
det_result->box.right, det_result->box.bottom, det_result->prop);
int x1 = det_result->box.left;
int y1 = det_result->box.top;
int x2 = det_result->box.right;
int y2 = det_result->box.bottom;
// 绘制红色检测框（原有代码）
//draw_rectangle_yuv420sp((unsigned char *)mpp_frame_addr, width_stride, height_stride, x1, y1, x2 - x1 + 1, y2 - y1 + 1, 0x00FF0000, 4);
cv::rectangle(
bgr_frame, // 绘制目标：BGR帧（与文字标注统一）
cv::Point(x1, y1), // 左上角坐标
cv::Point(x2, y2), // 右下角坐标
cv::Scalar(0, 0, 255), // 颜色：红色（BGR格式，注意顺序是B=0, G=0, R=255）
1 // 线宽：1px（与原效果一致）
);
// +++ 新增：添加文字标注（物体名称+置信度%） +++
// 1. 拼接文字内容（名称 + 置信度保留2位小数 + %）
char text[64];
snprintf(text, sizeof(text), "%s %.2f%%", det_result->name, det_result->prop * 100);
// 2. 设置文字位置（检测框左上角上方10像素，避免遮挡；若y1太靠上则放在下方）
int text_x = x1;
int text_y = (y1 > 20) ? (y1 - 10) : (y2 + 20);
// 黑色背景框（提高可读性）
cv::Size text_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 2, NULL);
cv::rectangle(
bgr_frame,
cv::Point(text_x - 2, text_y - text_size.height - 2),
cv::Point(text_x + text_size.width + 2, text_y + 2),
cv::Scalar(0, 0, 0), // 黑色背景
-1 // 填充背景
);
// 3. 在BGR帧上绘制文字（白色字体，粗体，字号0.5）
cv::putText(
bgr_frame, // 绘制目标帧（BGR格式）
text, // 文字内容
cv::Point(text_x, text_y), // 文字位置
cv::FONT_HERSHEY_SIMPLEX, // 字体
0.5, // 字号
cv::Scalar(255, 255, 255), // 文字颜色（白色）
2 // 文字线条粗细（避免模糊）
);
}
// 3. 实时显示画面
cv::imshow(DISPLAY_WINDOW_NAME, bgr_frame);
// 4. 等待10ms，确保画面流畅显示（按ESC键可退出）
if (cv::waitKey(100) == 27) {
exit(0); // 按ESC键退出程序
}
// Encode to file
// Write header on first frame
if (frame_index == 1)
{
enc_data_size = ctx->encoder->GetHeader(enc_data, enc_buf_size);
fwrite(enc_data, 1, enc_data_size, ctx->out_fp);
}
memset(enc_data, 0, enc_buf_size);
enc_data_size = ctx->encoder->Encode(mpp_frame, enc_data, enc_buf_size);
fwrite(enc_data, 1, enc_data_size, ctx->out_fp);
RET: // 跳转目标（此时所有变量要么已提前声明，要么不在跳转路径上）
if (enc_data != nullptr)
{
free(enc_data);
}
}
int process_video_file(rknn_app_context_t *ctx, const char *path)
{
int video_size;
char *video_data = (char *)read_file_data(path, &video_size);
char *video_data_end = video_data + video_size;
printf("read video size=%d\n", video_size);
const int SIZE = 8192;
char *video_data_ptr = video_data;
do
{
int pkt_eos = 0;
int size = SIZE;
if (video_data_ptr + size >= video_data_end)
{
pkt_eos = 1;
size = video_data_end - video_data_ptr;
}
ctx->decoder->Decode((uint8_t *)video_data_ptr, size, pkt_eos);
video_data_ptr += size;
if (video_data_ptr >= video_data_end)
{
printf("reset decoder\n");
break;
}
// LOGD("video_data_ptr=%p video_data_end=%p", video_data_ptr, video_data_end);
// usleep(10*1000);
} while (1);
return 0;
}
#if defined(BUILD_VIDEO_RTSP)
void API_CALL on_track_frame_out(void *user_data, mk_frame frame)
{
rknn_app_context_t *ctx = (rknn_app_context_t *)user_data;
printf("on_track_frame_out ctx=%p\n", ctx);
const char *data = mk_frame_get_data(frame);
size_t size = mk_frame_get_data_size(frame);
printf("decoder=%p\n", ctx->decoder);
ctx->decoder->Decode((uint8_t *)data, size, 0);
}
void API_CALL on_mk_play_event_func(void *user_data, int err_code, const char *err_msg, mk_track tracks[],
int track_count)
{
rknn_app_context_t *ctx = (rknn_app_context_t *)user_data;
if (err_code == 0)
{
// success
printf("play success!");
int i;
for (i = 0; i < track_count; ++i)
{
if (mk_track_is_video(tracks[i]))
{
log_info("got video track: %s", mk_track_codec_name(tracks[i]));
// 监听track数据回调
mk_track_add_delegate(tracks[i], on_track_frame_out, user_data);
}
}
}
else
{
printf("play failed: %d %s", err_code, err_msg);
}
}
void API_CALL on_mk_shutdown_func(void *user_data, int err_code, const char *err_msg, mk_track tracks[], int track_count)
{
printf("play interrupted: %d %s", err_code, err_msg);
}
int process_video_rtsp(rknn_app_context_t *ctx, const char *url)
{
mk_config config;
memset(&config, 0, sizeof(mk_config));
config.log_mask = LOG_CONSOLE;
mk_env_init(&config);
mk_player player = mk_player_create();
mk_player_set_on_result(player, on_mk_play_event_func, ctx);
mk_player_set_on_shutdown(player, on_mk_shutdown_func, ctx);
mk_player_play(player, url);
printf("enter any key to exit\n");
getchar();
if (player)
{
mk_player_release(player);
}
return 0;
}
#endif
/*-------------------------------------------
Main Functions
-------------------------------------------*/
int main(int argc, char **argv)
{
int status = 0;
int ret;
if (argc != 4)
{
printf("Usage: %s <rknn_model> <video_path> <video_type 264/265> \n", argv[0]);
return -1;
}
char *model_name = (char *)argv[1];
char *video_name = argv[2];
int video_type = atoi(argv[3]);
rknn_app_context_t app_ctx;
memset(&app_ctx, 0, sizeof(rknn_app_context_t));
ret = init_model(model_name, &app_ctx);
if (ret != 0)
{
printf("init model fail\n");
return -1;
}
if (app_ctx.decoder == NULL)
{
MppDecoder *decoder = new MppDecoder();
decoder->Init(video_type, 30, &app_ctx);
decoder->SetCallback(mpp_decoder_frame_callback);
app_ctx.decoder = decoder;
}
if (app_ctx.out_fp == NULL)
{
FILE *fp = fopen(OUT_VIDEO_PATH, "w");
if (fp == NULL)
{
printf("open %s error\n", OUT_VIDEO_PATH);
return -1;
}
app_ctx.out_fp = fp;
}
printf("app_ctx=%p decoder=%p\n", &app_ctx, app_ctx.decoder);
if (strncmp(video_name, "rtsp", 4) == 0)
{
#if defined(BUILD_VIDEO_RTSP)
process_video_rtsp(&app_ctx, video_name);
#else
printf("rtsp no support\n");
#endif
}
else
{
process_video_file(&app_ctx, video_name);
}
printf("waiting finish\n");
usleep(3 * 1000 * 1000);
// release
fflush(app_ctx.out_fp);
fclose(app_ctx.out_fp);
if (app_ctx.decoder != nullptr)
{
delete (app_ctx.decoder);
app_ctx.decoder = nullptr;
}
if (app_ctx.encoder != nullptr)
{
delete (app_ctx.encoder);
app_ctx.encoder = nullptr;
}
release_model(&app_ctx);
return 0;
}CMakeLists文件：
cmake_minimum_required(VERSION 3.6)
project(rknn_yolov5_demo)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# skip 3rd-party lib dependencies
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--allow-shlib-undefined")
# install target and libraries
set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install/rknn_yolov5_demo_${CMAKE_SYSTEM_NAME})
set(CMAKE_SKIP_INSTALL_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
if(CMAKE_C_COMPILER MATCHES "aarch64")
set(LIB_ARCH aarch64)
else()
set(LIB_ARCH armhf)
endif()
include_directories(${CMAKE_SOURCE_DIR})
# rknn api
set(RKNN_API_PATH ${CMAKE_SOURCE_DIR}/../../runtime//${CMAKE_SYSTEM_NAME}/librknn_api)
if(CMAKE_SYSTEM_NAME STREQUAL "Android")
set(RKNN_RT_LIB ${RKNN_API_PATH}/${CMAKE_ANDROID_ARCH_ABI}/librknnrt.so)
else()
set(RKNN_RT_LIB ${RKNN_API_PATH}/${LIB_ARCH}/librknnrt.so)
endif()
include_directories(${RKNN_API_PATH}/include)
include_directories(${CMAKE_SOURCE_DIR}/../3rdparty)
# opencv
if(CMAKE_SYSTEM_NAME STREQUAL "Android")
set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../3rdparty/opencv/OpenCV-android-sdk/sdk/native/jni/abi-${CMAKE_ANDROID_ARCH_ABI})
else()
# 注释掉原有强制指定的 3rdparty OpenCV 路径，让 CMake 自动查找系统 OpenCV
# if(LIB_ARCH STREQUAL "armhf")
# set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../3rdparty/opencv/opencv-linux-armhf/share/OpenCV)
# else()
# set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../3rdparty/opencv/opencv-linux-aarch64/share/OpenCV)
# endif()
# 可选：添加系统 OpenCV 查找提示（适配 Debian 11）
set(OpenCV_INCLUDE_DIRS /usr/include/opencv4)
set(OpenCV_LIB_DIR /usr/lib/aarch64-linux-gnu)
endif()
find_package(OpenCV REQUIRED)
# 新增：链接系统 OpenCV 库路径
link_directories(${OpenCV_LIB_DIR})
# rga
# comes from https://github.com/airockchip/librga
set(RGA_PATH ${CMAKE_SOURCE_DIR}/../3rdparty/rga/)
if(CMAKE_SYSTEM_NAME STREQUAL "Android")
set(RGA_LIB ${RGA_PATH}/libs/AndroidNdk/${CMAKE_ANDROID_ARCH_ABI}/librga.so)
else()
if(CMAKE_C_COMPILER MATCHES "aarch64")
set(LIB_ARCH aarch64)
else()
set(LIB_ARCH armhf)
endif()
set(RGA_LIB ${RGA_PATH}/libs/Linux//gcc-${LIB_ARCH}/librga.so)
endif()
include_directories( ${RGA_PATH}/include)
# mpp
set(MPP_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty/mpp)
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
set(MPP_LIBS ${MPP_PATH}/${CMAKE_SYSTEM_NAME}/${LIB_ARCH}/librockchip_mpp.so)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
set(MPP_LIBS ${MPP_PATH}/${CMAKE_SYSTEM_NAME}/${CMAKE_ANDROID_ARCH_ABI}/libmpp.so)
endif()
include_directories(${MPP_PATH}/include)
# zlmediakit
set(ZLMEDIAKIT_PATH ${CMAKE_SOURCE_DIR}/../3rdparty/zlmediakit)
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
include_directories(${ZLMEDIAKIT_PATH}/include)
set(ZLMEDIAKIT_LIBS ${ZLMEDIAKIT_PATH}/${LIB_ARCH}/libmk_api.so)
endif()
if(ZLMEDIAKIT_LIBS)
add_definitions(-DBUILD_VIDEO_RTSP)
endif()
set(CMAKE_INSTALL_RPATH "lib")
# rknn_yolov5_demo
include_directories(${CMAKE_SOURCE_DIR}/include)
add_executable(rknn_yolov5_demo
src/main.cc
src/preprocess.cc
src/postprocess.cc
)
target_link_libraries(rknn_yolov5_demo
${RKNN_RT_LIB}
${RGA_LIB}
${OpenCV_LIBS}
)
if(MPP_LIBS)
add_executable(rknn_yolov5_video_demo
src/main_video.cc
src/postprocess.cc
utils/mpp_decoder.cpp
utils/mpp_encoder.cpp
utils/drawing.cpp
)
target_link_libraries(rknn_yolov5_video_demo
${RKNN_RT_LIB}
${RGA_LIB}
${OpenCV_LIBS}
${MPP_LIBS}
${ZLMEDIAKIT_LIBS}
)
endif()
# install target and libraries
set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install/rknn_yolov5_demo_${CMAKE_SYSTEM_NAME})
install(TARGETS rknn_yolov5_demo DESTINATION ./)
install(PROGRAMS ${RKNN_RT_LIB} DESTINATION lib)
install(PROGRAMS ${RGA_LIB} DESTINATION lib)
install(DIRECTORY model/${TARGET_SOC} DESTINATION ./model)
file(GLOB IMAGE_FILES "model/*.jpg")
file(GLOB LABEL_FILE "model/*.txt")
install(FILES ${IMAGE_FILES} DESTINATION ./model/)
install(FILES ${LABEL_FILE} DESTINATION ./model/)
if(MPP_LIBS)
install(TARGETS rknn_yolov5_video_demo DESTINATION ./)
install(PROGRAMS ${MPP_LIBS} DESTINATION lib)
endif()
if(ZLMEDIAKIT_LIBS)
install(PROGRAMS ${ZLMEDIAKIT_LIBS} DESTINATION lib)
endif()代码修改完成后，需要重新编译。
#运行测试程序
./rknn_yolov5_demo model/RK3588/yolov5s-640-640.rknn model/test.jpg
6、测试性能分析
NPU占用率查看命令，因驱动版本不同，NPU占用率分析工具也不一样。
sudo watch -n 1 cat /sys/kernel/debug/rknpu/load
