deleted file mode 100644

@@ -1,848 +0,0 @@

-// snes_spc 0.9.0. http://www.slack.net/~ant/

-

-#include <algorithm>

-#include <cstring>

-#include "SPC_DSP.h"

-

-#include "blargg_endian.h"

-

-/* Copyright (C) 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 */

-

-#if INT_MAX < 0x7FFFFFFF

-# error "Requires that int type have at least 32 bits"

-#endif

-

-static const uint8_t initial_regs[] =

-{

-	0x45, 0x8B, 0x5A, 0x9A, 0xE4, 0x82, 0x1B, 0x78, 0x00, 0x00, 0xAA, 0x96, 0x89, 0x0E, 0xE0, 0x80,

-	0x2A, 0x49, 0x3D, 0xBA, 0x14, 0xA0, 0xAC, 0xC5, 0x00, 0x00, 0x51, 0xBB, 0x9C, 0x4E, 0x7B, 0xFF,

-	0xF4, 0xFD, 0x57, 0x32, 0x37, 0xD9, 0x42, 0x22, 0x00, 0x00, 0x5B, 0x3C, 0x9F, 0x1B, 0x87, 0x9A,

-	0x6F, 0x27, 0xAF, 0x7B, 0xE5, 0x68, 0x0A, 0xD9, 0x00, 0x00, 0x9A, 0xC5, 0x9C, 0x4E, 0x7B, 0xFF,

-	0xEA, 0x21, 0x78, 0x4F, 0xDD, 0xED, 0x24, 0x14, 0x00, 0x00, 0x77, 0xB1, 0xD1, 0x36, 0xC1, 0x67,

-	0x52, 0x57, 0x46, 0x3D, 0x59, 0xF4, 0x87, 0xA4, 0x00, 0x00, 0x7E, 0x44, 0x00, 0x4E, 0x7B, 0xFF,

-	0x75, 0xF5, 0x06, 0x97, 0x10, 0xC3, 0x24, 0xBB, 0x00, 0x00, 0x7B, 0x7A, 0xE0, 0x60, 0x12, 0x0F,

-	0xF7, 0x74, 0x1C, 0xE5, 0x39, 0x3D, 0x73, 0xC1, 0x00, 0x00, 0x7A, 0xB3, 0xFF, 0x4E, 0x7B, 0xFF

-};

-

-// if ( io < -32768 ) io = -32768;

-// if ( io >  32767 ) io =  32767;

-template<typename T> static inline void CLAMP16(T &io)

-{

-	if (static_cast<int16_t>(io) != io)

-		io = (io >> 31) ^ 0x7FFF;

-}

-

-void SPC_DSP::set_output(sample_t *out, int size)

-{

-	assert(!(size & 1)); // must be even

-	if (!out)

-	{

-		out = this->m.extra;

-		size = extra_size;

-	}

-	this->m.out_begin = this->m.out = out;

-	this->m.out_end = out + size;

-}

-

-// Volume registers and efb are signed! Easy to forget int8_t cast.

-// Prefixes are to avoid accidental use of locals with same names.

-

-// Gaussian interpolation

-

-static const short gauss[] =

-{

-	   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,

-	   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   2,   2,   2,   2,   2,

-	   2,   2,   3,   3,   3,   3,   3,   4,   4,   4,   4,   4,   5,   5,   5,   5,

-	   6,   6,   6,   6,   7,   7,   7,   8,   8,   8,   9,   9,   9,  10,  10,  10,

-	  11,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  15,  16,  16,  17,  17,

-	  18,  19,  19,  20,  20,  21,  21,  22,  23,  23,  24,  24,  25,  26,  27,  27,

-	  28,  29,  29,  30,  31,  32,  32,  33,  34,  35,  36,  36,  37,  38,  39,  40,

-	  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,

-	  58,  59,  60,  61,  62,  64,  65,  66,  67,  69,  70,  71,  73,  74,  76,  77,

-	  78,  80,  81,  83,  84,  86,  87,  89,  90,  92,  94,  95,  97,  99, 100, 102,

-	 104, 106, 107, 109, 111, 113, 115, 117, 118, 120, 122, 124, 126, 128, 130, 132,

-	 134, 137, 139, 141, 143, 145, 147, 150, 152, 154, 156, 159, 161, 163, 166, 168,

-	 171, 173, 175, 178, 180, 183, 186, 188, 191, 193, 196, 199, 201, 204, 207, 210,

-	 212, 215, 218, 221, 224, 227, 230, 233, 236, 239, 242, 245, 248, 251, 254, 257,

-	 260, 263, 267, 270, 273, 276, 280, 283, 286, 290, 293, 297, 300, 304, 307, 311,

-	 314, 318, 321, 325, 328, 332, 336, 339, 343, 347, 351, 354, 358, 362, 366, 370,

-	 374, 378, 381, 385, 389, 393, 397, 401, 405, 410, 414, 418, 422, 426, 430, 434,

-	 439, 443, 447, 451, 456, 460, 464, 469, 473, 477, 482, 486, 491, 495, 499, 504,

-	 508, 513, 517, 522, 527, 531, 536, 540, 545, 550, 554, 559, 563, 568, 573, 577,

-	 582, 587, 592, 596, 601, 606, 611, 615, 620, 625, 630, 635, 640, 644, 649, 654,

-	 659, 664, 669, 674, 678, 683, 688, 693, 698, 703, 708, 713, 718, 723, 728, 732,

-	 737, 742, 747, 752, 757, 762, 767, 772, 777, 782, 787, 792, 797, 802, 806, 811,

-	 816, 821, 826, 831, 836, 841, 846, 851, 855, 860, 865, 870, 875, 880, 884, 889,

-	 894, 899, 904, 908, 913, 918, 923, 927, 932, 937, 941, 946, 951, 955, 960, 965,

-	 969, 974, 978, 983, 988, 992, 997,1001,1005,1010,1014,1019,1023,1027,1032,1036,

-	1040,1045,1049,1053,1057,1061,1066,1070,1074,1078,1082,1086,1090,1094,1098,1102,

-	1106,1109,1113,1117,1121,1125,1128,1132,1136,1139,1143,1146,1150,1153,1157,1160,

-	1164,1167,1170,1174,1177,1180,1183,1186,1190,1193,1196,1199,1202,1205,1207,1210,

-	1213,1216,1219,1221,1224,1227,1229,1232,1234,1237,1239,1241,1244,1246,1248,1251,

-	1253,1255,1257,1259,1261,1263,1265,1267,1269,1270,1272,1274,1275,1277,1279,1280,

-	1282,1283,1284,1286,1287,1288,1290,1291,1292,1293,1294,1295,1296,1297,1297,1298,

-	1299,1300,1300,1301,1302,1302,1303,1303,1303,1304,1304,1304,1304,1304,1305,1305,

-};

-

-int SPC_DSP::interpolate(const voice_t *v)

-{

-	// Make pointers into gaussian based on fractional position between samples

-	int offset = (v->interp_pos >> 4) & 0xFF;

-	auto fwd = gauss + 255 - offset;

-	auto rev = gauss + offset; // mirror left half of gaussian

-

-	auto in = &v->buf[(v->interp_pos >> 12) + v->buf_pos];

-	int out = (fwd[0] * in[0]) >> 11;

-	out += (fwd[256] * in[1]) >> 11;

-	out += (rev[256] * in[2]) >> 11;

-	out = static_cast<int16_t>(out);

-	out += (rev[0] * in[3]) >> 11;

-

-	CLAMP16(out);

-	out &= ~1;

-	return out;

-}

-

-//// Counters

-

-static const int simple_counter_range = 2048 * 5 * 3; // 30720

-

-static const unsigned counter_rates[] =

-{

-	simple_counter_range + 1, // never fires

-	2048, 1536,

-	1280, 1024, 768,

-	640, 512, 384,

-	320, 256, 192,

-	160, 128, 96,

-	80, 64, 48,

-	40, 32, 24,

-	20, 16, 12,

-	10, 8, 6,

-	5, 4, 3,

-	2,

-	1

-};

-

-static const unsigned counter_offsets[] =

-{

-	1, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	536, 0, 1040,

-	0,

-	0

-};

-

-void SPC_DSP::init_counter()

-{

-	this->m.counter = 0;

-}

-

-void SPC_DSP::run_counters()

-{

-	if (--this->m.counter < 0)

-		this->m.counter = simple_counter_range - 1;

-}

-

-unsigned SPC_DSP::read_counter(int rate)

-{

-	return (static_cast<unsigned>(this->m.counter) + counter_offsets[rate]) % counter_rates[rate];

-}

-

-//// Envelope

-

-void SPC_DSP::run_envelope(voice_t *const v)

-{

-	int env = v->env;

-	if (v->env_mode == env_release) // 60%

-	{

-		if ((env -= 0x8) < 0)

-			env = 0;

-		v->env = env;

-	}

-	else

-	{

-		int rate;

-		int env_data = v->regs[v_adsr1];

-		if (this->m.t_adsr0 & 0x80) // 99% ADSR

-		{

-			if (v->env_mode >= env_decay) // 99%

-			{

-				--env;

-				env -= env >> 8;

-				rate = env_data & 0x1F;

-				if (v->env_mode == env_decay) // 1%

-					rate = ((this->m.t_adsr0 >> 3) & 0x0E) + 0x10;

-			}

-			else // env_attack

-			{

-				rate = (this->m.t_adsr0 & 0x0F) * 2 + 1;

-				env += rate < 31 ? 0x20 : 0x400;

-			}

-		}

-		else // GAIN

-		{

-			env_data = v->regs[v_gain];

-			int mode = env_data >> 5;

-			if (mode < 4) // direct

-			{

-				env = env_data * 0x10;

-				rate = 31;

-			}

-			else

-			{

-				rate = env_data & 0x1F;

-				if (mode == 4) // 4: linear decrease

-					env -= 0x20;

-				else if (mode < 6) // 5: exponential decrease

-				{

-					--env;

-					env -= env >> 8;

-				}

-				else // 6,7: linear increase

-				{

-					env += 0x20;

-					if (mode > 6 && static_cast<unsigned>(v->hidden_env) >= 0x600)

-						env += 0x8 - 0x20; // 7: two-slope linear increase

-				}

-			}

-		}

-

-		// Sustain level

-		if ((env >> 8) == (env_data >> 5) && v->env_mode == env_decay)

-			v->env_mode = env_sustain;

-

-		v->hidden_env = env;

-

-		// unsigned cast because linear decrease going negative also triggers this

-		if (static_cast<unsigned>(env) > 0x7FF)

-		{

-			env = env < 0 ? 0 : 0x7FF;

-			if (v->env_mode == env_attack)

-				v->env_mode = env_decay;

-		}

-

-		if (!this->read_counter(rate))

-			v->env = env; // nothing else is controlled by the counter

-	}

-}

-

-//// BRR Decoding

-

-void SPC_DSP::decode_brr(voice_t *v)

-{

-	// Arrange the four input nybbles in 0xABCD order for easy decoding

-	int nybbles = this->m.t_brr_byte * 0x100 + this->m.ram[(v->brr_addr + v->brr_offset + 1) & 0xFFFF];

-

-	int header = this->m.t_brr_header;

-

-	// Write to next four samples in circular buffer

-	int *pos = &v->buf[v->buf_pos];

-	int *end;

-	if ((v->buf_pos += 4) >= brr_buf_size)

-		v->buf_pos = 0;

-

-	// Decode four samples

-	for (end = pos + 4; pos < end; ++pos, nybbles <<= 4)

-	{

-		// Extract nybble and sign-extend

-		int s = static_cast<int16_t>(nybbles) >> 12;

-

-		// Shift sample based on header

-		int shift = header >> 4;

-		s = (s << shift) >> 1;

-		if (shift >= 0xD) // handle invalid range

-			s = (s >> 25) << 11; // same as: s = (s < 0 ? -0x800 : 0)

-

-		// Apply IIR filter (8 is the most commonly used)

-		int filter = header & 0x0C;

-		int p1 = pos[brr_buf_size - 1];

-		int p2 = pos[brr_buf_size - 2] >> 1;

-		if (filter >= 8)

-		{

-			s += p1;

-			s -= p2;

-			if (filter == 8) // s += p1 * 0.953125 - p2 * 0.46875

-			{

-				s += p2 >> 4;

-				s += (p1 * -3) >> 6;

-			}

-			else // s += p1 * 0.8984375 - p2 * 0.40625

-			{

-				s += (p1 * -13) >> 7;

-				s += (p2 * 3) >> 4;

-			}

-		}

-		else if (filter) // s += p1 * 0.46875

-		{

-			s += p1 >> 1;

-			s += -p1 >> 5;

-		}

-

-		// Adjust and write sample

-		CLAMP16(s);

-		s = static_cast<int16_t>(s * 2);

-		pos[brr_buf_size] = pos[0] = s; // second copy simplifies wrap-around

-	}

-}

-

-//// Misc

-

-void SPC_DSP::misc_27()

-{

-	this->m.t_pmon = this->m.regs[r_pmon] & 0xFE; // voice 0 doesn't support PMON

-}

-void SPC_DSP::misc_28()

-{

-	this->m.t_non = this->m.regs[r_non];

-	this->m.t_eon = this->m.regs[r_eon];

-	this->m.t_dir = this->m.regs[r_dir];

-}

-void SPC_DSP::misc_29()

-{

-	this->m.every_other_sample = !this->m.every_other_sample;

-	if (this->m.every_other_sample)

-		this->m.new_kon &= ~this->m.kon; // clears KON 63 clocks after it was last read

-}

-void SPC_DSP::misc_30()

-{

-	if (this->m.every_other_sample)

-	{

-		this->m.kon = this->m.new_kon;

-		this->m.t_koff = this->m.regs[r_koff] | this->m.mute_mask;

-	}

-

-	this->run_counters();

-

-	// Noise

-	if (!this->read_counter(this->m.regs[r_flg] & 0x1F))

-	{

-		int feedback = (this->m.noise << 13) ^ (this->m.noise << 14);

-		this->m.noise = (feedback & 0x4000) ^ (this->m.noise >> 1);

-	}

-}

-

-//// Voices

-

-void SPC_DSP::voice_V1(voice_t *const v)

-{

-	this->m.t_dir_addr = this->m.t_dir * 0x100 + this->m.t_srcn * 4;

-	this->m.t_srcn = v->regs[v_srcn];

-}

-void SPC_DSP::voice_V2(voice_t *const v)

-{

-	// Read sample pointer (ignored if not needed)

-	auto entry = &this->m.ram[m.t_dir_addr];

-	if (!v->kon_delay)

-		entry += 2;

-	this->m.t_brr_next_addr = get_le16(entry);

-

-	this->m.t_adsr0 = v->regs[v_adsr0];

-

-	// Read pitch, spread over two clocks

-	this->m.t_pitch = v->regs[v_pitchl];

-}

-void SPC_DSP::voice_V3a(voice_t *const v)

-{

-	this->m.t_pitch += (v->regs[v_pitchh] & 0x3F) << 8;

-}

-void SPC_DSP::voice_V3b(voice_t *const v)

-{

-	// Read BRR header and byte

-	this->m.t_brr_byte = this->m.ram[(v->brr_addr + v->brr_offset) & 0xFFFF];

-	this->m.t_brr_header = this->m.ram[v->brr_addr]; // brr_addr doesn't need masking

-}

-void SPC_DSP::voice_V3c(voice_t *const v)

-{

-	// Pitch modulation using previous voice's output

-	if (this->m.t_pmon & v->vbit)

-		this->m.t_pitch += ((this->m.t_output >> 5) * this->m.t_pitch) >> 10;

-

-	if (v->kon_delay)

-	{

-		// Get ready to start BRR decoding on next sample

-		if (v->kon_delay == 5)

-		{

-			v->brr_addr = this->m.t_brr_next_addr;

-			v->brr_offset = 1;

-			v->buf_pos = 0;

-			this->m.t_brr_header = 0; // header is ignored on this sample

-		}

-

-		// Envelope is never run during KON

-		v->env = 0;

-		v->hidden_env = 0;

-

-		// Disable BRR decoding until last three samples

-		v->interp_pos = 0;

-		if (--v->kon_delay & 3)

-			v->interp_pos = 0x4000;

-

-		// Pitch is never added during KON

-		this->m.t_pitch = 0;

-	}

-

-	// Gaussian interpolation

-	int output = this->interpolate(v);

-

-	// Noise

-	if (this->m.t_non & v->vbit)

-		output = static_cast<int16_t>(this->m.noise * 2);

-

-	// Apply envelope

-	this->m.t_output = (output * v->env) >> 11 & ~1;

-	v->t_envx_out = static_cast<uint8_t>(v->env >> 4);

-

-	// Immediate silence due to end of sample or soft reset

-	if (this->m.regs[r_flg] & 0x80 || (this->m.t_brr_header & 3) == 1)

-	{

-		v->env_mode = env_release;

-		v->env = 0;

-	}

-

-	if (this->m.every_other_sample)

-	{

-		// KOFF

-		if (this->m.t_koff & v->vbit)

-			v->env_mode = env_release;

-

-		// KON

-		if (this->m.kon & v->vbit)

-		{

-			v->kon_delay = 5;

-			v->env_mode  = env_attack;

-		}

-	}

-

-	// Run envelope for next sample

-	if (!v->kon_delay)

-		this->run_envelope(v);

-}

-

-void SPC_DSP::voice_output(const voice_t *v, int ch)

-{

-	// Apply left/right volume

-	int amp = (this->m.t_output * static_cast<int8_t>(v->regs[v_voll + ch])) >> 7;

-	amp *= (this->stereo_switch & (1 << (v->voice_number + ch * voice_count))) ? 1 : 0;

-

-	// Add to output total

-	this->m.t_main_out[ch] += amp;

-	CLAMP16(this->m.t_main_out[ch]);

-

-	// Optionally add to echo total

-	if (this->m.t_eon & v->vbit)

-	{

-		this->m.t_echo_out[ch] += amp;

-		CLAMP16(this->m.t_echo_out[ch]);

-	}

-}

-void SPC_DSP::voice_V4(voice_t *const v)

-{

-	// Decode BRR

-	this->m.t_looped = 0;

-	if (v->interp_pos >= 0x4000)

-	{

-		this->decode_brr(v);

-

-		if ((v->brr_offset += 2) >= brr_block_size)

-		{

-			// Start decoding next BRR block

-			assert(v->brr_offset == brr_block_size);

-			v->brr_addr = (v->brr_addr + brr_block_size) & 0xFFFF;

-			if (this->m.t_brr_header & 1)

-			{

-				v->brr_addr = this->m.t_brr_next_addr;

-				this->m.t_looped = v->vbit;

-			}

-			v->brr_offset = 1;

-		}

-	}

-

-	// Apply pitch

-	v->interp_pos = (v->interp_pos & 0x3FFF) + m.t_pitch;

-

-	// Keep from getting too far ahead (when using pitch modulation)

-	if (v->interp_pos > 0x7FFF)

-		v->interp_pos = 0x7FFF;

-

-	// Output left

-	this->voice_output(v, 0);

-}

-void SPC_DSP::voice_V5(voice_t *const v)

-{

-	// Output right

-	this->voice_output(v, 1);

-

-	// ENDX, OUTX, and ENVX won't update if you wrote to them 1-2 clocks earlier

-	int endx_buf = this->m.regs[r_endx] | this->m.t_looped;

-

-	// Clear bit in ENDX if KON just began

-	if (v->kon_delay == 5)

-		endx_buf &= ~v->vbit;

-	this->m.endx_buf = static_cast<uint8_t>(endx_buf);

-}

-void SPC_DSP::voice_V6(voice_t *const)

-{

-	this->m.outx_buf = static_cast<uint8_t>(this->m.t_output >> 8);

-}

-void SPC_DSP::voice_V7(voice_t *const v)

-{

-	// Update ENDX

-	this->m.regs[r_endx] = this->m.endx_buf;

-

-	this->m.envx_buf = v->t_envx_out;

-}

-void SPC_DSP::voice_V8(voice_t *const v)

-{

-	// Update OUTX

-	v->regs[v_outx] = this->m.outx_buf;

-}

-void SPC_DSP::voice_V9(voice_t *const v)

-{

-	// Update ENVX

-	v->regs[v_envx] = this->m.envx_buf;

-}

-

-// Most voices do all these in one clock, so make a handy composite

-void SPC_DSP::voice_V3(voice_t *const v)

-{

-	this->voice_V3a(v);

-	this->voice_V3b(v);

-	this->voice_V3c(v);

-}

-

-// Common combinations of voice steps on different voices. This greatly reduces

-// code size and allows everything to be inlined in these functions.

-void SPC_DSP::voice_V7_V4_V1(voice_t *const v) { this->voice_V7(v); this->voice_V1(v + 3); this->voice_V4(v + 1); }

-void SPC_DSP::voice_V8_V5_V2(voice_t *const v) { this->voice_V8(v); this->voice_V5(v + 1); this->voice_V2(v + 2); }

-void SPC_DSP::voice_V9_V6_V3(voice_t *const v) { this->voice_V9(v); this->voice_V6(v + 1); this->voice_V3(v + 2); }

-

-//// Echo

-

-void SPC_DSP::echo_read(int ch)

-{

-	int s = static_cast<int16_t>(get_le16(this->ECHO_PTR(ch)));

-	// second copy simplifies wrap-around handling

-	this->ECHO_FIR(0)[ch] = this->ECHO_FIR(8)[ch] = s >> 1;

-}

-

-void SPC_DSP::echo_22()

-{

-	// History

-	if (++this->m.echo_hist_pos >= &this->m.echo_hist[echo_hist_size])

-		this->m.echo_hist_pos = this->m.echo_hist;

-

-	this->m.t_echo_ptr = (this->m.t_esa * 0x100 + this->m.echo_offset) & 0xFFFF;

-	this->echo_read(0);

-

-	// FIR (using l and r temporaries below helps compiler optimize)

-	int l = this->CALC_FIR(0, 0);

-	int r = this->CALC_FIR(0, 1);

-

-	this->m.t_echo_in[0] = l;

-	this->m.t_echo_in[1] = r;

-}

-void SPC_DSP::echo_23()

-{

-	int l = this->CALC_FIR(1, 0) + this->CALC_FIR(2, 0);

-	int r = this->CALC_FIR(1, 1) + this->CALC_FIR(2, 1);

-

-	this->m.t_echo_in[0] += l;

-	this->m.t_echo_in[1] += r;

-

-	echo_read(1);

-}

-void SPC_DSP::echo_24()

-{

-	int l = this->CALC_FIR(3, 0) + this->CALC_FIR(4, 0) + this->CALC_FIR(5, 0);

-	int r = this->CALC_FIR(3, 1) + this->CALC_FIR(4, 1) + this->CALC_FIR(5, 1);

-

-	this->m.t_echo_in[0] += l;

-	this->m.t_echo_in[1] += r;

-}

-void SPC_DSP::echo_25()

-{

-	int l = this->m.t_echo_in[0] + this->CALC_FIR(6, 0);

-	int r = this->m.t_echo_in[1] + this->CALC_FIR(6, 1);

-

-	l = static_cast<int16_t>(l);

-	r = static_cast<int16_t>(r);

-

-	l += static_cast<int16_t>(this->CALC_FIR(7, 0));

-	r += static_cast<int16_t>(this->CALC_FIR(7, 1));

-

-	CLAMP16(l);

-	CLAMP16(r);

-

-	this->m.t_echo_in[0] = l & ~1;

-	this->m.t_echo_in[1] = r & ~1;

-}

-int SPC_DSP::echo_output(int ch)

-{

-	int out = static_cast<int16_t>((this->m.t_main_out [ch] * static_cast<int8_t>(this->m.regs[r_mvoll + ch * 0x10])) >> 7) +

-		static_cast<int16_t>((this->m.t_echo_in [ch] * static_cast<int8_t>(this->m.regs[r_evoll + ch * 0x10])) >> 7);

-	CLAMP16(out);

-	return out;

-}

-void SPC_DSP::echo_26()

-{

-	// Left output volumes

-	// (save sample for next clock so we can output both together)

-	this->m.t_main_out[0] = echo_output(0);

-

-	// Echo feedback

-	int l = this->m.t_echo_out[0] + static_cast<int16_t>((this->m.t_echo_in[0] * static_cast<int8_t>(this->m.regs[r_efb])) >> 7);

-	int r = this->m.t_echo_out[1] + static_cast<int16_t>((this->m.t_echo_in[1] * static_cast<int8_t>(this->m.regs[r_efb])) >> 7);

-

-	CLAMP16(l);

-	CLAMP16(r);

-

-	this->m.t_echo_out[0] = l & ~1;

-	this->m.t_echo_out[1] = r & ~1;

-}

-void SPC_DSP::echo_27()

-{

-	// Output

-	int l = this->m.t_main_out[0];

-	int r = echo_output(1);

-	this->m.t_main_out[0] = this->m.t_main_out[1] = 0;

-

-	// TODO: global muting isn't this simple (turns DAC on and off

-	// or something, causing small ~37-sample pulse when first muted)

-	if (this->m.regs[r_flg] & 0x40)

-		l = r = 0;

-

-	// Output sample to DAC

-#ifdef SPC_DSP_OUT_HOOK

-	SPC_DSP_OUT_HOOK(l, r);

-#else

-	sample_t *out = this->m.out;

-	out[0] = l;

-	out[1] = r;

-	out += 2;

-	if (out >= m.out_end)

-	{

-		out = this->m.extra;

-		this->m.out_end = &this->m.extra[extra_size];

-	}

-	this->m.out = out;

-#endif

-}

-void SPC_DSP::echo_28()

-{

-	this->m.t_echo_enabled = this->m.regs[r_flg];

-}

-void SPC_DSP::echo_write(int ch)

-{

-	if (!(this->m.t_echo_enabled & 0x20))

-	{

-		if (this->m.t_echo_ptr >= 0xffc0 && this->rom_enabled)

-			set_le16(&this->hi_ram[this->m.t_echo_ptr + ch * 2 - 0xffc0], this->m.t_echo_out [ch]);

-		else

-			set_le16(this->ECHO_PTR(ch), this->m.t_echo_out[ch]);

-	}

-

-	this->m.t_echo_out[ch] = 0;

-}

-void SPC_DSP::echo_29()

-{

-	this->m.t_esa = this->m.regs[r_esa];

-

-	if (!this->m.echo_offset)

-		this->m.echo_length = (this->m.regs[r_edl] & 0x0F) * 0x800;

-

-	this->m.echo_offset += 4;

-	if (this->m.echo_offset >= this->m.echo_length)

-		this->m.echo_offset = 0;

-

-	// Write left echo

-	this->echo_write(0);

-

-	this->m.t_echo_enabled = this->m.regs[r_flg];

-}

-void SPC_DSP::echo_30()

-{

-	// Write right echo

-	this->echo_write(1);

-}

-

-//// Timing

-

-// Execute clock for a particular voice

-#define V(clock, voice) voice_##clock(&this->m.voices[voice]);

-

-/* The most common sequence of clocks uses composite operations

-for efficiency. For example, the following are equivalent to the

-individual steps on the right:

-

-V(V7_V4_V1,2) -> V(V7,2) V(V4,3) V(V1,5)

-V(V8_V5_V2,2) -> V(V8,2) V(V5,3) V(V2,4)

-V(V9_V6_V3,2) -> V(V9,2) V(V6,3) V(V3,4) */

-

-// Voice      0      1      2      3      4      5      6      7

-#define GEN_DSP_TIMING \

-PHASE(0) V(V5, 0) V(V2, 1) \

-PHASE(1) V(V6, 0) V(V3, 1) \

-PHASE(2) V(V7_V4_V1, 0) \

-PHASE(3) V(V8_V5_V2, 0) \

-PHASE(4) V(V9_V6_V3, 0) \

-PHASE(5) V(V7_V4_V1, 1) \

-PHASE(6) V(V8_V5_V2, 1) \

-PHASE(7) V(V9_V6_V3, 1) \

-PHASE(8) V(V7_V4_V1, 2) \

-PHASE(9) V(V8_V5_V2, 2) \

-PHASE(10) V(V9_V6_V3, 2) \

-PHASE(11) V(V7_V4_V1, 3) \

-PHASE(12) V(V8_V5_V2, 3) \

-PHASE(13) V(V9_V6_V3, 3) \

-PHASE(14) V(V7_V4_V1, 4) \

-PHASE(15) V(V8_V5_V2, 4) \

-PHASE(16) V(V9_V6_V3, 4) \

-PHASE(17) V(V1, 0) V(V7, 5) V(V4, 6) \

-PHASE(18) V(V8_V5_V2, 5) \

-PHASE(19) V(V9_V6_V3, 5) \

-PHASE(20) V(V1, 1) V(V7, 6) V(V4, 7) \

-PHASE(21) V(V8, 6) V(V5, 7) V(V2, 0) /* t_brr_next_addr order dependency */ \

-PHASE(22) V(V3a, 0) V(V9, 6) V(V6, 7) echo_22(); \

-PHASE(23) V(V7, 7) echo_23(); \

-PHASE(24) V(V8, 7) echo_24(); \

-PHASE(25) V(V3b, 0) V(V9, 7) echo_25(); \

-PHASE(26) echo_26(); \

-PHASE(27) misc_27(); echo_27(); \

-PHASE(28) misc_28(); echo_28(); \

-PHASE(29) misc_29(); echo_29(); \

-PHASE(30) misc_30(); V(V3c, 0) echo_30(); \

-PHASE(31) V(V4, 0) V(V1, 2)

-

-#ifndef SPC_DSP_CUSTOM_RUN

-void SPC_DSP::run(int clocks_remain)

-{

-	assert(clocks_remain > 0);

-

-	int phase = this->m.phase;

-	this->m.phase = (phase + clocks_remain) & 31;

-	switch (phase)

-	{

-		loop:

-#define PHASE(n) if (n && !--clocks_remain) break; case n:

-		GEN_DSP_TIMING

-#undef PHASE

-

-		if (--clocks_remain)

-			goto loop;

-	}

-}

-#endif

-

-//// Setup

-

-void SPC_DSP::init(uint8_t *ram_64k)

-{

-	this->m.ram = ram_64k;

-	this->mute_voices(0);

-	this->disable_surround(false);

-	this->set_output(nullptr, 0);

-	this->reset();

-

-	this->stereo_switch = 0xffff;

-

-#ifndef NDEBUG

-	// be sure this sign-extends

-	assert(static_cast<int16_t>(0x8000) == -0x8000);

-

-	// be sure right shift preserves sign

-	assert((-1 >> 1) == -1);

-

-	// check clamp macro

-	int i = 0x8000;

-	CLAMP16(i);

-	assert(i == 0x7FFF);

-

-	i = -0x8001;

-	CLAMP16(i);

-	assert(i == -0x8000);

-

-	blargg_verify_byte_order();

-#endif

-}

-

-void SPC_DSP::soft_reset_common()

-{

-	assert(this->m.ram); // init() must have been called already

-

-	this->m.noise = 0x4000;

-	this->m.echo_hist_pos = this->m.echo_hist;

-	this->m.every_other_sample = true;

-	this->m.echo_offset = 0;

-	this->m.phase = 0;

-

-	this->init_counter();

-

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

-		this->m.voices[i].voice_number = i;

-}

-

-void SPC_DSP::soft_reset()

-{

-	this->m.regs[r_flg] = 0xE0;

-	this->soft_reset_common();

-}

-

-void SPC_DSP::load(const uint8_t regs[register_count])

-{

-	std::copy_n(&regs[0], static_cast<int>(register_count), &this->m.regs[0]);

-	memset(&this->m.regs[register_count], 0, offsetof(state_t, ram) - register_count);

-

-	// Internal state

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

-	{

-		auto &v = this->m.voices[i];

-		v.brr_offset = 1;

-		v.vbit = 1 << i;

-		v.regs = &this->m.regs[i * 0x10];

-	}

-	this->m.new_kon = this->m.regs[r_kon];

-	this->m.t_dir = this->m.regs[r_dir];

-	this->m.t_esa = this->m.regs[r_esa];

-

-	this->soft_reset_common();

-}

-

-void SPC_DSP::reset()

-{

-	this->load(initial_regs);

-}

-

-//// Snes9x Accessor

-

-void SPC_DSP::set_stereo_switch(int value)

-{

-	this->stereo_switch = value;

-}

-

-uint8_t SPC_DSP::reg_value(int ch, int addr)

-{

-	return this->m.voices[ch].regs[addr];

-}

-

-int SPC_DSP::envx_value(int ch)

-{

-	return this->m.voices[ch].env;

-}

@@ -731,7 +731,7 @@ PHASE(29) misc_29(); echo_29(); \

 PHASE(30) misc_30(); V(V3c, 0) echo_30(); \

 PHASE(31) V(V4, 0) V(V1, 2)

-#if !SPC_DSP_CUSTOM_RUN

+#ifndef SPC_DSP_CUSTOM_RUN

 void SPC_DSP::run(int clocks_remain)

 {

 	assert(clocks_remain > 0);

@@ -238,7 +238,7 @@ void SPC_DSP::run_envelope(voice_t *const v)

 			if (v->env_mode == env_attack)

 				v->env_mode = env_decay;

 		}

-		

+

 		if (!this->read_counter(rate))

 			v->env = env; // nothing else is controlled by the counter

 	}

@@ -326,7 +326,7 @@ void SPC_DSP::misc_30()

 	if (this->m.every_other_sample)

 	{

 		this->m.kon = this->m.new_kon;

-		this->m.t_koff = this->m.regs[r_koff] | this->m.mute_mask; 

+		this->m.t_koff = this->m.regs[r_koff] | this->m.mute_mask;

 	}