DRM——学习篇7：modeset-vsync.c示例学习

刚开始学习，记忆不是很好，容易忘，边学边记，阅读的速度会比较慢，看的会比较仔细。
详细请看：
  David Herrmann’s Blog: Linux DRM Mode-Setting API
  David Herrmann’s Github: drm-howto/modeset.c

modeset-vsync.c文件

源代码在上面可获取，原先备注是英文的，我就简单用翻译软件翻译一下，有错请指出：

/
						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(很难理解，因为它被分割在很多文件/项目中)
	欢迎任何反馈。您可以自由地将这些代码用于自己的文档或项目。
/