o add bsnes

bsnes/lib/ruby/audio/alsa.cpp

@@ -0,0 +1,237 @@
+#include <alsa/asoundlib.h>
+
+namespace ruby {
+
+#include "alsa.hpp"
+
+class pAudioALSA {
+public:
+  AudioALSA &self;
+
+  struct {
+    snd_pcm_t *handle;
+    snd_pcm_format_t format;
+    snd_pcm_uframes_t buffer_size;
+    snd_pcm_uframes_t period_size;
+    int channels;
+    const char *name;
+  } device;
+
+  struct {
+    uint32_t *data;
+    unsigned length;
+  } buffer;
+
+  struct {
+    bool synchronize;
+    unsigned frequency;
+    unsigned latency;
+  } settings;
+
+  bool cap(Audio::Setting setting) {
+    if(setting == Audio::Synchronize) return true;
+    if(setting == Audio::Frequency) return true;
+    if(setting == Audio::Latency) return true;
+    return false;
+  }
+
+  uintptr_t get(Audio::Setting setting) {
+    if(setting == Audio::Synchronize) return settings.synchronize;
+    if(setting == Audio::Frequency) return settings.frequency;
+    if(setting == Audio::Latency) return settings.latency;
+    return false;
+  }
+
+  bool set(Audio::Setting setting, uintptr_t param) {
+    if(setting == Audio::Synchronize) {
+      if(settings.synchronize != param) {
+        settings.synchronize = param;
+        if(device.handle) {
+          term();
+          init();
+        }
+      }
+      return true;
+    }
+
+    if(setting == Audio::Frequency) {
+      if(settings.frequency != param) {
+        settings.frequency = param;
+        if(device.handle) {
+          term();
+          init();
+        }
+      }
+      return true;
+    }
+
+    if(setting == Audio::Latency) {
+      if(settings.latency != param) {
+        settings.latency = param;
+        if(device.handle) {
+          term();
+          init();
+        }
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  void sample(uint16_t left, uint16_t right) {
+    if(!device.handle) return;
+
+    buffer.data[buffer.length++] = left + (right << 16);
+    if(buffer.length < device.period_size) return;
+
+    if(settings.synchronize == false) {
+      snd_pcm_avail_update(device.handle);
+      snd_pcm_sframes_t delay;
+      snd_pcm_delay(device.handle, &delay);
+      if(delay < 0) {
+        snd_pcm_prepare(device.handle);
+      } else if(delay > device.buffer_size - device.period_size) {
+        buffer.length = 0;
+        return;
+      }
+    }
+
+    uint32_t *buffer_ptr = buffer.data;
+    int i = 4;
+
+    while((buffer.length > 0) && i--) {
+      snd_pcm_sframes_t written = snd_pcm_writei(device.handle, buffer_ptr, buffer.length);
+      if(written < 0) {
+        //no samples written
+        snd_pcm_recover(device.handle, written, 1);
+      } else if(written <= buffer.length) {
+        buffer.length -= written;
+        buffer_ptr += written;
+      }
+    }
+
+    if(i < 0) {
+      if(buffer.data == buffer_ptr) {
+        buffer.length--;
+        buffer_ptr++;
+      }
+      memmove(buffer.data, buffer_ptr, buffer.length * sizeof(uint32_t));
+    }
+  }
+
+  bool init() {
+    if(snd_pcm_open(&device.handle, device.name, SND_PCM_STREAM_PLAYBACK, 0) < 0) {
+      term();
+      return false;
+    }
+
+    /* //below code will not work with 24khz frequency rate (ALSA library bug)
+    if(snd_pcm_set_params(device.handle, device.format, SND_PCM_ACCESS_RW_INTERLEAVED,
+      device.channels, settings.frequency, 1, settings.latency * 100) < 0) {
+      //failed to set device parameters
+      term();
+      return false;
+    }
+
+    if(snd_pcm_get_params(device.handle, &device.buffer_size, &device.period_size) < 0) {
+      device.period_size = settings.latency * 100 * 1e-6 * settings.frequency / 4;
+    }*/
+
+    snd_pcm_hw_params_t *hwparams;
+    snd_pcm_sw_params_t *swparams;
+    unsigned rate = settings.frequency;
+    unsigned buffer_time = settings.latency * 100;
+    unsigned period_time = settings.latency * 100 / 4;
+
+    snd_pcm_hw_params_alloca(&hwparams);
+    if(snd_pcm_hw_params_any(device.handle, hwparams) < 0) {
+      term();
+      return false;
+    }
+
+    if(snd_pcm_hw_params_set_access(device.handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0
+    || snd_pcm_hw_params_set_format(device.handle, hwparams, device.format) < 0
+    || snd_pcm_hw_params_set_channels(device.handle, hwparams, device.channels) < 0
+    || snd_pcm_hw_params_set_rate_near(device.handle, hwparams, &rate, 0) < 0
+    || snd_pcm_hw_params_set_period_time_near(device.handle, hwparams, &period_time, 0) < 0
+    || snd_pcm_hw_params_set_buffer_time_near(device.handle, hwparams, &buffer_time, 0) < 0
+    ) {
+      term();
+      return false;
+    }
+
+    if(snd_pcm_hw_params(device.handle, hwparams) < 0) {
+      term();
+      return false;
+    }
+
+    if(snd_pcm_get_params(device.handle, &device.buffer_size, &device.period_size) < 0) {
+      term();
+      return false;
+    }
+
+    snd_pcm_sw_params_alloca(&swparams);
+    if(snd_pcm_sw_params_current(device.handle, swparams) < 0) {
+      term();
+      return false;
+    }
+
+    if(snd_pcm_sw_params_set_start_threshold(device.handle, swparams,
+      (device.buffer_size / device.period_size) * device.period_size) < 0
+    ) {
+      term();
+      return false;
+    }
+
+    if(snd_pcm_sw_params(device.handle, swparams) < 0) {
+      term();
+      return false;
+    }
+
+    buffer.data = new uint32_t[device.period_size];
+    return true;
+  }
+
+  void term() {
+    if(device.handle) {
+      snd_pcm_drain(device.handle);
+      snd_pcm_close(device.handle);
+      device.handle = 0;
+    }
+
+    if(buffer.data) {
+      delete[] buffer.data;
+      buffer.data = 0;
+	}
+  }
+
+  pAudioALSA(AudioALSA &self_) : self(self_) {
+    device.handle = 0;
+    device.format = SND_PCM_FORMAT_S16_LE;
+    device.channels = 2;
+    device.name = "default";
+
+    buffer.data = 0;
+    buffer.length = 0;
+
+    settings.synchronize = false;
+    settings.frequency = 22050;
+    settings.latency = 60;
+  }
+
+  ~pAudioALSA() {
+    term();
+  }
+};
+
+bool AudioALSA::cap(Setting setting) { return p.cap(setting); }
+uintptr_t AudioALSA::get(Setting setting) { return p.get(setting); }
+bool AudioALSA::set(Setting setting, uintptr_t param) { return p.set(setting, param); }
+void AudioALSA::sample(uint16_t left, uint16_t right) { p.sample(left, right); }
+bool AudioALSA::init() { return p.init(); }
+void AudioALSA::term() { p.term(); }
+AudioALSA::AudioALSA() : p(*new pAudioALSA(*this)) {}
+AudioALSA::~AudioALSA() { delete &p; }
+
+} //namespace ruby

bsnes/lib/ruby/audio/alsa.hpp

@@ -0,0 +1,23 @@
+/*
+  audio.alsa (2008-08-12)
+  authors: Nach, RedDwarf
+*/
+
+class pAudioALSA;
+
+class AudioALSA : public Audio {
+public:
+  bool cap(Setting);
+  uintptr_t get(Setting);
+  bool set(Setting, uintptr_t);
+
+  void sample(uint16_t left, uint16_t right);
+  bool init();
+  void term();
+
+  AudioALSA();
+  ~AudioALSA();
+
+private:
+  pAudioALSA &p;
+};

bsnes/lib/ruby/audio/ao.cpp

@@ -0,0 +1,97 @@
+#include <ao/ao.h>
+
+namespace ruby {
+
+#include "ao.hpp"
+
+class pAudioAO {
+public:
+  AudioAO &self;
+
+  int driver_id;
+  ao_sample_format driver_format;
+  ao_device *audio_device;
+
+  struct {
+    unsigned frequency;
+  } settings;
+
+  bool cap(Audio::Setting setting) {
+    if(setting == Audio::Frequency) return true;
+    return false;
+  }
+
+  uintptr_t get(Audio::Setting setting) {
+    if(setting == Audio::Frequency) return settings.frequency;
+    return false;
+  }
+
+  bool set(Audio::Setting setting, uintptr_t param) {
+    if(setting == Audio::Frequency) {
+      settings.frequency = param;
+      if(audio_device) {
+        term();
+        init();
+      }
+      return true;
+    }
+    return false;
+  }
+
+  void sample(uint16_t l_sample, uint16_t r_sample) {
+    uint32_t samp = (l_sample << 0) + (r_sample << 16);
+    ao_play(audio_device, (char*)&samp, 4); //This may need to be byte swapped for Big Endian
+  }
+
+  bool init() {
+    driver_id = ao_default_driver_id(); //ao_driver_id((const char*)driver)
+    if(driver_id < 0) return false;
+
+    driver_format.bits = 16;
+    driver_format.channels = 2;
+    driver_format.rate = settings.frequency;
+    driver_format.byte_format = AO_FMT_LITTLE;
+
+    ao_option *options = 0;
+    ao_info *di = ao_driver_info(driver_id);
+    if(!di) return false;
+    if(!strcmp(di->short_name, "alsa")) {
+      ao_append_option(&options, "buffer_time", "100000"); //100ms latency (default was 500ms)
+    }
+
+    audio_device = ao_open_live(driver_id, &driver_format, options);
+    if(!audio_device) return false;
+
+    return true;
+  }
+
+  void term() {
+    if(audio_device) {
+      ao_close(audio_device);
+      audio_device = 0;
+    }
+  }
+
+  pAudioAO(AudioAO &self_) : self(self_) {
+    audio_device = 0;
+    ao_initialize();
+
+    settings.frequency = 22050;
+  }
+
+  ~pAudioAO() {
+    term();
+  //ao_shutdown(); //FIXME: this is causing a segfault for some reason when called ...
+  }
+};
+
+bool AudioAO::cap(Setting setting) { return p.cap(setting); }
+uintptr_t AudioAO::get(Setting setting) { return p.get(setting); }
+bool AudioAO::set(Setting setting, uintptr_t param) { return p.set(setting, param); }
+void AudioAO::sample(uint16_t l_sample, uint16_t r_sample) { p.sample(l_sample, r_sample); }
+bool AudioAO::init() { return p.init(); }
+void AudioAO::term() { p.term(); }
+AudioAO::AudioAO() : p(*new pAudioAO(*this)) {}
+AudioAO::~AudioAO() { delete &p; }
+
+} //namespace ruby

bsnes/lib/ruby/audio/ao.hpp

@@ -0,0 +1,23 @@
+/*
+  audio.ao (2008-06-01)
+  authors: Nach, RedDwarf
+*/
+
+class pAudioAO;
+
+class AudioAO : public Audio {
+public:
+  bool cap(Setting);
+  uintptr_t get(Setting);
+  bool set(Setting, uintptr_t);
+
+  void sample(uint16_t left, uint16_t right);
+  bool init();
+  void term();
+
+  AudioAO();
+  ~AudioAO();
+
+private:
+  pAudioAO &p;
+};

bsnes/lib/ruby/audio/directsound.cpp

@@ -0,0 +1,220 @@
+#include <windows.h>
+#include <dsound.h>
+
+namespace ruby {
+
+#include "directsound.hpp"
+
+class pAudioDS {
+public:
+  AudioDS &self;
+
+  LPDIRECTSOUND ds;
+  LPDIRECTSOUNDBUFFER dsb_p, dsb_b;
+  DSBUFFERDESC dsbd;
+  WAVEFORMATEX wfx;
+
+  struct {
+    unsigned rings;
+    unsigned latency;
+
+    uint32_t *buffer;
+    unsigned bufferoffset;
+
+    unsigned readring;
+    unsigned writering;
+    int distance;
+  } device;
+
+  struct {
+    HWND handle;
+    bool synchronize;
+    unsigned frequency;
+    unsigned latency;
+  } settings;
+
+  bool cap(Audio::Setting setting) {
+    if(setting == Audio::Handle) return true;
+    if(setting == Audio::Synchronize) return true;
+    if(setting == Audio::Frequency) return true;
+    if(setting == Audio::Latency) return true;
+    return false;
+  }
+
+  uintptr_t get(Audio::Setting setting) {
+    if(setting == Audio::Handle) return (uintptr_t)settings.handle;
+    if(setting == Audio::Synchronize) return settings.synchronize;
+    if(setting == Audio::Frequency) return settings.frequency;
+    if(setting == Audio::Latency) return settings.latency;
+    return false;
+  }
+
+  bool set(Audio::Setting setting, uintptr_t param) {
+    if(setting == Audio::Handle) {
+      settings.handle = (HWND)param;
+      return true;
+    }
+
+    if(setting == Audio::Synchronize) {
+      settings.synchronize = param;
+      if(ds) clear();
+      return true;
+    }
+
+    if(setting == Audio::Frequency) {
+      settings.frequency = param;
+      if(ds) init();
+      return true;
+    }
+
+    if(setting == Audio::Latency) {
+      settings.latency = param;
+      if(ds) init();
+      return true;
+    }
+
+    return false;
+  }
+
+  void sample(uint16_t left, uint16_t right) {
+    device.buffer[device.bufferoffset++] = left + (right << 16);
+    if(device.bufferoffset < device.latency) return;
+    device.bufferoffset = 0;
+
+    DWORD pos, size;
+    void *output;
+
+    if(settings.synchronize == true) {
+      //wait until playback buffer has an empty ring to write new audio data to
+      while(device.distance >= device.rings - 1) {
+        dsb_b->GetCurrentPosition(&pos, 0);
+        unsigned activering = pos / (device.latency * 4);
+        if(activering == device.readring) {
+          if(video.get(Video::Synchronize) == false) Sleep(1);
+          continue;
+        }
+
+        //subtract number of played rings from ring distance counter
+        device.distance -= (device.rings + activering - device.readring) % device.rings;
+        device.readring = activering;
+
+        if(device.distance < 2) {
+          //buffer underflow; set max distance to recover quickly
+          device.distance  = device.rings - 1;
+          device.writering = (device.rings + device.readring - 1) % device.rings;
+          break;
+        }
+      }
+    }
+
+    device.writering = (device.writering + 1) % device.rings;
+    device.distance  = (device.distance  + 1) % device.rings;
+
+    if(dsb_b->Lock(device.writering * device.latency * 4, device.latency * 4, &output, &size, 0, 0, 0) == DS_OK) {
+      memcpy(output, device.buffer, device.latency * 4);
+      dsb_b->Unlock(output, size, 0, 0);
+    }
+  }
+
+  void clear() {
+    device.readring  = 0;
+    device.writering = device.rings - 1;
+    device.distance  = device.rings - 1;
+
+    device.bufferoffset = 0;
+    if(device.buffer) memset(device.buffer, 0, device.latency * device.rings * 4);
+
+    if(!dsb_b) return;
+    dsb_b->Stop();
+    dsb_b->SetCurrentPosition(0);
+
+    DWORD size;
+    void *output;
+    dsb_b->Lock(0, device.latency * device.rings * 4, &output, &size, 0, 0, 0);
+    memset(output, 0, size);
+    dsb_b->Unlock(output, size, 0, 0);
+
+    dsb_b->Play(0, 0, DSBPLAY_LOOPING);
+  }
+
+  bool init() {
+    term();
+
+    device.rings   = 8;
+    device.latency = settings.frequency * settings.latency / device.rings / 1000.0 + 0.5;
+    device.buffer  = new uint32_t[device.latency * device.rings];
+    device.bufferoffset = 0;
+
+    DirectSoundCreate(0, &ds, 0);
+    ds->SetCooperativeLevel((HWND)settings.handle, DSSCL_PRIORITY);
+
+    memset(&dsbd, 0, sizeof(dsbd));
+    dsbd.dwSize        = sizeof(dsbd);
+    dsbd.dwFlags       = DSBCAPS_PRIMARYBUFFER;
+    dsbd.dwBufferBytes = 0;
+    dsbd.lpwfxFormat   = 0;
+    ds->CreateSoundBuffer(&dsbd, &dsb_p, 0);
+
+    memset(&wfx, 0, sizeof(wfx));
+    wfx.wFormatTag      = WAVE_FORMAT_PCM;
+    wfx.nChannels       = 2;
+    wfx.nSamplesPerSec  = settings.frequency;
+    wfx.wBitsPerSample  = 16;
+    wfx.nBlockAlign     = wfx.wBitsPerSample / 8 * wfx.nChannels;
+    wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
+    dsb_p->SetFormat(&wfx);
+
+    memset(&dsbd, 0, sizeof(dsbd));
+    dsbd.dwSize  = sizeof(dsbd);
+    dsbd.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_CTRLFREQUENCY | DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCSOFTWARE;
+    dsbd.dwBufferBytes   = device.latency * device.rings * sizeof(uint32_t);
+    dsbd.guid3DAlgorithm = GUID_NULL;
+    dsbd.lpwfxFormat     = &wfx;
+    ds->CreateSoundBuffer(&dsbd, &dsb_b, 0);
+    dsb_b->SetFrequency(settings.frequency);
+    dsb_b->SetCurrentPosition(0);
+
+    clear();
+    return true;
+  }
+
+  void term() {
+    if(device.buffer) {
+      delete[] device.buffer;
+      device.buffer = 0;
+    }
+
+    if(dsb_b) { dsb_b->Stop(); dsb_b->Release(); dsb_b = 0; }
+    if(dsb_p) { dsb_p->Stop(); dsb_p->Release(); dsb_p = 0; }
+    if(ds) { ds->Release(); ds = 0; }
+  }
+
+  pAudioDS(AudioDS &self_) : self(self_) {
+    ds = 0;
+    dsb_p = 0;
+    dsb_b = 0;
+
+    device.buffer = 0;
+    device.bufferoffset = 0;
+    device.readring = 0;
+    device.writering = 0;
+    device.distance = 0;
+
+    settings.handle = GetDesktopWindow();
+    settings.synchronize = false;
+    settings.frequency = 22050;
+    settings.latency = 120;
+  }
+};
+
+bool AudioDS::cap(Setting setting) { return p.cap(setting); }
+uintptr_t AudioDS::get(Setting setting) { return p.get(setting); }
+bool AudioDS::set(Setting setting, uintptr_t param) { return p.set(setting, param); }
+void AudioDS::sample(uint16_t left, uint16_t right) { p.sample(left, right); }
+void AudioDS::clear() { p.clear(); }
+bool AudioDS::init() { return p.init(); }
+void AudioDS::term() { p.term(); }
+AudioDS::AudioDS() : p(*new pAudioDS(*this)) {}
+AudioDS::~AudioDS() { delete &p; }
+
+} //namespace ruby

bsnes/lib/ruby/audio/directsound.hpp

@@ -0,0 +1,24 @@
+/*
+  audio.directsound (2007-12-26)
+  author: byuu
+*/
+
+class pAudioDS;
+
+class AudioDS : public Audio {
+public:
+  bool cap(Setting);
+  uintptr_t get(Setting);
+  bool set(Setting, uintptr_t);
+
+  void sample(uint16_t left, uint16_t right);
+  void clear();
+  bool init();
+  void term();
+
+  AudioDS();
+  ~AudioDS();
+
+private:
+  pAudioDS &p;
+};

bsnes/lib/ruby/audio/openal.cpp

@@ -0,0 +1,207 @@
+#include <AL/al.h>
+#include <AL/alc.h>
+
+namespace ruby {
+
+#include "openal.hpp"
+
+class pAudioOpenAL {
+public:
+  AudioOpenAL &self;
+
+  struct {
+    ALCdevice *handle;
+    ALCcontext *context;
+    ALuint source;
+    ALenum format;
+    unsigned latency;
+    unsigned queue_length;
+  } device;
+
+  struct {
+    uint32_t *data;
+    unsigned length;
+    unsigned size;
+  } buffer;
+
+  struct {
+    bool synchronize;
+    unsigned frequency;
+    unsigned latency;
+  } settings;
+
+  bool cap(Audio::Setting setting) {
+    if(setting == Audio::Synchronize) return true;
+    if(setting == Audio::Frequency) return true;
+    if(setting == Audio::Latency) return true;
+    return false;
+  }
+
+  uintptr_t get(Audio::Setting setting) {
+    if(setting == Audio::Synchronize) return settings.synchronize;
+    if(setting == Audio::Frequency) return settings.frequency;
+    if(setting == Audio::Latency) return settings.latency;
+    return false;
+  }
+
+  bool set(Audio::Setting setting, uintptr_t param) {
+    if(setting == Audio::Synchronize) {
+      settings.synchronize = param;
+      return true;
+    }
+
+    if(setting == Audio::Frequency) {
+      settings.frequency = param;
+      return true;
+    }
+
+    if(setting == Audio::Latency) {
+      if(settings.latency != param) {
+        settings.latency = param;
+        update_latency();
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  void sample(uint16_t sl, uint16_t sr) {
+    buffer.data[buffer.length++] = sl + (sr << 16);
+    if(buffer.length < buffer.size) return;
+
+    ALuint albuffer = 0;
+    int processed = 0;
+    while(true) {
+      alGetSourcei(device.source, AL_BUFFERS_PROCESSED, &processed);
+      while(processed--) {
+        alSourceUnqueueBuffers(device.source, 1, &albuffer);
+        alDeleteBuffers(1, &albuffer);
+        device.queue_length--;
+      }
+      //wait for buffer playback to catch up to sample generation if not synchronizing
+      if(settings.synchronize == false || device.queue_length < 3) break;
+    }
+
+    if(device.queue_length < 3) {
+      alGenBuffers(1, &albuffer);
+      alBufferData(albuffer, device.format, buffer.data, buffer.size * 4, settings.frequency);
+      alSourceQueueBuffers(device.source, 1, &albuffer);
+      device.queue_length++;
+    }
+
+    ALint playing;
+    alGetSourcei(device.source, AL_SOURCE_STATE, &playing);
+    if(playing != AL_PLAYING) alSourcePlay(device.source);
+    buffer.length = 0;
+  }
+
+  void update_latency() {
+    if(buffer.data) delete[] buffer.data;
+    buffer.size = settings.frequency * settings.latency / 1000.0 + 0.5;
+    buffer.data = new uint32_t[buffer.size];
+  }
+
+  bool init() {
+    update_latency();
+    device.queue_length = 0;
+
+    bool success = false;
+    if(device.handle = alcOpenDevice(NULL)) {
+      if(device.context = alcCreateContext(device.handle, NULL)) {
+        alcMakeContextCurrent(device.context);
+        alGenSources(1, &device.source);
+
+        //alSourcef (device.source, AL_PITCH, 1.0);
+        //alSourcef (device.source, AL_GAIN, 1.0);
+        //alSource3f(device.source, AL_POSITION, 0.0, 0.0, 0.0);
+        //alSource3f(device.source, AL_VELOCITY, 0.0, 0.0, 0.0);
+        //alSource3f(device.source, AL_DIRECTION, 0.0, 0.0, 0.0);
+        //alSourcef (device.source, AL_ROLLOFF_FACTOR, 0.0);
+        //alSourcei (device.source, AL_SOURCE_RELATIVE, AL_TRUE);
+
+        alListener3f(AL_POSITION, 0.0, 0.0, 0.0);
+        alListener3f(AL_VELOCITY, 0.0, 0.0, 0.0);
+        ALfloat listener_orientation[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+        alListenerfv(AL_ORIENTATION, listener_orientation);
+
+        success = true;
+      }
+    }
+
+    if(success == false) {
+      term();
+      return false;
+    }
+
+    return true;
+  }
+
+  void term() {
+    if(alIsSource(device.source) == AL_TRUE) {
+      int playing = 0;
+      alGetSourcei(device.source, AL_SOURCE_STATE, &playing);
+      if(playing == AL_PLAYING) {
+        alSourceStop(device.source);
+        int queued = 0;
+        alGetSourcei(device.source, AL_BUFFERS_QUEUED, &queued);
+        while(queued--) {
+          ALuint albuffer = 0;
+          alSourceUnqueueBuffers(device.source, 1, &albuffer);
+          alDeleteBuffers(1, &albuffer);
+          device.queue_length--;
+        }
+      }
+
+      alDeleteSources(1, &device.source);
+      device.source = 0;
+    }
+
+    if(device.context) {
+      alcMakeContextCurrent(NULL);
+      alcDestroyContext(device.context);
+      device.context = 0;
+    }
+
+    if(device.handle) {
+      alcCloseDevice(device.handle);
+      device.handle = 0;
+    }
+
+    if(buffer.data) {
+      delete[] buffer.data;
+      buffer.data = 0;
+    }
+  }
+
+  pAudioOpenAL(AudioOpenAL &self_) : self(self_) {
+    device.source = 0;
+    device.handle = 0;
+    device.context = 0;
+    device.format = AL_FORMAT_STEREO16;
+    device.queue_length = 0;
+
+    buffer.data = 0;
+    buffer.length = 0;
+    buffer.size = 0;
+
+    settings.synchronize = true;
+    settings.frequency = 22050;
+    settings.latency = 40;
+  }
+
+  ~pAudioOpenAL() {
+    term();
+  }
+};
+
+bool AudioOpenAL::cap(Setting setting) { return p.cap(setting); }
+uintptr_t AudioOpenAL::get(Setting setting) { return p.get(setting); }
+bool AudioOpenAL::set(Setting setting, uintptr_t param) { return p.set(setting, param); }
+void AudioOpenAL::sample(uint16_t sl, uint16_t sr) { p.sample(sl, sr); }
+bool AudioOpenAL::init() { return p.init(); }
+void AudioOpenAL::term() { p.term(); }
+AudioOpenAL::AudioOpenAL() : p(*new pAudioOpenAL(*this)) {}
+AudioOpenAL::~AudioOpenAL() { delete &p; }
+
+} //namespace ruby

bsnes/lib/ruby/audio/openal.hpp

@@ -0,0 +1,24 @@
+/*
+  audio.openal (2007-12-26)
+  author: Nach
+  contributors: byuu, wertigon, _willow_
+*/
+
+class pAudioOpenAL;
+
+class AudioOpenAL : public Audio {
+public:
+  bool cap(Setting);
+  uintptr_t get(Setting);
+  bool set(Setting, uintptr_t);
+
+  void sample(uint16_t sl, uint16_t sr);
+  bool init();
+  void term();
+
+  AudioOpenAL();
+  ~AudioOpenAL();
+
+private:
+  pAudioOpenAL &p;
+};

bsnes/lib/ruby/audio/oss.cpp

@@ -0,0 +1,116 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+
+//OSS4 soundcard.h includes below SNDCTL defines, but OSS3 does not
+//However, OSS4 soundcard.h does not reside in <sys/>
+//Therefore, attempt to manually define SNDCTL values if using OSS3 header
+//Note that if the defines below fail to work on any specific platform, one can point soundcard.h
+//above to the correct location for OSS4 (usually /usr/lib/oss/include/sys/soundcard.h)
+//Failing that, one can disable OSS4 ioctl calls inside init() and remove the below defines
+
+#ifndef SNDCTL_DSP_COOKEDMODE
+  #define SNDCTL_DSP_COOKEDMODE _IOW('P', 30, int)
+#endif
+
+#ifndef SNDCTL_DSP_POLICY
+  #define SNDCTL_DSP_POLICY _IOW('P', 45, int)
+#endif
+
+namespace ruby {
+
+#include "oss.hpp"
+
+class pAudioOSS {
+public:
+  AudioOSS &self;
+
+  struct {
+    int fd;
+    int format;
+    int channels;
+    const char *name;
+  } device;
+
+  struct {
+    unsigned frequency;
+  } settings;
+
+  bool cap(Audio::Setting setting) {
+    if(setting == Audio::Frequency) return true;
+    return false;
+  }
+
+  uintptr_t get(Audio::Setting setting) {
+    if(setting == Audio::Frequency) return settings.frequency;
+    return false;
+  }
+
+  bool set(Audio::Setting setting, uintptr_t param) {
+    if(setting == Audio::Frequency) {
+      settings.frequency = param;
+      if(device.fd > 0) {
+        term();
+        init();
+      }
+      return true;
+    }
+    return false;
+  }
+
+  void sample(uint16_t sl, uint16_t sr) {
+    uint32_t sample = sl + (sr << 16);
+    unsigned unused = write(device.fd, &sample, 4);
+  }
+
+  bool init() {
+    device.fd = open(device.name, O_WRONLY, O_NONBLOCK);
+    if(device.fd < 0) return false;
+
+    #if 1 //SOUND_VERSION >= 0x040000
+    //attempt to enable OSS4-specific features regardless of version
+    //OSS3 ioctl calls will silently fail, but sound will still work
+    int cooked = 1, policy = 4; //policy should be 0 - 10, lower = less latency, more CPU usage
+    ioctl(device.fd, SNDCTL_DSP_COOKEDMODE, &cooked);
+    ioctl(device.fd, SNDCTL_DSP_POLICY, &policy);
+    #endif
+    int freq = settings.frequency;
+    ioctl(device.fd, SNDCTL_DSP_CHANNELS, &device.channels);
+    ioctl(device.fd, SNDCTL_DSP_SETFMT, &device.format);
+    ioctl(device.fd, SNDCTL_DSP_SPEED, &freq);
+
+    return true;
+  }
+
+  void term() {
+    if(device.fd > 0) {
+      close(device.fd);
+      device.fd = -1;
+    }
+  }
+
+  pAudioOSS(AudioOSS &self_) : self(self_) {
+    device.fd = -1;
+    device.format = AFMT_S16_LE;
+    device.channels = 2;
+    device.name = "/dev/dsp";
+
+    settings.frequency = 22050;
+  }
+
+  ~pAudioOSS() {
+    term();
+  }
+};
+
+bool AudioOSS::cap(Setting setting) { return p.cap(setting); }
+uintptr_t AudioOSS::get(Setting setting) { return p.get(setting); }
+bool AudioOSS::set(Setting setting, uintptr_t param) { return p.set(setting, param); }
+void AudioOSS::sample(uint16_t sl, uint16_t sr) { p.sample(sl, sr); }
+bool AudioOSS::init() { return p.init(); }
+void AudioOSS::term() { p.term(); }
+AudioOSS::AudioOSS() : p(*new pAudioOSS(*this)) {}
+AudioOSS::~AudioOSS() { delete &p; }
+
+} //namespace ruby

bsnes/lib/ruby/audio/oss.hpp

@@ -0,0 +1,23 @@
+/*
+  audio.oss (2007-12-26)
+  author: Nach
+*/
+
+class pAudioOSS;
+
+class AudioOSS : public Audio {
+public:
+  bool cap(Setting);
+  uintptr_t get(Setting);
+  bool set(Setting, uintptr_t);
+
+  void sample(uint16_t sl, uint16_t sr);
+  bool init();
+  void term();
+
+  AudioOSS();
+  ~AudioOSS();
+
+private:
+  pAudioOSS &p;
+};

bsnes/lib/ruby/audio/pulseaudio.cpp

@@ -0,0 +1,121 @@
+#include <pulse/simple.h>
+#include <pulse/error.h>
+
+namespace ruby {
+
+#include "pulseaudio.hpp"
+
+class pAudioPulseAudio {
+public:
+  struct {
+    pa_simple *handle;
+    pa_sample_spec spec;
+  } device;
+
+  struct {
+    uint32_t *data;
+    unsigned offset;
+  } buffer;
+
+  struct {
+    unsigned frequency;
+  } settings;
+
+  AudioPulseAudio &self;
+
+  bool cap(Audio::Setting setting) {
+    if(setting == Audio::Frequency) return true;
+    return false;
+  }
+
+  uintptr_t get(Audio::Setting setting) {
+    if(setting == Audio::Frequency) return settings.frequency;
+    return false;
+  }
+
+  bool set(Audio::Setting setting, uintptr_t param) {
+    if(setting == Audio::Frequency) {
+      settings.frequency = param;
+      if(device.handle) {
+        term();
+        init();
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  void sample(uint16_t left, uint16_t right) {
+    if(!device.handle) return;
+
+    buffer.data[buffer.offset++] = left + (right << 16);
+    if(buffer.offset >= 64) {
+      int error;
+      pa_simple_write(device.handle, (const void*)buffer.data, buffer.offset * sizeof(uint32_t), &error);
+      buffer.offset = 0;
+    }
+  }
+
+  bool init() {
+    device.spec.format   = PA_SAMPLE_S16LE;
+    device.spec.channels = 2;
+    device.spec.rate     = settings.frequency;
+
+    int error = 0;
+    device.handle = pa_simple_new(
+      0,                   //default server
+      "ruby::pulseaudio",  //application name
+      PA_STREAM_PLAYBACK,  //direction
+      0,                   //default device
+      "audio",             //stream description
+      &device.spec,        //sample format
+      0,                   //default channel map
+      0,                   //default buffering attributes
+      &error               //error code
+    );
+    if(!device.handle) {
+      fprintf(stderr, "ruby::pulseaudio failed to initialize - %s\n", pa_strerror(error));
+      return false;
+    }
+
+    buffer.data = new uint32_t[64];
+    buffer.offset = 0;
+    return true;
+  }
+
+  void term() {
+    if(device.handle) {
+      int error;
+      pa_simple_flush(device.handle, &error);
+      pa_simple_free(device.handle);
+      device.handle = 0;
+    }
+
+    if(buffer.data) {
+      delete[] buffer.data;
+      buffer.data = 0;
+    }
+  }
+
+  pAudioPulseAudio(AudioPulseAudio &self_) : self(self_) {
+    device.handle = 0;
+    buffer.data = 0;
+    settings.frequency = 22050;
+  }
+
+  ~pAudioPulseAudio() {
+    term();
+  }
+};
+
+bool AudioPulseAudio::cap(Setting setting) { return p.cap(setting); }
+uintptr_t AudioPulseAudio::get(Setting setting) { return p.get(setting); }
+bool AudioPulseAudio::set(Setting setting, uintptr_t param) { return p.set(setting, param); }
+void AudioPulseAudio::sample(uint16_t left, uint16_t right) { return p.sample(left, right); }
+bool AudioPulseAudio::init() { return p.init(); }
+void AudioPulseAudio::term() { p.term(); }
+AudioPulseAudio::AudioPulseAudio() : p(*new pAudioPulseAudio(*this)) {}
+AudioPulseAudio::~AudioPulseAudio() { delete &p; }
+
+} //namespace ruby

bsnes/lib/ruby/audio/pulseaudio.hpp

@@ -0,0 +1,23 @@
+/*
+  audio.pulseaudio (2008-10-31)
+  author: byuu
+*/
+
+class pAudioPulseAudio;
+
+class AudioPulseAudio : public Audio {
+public:
+  bool cap(Setting);
+  uintptr_t get(Setting);
+  bool set(Setting, uintptr_t);
+
+  void sample(uint16_t left, uint16_t right);
+  bool init();
+  void term();
+
+  AudioPulseAudio();
+  ~AudioPulseAudio();
+
+private:
+  pAudioPulseAudio &p;
+};