/
DRM双缓冲垂直同步模式设置方法
这个例子扩展了modeset-double-buffered.c，并引入了与垂直空格(vsync'ed)同步的页面翻转。垂直空白是显示
控制器从扫描帧缓冲区中暂停的时间。垂直空白结束后，将逐行再次扫描framebuffer，并在后面跟着垂直空白。
在更改framebuffer时，垂直空格是很重要的。我们已经介绍了双缓冲，所以这个例子展示了我们如何在垂直空白和
扫描期间翻转缓冲区。
本例假设您熟悉modeset-double-buffered。这里只突出显示了两个文件之间的差异。
/
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <time.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
struct modeset_buf;
struct modeset_dev;
static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, struct modeset_dev *dev);
static int modeset_create_fb(int fd, struct modeset_buf *buf);
static void modeset_destroy_fb(int fd, struct modeset_buf *buf);
static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, struct modeset_dev *dev);
static int modeset_open(int *out, const char *node);
static int modeset_prepare(int fd);
static void modeset_draw(int fd);
static void modeset_draw_dev(int fd, struct modeset_dev *dev);
static void modeset_cleanup(int fd);
/
和前例相同
/
static int modeset_open(int *out, const char *node)
{
int fd, ret;
uint64_t has_dumb;
fd = open(node, O_RDWR | O_CLOEXEC);
if (fd < 0) {
ret = -errno;
fprintf(stderr, "cannot open '%s': %m\n", node);
return ret;
}
if (drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb) < 0 ||
!has_dumb) {
fprintf(stderr, "drm device '%s' does not support dumb buffers\n",
node);
close(fd);
return -EOPNOTSUPP;
}
*out = fd;
return 0;
}
/
modeset_buf和modeset_dev基本保持不变。但是6个新字段被添加到modeset_dev中:r, g, b, r_up, g_up, b_up。
它们用于计算在此输出设备上绘制的当前颜色。您可以忽略它们，因为它们对本示例不重要。
c示例中的modeset-double-buffered.c使用了完全相同的字段，但作为modeset_draw()中的局部变量。
当页面翻页正在挂起时，变量为true，也就是说，内核将在下一个垂直空白处翻转缓冲区。* \cleanup变量为真，
如果设备当前已清理并且不应该安排更多的页面翻转。它们用于同步清理例程。
/
struct modeset_buf {
uint32_t width;
uint32_t height;
uint32_t stride;
uint32_t size;
uint32_t handle;
uint8_t *map;
uint32_t fb;
};
struct modeset_dev {
struct modeset_dev *next;
unsigned int front_buf;
struct modeset_buf bufs[2];
drmModeModeInfo mode;
uint32_t conn;
uint32_t crtc;
drmModeCrtc *saved_crtc;
bool pflip_pending;
bool cleanup;
uint8_t r, g, b;
bool r_up, g_up, b_up;
};
static struct modeset_dev *modeset_list = NULL;
/
和前例相同
/
static int modeset_prepare(int fd)
{
drmModeRes *res;
drmModeConnector *conn;
int i;
struct modeset_dev *dev;
int ret;
/ 检索资源 /
res = drmModeGetResources(fd);
if (!res) {
fprintf(stderr, "cannot retrieve DRM resources (%d): %m\n",
errno);
return -errno;
}
/ 遍历所有的连接器 /
for (i = 0; i < res->count_connectors; ++i) {
conn = drmModeGetConnector(fd, res->connectors[i]); /获取每个连接器的信息
if (!conn) {
fprintf(stderr, "cannot retrieve DRM connector %u:%u (%d): %m\n",
i, res->connectors[i], errno);
continue;
}
/ 创建设备结构 /
dev = malloc(sizeof(*dev));
memset(dev, 0, sizeof(*dev)); /对该段内存内容置0
dev->conn = conn->connector_id;
/ 调用该函数来准备这个连接器 /
ret = modeset_setup_dev(fd, res, conn, dev);
if (ret) {
if (ret != -ENOENT) {
errno = -ret;
fprintf(stderr, "cannot setup device for connector %u:%u (%d): %m\n",
i, res->connectors[i], errno);
}
free(dev);
drmModeFreeConnector(conn);
continue;
}
/ 释放连接器数据和链接设备到全局列表 /
drmModeFreeConnector(conn);
dev->next = modeset_list;
modeset_list = dev;
}
/ 再次释放资源 /
drmModeFreeResources(res);
return 0;
}
/
和前例相同
/
static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn,
struct modeset_dev *dev)
{
int ret;
/ 检查是否有显示器连接 /
if (conn->connection != DRM_MODE_CONNECTED) {
fprintf(stderr, "ignoring unused connector %u\n",
conn->connector_id);
return -ENOENT;
}
/ 检查是否至少有一个有效的模式 /
if (conn->count_modes == 0) {
fprintf(stderr, "no valid mode for connector %u\n",
conn->connector_id);
return -EFAULT;
}
/ 复制模式信息到我们的设备结构和两个缓冲区 /
memcpy(&dev->mode, &conn->modes[0], sizeof(dev->mode));
dev->bufs[0].width = conn->modes[0].hdisplay;
dev->bufs[0].height = conn->modes[0].vdisplay;
dev->bufs[1].width = conn->modes[0].hdisplay;
dev->bufs[1].height = conn->modes[0].vdisplay;
fprintf(stderr, "mode for connector %u is %ux%u\n",
conn->connector_id, dev->bufs[0].width, dev->bufs[0].height);
/ 为这个连接器找到一个crtc /
ret = modeset_find_crtc(fd, res, conn, dev);
if (ret) {
fprintf(stderr, "no valid crtc for connector %u\n",
conn->connector_id);
return ret;
}
/ 为这个CRTC创建framebuffer #1 /
ret = modeset_create_fb(fd, &dev->bufs[0]);
if (ret) {
fprintf(stderr, "cannot create framebuffer for connector %u\n",
conn->connector_id);
return ret;
}
/ 为这个CRTC创建framebuffer #2 /
ret = modeset_create_fb(fd, &dev->bufs[1]);
if (ret) {
fprintf(stderr, "cannot create framebuffer for connector %u\n",
conn->connector_id);
modeset_destroy_fb(fd, &dev->bufs[0]);
return ret;
}
return 0;
}
/
和前例相同
/
static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, struct modeset_dev *dev)
{
drmModeEncoder *enc;
int i, j;
uint32_t crtc;
struct modeset_dev *iter;
/ 首先尝试当前连接的编码器+crtc /
if (conn->encoder_id)
enc = drmModeGetEncoder(fd, conn->encoder_id);
else
enc = NULL;
if (enc) {
if (enc->crtc_id) {
crtc = enc->crtc_id;
for (iter = modeset_list; iter; iter = iter->next) {
if (iter->crtc == crtc) {
crtc = -1;
break;
}
}
if (crtc >= 0) {
drmModeFreeEncoder(enc);
dev->crtc = crtc;
return 0;
}
}
drmModeFreeEncoder(enc);
}
/
如果连接器目前没有绑定到一个编码器，或者encoder+crtc已经被另一个连接器使用(实际上不太可能，
但让我们安全)，迭代所有其他可用的编码器来找到匹配的crtc。
/
for (i = 0; i < conn->count_encoders; ++i) {
enc = drmModeGetEncoder(fd, conn->encoders[i]);
if (!enc) {
fprintf(stderr, "cannot retrieve encoder %u:%u (%d): %m\n",
i, conn->encoders[i], errno);
continue;
}
/ 遍历所有crtc /
for (j = 0; j < res->count_crtcs; ++j) {
if (!(enc->possible_crtcs & (1 << j))) /检查此CRTC是否与编码器一起工作
continue;
/ 检查是否有其他设备已经使用此CRTC /
crtc = res->crtcs[j];
for (iter = modeset_list; iter; iter = iter->next) {
if (iter->crtc == crtc) {
crtc = -1;
break;
}
}
/ 我们已经找到一个CRTC，所以保存它并返回 /
if (crtc >= 0) {
drmModeFreeEncoder(enc);
dev->crtc = crtc;
return 0;
}
}
drmModeFreeEncoder(enc);
}
fprintf(stderr, "cannot find suitable CRTC for connector %u\n",
conn->connector_id);
return -ENOENT;
}
/
和前例相同
/
static int modeset_create_fb(int fd, struct modeset_buf *buf)
{
struct drm_mode_create_dumb creq;
struct drm_mode_destroy_dumb dreq;
struct drm_mode_map_dumb mreq;
int ret;
/ 创建 dumb buffer /
memset(&creq, 0, sizeof(creq));
creq.width = buf->width;
creq.height = buf->height;
creq.bpp = 32;
ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
if (ret < 0) {
fprintf(stderr, "cannot create dumb buffer (%d): %m\n",errno);
return -errno;
}
buf->stride = creq.pitch;
buf->size = creq.size;
buf->handle = creq.handle;
/ 为dumb-buffer创建framebuffer对象 /
ret = drmModeAddFB(fd, buf->width, buf->height, 24, 32, buf->stride,
buf->handle, &buf->fb);
if (ret) {
fprintf(stderr, "cannot create framebuffer (%d): %m\n",errno);
ret = -errno;
goto err_destroy;
}
/ 为内存映射准备缓冲区 /
memset(&mreq, 0, sizeof(mreq));
mreq.handle = buf->handle;
ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
if (ret) {
fprintf(stderr, "cannot map dumb buffer (%d): %m\n",errno);
ret = -errno;
goto err_fb;
}
/ 执行实际的内存映射 /
buf->map = mmap(0, buf->size, PROT_READ | PROT_WRITE, MAP_SHARED,
fd, mreq.offset);
if (buf->map == MAP_FAILED) {
fprintf(stderr, "cannot mmap dumb buffer (%d): %m\n",errno);
ret = -errno;
goto err_fb;
}
/ 将framebuffer清除为0 /
memset(buf->map, 0, buf->size);
return 0;
err_fb:
drmModeRmFB(fd, buf->fb);
err_destroy:
memset(&dreq, 0, sizeof(dreq));
dreq.handle = buf->handle;
drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
return ret;
}
/
和前例相同
/
static void modeset_destroy_fb(int fd, struct modeset_buf *buf)
{
struct drm_mode_destroy_dumb dreq;
/ unmap buffer /
munmap(buf->map, buf->size);
/ 删除 framebuffer /
drmModeRmFB(fd, buf->fb);
/ 删除 dumb buffer /
memset(&dreq, 0, sizeof(dreq));
dreq.handle = buf->handle;
drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
}
/
和前例相同
/
int main(int argc, char **argv)
{
int ret, fd;
const char *card;
struct modeset_dev *iter;
struct modeset_buf *buf;
/ 检查打开哪个DRM设备 /
if (argc > 1)
card = argv[1];
else
card = "/dev/dri/card0";
fprintf(stderr, "using card '%s'\n", card);
/ 打开DRM设备 /
ret = modeset_open(&fd, card);
if (ret)
goto out_return;
/ 准备好所有连接器和crtc /
ret = modeset_prepare(fd);
if (ret)
goto out_close;
/ 对每个找到的连接器+CRTC执行实际的modesset /
for (iter = modeset_list; iter; iter = iter->next) {
iter->saved_crtc = drmModeGetCrtc(fd, iter->crtc);
buf = &iter->bufs[iter->front_buf];
ret = drmModeSetCrtc(fd, iter->crtc, buf->fb, 0, 0,
&iter->conn, 1, &iter->mode);
if (ret)
fprintf(stderr, "cannot set CRTC for connector %u (%d): %m\n",
iter->conn, errno);
}
/ 画一些颜色5秒 /
modeset_draw(fd);
/ 清理所有 /
modeset_cleanup(fd);
ret = 0;
out_close:
close(fd);
out_return:
if (ret) {
errno = -ret;
fprintf(stderr, "modeset failed with error %d: %m\n", errno);
} else {
fprintf(stderr, "exiting\n");
}
return ret;
}
/
modeset_page_flip_event()是下面modeset_draw()的回调帮助器。有关更多信息，请参阅modeset_draw()。
注意，如果设备当前已被清理，那么这不会做任何事情。这允许在清除期间等待未完成的页面翻转。
/
static void modeset_page_flip_event(int fd, unsigned int frame,
unsigned int sec, unsigned int usec,
void *data)
{
struct modeset_dev *dev = data;
dev->pflip_pending = false;
if (!dev->cleanup)
modeset_draw_dev(fd, dev);
}
/
modeset_draw()与前面所有的例子有很大的不同。呈现已经转移到下面的另一个助手modeset_draw_dev()，
但是现在modeset_draw()负责控制何时需要重新绘制输出。
所以我们要做的是:首先重新绘制所有输出。我们首先初始化每个输出的r/g/b/_up变量，不过，您可以安全地忽
略这些变量。它们只用于计算下一种颜色。然后对每个输出调用modeset_draw_dev()。这个函数_always_重新绘制输
出，并为下一个垂直空白安排缓冲交换/翻转。
现在我们必须等待每一个垂直空白出现，这样我们才能绘制下一帧。如果发生了vblank，我们只需再次调用
modeset_draw_dev()，然后等待下一个vblank。
注意:不同的显示器可以有不同的刷新速率。这意味着，vblank事件总是分配给CRTC。因此，对于我们使用的每
个CRTC/modeset_dev，我们会得到不同的vblank事件。这也意味着，我们的帧数控制的颜色变化在每个显示器上都
是不同的。如果您想在所有显示器上完全相同的帧，我们就必须在所有设备之间共享颜色值。但是，为了简单起见，
我们在这里不这样做。
最后一个缺失的部分是如何获取vblank事件。libdrm提供了drmWaitVBlank()，然而，我们对_all_ vblanks
不感兴趣，而只对翻页的vblanks感兴趣。我们可以使用drmWaitVBlank()，但有一个更方便的方法:drmModePageFlip()
drmModePageFlip()为下一个vblank调度一个缓冲区翻转，然后通知我们。它接受一个CRTC-id、fb-id和一个任意的
数据指针，然后调度翻页。这是完全异步的，并立即返回。
当页面翻转发生时，DRM-fd将变得可读，我们可以调用drmHandleEvent()。这将读取所有vblank/page-flip事件，
并使用传递给drmModePageFlip()的数据指针调用modeset_page_flip_event()回调。我们简单地调用modeset_draw_dev()
然后让下一帧被渲染。
因此，modeset_draw()负责等待_all_当前使用的输出设备的页翻页/vblank事件，并为它们安排一次重画。
我们可以很容易地在while (1) {drmHandleEvent()}循环中做到这一点，然而，这个示例展示了如何使用DRM-fd
将其集成到您自己的主循环中。如果您不熟悉select()、poll()或epoll，请到其他地方阅读。在互联网上的其他地方有大量的文档。
因此，我们所做的是将DRM-fd和键盘输入FD(更准确地说:stdin FD)添加到一个选择集，然后等待该选择集。
如果DRM-fd是可读的，我们调用drmHandleEvents()来处理页面翻转事件。如果输入fd是可读的，我们退出。因此，
在任何键盘输入中，我们都会退出这个循环(您需要在每个键盘输入后按RETURN键才能完成此操作)。
/
static void modeset_draw(int fd)
{
int ret;
fd_set fds;
time_t start, cur;
struct timeval v;
drmEventContext ev;
struct modeset_dev *iter;
/ 初始化变量 /
srand(time(&start));
FD_ZERO(&fds);
memset(&v, 0, sizeof(v));
memset(&ev, 0, sizeof(ev));
/将此设置为仅支持的最新版本。版本2引入了page_flip_handler，因此我们使用它。/
ev.version = 2;
ev.page_flip_handler = modeset_page_flip_event;
/ 重画所有输出 /
for (iter = modeset_list; iter; iter = iter->next) {
iter->r = rand() % 0xff;
iter->g = rand() % 0xff;
iter->b = rand() % 0xff;
iter->r_up = iter->g_up = iter->b_up = true;
modeset_draw_dev(fd, iter);
}
/ 等待5秒等待VBLANK或input事件 /
while (time(&cur) < start + 5) {
FD_SET(0, &fds);
FD_SET(fd, &fds);
v.tv_sec = start + 5 - cur;
ret = select(fd + 1, &fds, NULL, NULL, &v);
if (ret < 0) {
fprintf(stderr, "select() failed with %d: %m\n", errno);
break;
} else if (FD_ISSET(0, &fds)) {
fprintf(stderr, "exit due to user-input\n");
break;
} else if (FD_ISSET(fd, &fds)) {
drmHandleEvent(fd, &ev);
}
}
}
/
一个简短的辅助函数来计算变化的颜色值。没必要去理解它。
/
static uint8_t next_color(bool *up, uint8_t cur, unsigned int mod)
{
uint8_t next;
next = cur + (*up ? 1 : -1) * (rand() % mod);
if ((*up && next < cur) || (!*up && next > cur)) {
*up = !*up;
next = cur;
}
return next;
}
/
modeset_draw_dev()是一个新函数，它重绘单个输出的屏幕。它将DRM-fd和输出设备作为参数，
重新绘制一个新帧并为下一次垂直同步安排页面翻页。
这个函数与前面的例子中的modeset_draw()一样，但现在只针对单个输出设备。
在我们完成渲染帧之后，我们必须交换缓冲区。我们现在不像前面那样调用drmModeSetCrtc()，
而是要为下一个垂直空白(vblank)安排页面翻页。为此我们使用drmModePageFlip()。它接受CRTC-id和FB-id，
并在下一次vblank发生时异步交换缓冲区。注意，这是由内核完成的，因此在libdrm中既不会启动线程，也不会执行任何其他魔法。
DRM_MODE_PAGE_FLIP_EVENT标志告诉drmModePageFlip()在页面翻页发生时向我们发送DRM-fd上
的页面翻页事件。最后一个参数是与此事件一起返回的数据指针。
如果我们不传递这个标志，那么当翻页发生时，我们将不会得到通知。
注意:如果您调用了drmModePageFlip()并再次直接调用它，如果在此期间页面翻页没有发生，它将返回EBUSY。
所以你几乎总是想要传递DRM_MODE_PAGE_FLIP_EVENT来在页面翻转发生时得到通知，这样你就知道什么时候渲染
下一帧。如果您计划了一个页面翻页，但在下一个vblank之前调用drmModeSetCrtc()，那么计划的页面翻页将成为
一个空操作。但是，当它发生时，您仍然会得到通知，并且您仍然不能再次调用drmModePageFlip()，直到它完成。
所以总结一下:没有办法有效地取消翻页。
如果您想知道为什么drmModePageFlip()接受的参数比drmModeSetCrtc()少，那么您应该考虑drmModePageFlip()
重用了来自drmModeSetCrtc()的参数。因此，在使用drmModePageFlip()之前，必须先通过drmModeSetCrtc()设置连接
器id、x/y偏移量等内容!我们在main()中这样做，就像前面所有的例子一样。
/
static void modeset_draw_dev(int fd, struct modeset_dev *dev)
{
struct modeset_buf *buf;
unsigned int j, k, off;
int ret;
dev->r = next_color(&dev->r_up, dev->r, 20);
dev->g = next_color(&dev->g_up, dev->g, 10);
dev->b = next_color(&dev->b_up, dev->b, 5);
buf = &dev->bufs[dev->front_buf ^ 1];
for (j = 0; j < buf->height; ++j) {
for (k = 0; k < buf->width; ++k) {
off = buf->stride * j + k * 4;
*(uint32_t*)&buf->map[off] =
(dev->r << 16) | (dev->g << 8) | dev->b;
}
}
ret = drmModePageFlip(fd, dev->crtc, buf->fb,
DRM_MODE_PAGE_FLIP_EVENT, dev);
if (ret) {
fprintf(stderr, "cannot flip CRTC for connector %u (%d): %m\n",
dev->conn, errno);
} else {
dev->front_buf ^= 1;
dev->pflip_pending = true;
}
}
/
modeset_cleanup()基本保持不变。但是，在将CRTC重置到以前的状态之前，我们等待任何未完成的页面翻页
完成。这并不是绝对必要的，但是，如果我们调用drmModeSetCrtc()来处理挂起的翻页，一些DRM驱动程序就会有错误。
此外，当应用程序存在时，我们不希望出现任何挂起的页面翻转。因为另一个应用程序可能会拿起DRM设备并尝
试调度它们自己的页翻转，只要我们的页翻转还挂起，它们就可能失败。
所以让我们在这里安全的等待任何翻页完成。这是一个阻塞操作，但它大部分都小于16ms，所以我们可以忽略它。
/
static void modeset_cleanup(int fd)
{
struct modeset_dev *iter;
drmEventContext ev;
int ret;
/ 初始化变量 /
memset(&ev, 0, sizeof(ev));
ev.version = DRM_EVENT_CONTEXT_VERSION;
ev.page_flip_handler = modeset_page_flip_event;
while (modeset_list) {
/ 从全局列表中删除 /
iter = modeset_list;
modeset_list = iter->next;
/ 如果页面翻转挂起，等待它完成 /
iter->cleanup = true;
fprintf(stderr, "wait for pending page-flip to complete...\n");
while (iter->pflip_pending) {
ret = drmHandleEvent(fd, &ev);
if (ret)
break;
}
/ 恢复保存的CRTC配置 /
if (!iter->pflip_pending)
drmModeSetCrtc(fd,
iter->saved_crtc->crtc_id,
iter->saved_crtc->buffer_id,
iter->saved_crtc->x,
iter->saved_crtc->y,
&iter->conn,
1,
&iter->saved_crtc->mode);
drmModeFreeCrtc(iter->saved_crtc);
/ 摧毁framebuffer /
modeset_destroy_fb(fd, &iter->bufs[1]);
modeset_destroy_fb(fd, &iter->bufs[0]);
/ 释放分配的内存 /
free(iter);
}
}
/
这个例子展示了如何让内核处理翻页，以及如何在用户空间中等待翻页。这里的select()示例将向您展示如何将
这些循环集成到您自己的应用程序中，而不需要单独的建模设置线程。
然而，请注意，垂直同步双缓冲并不能解决所有问题。想象一下，你无法以足够快的速度渲染帧来满足所有的垂
直空格。在这种情况下，您不希望在安排一次页面翻页之后等待vblank恰好绘制下一帧。解决这个问题的一种方法是
三缓冲。它应该是很容易扩展这个例子使用三重缓冲，但如果你有任何问题，请随时联系我。
还要注意，如果您想重新安排还没有发生的页面翻转，DRM内核API是非常有限的。不能在单个扫描周期内两次
调用drmModePageFlip()。当翻页挂起时，drmModeSetCrtc()的行为也可能出乎意料。
不幸的是，没有最终的解决方案来解决所有的设置问题。这个例子展示了做垂直同步页面翻转的工具，然而，这
取决于你如何实现它的用例。
如果你想要更多的代码，我可以推荐你阅读下面的源代码:
-plymouth(它使用了像这个例子一样的哑缓冲区;非常容易理解)
-kmscon(使用libuterm来做这个)
-wayland(非常复杂的DRM渲染器;很难完全理解，因为它使用更复杂的技术，如DRM飞机)
-xserver(很难理解，因为它被分割在很多文件/项目中)
欢迎任何反馈。您可以自由地将这些代码用于自己的文档或项目。
/