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.

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> {
-    return {44100.0, 48000.0, 96000.0};
-  }
-
-  auto availableLatencies() -> vector<uint> {
-    return {20, 40, 60, 80, 100};
-  }
-
-  auto availableChannels() -> vector<uint> {
+  auto availableChannels() -> vector<uint> override {
     return {2};
   }
 
-  auto ready() -> bool { return _ready; }
-  auto device() -> string { return _device; }
-  auto blocking() -> bool { return _blocking; }
-  auto channels() -> uint { return _channels; }
-  auto frequency() -> double { return (double)_frequency; }
-  auto latency() -> uint { return _latency; }
+  auto availableFrequencies() -> vector<double> override {
+    return {44100.0, 48000.0, 96000.0};
+  }
 
-  auto setDevice(string device) -> bool {
-    if(_device == device) return true;
-    _device = device;
+  auto availableLatencies() -> vector<uint> override {
+    return {20, 40, 60, 80, 100};
+  }
+
+  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 {
-    if(_blocking == blocking) return true;
-    _blocking = blocking;
+  auto setBlocking(bool blocking) -> bool override {
+    if(blocking == this->blocking()) return true;
+    if(!Audio::setBlocking(blocking)) return false;
     return true;
   }
 
-  auto setFrequency(double frequency) -> bool {
-    if(_frequency == (uint)frequency) return true;
-    _frequency = (uint)frequency;
+  auto setChannels(uint channels) -> bool override {
+    if(channels == this->channels()) return true;
+    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 {
-    if(_latency == latency) return true;
-    _latency = latency;
-    if(_ready) updateLatency();
+  auto setLatency(uint latency) -> bool override {
+    if(latency == this->latency()) return true;
+    if(!Audio::setLatency(latency)) return false;
+    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;