PixelToasterUnix.h

// Unix Platform
// Copyright © 2004-2007 Glenn Fiedler
// Part of the PixelToaster Framebuffer Library - http://www.pixeltoaster.com

// X11 version implemented by Bram de Greve <bramz@users.sourceforge.net>
// inspired by X11 version of TinyPTC by Alessandro Gatti <a.gatti@tiscali.it>

// unix display implementation

#define XK_LATIN1
#define XK_MISCELLANY

#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/XKBlib.h>
#include <X11/Xutil.h>
#include <X11/keysymdef.h>

namespace PixelToaster {
template <typename T>
class DirtyVector
{
public:
    explicit DirtyVector(size_t size = 0) { data_ = size == 0 ? nullptr : (static_cast<T*>(malloc(size * sizeof(T)))); }
    ~DirtyVector()
    {
        if (data_ != nullptr)
        {
            free(data_);
            data_ = nullptr;
        }
    }
    void reset(size_t size = 0)
    {
        DirtyVector<T> temp(size);
        swap(temp);
    }
    T& operator[](size_t i)
    {
        assert(data_);
        return data_[i];
    }
    T*   get() { return data_; }
    bool isEmpty() const { return data_ == nullptr; }
    void swap(DirtyVector& other)
    {
        T* temp     = data_;
        data_       = other.data_;
        other.data_ = temp;
    }

private:
    T* data_;
};

static Format findFormat(int bitsPerPixel, unsigned long redMask, unsigned long greenMask, unsigned long blueMask)
{
    switch (bitsPerPixel)
    {
        case 16:
            if (redMask == 0x7c00 && greenMask == 0x03e0 && blueMask == 0x001f)
                return Format::XRGB1555;
            if (redMask == 0x001f && greenMask == 0x03e0 && blueMask == 0x7c00)
                return Format::XBGR1555;
            if (redMask == 0xf800 && greenMask == 0x07e0 && blueMask == 0x001f)
                return Format::RGB565;
            if (redMask == 0x001f && greenMask == 0x07e0 && blueMask == 0xf800)
                return Format::BGR565;
            break;
        case 24:
            if (redMask == 0xff0000 && greenMask == 0x00ff00 && blueMask == 0x0000ff)
                return Format::RGB888;
            if (redMask == 0x0000ff && greenMask == 0x00ff00 && blueMask == 0xff0000)
                return Format::BGR888;
            break;
        case 32:
            if (redMask == 0xff0000 && greenMask == 0x00ff00 && blueMask == 0x0000ff)
                return Format::XRGB8888;
            if (redMask == 0x0000ff && greenMask == 0x00ff00 && blueMask == 0xff0000)
                return Format::XBGR8888;
            break;
    }
    return Format::Unknown;
}

class UnixDisplay : public DisplayAdapter
{
public:
    UnixDisplay()
    {
        defaults();
    }

    bool open(const char title[], int width, int height, Output output, Mode mode) override
    {
        DisplayAdapter::open(title, width, height, output, mode);

        // let's open a display

        display_ = ::XOpenDisplay(0);
        if (!display_)
        {
            close();
            return false;
        }

        const int screen = DefaultScreen(display_);
        ::Visual* visual = DefaultVisual(display_, screen);
        if (!visual)
        {
            close();
            return false;
        }

        // It gets messy when talking about color depths.
        //
        // For the image buffer, we either need 8, 16 or 32 bitsPerPixel.  8 bits we'll
        // never have (hopefully), 16 bits will be used for displayDepth 15 & 16, and
        // 32 bits must be used for depths 24 and 32.
        //
        // The converters will get this right when talking about displayDepth 15 & 16, but
        // it will wrongly assume that displayDepth 24 takes _exactly_ 24 bitsPerPixel.  We
        // solve that by tricking the converter requester by presenting it a 32 bit
        // bufferDepth instead.
        //
        const int displayDepth  = DefaultDepth(display_, screen);
        const int bufferDepth   = displayDepth == 24 ? 32 : displayDepth;
        const int bytesPerPixel = (bufferDepth + 7) / 8;
        const int bitsPerPixel  = 8 * bytesPerPixel;
        if (bitsPerPixel != 16 && bitsPerPixel != 32)
        {
            close();
            return false;
        }

        destFormat_             = findFormat(bufferDepth,
                                 visual->red_mask, visual->green_mask, visual->blue_mask);
        floatingPointConverter_ = requestConverter(Format::XBGRFFFF, destFormat_);
        trueColorConverter_     = requestConverter(Format::XRGB8888, destFormat_);
        if (!floatingPointConverter_ || !trueColorConverter_)
        {
            close();
            return false;
        }

        // let's create a window

        const Window root = DefaultRootWindow(display_);

        const int screenWidth  = DisplayWidth(display_, screen);
        const int screenHeight = DisplayHeight(display_, screen);
        const int left         = (screenWidth - width) / 2;
        const int top          = (screenHeight - height) / 2;

        ::XSetWindowAttributes attributes;
        attributes.border_pixel = attributes.background_pixel = BlackPixel(display_, screen);
        attributes.backing_store                              = NotUseful;

        window_ = ::XCreateWindow(display_, root, left, top, width, height, 0,
                                  displayDepth, InputOutput, visual,
                                  CWBackPixel | CWBorderPixel | CWBackingStore, &attributes);

        ::XStoreName(display_, window_, title);

        wmProtocols_    = XInternAtom(display_, "WM_PROTOCOLS", True);
        wmDeleteWindow_ = XInternAtom(display_, "WM_DELETE_WINDOW", True);
        if (wmProtocols_ == 0 || wmDeleteWindow_ == 0)
        {
            close();
            return false;
        }
        if (::XSetWMProtocols(display_, window_, &wmDeleteWindow_, 1) == 0)
        {
            close();
            return false;
        }

        ::XSizeHints sizeHints;
        sizeHints.flags = PPosition | PMinSize | PMaxSize;
        sizeHints.x = sizeHints.y = 0;
        sizeHints.min_width = sizeHints.max_width = width;
        sizeHints.min_height = sizeHints.max_height = height;
        ::XSetNormalHints(display_, window_, &sizeHints);
        ::XClearWindow(display_, window_);
        ::XSelectInput(display_, window_, eventMask_);

        // create (image) buffer

        buffer_.reset(width * height * bytesPerPixel);
        if (buffer_.isEmpty())
        {
            close();
            return false;
        }

        gc_    = DefaultGC(display_, screen);
        image_ = ::XCreateImage(display_, CopyFromParent, displayDepth, ZPixmap, 0, 0,
                                width, height, bitsPerPixel, width * bytesPerPixel);
#if defined(PIXELTOASTER_LITTLE_ENDIAN)
        image_->byte_order = LSBFirst;
#else
        image_->byte_order = MSBFirst;
#endif
        if (!image_)
        {
            close();
            return false;
        }

        // we have a winner!

        ::XMapRaised(display_, window_);
        ::XFlush(display_);

        if (DisplayAdapter::listener())
            DisplayAdapter::listener()->onOpen(wrapper() ? *wrapper() : *(DisplayInterface*)this);

        return true;
    }

    void close() override
    {
        if (image_)
        {
            XDestroyImage(image_);
            image_ = 0;
        }

        if (display_ && window_)
        {
            XDestroyWindow(display_, window_);
            window_ = 0;
        }

        if (display_)
        {
            XCloseDisplay(display_);
            display_ = 0;
        }

        DisplayAdapter::close(); // note: this calls our virtual defaults method
    }

    bool update(const TrueColorPixel* trueColorPixels, const FloatingPointPixel* floatingPointPixels, const Rectangle* dirtyBox) override
    {
        if (isShuttingDown_)
        {
            close();
            return false;
        }

        if (!display_ || !window_ || !image_)
            return false;

        const int w    = width();
        const int h    = height();
        const int size = w * h;

        const bool shortcut = trueColorPixels != nullptr && destFormat_ == Format::XRGB8888;

        if (!shortcut)
        {
            // extra conversion step: copy pixels to buffer

            if (trueColorPixels)
                trueColorConverter_->convert(trueColorPixels, buffer_.get(), size);
            else if (floatingPointPixels)
                floatingPointConverter_->convert(floatingPointPixels, buffer_.get(), size);
            else
                return false;

            image_->data = buffer_.get();
        }
        else
        {
            // shortcut: avoid extra copy - only works for truecolor pixels

            image_->data = (char*)trueColorPixels;
        }

        ::XPutImage(display_, window_, gc_, image_, 0, 0, 0, 0, w, h);
        ::XFlush(display_);

        image_->data = nullptr;

        pumpEvents();

        return true;
    }

    void title(const char title[]) override
    {
        DisplayAdapter::title(title);

        if (display_ && window_)
            ::XStoreName(display_, window_, title);
    }

protected:
    void defaults() override
    {
        DisplayAdapter::defaults();

        display_ = 0;
        window_  = 0;
        gc_      = 0;
        image_   = 0;
        buffer_.reset();
        trueColorConverter_     = 0;
        floatingPointConverter_ = 0;
        isShuttingDown_         = false;
        Format destFormat_      = Format::Unknown;
    }

private:
    enum
    {
        eventMask_  = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | ButtonMotionMask,
        keyMapSize_ = 256
    };

    typedef DirtyVector<char> TBuffer;
    typedef Key::Code         TKeyMap[keyMapSize_];
    typedef bool              TKeyFlags[keyMapSize_];

    void pumpEvents()
    {
        ::XEvent event;
        while (true)
        {
            if (::XCheckWindowEvent(display_, window_, -1, &event))
            {
                handleEvent(event);
            }
            else if (::XCheckTypedEvent(display_, ClientMessage, &event))
            {
                handleEvent(event);
            }
            else
            {
                break;
            }
        }

        // send key press and up events

        for (int i = 0; i < keyMapSize_; ++i)
        {
            if (keyIsReleased_[i] && keyIsPressed_[i])
            {
                if (listener())
                    listener()->onKeyUp(wrapper() ? *wrapper() : *(DisplayInterface*)this, static_cast<Key::Code>(i));
                keyIsPressed_[i]  = false;
                keyIsReleased_[i] = false;
            }
            else if (keyIsPressed_[i])
            {
                if (listener())
                    listener()->onKeyPressed(wrapper() ? *wrapper() : *(DisplayInterface*)this, static_cast<Key::Code>(i));
            }
        }
    }

    void handleEvent(const ::XEvent& event)
    {
        switch (event.type)
        {
            case KeyPress:
            case KeyRelease:
            {
                const KeySym keySym = ::XkbKeycodeToKeysym(display_, event.xkey.keycode, 0, 0);
                const int    hiSym  = (keySym & 0xff00) >> 8;
                const int    loSym  = keySym & 0xff;

                Key key = Key::Undefined;
                switch (hiSym)
                {
                    case 0x00:
                        key = normalKeys_[loSym];
                        break;
                    case 0xff:
                        key = functionKeys_[loSym];
                        break;
                }

                if (event.type == KeyPress)
                {
                    if (!keyIsPressed_[key])
                    {
                        bool defaultKeyHandlers = true;

                        if (listener())
                        {
                            listener()->onKeyDown(wrapper() ? *wrapper() : *(DisplayInterface*)this, key);
                            defaultKeyHandlers = listener()->defaultKeyHandlers();
                        }

                        if (defaultKeyHandlers && key == Key::Escape)
                        {
                            isShuttingDown_ = true;
                        }
                    }
                    keyIsPressed_[key]  = true;
                    keyIsReleased_[key] = false;
                }
                else
                {
                    keyIsReleased_[key] = true;
                }
                break;
            }

            case ButtonPress:
            case ButtonRelease:
            {
                Mouse mouse;
                mouse.x              = static_cast<float>(event.xbutton.x);
                mouse.y              = static_cast<float>(event.xbutton.y);
                mouse.buttons.left   = event.xbutton.button == Button1;
                mouse.buttons.middle = event.xbutton.button == Button2;
                mouse.buttons.right  = event.xbutton.button == Button3;
                if (event.type == ButtonPress)
                {
                    if (listener())
                        listener()->onMouseButtonDown(wrapper() ? *wrapper() : *(DisplayInterface*)this, mouse);
                }
                else
                {
                    if (listener())
                        listener()->onMouseButtonUp(wrapper() ? *wrapper() : *(DisplayInterface*)this, mouse);
                }
                break;
            }
            case MotionNotify:
            {
                Mouse mouse;
                mouse.x              = static_cast<float>(event.xmotion.x);
                mouse.y              = static_cast<float>(event.xmotion.y);
                mouse.buttons.left   = event.xmotion.state & Button1Mask;
                mouse.buttons.middle = event.xmotion.state & Button2Mask;
                mouse.buttons.right  = event.xmotion.state & Button3Mask;
                if (listener())
                    listener()->onMouseMove(wrapper() ? *wrapper() : *(DisplayInterface*)this, mouse);
                break;
            }
            case ClientMessage:
            {
                if (event.xclient.message_type == wmProtocols_ &&
                    event.xclient.format == 32 &&
                    event.xclient.data.l[0] == (long)wmDeleteWindow_)
                {
                    if (listener())
                    {
                        if (listener()->onClose(wrapper() ? *wrapper() : *(DisplayInterface*)this))
                            isShuttingDown_ = true;
                    }
                    else
                    {
                        isShuttingDown_ = true;
                    }
                }
                break;
            }
        }
    }

    static bool initializeKeyMaps()
    {
        for (int i = 0; i < keyMapSize_; ++i)
        {
            normalKeys_[i]    = Key::Undefined;
            functionKeys_[i]  = Key::Undefined;
            keyIsPressed_[i]  = false;
            keyIsReleased_[i] = false;
        }

        normalKeys_[XK_space]        = Key::Space;
        normalKeys_[XK_comma]        = Key::Comma;
        normalKeys_[XK_period]       = Key::Period;
        normalKeys_[XK_slash]        = Key::Slash;
        normalKeys_[XK_0]            = Key::Zero;
        normalKeys_[XK_1]            = Key::One;
        normalKeys_[XK_2]            = Key::Two;
        normalKeys_[XK_3]            = Key::Three;
        normalKeys_[XK_4]            = Key::Four;
        normalKeys_[XK_5]            = Key::Five;
        normalKeys_[XK_6]            = Key::Six;
        normalKeys_[XK_7]            = Key::Seven;
        normalKeys_[XK_8]            = Key::Eight;
        normalKeys_[XK_9]            = Key::Nine;
        normalKeys_[XK_semicolon]    = Key::SemiColon;
        normalKeys_[XK_equal]        = Key::Equals;
        normalKeys_[XK_a]            = Key::A;
        normalKeys_[XK_b]            = Key::B;
        normalKeys_[XK_c]            = Key::C;
        normalKeys_[XK_d]            = Key::D;
        normalKeys_[XK_e]            = Key::E;
        normalKeys_[XK_f]            = Key::F;
        normalKeys_[XK_g]            = Key::G;
        normalKeys_[XK_h]            = Key::H;
        normalKeys_[XK_i]            = Key::I;
        normalKeys_[XK_j]            = Key::J;
        normalKeys_[XK_k]            = Key::K;
        normalKeys_[XK_l]            = Key::L;
        normalKeys_[XK_m]            = Key::M;
        normalKeys_[XK_n]            = Key::N;
        normalKeys_[XK_o]            = Key::O;
        normalKeys_[XK_p]            = Key::P;
        normalKeys_[XK_q]            = Key::Q;
        normalKeys_[XK_r]            = Key::R;
        normalKeys_[XK_s]            = Key::S;
        normalKeys_[XK_t]            = Key::T;
        normalKeys_[XK_u]            = Key::U;
        normalKeys_[XK_v]            = Key::V;
        normalKeys_[XK_w]            = Key::W;
        normalKeys_[XK_x]            = Key::X;
        normalKeys_[XK_y]            = Key::Y;
        normalKeys_[XK_z]            = Key::Z;
        normalKeys_[XK_bracketleft]  = Key::OpenBracket;
        normalKeys_[XK_backslash]    = Key::BackSlash;
        normalKeys_[XK_bracketright] = Key::CloseBracket;

        functionKeys_[0xff & XK_BackSpace]    = Key::BackSpace;
        functionKeys_[0xff & XK_Tab]          = Key::Tab;
        functionKeys_[0xff & XK_Linefeed]     = Key::Undefined;
        functionKeys_[0xff & XK_Clear]        = Key::Clear;
        functionKeys_[0xff & XK_Return]       = Key::Enter;
        functionKeys_[0xff & XK_Pause]        = Key::Pause;
        functionKeys_[0xff & XK_Scroll_Lock]  = Key::ScrollLock;
        functionKeys_[0xff & XK_Sys_Req]      = Key::PrintScreen;
        functionKeys_[0xff & XK_Escape]       = Key::Escape;
        functionKeys_[0xff & XK_Delete]       = Key::Delete;
        functionKeys_[0xff & XK_Kanji]        = Key::Kanji;
        functionKeys_[0xff & XK_Kana_Shift]   = Key::Kana;
        functionKeys_[0xff & XK_Home]         = Key::Home;
        functionKeys_[0xff & XK_Left]         = Key::Left;
        functionKeys_[0xff & XK_Up]           = Key::Up;
        functionKeys_[0xff & XK_Right]        = Key::Right;
        functionKeys_[0xff & XK_Down]         = Key::Down;
        functionKeys_[0xff & XK_Prior]        = Key::Undefined;
        functionKeys_[0xff & XK_Page_Up]      = Key::PageUp;
        functionKeys_[0xff & XK_Next]         = Key::Undefined;
        functionKeys_[0xff & XK_Page_Down]    = Key::PageDown;
        functionKeys_[0xff & XK_End]          = Key::End;
        functionKeys_[0xff & XK_Begin]        = Key::Undefined;
        functionKeys_[0xff & XK_Select]       = Key::Undefined;
        functionKeys_[0xff & XK_Print]        = Key::Undefined;
        functionKeys_[0xff & XK_Execute]      = Key::Undefined;
        functionKeys_[0xff & XK_Insert]       = Key::Insert;
        functionKeys_[0xff & XK_Undo]         = Key::Undefined;
        functionKeys_[0xff & XK_Redo]         = Key::Undefined;
        functionKeys_[0xff & XK_Menu]         = Key::Undefined;
        functionKeys_[0xff & XK_Find]         = Key::Undefined;
        functionKeys_[0xff & XK_Cancel]       = Key::Cancel;
        functionKeys_[0xff & XK_Help]         = Key::Help;
        functionKeys_[0xff & XK_Break]        = Key::Undefined;
        functionKeys_[0xff & XK_Mode_switch]  = Key::ModeChange;
        functionKeys_[0xff & XK_Num_Lock]     = Key::NumLock;
        functionKeys_[0xff & XK_KP_Space]     = Key::Space;
        functionKeys_[0xff & XK_KP_Tab]       = Key::Tab;
        functionKeys_[0xff & XK_KP_Enter]     = Key::Enter;
        functionKeys_[0xff & XK_KP_F1]        = Key::F1;
        functionKeys_[0xff & XK_KP_F2]        = Key::F2;
        functionKeys_[0xff & XK_KP_F3]        = Key::F3;
        functionKeys_[0xff & XK_KP_F4]        = Key::F4;
        functionKeys_[0xff & XK_KP_Home]      = Key::Home;
        functionKeys_[0xff & XK_KP_Left]      = Key::Left;
        functionKeys_[0xff & XK_KP_Right]     = Key::Right;
        functionKeys_[0xff & XK_KP_Down]      = Key::Down;
        functionKeys_[0xff & XK_KP_Prior]     = Key::Undefined;
        functionKeys_[0xff & XK_KP_Page_Up]   = Key::PageUp;
        functionKeys_[0xff & XK_KP_Next]      = Key::Undefined;
        functionKeys_[0xff & XK_KP_Page_Down] = Key::PageDown;
        functionKeys_[0xff & XK_KP_End]       = Key::End;
        functionKeys_[0xff & XK_KP_Begin]     = Key::Undefined;
        functionKeys_[0xff & XK_KP_Insert]    = Key::Insert;
        functionKeys_[0xff & XK_KP_Delete]    = Key::Delete;
        functionKeys_[0xff & XK_KP_Equal]     = Key::Equals;
        functionKeys_[0xff & XK_KP_Multiply]  = Key::Multiply;
        functionKeys_[0xff & XK_KP_Add]       = Key::Add;
        functionKeys_[0xff & XK_KP_Separator] = Key::Separator;
        functionKeys_[0xff & XK_KP_Subtract]  = Key::Subtract;
        functionKeys_[0xff & XK_KP_Decimal]   = Key::Decimal;
        functionKeys_[0xff & XK_KP_Divide]    = Key::Divide;
        functionKeys_[0xff & XK_KP_0]         = Key::NumPad0;
        functionKeys_[0xff & XK_KP_1]         = Key::NumPad1;
        functionKeys_[0xff & XK_KP_2]         = Key::NumPad2;
        functionKeys_[0xff & XK_KP_3]         = Key::NumPad3;
        functionKeys_[0xff & XK_KP_4]         = Key::NumPad4;
        functionKeys_[0xff & XK_KP_5]         = Key::NumPad5;
        functionKeys_[0xff & XK_KP_6]         = Key::NumPad6;
        functionKeys_[0xff & XK_KP_7]         = Key::NumPad7;
        functionKeys_[0xff & XK_KP_8]         = Key::NumPad8;
        functionKeys_[0xff & XK_KP_9]         = Key::NumPad9;
        functionKeys_[0xff & XK_F1]           = Key::F1;
        functionKeys_[0xff & XK_F2]           = Key::F2;
        functionKeys_[0xff & XK_F3]           = Key::F3;
        functionKeys_[0xff & XK_F4]           = Key::F4;
        functionKeys_[0xff & XK_F5]           = Key::F5;
        functionKeys_[0xff & XK_F6]           = Key::F6;
        functionKeys_[0xff & XK_F7]           = Key::F7;
        functionKeys_[0xff & XK_F8]           = Key::F8;
        functionKeys_[0xff & XK_F9]           = Key::F9;
        functionKeys_[0xff & XK_F10]          = Key::F10;
        functionKeys_[0xff & XK_F11]          = Key::F11;
        functionKeys_[0xff & XK_F12]          = Key::F12;
        functionKeys_[0xff & XK_Shift_L]      = Key::Shift;
        functionKeys_[0xff & XK_Shift_R]      = Key::Shift;
        functionKeys_[0xff & XK_Control_L]    = Key::Control;
        functionKeys_[0xff & XK_Control_R]    = Key::Control;
        functionKeys_[0xff & XK_Caps_Lock]    = Key::CapsLock;
        functionKeys_[0xff & XK_Shift_Lock]   = Key::CapsLock;
        functionKeys_[0xff & XK_Meta_L]       = Key::Meta;
        functionKeys_[0xff & XK_Meta_R]       = Key::Meta;
        functionKeys_[0xff & XK_Alt_L]        = Key::Alt;
        functionKeys_[0xff & XK_Alt_R]        = Key::Alt;
        return true;
    }

    ::Display* display_;
    ::Window   window_;
    ::GC       gc_;
    ::XImage*  image_;
    TBuffer    buffer_;
    Converter* trueColorConverter_;
    Converter* floatingPointConverter_;
    bool       isShuttingDown_;
    Format     destFormat_;
    Atom       wmProtocols_;
    Atom       wmDeleteWindow_;

    static TKeyMap   normalKeys_;
    static TKeyMap   functionKeys_;
    static TKeyFlags keyIsPressed_;
    static TKeyFlags keyIsReleased_;
    static bool      keyMapsInitialized_;
};

UnixDisplay::TKeyMap   UnixDisplay::normalKeys_;
UnixDisplay::TKeyMap   UnixDisplay::functionKeys_;
UnixDisplay::TKeyFlags UnixDisplay::keyIsPressed_;
UnixDisplay::TKeyFlags UnixDisplay::keyIsReleased_;
bool                   UnixDisplay::keyMapsInitialized_ = UnixDisplay::initializeKeyMaps();
} // namespace PixelToaster

// unix timer implementation

#ifndef PIXELTOASTER_NO_UNIX_TIMER

#    include <time.h>
#    include <errno.h>
#    include <math.h>

//#define PIXELTOASTER_RDTSC
#    ifdef PIXELTOASTER_RDTSC
#        include <stdint.h>
#        include <stdio.h>
#    endif

namespace PixelToaster {
namespace internal {
static void wait(double seconds)
{
    const double floorSeconds      = ::floor(seconds);
    const double fractionalSeconds = seconds - floorSeconds;

    timespec timeOut;
    timeOut.tv_sec  = static_cast<time_t>(floorSeconds);
    timeOut.tv_nsec = static_cast<long>(fractionalSeconds * 1e9);

    // nanosleep may return earlier than expected if there's a signal
    // that should be handled by the calling thread.  If it happens,
    // sleep again. [Bramz]
    //
    timespec timeRemaining;
    while (true)
    {
        const int ret = nanosleep(&timeOut, &timeRemaining);
        if (ret == -1 && errno == EINTR)
        {
            // there was only an sleep interruption, go back to sleep.
            timeOut.tv_sec  = timeRemaining.tv_sec;
            timeOut.tv_nsec = timeRemaining.tv_nsec;
        }
        else
        {
            // we're done, or error =)
            return;
        }
    }
}
} // namespace internal

#    ifdef PIXELTOASTER_RDTSC

class UnixTimer : public TimerInterface
{
public:
    UnixTimer()
        : resolution_(determineResolution())
    {
        reset();
    }

    void reset()
    {
        deltaStart_ = start_ = tick();
    }

    double time()
    {
        const uint64_t now = tick();
        return resolution_ * (now - start_);
    }

    double delta()
    {
        const uint64_t now = tick();
        const double   dt  = resolution_ * (now - deltaStart_);
        deltaStart_        = now;
        return dt;
    }

    double resolution()
    {
        return resolution_;
    }

    void wait(double seconds)
    {
        internal::wait(seconds);
    }

private:
    static inline uint64_t tick()
    {
#        ifdef PIXELTOASTER_64BIT
        uint32_t a, d;
        __asm__ __volatile__("rdtsc"
                             : "=a"(a), "=d"(d));
        return (static_cast<uint64_t>(d) << 32) | static_cast<uint64_t>(a);
#        else
        uint64_t val;
        __asm__ __volatile__("rdtsc"
                             : "=A"(val));
        return val;
#        endif
    }

    static double determineResolution()
    {
        FILE* f = fopen("/proc/cpuinfo", "r");
        if (!f)
        {
            return 0.;
        }
        const int bufferSize = 256;
        char      buffer[bufferSize];
        while (fgets(buffer, bufferSize, f))
        {
            float frequency;
            if (sscanf(buffer, "cpu MHz         : %f", &frequency) == 1)
            {
                fclose(f);
                return 1e-6 / static_cast<double>(frequency);
            }
        }
        fclose(f);
        return 0.;
    }

    uint64_t start_;
    uint64_t deltaStart_;
    double   resolution_;
};

#    else

class UnixTimer : public TimerInterface
{
public:
    UnixTimer()
    {
        reset();
    }

    void reset()
    {
        deltaStart_ = start_ = realTime();
    }

    double time()
    {
        return realTime() - start_;
    }

    double delta()
    {
        const double now = realTime();
        const double dt  = now - deltaStart_;
        deltaStart_      = now;
        return dt;
    }

    double resolution()
    {
        timespec res;
        if (clock_getres(CLOCK_REALTIME, &res) != 0)
        {
            return 0.;
        }
        return res.tv_sec + res.tv_nsec * 1e-9;
    }

    void wait(double seconds)
    {
        internal::wait(seconds);
    }

private:
    static inline double realTime()
    {
        timespec time;
        if (clock_gettime(CLOCK_REALTIME, &time) != 0)
        {
            return 0.;
        }
        return time.tv_sec + time.tv_nsec * 1e-9;
    }

    double start_;
    double deltaStart_;
};
}

#    endif

#endif