Linux下GPU显存直出HDMI实现60fps全高清画面的子系统选型咨询

1. 首选子系统组合：DRM + GBM + OpenGL ES #

要实现Linux下从GPU显存（OpenGL ES渲染）快速输出1080p@60fps的HDMI画面，DRM（Direct Rendering Manager）是核心基础，搭配GBM（Generic Buffer Management）作为显存缓冲区的中间管理层，再结合OpenGL ES完成渲染，这是当前Linux嵌入式/桌面场景下的标准方案。

2. DRM是否足以完成任务？ #

完全足够。DRM是Linux内核中负责图形硬件直接访问的核心子系统，天生适配这类需求：

• 支持HDMI接口的模式设置，可直接配置1920x1080@60Hz的显示参数
• 提供页翻转（Page Flip）机制，能实现无撕裂的60fps画面输出
• 可与GPU驱动直接交互，支持将OpenGL ES渲染的显存缓冲区直接提交给显示控制器，全程无需CPU拷贝数据，保证性能

3. 通用架构实现思路 #

核心是让OpenGL ES渲染的缓冲区直接被DRM识别并输出，流程如下：

• DRM初始化：打开DRM设备节点（通常是/dev/dri/card0），遍历系统中的显示连接器，找到HDMI设备，获取并设置目标分辨率和刷新率的显示模式，绑定CRTC（显示控制器）与HDMI连接器。
• GBM缓冲区创建：通过GBM创建与DRM兼容的GPU显存缓冲区，这些缓冲区会作为OpenGL ES的渲染目标，确保渲染内容直接写入DRM可访问的显存区域。
• OpenGL ES上下文绑定：通过EGL（Embedded-System Graphics Library）将GBM表面作为渲染表面，初始化OpenGL ES上下文，让渲染操作直接作用于GBM缓冲区。
• 渲染输出循环：
  • 用OpenGL ES在当前缓冲区渲染一帧内容
  • 调用DRM的页翻转接口，将渲染完成的缓冲区提交到HDMI显示
  • 等待页翻转完成的内核信号，切换到下一个缓冲区开始渲染（双缓冲或三缓冲避免卡顿）

4. 简化示例代码 #

以下是核心流程的简化C代码，仅保留关键逻辑，实际使用需要补充错误处理、模式查询等细节：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <drm/drm.h>
#include <drm/drm_mode.h>
#include <gbm.h>
#include <EGL/egl.h>
#include <GLES2/gl2.h>

// 存储DRM核心数据
typedef struct {
    int fd;
    uint32_t crtc_id;
    uint32_t connector_id;
    drm_mode_modeinfo mode;
} DrmData;

// 简化的DRM初始化，实际需完善连接器、CRTC、模式查询逻辑
int drm_setup(DrmData *drm) {
    drm->fd = open("/dev/dri/card0", O_RDWR);
    if (drm->fd < 0) {
        perror("Failed to open DRM device");
        return -1;
    }

    // 此处省略：遍历连接器找到HDMI设备、查询支持的1920x1080@60Hz模式、匹配CRTC的逻辑
    // 假设已获取到合法的crtc_id、connector_id和mode参数

    // 设置显示模式
    if (drm_mode_setcrtc(drm->fd, drm->crtc_id, 0, 0, 0, &drm->connector_id, 1, &drm->mode) < 0) {
        perror("Failed to set CRTC mode");
        close(drm->fd);
        return -1;
    }
    return 0;
}

int main() {
    DrmData drm;
    if (drm_setup(&drm) != 0) return 1;

    // 初始化GBM设备和表面
    struct gbm_device *gbm = gbm_create_device(drm.fd);
    if (!gbm) {
        perror("Failed to create GBM device");
        close(drm.fd);
        return 1;
    }

    struct gbm_surface *gbm_surf = gbm_surface_create(
        gbm, 1920, 1080, GBM_FORMAT_XRGB8888,
        GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT
    );
    if (!gbm_surf) {
        perror("Failed to create GBM surface");
        gbm_device_destroy(gbm);
        close(drm.fd);
        return 1;
    }

    // 初始化EGL和OpenGL ES上下文
    EGLDisplay egl_dpy = eglGetDisplay(gbm);
    if (egl_dpy == EGL_NO_DISPLAY) {
        perror("Failed to get EGL display");
        gbm_surface_destroy(gbm_surf);
        gbm_device_destroy(gbm);
        close(drm.fd);
        return 1;
    }

    EGLint major, minor;
    if (!eglInitialize(egl_dpy, &major, &minor)) {
        perror("Failed to initialize EGL");
        gbm_surface_destroy(gbm_surf);
        gbm_device_destroy(gbm);
        close(drm.fd);
        return 1;
    }

    // EGL配置选择
    EGLConfig config;
    EGLint num_configs;
    EGLint attribs[] = {
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
        EGL_RED_SIZE, 8,
        EGL_GREEN_SIZE, 8,
        EGL_BLUE_SIZE, 8,
        EGL_NONE
    };
    if (!eglChooseConfig(egl_dpy, attribs, &config, 1, &num_configs) || num_configs == 0) {
        perror("Failed to choose EGL config");
        eglTerminate(egl_dpy);
        gbm_surface_destroy(gbm_surf);
        gbm_device_destroy(gbm);
        close(drm.fd);
        return 1;
    }

    EGLContext egl_ctx = eglCreateContext(egl_dpy, config, EGL_NO_CONTEXT, NULL);
    EGLSurface egl_surf = eglCreateWindowSurface(egl_dpy, config, gbm_surf, NULL);
    eglMakeCurrent(egl_dpy, egl_surf, egl_surf, egl_ctx);

    // 创建双缓冲区并绑定DRM帧缓冲
    struct gbm_bo *bo[2];
    uint32_t fb_id[2];
    for (int i = 0; i < 2; i++) {
        bo[i] = gbm_surface_lock_front_buffer(gbm_surf);
        drm_mode_fb_create(drm.fd, 1920, 1080, 24, 32, gbm_bo_get_stride(bo[i]),
                           gbm_bo_get_handle(bo[i]).u32, &fb_id[i]);
    }

    int current_buf = 0;
    // 渲染输出循环
    while (1) {
        // OpenGL ES渲染：清屏为红色
        glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        eglSwapBuffers(egl_dpy, egl_surf);

        // DRM页翻转，提交当前缓冲区到显示
        drm_mode_setcrtc(drm.fd, drm.crtc_id, fb_id[current_buf], 0, 0,
                         &drm.connector_id, 1, &drm.mode);
        // 等待页翻转事件（简化处理，实际需用drmEventContext监听）
        drmHandleEvent(drm.fd, NULL);

        // 切换缓冲区
        current_buf = 1 - current_buf;
        gbm_surface_release_buffer(gbm_surf, bo[current_buf]);
        bo[current_buf] = gbm_surface_lock_front_buffer(gbm_surf);
    }

    // 省略资源释放逻辑
    return 0;
}

编译时需链接相关库：gcc -o drm_gles_output drm_gles_output.c -ldrm -lgbm -lEGL -lGLES2

内容的提问来源于stack exchange，提问作者Andrii Omelchenko