@@ -404,7 +404,7 @@ template<class ResamplerClass> bool S9xInitSound(int buffer_ms, int lag_ms)

 		return false;

 	/* The resampler and spc unit use samples (16-bit short) as

-	/*   arguments. Use 2x in the resampler for buffer leveling with SoundSync */

+	 *   arguments. Use 2x in the resampler for buffer leveling with SoundSync */

 	spc::resampler.reset(new ResamplerClass(spc::buffer_size >> (Settings.SoundSync ? 0 : 1)));

 	if (!spc::resampler)

 	{

@@ -235,11 +235,10 @@ namespace spc

 static void EightBitize(uint8_t *buffer, int sample_count)

 {

-	uint8_t *buf8 = buffer;

 	int16_t *buf16 = reinterpret_cast<int16_t *>(buffer);

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

-		buf8[i] = static_cast<uint8_t>((buf16[i] / 256) + 128);

+		buffer[i] = static_cast<uint8_t>((buf16[i] / 256) + 128);

 }

 static void DeStereo(uint8_t *buffer, int sample_count)

@@ -287,7 +286,7 @@ bool S9xMixSamples(uint8_t *buffer, int sample_count)

 	if (Settings.Mute)

 	{

-		std::fill(&dest[0], &dest[sample_count << 1], 0);

+		std::fill_n(&dest[0], sample_count << 1, 0);

 		spc::resampler->clear();

 		return false;

@@ -302,7 +301,7 @@ bool S9xMixSamples(uint8_t *buffer, int sample_count)

 		}

 		else

 		{

-			std::fill(&buffer[0], &buffer[(sample_count << (Settings.SixteenBitSound ? 1 : 0)) >> (Settings.Stereo ? 0 : 1)], Settings.SixteenBitSound ? 0 : 128);

+			std::fill_n(&buffer[0], (sample_count << (Settings.SixteenBitSound ? 1 : 0)) >> (Settings.Stereo ? 0 : 1), Settings.SixteenBitSound ? 0 : 128);

 			if (!spc::lag)

 				spc::lag = spc::lag_master;

@@ -324,7 +323,7 @@ bool S9xMixSamples(uint8_t *buffer, int sample_count)

 		if (!Settings.SixteenBitSound)

 			EightBitize(dest, sample_count);

-		std::copy(&dest[0], &dest[sample_count << (Settings.SixteenBitSound ? 1 : 0)], &buffer[0]);

+		std::copy_n(&dest[0], sample_count << (Settings.SixteenBitSound ? 1 : 0), &buffer[0]);

 	}

 	return true;

@@ -349,12 +348,7 @@ void S9xFinalizeSamples()

 		}

 	}

-	if (!Settings.SoundSync || Settings.TurboMode || Settings.Mute)

-		spc::sound_in_sync = true;

-	else if (spc::resampler->space_empty() >= spc::resampler->space_filled())

-		spc::sound_in_sync = true;

-	else

-		spc::sound_in_sync = false;

+	spc::sound_in_sync = !Settings.SoundSync || Settings.TurboMode || Settings.Mute || spc::resampler->space_empty() >= spc::resampler->space_filled();

 	spc_core->set_output(reinterpret_cast<SNES_SPC::sample_t *>(spc::landing_buffer.get()), spc::buffer_size >> 1);

 }

@@ -175,11 +175,8 @@

   Nintendo Co., Limited and its subsidiary companies.

  ***********************************************************************************/

-

-#include <math.h>

+#include <memory>

 #include "apu.h"

-//#include "snapshot.h"

-//#include "display.h"

 #include "linear_resampler.h"

 #include "hermite_resampler.h"

 #include "bspline_resampler.h"

@@ -189,18 +186,17 @@

 bool SincResampler::initializedLUTs = false;

 double SincResampler::sinc_lut[SincResampler::SINC_SAMPLES + 1];

-#define APU_DEFAULT_INPUT_RATE		32000

-#define APU_MINIMUM_SAMPLE_COUNT	512

-#define APU_MINIMUM_SAMPLE_BLOCK	128

-#define APU_NUMERATOR_NTSC			15664

-#define APU_DENOMINATOR_NTSC		328125

-#define APU_NUMERATOR_PAL			34176

-#define APU_DENOMINATOR_PAL			709379

-#define APU_DEFAULT_RESAMPLER		HermiteResampler

+static const uint32_t APU_DEFAULT_INPUT_RATE = 32000;

+static const int APU_MINIMUM_SAMPLE_COUNT = 512;

+static const int APU_MINIMUM_SAMPLE_BLOCK = 128;

+static const uint32_t APU_NUMERATOR_NTSC = 15664;

+static const uint32_t APU_DENOMINATOR_NTSC = 328125;

+static const uint32_t APU_NUMERATOR_PAL = 34176;

+static const uint32_t APU_DENOMINATOR_PAL = 709379;

-SNES_SPC	*spc_core = NULL;

+static std::unique_ptr<SNES_SPC> spc_core;

-static uint8_t APUROM[64] =

+static const uint8_t APUROM[] =

 {

 	0xCD, 0xEF, 0xBD, 0xE8, 0x00, 0xC6, 0x1D, 0xD0,

 	0xFC, 0x8F, 0xAA, 0xF4, 0x8F, 0xBB, 0xF5, 0x78,

@@ -214,81 +210,62 @@ static uint8_t APUROM[64] =

 namespace spc

 {

-	static apu_callback	sa_callback     = NULL;

-	static void			*extra_data     = NULL;

-

-	static bool		sound_in_sync   = true;

-	static bool		sound_enabled   = false;

+	static bool sound_in_sync = true;

+	static bool sound_enabled = false;

-	static int			buffer_size;

-	static int			lag_master      = 0;

-	static int			lag             = 0;

+	static int buffer_size;

+	static int lag_master = 0;

+	static int lag = 0;

-	static uint8_t		*landing_buffer = NULL;

-	static uint8_t		*shrink_buffer  = NULL;

+	static std::unique_ptr<uint8_t[]> landing_buffer;

+	static std::unique_ptr<uint8_t[]> shrink_buffer;

-	static Resampler	*resampler      = NULL;

+	static std::unique_ptr<Resampler> resampler;

-	static int32_t		reference_time;

-	static uint32_t		remainder;

+	static int32_t reference_time;

+	static uint32_t remainder;

-	static const int	timing_hack_numerator   = SNES_SPC::tempo_unit;

-	static int			timing_hack_denominator = SNES_SPC::tempo_unit;

+	static const int timing_hack_numerator = SNES_SPC::tempo_unit;

+	static int timing_hack_denominator = SNES_SPC::tempo_unit;

 	/* Set these to NTSC for now. Will change to PAL in S9xAPUTimingSetSpeedup

 	   if necessary on game load. */

-	static uint32_t		ratio_numerator = APU_NUMERATOR_NTSC;

-	static uint32_t		ratio_denominator = APU_DENOMINATOR_NTSC;

+	static uint32_t ratio_numerator = APU_NUMERATOR_NTSC;

+	static uint32_t ratio_denominator = APU_DENOMINATOR_NTSC;

 }

-static void EightBitize (uint8_t *, int);

-static void DeStereo (uint8_t *, int);

-static void ReverseStereo (uint8_t *, int);

-static void UpdatePlaybackRate();

-static void from_apu_to_state (uint8_t **, void *, size_t);

-static void to_apu_from_state (uint8_t **, void *, size_t);

-//static void SPCSnapshotCallback();

-static inline int S9xAPUGetClock (int32_t);

-static inline int S9xAPUGetClockRemainder (int32_t);

-

-

-static void EightBitize (uint8_t *buffer, int sample_count)

+static void EightBitize(uint8_t *buffer, int sample_count)

 {

-	uint8_t	*buf8  = (uint8_t *) buffer;

-	int16_t	*buf16 = (int16_t *) buffer;

+	uint8_t *buf8 = buffer;

+	int16_t *buf16 = reinterpret_cast<int16_t *>(buffer);

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

-		buf8[i] = (uint8_t) ((buf16[i] / 256) + 128);

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

+		buf8[i] = static_cast<uint8_t>((buf16[i] / 256) + 128);

 }

-static void DeStereo (uint8_t *buffer, int sample_count)

+static void DeStereo(uint8_t *buffer, int sample_count)

 {

-	int16_t	*buf = (int16_t *) buffer;

-	int32_t	s1, s2;

+	int16_t *buf = reinterpret_cast<int16_t *>(buffer);

-	for (int i = 0; i < sample_count >> 1; i++)

+	for (int i = 0; i < sample_count >> 1; ++i)

 	{

-		s1 = (int32_t) buf[2 * i];

-		s2 = (int32_t) buf[2 * i + 1];

-		buf[i] = (int16_t) ((s1 + s2) >> 1);

+		int32_t s1 = static_cast<int32_t>(buf[2 * i]);

+		int32_t s2 = static_cast<int32_t>(buf[2 * i + 1]);

+		buf[i] = static_cast<int16_t>((s1 + s2) >> 1);

 	}

 }

-static void ReverseStereo (uint8_t *src_buffer, int sample_count)

+static void ReverseStereo(uint8_t *src_buffer, int sample_count)

 {

-	int16_t	*buffer = (int16_t *) src_buffer;

+	int16_t *buffer = reinterpret_cast<int16_t *>(src_buffer);

 	for (int i = 0; i < sample_count; i += 2)

-	{

-		buffer[i + 1] ^= buffer[i];

-		buffer[i] ^= buffer[i + 1];

-		buffer[i + 1] ^= buffer[i];

-	}

+		std::swap(buffer[i], buffer[i + 1]);

 }

-bool S9xMixSamples (uint8_t *buffer, int sample_count)

+bool S9xMixSamples(uint8_t *buffer, int sample_count)

 {

-	static int	shrink_buffer_size = -1;

-	uint8_t		*dest;

+	static int shrink_buffer_size = -1;

+	uint8_t *dest;

 	if (!Settings.SixteenBitSound || !Settings.Stereo)

 	{

@@ -299,35 +276,34 @@ bool S9xMixSamples (uint8_t *buffer, int sample_count)

 		/* We still have to generate 16-bit samples for bit-dropping, too */

 		if (shrink_buffer_size < (sample_count << 1))

 		{

-			delete[] spc::shrink_buffer;

-			spc::shrink_buffer = new uint8_t[sample_count << 1];

+			spc::shrink_buffer.reset(new uint8_t[sample_count << 1]);

 			shrink_buffer_size = sample_count << 1;

 		}

-		dest = spc::shrink_buffer;

+		dest = spc::shrink_buffer.get();

 	}

 	else

 		dest = buffer;

 	if (Settings.Mute)

 	{

-		memset(dest, 0, sample_count << 1);

+		std::fill(&dest[0], &dest[sample_count << 1], 0);

 		spc::resampler->clear();

 		return false;

 	}

 	else

 	{

-		if (spc::resampler->avail() >= (sample_count + spc::lag))

+		if (spc::resampler->avail() >= sample_count + spc::lag)

 		{

-			spc::resampler->read((short *) dest, sample_count);

+			spc::resampler->read(reinterpret_cast<short *>(dest), sample_count);

 			if (spc::lag == spc::lag_master)

 				spc::lag = 0;

 		}

 		else

 		{

-			memset(buffer, (Settings.SixteenBitSound ? 0 : 128), (sample_count << (Settings.SixteenBitSound ? 1 : 0)) >> (Settings.Stereo ? 0 : 1));

-			if (spc::lag == 0)

+			std::fill(&buffer[0], &buffer[(sample_count << (Settings.SixteenBitSound ? 1 : 0)) >> (Settings.Stereo ? 0 : 1)], Settings.SixteenBitSound ? 0 : 128);

+			if (!spc::lag)

 				spc::lag = spc::lag_master;

 			return false;

@@ -348,7 +324,7 @@ bool S9xMixSamples (uint8_t *buffer, int sample_count)

 		if (!Settings.SixteenBitSound)

 			EightBitize(dest, sample_count);

-		memcpy(buffer, dest, (sample_count << (Settings.SixteenBitSound ? 1 : 0)));

+		std::copy(&dest[0], &dest[sample_count << (Settings.SixteenBitSound ? 1 : 0)], &buffer[0]);

 	}

 	return true;

@@ -363,7 +339,7 @@ void S9xFinalizeSamples()

 {

 	if (!Settings.Mute)

 	{

-		if (!spc::resampler->push((short *) spc::landing_buffer, spc_core->sample_count()))

+		if (!spc::resampler->push(reinterpret_cast<short *>(spc::landing_buffer.get()), spc_core->sample_count()))

 		{

 			/* We weren't able to process the entire buffer. Potential overrun. */

 			spc::sound_in_sync = false;

@@ -375,27 +351,17 @@ void S9xFinalizeSamples()

 	if (!Settings.SoundSync || Settings.TurboMode || Settings.Mute)

 		spc::sound_in_sync = true;

-	else

-	if (spc::resampler->space_empty() >= spc::resampler->space_filled())

+	else if (spc::resampler->space_empty() >= spc::resampler->space_filled())

 		spc::sound_in_sync = true;

 	else

 		spc::sound_in_sync = false;

-	spc_core->set_output((SNES_SPC::sample_t *) spc::landing_buffer, spc::buffer_size >> 1);

+	spc_core->set_output(reinterpret_cast<SNES_SPC::sample_t *>(spc::landing_buffer.get()), spc::buffer_size >> 1);

 }

 void S9xLandSamples()

 {

-	if (spc::sa_callback != NULL)

-		spc::sa_callback(spc::extra_data);

-	else

-		S9xFinalizeSamples();

-}

-

-void S9xClearSamples()

-{

-	spc::resampler->clear();

-	spc::lag = spc::lag_master;

+	S9xFinalizeSamples();

 }

 bool S9xSyncSound()

@@ -408,28 +374,22 @@ bool S9xSyncSound()

 	return spc::sound_in_sync;

 }

-void S9xSetSamplesAvailableCallback (apu_callback callback, void *data)

-{

-	spc::sa_callback = callback;

-	spc::extra_data  = data;

-}

-

 static void UpdatePlaybackRate()

 {

-	if (Settings.SoundInputRate == 0)

+	if (!Settings.SoundInputRate)

 		Settings.SoundInputRate = APU_DEFAULT_INPUT_RATE;

-	double time_ratio = (double) Settings.SoundInputRate * spc::timing_hack_numerator / (Settings.SoundPlaybackRate * spc::timing_hack_denominator);

+	double time_ratio = static_cast<double>(Settings.SoundInputRate) * spc::timing_hack_numerator / (Settings.SoundPlaybackRate * spc::timing_hack_denominator);

 	spc::resampler->time_ratio(time_ratio);

 }

-template<class ResamplerClass> bool S9xInitSound (int buffer_ms, int lag_ms)

+template<class ResamplerClass> bool S9xInitSound(int buffer_ms, int lag_ms)

 {

 	// buffer_ms : buffer size given in millisecond

 	// lag_ms    : allowable time-lag given in millisecond

-	int	sample_count     = buffer_ms * 32000 / 1000;

-	int	lag_sample_count = lag_ms    * 32000 / 1000;

+	int sample_count = buffer_ms * 32000 / 1000;

+	int lag_sample_count = lag_ms * 32000 / 1000;

 	spc::lag_master = lag_sample_count;

 	if (Settings.Stereo)

@@ -445,32 +405,20 @@ template<class ResamplerClass> bool S9xInitSound (int buffer_ms, int lag_ms)

 	if (Settings.SixteenBitSound)

 		spc::buffer_size <<= 1;

-	printf("Sound buffer size: %d (%d samples)\n", spc::buffer_size, sample_count);

-

-	if (spc::landing_buffer)

-		delete[] spc::landing_buffer;

-	spc::landing_buffer = new uint8_t[spc::buffer_size * 2];

+	spc::landing_buffer.reset(new uint8_t[spc::buffer_size * 2]);

 	if (!spc::landing_buffer)

 		return false;

 	/* The resampler and spc unit use samples (16-bit short) as

 	/*   arguments. Use 2x in the resampler for buffer leveling with SoundSync */

-	/*if (!spc::resampler)

-	{*/

-	if (spc::resampler)

-		delete spc::resampler;

-

-		spc::resampler = new ResamplerClass(spc::buffer_size >> (Settings.SoundSync ? 0 : 1));

-		if (!spc::resampler)

-		{

-			delete[] spc::landing_buffer;

-			return false;

-		}

-	/*}

-	else

-		spc::resampler->resize(spc::buffer_size >> (Settings.SoundSync ? 0 : 1));*/

+	spc::resampler.reset(new ResamplerClass(spc::buffer_size >> (Settings.SoundSync ? 0 : 1)));

+	if (!spc::resampler)

+	{

+		spc::landing_buffer.reset();

+		return false;

+	}

-	spc_core->set_output((SNES_SPC::sample_t *) spc::landing_buffer, spc::buffer_size >> 1);

+	spc_core->set_output(reinterpret_cast<SNES_SPC::sample_t *>(spc::landing_buffer.get()), spc::buffer_size >> 1);

 	UpdatePlaybackRate();

@@ -485,97 +433,63 @@ template bool S9xInitSound<BsplineResampler>(int, int);

 template bool S9xInitSound<OsculatingResampler>(int, int);

 template bool S9xInitSound<SincResampler>(int, int);

-void S9xSetSoundControl (uint8_t voice_switch)

+void S9xSetSoundControl(uint8_t voice_switch)

 {

-	spc_core->dsp_set_stereo_switch(voice_switch << 8 | voice_switch);

+	spc_core->dsp_set_stereo_switch((voice_switch << 8) | voice_switch);

 }

-void S9xSetSoundMute (bool mute)

+void S9xSetSoundMute(bool mute)

 {

 	Settings.Mute = mute;

 	if (!spc::sound_enabled)

 		Settings.Mute = true;

 }

-void S9xDumpSPCSnapshot()

-{

-	spc_core->dsp_dump_spc_snapshot();

-}

-

-/*static void SPCSnapshotCallback()

-{

-	S9xSPCDump(S9xGetFilenameInc((".spc"), SPC_DIR));

-	printf("Dumped key-on triggered spc snapshot.\n");

-}*/

-

 bool S9xInitAPU()

 {

-	spc_core = new SNES_SPC;

+	spc_core.reset(new SNES_SPC);

 	if (!spc_core)

 		return false;

 	spc_core->init();

 	spc_core->init_rom(APUROM);

-	//spc_core->dsp_set_spc_snapshot_callback(SPCSnapshotCallback);

-

-	spc::landing_buffer = NULL;

-	spc::shrink_buffer  = NULL;

-	spc::resampler      = NULL;

+	spc::landing_buffer.reset();

+	spc::shrink_buffer.reset();

+	spc::resampler.reset();

 	return true;

 }

 void S9xDeinitAPU()

 {

-	if (spc_core)

-	{

-		delete spc_core;

-		spc_core = NULL;

-	}

-

-	if (spc::resampler)

-	{

-		delete spc::resampler;

-		spc::resampler = NULL;

-	}

-

-	if (spc::landing_buffer)

-	{

-		delete[] spc::landing_buffer;

-		spc::landing_buffer = NULL;

-	}

-

-	if (spc::shrink_buffer)

-	{

-		delete[] spc::shrink_buffer;

-		spc::shrink_buffer = NULL;

-	}

+	spc_core.reset();

+	spc::resampler.reset();

+	spc::landing_buffer.reset();

+	spc::shrink_buffer.reset();

 }

-static inline int S9xAPUGetClock (int32_t cpucycles)

+static inline int S9xAPUGetClock(int32_t cpucycles)

 {

-	return (spc::ratio_numerator * (cpucycles - spc::reference_time) + spc::remainder) /

-			spc::ratio_denominator;

+	return (spc::ratio_numerator * (cpucycles - spc::reference_time) + spc::remainder) / spc::ratio_denominator;

 }

-static inline int S9xAPUGetClockRemainder (int32_t cpucycles)

+static inline int S9xAPUGetClockRemainder(int32_t cpucycles)

 {

-	return (spc::ratio_numerator * (cpucycles - spc::reference_time) + spc::remainder) %

-			spc::ratio_denominator;

+	return (spc::ratio_numerator * (cpucycles - spc::reference_time) + spc::remainder) % spc::ratio_denominator;

 }

-uint8_t S9xAPUReadPort (int port)

+uint8_t S9xAPUReadPort(int port)

 {

-	return (uint8_t) spc_core->read_port(S9xAPUGetClock(CPU.Cycles), port);

+	return static_cast<uint8_t>(spc_core->read_port(S9xAPUGetClock(CPU.Cycles), port));

 }

-void S9xAPUWritePort (int port, uint8_t byte)

+void S9xAPUWritePort(int port, uint8_t byte)

 {

 	spc_core->write_port(S9xAPUGetClock(CPU.Cycles), port, byte);

 }

-void S9xAPUSetReferenceTime (int32_t cpucycles)

+void S9xAPUSetReferenceTime(int32_t cpucycles)

 {

 	spc::reference_time = cpucycles;

 }

@@ -598,26 +512,19 @@ void S9xAPUEndScanline()

 		S9xLandSamples();

 }

-void S9xAPUTimingSetSpeedup (int ticks)

+void S9xAPUTimingSetSpeedup(int ticks)

 {

-	if (ticks != 0)

-		printf("APU speedup hack: %d\n", ticks);

-

 	spc::timing_hack_denominator = SNES_SPC::tempo_unit - ticks;

 	spc_core->set_tempo(spc::timing_hack_denominator);

 	spc::ratio_numerator = Settings.PAL ? APU_NUMERATOR_PAL : APU_NUMERATOR_NTSC;

-	spc::ratio_denominator = Settings.PAL ? APU_DENOMINATOR_PAL : APU_DENOMINATOR_NTSC;

-	spc::ratio_denominator = spc::ratio_denominator * spc::timing_hack_denominator / spc::timing_hack_numerator;

+	spc::ratio_denominator = (Settings.PAL ? APU_DENOMINATOR_PAL : APU_DENOMINATOR_NTSC) * spc::timing_hack_denominator / spc::timing_hack_numerator;

 	UpdatePlaybackRate();

 }

-void S9xAPUAllowTimeOverflow (bool allow)

+void S9xAPUAllowTimeOverflow(bool allow)

 {

-	if (allow)

-		printf("APU time overflow allowed\n");

-

 	spc_core->spc_allow_time_overflow(allow);

 }

@@ -626,53 +533,7 @@ void S9xResetAPU()

 	spc::reference_time = 0;

 	spc::remainder = 0;

 	spc_core->reset();

-	spc_core->set_output((SNES_SPC::sample_t *) spc::landing_buffer, spc::buffer_size >> 1);

-

-	spc::resampler->clear();

-}

-

-void S9xSoftResetAPU()

-{

-	spc::reference_time = 0;

-	spc::remainder = 0;

-	spc_core->soft_reset();

-	spc_core->set_output((SNES_SPC::sample_t *) spc::landing_buffer, spc::buffer_size >> 1);

+	spc_core->set_output(reinterpret_cast<SNES_SPC::sample_t *>(spc::landing_buffer.get()), spc::buffer_size >> 1);

 	spc::resampler->clear();

 }

-

-static void from_apu_to_state (uint8_t **buf, void *var, size_t size)

-{

-	memcpy(*buf, var, size);

-	*buf += size;

-}

-

-static void to_apu_from_state (uint8_t **buf, void *var, size_t size)

-{

-	memcpy(var, *buf, size);

-	*buf += size;

-}

-

-void S9xAPUSaveState (uint8_t *block)

-{

-	uint8_t	*ptr = block;

-

-	spc_core->copy_state(&ptr, from_apu_to_state);

-

-	SET_LE32(ptr, spc::reference_time);

-	ptr += sizeof(int32_t);

-	SET_LE32(ptr, spc::remainder);

-}

-

-void S9xAPULoadState (uint8_t *block)

-{

-	uint8_t	*ptr = block;

-

-	S9xResetAPU();

-

-	spc_core->copy_state(&ptr, to_apu_from_state);

-

-	spc::reference_time = GET_LE32(ptr);

-	ptr += sizeof(int32_t);

-	spc::remainder = GET_LE32(ptr);

-}

@@ -184,6 +184,10 @@

 #include "hermite_resampler.h"

 #include "bspline_resampler.h"

 #include "osculating_resampler.h"

+#include "sinc_resampler.h"

+

+bool SincResampler::initializedLUTs = false;

+double SincResampler::sinc_lut[SincResampler::SINC_SAMPLES + 1];

 #define APU_DEFAULT_INPUT_RATE		32000

 #define APU_MINIMUM_SAMPLE_COUNT	512

@@ -479,6 +483,7 @@ template bool S9xInitSound<LinearResampler>(int, int);

 template bool S9xInitSound<HermiteResampler>(int, int);

 template bool S9xInitSound<BsplineResampler>(int, int);

 template bool S9xInitSound<OsculatingResampler>(int, int);

+template bool S9xInitSound<SincResampler>(int, int);

 void S9xSetSoundControl (uint8_t voice_switch)

 {

@@ -183,7 +183,7 @@

 #include "linear_resampler.h"

 #include "hermite_resampler.h"

 #include "bspline_resampler.h"

-#include "optimal_resampler.h"

+#include "osculating_resampler.h"

 #define APU_DEFAULT_INPUT_RATE		32000

 #define APU_MINIMUM_SAMPLE_COUNT	512

@@ -478,7 +478,7 @@ template<class ResamplerClass> bool S9xInitSound (int buffer_ms, int lag_ms)

 template bool S9xInitSound<LinearResampler>(int, int);

 template bool S9xInitSound<HermiteResampler>(int, int);

 template bool S9xInitSound<BsplineResampler>(int, int);

-template bool S9xInitSound<OptimalResampler>(int, int);

+template bool S9xInitSound<OsculatingResampler>(int, int);

 void S9xSetSoundControl (uint8_t voice_switch)

 {

@@ -182,6 +182,8 @@

 //#include "display.h"

 #include "linear_resampler.h"

 #include "hermite_resampler.h"

+#include "bspline_resampler.h"

+#include "optimal_resampler.h"

 #define APU_DEFAULT_INPUT_RATE		32000

 #define APU_MINIMUM_SAMPLE_COUNT	512

@@ -475,6 +477,8 @@ template<class ResamplerClass> bool S9xInitSound (int buffer_ms, int lag_ms)

 template bool S9xInitSound<LinearResampler>(int, int);

 template bool S9xInitSound<HermiteResampler>(int, int);

+template bool S9xInitSound<BsplineResampler>(int, int);

+template bool S9xInitSound<OptimalResampler>(int, int);

 void S9xSetSoundControl (uint8_t voice_switch)

 {

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

 #include <math.h>

-#include "snes9x.h"

 #include "apu.h"

 //#include "snapshot.h"

 //#include "display.h"

new file mode 100644

@@ -0,0 +1,670 @@

+/***********************************************************************************

+  Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.

+

+  (c) Copyright 1996 - 2002  Gary Henderson (gary.henderson@ntlworld.com),

+                             Jerremy Koot (jkoot@snes9x.com)

+

+  (c) Copyright 2002 - 2004  Matthew Kendora

+

+  (c) Copyright 2002 - 2005  Peter Bortas (peter@bortas.org)

+

+  (c) Copyright 2004 - 2005  Joel Yliluoma (http://iki.fi/bisqwit/)

+

+  (c) Copyright 2001 - 2006  John Weidman (jweidman@slip.net)

+

+  (c) Copyright 2002 - 2006  funkyass (funkyass@spam.shaw.ca),

+                             Kris Bleakley (codeviolation@hotmail.com)

+

+  (c) Copyright 2002 - 2010  Brad Jorsch (anomie@users.sourceforge.net),

+                             Nach (n-a-c-h@users.sourceforge.net),

+

+  (c) Copyright 2002 - 2011  zones (kasumitokoduck@yahoo.com)

+

+  (c) Copyright 2006 - 2007  nitsuja

+

+  (c) Copyright 2009 - 2011  BearOso,

+                             OV2

+

+

+  BS-X C emulator code

+  (c) Copyright 2005 - 2006  Dreamer Nom,

+                             zones

+

+  C4 x86 assembler and some C emulation code

+  (c) Copyright 2000 - 2003  _Demo_ (_demo_@zsnes.com),

+                             Nach,

+                             zsKnight (zsknight@zsnes.com)

+

+  C4 C++ code

+  (c) Copyright 2003 - 2006  Brad Jorsch,

+                             Nach

+

+  DSP-1 emulator code

+  (c) Copyright 1998 - 2006  _Demo_,

+                             Andreas Naive (andreasnaive@gmail.com),

+                             Gary Henderson,

+                             Ivar (ivar@snes9x.com),

+                             John Weidman,

+                             Kris Bleakley,

+                             Matthew Kendora,

+                             Nach,

+                             neviksti (neviksti@hotmail.com)

+

+  DSP-2 emulator code

+  (c) Copyright 2003         John Weidman,

+                             Kris Bleakley,

+                             Lord Nightmare (lord_nightmare@users.sourceforge.net),

+                             Matthew Kendora,

+                             neviksti

+

+  DSP-3 emulator code

+  (c) Copyright 2003 - 2006  John Weidman,

+                             Kris Bleakley,

+                             Lancer,

+                             z80 gaiden

+

+  DSP-4 emulator code

+  (c) Copyright 2004 - 2006  Dreamer Nom,

+                             John Weidman,

+                             Kris Bleakley,

+                             Nach,

+                             z80 gaiden

+

+  OBC1 emulator code

+  (c) Copyright 2001 - 2004  zsKnight,

+                             pagefault (pagefault@zsnes.com),

+                             Kris Bleakley

+                             Ported from x86 assembler to C by sanmaiwashi

+

+  SPC7110 and RTC C++ emulator code used in 1.39-1.51

+  (c) Copyright 2002         Matthew Kendora with research by

+                             zsKnight,

+                             John Weidman,

+                             Dark Force

+

+  SPC7110 and RTC C++ emulator code used in 1.52+

+  (c) Copyright 2009         byuu,

+                             neviksti

+

+  S-DD1 C emulator code

+  (c) Copyright 2003         Brad Jorsch with research by

+                             Andreas Naive,

+                             John Weidman

+

+  S-RTC C emulator code

+  (c) Copyright 2001 - 2006  byuu,

+                             John Weidman

+

+  ST010 C++ emulator code

+  (c) Copyright 2003         Feather,

+                             John Weidman,

+                             Kris Bleakley,

+                             Matthew Kendora

+

+  Super FX x86 assembler emulator code

+  (c) Copyright 1998 - 2003  _Demo_,

+                             pagefault,

+                             zsKnight

+

+  Super FX C emulator code

+  (c) Copyright 1997 - 1999  Ivar,

+                             Gary Henderson,

+                             John Weidman

+

+  Sound emulator code used in 1.5-1.51

+  (c) Copyright 1998 - 2003  Brad Martin

+  (c) Copyright 1998 - 2006  Charles Bilyue'

+

+  Sound emulator code used in 1.52+

+  (c) Copyright 2004 - 2007  Shay Green (gblargg@gmail.com)

+

+  SH assembler code partly based on x86 assembler code

+  (c) Copyright 2002 - 2004  Marcus Comstedt (marcus@mc.pp.se)

+

+  2xSaI filter

+  (c) Copyright 1999 - 2001  Derek Liauw Kie Fa

+

+  HQ2x, HQ3x, HQ4x filters

+  (c) Copyright 2003         Maxim Stepin (maxim@hiend3d.com)

+

+  NTSC filter

+  (c) Copyright 2006 - 2007  Shay Green

+

+  GTK+ GUI code

+  (c) Copyright 2004 - 2011  BearOso

+

+  Win32 GUI code

+  (c) Copyright 2003 - 2006  blip,

+                             funkyass,

+                             Matthew Kendora,

+                             Nach,

+                             nitsuja

+  (c) Copyright 2009 - 2011  OV2

+

+  Mac OS GUI code

+  (c) Copyright 1998 - 2001  John Stiles

+  (c) Copyright 2001 - 2011  zones

+

+

+  Specific ports contains the works of other authors. See headers in

+  individual files.

+

+

+  Snes9x homepage: http://www.snes9x.com/

+

+  Permission to use, copy, modify and/or distribute Snes9x in both binary

+  and source form, for non-commercial purposes, is hereby granted without

+  fee, providing that this license information and copyright notice appear

+  with all copies and any derived work.

+

+  This software is provided 'as-is', without any express or implied

+  warranty. In no event shall the authors be held liable for any damages

+  arising from the use of this software or it's derivatives.

+

+  Snes9x is freeware for PERSONAL USE only. Commercial users should

+  seek permission of the copyright holders first. Commercial use includes,

+  but is not limited to, charging money for Snes9x or software derived from

+  Snes9x, including Snes9x or derivatives in commercial game bundles, and/or

+  using Snes9x as a promotion for your commercial product.

+

+  The copyright holders request that bug fixes and improvements to the code

+  should be forwarded to them so everyone can benefit from the modifications

+  in future versions.

+

+  Super NES and Super Nintendo Entertainment System are trademarks of

+  Nintendo Co., Limited and its subsidiary companies.

+ ***********************************************************************************/

+

+

+#include <math.h>

+#include "snes9x.h"

+#include "apu.h"

+//#include "snapshot.h"

+//#include "display.h"

+#include "linear_resampler.h"

+#include "hermite_resampler.h"

+

+#define APU_DEFAULT_INPUT_RATE		32000

+#define APU_MINIMUM_SAMPLE_COUNT	512

+#define APU_MINIMUM_SAMPLE_BLOCK	128

+#define APU_NUMERATOR_NTSC			15664

+#define APU_DENOMINATOR_NTSC		328125

+#define APU_NUMERATOR_PAL			34176

+#define APU_DENOMINATOR_PAL			709379

+#define APU_DEFAULT_RESAMPLER		HermiteResampler

+

+SNES_SPC	*spc_core = NULL;

+

+static uint8_t APUROM[64] =

+{

+	0xCD, 0xEF, 0xBD, 0xE8, 0x00, 0xC6, 0x1D, 0xD0,

+	0xFC, 0x8F, 0xAA, 0xF4, 0x8F, 0xBB, 0xF5, 0x78,

+	0xCC, 0xF4, 0xD0, 0xFB, 0x2F, 0x19, 0xEB, 0xF4,

+	0xD0, 0xFC, 0x7E, 0xF4, 0xD0, 0x0B, 0xE4, 0xF5,

+	0xCB, 0xF4, 0xD7, 0x00, 0xFC, 0xD0, 0xF3, 0xAB,

+	0x01, 0x10, 0xEF, 0x7E, 0xF4, 0x10, 0xEB, 0xBA,

+	0xF6, 0xDA, 0x00, 0xBA, 0xF4, 0xC4, 0xF4, 0xDD,

+	0x5D, 0xD0, 0xDB, 0x1F, 0x00, 0x00, 0xC0, 0xFF

+};

+

+namespace spc

+{

+	static apu_callback	sa_callback     = NULL;

+	static void			*extra_data     = NULL;

+

+	static bool		sound_in_sync   = true;

+	static bool		sound_enabled   = false;

+

+	static int			buffer_size;

+	static int			lag_master      = 0;

+	static int			lag             = 0;

+