2025-05-10 21:58:58 +08:00

608 lines
21 KiB
C++

/*
* Copyright (C) 2021 Rockchip Electronics Co., Ltd.
* Authors:
* Cerf Yu <cerf.yu@rock-chips.com>
*
* 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.
*/
#define LOG_NDEBUG 0
#undef LOG_TAG
#define LOG_TAG "rga_im2d_slt"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <math.h>
#include <fcntl.h>
#include <memory.h>
#include <pthread.h>
#if LIBDRM
#include "drm_alloc.h"
#include "xf86drm.h"
#endif
#include "RockchipRga.h"
#include "im2d_api/im2d.hpp"
#include "RgaUtils.h"
#include "dma_alloc.h"
#include "drm_alloc.h"
#include "slt_config.h"
enum {
FILL_BUFF = 0,
EMPTY_BUFF = 1
};
typedef struct private_data {
int id;
const char *name;
int mode;
unsigned int num;
int width;
int height;
int format;
int rd_mode;
int core;
int priority;
int result;
} private_data_t;
static int get_buf_size_by_w_h_f(int w, int h, int f) {
float bpp = get_bpp_from_format(f);
int size = 0;
size = (int)w * h * bpp;
return size;
}
int read_image_from_path(void *buf, const char *path, int f, int sw, int sh, int index, int mode) {
const char *inputFilePath = "%s/in%dw%d-h%d-%s.bin";
const char *inputFbcFilePath = "%s/in%dw%d-h%d-%s-fbc.bin";
char filePath[100];
snprintf(filePath, 100, (mode == IM_FBC_MODE) ? inputFbcFilePath : inputFilePath,
path, index, sw, sh, translate_format_str(f));
FILE *file = fopen(filePath, "rb");
if (!file) {
fprintf(stderr, "Could not open %s\n", filePath);
return -EINVAL;
}
if (mode == IM_FBC_MODE)
fread(buf, get_buf_size_by_w_h_f(sw, sh, f) * 1.5, 1, file);
else
fread(buf, get_buf_size_by_w_h_f(sw, sh, f), 1, file);
fclose(file);
return 0;
}
static int write_image_to_path(void *buf, const char *path, int f, int sw, int sh, int index, int mode) {
const char *outputFilePath = "%s/out%dw%d-h%d-%s.bin";
const char *outputFbcFilePath = "%s/out%dw%d-h%d-%s-fbc.bin";
char filePath[100];
snprintf(filePath, 100, (mode == IM_FBC_MODE) ? outputFbcFilePath : outputFilePath,
path, index, sw, sh, translate_format_str(f));
FILE *file = fopen(filePath, "wb+");
if (!file) {
fprintf(stderr, "Could not open %s\n", filePath);
return false;
} else {
fprintf(stderr, "open %s and write ok\n", filePath);
}
if (mode == IM_FBC_MODE)
fwrite(buf, get_buf_size_by_w_h_f(sw, sh, f) * 1.5, 1, file);
else
fwrite(buf, get_buf_size_by_w_h_f(sw, sh, f), 1, file);
fclose(file);
return 0;
}
#if IM2D_SLT_GRAPHICBUFFER_EN
#include <ui/GraphicBuffer.h>
/*
* In order to be compatible with different android versions,
* some gralloc usage is defined here.
* The correct usage should be to refer to the corresponding header file:
* Android 12 and above: #include "hardware/gralloc_rockchip.h"
* Android 11 and below: #include "hardware/gralloc.h"
*/
#define GRALLOC_USAGE_PRIVATE_11 (1ULL << 56)
#define RK_GRALLOC_USAGE_WITHIN_4G GRALLOC_USAGE_PRIVATE_11
#define RK_GRALLOC_USAGE_RGA_ACCESS RK_GRALLOC_USAGE_WITHIN_4G
sp<GraphicBuffer> GraphicBuffer_Init(int width, int height,int format, bool use_rga2, bool cacheable) {
uint64_t usage = 0;
if (cacheable)
usage |= GRALLOC_USAGE_SW_READ_OFTEN;
if (use_rga2)
usage |= RK_GRALLOC_USAGE_WITHIN_4G;
sp<GraphicBuffer> gb(new GraphicBuffer(width, height, format, 0, usage));
if (gb->initCheck()) {
/*
* The lower version of gralloc (gralloc-0.3) does not support 64-bit usage,
* so it needs to be truncated externally to 32-bit. And don't need 4G usage.
*/
printf("graphicbuffer re-alloc 32-bit usage\n");
gb = sp<GraphicBuffer>(new GraphicBuffer(width, height, format, (int)usage));
if (gb->initCheck()) {
printf("GraphicBuffer check error : %s\n",strerror(errno));
return NULL;
}
}
return gb;
}
/* Write data to buffer or init buffer. */
int GraphicBuffer_Fill(sp<GraphicBuffer> gb, int width, int height,int format, int flag, int index, int mode) {
int ret = 0;
char* buf = NULL;
size_t buf_size;
ret = gb->lock(GRALLOC_USAGE_SW_READ_OFTEN, (void**)&buf);
if (ret) {
printf("lock buffer error : %s\n",strerror(errno));
return -1;
}
buf_size = width * height * get_bpp_from_format(format);
if (mode == IM_FBC_MODE)
buf_size = buf_size * 1.5;
if(flag) {
memset(buf, index, buf_size);
} else {
ret = read_image_from_path(buf, IM2D_SLT_DEFAULT_INPUT_PATH, format, width, height, index, mode);
if (ret != 0) {
printf ("open file %s \n", "fault");
memset(buf, index, buf_size);
ret = -1;
goto unlock;
}
}
unlock:
ret = gb->unlock();
if (ret) {
printf("unlock buffer error : %s\n",strerror(errno));
return -1;
}
return ret;
}
#endif
/******************************************************************************/
void *pthread_rga_run(void *args) {
int ret = 0, time = 0;
unsigned int num;
int srcWidth,srcHeight,srcFormat;
int dstWidth,dstHeight,dstFormat;
char *src_va, *dst_va;
#if IM2D_SLT_DRM_BUFFER_EN
struct drm_object drm_src, drm_dst;
#elif IM2D_SLT_GRAPHICBUFFER_EN
sp<GraphicBuffer> src_buf;
sp<GraphicBuffer> dst_buf;
#elif IM2D_SLT_RK_DMA_HEAP_EN
int src_fd, dst_fd;
rga_buffer_handle_t src_handle, dst_handle;
#endif
rga_buffer_t src;
rga_buffer_t dst;
im_rect src_rect;
im_rect dst_rect;
private_data_t *data = (private_data_t *)args;
num = data->num;
srcWidth = data->width;
srcHeight = data->height;
srcFormat = data->format;
dstWidth = data->width;
dstHeight = data->height;
dstFormat = data->format;
memset(&src, 0x0, sizeof(src));
memset(&dst, 0x0, sizeof(dst));
memset(&src_rect, 0x0, sizeof(src_rect));
memset(&dst_rect, 0x0, sizeof(dst_rect));
do {
time++;
#if IM2D_SLT_DRM_BUFFER_EN
if (data->rd_mode != IM_FBC_MODE) {
drm_src.drm_buf = (uint8_t *)drm_buf_alloc(srcWidth, srcHeight, get_bpp_from_format(srcFormat) * 8,
&drm_src.drm_buffer_fd, &drm_src.drm_buffer_handle,
&drm_src.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);
drm_dst.drm_buf = (uint8_t *)drm_buf_alloc(dstWidth, dstHeight, get_bpp_from_format(dstFormat) * 8,
&drm_dst.drm_buffer_fd, &drm_dst.drm_buffer_handle,
&drm_dst.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);
src_va = (char *)drm_src.drm_buf;
dst_va = (char *)drm_dst.drm_buf;
ret = read_image_from_path(src_va, IM2D_SLT_DEFAULT_INPUT_PATH,
srcFormat, srcWidth, srcHeight, 0, data->rd_mode);
if (ret != 0) {
printf ("ID[%d] %s open file %s \n", data->id, data->name, "fault");
goto NORMAL_ERR;
}
memset(dst_va, 0xff, dstWidth * dstHeight * get_bpp_from_format(dstFormat));
} else {
drm_src.drm_buf = (uint8_t *)drm_buf_alloc(srcWidth, srcHeight * 1.5, get_bpp_from_format(srcFormat) * 8,
&drm_src.drm_buffer_fd, &drm_src.drm_buffer_handle,
&drm_src.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);
drm_dst.drm_buf = (uint8_t *)drm_buf_alloc(dstWidth, dstHeight * 1.5, get_bpp_from_format(dstFormat) * 8,
&drm_dst.drm_buffer_fd, &drm_dst.drm_buffer_handle,
&drm_dst.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);
src_va = (char *)drm_src.drm_buf;
dst_va = (char *)drm_dst.drm_buf;
ret = read_image_from_path(src_va, IM2D_SLT_DEFAULT_INPUT_PATH,
srcFormat, srcWidth, srcHeight, 0, data->rd_mode);
if (ret != 0) {
printf ("ID[%d] %s open file %s \n", data->id, data->name, "fault");
goto NORMAL_ERR;
}
memset(dst_va, 0xff, dstWidth * dstHeight * 1.5 * get_bpp_from_format(dstFormat));
}
src = wrapbuffer_fd(drm_src.drm_buffer_fd, srcWidth, srcHeight, srcFormat);
dst = wrapbuffer_fd(drm_dst.drm_buffer_fd, dstWidth, dstHeight, dstFormat);
if (src.width == 0 || dst.width == 0) {
printf("%s", imStrError());
goto NORMAL_ERR;
}
#elif IM2D_SLT_GRAPHICBUFFER_EN
if (data->rd_mode == IM_FBC_MODE) {
src_buf = GraphicBuffer_Init(srcWidth, srcHeight * 1.5, srcFormat,
data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
dst_buf = GraphicBuffer_Init(dstWidth, dstHeight * 1.5, dstFormat,
data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
} else {
src_buf = GraphicBuffer_Init(srcWidth, srcHeight, srcFormat,
data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
dst_buf = GraphicBuffer_Init(dstWidth, dstHeight, dstFormat,
data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
}
if (src_buf == NULL || dst_buf == NULL) {
printf("GraphicBuff init error!\n");
goto NORMAL_ERR;
}
if(-1 == GraphicBuffer_Fill(src_buf, srcWidth, srcHeight, srcFormat, FILL_BUFF, 0, data->rd_mode)) {
printf("%s, src write Graphicbuffer error!\n", __FUNCTION__);
goto NORMAL_ERR;
}
if(-1 == GraphicBuffer_Fill(dst_buf, dstWidth, dstHeight, dstFormat, EMPTY_BUFF, 0xff, data->rd_mode)) {
printf("%s, dst write Graphicbuffer error!\n", __FUNCTION__);
goto NORMAL_ERR;
}
src = wrapbuffer_GraphicBuffer(src_buf);
src = wrapbuffer_fd(src.fd, srcWidth, srcHeight, srcFormat);
dst = wrapbuffer_GraphicBuffer(dst_buf);
dst = wrapbuffer_fd(dst.fd, dstWidth, dstHeight, dstFormat);
/* If it is in fbc mode, because the height of the alloc memory
* is modified, it needs to be corrected here */
if (data->rd_mode == IM_FBC_MODE) {
src.height = srcHeight;
src.hstride = srcHeight;
dst.height = dstHeight;
dst.hstride = dstHeight;
}
if (src.width == 0 || dst.width == 0) {
printf("%s", imStrError());
}
#elif IM2D_SLT_RK_DMA_HEAP_EN
ret = dma_buf_alloc(srcWidth, srcHeight, srcFormat, &src_fd, (void **)&src_va);
if (ret < 0) {
printf("ID[%d] %s alloc src dma_buf failed!\n", data->id, data->name);
goto NORMAL_ERR;
}
ret = dma_buf_alloc(dstWidth, dstHeight, dstFormat, &dst_fd, (void **)&dst_va);
if (ret < 0) {
printf("ID[%d] %s alloc dst dma_buf failed!\n", data->id, data->name);
goto NORMAL_ERR;
}
dma_sync_device_to_cpu(src_fd);
dma_sync_device_to_cpu(dst_fd);
ret = read_image_from_path(src_va, IM2D_SLT_DEFAULT_INPUT_PATH,
srcFormat, srcWidth, srcHeight, 0, data->rd_mode);
if (ret != 0) {
printf ("ID[%d] %s open file %s \n", data->id, data->name, "fault");
goto NORMAL_ERR;
}
memset(dst_va, 0xff, dstWidth * dstHeight * get_bpp_from_format(dstFormat));
dma_sync_cpu_to_device(src_fd);
dma_sync_cpu_to_device(dst_fd);
src_handle = importbuffer_fd(src_fd, srcWidth, srcHeight, srcFormat);
if (src_handle <= 0) {
printf("ID[%d] %s import src dma_buf failed!\n", data->id, data->name);
goto NORMAL_ERR;
}
dst_handle = importbuffer_fd(dst_fd, dstWidth, dstHeight, dstFormat);
if (dst_handle <= 0) {
printf("ID[%d] %s import dst dma_buf failed!\n", data->id, data->name);
releasebuffer_handle(src_handle);
goto NORMAL_ERR;
}
src = wrapbuffer_handle(src_handle, srcWidth, srcHeight, srcFormat);
dst = wrapbuffer_handle(dst_handle, dstWidth, dstHeight, dstFormat);
if (src.width == 0 || dst.width == 0) {
printf("%s", imStrError());
releasebuffer_handle(src_handle);
releasebuffer_handle(dst_handle);
goto NORMAL_ERR;
}
#endif
ret = imcheck(src, dst, src_rect, dst_rect);
if (ret != IM_STATUS_NOERROR) {
printf("ID[%d]: %s check %d time error! %s", data->id, data->name, time, imStrError((IM_STATUS)ret));
goto NORMAL_ERR;
}
imconfig(IM_CONFIG_SCHEDULER_CORE, data->core);
imconfig(IM_CONFIG_PRIORITY, data->priority);
src.rd_mode = data->rd_mode;
dst.rd_mode = data->rd_mode;
ret = imcopy(src, dst);
if (ret == IM_STATUS_SUCCESS) {
printf("ID[%d]: %s imcopy %d time success!\n", data->id, data->name, time);
#if IM2D_SLT_GRAPHICBUFFER_EN
ret = src_buf->lock(GRALLOC_USAGE_SW_READ_OFTEN, (void**)&src_va);
if (ret) {
printf("lock src_buf error : %s\n",strerror(errno));
goto NORMAL_ERR;
}
ret = dst_buf->lock(GRALLOC_USAGE_SW_READ_OFTEN, (void**)&dst_va);
if (ret) {
printf("lock dst_buf error : %s\n",strerror(errno));
goto NORMAL_ERR;
}
#elif IM2D_SLT_RK_DMA_HEAP_EN
dma_sync_device_to_cpu(src_fd);
dma_sync_device_to_cpu(dst_fd);
#endif
ret = memcmp(src_va, dst_va, dst.wstride * dst.hstride * get_bpp_from_format(dst.format));
if (ret < 0) {
printf("ID[%d]: %s check buffer %d time error!\n", data->id, data->name, time);
printf("src: %x %x %x %x\n", (int)src_va[0], (int)src_va[1], (int)src_va[2], (int)src_va[3]);
printf("dst: %x %x %x %x\n", (int)dst_va[0], (int)dst_va[1], (int)dst_va[2], (int)dst_va[3]);
write_image_to_path(dst_va, IM2D_SLT_DEFAULT_OUTPUT_PATH,
dst.format, dst.wstride, dst.hstride, data->id + 1, dst.rd_mode);
write_image_to_path(src_va, IM2D_SLT_DEFAULT_OUTPUT_PATH,
src.format, src.wstride, src.hstride, data->id + 2, src.rd_mode);
goto CHECK_ERR;
} else {
printf("ID[%d]: %s check buffer %d time success!\n", data->id, data->name, time);
}
#if IM2D_SLT_GRAPHICBUFFER_EN
ret = src_buf->unlock();
if (ret) {
printf("unlock src_buf error : %s\n",strerror(errno));
goto NORMAL_ERR;
}
ret = dst_buf->unlock();
if (ret) {
printf("unlock dst_buf error : %s\n",strerror(errno));
goto NORMAL_ERR;
}
#endif
} else {
printf("ID[%d]: %s run %d time error!, %s\n", data->id, data->name, time, imStrError((IM_STATUS)ret));
goto NORMAL_ERR;
}
#if IM2D_SLT_DRM_BUFFER_EN
drm_buf_destroy(drm_src.drm_buffer_fd, drm_src.drm_buffer_handle,
drm_src.drm_buf, drm_src.actual_size);
drm_buf_destroy(drm_dst.drm_buffer_fd, drm_dst.drm_buffer_handle,
drm_dst.drm_buf, drm_dst.actual_size);
#elif IM2D_SLT_RK_DMA_HEAP_EN
releasebuffer_handle(src_handle);
releasebuffer_handle(dst_handle);
dma_buf_free(srcWidth, srcHeight, srcFormat, &src_fd, (void *)src_va);
dma_buf_free(dstWidth, dstHeight, dstFormat, &dst_fd, (void *)dst_va);
#endif
} while (data->mode && --num);
#if IM2D_SLT_THREAD_EN
data->result = 0;
pthread_exit(NULL);
NORMAL_ERR:
data->result = -1;
pthread_exit(NULL);
CHECK_ERR:
data->result = -2;
pthread_exit(NULL);
#else
data->result = 0;
return NULL;
NORMAL_ERR:
data->result = -1;
return NULL;
CHECK_ERR:
data->result = -2;
return NULL;
#endif
}
int main() {
int pthread_num = 0;
pthread_t tdSyncID[IM2D_SLT_THREAD_MAX];
private_data_t data[IM2D_SLT_THREAD_MAX];
memset(&data, 0x0, sizeof(private_data_t) * IM2D_SLT_THREAD_MAX);
printf("-------------------------------------------------\n");
#if IM2D_SLT_TEST_RGA3_0_EN
pthread_num++;
data[pthread_num].id = pthread_num;
data[pthread_num].name = "RGA3_core0";
data[pthread_num].mode = IM2D_SLT_WHILE_EN;
data[pthread_num].num = IM2D_SLT_WHILE_NUM;
data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
data[pthread_num].rd_mode = IM_RASTER_MODE;
data[pthread_num].core = IM_SCHEDULER_RGA3_CORE0;
data[pthread_num].priority = 1;
#endif
#if IM2D_SLT_TEST_RGA3_1_EN
pthread_num++;
data[pthread_num].id = pthread_num;
data[pthread_num].name = "RGA3_core1";
data[pthread_num].mode = IM2D_SLT_WHILE_EN;
data[pthread_num].num = IM2D_SLT_WHILE_NUM;
data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
data[pthread_num].rd_mode = IM_RASTER_MODE;
data[pthread_num].core = IM_SCHEDULER_RGA3_CORE1;
data[pthread_num].priority = 1;
#endif
#if IM2D_SLT_TEST_RGA2_EN
pthread_num++;
data[pthread_num].id = pthread_num;
data[pthread_num].name = "RGA2";
data[pthread_num].mode = IM2D_SLT_WHILE_EN;
data[pthread_num].num = IM2D_SLT_WHILE_NUM;
data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
data[pthread_num].rd_mode = IM_RASTER_MODE;
data[pthread_num].core = IM_SCHEDULER_RGA2_CORE0;
data[pthread_num].priority = 1;
#endif
#if IM2D_SLT_TEST_RGA3_0_FBC_EN
pthread_num++;
data[pthread_num].id = pthread_num;
data[pthread_num].name = "RGA3_core0_fbc";
data[pthread_num].mode = IM2D_SLT_WHILE_EN;
data[pthread_num].num = IM2D_SLT_WHILE_NUM;
data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
data[pthread_num].rd_mode = IM_FBC_MODE;
data[pthread_num].core = IM_SCHEDULER_RGA3_CORE0;
data[pthread_num].priority = 1;
#endif
#if IM2D_SLT_TEST_RGA3_1_FBC_EN
pthread_num++;
data[pthread_num].id = pthread_num;
data[pthread_num].name = "RGA3_core1_fbc";
data[pthread_num].mode = IM2D_SLT_WHILE_EN;
data[pthread_num].num = IM2D_SLT_WHILE_NUM;
data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
data[pthread_num].rd_mode = IM_FBC_MODE;
data[pthread_num].core = IM_SCHEDULER_RGA3_CORE1;
data[pthread_num].priority = 1;
#endif
#if IM2D_SLT_THREAD_EN
for (int i = 1; i <= pthread_num; i++) {
pthread_create(&tdSyncID[i], NULL, pthread_rga_run, (void *)(&data[i]));
printf("creat Sync pthread[0x%lx] = %d, id = %d\n", tdSyncID[i], i, data[i].id);
}
for (int i = 1; i <= pthread_num; i++) {
pthread_join(tdSyncID[i], NULL);
if (data[i].result < 0) {
printf("ID[%d] case '%s' is faile!\n", data[i].id, data[i].name);
printf("-------------------------------------------------\n");
printf("im2d api slt fail!\n");
return -1;
}
}
printf("-------------------------------------------------\n");
printf("im2d api slt success!\n");
return 0;
#else
(void)(tdSyncID);
for (int i = 1; i <= pthread_num; i++) {
pthread_rga_run((void *)(&data[i]));
printf("ID[%d] %s run end!\n", data[i].id, data[i].name);
if (data[i].result < 0) {
printf("ID[%d] case '%s' is faile!\n", data[i].id, data[i].name);
return -1;
}
}
printf("-------------------------------------------------\n");
printf("im2d api slt success!\n");
return 0;
#endif
}