Simplified the SDL audio driver by using a generic ring buffer (from Gambatte). Changed the A/V max delay and sound update framerate to saner values. Emulation smoothness and sound quality have improved on my system. Please report any issue.

src/Sound.cpp

@@ -348,8 +348,11 @@ static void end_frame( blip_time_t time )
 
 void flush_samples(Multi_Buffer * buffer)
 {
-	// get the size in bytes of the sound driver buffer
+	// We want to write the data frame by frame to support legacy audio drivers
-	int soundBufferLen = soundDriver->getBufferLength();
+	// that don't use the length parameter of the write method.
+	// TODO: Update the Win32 audio drivers (DS, OAL, XA2), and flush all the
+	// samples at once to help reducing the audio delay on all platforms.
+	int soundBufferLen = ( soundSampleRate / 60 ) * 4;
 
 	// soundBufferLen should have a whole number of sample pairs
 	assert( soundBufferLen % (2 * sizeof *soundFinalWave) == 0 );

src/common/Array.h

@@ -0,0 +1,40 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by Sindre Aam<EFBFBD>s                                    *
+ *   aamas@stud.ntnu.no                                                    *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License version 2 as     *
+ *   published by the Free Software Foundation.                            *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License version 2 for more details.                *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   version 2 along with this program; if not, write to the               *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef ARRAY_H
+#define ARRAY_H
+
+#include <cstddef>
+
+template<typename T>
+class Array {
+	T *a;
+	std::size_t sz;
+	
+	Array(const Array &ar);
+	
+public:
+	Array(const std::size_t size = 0) : a(size ? new T[size] : 0), sz(size) {}
+	~Array() { delete []a; }
+	void reset(const std::size_t size) { delete []a; a = size ? new T[size] : 0; sz = size; }
+	std::size_t size() const { return sz; }
+	operator T*() { return a; }
+	operator const T*() const { return a; }
+};
+
+#endif

src/common/RingBuffer.h

@@ -0,0 +1,112 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by Sindre Aamås                                    *
+ *   aamas@stud.ntnu.no                                                    *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License version 2 as     *
+ *   published by the Free Software Foundation.                            *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License version 2 for more details.                *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   version 2 along with this program; if not, write to the               *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef RINGBUFFER_H
+#define RINGBUFFER_H
+
+#include "Array.h"
+#include <cstddef>
+#include <algorithm>
+#include <cstring>
+
+template<typename T>
+class RingBuffer {
+	Array<T> buf;
+	std::size_t sz;
+	std::size_t rpos;
+	std::size_t wpos;
+
+public:
+	RingBuffer(const std::size_t sz_in = 0) : sz(0), rpos(0), wpos(0) { reset(sz_in); }
+
+	std::size_t avail() const {
+		return (wpos < rpos ? 0 : sz) + rpos - wpos - 1;
+	}
+
+	void clear() {
+		wpos = rpos = 0;
+	}
+
+	void fill(T value);
+
+	void read(T *out, std::size_t num);
+
+	void reset(std::size_t sz_in);
+
+	std::size_t size() const {
+		return sz - 1;
+	}
+
+	std::size_t used() const {
+		return (wpos < rpos ? sz : 0) + wpos - rpos;
+	}
+
+	void write(const T *in, std::size_t num);
+};
+
+template<typename T>
+void RingBuffer<T>::fill(const T value) {
+	std::fill(buf + 0, buf + sz, value);
+	rpos = 0;
+	wpos = sz - 1;
+}
+
+template<typename T>
+void RingBuffer<T>::read(T *out, std::size_t num) {
+	if (rpos + num > sz) {
+		const std::size_t n = sz - rpos;
+
+		std::memcpy(out, buf + rpos, n * sizeof(T));
+
+		rpos = 0;
+		num -= n;
+		out += n;
+	}
+
+	std::memcpy(out, buf + rpos, num * sizeof(T));
+
+	if ((rpos += num) == sz)
+		rpos = 0;
+}
+
+template<typename T>
+void RingBuffer<T>::reset(const std::size_t sz_in) {
+	sz = sz_in + 1;
+	rpos = wpos = 0;
+	buf.reset(sz_in ? sz : 0);
+}
+
+template<typename T>
+void RingBuffer<T>::write(const T *in, std::size_t num) {
+	if (wpos + num > sz) {
+		const std::size_t n = sz - wpos;
+
+		std::memcpy(buf + wpos, in, n * sizeof(T));
+
+		wpos = 0;
+		num -= n;
+		in += n;
+	}
+
+	std::memcpy(buf + wpos, in, num * sizeof(T));
+
+	if ((wpos += num) == sz)
+		wpos = 0;
+}
+
+#endif

src/common/SoundDriver.h

@@ -55,12 +55,7 @@ public:
 	/**
 	 * Write length bytes of data from the finalWave buffer to the driver output buffer.
 	 */
-	virtual void write(const u16 * finalWave, int length) = 0;
+	virtual void write(u16 * finalWave, int length) = 0;
-
-	/**
-	 * Return the size in bytes of the core sound buffer.
-	 */
-	virtual int getBufferLength() = 0;
 
 	virtual void setThrottle(unsigned short throttle) { };
 };

src/common/SoundSDL.cpp

@@ -6,153 +6,120 @@
 
 extern int emulating;
 
-u8          SoundSDL::_buffer[_bufferTotalLen];
+SoundSDL::SoundSDL():
-int         SoundSDL::_readPosition;
+	_rbuf(0)
-int         SoundSDL::_writePosition;
-SDL_cond  * SoundSDL::_cond;
-SDL_mutex * SoundSDL::_mutex;
-
-inline int SoundSDL::getBufferFree()
 {
-  int ret = _readPosition - _writePosition - _bufferAlign;
+
-  if (ret < 0)
-    ret += _bufferTotalLen;
-  return ret;
 }
 
-inline int SoundSDL::getBufferUsed()
+void SoundSDL::soundCallback(void *data, u8 *stream, int len)
 {
-  int ret = _writePosition - _readPosition;
+	reinterpret_cast<SoundSDL*>(data)->read(reinterpret_cast<u16 *>(stream), len);
-  if (ret < 0)
-    ret += _bufferTotalLen;
-  return ret;
 }
 
-void SoundSDL::soundCallback(void *,u8 *stream,int len)
+void SoundSDL::read(u16 * stream, int length)
 {
-  if (len <= 0 || !emulating)
+	if (length <= 0 || !emulating)
-    return;
+		return;
 
-  SDL_mutexP(_mutex);
+	SDL_mutexP(_mutex);
-  const int nAvail = getBufferUsed();
+
-  if (len > nAvail)
+	_rbuf.read(stream, std::min(static_cast<std::size_t>(length) / 2, _rbuf.used()));
-    len = nAvail;
+
-  const int nAvail2 = _bufferTotalLen - _readPosition;
+	SDL_CondSignal(_cond);
-  if (len >= nAvail2) {
+	SDL_mutexV(_mutex);
-    memcpy(stream, &_buffer[_readPosition], nAvail2);
-    _readPosition = 0;
-    stream += nAvail2;
-    len    -= nAvail2;
-  }
-  if (len > 0) {
-    memcpy(stream, &_buffer[_readPosition], len);
-    _readPosition = (_readPosition + len) % _bufferTotalLen;
-    stream += len;
-  }
-  SDL_CondSignal(_cond);
-  SDL_mutexV(_mutex);
 }
 
-void SoundSDL::write(const u16 * finalWave, int length)
+void SoundSDL::write(u16 * finalWave, int length)
 {
-  if (SDL_GetAudioStatus() != SDL_AUDIO_PLAYING)
+	if (SDL_GetAudioStatus() != SDL_AUDIO_PLAYING)
-  {
+		SDL_PauseAudio(0);
-    SDL_PauseAudio(0);
-  }
 
-  int remain = length;
+	SDL_mutexP(_mutex);
-  const u8 *wave = reinterpret_cast<const u8 *>(finalWave);
 
-  SDL_mutexP(_mutex);
+	unsigned int samples = length / 4;
 
-  int n;
+	std::size_t avail;
-  while (remain >= (n = getBufferFree())) {
+	while ((avail = _rbuf.avail() / 2) < samples)
-  const int nAvail = (_bufferTotalLen - _writePosition) < n ? (_bufferTotalLen - _writePosition) : n;
+	{
-   memcpy(&_buffer[_writePosition], wave, nAvail);
+		_rbuf.write(finalWave, avail * 2);
-   _writePosition = (_writePosition + nAvail) % _bufferTotalLen;
-    wave        += nAvail;
-    remain      -= nAvail;
 
-	if (!emulating || speedup || systemThrottle) {
+		finalWave += avail * 2;
-       SDL_mutexV(_mutex);
+		samples -= avail;
-      return;
-    }
-    SDL_CondWait(_cond, _mutex);
-  }
 
-  const int nAvail = _bufferTotalLen - _writePosition;
+		// If emulating and not in speed up mode, synchronize to audio
-  if (remain >= nAvail) {
+		// by waiting till there is enough room in the buffer
-    memcpy(&_buffer[_writePosition], wave, nAvail);
+		if (emulating && !speedup && !systemThrottle)
-    _writePosition = 0;
+		{
-    wave   += nAvail;
+			SDL_CondWait(_cond, _mutex);
-    remain -= nAvail;
+		}
-  }
+		else
-  if (remain > 0) {
+		{
-    memcpy(&_buffer[_writePosition], wave, remain);
+			// Drop the remaining of the audio data
-    _writePosition = (_writePosition + remain) % _bufferTotalLen;
+			SDL_mutexV(_mutex);
-  }
+			return;
-  SDL_mutexV(_mutex);
+		}
+	}
+
+	_rbuf.write(finalWave, samples * 2);
+
+	SDL_mutexV(_mutex);
 }
 
+
 bool SoundSDL::init(long sampleRate)
 {
-  SDL_AudioSpec audio;
+	SDL_AudioSpec audio;
+	audio.freq = sampleRate;
+	audio.format = AUDIO_S16SYS;
+	audio.channels = 2;
+	audio.samples = sampleRate / 60;
+	audio.callback = soundCallback;
+	audio.userdata = this;
 
-  _bufferLen = sampleRate * 4 / 60;
+	if(SDL_OpenAudio(&audio, NULL))
+	{
+		fprintf(stderr,"Failed to open audio: %s\n", SDL_GetError());
+		return false;
+	}
 
-  audio.freq = sampleRate;
+	_rbuf.reset(_delay * sampleRate * 2);
-  audio.format = AUDIO_S16SYS;
-  audio.channels = 2;
-  audio.samples = 1024;
-  audio.callback = soundCallback;
-  audio.userdata = NULL;
-  if(SDL_OpenAudio(&audio, NULL)) {
-    fprintf(stderr,"Failed to open audio: %s\n", SDL_GetError());
-    return false;
-  }
 
-  _cond  = SDL_CreateCond();
+	_cond  = SDL_CreateCond();
-  _mutex = SDL_CreateMutex();
+	_mutex = SDL_CreateMutex();
-
-  _readPosition = _writePosition = 0;
-  return true;
 
+	return true;
 }
 
 SoundSDL::~SoundSDL()
 {
-  SDL_mutexP(_mutex);
+	SDL_mutexP(_mutex);
-  int iSave = emulating;
+	int iSave = emulating;
-  emulating = 0;
+	emulating = 0;
-  SDL_CondSignal(_cond);
+	SDL_CondSignal(_cond);
-  SDL_mutexV(_mutex);
+	SDL_mutexV(_mutex);
 
-  SDL_DestroyCond(_cond);
+	SDL_DestroyCond(_cond);
-  _cond = NULL;
+	_cond = NULL;
 
-  SDL_DestroyMutex(_mutex);
+	SDL_DestroyMutex(_mutex);
-  _mutex = NULL;
+	_mutex = NULL;
 
-  SDL_CloseAudio();
+	SDL_CloseAudio();
 
-  emulating = iSave;
+	emulating = iSave;
 }
 
 void SoundSDL::pause()
 {
-  SDL_PauseAudio(1);
+	SDL_PauseAudio(1);
 }
 
 void SoundSDL::resume()
 {
-  SDL_PauseAudio(0);
+	SDL_PauseAudio(0);
 }
 
 void SoundSDL::reset()
 {
 }
-
-int SoundSDL::getBufferLength()
-{
-	return _bufferLen;
-}

src/common/SoundSDL.h

@@ -19,35 +19,31 @@
 #define __VBA_SOUND_SDL_H__
 
 #include "SoundDriver.h"
+#include "RingBuffer.h"
 
 class SoundSDL: public SoundDriver
 {
 public:
+	SoundSDL();
 	virtual ~SoundSDL();
 
 	virtual bool init(long sampleRate);
 	virtual void pause();
 	virtual void reset();
 	virtual void resume();
-	virtual void write(const u16 * finalWave, int length);
+	virtual void write(u16 * finalWave, int length);
-	virtual int getBufferLength();
 
 private:
-	static const  int  _sampleCount    = 4096;
+	RingBuffer<u16> _rbuf;
-	static const  int  _bufferAlign    = 4;
-	static const  int  _bufferCapacity = _sampleCount * 2;
-	static const  int  _bufferTotalLen = _bufferCapacity + _bufferAlign;
 
-	static u8          _buffer[_bufferTotalLen];
+	SDL_cond  * _cond;
-	static int         _readPosition;
+	SDL_mutex * _mutex;
-	static int         _writePosition;
-	static SDL_cond  * _cond;
-	static SDL_mutex * _mutex;
-	int                _bufferLen;
 
-	static int getBufferFree();
+	// Hold up to 100 ms of data in the ring buffer
-	static int getBufferUsed();
+	static const float _delay = 0.1f;
-	static void soundCallback(void *, u8 *stream, int len);
+
+	static void soundCallback(void *data, u8 *stream, int length);
+	virtual void read(u16 * stream, int length);
 };
 
 #endif // __VBA_SOUND_SDL_H__

src/dmg/gb_apu/Blip_Buffer.h

@@ -40,7 +40,7 @@ public:
 	// a new time frame at the end of the current frame.
 	void end_frame( blip_time_t time );
 
-	// Reads at most 'max_samples' out of buffer into 'dest', removing them from from
+	// Reads at most 'max_samples' out of buffer into 'dest', removing them from
 	// the buffer. Returns number of samples actually read and removed. If stereo is
 	// true, increments 'dest' one extra time after writing each sample, to allow
 	// easy interleving of two channels into a stereo output buffer.

src/win32/DirectSound.cpp

@@ -38,8 +38,7 @@ public:
 	void pause();  // pause the secondary sound buffer
 	void reset();  // stop and reset the secondary sound buffer
 	void resume(); // resume the secondary sound buffer
-	void write(const u16 * finalWave, int length);  // write the emulated sound to the secondary sound buffer
+	void write(u16 * finalWave, int length);  // write the emulated sound to the secondary sound buffer
-	virtual int getBufferLength();
 };
 
 
@@ -224,7 +223,7 @@ void DirectSound::resume()
 }
 
 
-void DirectSound::write(const u16 * finalWave, int length)
+void DirectSound::write(u16 * finalWave, int length)
 {
 	if(!pDirectSound) return;
 
@@ -307,11 +306,6 @@ void DirectSound::write(const u16 * finalWave, int length)
 	}
 }
 
-int DirectSound::getBufferLength()
-{
-	return soundBufferLen;
-}
-
 SoundDriver *newDirectSound()
 {
 	return new DirectSound();

src/win32/OpenAL.cpp

@@ -41,8 +41,7 @@ public:
 	void pause();  // pause the secondary sound buffer
 	void reset();  // stop and reset the secondary sound buffer
 	void resume(); // play/resume the secondary sound buffer
-	void write(const u16 * finalWave, int length);  // write the emulated sound to a sound buffer
+	void write(u16 * finalWave, int length);  // write the emulated sound to a sound buffer
-	virtual int getBufferLength();
 
 private:
 	OPENALFNTABLE  ALFunction;
@@ -242,7 +241,7 @@ void OpenAL::reset()
 }
 
 
-void OpenAL::write(const u16 * finalWave, int length)
+void OpenAL::write(u16 * finalWave, int length)
 {
 	if( !initialized ) return;
 	winlog( "OpenAL::write\n" );
@@ -321,11 +320,6 @@ void OpenAL::write(const u16 * finalWave, int length)
 	}
 }
 
-int OpenAL::getBufferLength()
-{
-	return soundBufferLen;
-}
-
 SoundDriver *newOpenAL()
 {
 	winlog( "newOpenAL\n" );

src/win32/XAudio2.cpp

@@ -59,7 +59,7 @@ public:
 	bool init(long sampleRate);
 
 	// Sound Data Feed
-	void write(const u16 * finalWave, int length);
+	void write(u16 * finalWave, int length);
 
 	// Play Control
 	void pause();
@@ -69,8 +69,6 @@ public:
 	// Configuration Changes
 	void setThrottle( unsigned short throttle );
 
-	virtual int getBufferLength();
-
 private:
 	bool   failed;
 	bool   initialized;
@@ -280,7 +278,7 @@ bool XAudio2_Output::init(long sampleRate)
 }
 
 
-void XAudio2_Output::write(const u16 * finalWave, int length)
+void XAudio2_Output::write(u16 * finalWave, int length)
 {
 	if( !initialized || failed ) return;
 
@@ -373,11 +371,6 @@ void XAudio2_Output::setThrottle( unsigned short throttle )
 	ASSERT( hr == S_OK );
 }
 
-int XAudio2_Output::getBufferLength()
-{
-	return soundBufferLen;
-}
-
 SoundDriver *newXAudio2_Output()
 {
 	return new XAudio2_Output();