Merge lp:~glmark2-dev/glmark2/canvas-drm-rebranch into lp:glmark2/2011.11

[Jesse Barker]

CanvasDRM: Add a new canvas type that renders directly to DRM-managed buffers rather than going through X11. The canvas uses GBM for surface management, DRM (KMS) for mode control and page flip, and EGL for rendering context and config management. Client API support is predicated upon the EGL, but both OpenGL and OpenGL ES 2.0 are supported.

This work was originally done on lp:~glmark2-dev/glmark2/canvas-drm, however, based upon review comments there, it was decided it would be cleaner (with respect to other development branches that have been merged in the interim) to rebranch and reintegrate the work. So, I rebranched from current trunk and then did a 'bzr merge --interactive' from canvas-drm into this branch and de-selected the changes relating to egl-state.{h,cpp}. I think we lose a bit of the revision history, but actually gain a bit of clarity.

[Alexandros Frantzis (afrantzis)]

Rendering works fine on the platforms I have tested. The only problems I see are during shutdown:

1. Pressing Ctrl+C occasionally doesn't seem to reset the crtc correctly, so I end up with a blank screen. It also always causes an error message to be displayed (Error in select: -1).

2. Pressing Enter (and therefore flushing stdin), causes a segfault. This happens because we are leaving DRMState::do_flip() with both surface buffers locked. Next time we call gbm_surface_lock_front_buffer(surface_) we get back a NULL value which we currently don't handle properly (i.e. we just use it). We get into the same situation if select fails etc

(1) is not critical, so I am ok with shipping this as part of an experimental drm backend release (perhaps we could add a warning about the experimental status when startinp up?).

On the other hand, I think (2) should be fixed before this release, if possible, as it's relatively easy for a user to cause a segfault. For example, a user that wants to quit will probably try pressing ESC (which won't work), then some keys then Enter.

review: Needs Fixing

[Jesse Barker (jesse-barker)]

> Rendering works fine on the platforms I have tested. The only problems I see
> are during shutdown:
>
> 1. Pressing Ctrl+C occasionally doesn't seem to reset the crtc correctly, so I
> end up with a blank screen. It also always causes an error message to be
> displayed (Error in select: -1).

This obviously works better for you than it does for me (possibly a driver-specific thing?).

>
> 2. Pressing Enter (and therefore flushing stdin), causes a segfault. This
> happens because we are leaving DRMState::do_flip() with both surface buffers
> locked. Next time we call gbm_surface_lock_front_buffer(surface_) we get back
> a NULL value which we currently don't handle properly (i.e. we just use it).
> We get into the same situation if select fails etc

Are you saying that there's a segfault when you press <enter> after glmark2 exits normally? I'm not clear I've ever see this, but I think I'm misunderstanding the scenario.

>
> (1) is not critical, so I am ok with shipping this as part of an experimental
> drm backend release (perhaps we could add a warning about the experimental
> status when startinp up?).

Probably should declare this a bit experimental in any case.

>
> On the other hand, I think (2) should be fixed before this release, if
> possible, as it's relatively easy for a user to cause a segfault. For example,
> a user that wants to quit will probably try pressing ESC (which won't work),
> then some keys then Enter.

Agreed. I'll try to reproduce. If you can provide more info on how to reproduce, that would be very useful.

cheers,
Jesse

[lp:~glmark2-dev/glmark2/canvas-drm-rebranch]

256. By Jesse Barker on 2012-12-17

CanvasDRM: Fix handling of Ctrl-C. Because the Ctrl-C was being handled by
CanvasDRM directly, DRMState had no knowledge of the event, and wasn't able
to detect it properly when select() came back with an error. Move the
quit handler into DRMState, and give it a public should_quit() method that
CanvasDRM can call. This is better encapsulation, and allows DRMState to
properly detect the user interrupt and release the GBM resources so the
console isn't hung when the application exits.

[Jesse Barker (jesse-barker)]

OK, got it. I reproduced the behavior, and have pushed a fix at revision 256. This works fine for me from both a serial console, as well as the "main" console (Ctrl-Alt-F1). The signal handler is now better encapsulated within DRMState, and allows the resources to be released properly. I've squelched the "error in select" message by making it debug only, as the vast majority of the time we would see that is precisely the case where a user interrupt has broken us out. I also added a notice to CanvasDRM::init() to indicate that the DRM canvas is experimental and is subject to change with the evolution of buffer management and modesetting APIs.

review: Needs Resubmitting

[Alexandros Frantzis (afrantzis)]

Even with the latest changes, I still get stuck with the glmark2 buffer on screen occasionally (~1 out of 5 times) after exiting with Ctrl-C. There are no errors or hangs, and if I switch to the X11 VT and back again, everything is displayed correctly.

> Are you saying that there's a segfault when you press <enter> after glmark2 exits normally?
> I'm not clear I've ever see this, but I think I'm misunderstanding the scenario.

To reproduce, start glmark2*-drm and press enter while a benchmark is running.

[Alexandros Frantzis (afrantzis)]

> Even with the latest changes, I still get stuck with the glmark2 buffer on
> screen occasionally (~1 out of 5 times) after exiting with Ctrl-C. There are
> no errors or hangs, and if I switch to the X11 VT and back again, everything
> is displayed correctly.

Note that this happens for me only with radeon; I can't reproduce it at all with i915 (tried until my fingers got tired of pressing Ctrl-C ;)). This could well by some kind of driver issue, so I don't think it's worth pursuing further for now.

> > Are you saying that there's a segfault when you press <enter> after glmark2
> exits normally?
> > I'm not clear I've ever see this, but I think I'm misunderstanding the
> scenario.
>
> To reproduce, start glmark2*-drm and press enter while a benchmark is running.

This issue, however, is 100% reproducible on both platforms.

[lp:~glmark2-dev/glmark2/canvas-drm-rebranch]

257. By Jesse Barker on 2012-12-17

CanvasDRM: Further simplify the select() logic. Firstly, as we have a NULL
pointer for the timeout parameter, select() won't time out and we don't need to
handle that return value. Secondly, unless we have a really great idea for
handling user input (apart from Ctrl-C), we don't need to listen on stdin.

[Jesse Barker (jesse-barker)]

Got rid of the need (well, the need already wasn't there ;-) for listening on stdin for arbitrary user input. We also didn't need to watch for a time out. Things work fine for me, even with interspersed <Enter> and <Ctrl-C> presses.

review: Needs Resubmitting

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

=== modified file 'INSTALL'
--- INSTALL	2011-01-25 15:07:17 +0000
+++ INSTALL	2012-12-17 22:54:19 +0000
@@ -2,7 +2,7 @@
 
 To configure glmark2 use:
 
-$ ./waf configure [--enable-gl --enable-glesv2 --data-path=DATA_PATH --prefix=PREFIX]
+$ ./waf configure [--enable-gl --enable-glesv2 --enable-gl-drm --enable-glesv2-drm --data-path=DATA_PATH --prefix=PREFIX]
 
 To build use:
 

=== added file 'src/canvas-drm.cpp'
--- src/canvas-drm.cpp	1970-01-01 00:00:00 +0000
+++ src/canvas-drm.cpp	2012-12-17 22:54:19 +0000
@@ -0,0 +1,587 @@
+//
+// Copyright © 2012 Linaro Limited
+//
+// This file is part of the glmark2 OpenGL (ES) 2.0 benchmark.
+//
+// glmark2 is free software: you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the Free Software
+// Foundation, either version 3 of the License, or (at your option) any later
+// version.
+//
+// glmark2 is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// glmark2.  If not, see <http://www.gnu.org/licenses/>.
+//
+// Authors:
+//  Simon Que 
+//  Jesse Barker
+//
+#include "canvas-drm.h"
+#include "log.h"
+#include "options.h"
+#include "util.h"
+
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <string.h>
+#include <time.h>
+
+#include <fstream>
+#include <sstream>
+#include <list>
+
+/******************
+ * Public methods *
+ ******************/
+
+bool
+CanvasDRM::reset()
+{
+    if (!reset_context())
+        return false;
+
+    if (!make_current())
+        return false;
+
+    if (!supports_gl2()) {
+        Log::error("Glmark2 needs OpenGL(ES) version >= 2.0 to run"
+                   " (but version string is: '%s')!\n",
+                   glGetString(GL_VERSION));
+        return false;
+    }
+
+    glViewport(0, 0, width_, height_);
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LEQUAL);
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+
+    clear();
+    egl_.swap();
+
+    if (!drm_.reset()) {
+        return false;
+    }
+
+    return true;
+}
+
+void
+DRMState::fb_destroy_callback(gbm_bo* bo, void* data)
+{
+    DRMFBState* fb = reinterpret_cast<DRMFBState*>(data);
+    if (fb && fb->fb_id) {
+        drmModeRmFB(fb->fd, fb->fb_id);
+    }
+    delete fb;
+    gbm_device* dev = gbm_bo_get_device(bo);
+    Log::debug("Got GBM device handle %p from buffer object\n", dev);
+}
+
+DRMFBState*
+DRMState::fb_get_from_bo(gbm_bo* bo)
+{
+    DRMFBState* fb = reinterpret_cast<DRMFBState*>(gbm_bo_get_user_data(bo));
+    if (fb) {
+        return fb;
+    }
+
+    unsigned int width = gbm_bo_get_width(bo);
+    unsigned int height = gbm_bo_get_height(bo);
+    unsigned int stride = gbm_bo_get_stride(bo);
+    unsigned int handle = gbm_bo_get_handle(bo).u32;
+    unsigned int fb_id(0);
+    int status = drmModeAddFB(fd_, width, height, 24, 32, stride, handle, &fb_id);
+    if (status < 0) {
+        Log::error("Failed to create FB: %d\n", status);
+        return 0;
+    }
+
+    fb = new DRMFBState();
+    fb->fd = fd_;
+    fb->bo = bo;
+    fb->fb_id = fb_id;
+
+    gbm_bo_set_user_data(bo, fb, fb_destroy_callback);
+    return fb;
+}
+
+bool
+DRMState::init_gbm()
+{
+    dev_ = gbm_create_device(fd_);
+    if (!dev_) {
+        Log::error("Failed to create GBM device\n");
+        return false;
+    }
+
+    surface_ = gbm_surface_create(dev_, mode_->hdisplay, mode_->vdisplay,
+                                  GBM_FORMAT_XRGB8888,
+                                  GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
+    if (!surface_) {
+        Log::error("Failed to create GBM surface\n");
+        return false;
+    }
+
+    return true;
+}
+
+bool
+DRMState::init()
+{
+    // TODO: Replace this with something that explicitly probes for the loaded
+    // driver (udev?).
+    static const char* drm_modules[] = {
+        "i915",
+        "nouveau",
+        "radeon",
+        "vmgfx",
+        "omapdrm",
+        "exynos"
+    };
+
+    unsigned int num_modules(sizeof(drm_modules)/sizeof(drm_modules[0]));
+    for (unsigned int m = 0; m < num_modules; m++) {
+        fd_ = drmOpen(drm_modules[m], 0);
+        if (fd_ < 0) {
+            Log::debug("Failed to open DRM module '%s'\n", drm_modules[m]);
+            continue;
+        }
+        Log::debug("Opened DRM module '%s'\n", drm_modules[m]);
+        break;
+    }
+
+    if (fd_ < 0) {
+        Log::error("Failed to find a suitable DRM device\n");
+        return false;
+    }
+
+    resources_ = drmModeGetResources(fd_);
+    if (!resources_) {
+        Log::error("drmModeGetResources failed\n");
+        return false;
+    }
+
+    // Find a connected connector
+    for (int c = 0; c < resources_->count_connectors; c++) {
+        connector_ = drmModeGetConnector(fd_, resources_->connectors[c]);
+        if (DRM_MODE_CONNECTED == connector_->connection) {
+            break;
+        }
+        drmModeFreeConnector(connector_);
+        connector_ = 0;
+    }
+
+    if (!connector_) {
+        Log::error("Failed to find a suitable connector\n");
+        return false;
+    }
+
+    // Find the best resolution (we will always operate full-screen).
+    unsigned int bestArea(0);
+    for (int m = 0; m < connector_->count_modes; m++) {
+        drmModeModeInfo* curMode = &connector_->modes[m];
+        unsigned int curArea = curMode->hdisplay * curMode->vdisplay;
+        if (curArea > bestArea) {
+            mode_ = curMode;
+            bestArea = curArea;
+        }
+    }
+
+    if (!mode_) {
+        Log::error("Failed to find a suitable mode\n");
+        return false;
+    }
+
+    // Find a suitable encoder
+    for (int e = 0; e < resources_->count_encoders; e++) {
+        encoder_ = drmModeGetEncoder(fd_, resources_->encoders[e]);
+        if (encoder_ && encoder_->encoder_id == connector_->encoder_id) {
+            break;
+        }
+        drmModeFreeEncoder(encoder_);
+        encoder_ = 0;
+    }
+
+    if (!encoder_) {
+        Log::error("Failed to find a suitable encoder\n");
+        return false;
+    }
+
+    if (!init_gbm()) {
+        return false;
+    }
+
+    crtc_ = drmModeGetCrtc(fd_, encoder_->crtc_id);
+    if (!crtc_) {
+        Log::error("Failed to get current CRTC\n");
+        return false;
+    }
+
+    signal(SIGINT, &DRMState::quit_handler);
+
+    return true;
+}
+
+bool
+DRMState::reset()
+{
+    if (bo_) {
+        gbm_surface_release_buffer(surface_, bo_);
+    }
+
+    bo_ = gbm_surface_lock_front_buffer(surface_);
+    fb_ = fb_get_from_bo(bo_);
+
+    int status = drmModeSetCrtc(fd_, encoder_->crtc_id, fb_->fb_id, 0, 0,
+                                &connector_->connector_id, 1, mode_);
+    if (status < 0) {
+        Log::error("Failed to set CRTC: %d\n", status);
+        return false;
+    }
+
+    return true;
+}
+
+
+bool DRMState::should_quit_ = false;
+
+void
+DRMState::quit_handler(int signo)
+{
+    Log::debug("Got SIGINT (%d).\n", signo);
+    should_quit_ = true;
+}
+void
+DRMState::page_flip_handler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void* data)
+{
+    unsigned int* waiting = reinterpret_cast<unsigned int*>(data);
+    *waiting = 0;
+    // Deal with unused parameters
+    static_cast<void>(fd);
+    static_cast<void>(frame);
+    static_cast<void>(sec);
+    static_cast<void>(usec);
+}
+
+void
+DRMState::do_flip()
+{
+    gbm_bo* next = gbm_surface_lock_front_buffer(surface_);
+    fb_ = fb_get_from_bo(next);
+    unsigned int waiting(1);
+    int status = drmModePageFlip(fd_, encoder_->crtc_id, fb_->fb_id,
+                                 DRM_MODE_PAGE_FLIP_EVENT, &waiting);
+    if (status < 0) {
+        Log::error("Failed to enqueue page flip: %d\n", status);
+        return;
+    }
+
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(fd_, &fds);
+    drmEventContext evCtx;
+    evCtx.version = DRM_EVENT_CONTEXT_VERSION;
+    evCtx.page_flip_handler = page_flip_handler;
+
+    while (waiting) {
+        status = select(fd_ + 1, &fds, 0, 0, 0);
+        if (status < 0) {
+            // Most of the time, select() will return an error because the
+            // user pressed Ctrl-C.  So, only print out a message in debug
+            // mode, and just check for the likely condition and release
+            // the current buffer object before getting out.
+            Log::debug("Error in select\n");
+            if (should_quit()) {
+                gbm_surface_release_buffer(surface_, bo_);
+                bo_ = next;
+            }
+            return;
+        }
+        drmHandleEvent(fd_, &evCtx);
+    }
+
+    gbm_surface_release_buffer(surface_, bo_);
+    bo_ = next;
+}
+
+void
+DRMState::cleanup()
+{
+    // Restore CRTC state if necessary
+    if (crtc_) {
+        int status = drmModeSetCrtc(fd_, crtc_->crtc_id, crtc_->buffer_id,
+                                    crtc_->x, crtc_->y, &connector_->connector_id,
+                                    1, &crtc_->mode);
+        if (status < 0) {
+            Log::error("Failed to restore original CRTC: %d\n", status);
+        }
+        drmModeFreeCrtc(crtc_);
+        crtc_ = 0;
+    }
+    if (surface_) {
+        gbm_surface_destroy(surface_);
+        surface_ = 0;
+    }
+    if (dev_) {
+        gbm_device_destroy(dev_);
+        dev_ = 0;
+    }
+    if (connector_) {
+        drmModeFreeConnector(connector_);
+        connector_ = 0;
+    }
+    if (encoder_) {
+        drmModeFreeEncoder(encoder_);
+        encoder_ = 0;
+    }
+    if (resources_) {
+        drmModeFreeResources(resources_);
+        resources_ = 0;
+    }
+    if (fd_ > 0) {
+        drmClose(fd_);
+    }
+    fd_ = 0;
+    mode_ = 0;
+}
+
+bool
+CanvasDRM::init()
+{
+    Log::info("NOTE: The DRM canvas is still experimental and its behavior\n");
+    Log::info("      is subject to change as GBM and modesetting behavior\n");
+    Log::info("      evolves\n");
+
+    if (!drm_.init()) {
+        Log::error("Failed to initialize the DRM canvas\n");
+        drm_.cleanup();
+        return false;
+    }
+
+    width_ = drm_.mode_width();
+    height_ = drm_.mode_height();
+    resize_no_viewport(width_, height_);
+
+    if (!egl_.init_display(drm_.device(), visual_config_)) {
+        return false;
+    }
+    if (!egl_.init_surface(drm_.surface())) {
+        return false;
+    }
+    if (!egl_.valid()) {
+        return false;
+    }
+
+    return reset();
+}
+
+
+CanvasDRM::~CanvasDRM()
+{
+    drm_.cleanup();
+}
+
+void
+CanvasDRM::visible(bool /* visible */)
+{
+}
+
+void
+CanvasDRM::clear()
+{
+    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
+#if USE_GL
+    glClearDepth(1.0f);
+#elif USE_GLESv2
+    glClearDepthf(1.0f);
+#endif
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void
+CanvasDRM::update()
+{
+    Options::FrameEnd m = Options::frame_end;
+
+    if (m == Options::FrameEndDefault) {
+        if (offscreen_)
+            m = Options::FrameEndFinish;
+        else
+            m = Options::FrameEndSwap;
+    }
+
+    switch(m) {
+        case Options::FrameEndSwap:
+            swap_buffers();
+            break;
+        case Options::FrameEndFinish:
+            glFinish();
+            break;
+        case Options::FrameEndReadPixels:
+            read_pixel(width_ / 2, height_ / 2);
+            break;
+        case Options::FrameEndNone:
+        default:
+            break;
+    }
+}
+
+void
+CanvasDRM::print_info()
+{
+    make_current();
+
+    std::stringstream ss;
+    ss << "    OpenGL Information" << std::endl;
+    ss << "    GL_VENDOR:     " << glGetString(GL_VENDOR) << std::endl;
+    ss << "    GL_RENDERER:   " << glGetString(GL_RENDERER) << std::endl;
+    ss << "    GL_VERSION:    " << glGetString(GL_VERSION) << std::endl;
+    Log::info("%s", ss.str().c_str());
+}
+
+Canvas::Pixel
+CanvasDRM::read_pixel(int x, int y)
+{
+    uint8_t pixel[4];
+    glReadPixels(x, y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
+    return Canvas::Pixel(pixel[0], pixel[1], pixel[2], pixel[3]);
+}
+
+void
+CanvasDRM::write_to_file(std::string &filename)
+{
+    char *pixels = new char[width_ * height_ * 4];
+
+    for (int i = 0; i < height_; i++) {
+        glReadPixels(0, i, width_, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+                     &pixels[(height_ - i - 1) * width_ * 4]);
+    }
+
+    std::ofstream output (filename.c_str(), std::ios::out | std::ios::binary);
+    output.write(pixels, 4 * width_ * height_);
+
+    delete [] pixels;
+}
+
+bool
+CanvasDRM::should_quit()
+{
+    return drm_.should_quit();
+}
+
+void
+CanvasDRM::resize(int width, int height)
+{
+    resize_no_viewport(width, height);
+    glViewport(0, 0, width_, height_);
+}
+
+/*********************
+ * Protected methods *
+ *********************/
+
+bool
+CanvasDRM::supports_gl2()
+{
+    std::string gl_version_str(
+        reinterpret_cast<const char*>(glGetString(GL_VERSION)));
+    int gl_major = 0;
+
+    size_t point_pos(gl_version_str.find('.'));
+
+    if (point_pos != std::string::npos) {
+        point_pos--;
+
+        size_t start_pos(gl_version_str.rfind(' ', point_pos));
+        if (start_pos == std::string::npos)
+            start_pos = 0;
+        else
+            start_pos++;
+
+        gl_major = Util::fromString<int>(
+                gl_version_str.substr(start_pos, point_pos - start_pos + 1)
+                );
+    }
+
+    return gl_major >= 2;
+}
+
+bool
+CanvasDRM::make_current()
+{
+    if (!egl_.valid()) {
+        Log::error("CanvasDRM: Invalid EGL state\n");
+        return false;
+    }
+
+    init_gl_extensions();
+
+    return true;
+}
+
+bool
+CanvasDRM::reset_context()
+{
+    return egl_.reset();
+}
+
+void
+CanvasDRM::swap_buffers()
+{
+    egl_.swap();
+    drm_.do_flip();
+}
+
+void
+CanvasDRM::init_gl_extensions()
+{
+#if USE_GLESv2
+    /*
+     * Parse the extensions we care about from the extension string.
+     * Don't even bother to get function pointers until we know the
+     * extension is present.
+     */
+    std::string extString;
+    const char* exts =
+        reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+    if (exts)
+        extString = exts;
+
+    if (extString.find("GL_OES_mapbuffer") != std::string::npos) {
+        GLExtensions::MapBuffer = reinterpret_cast<PFNGLMAPBUFFEROESPROC>(
+            eglGetProcAddress("glMapBufferOES"));
+        GLExtensions::UnmapBuffer = reinterpret_cast<PFNGLUNMAPBUFFEROESPROC>(
+            eglGetProcAddress("glUnmapBufferOES"));
+    }
+#elif USE_GL
+    GLExtensions::MapBuffer = glMapBuffer;
+    GLExtensions::UnmapBuffer = glUnmapBuffer;
+#endif
+}
+
+
+/*******************
+ * Private methods *
+ *******************/
+
+void
+CanvasDRM::resize_no_viewport(int width, int height)
+{
+    width_ = drm_.mode_width();
+    height_ = drm_.mode_height();
+
+    if (!width_)
+        width_ = width;
+    if (!height_)
+        height_ = height;
+
+    projection_ =
+        LibMatrix::Mat4::perspective(60.0, width_ / static_cast<float>(height_),
+                                     1.0, 1024.0);
+}

=== added file 'src/canvas-drm.h'
--- src/canvas-drm.h	1970-01-01 00:00:00 +0000
+++ src/canvas-drm.h	2012-12-17 22:54:19 +0000
@@ -0,0 +1,132 @@
+//
+// Copyright © 2012 Linaro Limited
+//
+// This file is part of the glmark2 OpenGL (ES) 2.0 benchmark.
+//
+// glmark2 is free software: you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the Free Software
+// Foundation, either version 3 of the License, or (at your option) any later
+// version.
+//
+// glmark2 is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// glmark2.  If not, see <http://www.gnu.org/licenses/>.
+//
+// Authors:
+//  Simon Que 
+//  Jesse Barker
+//
+#ifndef GLMARK2_CANVAS_DRM_H_
+#define GLMARK2_CANVAS_DRM_H_
+
+#include <cstring>
+#include <gbm.h>
+#include <drm.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include "canvas.h"
+#include "egl-state.h"
+
+struct DRMFBState
+{
+    int fd;
+    gbm_bo* bo;
+    uint32_t fb_id;
+};
+
+class DRMState
+{
+    static void page_flip_handler(int fd, unsigned int frame, unsigned int sec,
+                                  unsigned int usec, void* data);
+    static void fb_destroy_callback(gbm_bo* bo, void* data);
+    static void quit_handler(int signum);
+    static bool should_quit_;
+    DRMFBState* fb_get_from_bo(gbm_bo* bo);
+    bool init_gbm();
+    int fd_;
+    drmModeRes* resources_;
+    drmModeConnector* connector_;
+    drmModeEncoder* encoder_;
+    drmModeCrtcPtr crtc_;
+    drmModeModeInfo* mode_;
+    gbm_device* dev_;
+    gbm_surface* surface_;
+    gbm_bo* bo_;
+    DRMFBState* fb_;
+
+public:
+    DRMState() :
+        fd_(0),
+        resources_(0),
+        connector_(0),
+        encoder_(0),
+        mode_(0),
+        dev_(0),
+        surface_(0),
+        bo_(0),
+        fb_(0) {}
+    ~DRMState() { cleanup(); }
+    void cleanup();
+    bool init();
+    bool reset();
+    void do_flip();
+    bool should_quit() const { return should_quit_; }
+    gbm_device* device() const { return dev_; }
+    gbm_surface* surface() const { return surface_; }
+    unsigned int mode_width() const
+    { 
+        if (mode_) {
+            return mode_->hdisplay;
+        }
+        return 0;
+    }
+    unsigned int mode_height() const
+    {
+        if (mode_) {
+            return mode_->vdisplay;
+        }
+        return 0;
+    }
+};
+
+/**
+ * Canvas for direct rendering with EGL.
+ */
+class CanvasDRM: public Canvas
+{
+public:
+    CanvasDRM(int width, int height) :
+        Canvas(width, height) {}
+    ~CanvasDRM();
+
+    virtual bool init();
+    virtual bool reset();
+    virtual void visible(bool visible);
+    virtual void clear();
+    virtual void update();
+    virtual void print_info();
+    virtual Pixel read_pixel(int x, int y);
+    virtual void write_to_file(std::string &filename);
+    virtual bool should_quit();
+    virtual void resize(int width, int height);
+
+protected:
+    virtual bool make_current();
+    virtual bool reset_context();
+    virtual void swap_buffers();
+    virtual bool supports_gl2();
+
+private:
+    DRMState drm_;
+    EGLState egl_;
+
+    void resize_no_viewport(int width, int height);
+    void init_gl_extensions();
+};
+
+#endif

=== modified file 'src/main.cpp'
--- src/main.cpp	2012-12-07 19:57:44 +0000
+++ src/main.cpp	2012-12-17 22:54:19 +0000
@@ -35,7 +35,9 @@
 #include <iostream>
 #include <fstream>
 
-#if USE_GL
+#if USE_DRM
+#include "canvas-drm.h"
+#elif USE_GL
 #include "canvas-x11-glx.h"
 #elif USE_GLESv2
 #include "canvas-x11-egl.h"
@@ -180,7 +182,9 @@
     }
 
     // Create the canvas
-#if USE_GL
+#if USE_DRM
+    CanvasDRM canvas(Options::size.first, Options::size.second);
+#elif USE_GL
     CanvasX11GLX canvas(Options::size.first, Options::size.second);
 #elif USE_GLESv2
     CanvasX11EGL canvas(Options::size.first, Options::size.second);

=== modified file 'src/wscript_build'
--- src/wscript_build	2012-11-13 16:53:41 +0000
+++ src/wscript_build	2012-12-17 22:54:19 +0000
@@ -4,6 +4,8 @@
                                             f.name.find('egl-') == -1]
 gl_sources = ['canvas-x11.cpp', 'canvas-x11-glx.cpp']
 glesv2_sources = ['canvas-x11.cpp', 'canvas-x11-egl.cpp', 'egl-state.cpp']
+gl_drm_sources = ['canvas-drm.cpp', 'egl-state.cpp']
+glesv2_drm_sources = ['canvas-drm.cpp', 'egl-state.cpp']
 libmatrix_sources = [f for f in bld.path.ant_glob('libmatrix/*.cc')
                      if not f.name.endswith('test.cc')]
 includes = ['.', 'scene-ideas', 'scene-terrain']
@@ -47,3 +49,44 @@
         includes     = includes,
         defines      = ['USE_GLESv2', 'USE_EXCEPTIONS']
         )
+
+if bld.env.USE_GL_DRM:
+    bld(
+        features = ['cxx', 'cxxstlib'],
+        source   = libmatrix_sources,
+        target   = 'matrix-drm',
+        lib      = ['m'],
+        includes = ['.'],
+        export_includes = 'libmatrix',
+        defines  = ['USE_DRM', '__GBM__', 'USE_GL', 'USE_EXCEPTIONS']
+        )
+    bld(
+        features     = ['cxx', 'cprogram'],
+        source       = common_sources + gl_drm_sources,
+        target       = 'glmark2-drm',
+        use          = ['egl', 'gl', 'matrix-drm', 'libpng12', 'drm', 'gbm'],
+        lib          = ['m', 'jpeg', 'dl'],
+        includes     = includes,
+        defines      = ['USE_DRM', '__GBM__', 'USE_GL']
+        )
+
+if bld.env.USE_GLESv2_DRM:
+    bld(
+        features = ['cxx', 'cxxstlib'],
+        source   = libmatrix_sources,
+        target   = 'matrix-es2-drm',
+        lib      = ['m'],
+        includes = ['.'],
+        export_includes = 'libmatrix',
+        defines  = ['USE_DRM', '__GBM__', 'USE_GLESv2', 'USE_EXCEPTIONS']
+        )
+    bld(
+        features     = ['cxx', 'cprogram'],
+        source       = common_sources + glesv2_drm_sources,
+        target       = 'glmark2-es2-drm',
+        use          = ['egl', 'glesv2', 'matrix-es2-drm', 'libpng12', 'drm',
+                        'gbm'],
+        lib          = ['m', 'jpeg', 'dl'],
+        includes     = includes,
+        defines      = ['USE_DRM', '__GBM__', 'USE_GLESv2']
+        )

=== modified file 'wscript'
--- wscript	2012-11-26 19:29:33 +0000
+++ wscript	2012-12-17 22:54:19 +0000
@@ -20,6 +20,11 @@
                    default = False, help='build using OpenGL 2.0')
     opt.add_option('--enable-glesv2', action='store_true', dest = 'glesv2',
                    default = False, help='build using OpenGL ES 2.0')
+    opt.add_option('--enable-gl-drm', action='store_true', dest = 'gl_drm',
+                   default = False, help='build using OpenGL 2.0 without X')
+    opt.add_option('--enable-glesv2-drm', action='store_true',
+                   dest = 'glesv2_drm',
+                   default = False, help='build using OpenGL ES 2.0 without X')
     opt.add_option('--no-debug', action='store_false', dest = 'debug',
                    default = True, help='disable compiler debug information')
     opt.add_option('--no-opt', action='store_false', dest = 'opt',
@@ -30,8 +35,10 @@
                    help='path to additional data (models, shaders, textures)')
 
 def configure(ctx):
-    if not Options.options.gl and not Options.options.glesv2:
-        ctx.fatal("You must configure using at least one of --enable-gl, --enable-glesv2")
+    if not Options.options.gl and not Options.options.glesv2 and \
+       not Options.options.gl_drm and not Options.options.glesv2_drm:
+        ctx.fatal("You must configure using at least one of --enable-gl, " +
+                  "--enable-glesv2, --enable-gl-drm, --enable-glesv2-drm")
 
     ctx.check_tool('gnu_dirs')
     ctx.check_tool('compiler_cc')
@@ -54,15 +61,22 @@
                       uselib = uselib, mandatory = True)
 
     # Check required packages
-    req_pkgs = [('x11', 'x11'), ('libpng12', 'libpng12')]
+    req_pkgs = [('libpng12', 'libpng12')]
     for (pkg, uselib) in req_pkgs:
         ctx.check_cfg(package = pkg, uselib_store = uselib,
                       args = '--cflags --libs', mandatory = True)
 
     # Check optional packages
-    opt_pkgs = [('gl', 'gl', Options.options.gl),
-                ('egl', 'egl', Options.options.glesv2),
-                ('glesv2', 'glesv2', Options.options.glesv2)]
+    opt_pkgs = [('x11', 'x11', Options.options.gl or Options.options.glesv2),
+                ('gl', 'gl', Options.options.gl or Options.options.gl_drm),
+                ('egl', 'egl', Options.options.glesv2 or
+                               Options.options.glesv2_drm),
+                ('glesv2', 'glesv2', Options.options.glesv2 or
+                                     Options.options.glesv2_drm),
+                ('libdrm','drm', Options.options.gl_drm or
+                                 Options.options.glesv2_drm),
+                ('gbm','gbm', Options.options.gl_drm or
+                              Options.options.glesv2_drm)]
     for (pkg, uselib, mandatory) in opt_pkgs:
         ctx.check_cfg(package = pkg, uselib_store = uselib,
                       args = '--cflags --libs', mandatory = mandatory)
@@ -94,6 +108,8 @@
 
     ctx.env.USE_GL = Options.options.gl
     ctx.env.USE_GLESv2 = Options.options.glesv2
+    ctx.env.USE_GL_DRM = Options.options.gl_drm
+    ctx.env.USE_GLESv2_DRM = Options.options.glesv2_drm
 
     ctx.msg("Prefix", ctx.env.PREFIX, color = 'PINK')
     ctx.msg("Data path", data_path, color = 'PINK')
@@ -101,9 +117,13 @@
             color = 'PINK');
     if ctx.env.HAVE_EXTRAS:
         ctx.msg("Extras path", Options.options.extras_path, color = 'PINK')
-    ctx.msg("Building GL2 version", "Yes" if ctx.env.USE_GL else "No",
-            color = 'PINK')
-    ctx.msg("Building GLESv2 version", "Yes" if ctx.env.USE_GLESv2 else "No",
+    ctx.msg("Building X11 GL2 version", "Yes" if ctx.env.USE_GL else "No",
+            color = 'PINK')
+    ctx.msg("Building X11 GLESv2 version", "Yes" if ctx.env.USE_GLESv2 else "No",
+            color = 'PINK')
+    ctx.msg("Building DRM GL2 version", "Yes" if ctx.env.USE_GL_DRM else "No",
+            color = 'PINK')
+    ctx.msg("Building DRM GLESv2 version", "Yes" if ctx.env.USE_GLESv2_DRM else "No",
             color = 'PINK')
 
 def build(ctx):