@@ -120,7 +120,7 @@ enum { BLIP_BUFFER_ACCURACY = 16 };

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

 enum

 {

-#if BLIP_BUFFER_FAST

+#ifdef BLIP_BUFFER_FAST

 	BLIP_PHASE_BITS = 8

 #else

 	BLIP_PHASE_BITS = 6

@@ -218,7 +218,7 @@ public:

 	}

 private:

-#if BLIP_BUFFER_FAST

+#ifdef BLIP_BUFFER_FAST

 	Blip_Synth_Fast_ impl;

 #else

 	Blip_Synth_ impl;

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

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

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

-#if BLIP_BUFFER_FAST

+#ifdef BLIP_BUFFER_FAST

 	int32_t left = buf[0] + delta;

 	// Kind of crappy, but doing shift after multiply results in overflow.

@@ -19,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 = 250);

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

 	// Sets number of source time units per second

 	void clock_rate(long clocks_per_sec);

@@ -54,7 +54,7 @@ public:

 	long sample_rate() const;

 	// Length of buffer in milliseconds

-	int length() const;

+	int32_t length() const;

 	// Number of source time units per second

 	long clock_rate() const;

@@ -107,7 +107,7 @@ private:

 	long sample_rate_;

 	long clock_rate_;

 	int bass_freq_;

-	int length_;

+	int32_t length_;

 	Blip_Buffer *modified_; // non-zero = true (more optimal than using bool, heh)

 };

@@ -421,7 +421,7 @@ template<int quality, int range> inline void Blip_Synth<quality, range>::update(

 inline blip_eq_t::blip_eq_t(double t) : treble(t), rolloff_freq(0), sample_rate(44100), cutoff_freq(0) { }

 inline blip_eq_t::blip_eq_t(double t, long rf, long sr, long cf) : treble(t), rolloff_freq(rf), sample_rate(sr), cutoff_freq(cf) { }

-inline int Blip_Buffer::length() const { return this->length_; }

+inline int32_t Blip_Buffer::length() const { return this->length_; }

 inline long Blip_Buffer::samples_avail() const { return static_cast<long>(this->offset_ >> BLIP_BUFFER_ACCURACY); }

 inline long Blip_Buffer::sample_rate() const { return this->sample_rate_; }

 inline int Blip_Buffer::output_latency() const { return blip_widest_impulse_ / 2; }

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

+};

@@ -17,12 +17,10 @@ enum { blip_sample_max = 32767 };

 class Blip_Buffer

 {

 public:

-	typedef const char *blargg_err_t;

-

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

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

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

 	// Sets number of source time units per second

 	void clock_rate(long clocks_per_sec);

@@ -96,8 +94,6 @@ public:

 	// Deprecated

 	typedef blip_resampled_time_t resampled_time_t;

-	blargg_err_t sample_rate(long r) { return this->set_sample_rate(r); }

-	blargg_err_t sample_rate(long r, int msec) { return this->set_sample_rate(r, msec); }

 private:

 	// noncopyable

 	Blip_Buffer(const Blip_Buffer &);

@@ -116,7 +112,6 @@ private:

 	int bass_freq_;

 	int length_;

 	Blip_Buffer *modified_; // non-zero = true (more optimal than using bool, heh)

-	friend class Blip_Reader;

 };

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

@@ -282,8 +277,6 @@ const int blip_reader_default_bass = 9;

 // experimental

 #define BLIP_READER_ADJ_(name, offset) (name##_reader_buf += offset)

-const int32_t blip_reader_idx_factor = sizeof(Blip_Buffer::buf_t_);

-

 #define BLIP_READER_NEXT_IDX_(name, bass, idx) \

 { \

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

@@ -292,15 +285,10 @@ const int32_t blip_reader_idx_factor = sizeof(Blip_Buffer::buf_t_);

 #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));\

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

 }

-// Compatibility with older version

-const long blip_unscaled = 65535;

-const int blip_low_quality = blip_med_quality;

-const int blip_best_quality = blip_high_quality;

-

 #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

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

 	// sub-sample resolution.

 	int32_t right = (delta >> BLIP_PHASE_BITS) * phase;

 	left -= right;

-	right += buf [1];

+	right += buf[1];

 	buf[0] = left;

 	buf[1] = right;

@@ -4,62 +4,54 @@

 #ifndef BLIP_BUFFER_H

 #define BLIP_BUFFER_H

-	// internal

-	#include <limits.h>

-	#if INT_MAX < 0x7FFFFFFF || LONG_MAX == 0x7FFFFFFF

-		typedef long blip_long;

-		typedef unsigned long blip_ulong;

-	#else

-		typedef int blip_long;

-		typedef unsigned blip_ulong;

-	#endif

+#include <vector>

+#include <cstdint>

 // Time unit at source clock rate

-typedef blip_long blip_time_t;

+typedef int32_t blip_time_t;

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

 typedef short blip_sample_t;

 enum { blip_sample_max = 32767 };

-struct blip_buffer_state_t;

-

-class Blip_Buffer {

+class Blip_Buffer

+{

 public:

-	typedef const char* blargg_err_t;

+	typedef const char *blargg_err_t;

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

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

+	blargg_err_t set_sample_rate(long samples_per_sec, int msec_length = 1000 / 4);

 	// Sets number of source time units per second

-	void clock_rate( long clocks_per_sec );

+	void clock_rate(long clocks_per_sec);

 	// Ends current time frame of specified duration and makes its samples available

 	// (along with any still-unread samples) for reading with read_samples(). Begins

 	// a new time frame at the end of the current frame.

-	void end_frame( blip_time_t time );

+	virtual void end_frame(blip_time_t time);

 	// Reads at most 'max_samples' out of buffer into 'dest', removing them from

 	// the buffer. Returns number of samples actually read and removed. If stereo is

 	// true, increments 'dest' one extra time after writing each sample, to allow

 	// easy interleving of two channels into a stereo output buffer.

-	long read_samples( blip_sample_t* dest, long max_samples, int stereo = 0 );

+	long read_samples(blip_sample_t *dest, long max_samples, bool stereo = false);

-// Additional features

+	// Additional features

 	// Removes all available samples and clear buffer to silence. If 'entire_buffer' is

 	// false, just clears out any samples waiting rather than the entire buffer.

-	void clear( int entire_buffer = 1 );

+	void clear(int entire_buffer = 1);

 	// Number of samples available for reading with read_samples()

 	long samples_avail() const;

 	// Removes 'count' samples from those waiting to be read

-	void remove_samples( long count );

+	virtual void remove_samples(long count);

 	// Sets frequency high-pass filter frequency, where higher values reduce bass more

-	void bass_freq( int frequency );

+	void bass_freq(int frequency);

 	// Current output sample rate

 	long sample_rate() const;

@@ -70,16 +62,7 @@ public:

 	// Number of source time units per second

 	long clock_rate() const;

-// Experimental features

-

-	// Saves state, including high-pass filter and tails of last deltas.

-	// All samples must have been read from buffer before calling this.

-	void save_state( blip_buffer_state_t* out );

-

-	// Loads state. State must have been saved from Blip_Buffer with same

-	// settings during same run of program. States can NOT be stored on disk.

-	// Clears buffer before loading state.

-	void load_state( blip_buffer_state_t const& in );

+	// Experimental features

 	// Number of samples delay from synthesis to samples read out

 	int output_latency() const;

@@ -87,113 +70,105 @@ public:

 	// Counts number of clocks needed until 'count' samples will be available.

 	// If buffer can't even hold 'count' samples, returns number of clocks until

 	// buffer becomes full.

-	blip_time_t count_clocks( long count ) const;

+	blip_time_t count_clocks(long count) const;

 	// Number of raw samples that can be mixed within frame of specified duration.

-	long count_samples( blip_time_t duration ) const;

+	long count_samples(blip_time_t duration) const;

 	// Mixes in 'count' samples from 'buf_in'

-	void mix_samples( blip_sample_t const* buf_in, long count );

-

+	void mix_samples(const blip_sample_t *buf_in, long count);

 	// Signals that sound has been added to buffer. Could be done automatically in

 	// Blip_Synth, but that would affect performance more, as you can arrange that

 	// this is called only once per time frame rather than for every delta.

-	void set_modified() { modified_ = this; }

+	void set_modified() { this->modified_ = this; }

 	// not documented yet

-	blip_ulong unsettled() const;

-	Blip_Buffer* clear_modified() { Blip_Buffer* b = modified_; modified_ = 0; return b; }

-	void remove_silence( long count );

-	typedef blip_ulong blip_resampled_time_t;

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

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

-	blip_resampled_time_t clock_rate_factor( long clock_rate ) const;

-public:

+	uint32_t unsettled() const;

+	Blip_Buffer *clear_modified() { auto b = this->modified_; this->modified_ = nullptr; return b; }

+	virtual void remove_silence(long count);

+	typedef uint32_t blip_resampled_time_t;

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

-	~Blip_Buffer();

+	virtual ~Blip_Buffer();

 	// Deprecated

 	typedef blip_resampled_time_t resampled_time_t;

-	blargg_err_t sample_rate( long r ) { return set_sample_rate( r ); }

-	blargg_err_t sample_rate( long r, int msec ) { return set_sample_rate( r, msec ); }

+	blargg_err_t sample_rate(long r) { return this->set_sample_rate(r); }

+	blargg_err_t sample_rate(long r, int msec) { return this->set_sample_rate(r, msec); }

 private:

 	// noncopyable

-	Blip_Buffer( const Blip_Buffer& );

-	Blip_Buffer& operator = ( const Blip_Buffer& );

+	Blip_Buffer(const Blip_Buffer &);

+	Blip_Buffer &operator=(const Blip_Buffer &);

 public:

-	typedef blip_long buf_t_;

-	blip_ulong factor_;

+	typedef int32_t buf_t_;

+	uint32_t factor_;

 	blip_resampled_time_t offset_;

-	buf_t_* buffer_;

-	blip_long buffer_size_;

-	blip_long reader_accum_;

+	std::vector<buf_t_> buffer_;

+	int32_t buffer_size_;

+	int32_t reader_accum_;

 	int bass_shift_;

 private:

 	long sample_rate_;

 	long clock_rate_;

 	int bass_freq_;

 	int length_;

-	Blip_Buffer* modified_; // non-zero = true (more optimal than using bool, heh)

+	Blip_Buffer *modified_; // non-zero = true (more optimal than using bool, heh)

 	friend class Blip_Reader;

 };

-#ifdef HAVE_CONFIG_H

-	#include "config.h"

-#endif

-

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

 // but reduce maximum buffer size.

-#ifndef BLIP_BUFFER_ACCURACY

-	#define BLIP_BUFFER_ACCURACY 16

-#endif

+const int 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.

-#ifndef BLIP_PHASE_BITS

-	#if BLIP_BUFFER_FAST

-		#define BLIP_PHASE_BITS 8

-	#else

-		#define BLIP_PHASE_BITS 6

-	#endif

+#if BLIP_BUFFER_FAST

+const int BLIP_PHASE_BITS = 8;

+#else

+const int BLIP_PHASE_BITS = 6;

 #endif

-	// Internal

-	typedef blip_ulong blip_resampled_time_t;

-	int const blip_widest_impulse_ = 16;

-	int const blip_buffer_extra_ = blip_widest_impulse_ + 2;

-	int const blip_res = 1 << BLIP_PHASE_BITS;

-	class blip_eq_t;

-

-	class Blip_Synth_Fast_ {

-	public:

-		Blip_Buffer* buf;

-		int last_amp;

-		int delta_factor;

-

-		void volume_unit( double );

-		Blip_Synth_Fast_();

-		void treble_eq( blip_eq_t const& ) { }

-	};

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

+class blip_eq_t;

-	class Blip_Synth_ {

-	public:

-		Blip_Buffer* buf;

-		int last_amp;

-		int delta_factor;

-

-		void volume_unit( double );

-		Blip_Synth_( short* impulses, int width );

-		void treble_eq( blip_eq_t const& );

-	private:

-		double volume_unit_;

-		short* const impulses;

-		int const width;

-		blip_long kernel_unit;

-		int impulses_size() const { return blip_res / 2 * width + 1; }

-		void adjust_impulse();

-	};

+class Blip_Synth_Fast_

+{

+public:

+	Blip_Buffer *buf;

+	int last_amp;

+	int delta_factor;

+

+	void volume_unit(double);

+	Blip_Synth_Fast_();

+	void treble_eq(const blip_eq_t &) { }

+};

+

+class Blip_Synth_

+{

+public:

+	Blip_Buffer *buf;

+	int last_amp;

+	int delta_factor;

+

+	void volume_unit(double);

+	Blip_Synth_(short *impulses, int width);

+	void treble_eq(const blip_eq_t &);

+private:

+	double volume_unit_;

+	short *const impulses;

+	const int width;

+	int32_t kernel_unit;

+	int impulses_size() const { return blip_res / 2 * this->width + 1; }

+	void adjust_impulse();

+};

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

 const int blip_med_quality  = 8;

@@ -203,40 +178,42 @@ const int blip_high_quality = 16;

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

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

 // amplitudes (max - min).

-template<int quality,int range>

-class Blip_Synth {

+template<int quality, int range> class Blip_Synth

+{

 public:

 	// Sets overall volume of waveform

-	void volume( double v ) { impl.volume_unit( v * (1.0 / (range < 0 ? -range : range)) ); }

+	void volume(double v) { this->impl.volume_unit(v * (1.0 / (range < 0 ? -range : range))); }

 	// Configures low-pass filter (see blip_buffer.txt)

-	void treble_eq( blip_eq_t const& eq )       { impl.treble_eq( eq ); }

+	void treble_eq(const blip_eq_t &eq) { this->impl.treble_eq(eq); }

 	// Gets/sets Blip_Buffer used for output

-	Blip_Buffer* output() const                 { return impl.buf; }

-	void output( Blip_Buffer* b )               { impl.buf = b; impl.last_amp = 0; }

+	Blip_Buffer *output() const { return this->impl.buf; }

+	void output(Blip_Buffer *b) { this->impl.buf = b; this->impl.last_amp = 0; }

 	// Updates amplitude of waveform at given time. Using this requires a separate

 	// Blip_Synth for each waveform.

-	void update( blip_time_t time, int amplitude );

+	void update(blip_time_t time, int amplitude);

-// Low-level interface

+	// Low-level interface

 	// Adds an amplitude transition of specified delta, optionally into specified buffer

 	// rather than the one set with output(). Delta can be positive or negative.

 	// The actual change in amplitude is delta * (volume / range)

-	void offset( blip_time_t, int delta, Blip_Buffer* ) const;

-	void offset( blip_time_t t, int delta ) const { offset( t, delta, impl.buf ); }

+	void offset(blip_time_t, int delta, Blip_Buffer *) const;

+	void offset(blip_time_t t, int delta) const { this->offset(t, delta, this->impl.buf); }

 	// Works directly in terms of fractional output samples. Contact author for more info.

-	void offset_resampled( blip_resampled_time_t, int delta, Blip_Buffer* ) const;

+	void offset_resampled(blip_resampled_time_t, int delta, Blip_Buffer *) const;

 	// Same as offset(), except code is inlined for higher performance

-	void offset_inline( blip_time_t t, int delta, Blip_Buffer* buf ) const {

-		offset_resampled( t * buf->factor_ + buf->offset_, delta, buf );

+	void offset_inline(blip_time_t t, int delta, Blip_Buffer *buf) const

+	{

+		this->offset_resampled(t * buf->factor_ + buf->offset_, delta, buf);

 	}

-	void offset_inline( blip_time_t t, int delta ) const {

-		offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf );

+	void offset_inline(blip_time_t t, int delta) const

+	{

+		this->offset_resampled(t * this->impl.buf->factor_ + this->impl.buf->offset_, delta, this->impl.buf);

 	}

 private:

@@ -245,312 +222,239 @@ private:

 #else

 	Blip_Synth_ impl;

 	typedef short imp_t;

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

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

 public:

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

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

 #endif

 };

 // Low-pass equalization parameters

-class blip_eq_t {

+class blip_eq_t

+{

 public:

 	// Logarithmic rolloff to treble dB at half sampling rate. Negative values reduce

 	// treble, small positive values (0 to 5.0) increase treble.

-	blip_eq_t( double treble_db = 0 );

+	blip_eq_t(double treble_db = 0);

 	// See blip_buffer.txt

-	blip_eq_t( double treble, long rolloff_freq, long sample_rate, long cutoff_freq = 0 );

+	blip_eq_t(double treble, long rolloff_freq, long sample_rate, long cutoff_freq = 0);

 private:

 	double treble;

 	long rolloff_freq;

 	long sample_rate;

 	long cutoff_freq;

-	void generate( float* out, int count ) const;

+	void generate(float *out, int count) const;

 	friend class Blip_Synth_;

 };

-int const blip_sample_bits = 30;

-

-// Dummy Blip_Buffer to direct sound output to, for easy muting without

-// having to stop sound code.

-class Silent_Blip_Buffer : public Blip_Buffer {

-	buf_t_ buf [blip_buffer_extra_ + 1];

-public:

-	// The following cannot be used (an assertion will fail if attempted):

-	blargg_err_t set_sample_rate( long samples_per_sec, int msec_length );

-	blip_time_t count_clocks( long count ) const;

-	void mix_samples( blip_sample_t const* buf, long count );

-

-	Silent_Blip_Buffer();

-};

-

-	#if __GNUC__ >= 3 || _MSC_VER >= 1100

-		#define BLIP_RESTRICT __restrict

-	#else

-		#define BLIP_RESTRICT

-	#endif

+const int 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 ) \

-	const Blip_Buffer::buf_t_* BLIP_RESTRICT name##_reader_buf = (blip_buffer).buffer_;\

-	blip_long name##_reader_accum = (blip_buffer).reader_accum_

+#define BLIP_READER_BEGIN(name, blip_buffer) \

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

+	int32_t name##_reader_accum = (blip_buffer).reader_accum_

 // Gets value to pass to BLIP_READER_NEXT()

-#define BLIP_READER_BASS( blip_buffer ) ((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

-int const blip_reader_default_bass = 9;

+const int blip_reader_default_bass = 9;

 // Current sample

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

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

 // Current raw sample in full internal resolution

-#define BLIP_READER_READ_RAW( name )    (name##_reader_accum)

+#define BLIP_READER_READ_RAW(name) (name##_reader_accum)

 // Advances to next sample

-#define BLIP_READER_NEXT( name, bass ) \

-	(void) (name##_reader_accum += *name##_reader_buf++ - (name##_reader_accum >> (bass)))

+#define BLIP_READER_NEXT(name, bass) \

+	(name##_reader_accum += *name##_reader_buf++ - (name##_reader_accum >> (bass)))

 // Ends reading samples from buffer. The number of samples read must now be removed

 // using Blip_Buffer::remove_samples().

-#define BLIP_READER_END( name, blip_buffer ) \

-	(void) ((blip_buffer).reader_accum_ = name##_reader_accum)

-

+#define BLIP_READER_END(name, blip_buffer) \

+	((blip_buffer).reader_accum_ = name##_reader_accum)

 // experimental

-#define BLIP_READER_ADJ_( name, offset ) (name##_reader_buf += offset)

+#define BLIP_READER_ADJ_(name, offset) (name##_reader_buf += offset)

-blip_long const blip_reader_idx_factor = sizeof (Blip_Buffer::buf_t_);

+const int32_t blip_reader_idx_factor = sizeof(Blip_Buffer::buf_t_);

-#define BLIP_READER_NEXT_IDX_( name, bass, idx ) {\

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

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

+#define BLIP_READER_NEXT_IDX_(name, bass, idx) \

+{ \

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

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

 }

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

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

+{ \

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

-	name##_reader_accum +=\

-			*(Blip_Buffer::buf_t_ const*) ((char const*) name##_reader_buf + (idx));\

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

 }

 // Compatibility with older version

 const long blip_unscaled = 65535;

-const int blip_low_quality  = blip_med_quality;

+const int blip_low_quality = blip_med_quality;

 const int blip_best_quality = blip_high_quality;

-// Deprecated; use BLIP_READER macros as follows:

-// Blip_Reader r; r.begin( buf ); -> BLIP_READER_BEGIN( r, buf );

-// int bass = r.begin( buf )      -> BLIP_READER_BEGIN( r, buf ); int bass = BLIP_READER_BASS( buf );

-// r.read()                       -> BLIP_READER_READ( r )

-// r.read_raw()                   -> BLIP_READER_READ_RAW( r )

-// r.next( bass )                 -> BLIP_READER_NEXT( r, bass )

-// r.next()                       -> BLIP_READER_NEXT( r, blip_reader_default_bass )

-// r.end( buf )                   -> BLIP_READER_END( r, buf )

-class Blip_Reader {

-public:

-	int begin( Blip_Buffer& );

-	blip_long read() const          { return accum >> (blip_sample_bits - 16); }

-	blip_long read_raw() const      { return accum; }

-	void next( int bass_shift = 9 ) { accum += *buf++ - (accum >> bass_shift); }

-	void end( Blip_Buffer& b )      { b.reader_accum_ = accum; }

-private:

-	const Blip_Buffer::buf_t_* buf;

-	blip_long accum;

-};

-

-#if defined (_M_IX86) || defined (_M_IA64) || defined (__i486__) || \

-		defined (__x86_64__) || defined (__ia64__) || defined (__i386__)

-	#define BLIP_CLAMP_( in ) in < -0x8000 || 0x7FFF < in

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

-	#define BLIP_CLAMP_( in ) (blip_sample_t) in != in

+template<typename T> inline bool BLIP_CLAMP_(const T &in) { return static_cast<blip_sample_t>(in) != in; }

 #endif

 // Clamp sample to blip_sample_t range

-#define BLIP_CLAMP( sample, out )\

-	{ if ( BLIP_CLAMP_( (sample) ) ) (out) = ((sample) >> 24) ^ 0x7FFF; }

-

-struct blip_buffer_state_t

+template<typename T1, typename T2> inline void BLIP_CLAMP(const T1 &sample, T2 &out)

 {

-	blip_resampled_time_t offset_;

-	blip_long reader_accum_;

-	blip_long buf [blip_buffer_extra_];

-};

+	if (BLIP_CLAMP_(sample))

+		out = (sample >> 24) ^ 0x7FFF;

+}

 // End of public interface

 #ifndef assert

-	#include <assert.h>

+# include <cassert>

 #endif

-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

+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

 {

 	// If this assertion fails, it means that an attempt was made to add a delta

 	// at a negative time or past the end of the buffer.

-	assert( (blip_long) (time >> BLIP_BUFFER_ACCURACY) < blip_buf->buffer_size_ );

+	assert(static_cast<int32_t>(time >> BLIP_BUFFER_ACCURACY) < blip_buf->buffer_size_);

-	delta *= impl.delta_factor;

-	blip_long* BLIP_RESTRICT buf = blip_buf->buffer_ + (time >> BLIP_BUFFER_ACCURACY);

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

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

 #if BLIP_BUFFER_FAST

-	blip_long left = buf [0] + delta;

+	int32_t left = buf[0] + delta;

 	// Kind of crappy, but doing shift after multiply results in overflow.

 	// Alternate way of delaying multiply by delta_factor results in worse

 	// sub-sample resolution.

-	blip_long right = (delta >> BLIP_PHASE_BITS) * phase;

-	left  -= right;

+	int32_t right = (delta >> BLIP_PHASE_BITS) * phase;

+	left -= right;

 	right += buf [1];

-	buf [0] = left;

-	buf [1] = right;

+	buf[0] = left;

+	buf[1] = right;

 #else