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

 #include <algorithm>

 #include "Gb_Apu.h"

+#include "XSFCommon.h"

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

 can redistribute it and/or modify it under the terms of the GNU Lesser

@@ -76,7 +77,7 @@ void Gb_Apu::apply_volume()

 void Gb_Apu::volume(double v)

 {

-	if (this->volume_ != v)

+	if (!fEqual(this->volume_, v))

 	{

 		this->volume_ = v;

 		this->apply_volume();

@@ -157,7 +158,7 @@ void Gb_Apu::reset(mode_t mode, bool agb_wave)

 void Gb_Apu::set_tempo(double t)

 {

 	this->frame_period = 4194304 / 512; // 512 Hz

-	if (t != 1.0)

+	if (!fEqual(t, 1.0))

 		this->frame_period = static_cast<blip_time_t>(this->frame_period / t);

 }

@@ -24,7 +24,8 @@ static const int power_mask = 0x80;

 void Gb_Apu::treble_eq(const blip_eq_t &eq)

 {

 	this->good_synth.treble_eq(eq);

-	this->med_synth.treble_eq(eq);

+	this->med_synth[0].treble_eq(eq);

+	this->med_synth[1].treble_eq(eq);

 }

 int Gb_Apu::calc_output(int osc) const

@@ -57,7 +58,8 @@ void Gb_Apu::synth_volume(int iv)

 {

 	double v = this->volume_ * 0.60 / osc_count / 15 /*steps*/ / 8 /*master vol range*/ * iv;

 	this->good_synth.volume(v);

-	this->med_synth.volume(v);

+	this->med_synth[0].volume(v);

+	this->med_synth[1].volume(v * 1.4);

 }

 void Gb_Apu::apply_volume()

@@ -174,7 +176,7 @@ Gb_Apu::Gb_Apu()

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

 		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;

+		o.med_synth = &this->med_synth[i == 3 ? 1 : 0];

 	}

 	this->reduce_clicks_ = false;

@@ -255,7 +257,7 @@ void Gb_Apu::silence_osc(Gb_Osc &o)

 		if (o.output)

 		{

 			o.output->set_modified();

-			this->med_synth.offset(this->last_time, delta, o.output);

+			this->med_synth[0].offset(this->last_time, delta, o.output);

 		}

 	}

 }

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

 void Gb_Apu::reset_regs()

 {

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

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

 	this->square1.reset();

 	this->square2.reset();

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

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

-#include "blargg_source.h"

-

 static const unsigned vol_reg = 0xFF24;

 static const unsigned stereo_reg = 0xFF25;

 static const unsigned status_reg = 0xFF26;

@@ -76,7 +74,7 @@ void Gb_Apu::apply_volume()

 void Gb_Apu::volume(double v)

 {

-	if (volume_ != v)

+	if (this->volume_ != v)

 	{

 		this->volume_ = v;

 		this->apply_volume();

@@ -117,7 +115,7 @@ void Gb_Apu::reduce_clicks(bool reduce)

 		this->oscs[i]->dac_off_amp = dac_off_amp;

 	// AGB always eliminates clicks on wave channel using same method

-	if (wave.mode == mode_agb)

+	if (this->wave.mode == mode_agb)

 		this->wave.dac_off_amp = -Gb_Osc::dac_bias;

 }

@@ -166,10 +164,10 @@ Gb_Apu::Gb_Apu()

 {

 	this->wave.wave_ram = &this->regs[wave_ram - start_addr];

-	this->oscs [0] = &this->square1;

-	this->oscs [1] = &this->square2;

-	this->oscs [2] = &this->wave;

-	this->oscs [3] = &this->noise;

+	this->oscs[0] = &this->square1;

+	this->oscs[1] = &this->square2;

+	this->oscs[2] = &this->wave;

+	this->oscs[3] = &this->noise;

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

 	{

@@ -199,10 +197,10 @@ void Gb_Apu::run_until_(blip_time_t end_time)

 		if (time > this->frame_time)

 			time = this->frame_time;

-		this->square1.run(last_time, time);

-		this->square2.run(last_time, time);

-		this->wave.run(last_time, time);

-		this->noise.run(last_time, time);

+		this->square1.run(this->last_time, time);

+		this->square2.run(this->last_time, time);

+		this->wave.run(this->last_time, time);

+		this->noise.run(this->last_time, time);

 		this->last_time = time;

 		if (time == end_time)

@@ -358,7 +356,7 @@ int Gb_Apu::read_register(blip_time_t time, unsigned addr)

 		return this->wave.read(addr);

 	// Value read back has some bits always set

-	static const uint8_t masks [] =

+	static const uint8_t masks[] =

 	{

 		0x80, 0x3F, 0x00, 0xFF, 0xBF,

 		0xFF, 0x3F, 0x00, 0xFF, 0xBF,

@@ -1,5 +1,6 @@

 // Gb_Snd_Emu 0.2.0. http://www.slack.net/~ant/

+#include <algorithm>

 #include "Gb_Apu.h"

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

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

 #include "blargg_source.h"

-unsigned const vol_reg    = 0xFF24;

-unsigned const stereo_reg = 0xFF25;

-unsigned const status_reg = 0xFF26;

-unsigned const wave_ram   = 0xFF30;

+static const unsigned vol_reg = 0xFF24;

+static const unsigned stereo_reg = 0xFF25;

+static const unsigned status_reg = 0xFF26;

+static const unsigned wave_ram = 0xFF30;

-int const power_mask = 0x80;

+static const int power_mask = 0x80;

-void Gb_Apu::treble_eq( blip_eq_t const& eq )

+void Gb_Apu::treble_eq(const blip_eq_t &eq)

 {

-	good_synth.treble_eq( eq );

-	med_synth .treble_eq( eq );

+	this->good_synth.treble_eq(eq);

+	this->med_synth.treble_eq(eq);

 }

-inline int Gb_Apu::calc_output( int osc ) const

+int Gb_Apu::calc_output(int osc) const

 {

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

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

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

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

 }

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

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

 {

 	// Must be silent (all NULL), mono (left and right NULL), or stereo (none NULL)

-	require( !center || (center && !left && !right) || (center && left && right) );

-	require( (unsigned) osc <= osc_count ); // fails if you pass invalid osc index

+	assert(!center || (center && !left && !right) || (center && left && right));

+	assert(static_cast<unsigned>(osc) <= osc_count); // fails if you pass invalid osc index

-	if ( !center || !left || !right )

-	{

-		left  = center;

-		right = center;

-	}

+	if (!center || !left || !right)

+		left = right = center;

-	int i = (unsigned) osc % osc_count;

+	int i = static_cast<unsigned>(osc) % osc_count;

 	do

 	{

-		Gb_Osc& o = *oscs [i];

-		o.outputs [1] = right;

-		o.outputs [2] = left;

-		o.outputs [3] = center;

-		o.output = o.outputs [calc_output( i )];

-	}

-	while ( ++i < osc );

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

+		o.outputs[1] = right;

+		o.outputs[2] = left;

+		o.outputs[3] = center;

+		o.output = o.outputs[this->calc_output(i)];

+	} while (++i < osc);

 }

-void Gb_Apu::synth_volume( int iv )

+void Gb_Apu::synth_volume(int iv)

 {

-	double v = volume_ * 0.60 / osc_count / 15 /*steps*/ / 8 /*master vol range*/ * iv;

-	good_synth.volume( v );

-	med_synth .volume( v );

+	double v = this->volume_ * 0.60 / osc_count / 15 /*steps*/ / 8 /*master vol range*/ * iv;

+	this->good_synth.volume(v);

+	this->med_synth.volume(v);

 }

 void Gb_Apu::apply_volume()

 {

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

 	// Not worth the complexity.

-	int data  = regs [vol_reg - start_addr];

-	int left  = data >> 4 & 7;

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

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

-	synth_volume( max( left, right ) + 1 );

+	this->synth_volume(std::max(left, right) + 1);

 }

-void Gb_Apu::volume( double v )

+void Gb_Apu::volume(double v)

 {

-	if ( volume_ != v )

+	if (volume_ != v)

 	{

-		volume_ = v;

-		apply_volume();

+		this->volume_ = v;

+		this->apply_volume();

 	}

 }

 void Gb_Apu::reset_regs()

 {

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

-		regs [i] = 0;

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

+		this->regs[i] = 0;

-	square1.reset();

-	square2.reset();

-	wave   .reset();

-	noise  .reset();

+	this->square1.reset();

+	this->square2.reset();

+	this->wave.reset();

+	this->noise.reset();

-	apply_volume();

+	this->apply_volume();

 }

 void Gb_Apu::reset_lengths()

 {

-	square1.length_ctr = 64;

-	square2.length_ctr = 64;

-	wave   .length_ctr = 256;

-	noise  .length_ctr = 64;

+	this->square1.length_ctr = 64;

+	this->square2.length_ctr = 64;

+	this->wave.length_ctr = 256;

+	this->noise.length_ctr = 64;

 }

-void Gb_Apu::reduce_clicks( bool reduce )

+void Gb_Apu::reduce_clicks(bool reduce)

 {

-	reduce_clicks_ = reduce;

+	this->reduce_clicks_ = reduce;

 	// Click reduction makes DAC off generate same output as volume 0

 	int dac_off_amp = 0;

-	if ( reduce && wave.mode != mode_agb ) // AGB already eliminates clicks

+	if (reduce && this->wave.mode != mode_agb) // AGB already eliminates clicks

 		dac_off_amp = -Gb_Osc::dac_bias;

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

-		oscs [i]->dac_off_amp = dac_off_amp;

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

+		this->oscs[i]->dac_off_amp = dac_off_amp;

 	// AGB always eliminates clicks on wave channel using same method

-	if ( wave.mode == mode_agb )

-		wave.dac_off_amp = -Gb_Osc::dac_bias;

+	if (wave.mode == mode_agb)

+		this->wave.dac_off_amp = -Gb_Osc::dac_bias;

 }

-void Gb_Apu::reset( mode_t mode, bool agb_wave )

+void Gb_Apu::reset(mode_t mode, bool agb_wave)

 {

 	// Hardware mode

-	if ( agb_wave )

+	if (agb_wave)

 		mode = mode_agb; // using AGB wave features implies AGB hardware

-	wave.agb_mask = agb_wave ? 0xFF : 0;

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

-		oscs [i]->mode = mode;

-	reduce_clicks( reduce_clicks_ );

+	this->wave.agb_mask = agb_wave ? 0xFF : 0;

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

+		this->oscs[i]->mode = mode;

+	this->reduce_clicks(this->reduce_clicks_);

 	// Reset state

-	frame_time  = 0;

-	last_time   = 0;

-	frame_phase = 0;

+	this->frame_time = 0;

+	this->last_time = 0;

+	this->frame_phase = 0;

-	reset_regs();

-	reset_lengths();

+	this->reset_regs();

+	this->reset_lengths();

 	// Load initial wave RAM

-	static byte const initial_wave [2] [16] = {

-		{0x84,0x40,0x43,0xAA,0x2D,0x78,0x92,0x3C,0x60,0x59,0x59,0xB0,0x34,0xB8,0x2E,0xDA},

-		{0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF},

+	static const uint8_t initial_wave[][16] =

+	{

+		{ 0x84, 0x40, 0x43, 0xAA, 0x2D, 0x78, 0x92, 0x3C, 0x60, 0x59, 0x59, 0xB0, 0x34, 0xB8, 0x2E, 0xDA },

+		{ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF }

 	};

-	for ( int b = 2; --b >= 0; )

+	for (int b = 2; --b >= 0; )

 	{

 		// Init both banks (does nothing if not in AGB mode)

 		// TODO: verify that this works

-		write_register( 0, 0xFF1A, b * 0x40 );

-		for ( unsigned i = 0; i < sizeof initial_wave [0]; i++ )

-			write_register( 0, i + wave_ram, initial_wave [(mode != mode_dmg)] [i] );

+		this->write_register(0, 0xFF1A, b * 0x40);

+		for (unsigned i = 0; i < sizeof(initial_wave[0]); ++i)

+			this->write_register(0, i + wave_ram, initial_wave[mode != mode_dmg][i]);

 	}

 }

-void Gb_Apu::set_tempo( double t )

+void Gb_Apu::set_tempo(double t)

 {

-	frame_period = 4194304 / 512; // 512 Hz

-	if ( t != 1.0 )

-		frame_period = blip_time_t (frame_period / t);

+	this->frame_period = 4194304 / 512; // 512 Hz

+	if (t != 1.0)

+		this->frame_period = static_cast<blip_time_t>(this->frame_period / t);

 }

 Gb_Apu::Gb_Apu()

 {

-	wave.wave_ram = &regs [wave_ram - start_addr];

+	this->wave.wave_ram = &this->regs[wave_ram - start_addr];

-	oscs [0] = &square1;

-	oscs [1] = &square2;

-	oscs [2] = &wave;

-	oscs [3] = &noise;

+	this->oscs [0] = &this->square1;

+	this->oscs [1] = &this->square2;

+	this->oscs [2] = &this->wave;

+	this->oscs [3] = &this->noise;

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

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

 	{

-		Gb_Osc& o = *oscs [i];

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

-		o.output      = 0;

-		o.outputs [0] = 0;

-		o.outputs [1] = 0;

-		o.outputs [2] = 0;

-		o.outputs [3] = 0;

-		o.good_synth  = &good_synth;

-		o.med_synth   = &med_synth;

+		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.good_synth = &this->good_synth;

+		o.med_synth = &this->med_synth;

 	}

-	reduce_clicks_ = false;

-	set_tempo( 1.0 );

-	volume_ = 1.0;

-	reset();

+	this->reduce_clicks_ = false;

+	this->set_tempo(1.0);

+	this->volume_ = 1.0;

+	this->reset();

 }

-void Gb_Apu::run_until_( blip_time_t end_time )

+void Gb_Apu::run_until_(blip_time_t end_time)

 {

-	while ( true )

+	while (1)

 	{

 		// run oscillators

 		blip_time_t time = end_time;

-		if ( time > frame_time )

-			time = frame_time;

+		if (time > this->frame_time)

+			time = this->frame_time;

-		square1.run( last_time, time );

-		square2.run( last_time, time );

-		wave   .run( last_time, time );

-		noise  .run( last_time, time );

-		last_time = time;

+		this->square1.run(last_time, time);

+		this->square2.run(last_time, time);

+		this->wave.run(last_time, time);

+		this->noise.run(last_time, time);

+		this->last_time = time;

-		if ( time == end_time )

+		if (time == end_time)

 			break;

 		// run frame sequencer

-		frame_time += frame_period * Gb_Osc::clk_mul;

-		switch ( frame_phase++ )

+		this->frame_time += this->frame_period * Gb_Osc::clk_mul;

+		switch (this->frame_phase++)

 		{

-		case 2:

-		case 6:

-			// 128 Hz

-			square1.clock_sweep();

-		case 0:

-		case 4:

-			// 256 Hz

-			square1.clock_length();

-			square2.clock_length();

-			wave   .clock_length();

-			noise  .clock_length();

-			break;

-

-		case 7:

-			// 64 Hz

-			frame_phase = 0;

-			square1.clock_envelope();

-			square2.clock_envelope();

-			noise  .clock_envelope();

+			case 2:

+			case 6:

+				// 128 Hz

+				this->square1.clock_sweep();

+			case 0:

+			case 4:

+				// 256 Hz

+				this->square1.clock_length();

+				this->square2.clock_length();

+				this->wave.clock_length();

+				this->noise.clock_length();

+				break;

+			case 7:

+				// 64 Hz

+				this->frame_phase = 0;

+				this->square1.clock_envelope();

+				this->square2.clock_envelope();

+				this->noise.clock_envelope();

 		}

 	}

 }

-inline void Gb_Apu::run_until( blip_time_t time )

+void Gb_Apu::run_until(blip_time_t time)

 {

-	require( time >= last_time ); // end_time must not be before previous time

-	if ( time > last_time )

-		run_until_( time );

+	assert(time >= this->last_time); // end_time must not be before previous time

+	if (time > this->last_time)

+		this->run_until_(time);

 }

-void Gb_Apu::end_frame( blip_time_t end_time )

+void Gb_Apu::end_frame(blip_time_t end_time)

 {

-	if ( end_time > last_time )

-		run_until( end_time );

+	if (end_time > this->last_time)

+		this->run_until(end_time);

-	frame_time -= end_time;

-	assert( frame_time >= 0 );

+	this->frame_time -= end_time;

+	assert(this->frame_time >= 0);

-	last_time -= end_time;

-	assert( last_time >= 0 );

+	this->last_time -= end_time;

+	assert(this->last_time >= 0);

 }

-void Gb_Apu::silence_osc( Gb_Osc& o )

+void Gb_Apu::silence_osc(Gb_Osc &o)

 {

 	int delta = -o.last_amp;

-	if ( delta )

+	if (delta)

 	{

 		o.last_amp = 0;

-		if ( o.output )

+		if (o.output)

 		{

 			o.output->set_modified();

-			med_synth.offset( last_time, delta, o.output );

+			this->med_synth.offset(this->last_time, delta, o.output);

 		}

 	}

 }

 void Gb_Apu::apply_stereo()

 {

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

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

 	{

-		Gb_Osc& o = *oscs [i];

-		Blip_Buffer* out = o.outputs [calc_output( i )];

-		if ( o.output != out )

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

+		auto out = o.outputs[this->calc_output(i)];

+		if (o.output != out)

 		{

-			silence_osc( o );

+			this->silence_osc(o);

 			o.output = out;

 		}

 	}

 }

-void Gb_Apu::write_register( blip_time_t time, unsigned addr, int data )

+void Gb_Apu::write_register(blip_time_t time, unsigned addr, int data)

 {

-	require( (unsigned) data < 0x100 );

+	assert(static_cast<unsigned>(data) < 0x100);

 	int reg = addr - start_addr;

-	if ( (unsigned) reg >= register_count )

+	if (static_cast<unsigned>(reg) >= register_count)

 	{

-		require( false );

+		assert(false);

 		return;

 	}

-	if ( addr < status_reg && !(regs [status_reg - start_addr] & power_mask) )

+	if (addr < status_reg && !(this->regs[status_reg - start_addr] & power_mask))

 	{

 		// Power is off

 		// length counters can only be written in DMG mode

-		if ( wave.mode != mode_dmg || (reg != 1 && reg != 5+1 && reg != 10+1 && reg != 15+1) )

+		if (this->wave.mode != mode_dmg || (reg != 1 && reg != 6 && reg != 11 && reg != 16))

 			return;

-		if ( reg < 10 )

+		if (reg < 10)

 			data &= 0x3F; // clear square duty

 	}

-	run_until( time );

+	this->run_until(time);

-	if ( addr >= wave_ram )

-	{

-		wave.write( addr, data );

-	}

+	if (addr >= wave_ram)

+		this->wave.write(addr, data);

 	else

 	{

-		int old_data = regs [reg];

-		regs [reg] = data;

+		int old_data = this->regs[reg];

+		this->regs[reg] = data;

-		if ( addr < vol_reg )

-		{

+		if (addr < vol_reg)

 			// Oscillator

-			write_osc( reg / 5, reg, old_data, data );

-		}

-		else if ( addr == vol_reg && data != old_data )

+			this->write_osc(reg / 5, reg, old_data, data);

+		else if (addr == vol_reg && data != old_data)

 		{

 			// Master volume

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

-				silence_osc( *oscs [i] );

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

+				this->silence_osc(*this->oscs[i]);

-			apply_volume();

+			this->apply_volume();

 		}

-		else if ( addr == stereo_reg )

-		{

+		else if (addr == stereo_reg)

 			// Stereo panning

-			apply_stereo();

-		}

-		else if ( addr == status_reg && (data ^ old_data) & power_mask )

+			this->apply_stereo();

+		else if (addr == status_reg && ((data ^ old_data) & power_mask))

 		{

 			// Power control

-			frame_phase = 0;

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

-				silence_osc( *oscs [i] );

+			this->frame_phase = 0;

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

+				this->silence_osc(*this->oscs[i]);

-			reset_regs();

-			if ( wave.mode != mode_dmg )

-				reset_lengths();

+			this->reset_regs();

+			if (this->wave.mode != mode_dmg)

+				this->reset_lengths();

-			regs [status_reg - start_addr] = data;

+			this->regs[status_reg - start_addr] = data;

 		}

 	}

 }

-int Gb_Apu::read_register( blip_time_t time, unsigned addr )

+int Gb_Apu::read_register(blip_time_t time, unsigned addr)

 {

-	run_until( time );

+	this->run_until(time);

 	int reg = addr - start_addr;

-	if ( (unsigned) reg >= register_count )

+	if (static_cast<unsigned>(reg) >= register_count)

 	{

-		require( false );

+		assert(false);

 		return 0;

 	}

-	if ( addr >= wave_ram )

-		return wave.read( addr );

+	if (addr >= wave_ram)

+		return this->wave.read(addr);

 	// Value read back has some bits always set

-	static byte const masks [] = {

-		0x80,0x3F,0x00,0xFF,0xBF,

-		0xFF,0x3F,0x00,0xFF,0xBF,

-		0x7F,0xFF,0x9F,0xFF,0xBF,

-		0xFF,0xFF,0x00,0x00,0xBF,

-		0x00,0x00,0x70,

-		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF

+	static const uint8_t masks [] =

+	{

+		0x80, 0x3F, 0x00, 0xFF, 0xBF,

+		0xFF, 0x3F, 0x00, 0xFF, 0xBF,

+		0x7F, 0xFF, 0x9F, 0xFF, 0xBF,

+		0xFF, 0xFF, 0x00, 0x00, 0xBF,

+		0x00, 0x00, 0x70,

+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF

 	};

-	int mask = masks [reg];

-	if ( wave.agb_mask && (reg == 10 || reg == 12) )

+	int mask = masks[reg];

+	if (this->wave.agb_mask && (reg == 10 || reg == 12))

 		mask = 0x1F; // extra implemented bits in wave regs on AGB

-	int data = regs [reg] | mask;

+	int data = this->regs[reg] | mask;

 	// Status register

-	if ( addr == status_reg )

+	if (addr == status_reg)

 	{

 		data &= 0xF0;

-		data |= (int) square1.enabled << 0;

-		data |= (int) square2.enabled << 1;

-		data |= (int) wave   .enabled << 2;

-		data |= (int) noise  .enabled << 3;

+		data |= static_cast<int>(this->square1.enabled);

+		data |= static_cast<int>(this->square2.enabled) << 1;

+		data |= static_cast<int>(this->wave.enabled) << 2;

+		data |= static_cast<int>(this->noise.enabled) << 3;

 	}

 	return data;

@@ -395,10 +387,9 @@ int Gb_Apu::read_register( blip_time_t time, unsigned addr )

 int Gb_Apu::read_status()

 {

-	int data = 0;

-	data |= (int) square1.enabled << 0;

-	data |= (int) square2.enabled << 1;

-	data |= (int) wave   .enabled << 2;

-	data |= (int) noise  .enabled << 3;

+	int data = static_cast<int>(this->square1.enabled);

+	data |= static_cast<int>(this->square2.enabled) << 1;

+	data |= static_cast<int>(this->wave.enabled) << 2;

+	data |= static_cast<int>(this->noise.enabled) << 3;

 	return data;

 }

new file mode 100644

@@ -0,0 +1,404 @@

+// Gb_Snd_Emu 0.2.0. http://www.slack.net/~ant/

+

+#include "Gb_Apu.h"

+

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

+can redistribute it and/or modify it under the terms of the GNU Lesser

+General Public License as published by the Free Software Foundation; either

+version 2.1 of the License, or (at your option) any later version. This

+module is distributed in the hope that it will be useful, but WITHOUT ANY

+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more

+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"

+

+unsigned const vol_reg    = 0xFF24;

+unsigned const stereo_reg = 0xFF25;

+unsigned const status_reg = 0xFF26;

+unsigned const wave_ram   = 0xFF30;

+

+int const power_mask = 0x80;

+

+void Gb_Apu::treble_eq( blip_eq_t const& eq )

+{

+	good_synth.treble_eq( eq );

+	med_synth .treble_eq( eq );

+}

+

+inline int Gb_Apu::calc_output( int osc ) const

+{

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

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

+}

+

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

+{

+	// Must be silent (all NULL), mono (left and right NULL), or stereo (none NULL)

+	require( !center || (center && !left && !right) || (center && left && right) );

+	require( (unsigned) osc <= osc_count ); // fails if you pass invalid osc index

+

+	if ( !center || !left || !right )

+	{

+		left  = center;

+		right = center;

+	}

+

+	int i = (unsigned) osc % osc_count;

+	do

+	{

+		Gb_Osc& o = *oscs [i];

+		o.outputs [1] = right;

+		o.outputs [2] = left;

+		o.outputs [3] = center;

+		o.output = o.outputs [calc_output( i )];

+	}

+	while ( ++i < osc );

+}

+

+void Gb_Apu::synth_volume( int iv )

+{

+	double v = volume_ * 0.60 / osc_count / 15 /*steps*/ / 8 /*master vol range*/ * iv;

+	good_synth.volume( v );

+	med_synth .volume( v );

+}

+

+void Gb_Apu::apply_volume()

+{

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

+	// Not worth the complexity.

+	int data  = regs [vol_reg - start_addr];

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

+	synth_volume( max( left, right ) + 1 );

+}

+

+void Gb_Apu::volume( double v )

+{

+	if ( volume_ != v )

+	{

+		volume_ = v;

+		apply_volume();

+	}