目錄
前言
1. 結果對比
1.1 時間對比
1.2 CPU和NPU占用對比
2. RGA實現YOLO前處理
2.1 實現思路
2.2 處理類的聲明
2.3 處理類的實現
總結
前言
RK平臺上有RGA?(Raster Graphic Acceleration Unit) 加速，使用RGA可以減少資源占用、加速圖片處理速度。因此，在部署YOLOv8是針對RGA和OpenCV的分別進行了實現，并對性能、速度和資源占用進行對比。
1. 結果對比
1.1 時間對比
總共跑100次計算平均時間。
純OpenCV實現：
OPencv實現resize+pad
[Convert] Step1: Check input pointer => 0 us
[Convert] Step2: define intermediate Mat => 37 us
[Convert] Step3: cv::resize => 9564 us
[Convert] Step4: create pad_img => 1629 us
[Convert] Step5: compute position => 61 us
[Convert] Step6: copyTo => 340 us
[Convert] Step7: return => 54 us
INFO: image resize time 12.15 ms
INFO: total infer time 22.71 ms: model time is 22.45 ms and postprocess time is 0.26ms
Iteration 100 - time: 35.034000 ms
Total execution time: 3770.930000 ms
Average execution time: 37.709300 ms純RGA實現：
RGA實現
[Convert] Step1: Check input pointer => 1 us
[Convert] Step2: Set format/bpp => 92 us
[Convert] Step3: Calculate buffer sizes => 13 us
[Convert] Step4: Define variables => 12 us
[Convert] Step5: Compute border => 13 us
[Convert] Step6: Alloc & memcpy src => 10048 us
[Convert] Step7: Alloc resized buffer => 477 us
[Convert] Step8: Alloc dst buffer => 269 us
[Convert] Step9: importbuffer_fd => 3494 us
[Convert] Step10: wrapbuffer_handle => 80 us
[Convert] Step11: imresize => 2714 us
[Convert] Step12: immakeBorder => 1154 us
[Convert] Step13: copy result => 428 us
[Convert] Step14: cleanup => 2607 us
INFO: image resize time 24.26 ms
INFO: total infer time 22.10 ms: model time is 21.84 ms and postprocess time is 0.26ms
Iteration 100 - time: 46.496000 ms
Total execution time: 4398.143000 ms
Average execution time: 43.981430 ms
總結：
（1）從上可以看到OpenCV最占時間的是resize步驟，需要9~10ms，而RGA只要2~3ms。
（2）但使用RGA，如果圖片數據不在DMA緩沖區，則需要進行拷貝，導致耗時太久。
（3）最終，導致RGA實現resize要比OpenCV慢了6~7ms。
1.2 CPU和NPU占用對比
跑單個模型持續推理。
純OpenCV實現：
CPU占用率：120%~140%
NPU占用率：43%~48%
純RGA實現：
CPU占用率：50%~60%
NPU占用率：35%~40%
總結：
（1）OPenCV使用CPU多線程計算差值，導致CPU占用率較高。
（2）RGA在DMA緩沖區使用硬件計算，減少對CPU依賴。
（3）RGA比OpenCV減少了60%的CPU占用和10%的NPU占用。
2. RGA實現YOLO前處理
參考代碼：
[1]?https://github.com/airockchip/librga
[2]?rga_resize_demo.cpp
[3]?rga_padding_demo.cpp
2.1 實現思路
? ? ? ? 在DMA緩沖區，每有一個形狀，便需要一個CPU指針、句柄和緩沖區，導致分配內存、處理起來極其麻煩，且寬度需要16倍對齊（高度沒有要求）、同時還存在著4G范圍尋址問題。所以，實際應用要起來還是很麻煩的（尤其是自定義的任意尺寸輸入）。
? ? ? ? 所以，這里僅使用RGA對合規的圖片做resize，再使用OpenCV做pad填充。
? ? ? ? 由于工資預算有限，這里僅實現攝像頭輸入的原圖尺寸（寬度滿足16倍長，主要以1920×1080為主）的圖片的前處理。
補充（實現任意尺寸處理的思路）：
(1) 設傳入的寬和高為：[H，W]，目標寬高（模型輸入大小）為：[H_T, W_T]，INT_UP表示向上取整函數。
(2) 原16倍寬度 W_16 為: INT_UP(W / 16) * 16，則現將原圖先填充（僅右邊填充）到尺寸[H, W_16]。
(3) 計算放縮比 R = min(H / H_T, W_16 / W_t)。
(4) 繼續計算得到目標放縮尺寸寬度的16倍 W_T_16 為：INT_UP(W_T_16 / 16) * 16。
(5) 然后更新放縮比 R = min(H / H_T, W_T_16 / R / W_T)，此過程可能需要迭代。
(6) 得到放縮比 R 后，計算原圖真正要填充到的尺寸為：[H_T / R, W_T_16 / R]。
(7) 然后對原圖僅做右邊和下面的填充，這樣就把原圖對齊到16倍長（放縮前后均是）。2.2 處理類的聲明
#include <iostream>
#include <memory>
#include <numeric>
#include <vector>
#include <algorithm>
#include "opencv2/opencv.hpp"
#include "common.h"
// 增加RGA庫實現pad resize
#include <rga/RgaApi.h>
#include <rga/im2d.hpp>
#include <rga/rga.h>
#include <rga/RgaUtils.h>
#include <dma/dma_alloc.h>
// 打印時間
#include <sys/time.h>
#include <stdint.h>
#include <stdio.h>// RGA 版本的 Pad Resize 處理類
class ImagePreProcessRGA {public:// 構造函數：輸入圖像為 width x height，目標尺寸為正方形 target_size x target_sizeImagePreProcessRGA(int width, int height, int target_size);// 構造函數：輸入圖像為 width x height，目標尺寸為 target_width x target_heightImagePreProcessRGA(int width, int height, int target_width, int target_height);// 對輸入圖像數據進行pad resize處理，返回處理后的圖像數據（unique_ptr管理）std::unique_ptr<uint8_t[]> Convert(const det_model_input& input);// 獲取letterbox信息const letterbox_t &get_letter_box() { return letterbox_; }private:double scale_; // 縮放比例int input_width_, input_height_; // 輸入圖像尺寸int real_input_width_, real_input_height_; // 輸入的實際尺寸int target_width_, target_height_; // 目標圖像尺寸int new_width_, new_height_; // 縮放后圖像的尺寸（填輸入的尺寸縮放后，經過填充才能變成目標尺寸）int padding_x_, padding_y_; // pad的總尺寸（左右、上下）letterbox_t letterbox_; // letterbox信息記錄縮放比例及左右/上下填充（一般為居中填充）
};2.3 處理類的實現
? ? ? ? 實現RGB的3通道或者4通道的圖片。
// 構造函數1：只傳一個target_size，默認目標是正方形
ImagePreProcessRGA::ImagePreProcessRGA(int width, int height, int target_size): input_width_(width), input_height_(height), target_width_(target_size), target_height_(target_size){// ------------------【Step1：根據最大邊計算放縮比例】---------------------// 如果原圖是 (width x height)，目標是 (target_size x target_size)，則 scale = target_size / max(width, height)scale_ = static_cast<double>(target_size) / std::max(input_width_, input_height_);// ------------------【Step2：計算縮放后尺寸】----------------------------new_width_ = static_cast<int>(input_width_ * scale_);new_height_ = static_cast<int>(input_height_ * scale_);// ------------------【Step3：計算在目標圖像中的剩余填充】------------------padding_x_ = target_size - new_width_;padding_y_ = target_size - new_height_;// ------------------【Step4：更新 letterbox】--------------------------letterbox_.scale = scale_;letterbox_.x_pad = padding_x_ / 2;letterbox_.y_pad = padding_y_ / 2;// ------------------【可選：打印結果】-----------------------------------// printf(">>> After => new_width_=%d, new_height_=%d, scale=%.3f\n", new_width_, new_height_, scale_);// printf(">>> padding_x_=%d, padding_y_=%d\n", padding_x_, padding_y_);
}// 構造函數2：傳入獨立的target_width和target_height，可能目標不是正方形
ImagePreProcessRGA::ImagePreProcessRGA(int width, int height, int target_width, int target_height): input_width_(width), input_height_(height), target_width_(target_width), target_height_(target_height){// ------------------【Step1：分別計算寬高縮放比例】-----------------------double width_scale = static_cast<double>(target_width_) / input_width_;double height_scale = static_cast<double>(target_height_) / input_height_;// 取較小的縮放比例scale_ = std::min(width_scale, height_scale);// ------------------【Step2：計算縮放后尺寸】----------------------------new_width_ = static_cast<int>(input_width_ * scale_);new_height_ = static_cast<int>(input_height_ * scale_);// ------------------【Step3：計算填充大小】------------------------------padding_x_ = target_width_ - new_width_;padding_y_ = target_height_ - new_height_;// ------------------【Step4：更新 letterbox】---------------------------letterbox_.scale = scale_;letterbox_.x_pad = padding_x_ / 2;letterbox_.y_pad = padding_y_ / 2;// ------------------【可選：打印結果】-----------------------------------// printf(">>> After => new_width_=%d, new_height_=%d, scale=%.3f\n", new_width_, new_height_, scale_);// printf(">>> padding_x_=%d, padding_y_=%d\n", padding_x_, padding_y_);
}// 核心函數：基于RGA對輸入圖像進行pad resize，并返回處理后的圖像數據
std::unique_ptr<uint8_t[]> ImagePreProcessRGA::Convert(const det_model_input& input){// -------------------【Step0：在函數開頭聲明所有變量】-------------------// 中間處理函數返回值int ret = 0;// DMA fdint src_dma_fd = -1;int resized_dma_fd = -1;// CPU指針uint8_t *src_buf = nullptr;uint8_t *resized_buf = nullptr;// RGA handlerga_buffer_handle_t src_handle = 0;rga_buffer_handle_t resized_handle = 0;// RGA bufferrga_buffer_t rga_src;rga_buffer_t rga_resized;memset(&rga_src, 0, sizeof(rga_src));memset(&rga_resized, 0, sizeof(rga_resized));// 最終的返回結果std::unique_ptr<uint8_t[]> final_data;// 其他局部變量int bpp_src = 0;int bpp_dst = 3; // 目標一定3通道int src_format = 0;int dst_format = RK_FORMAT_RGB_888;// 源圖大小和resize后大小int src_size = 0; int resized_size = 0; // 用于 pad 的邊界int left=0, right=0, top=0, bottom=0;// 常用114作為灰度cv::Scalar pad_color(114,114,114);// -------------------【Step1：基礎檢查】------------------------------------if (!input.data || input.width <= 0 || input.height <= 0 || (input.channel != 3 && input.channel != 4)){fprintf(stderr, "ERROR: invalid input data or channel.\n");return nullptr;}// 根據通道數決定 bpp & formatbpp_src = (input.channel == 4) ? 4 : 3;src_format = (input.channel == 4) ? RK_FORMAT_RGBA_8888 : RK_FORMAT_RGB_888;// 源圖大小src_size = input.width * input.height * bpp_src;// resize后大小int out_size_w = new_width_; // 由構造函數算好int out_size_h = new_height_; // 由構造函數算好resized_size = out_size_w * out_size_h * bpp_dst;std::unique_ptr<uint8_t[]> resized_cpu(new uint8_t[resized_size]);// 用于后面 OpenCV padleft = padding_x_ / 2;right = padding_x_ - left;top = padding_y_ / 2;bottom = padding_y_ - top;// -------------------【Step2：分配 src_buf, resized_buf】-------------------ret = dma_buf_alloc(DMA_HEAP_DMA32_PATH, src_size, &src_dma_fd, (void**)&src_buf);if (ret < 0 || !src_buf) {fprintf(stderr, "ERROR: alloc src_buf failed.\n");return nullptr;}ret = dma_buf_alloc(DMA_HEAP_DMA32_PATH, resized_size, &resized_dma_fd, (void**)&resized_buf);if (ret < 0 || !resized_buf) {fprintf(stderr, "ERROR: alloc resized_buf failed.\n");goto cleanup;}// 不考慮16對齊等，只做最原始的 YOLO思路。只需將 input.data 拷貝到 src_bufmemcpy(src_buf, input.data, src_size);// -------------------【Step3：import & wrap】-------------------------------src_handle = importbuffer_fd(src_dma_fd, src_size);resized_handle = importbuffer_fd(resized_dma_fd, resized_size);if (!src_handle || !resized_handle) {fprintf(stderr, "ERROR: importbuffer_fd failed.\n");ret = -1;goto cleanup;}rga_src = wrapbuffer_handle(src_handle, input.width, input.height, src_format);rga_resized = wrapbuffer_handle(resized_handle, out_size_w, out_size_h, dst_format);// -------------------【Step4：RGA僅做 resize or color convert+resize】-------------------if (input.channel == 4) {// RGBA => color convert => resizedIM_STATUS st_cvt = imcvtcolor(rga_src, rga_resized, RK_FORMAT_RGBA_8888, RK_FORMAT_RGB_888);if (st_cvt != IM_STATUS_SUCCESS) {fprintf(stderr, "ERROR: imcvtcolor failed: %s.\n", imStrError(st_cvt));ret = -1;goto cleanup;}}else {// channel=3 => 直接 resizeIM_STATUS st_resize = imresize(rga_src, rga_resized, 0, 0, INTER_LINEAR);if (st_resize != IM_STATUS_SUCCESS) {fprintf(stderr, "ERROR: imresize failed: %s.\n", imStrError(st_resize));ret = -1;goto cleanup;}}// -------------------【Step5：將 resized_buf 拷回 CPU】-------------------// 拿到 resize 后的 RGB 圖像數據memcpy(resized_cpu.get(), resized_buf, resized_size);// -------------------【Step6：用OpenCV進行 pad】-------------------{// 1) 構造一個 cv::Mat 指向 resized_cpucv::Mat resized_mat(new_height_, new_width_, CV_8UC3, resized_cpu.get());// 2) 構造一個 pad_mat (target_height_ x target_width_)，初始顏色(114,114,114)cv::Mat pad_mat(target_height_, target_width_, CV_8UC3, pad_color);// 3) 計算在 pad_mat 中的放置位置// left=padding_x_/2, top=padding_y_/2cv::Rect roi(left, top, resized_mat.cols, resized_mat.rows);// 4) 拷貝 resized_mat 到 pad_mat 對應區域resized_mat.copyTo(pad_mat(roi));// 5) 將 pad_mat 拷到 final_dataint final_size = target_width_ * target_height_ * 3; // 3通道final_data.reset(new uint8_t[final_size]);memcpy(final_data.get(), pad_mat.data, final_size);}cleanup:// -------------------【Step7：釋放資源】-------------------if (src_handle) releasebuffer_handle(src_handle);if (resized_handle) releasebuffer_handle(resized_handle);if (src_buf) dma_buf_free(src_size, &src_dma_fd, src_buf);if (resized_buf) dma_buf_free(resized_size,&resized_dma_fd, resized_buf);// 若 ret!=0, 返回 nullptrif (ret != 0) {return nullptr;}// 否則返回 final_data，即 "pad后" 的圖像return final_data;
}
總結
這樣實現資源占用還是約等于純RGA實現，在推理單張圖的時候，速度還可能更快一些：
RGA-resize+OpenCV-pad:
>>> After => new_width_=640, new_height_=360, scale=0.333
>>> padding_x_=0, padding_y_=24
[Convert] Step1: check => 9 usOriginal Input => width=1920, height=1080, channel=3Resize => new_width_=640, new_height_=360Pad => target_width_=640, target_height_=384
[Convert] Step2: alloc => 187 us
[Convert] StepFILL => copy input => 6220800 bytes
[Convert] StepFILL => 1709 us
rga_api version 1.10.1_[0]
[Convert] Step3: wrap => src=(1920x1080), resized=(640x360)
[Convert] Step3 => 892 us
[Convert] Step4: imresize => done
[Convert] Step4 => 2294 us
[Convert] Step5: copy resized => 691200 bytes
[Convert] Step5 => 543 us
[Convert] Step6: OpenCV pad => final_size=737280
[Convert] Step6 => 1314 us
[Convert] Step7: cleanup => 648 us
INFO: image resize time 7.64 ms
INFO: total infer time 28.11 ms: model time is 27.93 ms and postprocess time is 0.18ms
Iteration 1 - time: 35.846000 ms
Total execution time: 35.846000 ms
Average execution time: 35.846000 msOpenCV:
INFO: image resize time 9.49 ms
INFO: total infer time 23.12 ms: model time is 23.09 ms and postprocess time is 0.03ms
Iteration 1 - time: 32.688000 ms
