@@ -6,6 +6,7 @@

 #include "../apu/Gb_Apu.h"

 #include "../apu/Multi_Buffer.h"

 #include "../common/SoundDriver.h"

+#include "XSFCommon.h"

 extern SoundDriver *systemSoundInit();

@@ -117,7 +118,7 @@ void Gba_Pcm::apply_control(int idx)

 				// base filtering on how long since last sample was output

 				int32_t period = time - this->last_time;

-				int idx = period / 512;

+				idx = period / 512;

 				if (idx >= 3)

 					idx = 3;

@@ -189,11 +190,11 @@ void Gba_Pcm_Fifo::timer_overflowed(int which_timer)

 			if (!this->count)

 			{

 				// Not filled by DMA, so fill with 16 bytes of silence

-				int reg = this->which ? FIFOB_L : FIFOA_L;

+				int regi = this->which ? FIFOB_L : FIFOA_L;

 				for (int n = 8; n--; )

 				{

-					soundEvent(reg, static_cast<uint16_t>(0));

-					soundEvent(reg + 2, static_cast<uint16_t>(0));

+					soundEvent(regi, static_cast<uint16_t>(0));

+					soundEvent(regi + 2, static_cast<uint16_t>(0));

 				}

 			}

 		}

@@ -393,10 +394,10 @@ void psoundTickfn()

 		flush_samples(stereo_buffer.get());

-		if (soundFiltering_ != soundFiltering)

+		if (!fEqual(soundFiltering_, soundFiltering))

 			apply_filtering();

-		if (soundVolume_ != soundVolume)

+		if (!fEqual(soundVolume_, soundVolume))

 			apply_volume();

 	}

 }

@@ -412,10 +413,12 @@ static void apply_muting()

 	if (gb_apu)

 		// APU

 		for (int i = 0; i < 4; ++i)

+		{

 			if (soundEnableFlag >> i & 1)

 				gb_apu->set_output(stereo_buffer->center(), stereo_buffer->left(), stereo_buffer->right(), i);

 			else

 				gb_apu->set_output(nullptr, nullptr, nullptr, i);

+		}

 }

 static void reset_apu()

@@ -115,7 +115,7 @@ void Gba_Pcm::apply_control(int idx)

 			if (soundInterpolation)

 			{

 				// base filtering on how long since last sample was output

-				int period = time - this->last_time;

+				int32_t period = time - this->last_time;

 				int idx = period / 512;

 				if (idx >= 3)

@@ -158,7 +158,7 @@ void Gba_Pcm::update(int dac)

 			if (soundInterpolation)

 			{

 				// base filtering on how long since last sample was output

-				int period = time - this->last_time;

+				int32_t period = time - this->last_time;

 				int idx = period / 512;

 				if (idx >= 3)

@@ -350,22 +350,21 @@ void flush_samples(Multi_Buffer *buffer)

 	// 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;

+	int32_t soundBufferLen = (soundSampleRate / 60) * 4;

 	// soundBufferLen should have a whole number of sample pairs

 	assert(!(soundBufferLen % (2 * sizeof(*soundFinalWave))));

 	// number of samples in output buffer

-	int out_buf_size = soundBufferLen / sizeof(*soundFinalWave);

+	int32_t out_buf_size = soundBufferLen / sizeof(*soundFinalWave);

-	// Keep filling and writing soundFinalWave until it can't be fully filled

-	while (buffer->samples_avail() >= out_buf_size)

+	while (buffer->samples_avail())

 	{

-		buffer->read_samples(reinterpret_cast<blip_sample_t *>(soundFinalWave), out_buf_size);

+		long samples_read = buffer->read_samples(reinterpret_cast<blip_sample_t *>(soundFinalWave), out_buf_size);

 		if (soundPaused)

 			soundResume();

-		soundDriver->write(soundFinalWave, soundBufferLen);

+		soundDriver->write(soundFinalWave, samples_read * sizeof(*soundFinalWave));

 	}

 }

@@ -374,11 +373,11 @@ static void apply_filtering()

 	soundFiltering_ = soundFiltering;

 	int base_freq = static_cast<int>(32768 - soundFiltering_ * 16384);

-	int nyquist = stereo_buffer->sample_rate() / 2;

+	int32_t nyquist = stereo_buffer->sample_rate() / 2;

 	for (int i = 0; i < 3; ++i)

 	{

-		int cutoff = base_freq >> i;

+		int32_t cutoff = base_freq >> i;

 		if (cutoff > nyquist)

 			cutoff = nyquist;

 		pcm_synth[i].treble_eq(blip_eq_t(0, 0, stereo_buffer->sample_rate(), cutoff));

@@ -400,8 +399,6 @@ void psoundTickfn()

 		if (soundVolume_ != soundVolume)

 			apply_volume();

 	}

-

-	ioMem[NR52] = (ioMem[NR52] & 0x80) | (gb_apu->read_status() & 0x7f);

 }

 static void apply_muting()

@@ -423,8 +420,11 @@ static void apply_muting()

 static void reset_apu()

 {

-	gb_apu->reduce_clicks(true);

-	gb_apu->reset(gb_apu->mode_agb, true);

+	if (gb_apu)

+	{

+		gb_apu->reduce_clicks(true);

+		gb_apu->reset(Gb_Apu::mode_agb, true);

+	}

 	if (stereo_buffer)

 		stereo_buffer->clear();

@@ -438,23 +438,24 @@ static void remake_stereo_buffer()

 	pcm[0].pcm.init();

 	pcm[1].pcm.init();

-	// APU

-	if (!gb_apu)

-	{

-		gb_apu.reset(new Gb_Apu); // TODO: handle out of memory

-		reset_apu();

-	}

-

 	// Stereo_Buffer

 	stereo_buffer.reset(new Stereo_Buffer); // TODO: handle out of memory

 	stereo_buffer->set_sample_rate(soundSampleRate); // TODO: handle out of memory

-	stereo_buffer->clock_rate(gb_apu->clock_rate);

 	// PCM

 	pcm[0].which = 0;

 	pcm[1].which = 1;

 	apply_filtering();

+	// APU

+	if (!gb_apu)

+	{

+		gb_apu.reset(new Gb_Apu); // TODO: handle out of memory

+		reset_apu();

+		gb_apu->treble_eq(blip_eq_t(0, 0, soundSampleRate, soundSampleRate / 2));

+	}

+	stereo_buffer->clock_rate(gb_apu->clock_rate);

+

 	// Volume Level

 	apply_muting();

 	apply_volume();

@@ -8,7 +8,6 @@

 #include "../common/SoundDriver.h"

 extern SoundDriver *systemSoundInit();

-bool soundDeclicking = true;

 static const uint32_t NR52 = 0x84;

@@ -20,12 +19,12 @@ static uint16_t soundFinalWave[6400];

 static long soundSampleRate = 44100;

 bool soundInterpolation = true;

 static bool soundPaused = true;

-static float soundFiltering = 0.5f; // 0.0 = none, 1.0 = max

+static float soundFiltering = 1.0f;

 int SOUND_CLOCK_TICKS = SOUND_CLOCK_TICKS_;

 int soundTicks = SOUND_CLOCK_TICKS_;

 static float soundVolume = 1.0f;

-static int soundEnableFlag = 0x30f; // emulator channels enabled

+static int soundEnableFlag = 0x3ff; // emulator channels enabled

 static float soundFiltering_ = -1;

 static float soundVolume_ = -1;

@@ -85,11 +84,11 @@ inline void Gba_Pcm::init()

 void Gba_Pcm::apply_control(int idx)

 {

-	this->shift = (~ioMem[SGCNT0_H] >> (2 + idx)) & 1;

+	this->shift = ~ioMem[SGCNT0_H] >> (2 + idx) & 1;

 	int ch = 0;

-	if (((soundEnableFlag >> idx) & 0x100) && (ioMem[NR52] & 0x80))

-		ch = (ioMem[SGCNT0_H + 1] >> (idx * 4)) & 3;

+	if ((soundEnableFlag >> idx & 0x100) && (ioMem[NR52] & 0x80))

+		ch = ioMem[SGCNT0_H + 1] >> (idx * 4) & 3;

 	Blip_Buffer *out = nullptr;

 	switch (ch)

@@ -108,7 +107,7 @@ void Gba_Pcm::apply_control(int idx)

 	{

 		if (this->output)

 		{

-			blip_time_t time = blip_time();

+			auto time = blip_time();

 			this->output->set_modified();

@@ -147,7 +146,7 @@ void Gba_Pcm::update(int dac)

 {

 	if (this->output)

 	{

-		blip_time_t time = blip_time();

+		auto time = blip_time();

 		dac = static_cast<int8_t>(dac) >> this->shift;

 		int delta = dac - this->last_amp;

@@ -179,15 +178,19 @@ void Gba_Pcm_Fifo::timer_overflowed(int which_timer)

 {

 	if (which_timer == this->timer && this->enabled)

 	{

-		if (this->count <= 16)

+		/* Mother 3 fix, refined to not break Metroid Fusion */

+		if (this->count == 16 || !this->count)

 		{

 			// Need to fill FIFO

+			int saved_count = this->count;

 			CPUCheckDMA(3, this->which ? 4 : 2);

-			if (this->count <= 16)

+			if (!saved_count && this->count == 16)

+				CPUCheckDMA(3, this->which ? 4 : 2);

+			if (!this->count)

 			{

 				// Not filled by DMA, so fill with 16 bytes of silence

 				int reg = this->which ? FIFOB_L : FIFOA_L;

-				for (int n = 4; n--; )

+				for (int n = 8; n--; )

 				{

 					soundEvent(reg, static_cast<uint16_t>(0));

 					soundEvent(reg + 2, static_cast<uint16_t>(0));

@@ -412,7 +415,7 @@ static void apply_muting()

 	if (gb_apu)

 		// APU

 		for (int i = 0; i < 4; ++i)

-			if ((soundEnableFlag >> i) & 1)

+			if (soundEnableFlag >> i & 1)

 				gb_apu->set_output(stereo_buffer->center(), stereo_buffer->left(), stereo_buffer->right(), i);

 			else

 				gb_apu->set_output(nullptr, nullptr, nullptr, i);

@@ -420,7 +423,7 @@ static void apply_muting()

 static void reset_apu()

 {

-	gb_apu->reduce_clicks(soundDeclicking);

+	gb_apu->reduce_clicks(true);

 	gb_apu->reset(gb_apu->mode_agb, true);

 	if (stereo_buffer)

@@ -68,7 +68,7 @@ static Gba_Pcm_Fifo pcm[2];

 static std::unique_ptr<Gb_Apu> gb_apu;

 static std::unique_ptr<Stereo_Buffer> stereo_buffer;

-static Blip_Synth<blip_best_quality, 1> pcm_synth[3]; // 32 kHz, 16 kHz, 8 kHz

+static Blip_Synth<blip_high_quality, 1> pcm_synth[3]; // 32 kHz, 16 kHz, 8 kHz

 static inline blip_time_t blip_time()

 {

@@ -1,275 +1,268 @@

-#include <string.h>

-

+#include <memory>

 #include "Sound.h"

-

 #include "GBA.h"

 #include "Globals.h"

-//#include "../Util.h"

 #include "../common/Port.h"

-

 #include "../apu/Gb_Apu.h"

 #include "../apu/Multi_Buffer.h"

-

 #include "../common/SoundDriver.h"

 extern SoundDriver *systemSoundInit();

 bool soundDeclicking = true;

-#define NR10 0x60

-#define NR11 0x62

-#define NR12 0x63

-#define NR13 0x64

-#define NR14 0x65

-#define NR21 0x68

-#define NR22 0x69

-#define NR23 0x6c

-#define NR24 0x6d

-#define NR30 0x70

-#define NR31 0x72

-#define NR32 0x73

-#define NR33 0x74

-#define NR34 0x75

-#define NR41 0x78

-#define NR42 0x79

-#define NR43 0x7c

-#define NR44 0x7d

-#define NR50 0x80

-#define NR51 0x81

-#define NR52 0x84

-

-SoundDriver * soundDriver = 0;

-

-extern bool stopState;      // TODO: silence sound when true

-

-int const SOUND_CLOCK_TICKS_ = 167772; // 1/100 second

-

-static uint16_t   soundFinalWave [6400];

-long  soundSampleRate    = 44100;

-bool  soundInterpolation = true;

-bool  soundPaused        = true;

-float soundFiltering     = 0.5f;

-int   SOUND_CLOCK_TICKS  = SOUND_CLOCK_TICKS_;

-int   soundTicks         = SOUND_CLOCK_TICKS_;

-

-static float soundVolume     = 1.0f;

-static int soundEnableFlag   = 0x3ff; // emulator channels enabled

-static float soundFiltering_ = -1;

-static float soundVolume_    = -1;

+static const uint32_t NR52 = 0x84;

+

+static std::unique_ptr<SoundDriver> soundDriver;

-void interp_rate() { /* empty for now */ }

+static const int SOUND_CLOCK_TICKS_ = 167772; // 1/100 second

-class Gba_Pcm {

+static uint16_t soundFinalWave[6400];

+static long soundSampleRate = 44100;

+bool soundInterpolation = true;

+static bool soundPaused = true;

+static float soundFiltering = 0.5f; // 0.0 = none, 1.0 = max

+int SOUND_CLOCK_TICKS = SOUND_CLOCK_TICKS_;

+int soundTicks = SOUND_CLOCK_TICKS_;

+

+static float soundVolume = 1.0f;

+static int soundEnableFlag = 0x30f; // emulator channels enabled

+static float soundFiltering_ = -1;

+static float soundVolume_ = -1;

+

+class Gba_Pcm

+{

 public:

 	void init();

-	void apply_control( int idx );

-	void update( int dac );

-	void end_frame( blip_time_t );

+	void apply_control(int idx);

+	void update(int dac);

+	void end_frame(blip_time_t);

 private:

-	Blip_Buffer* output;

+	Blip_Buffer *output;

 	blip_time_t last_time;

 	int last_amp;

 	int shift;

 };

-class Gba_Pcm_Fifo {

+class Gba_Pcm_Fifo

+{

 public:

-	int     which;

+	int which;

 	Gba_Pcm pcm;

-	void write_control( int data );

-	void write_fifo( int data );

-	void timer_overflowed( int which_timer );

+	void write_control(int data);

+	void write_fifo(int data);

+	void timer_overflowed(int which_timer);

-	// public only so save state routines can access it

-	int  readIndex;

-	int  count;

-	int  writeIndex;

-	uint8_t   fifo [32];

-	int  dac;

 private:

-

-	int  timer;

+	int readIndex;

+	int count;

+	int writeIndex;

+	uint8_t fifo[32];

+	int dac;

+	int timer;

 	bool enabled;

 };

-static Gba_Pcm_Fifo     pcm [2];

-static Gb_Apu*          gb_apu;

-static Stereo_Buffer*   stereo_buffer;

+static Gba_Pcm_Fifo pcm[2];

+static std::unique_ptr<Gb_Apu> gb_apu;

+static std::unique_ptr<Stereo_Buffer> stereo_buffer;

-static Blip_Synth<blip_best_quality,1> pcm_synth [3]; // 32 kHz, 16 kHz, 8 kHz

+static Blip_Synth<blip_best_quality, 1> pcm_synth[3]; // 32 kHz, 16 kHz, 8 kHz

 static inline blip_time_t blip_time()

 {

 	return SOUND_CLOCK_TICKS - soundTicks;

 }

-void Gba_Pcm::init()

+inline void Gba_Pcm::init()

 {

-	output    = 0;

-	last_time = 0;

-	last_amp  = 0;

-	shift     = 0;

+	this->output = nullptr;

+	this->last_time = 0;

+	this->last_amp = 0;

+	this->shift = 0;

 }

-void Gba_Pcm::apply_control( int idx )

+void Gba_Pcm::apply_control(int idx)

 {

-	shift = ~ioMem [SGCNT0_H] >> (2 + idx) & 1;

+	this->shift = (~ioMem[SGCNT0_H] >> (2 + idx)) & 1;

 	int ch = 0;

-	if ( (soundEnableFlag >> idx & 0x100) && (ioMem [NR52] & 0x80) )

-		ch = ioMem [SGCNT0_H+1] >> (idx * 4) & 3;

+	if (((soundEnableFlag >> idx) & 0x100) && (ioMem[NR52] & 0x80))

+		ch = (ioMem[SGCNT0_H + 1] >> (idx * 4)) & 3;

-	Blip_Buffer* out = 0;

-	switch ( ch )

+	Blip_Buffer *out = nullptr;

+	switch (ch)

 	{

-	case 1: out = stereo_buffer->right();  break;

-	case 2: out = stereo_buffer->left();   break;

-	case 3: out = stereo_buffer->center(); break;

+		case 1:

+			out = stereo_buffer->right();

+			break;

+		case 2:

+			out = stereo_buffer->left();

+			break;

+		case 3:

+			out = stereo_buffer->center();

 	}

-	if ( output != out )

+	if (this->output != out)

 	{

-		if ( output )

+		if (this->output)

 		{

-			output->set_modified();

-			pcm_synth [0].offset( blip_time(), -last_amp, output );

+			blip_time_t time = blip_time();

+

+			this->output->set_modified();

+

+			int filter = 0;

+			if (soundInterpolation)

+			{

+				// base filtering on how long since last sample was output

+				int period = time - this->last_time;

+

+				int idx = period / 512;

+				if (idx >= 3)

+					idx = 3;

+

+				static const int filters[] = { 0, 0, 1, 2 };

+				filter = filters[idx];

+			}

+

+			pcm_synth[filter].offset(time, -this->last_amp, this->output);

 		}

-		last_amp = 0;

-		output = out;

+		this->last_amp = 0;

+		this->output = out;

 	}

 }

-void Gba_Pcm::end_frame( blip_time_t time )

+inline void Gba_Pcm::end_frame(blip_time_t time)

 {

-	last_time -= time;

-	if ( last_time < -2048 )

-		last_time = -2048;

+	this->last_time -= time;

+	if (this->last_time < -2048)

+		this->last_time = -2048;

-	if ( output )

-		output->set_modified();

+	if (this->output)

+		this->output->set_modified();

 }

-void Gba_Pcm::update( int dac )

+void Gba_Pcm::update(int dac)

 {

-	if ( output )

+	if (this->output)

 	{

 		blip_time_t time = blip_time();

-		dac = (int8_t) dac >> shift;

-		int delta = dac - last_amp;

-		if ( delta )

+		dac = static_cast<int8_t>(dac) >> this->shift;

+		int delta = dac - this->last_amp;

+		if (delta)

 		{

-			last_amp = dac;

+			this->last_amp = dac;

 			int filter = 0;

-			if ( soundInterpolation )

+			if (soundInterpolation)

 			{

 				// base filtering on how long since last sample was output

-				int period = time - last_time;

+				int period = time - this->last_time;

-				int idx = (unsigned) period / 512;

-				if ( idx >= 3 )

+				int idx = period / 512;

+				if (idx >= 3)

 					idx = 3;

-				static int const filters [4] = { 0, 0, 1, 2 };

-				filter = filters [idx];

+				static const int filters[] = { 0, 0, 1, 2 };

+				filter = filters[idx];

 			}

-			pcm_synth [filter].offset( time, delta, output );

+			pcm_synth[filter].offset(time, delta, this->output);

 		}

-		last_time = time;

+		this->last_time = time;

 	}

 }

-void Gba_Pcm_Fifo::timer_overflowed( int which_timer )

+void Gba_Pcm_Fifo::timer_overflowed(int which_timer)

 {

-	if ( which_timer == timer && enabled )

+	if (which_timer == this->timer && this->enabled)

 	{

-		if ( count <= 16 )

+		if (this->count <= 16)

 		{

 			// Need to fill FIFO

-			CPUCheckDMA( 3, which ? 4 : 2 );

-			if ( count <= 16 )

+			CPUCheckDMA(3, this->which ? 4 : 2);

+			if (this->count <= 16)

 			{

 				// Not filled by DMA, so fill with 16 bytes of silence

-				int reg = which ? FIFOB_L : FIFOA_L;

-				for ( int n = 4; n--; )

+				int reg = this->which ? FIFOB_L : FIFOA_L;

+				for (int n = 4; n--; )

 				{

-					soundEvent(reg  , (uint16_t)0);

-					soundEvent(reg+2, (uint16_t)0);

+					soundEvent(reg, static_cast<uint16_t>(0));

+					soundEvent(reg + 2, static_cast<uint16_t>(0));

 				}

 			}

 		}

 		// Read next sample from FIFO

-		count--;

-		dac = fifo [readIndex];

-		readIndex = (readIndex + 1) & 31;

-		pcm.update( dac );

+		--this->count;

+		this->dac = this->fifo[this->readIndex];

+		this->readIndex = (this->readIndex + 1) & 31;

+		this->pcm.update(this->dac);

 	}

 }

-void Gba_Pcm_Fifo::write_control( int data )

+void Gba_Pcm_Fifo::write_control(int data)

 {

-	enabled = (data & 0x0300) ? true : false;

-	timer   = (data & 0x0400) ? 1 : 0;

+	this->enabled = !!(data & 0x0300);

+	this->timer = !!(data & 0x0400);

-	if ( data & 0x0800 )

+	if (data & 0x0800)

 	{

 		// Reset

-		writeIndex = 0;

-		readIndex  = 0;

-		count      = 0;

-		dac        = 0;

-		memset( fifo, 0, sizeof fifo );

+		this->writeIndex = 0;

+		this->readIndex = 0;

+		this->count = 0;

+		this->dac = 0;

+		memset(this->fifo, 0, sizeof(this->fifo));

 	}

-	pcm.apply_control( which );

-	pcm.update( dac );

+	this->pcm.apply_control(this->which);

+	this->pcm.update(this->dac);

 }

-void Gba_Pcm_Fifo::write_fifo( int data )

+inline void Gba_Pcm_Fifo::write_fifo(int data)

 {

-	fifo [writeIndex  ] = data & 0xFF;

-	fifo [writeIndex+1] = data >> 8;

-	count += 2;

-	writeIndex = (writeIndex + 2) & 31;

+	this->fifo[this->writeIndex] = data & 0xFF;

+	this->fifo[this->writeIndex + 1] = data >> 8;

+	this->count += 2;

+	this->writeIndex = (this->writeIndex + 2) & 31;

 }

 static void apply_control()

 {

-	pcm [0].pcm.apply_control( 0 );

-	pcm [1].pcm.apply_control( 1 );

+	pcm[0].pcm.apply_control(0);

+	pcm[1].pcm.apply_control(1);

 }

-static int gba_to_gb_sound( int addr )

+static int gba_to_gb_sound(int addr)

 {

-	static const int table [0x40] =

+	static const int table[] =

 	{

-		0xFF10,     0,0xFF11,0xFF12,0xFF13,0xFF14,     0,     0,

-		0xFF16,0xFF17,     0,     0,0xFF18,0xFF19,     0,     0,

-		0xFF1A,     0,0xFF1B,0xFF1C,0xFF1D,0xFF1E,     0,     0,

-		0xFF20,0xFF21,     0,     0,0xFF22,0xFF23,     0,     0,

-		0xFF24,0xFF25,     0,     0,0xFF26,     0,     0,     0,

-		     0,     0,     0,     0,     0,     0,     0,     0,

-		0xFF30,0xFF31,0xFF32,0xFF33,0xFF34,0xFF35,0xFF36,0xFF37,

-		0xFF38,0xFF39,0xFF3A,0xFF3B,0xFF3C,0xFF3D,0xFF3E,0xFF3F,

+		0xFF10, 0, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0, 0,

+		0xFF16, 0xFF17, 0, 0, 0xFF18, 0xFF19, 0, 0,

+		0xFF1A, 0, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0, 0,

+		0xFF20, 0xFF21, 0, 0, 0xFF22, 0xFF23, 0, 0,

+		0xFF24, 0xFF25, 0, 0, 0xFF26, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0,

+		0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37,

+		0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F,

 	};

-	if ( addr >= 0x60 && addr < 0xA0 )

-		return table [addr - 0x60];

+	if (addr >= 0x60 && addr < 0xA0)

+		return table[addr - 0x60];

 	return 0;

 }

 void soundEvent(uint32_t address, uint8_t data)

 {

-	int gb_addr = gba_to_gb_sound( address );

-	if ( gb_addr )

+	int gb_addr = gba_to_gb_sound(address);

+	if (gb_addr)

 	{

 		ioMem[address] = data;

-		gb_apu->write_register( blip_time(), gb_addr, data );

+		gb_apu->write_register(blip_time(), gb_addr, data);

-		if ( address == NR52 )

+		if (address == NR52)

 			apply_control();

 	}

@@ -278,102 +271,98 @@ void soundEvent(uint32_t address, uint8_t data)

 	// TODO: what about byte writes to SGCNT0_H etc.?

 }

-static void apply_volume( bool apu_only = false )

+static void apply_volume(bool apu_only = false)

 {

-	if ( !apu_only )

+	if (!apu_only)

 		soundVolume_ = soundVolume;

-	if ( gb_apu )

+	if (gb_apu)

 	{

-		static float const apu_vols [4] = { 0.25, 0.5, 1, 0.25 };

-		gb_apu->volume( soundVolume_ * apu_vols [ioMem [SGCNT0_H] & 3] );

+		static const float apu_vols[] = { 0.25, 0.5, 1, 0.25 };

+		gb_apu->volume(soundVolume_ * apu_vols[ioMem[SGCNT0_H] & 3]);

 	}

-	if ( !apu_only )

-	{

-		for ( int i = 0; i < 3; i++ )

-			pcm_synth [i].volume( 0.66 / 256 * soundVolume_ );

-	}

+	if (!apu_only)

+		for (int i = 0; i < 3; ++i)

+			pcm_synth[i].volume(0.66 / 256 * soundVolume_);

 }

-static void write_SGCNT0_H( int data )

+static void write_SGCNT0_H(int data)

 {

-	WRITE16LE( &ioMem [SGCNT0_H], data & 0x770F );

-	pcm [0].write_control( data      );

-	pcm [1].write_control( data >> 4 );

-	apply_volume( true );

+	WRITE16LE(&ioMem[SGCNT0_H], data & 0x770F);

+	pcm[0].write_control(data);

+	pcm[1].write_control(data >> 4);

+	apply_volume(true);

 }

 void soundEvent(uint32_t address, uint16_t data)

 {

-	switch ( address )

+	switch (address)

 	{

-	case SGCNT0_H:

-		write_SGCNT0_H( data );

-		break;

-

-	case FIFOA_L:

-	case FIFOA_H:

-		pcm [0].write_fifo( data );

-		WRITE16LE( &ioMem[address], data );

-		break;

-

-	case FIFOB_L:

-	case FIFOB_H:

-		pcm [1].write_fifo( data );

-		WRITE16LE( &ioMem[address], data );

-		break;

-

-	case 0x88:

-		data &= 0xC3FF;

-		WRITE16LE( &ioMem[address], data );

-		break;

-

-	default:

-		soundEvent( address & ~1, (uint8_t) (data     ) ); // even

-		soundEvent( address |  1, (uint8_t) (data >> 8) ); // odd

-		break;

+		case SGCNT0_H:

+			write_SGCNT0_H(data);

+			break;

+

+		case FIFOA_L:

+		case FIFOA_H:

+			pcm[0].write_fifo(data);

+			WRITE16LE(&ioMem[address], data);

+			break;

+

+		case FIFOB_L:

+		case FIFOB_H:

+			pcm[1].write_fifo(data);

+			WRITE16LE(&ioMem[address], data);

+			break;

+

+		case 0x88:

+			data &= 0xC3FF;

+			WRITE16LE(&ioMem[address], data);

+			break;

+

+		default:

+			soundEvent(address & ~1, static_cast<uint8_t>(data)); // even

+			soundEvent(address | 1, static_cast<uint8_t>(data >> 8)); // odd

 	}

 }

 void soundTimerOverflow(int timer)

 {

-	pcm [0].timer_overflowed( timer );

-	pcm [1].timer_overflowed( timer );

+	pcm[0].timer_overflowed(timer);

+	pcm[1].timer_overflowed(timer);

 }

-static void end_frame( blip_time_t time )

+static void end_frame(blip_time_t time)

 {

-	pcm [0].pcm.end_frame( time );

-	pcm [1].pcm.end_frame( time );

+	pcm[0].pcm.end_frame(time);

+	pcm[1].pcm.end_frame(time);

-	gb_apu       ->end_frame( time );

-	stereo_buffer->end_frame( time );

+	gb_apu->end_frame(time);

+	stereo_buffer->end_frame(time);

 }

-void flush_samples(Multi_Buffer * buffer)

+void flush_samples(Multi_Buffer *buffer)

 {

 	// We want to write the data frame by frame to support legacy audio drivers

 	// 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;

+	int soundBufferLen = (soundSampleRate / 60) * 4;

 	// soundBufferLen should have a whole number of sample pairs

-	assert( soundBufferLen % (2 * sizeof *soundFinalWave) == 0 );

+	assert(!(soundBufferLen % (2 * sizeof(*soundFinalWave))));

 	// number of samples in output buffer

-	int const out_buf_size = soundBufferLen / sizeof *soundFinalWave;

+	int out_buf_size = soundBufferLen / sizeof(*soundFinalWave);

 	// Keep filling and writing soundFinalWave until it can't be fully filled

-	while ( buffer->samples_avail() >= out_buf_size )

+	while (buffer->samples_avail() >= out_buf_size)

 	{

-		buffer->read_samples( (blip_sample_t*) soundFinalWave, out_buf_size );

-		if(soundPaused)

+		buffer->read_samples(reinterpret_cast<blip_sample_t *>(soundFinalWave), out_buf_size);

+		if (soundPaused)

 			soundResume();

 		soundDriver->write(soundFinalWave, soundBufferLen);

-		//systemOnWriteDataToSoundBuffer(soundFinalWave, soundBufferLen);

 	}

 }

@@ -381,31 +370,31 @@ static void apply_filtering()

 {

 	soundFiltering_ = soundFiltering;

-	int const base_freq = (int) (32768 - soundFiltering_ * 16384);

-	int const nyquist = stereo_buffer->sample_rate() / 2;

+	int base_freq = static_cast<int>(32768 - soundFiltering_ * 16384);

+	int nyquist = stereo_buffer->sample_rate() / 2;

-	for ( int i = 0; i < 3; i++ )

+	for (int i = 0; i < 3; ++i)

 	{

 		int cutoff = base_freq >> i;

-		if ( cutoff > nyquist )

+		if (cutoff > nyquist)

 			cutoff = nyquist;

-		pcm_synth [i].treble_eq( blip_eq_t( 0, 0, stereo_buffer->sample_rate(), cutoff ) );

+		pcm_synth[i].treble_eq(blip_eq_t(0, 0, stereo_buffer->sample_rate(), cutoff));

 	}