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

 		else if (!vol)

 		{

 			// Maintain phase when not playing

-			int32_t count = (end_time - time + per - 1) / per;

+			count = (end_time - time + per - 1) / per;

 			time += static_cast<blip_time_t>(count) * per;

 			bits = run_lfsr(bits, ~mask, count);

 		}

@@ -373,7 +373,7 @@ void Gb_Square::run(blip_time_t time, blip_time_t end_time)

 		if (!vol)

 		{

 			// Maintain phase when not playing

-			int count = (end_time - time + per - 1) / per;

+			int32_t count = (end_time - time + per - 1) / per;

 			ph += count; // will be masked below

 			time += static_cast<blip_time_t>(count) * per;

 		}

@@ -402,7 +402,7 @@ void Gb_Square::run(blip_time_t time, blip_time_t end_time)

 // Quickly runs LFSR for a large number of clocks. For use when noise is generating

 // no sound.

-static unsigned run_lfsr(unsigned s, unsigned mask, int count)

+static unsigned run_lfsr(unsigned s, unsigned mask, int32_t count)

 {

 	static const bool optimized = true; // set to false to use only unoptimized loop in middle

@@ -513,11 +513,11 @@ 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;

+	int32_t 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;

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

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

 	this->delay = count * period1 - extra;

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

 		else if (!vol)

 		{

 			// Maintain phase when not playing

-			int count = (end_time - time + per - 1) / per;

+			int32_t count = (end_time - time + per - 1) / per;

 			time += static_cast<blip_time_t>(count) * per;

 			bits = run_lfsr(bits, ~mask, count);

 		}

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

 		if (!playing)

 		{

 			// Maintain phase when not playing

-			int count = (end_time - time + per - 1) / per;

+			int32_t count = (end_time - time + per - 1) / per;

 			ph += count; // will be masked below

 			time += static_cast<blip_time_t>(count) * per;

 		}

@@ -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

@@ -13,8 +13,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 */

-#include "blargg_source.h"

-

 static const bool cgb_02 = false; // enables bug in early CGB units that causes problems in some games

 static const bool cgb_05 = false; // enables CGB-05 zombie behavior

@@ -45,14 +43,14 @@ void Gb_Osc::update_amp(blip_time_t time, int new_amp)

 void Gb_Osc::clock_length()

 {

-	if ((this->regs [4] & length_enabled) && this->length_ctr)

+	if ((this->regs[4] & length_enabled) && this->length_ctr)

 	{

 		if (--this->length_ctr <= 0)

 			this->enabled = false;

 	}

 }

-inline int Gb_Env::reload_env_timer()

+int Gb_Env::reload_env_timer()

 {

 	int raw = this->regs[2] & 7;

 	this->env_delay = raw ? raw : 8;

@@ -154,7 +152,7 @@ int Gb_Osc::write_trig(int frame_phase, int max_len, int old_data)

 	return data & trigger_mask;

 }

-inline void Gb_Env::zombie_volume(int old, int data)

+void Gb_Env::zombie_volume(int old, int data)

 {

 	int v = this->volume;

 	if (this->mode == Gb_Apu::mode_agb || cgb_05)

@@ -188,7 +186,7 @@ inline void Gb_Env::zombie_volume(int old, int data)

 	this->volume = v & 0x0F;

 }

-bool Gb_Env::write_register( int frame_phase, int reg, int old, int data )

+bool Gb_Env::write_register(int frame_phase, int reg, int old, int data)

 {

 	static const int max_len = 64;

@@ -235,7 +233,7 @@ bool Gb_Square::write_register(int frame_phase, int reg, int old_data, int data)

 	return result;

 }

-inline void Gb_Noise::write_register( int frame_phase, int reg, int old_data, int data )

+void Gb_Noise::write_register(int frame_phase, int reg, int old_data, int data)

 {

 	if (Gb_Env::write_register(frame_phase, reg, old_data, data))

 	{

@@ -244,7 +242,7 @@ inline void Gb_Noise::write_register( int frame_phase, int reg, int old_data, in

 	}

 }

-inline void Gb_Sweep_Square::write_register(int frame_phase, int reg, int old_data, int data)

+void Gb_Sweep_Square::write_register(int frame_phase, int reg, int old_data, int data)

 {

 	if (!reg && this->sweep_enabled && this->sweep_neg && !(data & 0x08))

 		this->enabled = false; // sweep negate disabled after used

@@ -270,7 +268,7 @@ void Gb_Wave::corrupt_wave()

 			this->wave_ram[i] = this->wave_ram[(pos & ~3) + i];

 }

-inline void Gb_Wave::write_register(int frame_phase, int reg, int old_data, int data)

+void Gb_Wave::write_register(int frame_phase, int reg, int old_data, int data)

 {

 	static const int max_len = 256;

@@ -455,7 +453,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

@@ -521,7 +519,7 @@ void Gb_Noise::run(blip_time_t time, blip_time_t end_time)

 		int per2 = this->period2();

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

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

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

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

 		this->delay = count * period1 - extra;

 	}

@@ -579,7 +577,7 @@ void Gb_Wave::run(blip_time_t time, blip_time_t end_time)

 	auto out = this->output;

 	if (out)

 	{

-		int amp = dac_off_amp;

+		int amp = this->dac_off_amp;

 		if (this->dac_enabled())

 		{

 			// Play inaudible frequencies as constant amplitude

@@ -589,7 +587,7 @@ 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 = enabled;

+					playing = this->enabled;

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

 			}

@@ -634,7 +632,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

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

 #include "blargg_source.h"

-bool const cgb_02 = false; // enables bug in early CGB units that causes problems in some games

-bool const cgb_05 = false; // enables CGB-05 zombie behavior

+static const bool cgb_02 = false; // enables bug in early CGB units that causes problems in some games

+static const bool cgb_05 = false; // enables CGB-05 zombie behavior

-int const trigger_mask   = 0x80;

-int const length_enabled = 0x40;

+static const int trigger_mask = 0x80;

+static const int length_enabled = 0x40;

 void Gb_Osc::reset()

 {

-	output   = 0;

-	last_amp = 0;

-	delay    = 0;

-	phase    = 0;

-	enabled  = false;

+	this->output = nullptr;

+	this->last_amp = 0;

+	this->delay = 0;

+	this->phase = 0;

+	this->enabled = false;

 }

-inline void Gb_Osc::update_amp( blip_time_t time, int new_amp )

+void Gb_Osc::update_amp(blip_time_t time, int new_amp)

 {

-	output->set_modified();

-	int delta = new_amp - last_amp;

-	if ( delta )

+	this->output->set_modified();

+	int delta = new_amp - this->last_amp;

+	if (delta)

 	{

-		last_amp = new_amp;

-		med_synth->offset( time, delta, output );

+		this->last_amp = new_amp;

+		this->med_synth->offset(time, delta, this->output);

 	}

 }

@@ -45,81 +45,79 @@ inline void Gb_Osc::update_amp( blip_time_t time, int new_amp )

 void Gb_Osc::clock_length()

 {

-	if ( (regs [4] & length_enabled) && length_ctr )

+	if ((this->regs [4] & length_enabled) && this->length_ctr)

 	{

-		if ( --length_ctr <= 0 )

-			enabled = false;

+		if (--this->length_ctr <= 0)

+			this->enabled = false;

 	}

 }

 inline int Gb_Env::reload_env_timer()

 {

-	int raw = regs [2] & 7;

-	env_delay = (raw ? raw : 8);

+	int raw = this->regs[2] & 7;

+	this->env_delay = raw ? raw : 8;

 	return raw;

 }

 void Gb_Env::clock_envelope()

 {

-	if ( env_enabled && --env_delay <= 0 && reload_env_timer() )

+	if (this->env_enabled && --this->env_delay <= 0 && this->reload_env_timer())

 	{

-		int v = volume + (regs [2] & 0x08 ? +1 : -1);

-		if ( 0 <= v && v <= 15 )

-			volume = v;

+		int v = this->volume + (this->regs[2] & 0x08 ? 1 : -1);

+		if (0 <= v && v <= 15)

+			this->volume = v;

 		else

-			env_enabled = false;

+			this->env_enabled = false;

 	}

 }

-inline void Gb_Sweep_Square::reload_sweep_timer()

+void Gb_Sweep_Square::reload_sweep_timer()

 {

-	sweep_delay = (regs [0] & period_mask) >> 4;

-	if ( !sweep_delay )

-		sweep_delay = 8;

+	this->sweep_delay = (this->regs[0] & period_mask) >> 4;

+	if (!this->sweep_delay)

+		this->sweep_delay = 8;

 }

-void Gb_Sweep_Square::calc_sweep( bool update )

+void Gb_Sweep_Square::calc_sweep(bool update)

 {

-	int const shift = regs [0] & shift_mask;

-	int const delta = sweep_freq >> shift;

-	sweep_neg = (regs [0] & 0x08) != 0;

-	int const freq = sweep_freq + (sweep_neg ? -delta : delta);

-

-	if ( freq > 0x7FF )

-	{

-		enabled = false;

-	}

-	else if ( shift && update )

+	int shift = this->regs[0] & shift_mask;

+	int delta = this->sweep_freq >> shift;

+	this->sweep_neg = !!(this->regs[0] & 0x08);

+	int freq = this->sweep_freq + (this->sweep_neg ? -delta : delta);

+

+	if (freq > 0x7FF)

+		this->enabled = false;

+	else if (shift && update)

 	{

-		sweep_freq = freq;

+		this->sweep_freq = freq;

-		regs [3] = freq & 0xFF;

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

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

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

 	}

 }

 void Gb_Sweep_Square::clock_sweep()

 {

-	if ( --sweep_delay <= 0 )

+	if (--this->sweep_delay <= 0)

 	{

-		reload_sweep_timer();

-		if ( sweep_enabled && (regs [0] & period_mask) )

+		this->reload_sweep_timer();

+		if (this->sweep_enabled && (this->regs[0] & period_mask))

 		{

-			calc_sweep( true  );

-			calc_sweep( false );

+			this->calc_sweep(true);

+			this->calc_sweep(false);

 		}

 	}

 }

-int Gb_Wave::access( unsigned addr ) const

+int Gb_Wave::access(unsigned addr) const

 {

-	if ( enabled && mode != Gb_Apu::mode_agb )

+	if (this->enabled && this->mode != Gb_Apu::mode_agb)

 	{

-		addr = phase & (bank_size - 1);

-		if ( mode == Gb_Apu::mode_dmg )

+		addr = this->phase & (bank_size - 1);

+		if (this->mode == Gb_Apu::mode_dmg)

 		{

-			addr++;

-			if ( delay > clk_mul )

+			++addr;

+			if (this->delay > clk_mul)

 				return -1; // can only access within narrow time window while playing

 		}

 		addr >>= 1;

@@ -129,205 +127,209 @@ int Gb_Wave::access( unsigned addr ) const

 // write_register

-int Gb_Osc::write_trig( int frame_phase, int max_len, int old_data )

+int Gb_Osc::write_trig(int frame_phase, int max_len, int old_data)

 {

-	int data = regs [4];

+	int data = this->regs[4];

-	if ( (frame_phase & 1) && !(old_data & length_enabled) && length_ctr )

+	if ((frame_phase & 1) && !(old_data & length_enabled) && this->length_ctr)

 	{

-		if ( (data & length_enabled) || cgb_02 )

-			length_ctr--;

+		if ((data & length_enabled) || cgb_02)

+			--this->length_ctr;

 	}

-	if ( data & trigger_mask )

+	if (data & trigger_mask)

 	{

-		enabled = true;

-		if ( !length_ctr )

+		this->enabled = true;

+		if (!this->length_ctr)

 		{

-			length_ctr = max_len;

-			if ( (frame_phase & 1) && (data & length_enabled) )

-				length_ctr--;

+			this->length_ctr = max_len;

+			if ((frame_phase & 1) && (data & length_enabled))

+				--this->length_ctr;

 		}

 	}

-	if ( !length_ctr )

-		enabled = false;

+	if (!this->length_ctr)

+		this->enabled = false;

 	return data & trigger_mask;

 }

-inline void Gb_Env::zombie_volume( int old, int data )

+inline void Gb_Env::zombie_volume(int old, int data)

 {

-	int v = volume;

-	if ( mode == Gb_Apu::mode_agb || cgb_05 )

+	int v = this->volume;

+	if (this->mode == Gb_Apu::mode_agb || cgb_05)

 	{

 		// CGB-05 behavior, very close to AGB behavior as well

-		if ( (old ^ data) & 8 )

+		if ((old ^ data) & 8)

 		{

-			if ( !(old & 8) )

+			if (!(old & 8))

 			{

-				v++;

-				if ( old & 7 )

-					v++;

+				++v;

+				if (old & 7)

+					++v;

 			}

 			v = 16 - v;

 		}

-		else if ( (old & 0x0F) == 8 )

-		{

-			v++;

-		}

+		else if ((old & 0x0F) == 8)

+			++v;

 	}

 	else

 	{

 		// CGB-04&02 behavior, very close to MGB behavior as well

-		if ( !(old & 7) && env_enabled )

-			v++;

-		else if ( !(old & 8) )

+		if (!(old & 7) && this->env_enabled)

+			++v;

+		else if (!(old & 8))

 			v += 2;

-		if ( (old ^ data) & 8 )

+		if ((old ^ data) & 8)

 			v = 16 - v;

 	}

-	volume = v & 0x0F;

+	this->volume = v & 0x0F;

 }

 bool Gb_Env::write_register( int frame_phase, int reg, int old, int data )

 {

-	int const max_len = 64;

+	static const int max_len = 64;

-	switch ( reg )

+	switch (reg)

 	{

-	case 1:

-		length_ctr = max_len - (data & (max_len - 1));

-		break;

+		case 1:

+			this->length_ctr = max_len - (data & (max_len - 1));

+			break;

-	case 2:

-		if ( !dac_enabled() )

-			enabled = false;

+		case 2:

+			if (!this->dac_enabled())

+				this->enabled = false;

-		zombie_volume( old, data );

+			this->zombie_volume(old, data);

-		if ( (data & 7) && env_delay == 8 )

-		{

-			env_delay = 1;

-			clock_envelope(); // TODO: really happens at next length clock

-		}

-		break;

+			if ((data & 7) && this->env_delay == 8)

+			{

+				this->env_delay = 1;

+				this->clock_envelope(); // TODO: really happens at next length clock

+			}

+			break;

-	case 4:

-		if ( write_trig( frame_phase, max_len, old ) )

-		{

-			volume = regs [2] >> 4;

-			reload_env_timer();

-			env_enabled = true;

-			if ( frame_phase == 7 )

-				env_delay++;

-			if ( !dac_enabled() )

-				enabled = false;

-			return true;

-		}

+		case 4:

+			if (this->write_trig(frame_phase, max_len, old))

+			{

+				this->volume = this->regs[2] >> 4;

+				this->reload_env_timer();

+				this->env_enabled = true;

+				if (frame_phase == 7)

+					++this->env_delay;

+				if (!this->dac_enabled())

+					this->enabled = false;

+				return true;

+			}

 	}

 	return false;

 }

-bool Gb_Square::write_register( int frame_phase, int reg, int old_data, int data )

+bool Gb_Square::write_register(int frame_phase, int reg, int old_data, int data)

 {

-	bool result = Gb_Env::write_register( frame_phase, reg, old_data, data );

-	if ( result )

-		delay = (delay & (4 * clk_mul - 1)) + period();

+	bool result = Gb_Env::write_register(frame_phase, reg, old_data, data);

+	if (result)

+		this->delay = (this->delay & (4 * clk_mul - 1)) + this->period();

 	return result;

 }

 inline void Gb_Noise::write_register( int frame_phase, int reg, int old_data, int data )

 {

-	if ( Gb_Env::write_register( frame_phase, reg, old_data, data ) )

+	if (Gb_Env::write_register(frame_phase, reg, old_data, data))

 	{

-		phase = 0x7FFF;

-		delay += 8 * clk_mul;

+		this->phase = 0x7FFF;

+		this->delay += 8 * clk_mul;

 	}

 }

-inline void Gb_Sweep_Square::write_register( int frame_phase, int reg, int old_data, int data )

+inline void Gb_Sweep_Square::write_register(int frame_phase, int reg, int old_data, int data)

 {

-	if ( reg == 0 && sweep_enabled && sweep_neg && !(data & 0x08) )

-		enabled = false; // sweep negate disabled after used

+	if (!reg && this->sweep_enabled && this->sweep_neg && !(data & 0x08))

+		this->enabled = false; // sweep negate disabled after used

-	if ( Gb_Square::write_register( frame_phase, reg, old_data, data ) )

+	if (Gb_Square::write_register(frame_phase, reg, old_data, data))

 	{

-		sweep_freq = frequency();

-		sweep_neg = false;

-		reload_sweep_timer();

-		sweep_enabled = (regs [0] & (period_mask | shift_mask)) != 0;

-		if ( regs [0] & shift_mask )

-			calc_sweep( false );

+		this->sweep_freq = this->frequency();

+		this->sweep_neg = false;

+		this->reload_sweep_timer();

+		this->sweep_enabled = !!(this->regs[0] & (period_mask | shift_mask));

+		if (this->regs[0] & shift_mask)

+			this->calc_sweep(false);

 	}

 }

 void Gb_Wave::corrupt_wave()

 {

-	int pos = ((phase + 1) & (bank_size - 1)) >> 1;

-	if ( pos < 4 )

-		wave_ram [0] = wave_ram [pos];

+	int pos = ((this->phase + 1) & (bank_size - 1)) >> 1;

+	if (pos < 4)

+		this->wave_ram[0] = this->wave_ram[pos];

 	else

-		for ( int i = 4; --i >= 0; )

-			wave_ram [i] = wave_ram [(pos & ~3) + i];

+		for (int i = 4; --i >= 0; )

+			this->wave_ram[i] = this->wave_ram[(pos & ~3) + i];

 }

-inline void Gb_Wave::write_register( int frame_phase, int reg, int old_data, int data )

+inline void Gb_Wave::write_register(int frame_phase, int reg, int old_data, int data)

 {

-	int const max_len = 256;

+	static const int max_len = 256;

-	switch ( reg )

+	switch (reg)

 	{

-	case 0:

-		if ( !dac_enabled() )

-			enabled = false;

-		break;

-

-	case 1:

-		length_ctr = max_len - data;

-		break;

-

-	case 4:

-		bool was_enabled = enabled;

-		if ( write_trig( frame_phase, max_len, old_data ) )

-		{

-			if ( !dac_enabled() )

-				enabled = false;

-			else if ( mode == Gb_Apu::mode_dmg && was_enabled &&

-					(unsigned) (delay - 2 * clk_mul) < 2 * clk_mul )

-				corrupt_wave();

-

-			phase = 0;

-			delay    = period() + 6 * clk_mul;

-		}

+		case 0:

+			if (!this->dac_enabled())

+				this->enabled = false;

+			break;

+

+		case 1:

+			this->length_ctr = max_len - data;

+			break;

+

+		case 4:

+			bool was_enabled = this->enabled;

+			if (this->write_trig(frame_phase, max_len, old_data))

+			{

+				if (!this->dac_enabled())

+					this->enabled = false;

+				else if (this->mode == Gb_Apu::mode_dmg && was_enabled && static_cast<unsigned>(this->delay - 2 * clk_mul) < 2 * clk_mul)

+					this->corrupt_wave();

+

+				this->phase = 0;

+				this->delay = this->period() + 6 * clk_mul;

+			}

 	}

 }

-void Gb_Apu::write_osc( int index, int reg, int old_data, int data )

+void Gb_Apu::write_osc(int index, int reg, int old_data, int data)

 {

 	reg -= index * 5;

-	switch ( index )

+	switch (index)

 	{

-	case 0: square1.write_register( frame_phase, reg, old_data, data ); break;

-	case 1: square2.write_register( frame_phase, reg, old_data, data ); break;

-	case 2: wave   .write_register( frame_phase, reg, old_data, data ); break;

-	case 3: noise  .write_register( frame_phase, reg, old_data, data ); break;

+		case 0:

+			this->square1.write_register(this->frame_phase, reg, old_data, data);

+			break;

+		case 1:

+			this->square2.write_register(this->frame_phase, reg, old_data, data);

+			break;

+		case 2:

+			this->wave.write_register(this->frame_phase, reg, old_data, data);

+			break;

+		case 3:

+			this->noise.write_register(this->frame_phase, reg, old_data, data);

 	}

 }

 // Synthesis

-void Gb_Square::run( blip_time_t time, blip_time_t end_time )

+void Gb_Square::run(blip_time_t time, blip_time_t end_time)

 {

 	// Calc duty and phase

-	static byte const duty_offsets [4] = { 1, 1, 3, 7 };

-	static byte const duties       [4] = { 1, 2, 4, 6 };

-	int const duty_code = regs [1] >> 6;

-	int duty_offset = duty_offsets [duty_code];

-	int duty = duties [duty_code];

-	if ( mode == Gb_Apu::mode_agb )

+	static const uint8_t duty_offsets[] = { 1, 1, 3, 7 };

+	static const uint8_t duties[] = { 1, 2, 4, 6 };

+	int duty_code = this->regs[1] >> 6;

+	int duty_offset = duty_offsets[duty_code];

+	int duty = duties[duty_code];

+	if (this->mode == Gb_Apu::mode_agb)

 	{

 		// AGB uses inverted duty

 		duty_offset -= duty;

@@ -337,46 +339,46 @@ void Gb_Square::run( blip_time_t time, blip_time_t end_time )

 	// Determine what will be generated

 	int vol = 0;

-	Blip_Buffer* const out = this->output;

-	if ( out )

+	auto out = this->output;

+	if (out)

 	{

-		int amp = dac_off_amp;

-		if ( dac_enabled() )

+		int amp = this->dac_off_amp;

+		if (this->dac_enabled())

 		{

-			if ( enabled )

+			if (this->enabled)

 				vol = this->volume;

 			amp = -dac_bias;

-			if ( mode == Gb_Apu::mode_agb )

+			if (this->mode == Gb_Apu::mode_agb)

 				amp = -(vol >> 1);

 			// Play inaudible frequencies as constant amplitude

-			if ( frequency() >= 0x7FA && delay < 32 * clk_mul )

+			if (this->frequency() >= 0x7FA && this->delay < 32 * clk_mul)

 			{

 				amp += (vol * duty) >> 3;

 				vol = 0;

 			}

-			if ( ph < duty )

+			if (ph < duty)

 			{

 				amp += vol;

 				vol = -vol;

 			}

 		}

-		update_amp( time, amp );

+		this->update_amp(time, amp);

 	}

 	// Generate wave

-	time += delay;

-	if ( time < end_time )

+	time += this->delay;

+	if (time < end_time)

 	{

-		int const per = this->period();

-		if ( !vol )

+		int per = this->period();

+		if (!vol)

 		{

 			// Maintain phase when not playing

 			int count = (end_time - time + per - 1) / per;

 			ph += count; // will be masked below

-			time += (blip_time_t) count * per;

+			time += static_cast<blip_time_t>(count) * per;

 		}

 		else

 		{

@@ -385,35 +387,34 @@ void Gb_Square::run( blip_time_t time, blip_time_t end_time )

 			do

 			{

 				ph = (ph + 1) & 7;

-				if ( ph == 0 || ph == duty )

+				if (!ph || ph == duty)

 				{

-					good_synth->offset_inline( time, delta, out );

+					this->good_synth->offset_inline(time, delta, out);

 					delta = -delta;

 				}

 				time += per;

-			}

-			while ( time < end_time );

+			} while (time < end_time);

-			if ( delta != vol )

-				last_amp -= delta;

+			if (delta != vol)

+				this->last_amp -= delta;

 		}

 		this->phase = (ph - duty_offset) & 7;

 	}

-	delay = time - end_time;

+	this->delay = time - end_time;

 }

 // Quickly runs LFSR for a large number of clocks. For use when noise is generating

 // no sound.

-static unsigned run_lfsr( unsigned s, unsigned mask, int count )

+static unsigned run_lfsr(unsigned s, unsigned mask, int count)

 {

-	bool const optimized = true; // set to false to use only unoptimized loop in middle

+	static const bool optimized = true; // set to false to use only unoptimized loop in middle

 	// optimization used in several places:

 	// ((s & (1 << b)) << n) ^ ((s & (1 << b)) << (n + 1)) = (s & (1 << b)) * (3 << n)

-	if ( mask == 0x4000 && optimized )

+	if (mask == 0x4000 && optimized)

 	{

-		if ( count >= 32767 )

+		if (count >= 32767)

 			count %= 32767;