// 1. 打开V4L2设备
int v4l2_fd = open("/dev/video0", O_RDWR);

// 2. 设置视频格式
struct v4l2_format fmt = {
    .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
    .fmt.pix = { .width = 1920, .height = 1080, 
                 .pixelformat = V4L2_PIX_FMT_YUYV }
};
ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt);

// 3. 🔥 申请DMA-BUF缓冲区（零拷贝核心）
struct v4l2_requestbuffers req = {
    .count = 4,
    .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
    .memory = V4L2_MEMORY_DMABUF  // 关键：零拷贝模式
};
ioctl(v4l2_fd, VIDIOC_REQBUFS, &req);

// 4. 🔥 导出DMA-BUF文件描述符
struct v4l2_exportbuffer expbuf = { .type = ..., .index = 0, .flags = O_CLOEXEC };
ioctl(v4l2_fd, VIDIOC_EXPBUF, &expbuf);
int dma_fd = expbuf.fd;  // 🔥 这个fd可直接传给DRM/GPU/NPU

// 5. 入队缓冲区
struct v4l2_buffer buf = { .type = ..., .memory = V4L2_MEMORY_DMABUF, .index = 0 };
ioctl(v4l2_fd, VIDIOC_QBUF, &buf);

// 6. 启动采集
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ioctl(v4l2_fd, VIDIOC_STREAMON, &type);

// 7. 🔥 采集循环：获取dma_fd（零拷贝关键）
while (1) {
    ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);  // 取帧
    int current_dma_fd = buffers[buf.index].dma_fd;
    // 🔥 current_dma_fd 可直接传给DRM/GPU/NPU，全程零拷贝！
    process_with_dma_fd(current_dma_fd);
    ioctl(v4l2_fd, VIDIOC_QBUF, &buf);  // 回收缓冲区
}

# 编译
gcc v4l2_dmabuf_capture.c -o v4l2_capture -Wall

# 运行（需要root权限访问DMA-BUF）
sudo ./v4l2_capture /dev/video0

# 预期输出：
# ========== V4L2 DMA-BUF零拷贝采集演示 ==========
# 成功打开设备：/dev/video0
# 支持的像素格式：
#   [YUYV] YUYV 4:2:2
#   [NV12] Y/CbCr 4:2:0
# 视频格式设置：1920x1080, 字节行宽：3840
# 申请DMA-BUF缓冲区数量：4
#   缓冲区[0]: dma_fd=35, 长度=4147200 bytes
#   缓冲区[1]: dma_fd=36, 长度=4147200 bytes
#   缓冲区[2]: dma_fd=37, 长度=4147200 bytes
#   缓冲区[3]: dma_fd=38, 长度=4147200 bytes
# 所有缓冲区已入队
# 视频采集已启动
# 
# 开始采集（按Ctrl+C退出）...
# 采集到帧: index=0, dma_fd=35, bytesused=4147200
#   [帧0] 🔥 零拷贝关键: dma_fd=35 可直接传给DRM/GPU/NPU

# 1. 检查摄像头是否支持DMABUF模式
v4l2-ctl -d /dev/video0 --list-formats-ext

# 2. 查看V4L2设备信息
v4l2-ctl -d /dev/video0 --all

# 3. 检查DMA-BUF支持
ls /sys/class/dma-buf/

# 4. 查看设备节点权限
ls -la /dev/video0

# 5. dmesg查看驱动日志
dmesg | grep -i "v4l2\|mipi\|csi"

// 1. 打开DRM设备
int drm_fd = open("/dev/dri/card0", O_RDWR);

// 2. 🔥 从dma_fd创建DRM Framebuffer（零拷贝核心）
struct drm_prime_handle prime = { .fd = v4l2_dma_fd };
ioctl(drm_fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime);

// 3. 创建Framebuffer
uint32_t handles[] = { prime.handle };
uint32_t pitches[] = { width * 2 };  // YUYV: 2 bytes/pixel
drmModeAddFB2(drm_fd, width, height, DRM_FORMAT_YUYV, 
               handles, pitches, offsets, &fb_id, 0);

// 4. 🔥 零拷贝显示
drmModeSetCrtc(drm_fd, crtc_id, fb_id, 0, 0, &connector_id, 1, &mode);

// 零拷贝主循环：摄像头 → DMA-BUF → DRM显示
while (1) {
    // V4L2采集（获取dma_fd）
    ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);
    int dma_fd = buffers[buf.index].dma_fd;

    // DRM从dma_fd创建Framebuffer（零拷贝）
    drm_create_fb_from_dmabuf(drm_fd, dma_fd, width, height, &fb_id);

    // DRM直接显示（零拷贝）
    drmModeSetCrtc(drm_fd, crtc_id, fb_id, 0, 0, &connector_id, 1, &mode);

    // 回收V4L2缓冲区
    ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
}

// 1. 初始化CUDA
cuInit(0);
cuDeviceGet(&cuDevice, 0);
cuCtxCreate(&cuContext, 0, cuDevice);
cuStreamCreate(&cuStream, 0);

// 2. 🔥 从DMA-BUF fd创建CUDA内存（零拷贝核心）
CUDA_EXTERNAL_MEMORY_HANDLE_DESC extDesc = {
    .type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD,
    .handle.fd = v4l2_dma_fd,  // V4L2的dma_fd
    .size = buf_size,
    .flags = 0
};
cuImportExternalMemory(&ext_mem, &extDesc);
cuExternalMemoryGetMappedBuffer(&device_ptr, ext_mem, &bufDesc);

// 3. 🔥 GPU零拷贝处理
dim3 block(16, 16), grid(width/16, height/16);
grayscale_kernel<<<grid, block>>>(
    (unsigned char*)device_ptr,  // 直接使用DMA-BUF内存
    d_output, width, height, pitch);
cuStreamSynchronize(cuStream);

// 1. 初始化RKNN模型
rknn_init(&ctx, model_path, 0, RKNN_FLAG_PRIOR_LOW);

// 2. 🔥 从DMA-BUF设置RKNN输入（零拷贝核心）
rknn_input rknn_in = {
    .index = 0,
    .type = RKNN_TENSOR_TYPE_UINT8,
    .fd = v4l2_dma_fd,  // 🔥 直接使用V4L2的dma_fd！
    .pass_through = 1,   // 🔥 启用透传模式
    .width_with_stride = img_width * 2
};
rknn_inputs_set(ctx, io_num.n_input, &rknn_in);

// 3. 🔥 执行推理（零拷贝）
rknn_run(ctx, NULL);

// 4. 获取输出结果
rknn_output outputs[2] = {0};
outputs[0].want_float = 1;
rknn_outputs_get(ctx, io_num.n_output, outputs, NULL);

// NPU零拷贝主循环：摄像头 → DMA-BUF → NPU推理
while (frame_count < 100) {
    // V4L2采集（获取dma_fd）
    ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);
    int dma_fd = buffers[buf.index].dma_fd;

    // RKNN直接使用dma_fd推理（零拷贝）
    rknn_in.fd = dma_fd;
    rknn_inputs_set(ctx, 1, &rknn_in);
    rknn_run(ctx, NULL);
    rknn_outputs_get(ctx, 2, outputs, NULL);

    // 处理检测结果
    process_detection_results(outputs);

    // 回收V4L2缓冲区
    ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
}

# 1. 检查DMA-BUF支持
ls /sys/class/dma-buf/
cat /proc/dma-buf/buffers

# 2. 检查V4L2 DMABUF支持
v4l2-ctl -d /dev/video0 --list-formats-ext
v4l2-ctl -d /dev/video0 --get-formats

# 3. 检查DRM PRIME支持
ls /sys/class/drm/
cat /sys/class/drm/card0/device/drm/card0/prime_import

# 4. 查看DMA-BUF关联
ls /sys/kernel/debug/dri/

# 5. 跟踪DMA-BUF操作
echo 1 > /sys/module/drm/parameters/debug
dmesg | grep -i "dma_buf\|prime"

# 6. 检查NPU驱动
ls /dev/video*
cat /sys/class/video4linux/video*/name
rknn_toolkit2 -I  # RKNN信息

#!/bin/bash
# 零拷贝性能测试脚本

echo "========== Linux零拷贝性能测试 =========="

# 测试V4L2 DMA-BUF
echo "1. V4L2 DMA-BUF测试"
./v4l2_capture /dev/video0 &
V4L2_PID=$!
sleep 5
kill $V4L2_PID

# 测试DRM显示
echo "2. DRM显示测试"
./drm_display /dev/dri/card0 &
DRM_PID=$!
sleep 5
kill $DRM_PID

# 性能指标收集
echo "3. 性能指标"
echo "  CPU占用: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')%"
echo "  内存带宽: $(vmstat 1 1 | tail -1 | awk '{print $9" MB/s"}')"
echo "  DMA-BUF数量: $(ls /sys/class/dma-buf/ | wc -l)"

echo "测试完成"

┌─────────────────────────────────────────────────────────────┐
│  DMA-BUF = 跨设备物理内存共享机制                            │
│  文件描述符fd = 共享句柄跨进程/跨设备传递                    │
│  全程CPU零拷贝、内存只存一份                                 │
└─────────────────────────────────────────────────────────────┘