@@ -49,7 +49,7 @@

     <ClCompile>

       <WarningLevel>Level4</WarningLevel>

       <Optimization>Disabled</Optimization>

-      <PreprocessorDefinitions>WIN32;_WINDOWS;_USRDLL;IN_GSF_EXPORTS;_CRT_SECURE_NO_WARNINGS;WINAMP_PLUGIN;NO_DEBUGGER;FINAL_VERSION;C_CORE;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <PreprocessorDefinitions>WIN32;_WINDOWS;_USRDLL;IN_GSF_EXPORTS;_CRT_SECURE_NO_WARNINGS;WINAMP_PLUGIN;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>

       <AdditionalIncludeDirectories>G:\Code\my_xsf\src;$(zlibRootDir)\include;$(WinampSDKDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <DisableSpecificWarnings>4100;4127;4189;4244;4291;4310;4512;4800;%(DisableSpecificWarnings)</DisableSpecificWarnings>

     </ClCompile>

@@ -66,7 +66,7 @@

       <Optimization>MaxSpeed</Optimization>

       <FunctionLevelLinking>true</FunctionLevelLinking>

       <IntrinsicFunctions>true</IntrinsicFunctions>

-      <PreprocessorDefinitions>WIN32;_WINDOWS;_USRDLL;IN_GSF_EXPORTS;_CRT_SECURE_NO_WARNINGS;WINAMP_PLUGIN;NO_DEBUGGER;FINAL_VERSION;C_CORE;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <PreprocessorDefinitions>WIN32;_WINDOWS;_USRDLL;IN_GSF_EXPORTS;_CRT_SECURE_NO_WARNINGS;WINAMP_PLUGIN;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

       <AdditionalIncludeDirectories>G:\Code\my_xsf\src;$(zlibRootDir)\include;$(WinampSDKDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <DisableSpecificWarnings>4100;4127;4189;4244;4291;4310;4512;4800;%(DisableSpecificWarnings)</DisableSpecificWarnings>

     </ClCompile>

@@ -1,10 +1,9 @@

 // Blip_Buffer 0.4.1. http://www.slack.net/~ant/

+#include <limits>

 #include <numeric>

-#include <cassert>

 #include <cmath>

 #include <cstring>

-#include <cstdlib>

 #include "Blip_Buffer.h"

 /* Copyright (C) 2003-2007 Shay Green. This module is free software; you

@@ -22,7 +21,7 @@ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */

 Blip_Buffer::Blip_Buffer()

 {

-	this->factor_ = static_cast<uint32_t>(LONG_MAX);

+	this->factor_ = static_cast<uint32_t>(std::numeric_limits<long>::max());

 	this->buffer_.clear();

 	this->buffer_size_ = 0;

 	this->sample_rate_ = 0;

@@ -71,7 +70,7 @@ void Blip_Buffer::set_sample_rate(long new_rate, int msec)

 		if (s < new_size)

 			new_size = s;

 		else

-			assert(0); // fails if requested buffer length exceeds limit

+			assert(false); // fails if requested buffer length exceeds limit

 	}

 	if (this->buffer_size_ != new_size)

@@ -131,7 +130,7 @@ blip_time_t Blip_Buffer::count_clocks(long count) const

 {

 	if (!this->factor_)

 	{

-		assert(0); // sample rate and clock rates must be set first

+		assert(false); // sample rate and clock rates must be set first

 		return 0;

 	}

@@ -149,8 +148,8 @@ void Blip_Buffer::remove_samples(long count)

 		// copy remaining samples to beginning and clear old samples

 		long remain = this->samples_avail() + blip_buffer_extra_;

-		memmove(&this->buffer_[0], &this->buffer_[count], remain * sizeof(this->buffer_[0]));

-		memset(&this->buffer_[remain], 0, count * sizeof(this->buffer_[0]));

+		memmove(&this->buffer_[0], &this->buffer_[count], remain * sizeof(buf_t_));

+		memset(&this->buffer_[remain], 0, count * sizeof(buf_t_));

 	}

 }

@@ -159,8 +158,7 @@ void Blip_Buffer::remove_samples(long count)

 Blip_Synth_Fast_::Blip_Synth_Fast_()

 {

 	this->buf = nullptr;

-	this->last_amp = 0;

-	this->delta_factor = 0;

+	this->last_amp = this->delta_factor = 0;

 }

 void Blip_Synth_Fast_::volume_unit(double new_unit)

@@ -175,8 +173,7 @@ Blip_Synth_::Blip_Synth_(short *p, int w) : impulses(p), width(w)

 	this->volume_unit_ = 0.0;

 	this->kernel_unit = 0;

 	this->buf = nullptr;

-	this->last_amp = 0;

-	this->delta_factor = 0;

+	this->last_amp = this->delta_factor = 0;

 }

 #ifndef M_PI

@@ -193,10 +190,10 @@ static void gen_sinc(float *out, int count, double oversample, double treble, do

 	if (treble > 5.0)

 		treble = 5.0;

-	double const maxh = 4096.0;

-	double const rolloff = std::pow(10.0, 1.0 / (maxh * 20.0) * treble / (1.0 - cutoff));

-	double const pow_a_n = std::pow(rolloff, maxh - maxh * cutoff);

-	double const to_angle = M_PI / 2 / maxh / oversample;

+	static const double maxh = 4096.0;

+	double rolloff = std::pow(10.0, 1.0 / (maxh * 20.0) * treble / (1.0 - cutoff));

+	double pow_a_n = std::pow(rolloff, maxh - maxh * cutoff);

+	double to_angle = M_PI / 2 / maxh / oversample;

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

 	{

 		double angle = ((i - count) * 2 + 1) * to_angle;

@@ -226,10 +223,10 @@ void blip_eq_t::generate(float *out, int count) const

 	gen_sinc(out, count, blip_res * oversample, this->treble, cutoff);

-	// apply (half of) hann window

+	// apply (half of) hamming window

 	double to_fraction = M_PI / (count - 1);

 	for (int i = count; i--; )

-		out[i] *= 0.5f * (1.0f - static_cast<float>(std::cos(i * to_fraction)));

+		out[i] *= 0.54f - 0.46f * static_cast<float>(std::cos(i * to_fraction));

 }

 void Blip_Synth_::adjust_impulse()

@@ -245,7 +242,7 @@ void Blip_Synth_::adjust_impulse()

 		if (p == p2)

 			error /= 2; // phase = 0.5 impulse uses same half for both sides

 		this->impulses[size - blip_res + p] += static_cast<short>(error);

-		//printf("error: %ld\n", error);

+		//printf( "error: %ld\n", error );

 	}

 	//for (int i = blip_res; i--; printf("\n"))

@@ -336,7 +333,7 @@ void Blip_Synth_::volume_unit(double new_unit)

 			}

 		}

 		this->delta_factor = static_cast<int>(std::floor(factor + 0.5));

-		//printf("delta_factor: %d, kernel_unit: %d\n", this->delta_factor, this->kernel_unit);

+		//printf( "delta_factor: %d, kernel_unit: %d\n", delta_factor, kernel_unit );

 	}

 }

 #endif

@@ -349,10 +346,10 @@ long Blip_Buffer::read_samples(blip_sample_t *out_, long max_samples, bool stere

 	if (count)

 	{

-		int bass = BLIP_READER_BASS(*this);

+		int bass = BLIP_READER_BASS(this);

 		BLIP_READER_BEGIN(reader, *this);

 		BLIP_READER_ADJ_(reader, count);

-		auto out = out_ + count;

+		auto out = &out_[count];

 		int32_t offset = static_cast<int32_t>(-count);

 		do

@@ -1,8 +1,7 @@

 // Band-limited sound synthesis buffer

 // Blip_Buffer 0.4.1

-#ifndef BLIP_BUFFER_H

-#define BLIP_BUFFER_H

+#pragma once

 #include <vector>

 #include <cstdint>

@@ -11,7 +10,7 @@

 typedef int32_t blip_time_t;

 // Output samples are 16-bit signed, with a range of -32768 to 32767

-typedef short blip_sample_t;

+typedef int16_t blip_sample_t;

 enum { blip_sample_max = 32767 };

 class Blip_Buffer

@@ -20,7 +19,7 @@ public:

 	// Sets output sample rate and buffer length in milliseconds (1/1000 sec, defaults

 	// to 1/4 second) and clears buffer. If there isn't enough memory, leaves buffer

 	// untouched and returns "Out of memory", otherwise returns NULL.

-	void set_sample_rate(long samples_per_sec, int msec_length = 1000 / 4);

+	void set_sample_rate(long samples_per_sec, int msec_length = 250);

 	// Sets number of source time units per second

 	void clock_rate(long clocks_per_sec);

@@ -89,11 +88,9 @@ public:

 	blip_resampled_time_t resampled_duration(int t) const { return t * this->factor_; }

 	blip_resampled_time_t resampled_time(blip_time_t t) const { return t * this->factor_ + this->offset_; }

 	blip_resampled_time_t clock_rate_factor(long clock_rate) const;

+

 	Blip_Buffer();

 	virtual ~Blip_Buffer();

-

-	// Deprecated

-	typedef blip_resampled_time_t resampled_time_t;

 private:

 	// noncopyable

 	Blip_Buffer(const Blip_Buffer &);

@@ -116,22 +113,28 @@ private:

 // Number of bits in resample ratio fraction. Higher values give a more accurate ratio

 // but reduce maximum buffer size.

-const int BLIP_BUFFER_ACCURACY = 16;

+enum { BLIP_BUFFER_ACCURACY = 16 };

 // Number bits in phase offset. Fewer than 6 bits (64 phase offsets) results in

 // noticeable broadband noise when synthesizing high frequency square waves.

 // Affects size of Blip_Synth objects since they store the waveform directly.

+enum

+{

 #if BLIP_BUFFER_FAST

-const int BLIP_PHASE_BITS = 8;

+	BLIP_PHASE_BITS = 8

 #else

-const int BLIP_PHASE_BITS = 6;

+	BLIP_PHASE_BITS = 6

 #endif

+};

 // Internal

 typedef uint32_t blip_resampled_time_t;

-const int blip_widest_impulse_ = 16;

-const int blip_buffer_extra_ = blip_widest_impulse_ + 2;

-const int blip_res = 1 << BLIP_PHASE_BITS;

+enum

+{

+	blip_widest_impulse_ = 16,

+	blip_buffer_extra_ = blip_widest_impulse_ + 2,

+	blip_res = 1 << BLIP_PHASE_BITS

+};

 class blip_eq_t;

 class Blip_Synth_Fast_

@@ -166,9 +169,12 @@ private:

 };

 // Quality level, better = slower. In general, use blip_good_quality.

-const int blip_med_quality  = 8;

-const int blip_good_quality = 12;

-const int blip_high_quality = 16;

+enum

+{

+	blip_med_quality = 8,

+	blip_good_quality = 12,

+	blip_high_quality = 16

+};

 // Range specifies the greatest expected change in amplitude. Calculate it

 // by finding the difference between the maximum and minimum expected

@@ -216,7 +222,7 @@ private:

 	Blip_Synth_Fast_ impl;

 #else

 	Blip_Synth_ impl;

-	typedef short imp_t;

+	typedef int16_t imp_t;

 	imp_t impulses[blip_res * (quality / 2) + 1];

 public:

 	Blip_Synth() : impl(impulses, quality) { }

@@ -243,21 +249,21 @@ private:

 	friend class Blip_Synth_;

 };

-const int blip_sample_bits = 30;

+enum { blip_sample_bits = 30 };

 // Optimized reading from Blip_Buffer, for use in custom sample output

 // Begins reading from buffer. Name should be unique to the current block.

 #define BLIP_READER_BEGIN(name, blip_buffer) \

-	auto name##_reader_buf = &(blip_buffer).buffer_[0]; \

+	const Blip_Buffer::buf_t_ *name##_reader_buf = &(blip_buffer).buffer_[0]; \

 	int32_t name##_reader_accum = (blip_buffer).reader_accum_

 // Gets value to pass to BLIP_READER_NEXT()

-inline int BLIP_READER_BASS(const Blip_Buffer &blip_buffer) { return blip_buffer.bass_shift_; }

+inline int BLIP_READER_BASS(const Blip_Buffer *blip_buffer) { return blip_buffer->bass_shift_; }

 // Constant value to use instead of BLIP_READER_BASS(), for slightly more optimal

 // code at the cost of having no bass control

-const int blip_reader_default_bass = 9;

+enum { blip_reader_default_bass = 9 };

 // Current sample

 #define BLIP_READER_READ(name) (name##_reader_accum >> (blip_sample_bits - 16))

@@ -283,12 +289,6 @@ const int blip_reader_default_bass = 9;

 	name##_reader_accum += name##_reader_buf[(idx)]; \

 }

-#define BLIP_READER_NEXT_RAW_IDX_(name, bass, idx) \

-{ \

-	name##_reader_accum -= name##_reader_accum >> (bass); \

-	name##_reader_accum += *reinterpret_cast<const Blip_Buffer::buf_t_ *>(reinterpret_cast<const char *>(name##_reader_buf) + (idx)); \

-}

-

 #if defined(_M_IX86) || defined(_M_IA64) || defined(__i486__) || defined(__x86_64__) || defined(__ia64__) || defined(__i386__)

 template<typename T> inline bool BLIP_CLAMP_(const T &in) { return in < -0x8000 || 0x7FFF < in; }

 #else

@@ -304,9 +304,7 @@ template<typename T1, typename T2> inline void BLIP_CLAMP(const T1 &sample, T2 &

 // End of public interface

-#ifndef assert

-# include <cassert>

-#endif

+#include <cassert>

 template<int quality, int range> inline void Blip_Synth<quality, range>::offset_resampled(blip_resampled_time_t time, int delta, Blip_Buffer *blip_buf) const

 {

@@ -316,7 +314,7 @@ template<int quality, int range> inline void Blip_Synth<quality, range>::offset_

 	delta *= this->impl.delta_factor;

 	auto buf = &blip_buf->buffer_[time >> BLIP_BUFFER_ACCURACY];

-	int phase = static_cast<int>((time >> (BLIP_BUFFER_ACCURACY - BLIP_PHASE_BITS)) & (blip_res - 1));

+	int phase = static_cast<int>(time >> (BLIP_BUFFER_ACCURACY - BLIP_PHASE_BITS) & (blip_res - 1));

 #if BLIP_BUFFER_FAST

 	int32_t left = buf[0] + delta;

@@ -335,12 +333,12 @@ template<int quality, int range> inline void Blip_Synth<quality, range>::offset_

 	int rev = fwd + quality - 2;

 	int mid = quality / 2 - 1;

-	auto imp = this->impulses + blip_res - phase;

+	auto imp = &this->impulses[blip_res - phase];

 # if defined(_M_IX86) || defined(_M_IA64) || defined(__i486__) || defined(__x86_64__) || defined(__ia64__) || defined(__i386__)

 	// this straight forward version gave in better code on GCC for x86

-	auto ADD_IMP = [&](int out, int in) { buf[out] += static_cast<int32_t>(imp[blip_res * in] * delta); };

+	auto ADD_IMP = [&](int out, int in) { buf[out] += static_cast<int32_t>(imp[blip_res * in]) * delta; };

 	auto BLIP_FWD = [&](int i) { ADD_IMP(fwd + i, i); ADD_IMP(fwd + 1 + i, i + 1); };

 	auto BLIP_REV = [&](int r) { ADD_IMP(rev - r, r + 1); ADD_IMP(rev + 1 - r, r); };

@@ -352,7 +350,7 @@ template<int quality, int range> inline void Blip_Synth<quality, range>::offset_

 		BLIP_FWD(4);

 	ADD_IMP(fwd + mid - 1, mid - 1);

 	ADD_IMP(fwd + mid, mid);

-	imp = this->impulses + phase;

+	imp = &this->impulses[phase];

 	if (quality > 12)

 		BLIP_REV(6);

 	if (quality > 8)

@@ -390,7 +388,7 @@ template<int quality, int range> inline void Blip_Synth<quality, range>::offset_

 		BLIP_FWD(4);

 	int32_t t0 = i0 * delta + buf[fwd + mid - 1];

 	int32_t t1 = imp[blip_res * mid] * delta + buf[fwd + mid];

-	imp = this->impulses + phase;

+	imp = &this->impulses[phase];

 	i0 = imp[blip_res * mid];

 	buf[fwd + mid - 1] = t0;

 	buf[fwd + mid] = t1;

@@ -442,7 +440,8 @@ inline uint32_t Blip_Buffer::unsettled() const

 	return this->reader_accum_ >> (blip_sample_bits - 16);

 }

-const int blip_max_length = 0;

-const int blip_default_length = 250; // 1/4 second

-

-#endif

+enum

+{

+	blip_max_length = 0,

+	blip_default_length = 250 // 1/4 second

+};

@@ -30,7 +30,7 @@ void Gb_Apu::treble_eq(const blip_eq_t &eq)

 int Gb_Apu::calc_output(int osc) const

 {

 	int bits = this->regs[stereo_reg - start_addr] >> osc;

-	return ((bits >> 3) & 2) | (bits & 1);

+	return (bits >> 3 & 2) | (bits & 1);

 }

 void Gb_Apu::set_output(Blip_Buffer *center, Blip_Buffer *left, Blip_Buffer *right, int osc)

@@ -65,7 +65,7 @@ void Gb_Apu::apply_volume()

 	// TODO: Doesn't handle differing left and right volumes (panning).

 	// Not worth the complexity.

 	int data = this->regs[vol_reg - start_addr];

-	int left = (data >> 4) & 7;

+	int left = data >> 4 & 7;

 	int right = data & 7;

 	//if ( data & 0x88 ) dprintf( "Vin: %02X\n", data & 0x88 );

 	//if ( left != right ) dprintf( "l: %d r: %d\n", left, right );

@@ -83,8 +83,7 @@ void Gb_Apu::volume(double v)

 void Gb_Apu::reset_regs()

 {

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

-		this->regs[i] = 0;

+	std::fill(&this->regs[0], &this->regs[0x20], 0);

 	this->square1.reset();

 	this->square2.reset();

@@ -173,11 +172,7 @@ Gb_Apu::Gb_Apu()

 	{

 		auto &o = *this->oscs[i];

 		o.regs = &this->regs[i * 5];

-		o.output = nullptr;

-		o.outputs[0] = nullptr;

-		o.outputs[1] = nullptr;

-		o.outputs[2] = nullptr;

-		o.outputs[3] = nullptr;

+		o.output = o.outputs[0] = o.outputs[1] = o.outputs[2] = o.outputs[3] = nullptr;

 		o.good_synth = &this->good_synth;

 		o.med_synth = &this->med_synth;

 	}

@@ -190,7 +185,7 @@ Gb_Apu::Gb_Apu()

 void Gb_Apu::run_until_(blip_time_t end_time)

 {

-	while (1)

+	while (true)

 	{

 		// run oscillators

 		blip_time_t time = end_time;

@@ -1,8 +1,7 @@

 // Nintendo Game Boy sound hardware emulator with save state support

 // Gb_Snd_Emu 0.2.0

-#ifndef GB_APU_H

-#define GB_APU_H

+#pragma once

 #include "Gb_Oscs.h"

@@ -64,7 +63,7 @@ public:

 	// Treble and bass values for various hardware.

 	enum

 	{

-		speaker_treble =  -47, // speaker on system

+		speaker_treble = -47, // speaker on system

 		speaker_bass = 2000,

 		dmg_treble = 0, // headphones on each system

 		dmg_bass = 30,

@@ -114,10 +113,7 @@ private:

 	void run_until(blip_time_t);

 	void silence_osc(Gb_Osc &);

 	void write_osc(int index, int reg, int old_data, int data);

-	friend class Gb_Apu_Tester;

 public:

 	int read_status();

 };

-

-#endif

@@ -22,8 +22,7 @@ static const int length_enabled = 0x40;

 void Gb_Osc::reset()

 {

 	this->output = nullptr;

-	this->last_amp = 0;

-	this->delay = 0;

+	this->last_amp = this->delay = 0;

 	this->phase = 0;

 	this->enabled = false;

 }

@@ -90,7 +89,7 @@ void Gb_Sweep_Square::calc_sweep(bool update)

 		this->sweep_freq = freq;

 		this->regs[3] = freq & 0xFF;

-		this->regs[4] = (this->regs[4] & ~0x07) | ((freq >> 8) & 0x07);

+		this->regs[4] = (this->regs[4] & ~0x07) | (freq >> 8 & 0x07);

 	}

 }

@@ -441,7 +440,7 @@ static unsigned run_lfsr(unsigned s, unsigned mask, int count)

 	{

 		// won't fully replace upper 8 bits, so have to do the unoptimized way

 		while (--count >= 0)

-			s = ((s >> 1) | mask) ^ (mask & (0 - ((s - 1) & 2)));

+			s = (s >> 1 | mask) ^ (mask & (0 - ((s - 1) & 2)));

 	}

 	else

 	{

@@ -453,7 +452,7 @@ static unsigned run_lfsr(unsigned s, unsigned mask, int count)

 		}

 		// Need to keep one extra bit of history

-		s = (s << 1) & 0xFF;

+		s = s << 1 & 0xFF;

 		// Convert from Fibonacci to Galois configuration,

 		// shifted left 2 bits

@@ -471,7 +470,7 @@ static unsigned run_lfsr(unsigned s, unsigned mask, int count)

 		// Convert back to Fibonacci configuration and

 		// repeat last 8 bits above significant 7

-		s = ((s << 7) & 0x7F80) | ((s >> 1) & 0x7F);

+		s = (s << 7 & 0x7F80) | (s >> 1 & 0x7F);

 	}

 	return s;

@@ -514,15 +513,13 @@ void Gb_Noise::run(blip_time_t time, blip_time_t end_time)

 	// Run timer and calculate time of next LFSR clock

 	static const uint8_t period1s[] = { 1, 2, 4, 6, 8, 10, 12, 14 };

 	int period1 = period1s[this->regs[3] & 7] * clk_mul;

-	{

-		int extra = (end_time - time) - this->delay;

-		int per2 = this->period2();

-		time += this->delay + ((this->divider ^ (per2 >> 1)) & (per2 - 1)) * period1;

+	int extra = (end_time - time) - this->delay;

+	int per2 = this->period2();

+	time += this->delay + ((this->divider ^ (per2 >> 1)) & (per2 - 1)) * period1;

-		int count = extra < 0 ? 0 : (extra + period1 - 1) / period1;

-		this->divider = (this->divider - count) & period2_mask;

-		this->delay = count * period1 - extra;

-	}

+	int count = extra < 0 ? 0 : (extra + period1 - 1) / period1;

+	this->divider = (this->divider - count) & period2_mask;

+	this->delay = count * period1 - extra;

 	// Generate wave

 	if (time < end_time)

@@ -547,7 +544,7 @@ void Gb_Noise::run(blip_time_t time, blip_time_t end_time)

 			do

 			{

 				unsigned changed = bits + 1;

-				bits = (bits >> 1) & mask;

+				bits = bits >> 1 & mask;

 				if (changed & 2)

 				{

 					bits |= ~mask;

@@ -569,11 +566,11 @@ void Gb_Wave::run(blip_time_t time, blip_time_t end_time)

 	// Calc volume

 	static const uint8_t volumes[] = { 0, 4, 2, 1, 3, 3, 3, 3 };

 	static const int volume_shift = 2;

-	int volume_idx = (this->regs[2] >> 5) & (this->agb_mask | 3); // 2 bits on DMG/CGB, 3 on AGB

+	int volume_idx = this->regs[2] >> 5 & (this->agb_mask | 3); // 2 bits on DMG/CGB, 3 on AGB

 	int volume_mul = volumes[volume_idx];

 	// Determine what will be generated

-	int playing = false;

+	int playing = 0;

 	auto out = this->output;

 	if (out)

 	{

@@ -587,9 +584,9 @@ void Gb_Wave::run(blip_time_t time, blip_time_t end_time)

 			if (this->frequency() <= 0x7FB || this->delay > 15 * clk_mul)

 			{

 				if (volume_mul)

-					playing = this->enabled;

+					playing = static_cast<int>(this->enabled);

-				amp = (this->sample_buf << ((this->phase << 2) & 4) & 0xF0) * playing;

+				amp = (this->sample_buf << (this->phase << 2 & 4) & 0xF0) * playing;

 			}

 			amp = ((amp * volume_mul) >> (volume_shift + 4)) - dac_bias;

@@ -632,7 +629,7 @@ void Gb_Wave::run(blip_time_t time, blip_time_t end_time)

 			do

 			{

 				// Extract nybble

-				int nybble = (wave[ph >> 1] << ((ph << 2) & 4)) & 0xF0;

+				int nybble = wave[ph >> 1] << (ph << 2 & 4) & 0xF0;

 				ph = (ph + 1) & wave_mask;

 				// Scale by volume

@@ -1,8 +1,7 @@

 // Private oscillators used by Gb_Apu

 // Gb_Snd_Emu 0.2.0

-#ifndef GB_OSCS_H

-#define GB_OSCS_H

+#pragma once

 #include "blargg_common.h"

 #include "Blip_Buffer.h"

@@ -170,7 +169,7 @@ private:

 	void corrupt_wave();

-	uint8_t *wave_bank() const { return &this->wave_ram[((~this->regs[0] & bank40_mask) >> 2) & agb_mask]; }

+	uint8_t *wave_bank() const { return &this->wave_ram[(~this->regs[0] & bank40_mask) >> 2 & this->agb_mask]; }

 	// Wave index that would be accessed, or -1 if no access would occur

 	int access(unsigned addr) const;

@@ -188,5 +187,3 @@ inline void Gb_Wave::write(unsigned addr, int data)

 	if (index >= 0)

 		this->wave_bank()[index] = data;

 }

-

-#endif

@@ -14,10 +14,6 @@ details. You should have received a copy of the GNU Lesser General Public

 License along with this module; if not, write to the Free Software Foundation,

 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */

-#ifdef BLARGG_ENABLE_OPTIMIZER

-# include BLARGG_ENABLE_OPTIMIZER

-#endif

-

 Multi_Buffer::Multi_Buffer(int spf) : samples_per_frame_(spf)

 {

 	this->length_ = 0;

@@ -177,7 +173,7 @@ void Stereo_Mixer::read_pairs(blip_sample_t *out, int count)

 void Stereo_Mixer::mix_mono(blip_sample_t *out_, int count)

 {

-	int bass = BLIP_READER_BASS(*this->bufs[2]);

+	int bass = BLIP_READER_BASS(this->bufs[2]);

 	BLIP_READER_BEGIN(center, *this->bufs[2]);

 	BLIP_READER_ADJ_(center, this->samples_read);

@@ -198,16 +194,16 @@ void Stereo_Mixer::mix_mono(blip_sample_t *out_, int count)

 void Stereo_Mixer::mix_stereo(blip_sample_t *out_, int count)

 {

-	auto out = out_ + count * stereo;

+	auto out = &out_[count * stereo];

 	// do left + center and right + center separately to reduce register load

 	auto buf = &this->bufs[2];

-	while (1) // loop runs twice

+	while (true) // loop runs twice

 	{

 		--buf;

 		--out;

-		int bass = BLIP_READER_BASS(*this->bufs[2]);

+		int bass = BLIP_READER_BASS(this->bufs[2]);

 		BLIP_READER_BEGIN(side, **buf);

 		BLIP_READER_BEGIN(center, *this->bufs[2]);

@@ -1,8 +1,7 @@

 // Multi-channel sound buffer interface, and basic mono and stereo buffers

 // Blip_Buffer 0.4.1

-#ifndef MULTI_BUFFER_H

-#define MULTI_BUFFER_H

+#pragma once

 #include "blargg_common.h"

 #include "Blip_Buffer.h"

@@ -19,7 +18,7 @@ public:

 	// (type information used by Effects_Buffer)

 	enum { type_index_mask = 0xFF };

 	enum { wave_type = 0x100, noise_type = 0x200, mixed_type = wave_type | noise_type };

-	virtual void set_channel_count(int, const int* types = nullptr);

+	virtual void set_channel_count(int, const int *types = nullptr);

 	int channel_count() const { return this->channel_count_; }

 	// Gets indexed channel, from 0 to channel count - 1

@@ -152,5 +151,3 @@ inline void Multi_Buffer::set_channel_count(int n, const int *types)

 	this->channel_count_ = n;

 	this->channel_types_ = types;

 }

-

-#endif

@@ -2,18 +2,12 @@

 // To change configuration options, modify blargg_config.h, not this file.

 // Gb_Snd_Emu 0.2.0

-#ifndef BLARGG_COMMON_H

-#define BLARGG_COMMON_H

+#pragma once

 #include <cstdlib>

 #include <cassert>

 #include <cstdint>

-

-#undef BLARGG_COMMON_H

-// allow blargg_config.h to #include blargg_common.h

 #include "blargg_config.h"

-#ifndef BLARGG_COMMON_H

-#define BLARGG_COMMON_H

 // BLARGG_COMPILER_HAS_BOOL: If 0, provides bool support for old compiler. If 1,

 // compiler is assumed to support bool. If undefined, availability is determined.

@@ -38,6 +32,3 @@ typedef int bool;

 const bool true = 1;

 const bool false = 0;

 #endif

-

-#endif

-#endif

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

 // $package user configuration file. Don't replace when updating library.

-#ifndef BLARGG_CONFIG_H

-#define BLARGG_CONFIG_H

+#pragma once

 // Uncomment to have Gb_Apu run at 4x normal clock rate (16777216 Hz), useful in

 // a Game Boy Advance emulator.

@@ -9,5 +8,3 @@

 // Uncomment if you get errors in the bool section of blargg_common.h

 //#define BLARGG_COMPILER_HAS_BOOL 1

-

-#endif

@@ -1,28 +1,25 @@

-#ifndef PORT_H

-#define PORT_H

+#pragma once

 #include <cstdint>

 #ifdef WORDS_BIGENDIAN

-#if defined(__GNUC__) && defined(__ppc__)

+# if defined(__GNUC__) && defined(__ppc__)

 #define READ16LE(base) \

-	({ \

-		unsigned short lhbrxResult; \

-		__asm__("lhbrx %0, 0, %1" : "=r" (lhbrxResult) : "r" (base) : "memory"); \

-		lhbrxResult; \

-	})

+	({ unsigned short lhbrxResult;       \

+		__asm__ ("lhbrx %0, 0, %1" : "=r" (lhbrxResult) : "r" (base) : "memory"); \

+		lhbrxResult; })

 #define READ32LE(base) \

-	({ \

-		unsigned long lwbrxResult; \

-		__asm__("lwbrx %0, 0, %1" : "=r" (lwbrxResult) : "r" (base) : "memory"); \

-		lwbrxResult; \

-	})

+	({ unsigned long lwbrxResult; \

+		__asm__ ("lwbrx %0, 0, %1" : "=r" (lwbrxResult) : "r" (base) : "memory"); \

+		lwbrxResult; })

-#define WRITE16LE(base, value) __asm__("sthbrx %0, 0, %1" : : "r" (value), "r" (base) : "memory")

+#define WRITE16LE(base, value) \

+	__asm__ ("sthbrx %0, 0, %1" : : "r" (value), "r" (base) : "memory")

-#define WRITE32LE(base, value) __asm__("stwbrx %0, 0, %1" : : "r" (value), "r" (base) : "memory")

-#else

+#define WRITE32LE(base, value) \

+	__asm__ ("stwbrx %0, 0, %1" : : "r" (value), "r" (base) : "memory")

+# else

 // swaps a 16-bit value

 inline uint16_t swap16(uint16_t v)

 {

@@ -35,16 +32,14 @@ inline uint32_t swap32(uint32_t v)

 	return (v << 24) | ((v << 8) & 0xff0000) | ((v >> 8) & 0xff00) | (v >> 24);

 }

-template<typename T> inline uint16_t READ16LE(T *x) { return swap16(*reinterpret_cast<uint16_t *>(x)); }

-template<typename T> inline uint32_t READ32LE(T *x) { return swap32(*reinterpret_cast<uint32_t *>(x)); }

+template<typename T> inline uint16_t READ16LE(const T *x) { return swap16(*reinterpret_cast<const uint16_t *>(x)); }

+template<typename T> inline uint32_t READ32LE(const T *x) { return swap32(*reinterpret_cast<const uint32_t *>(x)); }

 template<typename T> inline void WRITE16LE(T *x, uint16_t v) { *reinterpret_cast<uint16_t *>(x) = swap16(v); }

 template<typename T> inline void WRITE32LE(T *x, uint32_t v) { *reinterpret_cast<uint32_t *>(x) = swap32(v); }

-#endif

+# endif

 #else

-template<typename T> inline uint16_t READ16LE(T *x) { return *reinterpret_cast<uint16_t *>(x); }

-template<typename T> inline uint32_t READ32LE(T *x) { return *reinterpret_cast<uint32_t *>(x); }

+template<typename T> inline uint16_t READ16LE(const T *x) { return *reinterpret_cast<const uint16_t *>(x); }

+template<typename T> inline uint32_t READ32LE(const T *x) { return *reinterpret_cast<const uint32_t *>(x); }

 template<typename T> inline void WRITE16LE(T *x, uint16_t v) { *reinterpret_cast<uint16_t *>(x) = v; }

 template<typename T> inline void WRITE32LE(T *x, uint32_t v) { *reinterpret_cast<uint32_t *>(x) = v; }

 #endif

-

-#endif // PORT_H

@@ -15,8 +15,7 @@

 // along with this program; if not, write to the Free Software Foundation,

 // Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

-#ifndef __VBA_SOUND_DRIVER_H__

-#define __VBA_SOUND_DRIVER_H__

+#pragma once

 #include <cstdint>

@@ -60,5 +59,3 @@ public:

 	virtual void setThrottle(unsigned short throttle) { }

 };

-

-#endif // __VBA_SOUND_DRIVER_H__

@@ -52,578 +52,6 @@ template<typename T> static inline T POS(const T &i) { return ~i >> 31; }

 //    RRX_OFFSET: Used to rotate (RRX) the `offset' parameter for LDR and

 //                STR instructions.

-#ifndef C_CORE

-# if 0  // definitions have changed

-//#ifdef __POWERPC__

-#  define OP_SUBS \

-{ \

-	register int Flags; \

-	register int Result; \

-	asm volatile("subco. %0, %2, %3\n" \

-		"mcrxr cr1\n" \

-		"mfcr %1\n" \

-		: "=r" (Result), \

-		"=r" (Flags) \

-		: "r" (reg[base].I), \

-		"r" (value) \

-		); \

-	reg[dest].I = Result; \

-	Z_FLAG = (Flags >> 29) & 1; \

-	N_FLAG = (Flags >> 31) & 1; \

-	C_FLAG = (Flags >> 25) & 1; \

-	V_FLAG = (Flags >> 26) & 1; \

-}

-#  define OP_RSBS \

-{ \

-	register int Flags; \

-	register int Result; \

-	asm volatile("subfco. %0, %2, %3\n" \

-		"mcrxr cr1\n" \

-		"mfcr %1\n" \

-		: "=r" (Result), \

-		"=r" (Flags) \

-		: "r" (reg[base].I), \

-		"r" (value) \

-		); \

-	reg[dest].I = Result; \

-	Z_FLAG = (Flags >> 29) & 1; \

-	N_FLAG = (Flags >> 31) & 1; \

-	C_FLAG = (Flags >> 25) & 1; \

-	V_FLAG = (Flags >> 26) & 1; \

-}

-#  define OP_ADDS \

-{ \

-	register int Flags; \

-	register int Result; \

-	asm volatile("addco. %0, %2, %3\n" \

-		"mcrxr cr1\n" \

-		"mfcr %1\n" \

-		: "=r" (Result), \

-		"=r" (Flags) \

-		: "r" (reg[base].I), \

-		"r" (value) \

-		); \

-	reg[dest].I = Result; \

-	Z_FLAG = (Flags >> 29) & 1; \

-	N_FLAG = (Flags >> 31) & 1; \

-	C_FLAG = (Flags >> 25) & 1; \

-	V_FLAG = (Flags >> 26) & 1; \

-}

-#  define OP_ADCS \

-{ \

-	register int Flags; \

-	register int Result; \

-	asm volatile("mtspr xer, %4\n" \

-		"addeo. %0, %2, %3\n" \

-		"mcrxr cr1\n" \

-		"mfcr %1\n" \

-		: "=r" (Result), \

-		"=r" (Flags) \

-		: "r" (reg[base].I), \

-		"r" (value), \

-		"r" (C_FLAG << 29) \

-		); \

-	reg[dest].I = Result; \

-	Z_FLAG = (Flags >> 29) & 1; \

-	N_FLAG = (Flags >> 31) & 1; \

-	C_FLAG = (Flags >> 25) & 1; \

-	V_FLAG = (Flags >> 26) & 1; \

-}

-#  define OP_SBCS \

-{ \

-	register int Flags; \

-	register int Result; \

-	asm volatile("mtspr xer, %4\n" \

-		"subfeo. %0, %3, %2\n" \

-		"mcrxr cr1\n" \

-		"mfcr %1\n" \

-		: "=r" (Result), \

-		"=r" (Flags) \

-		: "r" (reg[base].I), \

-		"r" (value), \

-		"r" (C_FLAG << 29) \

-		); \

-	reg[dest].I = Result; \

-	Z_FLAG = (Flags >> 29) & 1; \

-	N_FLAG = (Flags >> 31) & 1; \

-	C_FLAG = (Flags >> 25) & 1; \

-	V_FLAG = (Flags >> 26) & 1; \

-}

-#  define OP_RSCS \

-{ \

-	register int Flags; \

-	register int Result; \

-	asm volatile("mtspr xer, %4\n"\

-		"subfeo. %0, %2, %3\n" \

-		"mcrxr cr1\n" \

-		"mfcr %1\n" \

-		: "=r" (Result), \

-		"=r" (Flags) \

-		: "r" (reg[base].I), \

-		"r" (value), \

-		"r" (C_FLAG << 29) \

-		); \

-	reg[dest].I = Result; \

-	Z_FLAG = (Flags >> 29) & 1; \

-	N_FLAG = (Flags >> 31) & 1; \

-	C_FLAG = (Flags >> 25) & 1; \

-	V_FLAG = (Flags >> 26) & 1; \

-}

-#  define OP_CMP \