cubie/a7z/app-dev/npu-dev/g2d-usage-guide

[giscus[bot]]

cubie/a7z/app-dev/npu-dev/g2d-usage-guide

https://docs.radxa.com/cubie/a7z/app-dev/npu-dev/g2d-usage-guide

[ZivenMan]

我碰到一个权限问题（表面看起来是权限问题，实际可能不是），求助。我的设备信息：
radxa@radxa-cubie-a7z:~/Documents/G2D$ lsmod | grep g2d
g2d_sunxi 90112 0

radxa@radxa-cubie-a7z:~/Documents/G2D$ ls -la /dev/g2d
crw-rw-rw- 1 radxa root 235, 0 May 13 02:50 /dev/g2d (对应Mode: 0666)

radxa@radxa-cubie-a7z:~/Documents/G2D$ ls -la /dev/dma_heap/system
crw-rw-rw-+ 1 radxa root 253, 0 May 13 02:47 /dev/dma_heap/system (对应Mode: 0666)

并配置了udev规则到文件 /etc/udev/rules.d/99-g2d.rules：
KERNEL=="g2d", MODE="0666", OWNER="radxa"
KERNEL=="system", SUBSYSTEM=="dma_heap", MODE="0666", OWNER="radxa"

在执行文件时（用sudo或直接执行）仍然出现错误：
radxa@radxa-cubie-a7z:~/Documents/G2D$ sudo ./g2d_rotate
alloc src buff result value: 0
[ 1396.997255][ C0] L2 PageTable Invalid
[ 1397.001906][ C0] 0x0x00000000fdfed000 is not mapped!
[ 1397.007797][ C0] Bug is in G2D module, invalid address: 0xfdfed000, data:0x0, id:0x10

open g2d fd result value: 3
Open G2D fd Status: Success
[ 1397.098272][ T7174] sunxi:g2d_sunxi:[ERR]: [G2D]: G2D irq pending flag timeout
Fail to Invoke IOCTL. result value: -1
G2D ioctl Status: Operation not permitted
有时是这样：
radxa@radxa-cubie-a7z:~/Documents/G2D$ sudo ./g2d_rotate
alloc src buff result value: 0
alloc dst buff result value: 0 [ 1383.290150][ C0] L2 PageTable Invalid
[ 1383.295992][ C0] 0x0x00000000fdfed000 is not mapped!
[ 1383.301877][ C0] Bug is in G2D module, invalid address: 0xfdfed000, data:0x0, id:0x10

open g2d fd result value: 3
Open G2D fd Status: Success
[ 1383.390178][ T7172] sunxi:g2d_sunxi:[ERR]: [G2D]: G2D irq pending flag timeout
Fail to Invoke IOCTL. result value: -1
G2D ioctl Status: Operation not permitted

我的代码为：
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <bsp/linux/sunxi-g2d.h>
#include <linux/dma-heap.h>
#include <sys/mman.h>
#include <string.h>
#include <stdint.h>
#include <error.h>

#define W 1920
#define H 1080

static int alloc_dmabuf(int *fd, void **vaddr, size_t size)
{
struct dma_heap_allocation_data alloc_data = {
.len = size, .fd_flags = O_RDWR | O_CLOEXEC, .heap_flags = 0,
};
int heap_fd = open("/dev/dma_heap/system", O_RDONLY);
if (heap_fd < 0) return -1;
if (ioctl(heap_fd, DMA_HEAP_IOCTL_ALLOC, &alloc_data) < 0) {
close(heap_fd); return -1;
}
close(heap_fd);
*fd = alloc_data.fd;
*vaddr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, *fd, 0);
if (*vaddr == MAP_FAILED) { close(*fd); return -1; }
return 0;
}

int main(void)
{
int g2d_fd, src_fd, dst_fd;
int ret = -100;
void *src_v, *dst_v;
g2d_blt_h blit;

ret = alloc_dmabuf(&src_fd, &src_v, W * H * 4);
printf("alloc src buff result value: %d \n", ret);

alloc_dmabuf(&dst_fd, &dst_v, W * H * 4);
printf("alloc dst buff result value: %d \n\n", ret);

//fill_pattern(src_v, W, H);

g2d_fd = open("/dev/g2d", O_RDWR);

printf("open g2d fd result value: %d \n", g2d_fd);

perror("Open G2D fd Status");

memset(&blit, 0, sizeof(blit));
blit.flag_h = G2D_ROT_90;  
blit.src_image_h.fd = src_fd;
blit.src_image_h.format = G2D_FORMAT_ARGB8888;
blit.src_image_h.width = W;
blit.src_image_h.height = H;

blit.dst_image_h.fd = dst_fd;
blit.dst_image_h.format = G2D_FORMAT_ARGB8888;
blit.dst_image_h.width = H; 
blit.dst_image_h.height = W;

ret = ioctl(g2d_fd, G2D_CMD_BITBLT_H, (void *)(&blit));

if (0 != ret)
{
  printf("Fail to Invoke IOCTL. result value: %d \n", ret);
  perror("G2D ioctl Status");
}


close(g2d_fd); 
munmap(src_v, W * H * 4); close(src_fd);
munmap(dst_v, W * H * 4); close(dst_fd);
return 0;

}

[ZivenMan]

补充一下，我用的R6 KDE。

[ZivenMan]

我艹， 我将这一行： ret = ioctl(g2d_fd, G2D_CMD_BITBLT_H, (void *)(&blit));，修改成： ret = ioctl(g2d_fd, G2D_CMD_BITBLT, (void *)(&blit));，没有权限报错了。文档《Linux_G2D_开发指南.pdf》中说，G2D_CMD_BITBLT_H是2.0接口，G2D_CMD_BITBLT是1.0接口。

[ZivenMan]

虽然，弄成G2D_CMD_BITBLT能执行，但是转换后的图像是空的，全黑。太难搞了...................

[ZivenMan]

伙计们，我用该页面“4.示例运行结果”里提示里说到的github中的格式转换示例（https://github.com/Ronin-1124/allwinner-g2d-usage-guide/blob/main/g2d_format_conversion.c）跑通了。我的代码为：

[ZivenMan]

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <bsp/linux/sunxi-g2d.h>
#include <linux/dma-heap.h>
#include <sys/mman.h>
#include <string.h>
#include <stdint.h>
#include <error.h>
#include <time.h>

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include

using namespace cv;

#define IMAGE_WIDTH 1920
#define IMAGE_HEIGHT 1080

#define DMA_HEAP_NAME "/dev/dma_heap/system"

#define get_time_ms() ({
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
ts.tv_sec * 1000.0 + ts.tv_nsec / 1e6;
})

/* BGR888: 3 bytes/pixel; YUV420 (NV12): 1.5 bytes/pixel */
#define SRC_SIZE (IMAGE_WIDTH * IMAGE_HEIGHT * 3)
#define DST_SIZE (IMAGE_WIDTH * IMAGE_HEIGHT * 3 / 2)

static int alloc_dmabuf(int *fd, void **vaddr, size_t size)
{
struct dma_heap_allocation_data alloc_data = {
.len = size,
.fd_flags = O_RDWR | O_CLOEXEC,
.heap_flags = 0,
};

int heap_fd = open(DMA_HEAP_NAME, O_RDONLY);
if (heap_fd < 0) {
    perror("open DMA heap");
    return -1;
}

if (ioctl(heap_fd, DMA_HEAP_IOCTL_ALLOC, &alloc_data) < 0) {
    perror("DMA_HEAP_IOCTL_ALLOC");
    close(heap_fd);
    return -1;
}
close(heap_fd);

*fd = alloc_data.fd;
*vaddr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, *fd, 0);
if (*vaddr == MAP_FAILED) {
    perror("mmap");
    close(*fd);
    return -1;
}
return 0;

}

int main(void)
{
int g2d_fd, src_fd, dst_fd;
void *src_v, *dst_v;
g2d_blt_h blit;
double t0, t1;
double t_g2d_start = 0;
double t_g2d_end = 0;
int ret = -1000;

t0 = get_time_ms();

if (alloc_dmabuf(&src_fd, &src_v, SRC_SIZE) < 0)
    return 1;
if (alloc_dmabuf(&dst_fd, &dst_v, DST_SIZE) < 0) {
    munmap(src_v, SRC_SIZE);
    close(src_fd);
    return 1;
}

cv::Mat bgr_img = cv::imread("lake.jpg", cv::IMREAD_COLOR); 
if (bgr_img.empty()) {
    std::cerr << "Fail to Read Image." << std::endl;
    return -1;
}   

memcpy(src_v, bgr_img.data, SRC_SIZE);     

memset(dst_v, 128, DST_SIZE);
cv::Mat yuv_image(IMAGE_HEIGHT * 3 / 2, IMAGE_WIDTH, CV_8UC1, dst_v);
cv::Mat saved_image;

g2d_fd = open("/dev/g2d", O_RDWR);
if (g2d_fd < 0) {
    perror("open /dev/g2d");
    goto cleanup;
}

memset(&blit, 0, sizeof(blit));
blit.flag_h = G2D_BLT_NONE_H;

blit.src_image_h.use_phy_addr = 0;
blit.src_image_h.fd = src_fd;
blit.src_image_h.bbuff = 1;
blit.src_image_h.mode = G2D_PIXEL_ALPHA;
blit.src_image_h.alpha = 0xff;
blit.src_image_h.format = G2D_FORMAT_BGR888;
blit.src_image_h.width = IMAGE_WIDTH;
blit.src_image_h.height = IMAGE_HEIGHT;
blit.src_image_h.clip_rect.x = 0;
blit.src_image_h.clip_rect.y = 0;
blit.src_image_h.clip_rect.w = IMAGE_WIDTH;
blit.src_image_h.clip_rect.h = IMAGE_HEIGHT;

blit.dst_image_h.use_phy_addr = 0;
blit.dst_image_h.fd = dst_fd;
blit.dst_image_h.bbuff = 1;
blit.dst_image_h.mode = G2D_PIXEL_ALPHA;
blit.dst_image_h.alpha = 0xff;
blit.dst_image_h.format = G2D_FORMAT_YUV420UVC_U1V1U0V0;
blit.dst_image_h.width = IMAGE_WIDTH;
blit.dst_image_h.height = IMAGE_HEIGHT;
blit.dst_image_h.clip_rect.x = 0;
blit.dst_image_h.clip_rect.y = 0;
blit.dst_image_h.clip_rect.w = IMAGE_WIDTH;
blit.dst_image_h.clip_rect.h = IMAGE_HEIGHT;

t_g2d_start = get_time_ms();
ret = ioctl(g2d_fd, G2D_CMD_BITBLT_H, (unsigned long)(&blit));
t_g2d_end = get_time_ms();

if (ret < 0) {
    fprintf(stderr, "G2D_CMD_BITBLT_H failed: %s\n", strerror(errno));
    goto cleanup;
}


cv::cvtColor(yuv_image, saved_image, cv::COLOR_YUV2RGB_I420); 

cv::imwrite("final_image.jpg", saved_image);     

printf("G2D format conv (BGR888→YUV420): %.2f ms\n", t_g2d_end - t_g2d_start);
printf("throughput: %.1f MP/sec\n", (IMAGE_WIDTH * IMAGE_HEIGHT) / 1e6 / ((t_g2d_end - t_g2d_start) / 1000.0));
printf("compression: %.2f%% (%.2f MB → %.2f MB)\n",  (DST_SIZE * 100.0) / SRC_SIZE, SRC_SIZE / 1e6, DST_SIZE / 1e6);

cleanup:
close(g2d_fd);
munmap(src_v, SRC_SIZE);
munmap(dst_v, DST_SIZE);
close(src_fd);
close(dst_fd);

t1 = get_time_ms();
printf("total: %.2f ms\n", t1 - t0);
return 0;

}