Update to 20180728 release.

byuu says:

Sigh, I seem to be spiraling a bit here ... but the work is very
important. Hopefully I can get a solid WIP together soon. But for now...

I've integrated dynamic rate control into ruby::Audio via
setDynamic(bool) for now. It's very demanding, as you would expect. When
it's not in use, I realized the OSS driver's performance was pretty bad
due to calling write() for every sample for every channel. I implemented
a tiny 256-sample buffer and bsnes went from 290fps to 330fps on my
FreeBSD desktop. It may be possible to do the same buffering with DRC,
but for now, I'm not doing so, and adjusting the audio input frequency
on every sample.

I also added ruby::Video::setFlush(bool), which is available only in the
OpenGL drivers, and this causes glFinish() to be called after swapping
display buffers. I really couldn't think of a good name for this, "hard
GPU sync" sounds kind of silly. In my view, flush is what commits queued
events. Eg fflush(). OpenGL of course treats glFlush differently (I
really don't even know what the point of it is even after reading the
manual ...), and then has glFinish ... meh, whatever. It's
setFlush(bool) until I come up with something better. Also as expected,
this one's a big hit to performance.

To implement the DRC, I started putting helper functions into the ruby
video/audio/input core classes. And then the XVideo driver started
crashing. It took hours and hours and hours to track down the problem:
you have to clear XSetWindowAttributes to zero before calling
XCreateWindow. No amount of `--sync`, `gdb break gdk_x_error`, `-Og`,
etc will make Xlib be even remotely helpful in debugging errors like
this.

The GLX, GLX2, and XVideo drivers basically worked by chance before. If
the stack frame had the right memory cleared, it worked. Otherwise it'd
crash with BadValue, and my changing things broke that condition on the
XVideo driver. So this has been fixed in all three now.

Once XVideo was running again, I realized that non-power of two video
sizes were completely broken for the YUV formats. It took a while, but I
managed to fix all of that as well.

At this point, most of ruby is going to be broken outside of FreeBSD, as
I still need to finish updating all the drivers.

higan/audio/stream.cpp

@@ -65,7 +65,7 @@ auto Stream::pending() const -> bool {
 }
 
 auto Stream::read(double samples[]) -> uint {
-  for(auto c : range(channels.size())) samples[c] = channels[c].resampler.read();
+  for(uint c : range(channels.size())) samples[c] = channels[c].resampler.read();
   return channels.size();
 }
 

higan/target-bsnes/presentation/presentation.cpp

@@ -393,7 +393,7 @@ auto Presentation::updateDeviceSelections() -> void {
 
 //generate a list of size multipliers
 auto Presentation::updateSizeMenu() -> void {
-  assert(sizeMenu.actions() == 0);  //should only be called once
+  assert(sizeMenu.actionCount() == 0);  //should only be called once
 
   //determine the largest multiplier that can be used by the largest monitor found
   uint height = 1;

higan/target-bsnes/program/audio.cpp

@@ -19,10 +19,15 @@ auto Program::updateAudioDriver() -> void {
 
 auto Program::updateAudioExclusive() -> void {
   if(!audio) return;
-  audio->clear();
+  if(audio->hasExclusive()) {
     audio->setExclusive(settings["Audio/Exclusive"].boolean());
+    settingsWindow->audio.exclusiveMode.setEnabled(true).setChecked(settings["Audio/Exclusive"].boolean());
+    audio->clear();
     updateAudioFrequency();
     updateAudioLatency();
+  } else {
+    settingsWindow->audio.exclusiveMode.setEnabled(false).setChecked(false);
+  }
 }
 
 auto Program::updateAudioDevice() -> void {

higan/target-bsnes/program/program.hpp

@@ -58,6 +58,7 @@ struct Program : Emulator::Platform {
   auto renameState(string from, string to) -> bool;
 
   //video.cpp
+  auto updateVideoExclusive() -> void;
   auto updateVideoDriver() -> void;
   auto updateVideoBlocking() -> void;
   auto updateVideoShader() -> void;

higan/target-bsnes/program/video.cpp

@@ -1,7 +1,7 @@
 auto Program::updateVideoDriver() -> void {
   video = Video::create(settings["Video/Driver"].text());
   video->setContext(presentation->viewport.handle());
-  video->setExclusive(false);
+  updateVideoExclusive();
   updateVideoBlocking();
   updateVideoShader();
 
@@ -27,6 +27,15 @@ auto Program::updateVideoDriver() -> void {
   presentation->updateShaders();
 }
 
+auto Program::updateVideoExclusive() -> void {
+  video->setExclusive(false);
+  if(video->hasExclusive()) {
+    settingsWindow->video.exclusiveMode.setEnabled(true).setChecked(settings["Video/Exclusive"].boolean());
+  } else {
+    settingsWindow->video.exclusiveMode.setEnabled(false).setChecked(false);
+  }
+}
+
 auto Program::updateVideoBlocking() -> void {
   video->setBlocking(settings["Video/Blocking"].boolean());
 }

hiro/gtk/action/action.cpp

@@ -21,12 +21,8 @@ auto pAction::setVisible(bool visible) -> void {
 }
 
 //GTK+ uses _ for mnemonics, __ for _
-//transform so that & is used for mnemonics, && for &
 auto pAction::_mnemonic(string text) -> string {
-  text.transform("&_", "\x01\x02");
+  text.replace("_", "__");
-  text.replace("\x01\x01", "&");
-  text.transform("\x01", "_");
-  text.replace("\x02", "__");
   return text;
 }
 

hiro/gtk/window.cpp

@@ -487,7 +487,7 @@ auto pWindow::_setScreenSaver(bool screenSaver) -> void {
   if(pApplication::xdgScreenSaver) {
     if(this->screenSaver != screenSaver) {
       this->screenSaver = screenSaver;
-      execute("xdg-screensaver", screenSaver ? "resume" : "suspend", string{"0x", hex(handle())});
+      invoke("xdg-screensaver", screenSaver ? "resume" : "suspend", string{"0x", hex(handle())});
     }
   }
   #endif

nall/dsp/resampler/cubic.hpp

@@ -7,8 +7,9 @@ namespace nall { namespace DSP { namespace Resampler {
 
 struct Cubic {
   inline auto reset(real inputFrequency, real outputFrequency, uint queueSize = 0) -> void;
-  inline auto pending() const -> bool { return samples.pending(); }
+  inline auto setInputFrequency(real inputFrequency) -> void;
-  inline auto read() -> real { return samples.read(); }
+  inline auto pending() const -> bool;
+  inline auto read() -> real;
   inline auto write(real sample) -> void;
 
 private:
@@ -32,6 +33,19 @@ auto Cubic::reset(real inputFrequency, real outputFrequency, uint queueSize) ->
   samples.resize(queueSize);
 }
 
+auto Cubic::setInputFrequency(real inputFrequency) -> void {
+  this->inputFrequency = inputFrequency;
+  ratio = inputFrequency / outputFrequency;
+}
+
+auto Cubic::pending() const -> bool {
+  return samples.pending();
+}
+
+auto Cubic::read() -> real {
+  return samples.read();
+}
+
 auto Cubic::write(real sample) -> void {
   auto& mu = fraction;
   auto& s = history;

nall/hid.hpp

@@ -1,5 +1,10 @@
 #pragma once
 
+#include <nall/maybe.hpp>
+#include <nall/range.hpp>
+#include <nall/string.hpp>
+#include <nall/vector.hpp>
+
 namespace nall { namespace HID {
 
 struct Input {

ruby/GNUmakefile

@@ -12,7 +12,7 @@ ifeq ($(ruby),)
     ruby += audio.oss audio.alsa audio.openal audio.pulseaudio audio.pulseaudiosimple audio.ao
     ruby += input.sdl input.xlib input.udev
   else ifeq ($(platform),bsd)
-    ruby += video.glx video.xvideo video.xshm
+    ruby += video.glx video.glx2 video.xvideo video.xshm
     ruby += audio.oss audio.openal
     ruby += input.sdl input.xlib
   endif
@@ -68,7 +68,7 @@ endif
 
 ruby.objects := $(object.path)/ruby.o
 
-$(object.path)/ruby.o: $(ruby.path)/ruby.cpp
+$(object.path)/ruby.o: $(ruby.path)/ruby.cpp $(call rwildcard,$(ruby.path))
 	$(info Compiling $< ...)
 	@$(compiler) $(ruby.flags) $(flags) $(flags.deps) -c $< -o $@
 

ruby/audio.cpp

@@ -0,0 +1,254 @@
+#if defined(AUDIO_ALSA)
+  #include <ruby/audio/alsa.cpp>
+#endif
+
+#if defined(AUDIO_AO)
+  #include <ruby/audio/ao.cpp>
+#endif
+
+#if defined(AUDIO_ASIO)
+  #include <ruby/audio/asio.cpp>
+#endif
+
+#if defined(AUDIO_DIRECTSOUND)
+  #include <ruby/audio/directsound.cpp>
+#endif
+
+#if defined(AUDIO_OPENAL)
+  #include <ruby/audio/openal.cpp>
+#endif
+
+#if defined(AUDIO_OSS)
+  #include <ruby/audio/oss.cpp>
+#endif
+
+#if defined(AUDIO_PULSEAUDIO)
+  #include <ruby/audio/pulseaudio.cpp>
+#endif
+
+#if defined(AUDIO_PULSEAUDIOSIMPLE)
+  #include <ruby/audio/pulseaudiosimple.cpp>
+#endif
+
+#if defined(AUDIO_WASAPI)
+  #include <ruby/audio/wasapi.cpp>
+#endif
+
+#if defined(AUDIO_XAUDIO2)
+  #include <ruby/audio/xaudio2.cpp>
+#endif
+
+namespace ruby {
+
+auto Audio::setExclusive(bool exclusive) -> bool {
+  _exclusive = exclusive;
+  return true;
+}
+
+auto Audio::setContext(uintptr context) -> bool {
+  _context = context;
+  return true;
+}
+
+auto Audio::setDevice(string device) -> bool {
+  _device = device;
+  return true;
+}
+
+auto Audio::setBlocking(bool blocking) -> bool {
+  _blocking = blocking;
+  Audio::setFrequency(frequency());
+  return true;
+}
+
+auto Audio::setDynamic(bool dynamic) -> bool {
+  _dynamic = dynamic;
+  return true;
+}
+
+auto Audio::setChannels(uint channels) -> bool {
+  _channels = channels;
+  _resamplers.reset();
+  _resamplers.resize(channels);
+  Audio::setFrequency(frequency());
+  return true;
+}
+
+auto Audio::setFrequency(double frequency) -> bool {
+  _frequency = frequency;
+  for(auto& resampler : _resamplers) {
+    resampler.reset(frequency, frequency);
+  }
+  return true;
+}
+
+auto Audio::setLatency(uint latency) -> bool {
+  _latency = latency;
+  return true;
+}
+
+//protected functions
+
+auto Audio::pending() -> bool {
+  return _resamplers && _resamplers[0].pending();
+}
+
+auto Audio::outputDynamic(const double samples[]) -> void {
+  auto maxDelta = 0.005;
+  double fillLevel = level();
+  double dynamicFrequency = ((1.0 - maxDelta) + 2.0 * fillLevel * maxDelta) * frequency();
+  for(auto& resampler : _resamplers) {
+    resampler.setInputFrequency(dynamicFrequency);
+    resampler.write(*samples++);
+  }
+}
+
+//static functions
+
+auto Audio::create(string driver) -> Audio* {
+  Audio* audio = nullptr;
+  if(!driver) driver = optimalDriver();
+
+  #if defined(AUDIO_ALSA)
+  if(driver == "ALSA") audio = new AudioALSA;
+  #endif
+
+  #if defined(AUDIO_AO)
+  if(driver == "libao") audio = new AudioAO;
+  #endif
+
+  #if defined(AUDIO_ASIO)
+  if(driver == "ASIO") audio = new AudioASIO;
+  #endif
+
+  #if defined(AUDIO_DIRECTSOUND)
+  if(driver == "DirectSound") audio = new AudioDirectSound;
+  #endif
+
+  #if defined(AUDIO_OPENAL)
+  if(driver == "OpenAL") audio = new AudioOpenAL;
+  #endif
+
+  #if defined(AUDIO_OSS)
+  if(driver == "OSS") audio = new AudioOSS;
+  #endif
+
+  #if defined(AUDIO_PULSEAUDIO)
+  if(driver == "PulseAudio") audio = new AudioPulseAudio;
+  #endif
+
+  #if defined(AUDIO_PULSEAUDIOSIMPLE)
+  if(driver == "PulseAudioSimple") audio = new AudioPulseAudioSimple;
+  #endif
+
+  #if defined(AUDIO_WASAPI)
+  if(driver == "WASAPI") audio = new AudioWASAPI;
+  #endif
+
+  #if defined(AUDIO_XAUDIO2)
+  if(driver == "XAudio2") audio = new AudioXAudio2;
+  #endif
+
+  if(!audio) audio = new Audio;
+  return audio;
+}
+
+auto Audio::optimalDriver() -> string {
+  #if defined(AUDIO_ASIO)
+  return "ASIO";
+  #elif defined(AUDIO_WASAPI)
+  return "WASAPI";
+  #elif defined(AUDIO_XAUDIO2)
+  return "XAudio2";
+  #elif defined(AUDIO_DIRECTSOUND)
+  return "DirectSound";
+  #elif defined(AUDIO_ALSA)
+  return "ALSA";
+  #elif defined(AUDIO_OSS)
+  return "OSS";
+  #elif defined(AUDIO_OPENAL)
+  return "OpenAL";
+  #elif defined(AUDIO_PULSEAUDIO)
+  return "PulseAudio";
+  #elif defined(AUDIO_PULSEAUDIOSIMPLE)
+  return "PulseAudioSimple";
+  #elif defined(AUDIO_AO)
+  return "libao";
+  #else
+  return "None";
+  #endif
+}
+
+auto Audio::safestDriver() -> string {
+  #if defined(AUDIO_DIRECTSOUND)
+  return "DirectSound";
+  #elif defined(AUDIO_WASAPI)
+  return "WASAPI";
+  #elif defined(AUDIO_XAUDIO2)
+  return "XAudio2";
+  #elif defined(AUDIO_ALSA)
+  return "ALSA";
+  #elif defined(AUDIO_OSS)
+  return "OSS";
+  #elif defined(AUDIO_OPENAL)
+  return "OpenAL";
+  #elif defined(AUDIO_PULSEAUDIO)
+  return "PulseAudio";
+  #elif defined(AUDIO_PULSEAUDIOSIMPLE)
+  return "PulseAudioSimple";
+  #elif defined(AUDIO_AO)
+  return "libao";
+  #elif defined(AUDIO_ASIO)
+  return "ASIO";
+  #else
+  return "None";
+  #endif
+}
+
+auto Audio::availableDrivers() -> vector<string> {
+  return {
+
+  #if defined(AUDIO_ASIO)
+  "ASIO",
+  #endif
+
+  #if defined(AUDIO_WASAPI)
+  "WASAPI",
+  #endif
+
+  #if defined(AUDIO_XAUDIO2)
+  "XAudio2",
+  #endif
+
+  #if defined(AUDIO_DIRECTSOUND)
+  "DirectSound",
+  #endif
+
+  #if defined(AUDIO_ALSA)
+  "ALSA",
+  #endif
+
+  #if defined(AUDIO_OSS)
+  "OSS",
+  #endif
+
+  #if defined(AUDIO_OPENAL)
+  "OpenAL",
+  #endif
+
+  #if defined(AUDIO_PULSEAUDIO)
+  "PulseAudio",
+  #endif
+
+  #if defined(AUDIO_PULSEAUDIOSIMPLE)
+  "PulseAudioSimple",
+  #endif
+
+  #if defined(AUDIO_AO)
+  "libao",
+  #endif
+
+  "None"};
+}
+
+}

ruby/audio.hpp

@@ -0,0 +1,62 @@
+struct Audio {
+  static auto create(string driver = "") -> Audio*;
+  static auto optimalDriver() -> string;
+  static auto safestDriver() -> string;
+  static auto availableDrivers() -> vector<string>;
+
+  virtual ~Audio() = default;
+
+  virtual auto driver() -> string { return "None"; }
+  virtual auto ready() -> bool { return true; }
+
+  virtual auto availableDevices() -> vector<string> { return {"Default"}; }
+  virtual auto availableChannels() -> vector<uint> { return {2}; }
+  virtual auto availableFrequencies() -> vector<double> { return {48000.0}; }
+  virtual auto availableLatencies() -> vector<uint> { return {0}; }
+
+  virtual auto hasExclusive() -> bool { return false; }
+  virtual auto hasContext() -> bool { return false; }
+  virtual auto hasDevice() -> bool { return false; }
+  virtual auto hasBlocking() -> bool { return false; }
+  virtual auto hasDynamic() -> bool { return false; }
+  virtual auto hasChannels() -> bool { return false; }
+  virtual auto hasFrequency() -> bool { return false; }
+  virtual auto hasLatency() -> bool { return false; }
+
+  virtual auto exclusive() -> bool { return _exclusive; }
+  virtual auto context() -> uintptr { return _context; }
+  virtual auto device() -> string { return _device; }
+  virtual auto blocking() -> bool { return _blocking; }
+  virtual auto dynamic() -> bool { return _dynamic; }
+  virtual auto channels() -> uint { return _channels; }
+  virtual auto frequency() -> double { return _frequency; }
+  virtual auto latency() -> uint { return _latency; }
+
+  virtual auto setExclusive(bool exclusive) -> bool;
+  virtual auto setContext(uintptr context) -> bool;
+  virtual auto setDevice(string device) -> bool;
+  virtual auto setBlocking(bool blocking) -> bool;
+  virtual auto setDynamic(bool dynamic) -> bool;
+  virtual auto setChannels(uint channels) -> bool;
+  virtual auto setFrequency(double frequency) -> bool;
+  virtual auto setLatency(uint latency) -> bool;
+
+  virtual auto clear() -> void {}
+  virtual auto level() -> double { return 0.5; }
+  virtual auto output(const double samples[]) -> void {}
+
+protected:
+  virtual auto pending() -> bool;
+  virtual auto outputDynamic(const double samples[]) -> void;
+
+  bool _exclusive = false;
+  uintptr _context = 0;
+  string _device = "Default";
+  bool _blocking = false;
+  bool _dynamic = false;
+  uint _channels = 2;
+  double _frequency = 48000.0;
+  uint _latency = 0;
+
+  vector<nall::DSP::Resampler::Cubic> _resamplers;
+};

ruby/audio/alsa.cpp

@@ -4,54 +4,67 @@ struct AudioALSA : Audio {
   AudioALSA() { initialize(); }
   ~AudioALSA() { terminate(); }
 
-  auto availableDevices() -> string_vector {
+  auto driver() -> string override {
+    return "ALSA";
+  }
+
+  auto ready() -> bool override {
+    return _ready;
+  }
+
+  auto availableDevices() -> vector<string> override {
     return queryDevices();
   }
 
-  auto availableFrequencies() -> vector<double> {
+  auto availableChannels() -> vector<uint> override {
-    return {44100.0, 48000.0, 96000.0};
-  }
-
-  auto availableLatencies() -> vector<uint> {
-    return {20, 40, 60, 80, 100};
-  }
-
-  auto availableChannels() -> vector<uint> {
     return {2};
   }
 
-  auto ready() -> bool { return _ready; }
+  auto availableFrequencies() -> vector<double> override {
-  auto device() -> string { return _device; }
+    return {44100.0, 48000.0, 96000.0};
-  auto blocking() -> bool { return _blocking; }
+  }
-  auto channels() -> uint { return 2; }
-  auto frequency() -> double { return _frequency; }
-  auto latency() -> uint { return _latency; }
 
-  auto setDevice(string device) -> bool {
+  auto availableLatencies() -> vector<uint> override {
-    if(_device == device) return true;
+    return {20, 40, 60, 80, 100};
-    _device = device;
+  }
+
+  auto hasDevice() -> bool override { return true; }
+  auto hasBlocking() -> bool override { return true; }
+  auto hasChannels() -> bool override { return true; }
+  auto hasFrequency() -> bool override { return true; }
+  auto hasLatency() -> bool override { return true; }
+
+  auto setDevice(string device) -> bool override {
+    if(device == this->device()) return true;
+    if(!Audio::setDevice(device)) return false;
     return initialize();
   }
 
-  auto setBlocking(bool blocking) -> bool {
+  auto setBlocking(bool blocking) -> bool override {
-    if(_blocking == blocking) return true;
+    if(blocking == this->blocking()) return true;
-    _blocking = blocking;
+    if(!Audio::setBlocking(blocking)) return false;
     return true;
   }
 
-  auto setFrequency(double frequency) -> bool {
+  auto setChannels(uint channels) -> bool override {
-    if(_frequency == frequency) return true;
+    if(channels == this->channels()) return true;
-    _frequency = frequency;
+    if(!Audio::setChannels(channels)) return false;
+    return true;
+  }
+
+  auto setFrequency(double frequency) -> bool override {
+    if(frequency == this->frequency()) return true;
+    if(!Audio::setFrequency(frequency)) return false;
     return initialize();
   }
 
-  auto setLatency(uint latency) -> bool {
+  auto setLatency(uint latency) -> bool override {
-    if(_latency == latency) return true;
+    if(latency == this->latency()) return true;
-    _latency = latency;
+    if(!Audio::setLatency(latency)) return false;
     return initialize();
   }
 
-  auto output(const double samples[]) -> void {
+  auto output(const double samples[]) -> void override {
     if(!ready()) return;
 
     _buffer[_offset]  = (uint16_t)sclamp<16>(samples[0] * 32767.0) <<  0;
@@ -169,10 +182,6 @@ private:
   }
 
   bool _ready = false;
-  string _device;
-  bool _blocking = true;
-  double _frequency = 48000.0;
-  uint _latency = 40;
 
   snd_pcm_t* _interface = nullptr;
   snd_pcm_uframes_t _bufferSize;

ruby/audio/openal.cpp

@@ -10,57 +10,70 @@ struct AudioOpenAL : Audio {
   AudioOpenAL() { initialize(); }
   ~AudioOpenAL() { terminate(); }
 
-  auto availableDevices() -> vector<string> {
+  auto driver() -> string override {
+    return "OpenAL";
+  }
+
+  auto ready() -> bool override {
+    return _ready;
+  }
+
+  auto availableDevices() -> vector<string> override {
     vector<string> devices;
     for(auto& device : queryDevices()) devices.append(device);
     return devices;
   }
 
-  auto availableFrequencies() -> vector<double> {
+  auto availableChannels() -> vector<uint> override {
-    return {44100.0, 48000.0, 96000.0};
-  }
-
-  auto availableLatencies() -> vector<uint> {
-    return {20, 40, 60, 80, 100};
-  }
-
-  auto availableChannels() -> vector<uint> {
     return {2};
   }
 
-  auto ready() -> bool { return _ready; }
+  auto availableFrequencies() -> vector<double> override {
-  auto device() -> string { return _device; }
+    return {44100.0, 48000.0, 96000.0};
-  auto blocking() -> bool { return _blocking; }
+  }
-  auto channels() -> uint { return _channels; }
-  auto frequency() -> double { return (double)_frequency; }
-  auto latency() -> uint { return _latency; }
 
-  auto setDevice(string device) -> bool {
+  auto availableLatencies() -> vector<uint> override {
-    if(_device == device) return true;
+    return {20, 40, 60, 80, 100};
-    _device = device;
+  }
+
+  auto hasDevice() -> bool override { return true; }
+  auto hasBlocking() -> bool override { return true; }
+  auto hasChannels() -> bool override { return true; }
+  auto hasFrequency() -> bool override { return true; }
+  auto hasLatency() -> bool override { return true; }
+
+  auto setDevice(string device) -> bool override {
+    if(device == this->device()) return true;
+    if(!Audio::setDevice(device)) return false;
     return initialize();
   }
 
-  auto setBlocking(bool blocking) -> bool {
+  auto setBlocking(bool blocking) -> bool override {
-    if(_blocking == blocking) return true;
+    if(blocking == this->blocking()) return true;
-    _blocking = blocking;
+    if(!Audio::setBlocking(blocking)) return false;
     return true;
   }
 
-  auto setFrequency(double frequency) -> bool {
+  auto setChannels(uint channels) -> bool override {
-    if(_frequency == (uint)frequency) return true;
+    if(channels == this->channels()) return true;
-    _frequency = (uint)frequency;
+    if(!Audio::setChannels(channels)) return false;
+    return true;
+  }
+
+  auto setFrequency(double frequency) -> bool override {
+    if(frequency == this->frequency()) return true;
+    if(!Audio::setFrequency(frequency)) return false;
     return initialize();
   }
 
-  auto setLatency(uint latency) -> bool {
+  auto setLatency(uint latency) -> bool override {
-    if(_latency == latency) return true;
+    if(latency == this->latency()) return true;
-    _latency = latency;
+    if(!Audio::setLatency(latency)) return false;
-    if(_ready) updateLatency();
+    if(ready()) updateLatency();
     return true;
   }
 
-  auto output(const double samples[]) -> void {
+  auto output(const double samples[]) -> void override {
     _buffer[_bufferLength]  = (uint16_t)sclamp<16>(samples[0] * 32767.0) <<  0;
     _buffer[_bufferLength] |= (uint16_t)sclamp<16>(samples[1] * 32767.0) << 16;
     if(++_bufferLength < _bufferSize) return;
@@ -184,11 +197,6 @@ private:
   }
 
   bool _ready = false;
-  string _device;
-  bool _blocking = true;
-  uint _channels = 2;
-  uint _frequency = 48000;
-  uint _latency = 20;
 
   ALCdevice* _openAL = nullptr;
   ALCcontext* _context = nullptr;

ruby/audio/oss.cpp

@@ -17,78 +17,108 @@ struct AudioOSS : Audio {
   AudioOSS() { initialize(); }
   ~AudioOSS() { terminate(); }
 
-  auto availableDevices() -> vector<string> {
+  auto driver() -> string override {
+    return "OSS";
+  }
+
+  auto ready() -> bool override {
+    return _fd >= 0;
+  }
+
+  auto availableDevices() -> vector<string> override {
     vector<string> devices;
     devices.append("/dev/dsp");
     for(auto& device : directory::files("/dev/", "dsp?*")) devices.append(string{"/dev/", device});
     return devices;
   }
 
-  auto availableFrequencies() -> vector<double> {
+  auto availableChannels() -> vector<uint> override {
-    return {44100.0, 48000.0, 96000.0};
-  }
-
-  auto availableLatencies() -> vector<uint> {
-    return {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-  }
-
-  auto availableChannels() -> vector<uint> {
     return {1, 2};
   }
 
-  auto ready() -> bool { return _ready; }
+  auto availableFrequencies() -> vector<double> override {
-  auto device() -> string { return _device; }
+    return {44100.0, 48000.0, 96000.0};
-  auto blocking() -> bool { return _blocking; }
+  }
-  auto channels() -> uint { return _channels; }
-  auto frequency() -> double { return _frequency; }
-  auto latency() -> uint { return _latency; }
 
-  auto setDevice(string device) -> bool {
+  auto availableLatencies() -> vector<uint> override {
-    if(_device == device) return true;
+    return {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    _device = device;
+  }
+
+  auto hasDevice() -> bool override { return true; }
+  auto hasDynamic() -> bool override { return true; }
+  auto hasBlocking() -> bool override { return true; }
+  auto hasChannels() -> bool override { return true; }
+  auto hasFrequency() -> bool override { return true; }
+  auto hasLatency() -> bool override { return true; }
+
+  auto setDevice(string device) -> bool override {
+    if(device == this->device()) return true;
+    if(!Audio::setDevice(device)) return false;
     return initialize();
   }
 
-  auto setBlocking(bool blocking) -> bool {
+  auto setBlocking(bool blocking) -> bool override {
-    if(_blocking == blocking) return true;
+    if(blocking == this->blocking()) return true;
-    _blocking = blocking;
+    if(!Audio::setBlocking(blocking)) return false;
-    updateBlocking();
+    return updateBlocking();
+  }
+
+  auto setDynamic(bool dynamic) -> bool override {
+    if(dynamic == this->dynamic()) return true;
+    if(!Audio::setDynamic(dynamic)) return false;
     return true;
   }
 
-  auto setChannels(uint channels) -> bool {
+  auto setChannels(uint channels) -> bool override {
-    if(_channels == channels) return true;
+    if(channels == this->channels()) return true;
-    _channels = channels;
+    if(!Audio::setChannels(channels)) return false;
     return initialize();
   }
 
-  auto setFrequency(double frequency) -> bool {
+  auto setFrequency(double frequency) -> bool override {
-    if(_frequency == frequency) return true;
+    if(frequency == this->frequency()) return true;
-    _frequency = frequency;
+    if(!Audio::setFrequency(frequency)) return false;
     return initialize();
   }
 
-  auto setLatency(uint latency) -> bool {
+  auto setLatency(uint latency) -> bool override {
-    if(_latency == latency) return true;
+    if(latency == this->latency()) return true;
-    _latency = latency;
+    if(!Audio::setLatency(latency)) return false;
     return initialize();
   }
 
-  auto output(const double samples[]) -> void {
+  auto level() -> double override {
+    audio_buf_info info;
+    ioctl(_fd, SNDCTL_DSP_GETOSPACE, &info);
+    return (double)(_bufferSize - info.bytes) / _bufferSize;
+  }
+
+  auto output(const double samples[]) -> void override {
     if(!ready()) return;
-    for(auto n : range(_channels)) {
+
-      auto sample = (uint16_t)sclamp<16>(samples[n] * 32767.0);
+    if(!_dynamic) {
+      for(uint n : range(channels())) {
+        sample(sclamp<16>(samples[n] * 32767.0));
+      }
+    } else {
+      Audio::outputDynamic(samples);
+      while(pending()) {
+        for(auto& resampler : _resamplers) {
+          auto sample = (uint16_t)sclamp<16>(resampler.read() * 32767.0);
           auto unused = write(_fd, &sample, 2);
         }
       }
+    }
+  }
 
 private:
   auto initialize() -> bool {
     terminate();
 
     if(!availableDevices().find(_device)) {
-      _device = availableDevices().left();
+      Audio::setDevice(availableDevices().left());
     }
+    Audio::setChannels(channels());
 
     _fd = open(_device, O_WRONLY, O_NONBLOCK);
     if(_fd < 0) return false;
@@ -103,33 +133,41 @@ private:
     ioctl(_fd, SNDCTL_DSP_SETFMT, &_format);
     int frequency = _frequency;
     ioctl(_fd, SNDCTL_DSP_SPEED, &frequency);
-
     updateBlocking();
-    return _ready = true;
+    audio_buf_info info;
+    ioctl(_fd, SNDCTL_DSP_GETOSPACE, &info);
+    _bufferSize = info.bytes;
+
+    return true;
   }
 
   auto terminate() -> void {
-    _ready = false;
+    if(!ready()) return;
-    if(_fd < 0) return;
     close(_fd);
     _fd = -1;
   }
 
-  auto updateBlocking() -> void {
+  auto updateBlocking() -> bool {
-    if(!_ready) return;
+    if(!ready()) return false;
     auto flags = fcntl(_fd, F_GETFL);
-    if(flags < 0) return;
+    if(flags < 0) return false;
     _blocking ? flags &=~ O_NONBLOCK : flags |= O_NONBLOCK;
     fcntl(_fd, F_SETFL, flags);
+    return true;
   }
 
-  bool _ready = false;
+  auto sample(uint16_t sample) -> void {
-  string _device;
+    _outputBuffer[_outputOffset++] = sample;
-  bool _blocking = true;
+    if(_outputOffset >= sizeof(_outputBuffer) / sizeof(uint16_t)) {
-  uint _channels = 2;
+      write(_fd, &_outputBuffer, sizeof(_outputBuffer));
-  double _frequency = 48000.0;
+      _outputOffset = 0;
-  uint _latency = 2;
+    }
+  }
 
   int _fd = -1;
   int _format = AFMT_S16_LE;
+  int _bufferSize = 1;
+
+  uint _outputOffset = 0;
+  uint16_t _outputBuffer[256];
 };

ruby/input.cpp

@@ -0,0 +1,142 @@
+#if defined(INPUT_CARBON)
+  #include <ruby/input/carbon.cpp>
+#endif
+
+#if defined(INPUT_QUARTZ)
+  #include <ruby/input/quartz.cpp>
+#endif
+
+#if defined(INPUT_SDL)
+  #include <ruby/input/sdl.cpp>
+#endif
+
+#if defined(INPUT_UDEV)
+  #include <ruby/input/udev.cpp>
+#endif
+
+#if defined(INPUT_WINDOWS)
+  #include <ruby/input/windows.cpp>
+#endif
+
+#if defined(INPUT_XLIB)
+  #include <ruby/input/xlib.cpp>
+#endif
+
+namespace ruby {
+
+auto Input::setContext(uintptr context) -> bool {
+  _context = context;
+  return true;
+}
+
+auto Input::onChange(const function<void (shared_pointer<HID::Device>, uint, uint, int16_t, int16_t)>& onChange) -> void {
+  _onChange = onChange;
+}
+
+auto Input::doChange(shared_pointer<HID::Device> device, uint group, uint input, int16_t oldValue, int16_t newValue) -> void {
+  if(_onChange) _onChange(device, group, input, oldValue, newValue);
+}
+
+//protected functions
+
+//static functions
+
+auto Input::create(string driver) -> Input* {
+  Input* input = nullptr;
+  if(!driver) driver = optimalDriver();
+
+  #if defined(INPUT_WINDOWS)
+  if(driver == "Windows") input = new InputWindows;
+  #endif
+
+  #if defined(INPUT_QUARTZ)
+  if(driver == "Quartz") input = new InputQuartz;
+  #endif
+
+  #if defined(INPUT_CARBON)
+  if(driver == "Carbon") input = new InputCarbon;
+  #endif
+
+  #if defined(INPUT_UDEV)
+  if(driver == "udev") input = new InputUdev;
+  #endif
+
+  #if defined(INPUT_SDL)
+  if(driver == "SDL") input = new InputSDL;
+  #endif
+
+  #if defined(INPUT_XLIB)
+  if(driver == "Xlib") input = new InputXlib;
+  #endif
+
+  if(!input) input = new Input;
+  return input;
+}
+
+auto Input::optimalDriver() -> string {
+  #if defined(INPUT_WINDOWS)
+  return "Windows";
+  #elif defined(INPUT_QUARTZ)
+  return "Quartz";
+  #elif defined(INPUT_CARBON)
+  return "Carbon";
+  #elif defined(INPUT_UDEV)
+  return "udev";
+  #elif defined(INPUT_SDL)
+  return "SDL";
+  #elif defined(INPUT_XLIB)
+  return "Xlib";
+  #else
+  return "None";
+  #endif
+}
+
+auto Input::safestDriver() -> string {
+  #if defined(INPUT_WINDOWS)
+  return "Windows";
+  #elif defined(INPUT_QUARTZ)
+  return "Quartz";
+  #elif defined(INPUT_CARBON)
+  return "Carbon";
+  #elif defined(INPUT_UDEV)
+  return "udev";
+  #elif defined(INPUT_SDL)
+  return "SDL";
+  #elif defined(INPUT_XLIB)
+  return "Xlib";
+  #else
+  return "none";
+  #endif
+}
+
+auto Input::availableDrivers() -> vector<string> {
+  return {
+
+  #if defined(INPUT_WINDOWS)
+  "Windows",
+  #endif
+
+  #if defined(INPUT_QUARTZ)
+  "Quartz",
+  #endif
+
+  #if defined(INPUT_CARBON)
+  "Carbon",
+  #endif
+
+  #if defined(INPUT_UDEV)
+  "udev",
+  #endif
+
+  #if defined(INPUT_SDL)
+  "SDL",
+  #endif
+
+  #if defined(INPUT_XLIB)
+  "Xlib",
+  #endif
+
+  "None"};
+}
+
+}

ruby/input.hpp

@@ -0,0 +1,31 @@
+struct Input {
+  static auto create(string driver = "") -> Input*;
+  static auto optimalDriver() -> string;
+  static auto safestDriver() -> string;
+  static auto availableDrivers() -> vector<string>;
+
+  virtual ~Input() = default;
+
+  virtual auto driver() -> string { return "None"; }
+  virtual auto ready() -> bool { return true; }
+
+  virtual auto hasContext() -> bool { return false; }
+
+  virtual auto context() -> uintptr { return _context; }
+
+  virtual auto setContext(uintptr context) -> bool;
+
+  virtual auto acquired() -> bool { return false; }
+  virtual auto acquire() -> bool { return false; }
+  virtual auto release() -> bool { return false; }
+  virtual auto poll() -> vector<shared_pointer<nall::HID::Device>> { return {}; }
+  virtual auto rumble(uint64_t id, bool enable) -> bool { return false; }
+
+  auto onChange(const function<void (shared_pointer<nall::HID::Device>, uint, uint, int16_t, int16_t)>&) -> void;
+  auto doChange(shared_pointer<nall::HID::Device> device, uint group, uint input, int16_t oldValue, int16_t newValue) -> void;
+
+protected:
+  uintptr _context = 0;
+
+  function<void (shared_pointer<nall::HID::Device> device, uint group, uint input, int16_t oldValue, int16_t newValue)> _onChange;
+};

ruby/input/sdl.cpp

@@ -10,29 +10,30 @@ struct InputSDL : Input {
   InputSDL() : _keyboard(*this), _mouse(*this), _joypad(*this) { initialize(); }
   ~InputSDL() { terminate(); }
 
-  auto ready() -> bool { return _ready; }
+  auto driver() -> string override { return "SDL"; }
+  auto ready() -> bool override { return _ready; }
 
-  auto context() -> uintptr { return _context; }
+  auto hasContext() -> bool override { return true; }
 
-  auto setContext(uintptr context) -> bool {
+  auto setContext(uintptr context) -> bool override {
-    if(_context == context) return true;
+    if(context == this->context()) return true;
-    _context = context;
+    if(!Input::setContext(context)) return false;
     return initialize();
   }
 
-  auto acquired() -> bool {
+  auto acquired() -> bool override {
     return _mouse.acquired();
   }
 
-  auto acquire() -> bool {
+  auto acquire() -> bool override {
     return _mouse.acquire();
   }
 
-  auto release() -> bool {
+  auto release() -> bool override {
     return _mouse.release();
   }
 
-  auto poll() -> vector<shared_pointer<HID::Device>> {
+  auto poll() -> vector<shared_pointer<HID::Device>> override {
     vector<shared_pointer<HID::Device>> devices;
     _keyboard.poll(devices);
     _mouse.poll(devices);
@@ -40,7 +41,7 @@ struct InputSDL : Input {
     return devices;
   }
 
-  auto rumble(uint64_t id, bool enable) -> bool {
+  auto rumble(uint64_t id, bool enable) -> bool override {
     return false;
   }
 
@@ -62,7 +63,6 @@ private:
   }
 
   bool _ready = false;
-  uintptr _context = 0;
 
   InputKeyboardXlib _keyboard;
   InputMouseXlib _mouse;

ruby/input/xlib.cpp

@@ -11,36 +11,37 @@ struct InputXlib : Input {
   InputXlib() : _keyboard(*this), _mouse(*this) { initialize(); }
   ~InputXlib() { terminate(); }
 
-  auto ready() -> bool { return _ready; }
+  auto driver() -> string override { return "Xlib"; }
+  auto ready() -> bool override { return _ready; }
 
-  auto context() -> uintptr { return _context; }
+  auto hasContext() -> bool override { return true; }
 
-  auto setContext(uintptr context) -> bool {
+  auto setContext(uintptr context) -> bool override {
-    if(_context == context) return true;
+    if(context == this->context()) return true;
-    _context = context;
+    if(!Input::setContext(context)) return false;
     return initialize();
   }
 
-  auto acquired() -> bool {
+  auto acquired() -> bool override {
     return _mouse.acquired();
   }
 
-  auto acquire() -> bool {
+  auto acquire() -> bool override {
     return _mouse.acquire();
   }
 
-  auto release() -> bool {
+  auto release() -> bool override {
     return _mouse.release();
   }
 
-  auto poll() -> vector<shared_pointer<HID::Device>> {
+  auto poll() -> vector<shared_pointer<HID::Device>> override {
     vector<shared_pointer<HID::Device>> devices;
     _keyboard.poll(devices);
     _mouse.poll(devices);
     return devices;
   }
 
-  auto rumble(uint64_t id, bool enable) -> bool {
+  auto rumble(uint64_t id, bool enable) -> bool override {
     return false;
   }
 
@@ -60,7 +61,6 @@ private:
   }
 
   bool _ready = false;
-  uintptr _context = 0;
 
   InputKeyboardXlib _keyboard;
   InputMouseXlib _mouse;

ruby/ruby.cpp

@@ -7,8 +7,6 @@
 using namespace nall;
 using namespace ruby;
 
-/* Shared */
-
 #undef deprecated
 #undef mkdir
 #undef usleep
@@ -26,501 +24,6 @@ using namespace ruby;
   #include <windows.h>
 #endif
 
-/* Video */
+#include "video.cpp"
-
+#include "audio.cpp"
-#if defined(VIDEO_CGL)
+#include "input.cpp"
-  #include <ruby/video/cgl.cpp>
-#endif
-
-#if defined(VIDEO_DIRECT3D)
-  #include <ruby/video/direct3d.cpp>
-#endif
-
-#if defined(VIDEO_DIRECTDRAW)
-  #include <ruby/video/directdraw.cpp>
-#endif
-
-#if defined(VIDEO_GDI)
-  #include <ruby/video/gdi.cpp>
-#endif
-
-#if defined(VIDEO_GLX)
-  #include <ruby/video/glx.cpp>
-#endif
-
-#if defined(VIDEO_GLX2)
-  #include <ruby/video/glx2.cpp>
-#endif
-
-#if defined(VIDEO_WGL)
-  #include <ruby/video/wgl.cpp>
-#endif
-
-#if defined(VIDEO_XSHM)
-  #include <ruby/video/xshm.cpp>
-#endif
-
-#if defined(VIDEO_XVIDEO)
-  #include <ruby/video/xvideo.cpp>
-#endif
-
-namespace ruby {
-
-auto Video::create(string driver) -> Video* {
-  Video* video = nullptr;
-  if(!driver) driver = optimalDriver();
-
-  #if defined(VIDEO_CGL)
-  if(driver == "OpenGL") video = new VideoCGL;
-  #endif
-
-  #if defined(VIDEO_DIRECT3D)
-  if(driver == "Direct3D") video = new VideoDirect3D;
-  #endif
-
-  #if defined(VIDEO_DIRECTDRAW)
-  if(driver == "DirectDraw") video = new VideoDirectDraw;
-  #endif
-
-  #if defined(VIDEO_GDI)
-  if(driver == "GDI") video = new VideoGDI;
-  #endif
-
-  #if defined(VIDEO_GLX)
-  if(driver == "OpenGL") video = new VideoGLX;
-  #endif
-
-  #if defined(VIDEO_GLX2)
-  if(driver == "OpenGL2") video = new VideoGLX2;
-  #endif
-
-  #if defined(VIDEO_WGL)
-  if(driver == "OpenGL") video = new VideoWGL;
-  #endif
-
-  #if defined(VIDEO_XSHM)
-  if(driver == "XShm") video = new VideoXShm;
-  #endif
-
-  #if defined(VIDEO_XVIDEO)
-  if(driver == "XVideo") video = new VideoXVideo;
-  #endif
-
-  if(!video) driver = "None", video = new Video;
-  video->_driver = driver;
-  return video;
-}
-
-auto Video::optimalDriver() -> string {
-  #if defined(VIDEO_WGL)
-  return "OpenGL";
-  #elif defined(VIDEO_DIRECT3D)
-  return "Direct3D";
-  #elif defined(VIDEO_DIRECTDRAW)
-  return "DirectDraw";
-  #elif defined(VIDEO_GDI)
-  return "GDI";
-  #elif defined(VIDEO_CGL)
-  return "OpenGL";
-  #elif defined(VIDEO_GLX)
-  return "OpenGL";
-  #elif defined(VIDEO_GLX2)
-  return "OpenGL2";
-  #elif defined(VIDEO_XVIDEO)
-  return "XVideo";
-  #elif defined(VIDEO_XSHM)
-  return "XShm";
-  #else
-  return "None";
-  #endif
-}
-
-auto Video::safestDriver() -> string {
-  #if defined(VIDEO_DIRECT3D)
-  return "Direct3D";
-  #elif defined(VIDEO_WGL)
-  return "OpenGL";
-  #elif defined(VIDEO_DIRECTDRAW)
-  return "DirectDraw";
-  #elif defined(VIDEO_GDI)
-  return "GDI";
-  #elif defined(VIDEO_CGL)
-  return "OpenGL";
-  #elif defined(VIDEO_XSHM)
-  return "XShm";
-  #elif defined(VIDEO_XVIDEO)
-  return "XVideo";
-  #elif defined(VIDEO_GLX2)
-  return "OpenGL2";
-  #elif defined(VIDEO_GLX)
-  return "OpenGL";
-  #else
-  return "None";
-  #endif
-}
-
-auto Video::availableDrivers() -> vector<string> {
-  return {
-
-  #if defined(VIDEO_WGL)
-  "OpenGL",
-  #endif
-
-  #if defined(VIDEO_DIRECT3D)
-  "Direct3D",
-  #endif
-
-  #if defined(VIDEO_DIRECTDRAW)
-  "DirectDraw",
-  #endif
-
-  #if defined(VIDEO_GDI)
-  "GDI",
-  #endif
-
-  #if defined(VIDEO_CGL)
-  "OpenGL",
-  #endif
-
-  #if defined(VIDEO_GLX)
-  "OpenGL",
-  #endif
-
-  #if defined(VIDEO_GLX2)
-  "OpenGL2",
-  #endif
-
-  #if defined(VIDEO_XVIDEO)
-  "XVideo",
-  #endif
-
-  #if defined(VIDEO_XSHM)
-  "XShm",
-  #endif
-
-  "None"};
-}
-
-}
-
-/* Audio */
-
-#if defined(AUDIO_ALSA)
-  #include <ruby/audio/alsa.cpp>
-#endif
-
-#if defined(AUDIO_AO)
-  #include <ruby/audio/ao.cpp>
-#endif
-
-#if defined(AUDIO_ASIO)
-  #include <ruby/audio/asio.cpp>
-#endif
-
-#if defined(AUDIO_DIRECTSOUND)
-  #include <ruby/audio/directsound.cpp>
-#endif
-
-#if defined(AUDIO_OPENAL)
-  #include <ruby/audio/openal.cpp>
-#endif
-
-#if defined(AUDIO_OSS)
-  #include <ruby/audio/oss.cpp>
-#endif
-
-#if defined(AUDIO_PULSEAUDIO)
-  #include <ruby/audio/pulseaudio.cpp>
-#endif
-
-#if defined(AUDIO_PULSEAUDIOSIMPLE)
-  #include <ruby/audio/pulseaudiosimple.cpp>
-#endif
-
-#if defined(AUDIO_WASAPI)
-  #include <ruby/audio/wasapi.cpp>
-#endif
-
-#if defined(AUDIO_XAUDIO2)
-  #include <ruby/audio/xaudio2.cpp>
-#endif
-
-namespace ruby {
-
-auto Audio::create(string driver) -> Audio* {
-  Audio* audio = nullptr;
-  if(!driver) driver = optimalDriver();
-
-  #if defined(AUDIO_ALSA)
-  if(driver == "ALSA") audio = new AudioALSA;
-  #endif
-
-  #if defined(AUDIO_AO)
-  if(driver == "libao") audio = new AudioAO;
-  #endif
-
-  #if defined(AUDIO_ASIO)
-  if(driver == "ASIO") audio = new AudioASIO;
-  #endif
-
-  #if defined(AUDIO_DIRECTSOUND)
-  if(driver == "DirectSound") audio = new AudioDirectSound;
-  #endif
-
-  #if defined(AUDIO_OPENAL)
-  if(driver == "OpenAL") audio = new AudioOpenAL;
-  #endif
-
-  #if defined(AUDIO_OSS)
-  if(driver == "OSS") audio = new AudioOSS;
-  #endif
-
-  #if defined(AUDIO_PULSEAUDIO)
-  if(driver == "PulseAudio") audio = new AudioPulseAudio;
-  #endif
-
-  #if defined(AUDIO_PULSEAUDIOSIMPLE)
-  if(driver == "PulseAudioSimple") audio = new AudioPulseAudioSimple;
-  #endif
-
-  #if defined(AUDIO_WASAPI)
-  if(driver == "WASAPI") audio = new AudioWASAPI;
-  #endif
-
-  #if defined(AUDIO_XAUDIO2)
-  if(driver == "XAudio2") audio = new AudioXAudio2;
-  #endif
-
-  if(!audio) driver = "None", audio = new Audio;
-  audio->_driver = driver;
-  return audio;
-}
-
-auto Audio::optimalDriver() -> string {
-  #if defined(AUDIO_ASIO)
-  return "ASIO";
-  #elif defined(AUDIO_WASAPI)
-  return "WASAPI";
-  #elif defined(AUDIO_XAUDIO2)
-  return "XAudio2";
-  #elif defined(AUDIO_DIRECTSOUND)
-  return "DirectSound";
-  #elif defined(AUDIO_ALSA)
-  return "ALSA";
-  #elif defined(AUDIO_OSS)
-  return "OSS";
-  #elif defined(AUDIO_OPENAL)
-  return "OpenAL";
-  #elif defined(AUDIO_PULSEAUDIO)
-  return "PulseAudio";
-  #elif defined(AUDIO_PULSEAUDIOSIMPLE)
-  return "PulseAudioSimple";
-  #elif defined(AUDIO_AO)
-  return "libao";
-  #else
-  return "None";
-  #endif
-}
-
-auto Audio::safestDriver() -> string {
-  #if defined(AUDIO_DIRECTSOUND)
-  return "DirectSound";
-  #elif defined(AUDIO_WASAPI)
-  return "WASAPI";
-  #elif defined(AUDIO_XAUDIO2)
-  return "XAudio2";
-  #elif defined(AUDIO_ALSA)
-  return "ALSA";
-  #elif defined(AUDIO_OSS)
-  return "OSS";
-  #elif defined(AUDIO_OPENAL)
-  return "OpenAL";
-  #elif defined(AUDIO_PULSEAUDIO)
-  return "PulseAudio";
-  #elif defined(AUDIO_PULSEAUDIOSIMPLE)
-  return "PulseAudioSimple";
-  #elif defined(AUDIO_AO)
-  return "libao";
-  #elif defined(AUDIO_ASIO)
-  return "ASIO";
-  #else
-  return "None";
-  #endif
-}
-
-auto Audio::availableDrivers() -> vector<string> {
-  return {
-
-  #if defined(AUDIO_ASIO)
-  "ASIO",
-  #endif
-
-  #if defined(AUDIO_WASAPI)
-  "WASAPI",
-  #endif
-
-  #if defined(AUDIO_XAUDIO2)
-  "XAudio2",
-  #endif
-
-  #if defined(AUDIO_DIRECTSOUND)
-  "DirectSound",
-  #endif
-
-  #if defined(AUDIO_ALSA)
-  "ALSA",
-  #endif
-
-  #if defined(AUDIO_OSS)
-  "OSS",
-  #endif
-
-  #if defined(AUDIO_OPENAL)
-  "OpenAL",
-  #endif
-
-  #if defined(AUDIO_PULSEAUDIO)
-  "PulseAudio",
-  #endif
-
-  #if defined(AUDIO_PULSEAUDIOSIMPLE)
-  "PulseAudioSimple",
-  #endif
-
-  #if defined(AUDIO_AO)
-  "libao",
-  #endif
-
-  "None"};
-}
-
-}
-
-/* Input */
-
-#if defined(INPUT_CARBON)
-  #include <ruby/input/carbon.cpp>
-#endif
-
-#if defined(INPUT_QUARTZ)
-  #include <ruby/input/quartz.cpp>
-#endif
-
-#if defined(INPUT_SDL)
-  #include <ruby/input/sdl.cpp>
-#endif
-
-#if defined(INPUT_UDEV)
-  #include <ruby/input/udev.cpp>
-#endif
-
-#if defined(INPUT_WINDOWS)
-  #include <ruby/input/windows.cpp>
-#endif
-
-#if defined(INPUT_XLIB)
-  #include <ruby/input/xlib.cpp>
-#endif
-
-namespace ruby {
-
-auto Input::create(string driver) -> Input* {
-  Input* input = nullptr;
-  if(!driver) driver = optimalDriver();
-
-  #if defined(INPUT_WINDOWS)
-  if(driver == "Windows") input = new InputWindows;
-  #endif
-
-  #if defined(INPUT_QUARTZ)
-  if(driver == "Quartz") input = new InputQuartz;
-  #endif
-
-  #if defined(INPUT_CARBON)
-  if(driver == "Carbon") input = new InputCarbon;
-  #endif
-
-  #if defined(INPUT_UDEV)
-  if(driver == "udev") input = new InputUdev;
-  #endif
-
-  #if defined(INPUT_SDL)
-  if(driver == "SDL") input = new InputSDL;
-  #endif
-
-  #if defined(INPUT_XLIB)
-  if(driver == "Xlib") input = new InputXlib;
-  #endif
-
-  if(!input) driver = "None", input = new Input;
-  input->_driver = driver;
-  return input;
-}
-
-auto Input::optimalDriver() -> string {
-  #if defined(INPUT_WINDOWS)
-  return "Windows";
-  #elif defined(INPUT_QUARTZ)
-  return "Quartz";
-  #elif defined(INPUT_CARBON)
-  return "Carbon";
-  #elif defined(INPUT_UDEV)
-  return "udev";
-  #elif defined(INPUT_SDL)
-  return "SDL";
-  #elif defined(INPUT_XLIB)
-  return "Xlib";
-  #else
-  return "None";
-  #endif
-}
-
-auto Input::safestDriver() -> string {
-  #if defined(INPUT_WINDOWS)
-  return "Windows";
-  #elif defined(INPUT_QUARTZ)
-  return "Quartz";
-  #elif defined(INPUT_CARBON)
-  return "Carbon";
-  #elif defined(INPUT_UDEV)
-  return "udev";
-  #elif defined(INPUT_SDL)
-  return "SDL";
-  #elif defined(INPUT_XLIB)
-  return "Xlib";
-  #else
-  return "none";
-  #endif
-}
-
-auto Input::availableDrivers() -> vector<string> {
-  return {
-
-  #if defined(INPUT_WINDOWS)
-  "Windows",
-  #endif
-
-  #if defined(INPUT_QUARTZ)
-  "Quartz",
-  #endif
-
-  #if defined(INPUT_CARBON)
-  "Carbon",
-  #endif
-
-  #if defined(INPUT_UDEV)
-  "udev",
-  #endif
-
-  #if defined(INPUT_SDL)
-  "SDL",
-  #endif
-
-  #if defined(INPUT_XLIB)
-  "Xlib",
-  #endif
-
-  "None"};
-}
-
-}

ruby/ruby.hpp

@@ -1,118 +1,28 @@
 #pragma once
 
-#include <nall/nall.hpp>
+#include <nall/platform.hpp>
+#include <nall/directory.hpp>
+#include <nall/file.hpp>
+#include <nall/function.hpp>
+#include <nall/hid.hpp>
+#include <nall/image.hpp>
+#include <nall/matrix.hpp>
+#include <nall/range.hpp>
+#include <nall/set.hpp>
+#include <nall/shared-pointer.hpp>
+#include <nall/string.hpp>
+#include <nall/vector.hpp>
+#include <nall/dsp/resampler/cubic.hpp>
+
+using nall::function;
+using nall::shared_pointer;
+using nall::string;
+using nall::vector;
 
 namespace ruby {
 
-struct Video {
+#include "video.hpp"
-  static auto create(nall::string driver = "") -> Video*;
+#include "audio.hpp"
-  static auto optimalDriver() -> nall::string;
+#include "input.hpp"
-  static auto safestDriver() -> nall::string;
-  static auto availableDrivers() -> nall::vector<nall::string>;
-
-  virtual ~Video() = default;
-
-  virtual auto ready() -> bool { return true; }
-  virtual auto driver() -> nall::string { return _driver; }
-
-  virtual auto exclusive() -> bool { return false; }
-  virtual auto context() -> uintptr { return 0; }
-  virtual auto blocking() -> bool { return false; }
-  virtual auto depth() -> uint { return 24; }
-  virtual auto smooth() -> bool { return false; }
-  virtual auto shader() -> nall::string { return ""; }
-
-  virtual auto setExclusive(bool exclusive) -> bool { return false; }
-  virtual auto setContext(uintptr context) -> bool { return false; }
-  virtual auto setBlocking(bool blocking) -> bool { return false; }
-  virtual auto setDepth(uint depth) -> bool { return false; }
-  virtual auto setSmooth(bool smooth) -> bool { return false; }
-  virtual auto setShader(nall::string shader) -> bool { return false; }
-
-  virtual auto clear() -> void {}
-  virtual auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool { return false; }
-  virtual auto unlock() -> void {}
-  virtual auto output() -> void {}
-  virtual auto poll() -> void {}
-
-  auto onUpdate(const nall::function<void (uint, uint)>& callback) { _onUpdate = callback; }
-  auto doUpdate(uint width, uint height) -> void {
-    if(_onUpdate) return _onUpdate(width, height);
-  }
-
-private:
-  nall::string _driver;
-  nall::function<void (uint, uint)> _onUpdate;
-};
-
-struct Audio {
-  static auto create(nall::string driver = "") -> Audio*;
-  static auto optimalDriver() -> nall::string;
-  static auto safestDriver() -> nall::string;
-  static auto availableDrivers() -> nall::vector<nall::string>;
-
-  virtual ~Audio() = default;
-
-  virtual auto availableDevices() -> nall::vector<nall::string> { return {"Default"}; }
-  virtual auto availableFrequencies() -> nall::vector<double> { return {44100.0}; }
-  virtual auto availableLatencies() -> nall::vector<uint> { return {0}; }
-  virtual auto availableChannels() -> nall::vector<uint> { return {2}; }
-
-  virtual auto ready() -> bool { return true; }
-  virtual auto driver() -> nall::string { return _driver; }
-
-  virtual auto exclusive() -> bool { return false; }
-  virtual auto context() -> uintptr { return 0; }
-  virtual auto device() -> nall::string { return "None"; }
-  virtual auto blocking() -> bool { return false; }
-  virtual auto channels() -> uint { return 2; }
-  virtual auto frequency() -> double { return 48000.0; }
-  virtual auto latency() -> uint { return 0; }
-
-  virtual auto setExclusive(bool exclusive) -> bool { return false; }
-  virtual auto setContext(uintptr context) -> bool { return false; }
-  virtual auto setDevice(nall::string device) -> bool { return false; }
-  virtual auto setBlocking(bool blocking) -> bool { return false; }
-  virtual auto setChannels(uint channels) -> bool { return false; }
-  virtual auto setFrequency(double frequency) -> bool { return false; }
-  virtual auto setLatency(uint latency) -> bool { return false; }
-
-  virtual auto clear() -> void {}
-  virtual auto output(const double samples[]) -> void {}
-
-private:
-  nall::string _driver;
-};
-
-struct Input {
-  static auto create(nall::string driver = "") -> Input*;
-  static auto optimalDriver() -> nall::string;
-  static auto safestDriver() -> nall::string;
-  static auto availableDrivers() -> nall::vector<nall::string>;
-
-  virtual ~Input() = default;
-
-  virtual auto ready() -> bool { return true; }
-  virtual auto driver() -> nall::string { return _driver; }
-
-  virtual auto context() -> uintptr { return 0; }
-
-  virtual auto setContext(uintptr context) -> bool { return false; }
-
-  virtual auto acquired() -> bool { return false; }
-  virtual auto acquire() -> bool { return false; }
-  virtual auto release() -> bool { return false; }
-  virtual auto poll() -> nall::vector<nall::shared_pointer<nall::HID::Device>> { return {}; }
-  virtual auto rumble(uint64_t id, bool enable) -> bool { return false; }
-
-  auto onChange(const nall::function<void (nall::shared_pointer<nall::HID::Device>, uint, uint, int16_t, int16_t)>& callback) { _onChange = callback; }
-  auto doChange(nall::shared_pointer<nall::HID::Device> device, uint group, uint input, int16_t oldValue, int16_t newValue) -> void {
-    if(_onChange) return _onChange(device, group, input, oldValue, newValue);
-  }
-
-private:
-  nall::string _driver;
-  nall::function<void (nall::shared_pointer<nall::HID::Device> device, uint group, uint input, int16_t oldValue, int16_t newValue)> _onChange;
-};
 
 }

ruby/video.cpp

@@ -0,0 +1,220 @@
+#if defined(VIDEO_CGL)
+  #include <ruby/video/cgl.cpp>
+#endif
+
+#if defined(VIDEO_DIRECT3D)
+  #include <ruby/video/direct3d.cpp>
+#endif
+
+#if defined(VIDEO_DIRECTDRAW)
+  #include <ruby/video/directdraw.cpp>
+#endif
+
+#if defined(VIDEO_GDI)
+  #include <ruby/video/gdi.cpp>
+#endif
+
+#if defined(VIDEO_GLX)
+  #include <ruby/video/glx.cpp>
+#endif
+
+#if defined(VIDEO_GLX2)
+  #include <ruby/video/glx2.cpp>
+#endif
+
+#if defined(VIDEO_WGL)
+  #include <ruby/video/wgl.cpp>
+#endif
+
+#if defined(VIDEO_XSHM)
+  #include <ruby/video/xshm.cpp>
+#endif
+
+#if defined(VIDEO_XVIDEO)
+  #include <ruby/video/xvideo.cpp>
+#endif
+
+namespace ruby {
+
+auto Video::setExclusive(bool exclusive) -> bool {
+  _exclusive = exclusive;
+  return true;
+}
+
+auto Video::setContext(uintptr context) -> bool {
+  _context = context;
+  return true;
+}
+
+auto Video::setBlocking(bool blocking) -> bool {
+  _blocking = blocking;
+  return true;
+}
+
+auto Video::setFlush(bool flush) -> bool {
+  _flush = flush;
+  return true;
+}
+
+auto Video::setFormat(string format) -> bool {
+  _format = format;
+  return true;
+}
+
+auto Video::setSmooth(bool smooth) -> bool {
+  _smooth = smooth;
+  return true;
+}
+
+auto Video::setShader(string shader) -> bool {
+  _shader = shader;
+  return true;
+}
+
+auto Video::onUpdate(const function<void (uint, uint)>& onUpdate) -> void {
+  _onUpdate = onUpdate;
+}
+
+auto Video::doUpdate(uint width, uint height) -> void {
+  if(_onUpdate) return _onUpdate(width, height);
+}
+
+//protected functions
+
+//static functions
+
+auto Video::create(string driver) -> Video* {
+  Video* video = nullptr;
+  if(!driver) driver = optimalDriver();
+
+  #if defined(VIDEO_CGL)
+  if(driver == "OpenGL") video = new VideoCGL;
+  #endif
+
+  #if defined(VIDEO_DIRECT3D)
+  if(driver == "Direct3D") video = new VideoDirect3D;
+  #endif
+
+  #if defined(VIDEO_DIRECTDRAW)
+  if(driver == "DirectDraw") video = new VideoDirectDraw;
+  #endif
+
+  #if defined(VIDEO_GDI)
+  if(driver == "GDI") video = new VideoGDI;
+  #endif
+
+  #if defined(VIDEO_GLX)
+  if(driver == "OpenGL") video = new VideoGLX;
+  #endif
+
+  #if defined(VIDEO_GLX2)
+  if(driver == "OpenGL2") video = new VideoGLX2;
+  #endif
+
+  #if defined(VIDEO_WGL)
+  if(driver == "OpenGL") video = new VideoWGL;
+  #endif
+
+  #if defined(VIDEO_XSHM)
+  if(driver == "XShm") video = new VideoXShm;
+  #endif
+
+  #if defined(VIDEO_XVIDEO)
+  if(driver == "XVideo") video = new VideoXVideo;
+  #endif
+
+  if(!video) video = new Video;
+  return video;
+}
+
+auto Video::optimalDriver() -> string {
+  #if defined(VIDEO_WGL)
+  return "OpenGL";
+  #elif defined(VIDEO_DIRECT3D)
+  return "Direct3D";
+  #elif defined(VIDEO_DIRECTDRAW)
+  return "DirectDraw";
+  #elif defined(VIDEO_GDI)
+  return "GDI";
+  #elif defined(VIDEO_CGL)
+  return "OpenGL";
+  #elif defined(VIDEO_GLX)
+  return "OpenGL";
+  #elif defined(VIDEO_GLX2)
+  return "OpenGL2";
+  #elif defined(VIDEO_XVIDEO)
+  return "XVideo";
+  #elif defined(VIDEO_XSHM)
+  return "XShm";
+  #else
+  return "None";
+  #endif
+}
+
+auto Video::safestDriver() -> string {
+  #if defined(VIDEO_DIRECT3D)
+  return "Direct3D";
+  #elif defined(VIDEO_WGL)
+  return "OpenGL";
+  #elif defined(VIDEO_DIRECTDRAW)
+  return "DirectDraw";
+  #elif defined(VIDEO_GDI)
+  return "GDI";
+  #elif defined(VIDEO_CGL)
+  return "OpenGL";
+  #elif defined(VIDEO_XSHM)
+  return "XShm";
+  #elif defined(VIDEO_XVIDEO)
+  return "XVideo";
+  #elif defined(VIDEO_GLX2)
+  return "OpenGL2";
+  #elif defined(VIDEO_GLX)
+  return "OpenGL";
+  #else
+  return "None";
+  #endif
+}
+
+auto Video::availableDrivers() -> vector<string> {
+  return {
+
+  #if defined(VIDEO_WGL)
+  "OpenGL",
+  #endif
+
+  #if defined(VIDEO_DIRECT3D)
+  "Direct3D",
+  #endif
+
+  #if defined(VIDEO_DIRECTDRAW)
+  "DirectDraw",
+  #endif
+
+  #if defined(VIDEO_GDI)
+  "GDI",
+  #endif
+
+  #if defined(VIDEO_CGL)
+  "OpenGL",
+  #endif
+
+  #if defined(VIDEO_GLX)
+  "OpenGL",
+  #endif
+
+  #if defined(VIDEO_GLX2)
+  "OpenGL2",
+  #endif
+
+  #if defined(VIDEO_XVIDEO)
+  "XVideo",
+  #endif
+
+  #if defined(VIDEO_XSHM)
+  "XShm",
+  #endif
+
+  "None"};
+}
+
+}

ruby/video.hpp

@@ -0,0 +1,57 @@
+struct Video {
+  static auto create(string driver = "") -> Video*;
+  static auto optimalDriver() -> string;
+  static auto safestDriver() -> string;
+  static auto availableDrivers() -> vector<string>;
+
+  virtual ~Video() = default;
+
+  virtual auto driver() -> string { return "None"; }
+  virtual auto ready() -> bool { return true; }
+
+  virtual auto availableFormats() -> vector<string> { return {"Default"}; }
+
+  virtual auto hasExclusive() -> bool { return false; }
+  virtual auto hasContext() -> bool { return false; }
+  virtual auto hasBlocking() -> bool { return false; }
+  virtual auto hasFlush() -> bool { return false; }
+  virtual auto hasFormat() -> bool { return false; }
+  virtual auto hasSmooth() -> bool { return false; }
+  virtual auto hasShader() -> bool { return false; }
+
+  virtual auto exclusive() -> bool { return _exclusive; }
+  virtual auto context() -> uintptr { return _context; }
+  virtual auto blocking() -> bool { return _blocking; }
+  virtual auto flush() -> bool { return _flush; }
+  virtual auto format() -> string { return _format; }
+  virtual auto smooth() -> bool { return _smooth; }
+  virtual auto shader() -> string { return _shader; }
+
+  virtual auto setExclusive(bool exclusive) -> bool;
+  virtual auto setContext(uintptr context) -> bool;
+  virtual auto setBlocking(bool blocking) -> bool;
+  virtual auto setFlush(bool flush) -> bool;
+  virtual auto setFormat(string format) -> bool;
+  virtual auto setSmooth(bool smooth) -> bool;
+  virtual auto setShader(string shader) -> bool;
+
+  virtual auto clear() -> void {}
+  virtual auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool { return false; }
+  virtual auto unlock() -> void {}
+  virtual auto output() -> void {}
+  virtual auto poll() -> void {}
+
+  auto onUpdate(const function<void (uint, uint)>&) -> void;
+  auto doUpdate(uint width, uint height) -> void;
+
+protected:
+  bool _exclusive = false;
+  uintptr _context = 0;
+  bool _blocking = false;
+  bool _flush = false;
+  string _format = "Default";
+  bool _smooth = false;
+  string _shader = "";
+
+  function<void (uint, uint)> _onUpdate;
+};

ruby/video/glx.cpp

@@ -11,67 +11,88 @@ struct VideoGLX : Video, OpenGL {
   VideoGLX() { initialize(); }
   ~VideoGLX() { terminate(); }
 
-  auto ready() -> bool { return _ready; }
+  auto driver() -> string override { return "OpenGL"; }
+  auto ready() -> bool override { return _ready; }
 
-  auto context() -> uintptr { return _context; }
+  auto availableFormats() -> vector<string> override {
-  auto blocking() -> bool { return _blocking; }
+    return {"R8G8B8", "R10G10B10"};
-  auto depth() -> uint { return _depth; }
+  }
-  auto smooth() -> bool { return _smooth; }
-  auto shader() -> string { return _shader; }
 
-  auto setContext(uintptr context) -> bool {
+  auto hasContext() -> bool override { return true; }
-    if(_context == context) return true;
+  auto hasBlocking() -> bool override { return true; }
-    _context = context;
+  auto hasFlush() -> bool override { return true; }
+  auto hasFormat() -> bool override { return true; }
+  auto hasSmooth() -> bool override { return true; }
+  auto hasShader() -> bool override { return true; }
+
+  auto setContext(uintptr context) -> bool override {
+    if(context == Video::context()) return true;
+    if(!Video::setContext(context)) return false;
     return initialize();
   }
 
-  auto setBlocking(bool blocking) -> bool {
+  auto setBlocking(bool blocking) -> bool override {
-    if(_blocking == blocking) return true;
+    if(blocking == Video::blocking()) return true;
-    _blocking = blocking;
+    if(!Video::setBlocking(blocking)) return false;
     if(glXSwapInterval) glXSwapInterval(_blocking);
     return true;
   }
 
-  auto setDepth(uint depth) -> bool {
+  auto setFlush(bool flush) -> bool override {
-    if(_depth == depth) return true;
+    if(flush == Video::flush()) return true;
-    switch(depth) {
+    if(!Video::setFlush(flush)) return false;
-    case 24: _depth = depth; OpenGL::inputFormat = GL_RGBA8; return true;
-    case 30: _depth = depth; OpenGL::inputFormat = GL_RGB10_A2; return true;
-    default: return false;
-    }
-  }
-
-  auto setSmooth(bool smooth) -> bool {
-    if(_smooth == smooth) return true;
-    _smooth = smooth;
-    if(!_shader) OpenGL::filter = _smooth ? GL_LINEAR : GL_NEAREST;
     return true;
   }
 
-  auto setShader(string shader) -> bool {
+  auto setFormat(string format) -> bool override {
-    if(_shader == shader) return true;
+    if(format == Video::format()) return true;
-    OpenGL::shader(_shader = shader);
+    if(!Video::setFormat(format)) return false;
-    if(!_shader) OpenGL::filter = _smooth ? GL_LINEAR : GL_NEAREST;
+
+    if(format == "R8G8B8") {
+      OpenGL::inputFormat = GL_RGBA8;
       return true;
     }
 
-  auto clear() -> void {
+    if(format == "R10G10B10") {
+      OpenGL::inputFormat = GL_RGB10_A2;
+      return true;
+    }
+
+    return false;
+  }
+
+  auto setSmooth(bool smooth) -> bool override {
+    if(smooth == Video::smooth()) return true;
+    if(!Video::setSmooth(smooth)) return false;
+    if(!shader()) OpenGL::filter = smooth ? GL_LINEAR : GL_NEAREST;
+    return true;
+  }
+
+  auto setShader(string shader) -> bool override {
+    if(shader == Video::shader()) return true;
+    if(!Video::setShader(shader)) return false;
+    OpenGL::setShader(shader);
+    if(!shader) OpenGL::filter = smooth() ? GL_LINEAR : GL_NEAREST;
+    return true;
+  }
+
+  auto clear() -> void override {
     if(!ready()) return;
     OpenGL::clear();
     if(_doubleBuffer) glXSwapBuffers(_display, _glXWindow);
   }
 
-  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool {
+  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool override {
     if(!ready()) return false;
     OpenGL::size(width, height);
     return OpenGL::lock(data, pitch);
   }
 
-  auto unlock() -> void {
+  auto unlock() -> void override {
     if(!ready()) return;
   }
 
-  auto output() -> void {
+  auto output() -> void override {
     if(!ready()) return;
 
     //we must ensure that the child window is the same size as the parent window.
@@ -89,9 +110,10 @@ struct VideoGLX : Video, OpenGL {
     OpenGL::outputHeight = parent.height;
     OpenGL::output();
     if(_doubleBuffer) glXSwapBuffers(_display, _glXWindow);
+    if(flush()) glFinish();
   }
 
-  auto poll() -> void {
+  auto poll() -> void override {
     while(XPending(_display)) {
       XEvent event;
       XNextEvent(_display, &event);
@@ -118,15 +140,19 @@ private:
     XWindowAttributes windowAttributes;
     XGetWindowAttributes(_display, (Window)_context, &windowAttributes);
 
+    int redDepth   = Video::format() == "R10G10B10" ? 10 : 8;
+    int greenDepth = Video::format() == "R10G10B10" ? 10 : 8;
+    int blueDepth  = Video::format() == "R10G10B10" ? 10 : 8;
+
     //let GLX determine the best Visual to use for GL output; provide a few hints
     //note: some video drivers will override double buffering attribute
     int attributeList[] = {
       GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
       GLX_RENDER_TYPE, GLX_RGBA_BIT,
       GLX_DOUBLEBUFFER, True,
-      GLX_RED_SIZE, (int)(_depth / 3),
+      GLX_RED_SIZE, redDepth,
-      GLX_GREEN_SIZE, (int)(_depth / 3) + (int)(_depth % 3),
+      GLX_GREEN_SIZE, greenDepth,
-      GLX_BLUE_SIZE, (int)(_depth / 3),
+      GLX_BLUE_SIZE, blueDepth,
       None
     };
 
@@ -141,7 +167,7 @@ private:
     //it is not possible to change the Visual of an already realized (created) window.
     //therefore a new child window, using the same GLX Visual, must be created and binded to it.
     _colormap = XCreateColormap(_display, RootWindow(_display, vi->screen), vi->visual, AllocNone);
-    XSetWindowAttributes attributes;
+    XSetWindowAttributes attributes = {};
     attributes.colormap = _colormap;
     attributes.border_pixel = 0;
     _window = XCreateWindow(_display, /* parent = */ (Window)_context,
@@ -230,11 +256,6 @@ private:
   }
 
   bool _ready = false;
-  uintptr _context = 0;
-  bool _blocking = false;
-  uint _depth = 24;
-  bool _smooth = true;
-  string _shader;
 
   auto (*glXSwapInterval)(int) -> int = nullptr;
 

ruby/video/glx2.cpp

@@ -25,32 +25,40 @@ struct VideoGLX2 : Video {
   VideoGLX2() { initialize(); }
   ~VideoGLX2() { terminate(); }
 
-  auto ready() -> bool { return _ready; }
+  auto driver() -> string override { return "OpenGL2"; }
+  auto ready() -> bool override { return _ready; }
 
-  auto context() -> uintptr { return _context; }
+  auto hasContext() -> bool override { return true; }
-  auto blocking() -> bool { return _blocking; }
+  auto hasBlocking() -> bool override { return true; }
-  auto smooth() -> bool { return _smooth; }
+  auto hasFlush() -> bool override { return true; }
+  auto hasSmooth() -> bool override { return true; }
 
-  auto setContext(uintptr context) -> bool {
+  auto setContext(uintptr context) -> bool override {
-    if(_context == context) return true;
+    if(context == this->context()) return true;
-    _context = context;
+    if(!Video::setContext(context)) return false;
     return initialize();
   }
 
-  auto setBlocking(bool blocking) -> bool {
+  auto setBlocking(bool blocking) -> bool override {
-    if(_blocking == blocking) return true;
+    if(blocking == this->blocking()) return true;
-    _blocking = blocking;
+    if(!Video::setBlocking(blocking)) return false;
-    if(_ready && glXSwapInterval) glXSwapInterval(_blocking);
+    if(ready() && glXSwapInterval) glXSwapInterval(_blocking);
     return true;
   }
 
-  auto setSmooth(bool smooth) -> bool {
+  auto setFlush(bool flush) -> bool override {
-    if(_smooth == smooth) return true;
+    if(flush == this->flush()) return true;
-    _smooth = smooth;
+    if(!Video::setFlush(flush)) return false;
     return true;
   }
 
-  auto clear() -> void {
+  auto setSmooth(bool smooth) -> bool override {
+    if(smooth == this->smooth()) return true;
+    if(!Video::setSmooth(smooth)) return false;
+    return true;
+  }
+
+  auto clear() -> void override {
     if(!ready()) return;
     memory::fill<uint32_t>(_glBuffer, _glWidth * _glHeight);
     glClearColor(0.0, 0.0, 0.0, 1.0);
@@ -59,18 +67,18 @@ struct VideoGLX2 : Video {
     if(_isDoubleBuffered) glXSwapBuffers(_display, _glXWindow);
   }
 
-  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool {
+  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool override {
     if(!ready()) return false;
     if(width != _width || height != _height) resize(width, height);
     pitch = _glWidth * sizeof(uint32_t);
     return data = _glBuffer;
   }
 
-  auto unlock() -> void {
+  auto unlock() -> void override {
     if(!ready()) return;
   }
 
-  auto output() -> void {
+  auto output() -> void override {
     if(!ready()) return;
 
     XWindowAttributes parent, child;
@@ -109,9 +117,10 @@ struct VideoGLX2 : Video {
     glFlush();
 
     if(_isDoubleBuffered) glXSwapBuffers(_display, _glXWindow);
+    if(flush()) glFinish();
   }
 
-  auto poll() -> void {
+  auto poll() -> void override {
     while(XPending(_display)) {
       XEvent event;
       XNextEvent(_display, &event);
@@ -154,7 +163,7 @@ private:
 
     auto vi = glXGetVisualFromFBConfig(_display, fbConfig[0]);
     _colormap = XCreateColormap(_display, RootWindow(_display, vi->screen), vi->visual, AllocNone);
-    XSetWindowAttributes attributes;
+    XSetWindowAttributes attributes = {};
     attributes.colormap = _colormap;
     attributes.border_pixel = 0;
     _window = XCreateWindow(_display, (Window)_context, 0, 0, windowAttributes.width, windowAttributes.height,
@@ -250,9 +259,6 @@ private:
   auto (*glXSwapInterval)(int) -> int = nullptr;
 
   bool _ready = false;
-  uintptr _context = 0;
-  bool _blocking = false;
-  bool _smooth = true;
 
   Display* _display = nullptr;
   int _screen = 0;

ruby/video/opengl/main.hpp

@@ -1,4 +1,4 @@
-auto OpenGL::shader(const string& pathname) -> void {
+auto OpenGL::setShader(const string& pathname) -> void {
   for(auto& program : programs) program.release();
   programs.reset();
 
@@ -196,13 +196,13 @@ auto OpenGL::initialize() -> bool {
   OpenGLSurface::allocate();
   glrLinkProgram(program);
 
-  shader("");
+  setShader("");
   return initialized = true;
 }
 
 auto OpenGL::terminate() -> void {
   if(!initialized) return;
-  shader("");  //release shader resources (eg frame[] history)
+  setShader("");  //release shader resources (eg frame[] history)
   OpenGLSurface::release();
   if(buffer) { delete[] buffer; buffer = nullptr; }
   initialized = false;

ruby/video/opengl/opengl.hpp

@@ -65,7 +65,7 @@ struct OpenGLProgram : OpenGLSurface {
 };
 
 struct OpenGL : OpenGLProgram {
-  auto shader(const string& pathname) -> void;
+  auto setShader(const string& pathname) -> void;
   auto allocateHistory(uint size) -> void;
   auto clear() -> void;
   auto lock(uint32_t*& data, uint& pitch) -> bool;

ruby/video/xshm.cpp

@@ -12,23 +12,25 @@ struct VideoXShm : Video {
   VideoXShm() { initialize(); }
   ~VideoXShm() { terminate(); }
 
-  auto ready() -> bool { return _ready; }
+  auto driver() -> string override { return "XShm"; }
+  auto ready() -> bool override { return _ready; }
 
-  auto context() -> uintptr { return _context; }
+  auto hasContext() -> bool override { return true; }
-  auto smooth() -> bool { return _smooth; }
+  auto hasSmooth() -> bool override { return true; }
 
-  auto setContext(uintptr context) -> bool {
+  auto setContext(uintptr context) -> bool override {
-    if(_context == context) return true;
+    if(context == this->context()) return true;
-    _context = context;
+    if(!Video::setContext(context)) return false;
     return initialize();
   }
 
-  auto setSmooth(bool smooth) -> bool {
+  auto setSmooth(bool smooth) -> bool override {
-    _smooth = smooth;
+    if(smooth == this->smooth()) return true;
+    if(!Video::setSmooth(smooth)) return false;
     return true;
   }
 
-  auto clear() -> void {
+  auto clear() -> void override {
     if(!ready()) return;
     auto dp = _inputBuffer;
     uint length = _inputWidth * _inputHeight;
@@ -36,7 +38,7 @@ struct VideoXShm : Video {
     output();
   }
 
-  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool {
+  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool override {
     if(!ready()) return false;
     if(!_inputBuffer || _inputWidth != width || _inputHeight != height) {
       if(_inputBuffer) delete[] _inputBuffer;
@@ -50,11 +52,11 @@ struct VideoXShm : Video {
     return true;
   }
 
-  auto unlock() -> void {
+  auto unlock() -> void override {
     if(!ready()) return;
   }
 
-  auto output() -> void {
+  auto output() -> void override {
     if(!ready()) return;
     size();
 
@@ -190,8 +192,6 @@ private:
   }
 
   bool _ready = false;
-  uintptr _context = 0;
-  bool _smooth = true;
 
   uint32_t* _inputBuffer = nullptr;
   uint _inputWidth = 0;

ruby/video/xvideo.cpp

@@ -10,20 +10,26 @@ struct VideoXVideo : Video {
   VideoXVideo() { initialize(); }
   ~VideoXVideo() { terminate(); }
 
-  auto ready() -> bool { return _ready; }
+  auto driver() -> string override { return "XVideo"; }
+  auto ready() -> bool override { return _ready; }
 
-  auto context() -> uintptr { return _context; }
+  auto availableFormats() -> vector<string> override {
-  auto blocking() -> bool { return _blocking; }
+    return _formatNames;
+  }
 
-  auto setContext(uintptr context) -> bool {
+  auto hasContext() -> bool override { return true; }
-    if(_context == context) return true;
+  auto hasBlocking() -> bool override { return true; }
-    _context = context;
+  auto hasFormat() -> bool override { return true; }
+
+  auto setContext(uintptr context) -> bool override {
+    if(context == Video::context()) return true;
+    if(!Video::setContext(context)) return false;
     return initialize();
   }
 
-  auto setBlocking(bool blocking) -> bool {
+  auto setBlocking(bool blocking) -> bool override {
-    if(_blocking == blocking) return true;
+    if(blocking == Video::blocking()) return true;
-    _blocking = blocking;
+    if(!Video::setBlocking(blocking)) return false;
 
     bool result = false;
     Display* display = XOpenDisplay(nullptr);
@@ -36,7 +42,13 @@ struct VideoXVideo : Video {
     return result;
   }
 
-  auto clear() -> void {
+  auto setFormat(string format) -> bool override {
+    if(format == Video::format()) return true;
+    if(!Video::setFormat(format)) return false;
+    return initialize();
+  }
+
+  auto clear() -> void override {
     if(!ready()) return;
     memory::fill<uint32_t>(_buffer, _bufferWidth * _bufferHeight);
     //clear twice in case video is double buffered ...
@@ -44,18 +56,18 @@ struct VideoXVideo : Video {
     output();
   }
 
-  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool {
+  auto lock(uint32_t*& data, uint& pitch, uint width, uint height) -> bool override {
     if(!ready()) return false;
     if(width != _width || height != _height) resize(_width = width, _height = height);
     pitch = _bufferWidth * 4;
     return data = _buffer;
   }
 
-  auto unlock() -> void {
+  auto unlock() -> void override {
     if(!ready()) return;
   }
 
-  auto output() -> void {
+  auto output() -> void override {
     if(!ready()) return;
 
     XWindowAttributes target;
@@ -74,16 +86,15 @@ struct VideoXVideo : Video {
     //update target width and height attributes
     XGetWindowAttributes(_display, _window, &target);
 
-    switch(_format) {
+    auto& name = _formatName;
-    case XvFormatRGB32: renderRGB32(_width, _height); break;
+    if(name == "RGB32") renderRGB32(_width, _height);
-    case XvFormatRGB24: renderRGB24(_width, _height); break;
+    if(name == "RGB24") renderRGB24(_width, _height);
-    case XvFormatRGB16: renderRGB16(_width, _height); break;
+    if(name == "RGB16") renderRGB16(_width, _height);
-    case XvFormatRGB15: renderRGB15(_width, _height); break;
+    if(name == "RGB15") renderRGB15(_width, _height);
-    case XvFormatUYVY:  renderUYVY (_width, _height); break;
+    if(name == "UYVY" ) renderUYVY (_width, _height);
-    case XvFormatYUY2:  renderYUY2 (_width, _height); break;
+    if(name == "YUY2" ) renderYUY2 (_width, _height);
-    case XvFormatYV12:  renderYV12 (_width, _height); break;
+    if(name == "YV12" ) renderYV12 (_width, _height);
-    case XvFormatI420:  renderI420 (_width, _height); break;
+    if(name == "I420" ) renderI420 (_width, _height);
-    }
 
     XvShmPutImage(_display, _port, _window, _gc, _image,
       0, 0, _width, _height,
@@ -91,7 +102,7 @@ struct VideoXVideo : Video {
       true);
   }
 
-  auto poll() -> void {
+  auto poll() -> void override {
     while(XPending(_display)) {
       XEvent event;
       XNextEvent(_display, &event);
@@ -111,12 +122,14 @@ private:
     _display = XOpenDisplay(nullptr);
 
     if(!XShmQueryExtension(_display)) {
-      print("VideoXv: XShm extension not found.\n");
+      print("XVideo: XShm extension not found.\n");
       return false;
     }
 
     //find an appropriate Xv port
     _port = -1;
+    int depth = 0;
+    int visualID = 0;
     XvAdaptorInfo* adaptorInfo = nullptr;
     uint adaptorCount = 0;
     XvQueryAdaptors(_display, DefaultRootWindow(_display), &adaptorCount, &adaptorInfo);
@@ -127,42 +140,42 @@ private:
       if(!(adaptorInfo[n].type & XvImageMask)) continue;
 
       _port = adaptorInfo[n].base_id;
-      _depth = adaptorInfo[n].formats->depth;
+      depth = adaptorInfo[n].formats->depth;
-      _visualID = adaptorInfo[n].formats->visual_id;
+      visualID = adaptorInfo[n].formats->visual_id;
       break;
     }
     XvFreeAdaptorInfo(adaptorInfo);
     if(_port < 0) {
-      print("VideoXv: failed to find valid XvPort.\n");
+      print("XVideo: failed to find valid XvPort.\n");
       return false;
     }
 
     //create child window to attach to parent window.
     //this is so that even if parent window visual depth doesn't match Xv visual
     //(common with composited windows), Xv can still render to child window.
-    XWindowAttributes window_attributes;
+    XWindowAttributes windowAttributes;
-    XGetWindowAttributes(_display, (Window)_context, &window_attributes);
+    XGetWindowAttributes(_display, (Window)_context, &windowAttributes);
 
     XVisualInfo visualTemplate;
-    visualTemplate.visualid = _visualID;
+    visualTemplate.visualid = visualID;
     visualTemplate.screen = DefaultScreen(_display);
-    visualTemplate.depth = _depth;
+    visualTemplate.depth = depth;
     visualTemplate.visual = 0;
     int visualMatches = 0;
-    XVisualInfo* visualInfo = XGetVisualInfo(_display, VisualIDMask | VisualScreenMask | VisualDepthMask, &visualTemplate, &visualMatches);
+    auto visualInfo = XGetVisualInfo(_display, VisualIDMask | VisualScreenMask | VisualDepthMask, &visualTemplate, &visualMatches);
     if(visualMatches < 1 || !visualInfo->visual) {
       if(visualInfo) XFree(visualInfo);
-      print("VideoXv: unable to find Xv-compatible visual.\n");
+      print("XVideo: unable to find Xv-compatible visual.\n");
       return false;
     }
 
     _colormap = XCreateColormap(_display, (Window)_context, visualInfo->visual, AllocNone);
-    XSetWindowAttributes attributes;
+    XSetWindowAttributes attributes = {};
     attributes.colormap = _colormap;
     attributes.border_pixel = 0;
     _window = XCreateWindow(_display, /* parent = */ (Window)_context,
-      /* x = */ 0, /* y = */ 0, window_attributes.width, window_attributes.height,
+      /* x = */ 0, /* y = */ 0, windowAttributes.width, windowAttributes.height,
-      /* border_width = */ 0, _depth, InputOutput, visualInfo->visual,
+      /* border_width = */ 0, depth, InputOutput, visualInfo->visual,
       CWColormap | CWBorderPixel | CWEventMask, &attributes);
     XSelectInput(_display, _window, ExposureMask);
     XFree(visualInfo);
@@ -172,7 +185,7 @@ private:
     _gc = XCreateGC(_display, _window, 0, 0);
 
     int attributeCount = 0;
-    XvAttribute* attributeList = XvQueryPortAttributes(_display, _port, &attributeCount);
+    auto attributeList = XvQueryPortAttributes(_display, _port, &attributeCount);
     for(auto n : range(attributeCount)) {
       if(string{attributeList[n].name} == "XV_AUTOPAINT_COLORKEY") {
         //set colorkey to auto paint, so that Xv video output is always visible
@@ -182,96 +195,19 @@ private:
     }
     XFree(attributeList);
 
-    //find optimal rendering format
+    queryAvailableFormats();
-    _format = XvFormatUnknown;
+    if(!_formatNames) {
-    int formatCount = 0;
+      print("XVideo: unable to find a supported image format.\n");
-    XvImageFormatValues* format = XvListImageFormats(_display, _port, &formatCount);
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvRGB && format[n].bits_per_pixel == 32) {
-        _format = XvFormatRGB32;
-        _fourCC = format[n].id;
-        break;
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvRGB && format[n].bits_per_pixel == 24) {
-        _format = XvFormatRGB24;
-        _fourCC = format[n].id;
-        break;
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvRGB && format[n].bits_per_pixel <= 16 && format[n].red_mask == 0xf800) {
-        _format = XvFormatRGB16;
-        _fourCC = format[n].id;
-        break;
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvRGB && format[n].bits_per_pixel <= 16 && format[n].red_mask == 0x7c00) {
-        _format = XvFormatRGB15;
-        _fourCC = format[n].id;
-        break;
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvYUV && format[n].bits_per_pixel == 16 && format[n].format == XvPacked) {
-        if(format[n].component_order[0] == 'U' && format[n].component_order[1] == 'Y'
-        && format[n].component_order[2] == 'V' && format[n].component_order[3] == 'Y'
-        ) {
-          _format = XvFormatUYVY;
-          _fourCC = format[n].id;
-          break;
-        }
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvYUV && format[n].bits_per_pixel == 16 && format[n].format == XvPacked) {
-        if(format[n].component_order[0] == 'Y' && format[n].component_order[1] == 'U'
-        && format[n].component_order[2] == 'Y' && format[n].component_order[3] == 'V'
-        ) {
-          _format = XvFormatYUY2;
-          _fourCC = format[n].id;
-          break;
-        }
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvYUV && format[n].bits_per_pixel == 12 && format[n].format == XvPlanar) {
-        if(format[n].component_order[0] == 'Y' && format[n].component_order[1] == 'V'
-        && format[n].component_order[2] == 'U' && format[n].component_order[3] == '\x00'
-        ) {
-          _format = XvFormatYV12;
-          _fourCC = format[n].id;
-          break;
-        }
-      }
-    }
-
-    if(_format == XvFormatUnknown) for(auto n : range(formatCount)) {
-      if(format[n].type == XvYUV && format[n].bits_per_pixel == 12 && format[n].format == XvPlanar) {
-        if(format[n].component_order[0] == 'Y' && format[n].component_order[1] == 'U'
-        && format[n].component_order[2] == 'V' && format[n].component_order[3] == '\x00'
-        ) {
-          _format = XvFormatI420;
-          _fourCC = format[n].id;
-          break;
-        }
-      }
-    }
-
-    free(format);
-    if(_format == XvFormatUnknown) {
-      print("VideoXv: unable to find a supported image format.\n");
       return false;
     }
+    if(auto match = _formatNames.find(Video::format())) {
+      _formatID = _formatIDs[match()];
+      _formatName = _formatNames[match()];
+    } else {
+      _formatID = _formatIDs[0];
+      _formatName = _formatNames[0];
+      Video::setFormat(_formatName);
+    }
 
     _ready = true;
     initializeTables();
@@ -291,6 +227,11 @@ private:
       _image = nullptr;
     }
 
+    if(_gc) {
+      XFreeGC(_display, _gc);
+      _gc = 0;
+    }
+
     if(_window) {
       XUnmapWindow(_display, _window);
       _window = 0;
@@ -312,6 +253,49 @@ private:
     delete[] _vtable, _vtable = nullptr;
   }
 
+  auto queryAvailableFormats() -> void {
+    auto& ids = _formatIDs;
+    auto& names = _formatNames;
+
+    ids.reset();
+    names.reset();
+
+    int count = 0;
+    auto array = XvListImageFormats(_display, _port, &count);
+
+    for(uint sort : range(8)) {
+      for(uint n : range(count)) {
+        auto id = array[n].id;
+        auto type = array[n].type;
+        auto format = array[n].format;
+        auto depth = array[n].bits_per_pixel;
+        auto redMask = array[n].red_mask;
+        auto order = array[n].component_order;
+        string components;
+        for(uint n : range(4)) if(char c = order[n]) components.append(c);
+
+        if(type == XvRGB) {
+          if(sort == 0 && depth == 32) ids.append(id), names.append("RGB32");
+          if(sort == 1 && depth == 24) ids.append(id), names.append("RGB24");
+          if(sort == 2 && depth <= 16 && redMask == 0xf800) ids.append(id), names.append("RGB16");
+          if(sort == 3 && depth <= 16 && redMask == 0x7c00) ids.append(id), names.append("RGB15");
+        }
+
+        if(type == XvYUV && format == XvPacked) {
+          if(sort == 4 && depth == 16 && components == "UYVY") ids.append(id), names.append("UYVY");
+          if(sort == 5 && depth == 16 && components == "YUYV") ids.append(id), names.append("YUY2");
+        }
+
+        if(type == XvYUV && format == XvPlanar) {
+          if(sort == 6 && depth == 12 && components == "YVU" ) ids.append(id), names.append("YV12");
+          if(sort == 7 && depth == 12 && components == "YUV" ) ids.append(id), names.append("I420");
+        }
+      }
+    }
+
+    free(array);
+  }
+
   auto resize(uint width, uint height) -> void {
     if(_bufferWidth >= width && _bufferHeight >= height) return;
     _bufferWidth = max(width, _bufferWidth);
@@ -331,7 +315,7 @@ private:
       XFree(_image);
     }
 
-    _image = XvShmCreateImage(_display, _port, _fourCC, 0, _bufferWidth, _bufferHeight, &_shmInfo);
+    _image = XvShmCreateImage(_display, _port, _formatID, 0, _bufferWidth, _bufferHeight, &_shmInfo);
 
     _shmInfo.shmid = shmget(IPC_PRIVATE, _image->data_size, IPC_CREAT | 0777);
     _shmInfo.shmaddr = _image->data = (char*)shmat(_shmInfo.shmid, 0, 0);
@@ -343,38 +327,36 @@ private:
   }
 
   auto renderRGB32(uint width, uint height) -> void {
-    uint32_t* input = (uint32_t*)_buffer;
-    uint32_t* output = (uint32_t*)_image->data;
-
     for(uint y : range(height)) {
-      memory::copy<uint32_t>(output, input, width);
+      auto input = (const uint32_t*)_buffer + y * width;
-      input += _bufferWidth;
+      auto output = (uint32_t*)_image->data + y * (_image->pitches[0] >> 2);
-      output += _bufferWidth;
+
+      for(uint x : range(width)) {
+        uint32_t p = *input++;
+        *output++ = p;
+      }
     }
   }
 
   auto renderRGB24(uint width, uint height) -> void {
-    uint32_t* input = (uint32_t*)_buffer;
-    uint8_t* output = (uint8_t*)_image->data;
-
     for(uint y : range(height)) {
+      auto input = (const uint32_t*)_buffer + y * width;
+      auto output = (uint8_t*)_image->data + y * _image->pitches[0];
+
       for(uint x : range(width)) {
         uint32_t p = *input++;
         *output++ = p >>  0;
         *output++ = p >>  8;
         *output++ = p >> 16;
       }
-
-      input += (_bufferWidth - width);
-      output += (_bufferWidth - width) * 3;
     }
   }
 
   auto renderRGB16(uint width, uint height) -> void {
-    uint32_t* input = (uint32_t*)_buffer;
-    uint16_t* output = (uint16_t*)_image->data;
-
     for(uint y : range(height)) {
+      auto input = (const uint32_t*)_buffer + y * width;
+      auto output = (uint16_t*)_image->data + y * (_image->pitches[0] >> 1);
+
       for(uint x : range(width)) {
         uint32_t p = toRGB16(*input++);
         *output++ = p;
@@ -386,25 +368,22 @@ private:
   }
 
   auto renderRGB15(uint width, uint height) -> void {
-    uint32_t* input = (uint32_t*)_buffer;
-    uint16_t* output = (uint16_t*)_image->data;
-
     for(uint y : range(height)) {
+      auto input = (const uint32_t*)_buffer + y * width;
+      auto output = (uint16_t*)_image->data + y * (_image->pitches[0] >> 1);
+
       for(uint x : range(width)) {
         uint32_t p = toRGB15(*input++);
         *output++ = p;
       }
-
-      input += _bufferWidth - width;
-      output += _bufferWidth - width;
     }
   }
 
   auto renderUYVY(uint width, uint height) -> void {
-    const uint32_t* input = (const uint32_t*)_buffer;
-    uint16_t* output = (uint16_t*)_image->data;
-
     for(uint y : range(height)) {
+      auto input = (const uint32_t*)_buffer + y * width;
+      auto output = (uint16_t*)_image->data + y * (_image->pitches[0] >> 1);
+
       for(uint x : range(width >> 1)) {
         uint32_t p0 = toRGB16(*input++);
         uint32_t p1 = toRGB16(*input++);
@@ -412,17 +391,14 @@ private:
         *output++ = _ytable[p0] << 8 | ((_utable[p0] + _utable[p1]) >> 1) << 0;
         *output++ = _ytable[p1] << 8 | ((_vtable[p0] + _vtable[p1]) >> 1) << 0;
       }
-
-      input += _bufferWidth - width;
-      output += _bufferWidth - width;
     }
   }
 
   auto renderYUY2(uint width, uint height) -> void {
-    const uint32_t* input = (const uint32_t*)_buffer;
-    uint16_t* output = (uint16_t*)_image->data;
-
     for(uint y : range(height)) {
+      auto input = (const uint32_t*)_buffer + y * width;
+      auto output = (uint16_t*)_image->data + y * (_image->pitches[0] >> 1);
+
       for(uint x : range(width >> 1)) {
         uint32_t p0 = toRGB16(*input++);
         uint32_t p1 = toRGB16(*input++);
@@ -430,22 +406,17 @@ private:
         *output++ = ((_utable[p0] + _utable[p1]) >> 1) << 8 | _ytable[p0] << 0;
         *output++ = ((_vtable[p0] + _vtable[p1]) >> 1) << 8 | _ytable[p1] << 0;
       }
-
-      input += _bufferWidth - width;
-      output += _bufferWidth - width;
     }
   }
 
   auto renderYV12(uint width, uint height) -> void {
-    const uint w = _bufferWidth, h = _bufferHeight;
-
     for(uint y : range(height >> 1)) {
-      const uint32_t* input0 = (const uint32_t*)_buffer + (2 * y * w);
+      auto input0 = (const uint32_t*)_buffer + (2 * y + 0) * width;
-      const uint32_t* input1 = input0 + w;
+      auto input1 = (const uint32_t*)_buffer + (2 * y + 1) * width;
-      uint16_t* youtput0 = (uint16_t*)_image->data + ((2 * y * w) >> 1);
+      auto youtput0 = (uint16_t*)_image->data + (_image->offsets[0] >> 1) + (2 * y + 0) * (_image->pitches[0] >> 1);
-      uint16_t* youtput1 = youtput0 + (w >> 1);
+      auto youtput1 = (uint16_t*)_image->data + (_image->offsets[0] >> 1) + (2 * y + 1) * (_image->pitches[0] >> 1);
-      uint8_t* voutput = (uint8_t*)_image->data + (w * h) + ((2 * y * w) >> 2);
+      auto voutput = (uint8_t*)_image->data + _image->offsets[1] + y * _image->pitches[1];
-      uint8_t* uoutput = (uint8_t*)_image->data + (w * h) + ((w * h) >> 2) + ((2 * y * w) >> 2);
+      auto uoutput = (uint8_t*)_image->data + _image->offsets[2] + y * _image->pitches[2];
 
       for(uint x : range(width >> 1)) {
         uint16_t p0 = toRGB16(*input0++);
@@ -462,15 +433,13 @@ private:
   }
 
   auto renderI420(uint width, uint height) -> void {
-    const uint w = _bufferWidth, h = _bufferHeight;
-
     for(uint y : range(height >> 1)) {
-      const uint32_t* input0 = (const uint32_t*)_buffer + (2 * y * w);
+      auto input0 = (const uint32_t*)_buffer + (2 * y + 0) * width;
-      const uint32_t* input1 = input0 + w;
+      auto input1 = (const uint32_t*)_buffer + (2 * y + 1) * width;
-      uint16_t* youtput0 = (uint16_t*)_image->data + ((2 * y * w) >> 1);
+      auto youtput0 = (uint16_t*)_image->data + (_image->offsets[0] >> 1) + (2 * y + 0) * (_image->pitches[0] >> 1);
-      uint16_t* youtput1 = youtput0 + (w >> 1);
+      auto youtput1 = (uint16_t*)_image->data + (_image->offsets[0] >> 1) + (2 * y + 1) * (_image->pitches[0] >> 1);
-      uint8_t* uoutput = (uint8_t*)_image->data + (w * h) + ((2 * y * w) >> 2);
+      auto uoutput = (uint8_t*)_image->data + _image->offsets[1] + y * _image->pitches[1];
-      uint8_t* voutput = (uint8_t*)_image->data + (w * h) + ((w * h) >> 2) + ((2 * y * w) >> 2);
+      auto voutput = (uint8_t*)_image->data + _image->offsets[2] + y * _image->pitches[2];
 
       for(uint x : range(width >> 1)) {
         uint16_t p0 = toRGB16(*input0++);
@@ -525,8 +494,6 @@ private:
   }
 
   bool _ready = false;
-  uintptr _context = 0;
-  bool _blocking = false;
 
   uint _width = 0;
   uint _height = 0;
@@ -539,18 +506,6 @@ private:
   uint8_t* _utable = nullptr;
   uint8_t* _vtable = nullptr;
 
-  enum XvFormat : uint {
-    XvFormatRGB32,
-    XvFormatRGB24,
-    XvFormatRGB16,
-    XvFormatRGB15,
-    XvFormatUYVY,
-    XvFormatYUY2,
-    XvFormatYV12,
-    XvFormatI420,
-    XvFormatUnknown,
-  };
-
   Display* _display = nullptr;
   GC _gc = 0;
   Window _window = 0;
@@ -558,10 +513,11 @@ private:
   XShmSegmentInfo _shmInfo;
 
   int _port = -1;
-  int _depth = 0;
-  int _visualID = 0;
-
   XvImage* _image = nullptr;
-  XvFormat _format = XvFormatUnknown;
+
-  uint32_t _fourCC = 0;
+  vector<int> _formatIDs;
+  vector<string> _formatNames;
+
+  int _formatID = 0;
+  string _formatName;
 };