rlm@0: // snes_spc 0.9.0. http://www.slack.net/~ant/ rlm@0: rlm@0: #include "SPC_DSP.h" rlm@0: rlm@0: #include "blargg_endian.h" rlm@0: #include rlm@0: rlm@0: /* Copyright (C) 2007 Shay Green. This module is free software; you rlm@0: can redistribute it and/or modify it under the terms of the GNU Lesser rlm@0: General Public License as published by the Free Software Foundation; either rlm@0: version 2.1 of the License, or (at your option) any later version. This rlm@0: module is distributed in the hope that it will be useful, but WITHOUT ANY rlm@0: WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS rlm@0: FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more rlm@0: details. You should have received a copy of the GNU Lesser General Public rlm@0: License along with this module; if not, write to the Free Software Foundation, rlm@0: Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ rlm@0: rlm@0: #include "blargg_source.h" rlm@0: rlm@0: #ifdef BLARGG_ENABLE_OPTIMIZER rlm@0: #include BLARGG_ENABLE_OPTIMIZER rlm@0: #endif rlm@0: rlm@0: #if INT_MAX < 0x7FFFFFFF rlm@0: #error "Requires that int type have at least 32 bits" rlm@0: #endif rlm@0: rlm@0: rlm@0: // TODO: add to blargg_endian.h rlm@0: #define GET_LE16SA( addr ) ((BOOST::int16_t) GET_LE16( addr )) rlm@0: #define GET_LE16A( addr ) GET_LE16( addr ) rlm@0: #define SET_LE16A( addr, data ) SET_LE16( addr, data ) rlm@0: rlm@0: static BOOST::uint8_t const initial_regs [SPC_DSP::register_count] = rlm@0: { rlm@0: 0x45,0x8B,0x5A,0x9A,0xE4,0x82,0x1B,0x78,0x00,0x00,0xAA,0x96,0x89,0x0E,0xE0,0x80, rlm@0: 0x2A,0x49,0x3D,0xBA,0x14,0xA0,0xAC,0xC5,0x00,0x00,0x51,0xBB,0x9C,0x4E,0x7B,0xFF, rlm@0: 0xF4,0xFD,0x57,0x32,0x37,0xD9,0x42,0x22,0x00,0x00,0x5B,0x3C,0x9F,0x1B,0x87,0x9A, rlm@0: 0x6F,0x27,0xAF,0x7B,0xE5,0x68,0x0A,0xD9,0x00,0x00,0x9A,0xC5,0x9C,0x4E,0x7B,0xFF, rlm@0: 0xEA,0x21,0x78,0x4F,0xDD,0xED,0x24,0x14,0x00,0x00,0x77,0xB1,0xD1,0x36,0xC1,0x67, rlm@0: 0x52,0x57,0x46,0x3D,0x59,0xF4,0x87,0xA4,0x00,0x00,0x7E,0x44,0x9C,0x4E,0x7B,0xFF, rlm@0: 0x75,0xF5,0x06,0x97,0x10,0xC3,0x24,0xBB,0x00,0x00,0x7B,0x7A,0xE0,0x60,0x12,0x0F, rlm@0: 0xF7,0x74,0x1C,0xE5,0x39,0x3D,0x73,0xC1,0x00,0x00,0x7A,0xB3,0xFF,0x4E,0x7B,0xFF rlm@0: }; rlm@0: rlm@0: // if ( io < -32768 ) io = -32768; rlm@0: // if ( io > 32767 ) io = 32767; rlm@0: #define CLAMP16( io )\ rlm@0: {\ rlm@0: if ( (int16_t) io != io )\ rlm@0: io = (io >> 31) ^ 0x7FFF;\ rlm@0: } rlm@0: rlm@0: // Access global DSP register rlm@0: #define REG(n) m.regs [r_##n] rlm@0: rlm@0: // Access voice DSP register rlm@0: #define VREG(r,n) r [v_##n] rlm@0: rlm@0: #define WRITE_SAMPLES( l, r, out ) \ rlm@0: {\ rlm@0: out [0] = l;\ rlm@0: out [1] = r;\ rlm@0: out += 2;\ rlm@0: if ( out >= m.out_end )\ rlm@0: {\ rlm@0: check( out == m.out_end );\ rlm@0: check( m.out_end != &m.extra [extra_size] || \ rlm@0: (m.extra <= m.out_begin && m.extra < &m.extra [extra_size]) );\ rlm@0: out = m.extra;\ rlm@0: m.out_end = &m.extra [extra_size];\ rlm@0: }\ rlm@0: }\ rlm@0: rlm@0: void SPC_DSP::set_output( sample_t* out, int size ) rlm@0: { rlm@0: require( (size & 1) == 0 ); // must be even rlm@0: if ( !out ) rlm@0: { rlm@0: out = m.extra; rlm@0: size = extra_size; rlm@0: } rlm@0: m.out_begin = out; rlm@0: m.out = out; rlm@0: m.out_end = out + size; rlm@0: } rlm@0: rlm@0: // Volume registers and efb are signed! Easy to forget int8_t cast. rlm@0: // Prefixes are to avoid accidental use of locals with same names. rlm@0: rlm@0: // Interleved gauss table (to improve cache coherency) rlm@0: // interleved_gauss [i] = gauss [(i & 1) * 256 + 255 - (i >> 1 & 0xFF)] rlm@0: static short const interleved_gauss [512] = rlm@0: { rlm@0: 370,1305, 366,1305, 362,1304, 358,1304, 354,1304, 351,1304, 347,1304, 343,1303, rlm@0: 339,1303, 336,1303, 332,1302, 328,1302, 325,1301, 321,1300, 318,1300, 314,1299, rlm@0: 311,1298, 307,1297, 304,1297, 300,1296, 297,1295, 293,1294, 290,1293, 286,1292, rlm@0: 283,1291, 280,1290, 276,1288, 273,1287, 270,1286, 267,1284, 263,1283, 260,1282, rlm@0: 257,1280, 254,1279, 251,1277, 248,1275, 245,1274, 242,1272, 239,1270, 236,1269, rlm@0: 233,1267, 230,1265, 227,1263, 224,1261, 221,1259, 218,1257, 215,1255, 212,1253, rlm@0: 210,1251, 207,1248, 204,1246, 201,1244, 199,1241, 196,1239, 193,1237, 191,1234, rlm@0: 188,1232, 186,1229, 183,1227, 180,1224, 178,1221, 175,1219, 173,1216, 171,1213, rlm@0: 168,1210, 166,1207, 163,1205, 161,1202, 159,1199, 156,1196, 154,1193, 152,1190, rlm@0: 150,1186, 147,1183, 145,1180, 143,1177, 141,1174, 139,1170, 137,1167, 134,1164, rlm@0: 132,1160, 130,1157, 128,1153, 126,1150, 124,1146, 122,1143, 120,1139, 118,1136, rlm@0: 117,1132, 115,1128, 113,1125, 111,1121, 109,1117, 107,1113, 106,1109, 104,1106, rlm@0: 102,1102, 100,1098, 99,1094, 97,1090, 95,1086, 94,1082, 92,1078, 90,1074, rlm@0: 89,1070, 87,1066, 86,1061, 84,1057, 83,1053, 81,1049, 80,1045, 78,1040, rlm@0: 77,1036, 76,1032, 74,1027, 73,1023, 71,1019, 70,1014, 69,1010, 67,1005, rlm@0: 66,1001, 65, 997, 64, 992, 62, 988, 61, 983, 60, 978, 59, 974, 58, 969, rlm@0: 56, 965, 55, 960, 54, 955, 53, 951, 52, 946, 51, 941, 50, 937, 49, 932, rlm@0: 48, 927, 47, 923, 46, 918, 45, 913, 44, 908, 43, 904, 42, 899, 41, 894, rlm@0: 40, 889, 39, 884, 38, 880, 37, 875, 36, 870, 36, 865, 35, 860, 34, 855, rlm@0: 33, 851, 32, 846, 32, 841, 31, 836, 30, 831, 29, 826, 29, 821, 28, 816, rlm@0: 27, 811, 27, 806, 26, 802, 25, 797, 24, 792, 24, 787, 23, 782, 23, 777, rlm@0: 22, 772, 21, 767, 21, 762, 20, 757, 20, 752, 19, 747, 19, 742, 18, 737, rlm@0: 17, 732, 17, 728, 16, 723, 16, 718, 15, 713, 15, 708, 15, 703, 14, 698, rlm@0: 14, 693, 13, 688, 13, 683, 12, 678, 12, 674, 11, 669, 11, 664, 11, 659, rlm@0: 10, 654, 10, 649, 10, 644, 9, 640, 9, 635, 9, 630, 8, 625, 8, 620, rlm@0: 8, 615, 7, 611, 7, 606, 7, 601, 6, 596, 6, 592, 6, 587, 6, 582, rlm@0: 5, 577, 5, 573, 5, 568, 5, 563, 4, 559, 4, 554, 4, 550, 4, 545, rlm@0: 4, 540, 3, 536, 3, 531, 3, 527, 3, 522, 3, 517, 2, 513, 2, 508, rlm@0: 2, 504, 2, 499, 2, 495, 2, 491, 2, 486, 1, 482, 1, 477, 1, 473, rlm@0: 1, 469, 1, 464, 1, 460, 1, 456, 1, 451, 1, 447, 1, 443, 1, 439, rlm@0: 0, 434, 0, 430, 0, 426, 0, 422, 0, 418, 0, 414, 0, 410, 0, 405, rlm@0: 0, 401, 0, 397, 0, 393, 0, 389, 0, 385, 0, 381, 0, 378, 0, 374, rlm@0: }; rlm@0: rlm@0: rlm@0: //// Counters rlm@0: rlm@0: #define RATE( rate, div )\ rlm@0: (rate >= div ? rate / div * 8 - 1 : rate - 1) rlm@0: rlm@0: static unsigned const counter_mask [32] = rlm@0: { rlm@0: RATE( 2,2), RATE(2048,4), RATE(1536,3), rlm@0: RATE(1280,5), RATE(1024,4), RATE( 768,3), rlm@0: RATE( 640,5), RATE( 512,4), RATE( 384,3), rlm@0: RATE( 320,5), RATE( 256,4), RATE( 192,3), rlm@0: RATE( 160,5), RATE( 128,4), RATE( 96,3), rlm@0: RATE( 80,5), RATE( 64,4), RATE( 48,3), rlm@0: RATE( 40,5), RATE( 32,4), RATE( 24,3), rlm@0: RATE( 20,5), RATE( 16,4), RATE( 12,3), rlm@0: RATE( 10,5), RATE( 8,4), RATE( 6,3), rlm@0: RATE( 5,5), RATE( 4,4), RATE( 3,3), rlm@0: RATE( 2,4), rlm@0: RATE( 1,4) rlm@0: }; rlm@0: #undef RATE rlm@0: rlm@0: inline void SPC_DSP::init_counter() rlm@0: { rlm@0: // counters start out with this synchronization rlm@0: m.counters [0] = 1; rlm@0: m.counters [1] = 0; rlm@0: m.counters [2] = -0x20u; rlm@0: m.counters [3] = 0x0B; rlm@0: rlm@0: int n = 2; rlm@0: for ( int i = 1; i < 32; i++ ) rlm@0: { rlm@0: m.counter_select [i] = &m.counters [n]; rlm@0: if ( !--n ) rlm@0: n = 3; rlm@0: } rlm@0: m.counter_select [ 0] = &m.counters [0]; rlm@0: m.counter_select [30] = &m.counters [2]; rlm@0: } rlm@0: rlm@0: inline void SPC_DSP::run_counter( int i ) rlm@0: { rlm@0: int n = m.counters [i]; rlm@0: if ( !(n-- & 7) ) rlm@0: n -= 6 - i; rlm@0: m.counters [i] = n; rlm@0: } rlm@0: rlm@0: #define READ_COUNTER( rate )\ rlm@0: (*m.counter_select [rate] & counter_mask [rate]) rlm@0: rlm@0: rlm@0: //// Emulation rlm@0: rlm@0: void SPC_DSP::run( int clock_count ) rlm@0: { rlm@0: int new_phase = m.phase + clock_count; rlm@0: int count = new_phase >> 5; rlm@0: m.phase = new_phase & 31; rlm@0: if ( !count ) rlm@0: return; rlm@0: rlm@0: uint8_t* const ram = m.ram; rlm@0: uint8_t const* const dir = &ram [REG(dir) * 0x100]; rlm@0: int const slow_gaussian = (REG(pmon) >> 1) | REG(non); rlm@0: int const noise_rate = REG(flg) & 0x1F; rlm@0: rlm@0: // Global volume rlm@0: int mvoll = (int8_t) REG(mvoll); rlm@0: int mvolr = (int8_t) REG(mvolr); rlm@0: if ( mvoll * mvolr < m.surround_threshold ) rlm@0: mvoll = -mvoll; // eliminate surround rlm@0: rlm@0: do rlm@0: { rlm@0: // KON/KOFF reading rlm@0: if ( (m.every_other_sample ^= 1) != 0 ) rlm@0: { rlm@0: m.new_kon &= ~m.kon; rlm@0: m.kon = m.new_kon; rlm@0: m.t_koff = REG(koff); rlm@0: } rlm@0: rlm@0: run_counter( 1 ); rlm@0: run_counter( 2 ); rlm@0: run_counter( 3 ); rlm@0: rlm@0: // Noise rlm@0: if ( !READ_COUNTER( noise_rate ) ) rlm@0: { rlm@0: int feedback = (m.noise << 13) ^ (m.noise << 14); rlm@0: m.noise = (feedback & 0x4000) ^ (m.noise >> 1); rlm@0: } rlm@0: rlm@0: // Voices rlm@0: int pmon_input = 0; rlm@0: int main_out_l = 0; rlm@0: int main_out_r = 0; rlm@0: int echo_out_l = 0; rlm@0: int echo_out_r = 0; rlm@0: voice_t* v = m.voices; rlm@0: uint8_t* v_regs = m.regs; rlm@0: int vbit = 1; rlm@0: do rlm@0: { rlm@0: #define SAMPLE_PTR(i) GET_LE16A( &dir [VREG(v_regs,srcn) * 4 + i * 2] ) rlm@0: rlm@0: int brr_header = ram [v->brr_addr]; rlm@0: int kon_delay = v->kon_delay; rlm@0: rlm@0: // Pitch rlm@0: int pitch = GET_LE16A( &VREG(v_regs,pitchl) ) & 0x3FFF; rlm@0: if ( REG(pmon) & vbit ) rlm@0: pitch += ((pmon_input >> 5) * pitch) >> 10; rlm@0: rlm@0: // KON phases rlm@0: if ( --kon_delay >= 0 ) rlm@0: { rlm@0: v->kon_delay = kon_delay; rlm@0: rlm@0: // Get ready to start BRR decoding on next sample rlm@0: if ( kon_delay == 4 ) rlm@0: { rlm@0: v->brr_addr = SAMPLE_PTR( 0 ); rlm@0: v->brr_offset = 1; rlm@0: v->buf_pos = v->buf; rlm@0: brr_header = 0; // header is ignored on this sample rlm@0: } rlm@0: rlm@0: // Envelope is never run during KON rlm@0: v->env = 0; rlm@0: v->hidden_env = 0; rlm@0: rlm@0: // Disable BRR decoding until last three samples rlm@0: v->interp_pos = (kon_delay & 3 ? 0x4000 : 0); rlm@0: rlm@0: // Pitch is never added during KON rlm@0: pitch = 0; rlm@0: } rlm@0: rlm@0: int env = v->env; rlm@0: rlm@0: // Gaussian interpolation rlm@0: { rlm@0: int output = 0; rlm@0: VREG(v_regs,envx) = (uint8_t) (env >> 4); rlm@0: if ( env ) rlm@0: { rlm@0: // Make pointers into gaussian based on fractional position between samples rlm@0: int offset = (unsigned) v->interp_pos >> 3 & 0x1FE; rlm@0: short const* fwd = interleved_gauss + offset; rlm@0: short const* rev = interleved_gauss + 510 - offset; // mirror left half of gaussian rlm@0: rlm@0: int const* in = &v->buf_pos [(unsigned) v->interp_pos >> 12]; rlm@0: rlm@0: if ( !(slow_gaussian & vbit) ) // 99% rlm@0: { rlm@0: // Faster approximation when exact sample value isn't necessary for pitch mod rlm@0: output = (fwd [0] * in [0] + rlm@0: fwd [1] * in [1] + rlm@0: rev [1] * in [2] + rlm@0: rev [0] * in [3]) >> 11; rlm@0: output = (output * env) >> 11; rlm@0: } rlm@0: else rlm@0: { rlm@0: output = (int16_t) (m.noise * 2); rlm@0: if ( !(REG(non) & vbit) ) rlm@0: { rlm@0: output = (fwd [0] * in [0]) >> 11; rlm@0: output += (fwd [1] * in [1]) >> 11; rlm@0: output += (rev [1] * in [2]) >> 11; rlm@0: output = (int16_t) output; rlm@0: output += (rev [0] * in [3]) >> 11; rlm@0: rlm@0: CLAMP16( output ); rlm@0: output &= ~1; rlm@0: } rlm@0: output = (output * env) >> 11 & ~1; rlm@0: } rlm@0: rlm@0: // Output rlm@0: int l = output * v->volume [0]; rlm@0: int r = output * v->volume [1]; rlm@0: rlm@0: main_out_l += l; rlm@0: main_out_r += r; rlm@0: rlm@0: if ( REG(eon) & vbit ) rlm@0: { rlm@0: echo_out_l += l; rlm@0: echo_out_r += r; rlm@0: } rlm@0: } rlm@0: rlm@0: pmon_input = output; rlm@0: VREG(v_regs,outx) = (uint8_t) (output >> 8); rlm@0: } rlm@0: rlm@0: // Soft reset or end of sample rlm@0: if ( REG(flg) & 0x80 || (brr_header & 3) == 1 ) rlm@0: { rlm@0: v->env_mode = env_release; rlm@0: env = 0; rlm@0: } rlm@0: rlm@0: if ( m.every_other_sample ) rlm@0: { rlm@0: // KOFF rlm@0: if ( m.t_koff & vbit ) rlm@0: v->env_mode = env_release; rlm@0: rlm@0: // KON rlm@0: if ( m.kon & vbit ) rlm@0: { rlm@0: v->kon_delay = 5; rlm@0: v->env_mode = env_attack; rlm@0: REG(endx) &= ~vbit; rlm@0: } rlm@0: } rlm@0: rlm@0: // Envelope rlm@0: if ( !v->kon_delay ) rlm@0: { rlm@0: if ( v->env_mode == env_release ) // 97% rlm@0: { rlm@0: env -= 0x8; rlm@0: v->env = env; rlm@0: if ( env <= 0 ) rlm@0: { rlm@0: v->env = 0; rlm@0: goto skip_brr; // no BRR decoding for you! rlm@0: } rlm@0: } rlm@0: else // 3% rlm@0: { rlm@0: int rate; rlm@0: int const adsr0 = VREG(v_regs,adsr0); rlm@0: int env_data = VREG(v_regs,adsr1); rlm@0: if ( adsr0 >= 0x80 ) // 97% ADSR rlm@0: { rlm@0: if ( v->env_mode > env_decay ) // 89% rlm@0: { rlm@0: env--; rlm@0: env -= env >> 8; rlm@0: rate = env_data & 0x1F; rlm@0: rlm@0: // optimized handling rlm@0: v->hidden_env = env; rlm@0: if ( READ_COUNTER( rate ) ) rlm@0: goto exit_env; rlm@0: v->env = env; rlm@0: goto exit_env; rlm@0: } rlm@0: else if ( v->env_mode == env_decay ) rlm@0: { rlm@0: env--; rlm@0: env -= env >> 8; rlm@0: rate = (adsr0 >> 3 & 0x0E) + 0x10; rlm@0: } rlm@0: else // env_attack rlm@0: { rlm@0: rate = (adsr0 & 0x0F) * 2 + 1; rlm@0: env += rate < 31 ? 0x20 : 0x400; rlm@0: } rlm@0: } rlm@0: else // GAIN rlm@0: { rlm@0: int mode; rlm@0: env_data = VREG(v_regs,gain); rlm@0: mode = env_data >> 5; rlm@0: if ( mode < 4 ) // direct rlm@0: { rlm@0: env = env_data * 0x10; rlm@0: rate = 31; rlm@0: } rlm@0: else rlm@0: { rlm@0: rate = env_data & 0x1F; rlm@0: if ( mode == 4 ) // 4: linear decrease rlm@0: { rlm@0: env -= 0x20; rlm@0: } rlm@0: else if ( mode < 6 ) // 5: exponential decrease rlm@0: { rlm@0: env--; rlm@0: env -= env >> 8; rlm@0: } rlm@0: else // 6,7: linear increase rlm@0: { rlm@0: env += 0x20; rlm@0: if ( mode > 6 && (unsigned) v->hidden_env >= 0x600 ) rlm@0: env += 0x8 - 0x20; // 7: two-slope linear increase rlm@0: } rlm@0: } rlm@0: } rlm@0: rlm@0: // Sustain level rlm@0: if ( (env >> 8) == (env_data >> 5) && v->env_mode == env_decay ) rlm@0: v->env_mode = env_sustain; rlm@0: rlm@0: v->hidden_env = env; rlm@0: rlm@0: // unsigned cast because linear decrease going negative also triggers this rlm@0: if ( (unsigned) env > 0x7FF ) rlm@0: { rlm@0: env = (env < 0 ? 0 : 0x7FF); rlm@0: if ( v->env_mode == env_attack ) rlm@0: v->env_mode = env_decay; rlm@0: } rlm@0: rlm@0: if ( !READ_COUNTER( rate ) ) rlm@0: v->env = env; // nothing else is controlled by the counter rlm@0: } rlm@0: } rlm@0: exit_env: rlm@0: rlm@0: { rlm@0: // Apply pitch rlm@0: int old_pos = v->interp_pos; rlm@0: int interp_pos = (old_pos & 0x3FFF) + pitch; rlm@0: if ( interp_pos > 0x7FFF ) rlm@0: interp_pos = 0x7FFF; rlm@0: v->interp_pos = interp_pos; rlm@0: rlm@0: // BRR decode if necessary rlm@0: if ( old_pos >= 0x4000 ) rlm@0: { rlm@0: // Arrange the four input nybbles in 0xABCD order for easy decoding rlm@0: int nybbles = ram [(v->brr_addr + v->brr_offset) & 0xFFFF] * 0x100 + rlm@0: ram [(v->brr_addr + v->brr_offset + 1) & 0xFFFF]; rlm@0: rlm@0: // Advance read position rlm@0: int const brr_block_size = 9; rlm@0: int brr_offset = v->brr_offset; rlm@0: if ( (brr_offset += 2) >= brr_block_size ) rlm@0: { rlm@0: // Next BRR block rlm@0: int brr_addr = (v->brr_addr + brr_block_size) & 0xFFFF; rlm@0: assert( brr_offset == brr_block_size ); rlm@0: if ( brr_header & 1 ) rlm@0: { rlm@0: brr_addr = SAMPLE_PTR( 1 ); rlm@0: if ( !v->kon_delay ) rlm@0: REG(endx) |= vbit; rlm@0: } rlm@0: v->brr_addr = brr_addr; rlm@0: brr_offset = 1; rlm@0: } rlm@0: v->brr_offset = brr_offset; rlm@0: rlm@0: // Decode rlm@0: rlm@0: // 0: >>1 1: <<0 2: <<1 ... 12: <<11 13-15: >>4 <<11 rlm@0: static unsigned char const shifts [16 * 2] = { rlm@0: 13,12,12,12,12,12,12,12,12,12,12, 12, 12, 16, 16, 16, rlm@0: 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11, 11, 11 rlm@0: }; rlm@0: int const scale = brr_header >> 4; rlm@0: int const right_shift = shifts [scale]; rlm@0: int const left_shift = shifts [scale + 16]; rlm@0: rlm@0: // Write to next four samples in circular buffer rlm@0: int* pos = v->buf_pos; rlm@0: int* end; rlm@0: rlm@0: // Decode four samples rlm@0: for ( end = pos + 4; pos < end; pos++, nybbles <<= 4 ) rlm@0: { rlm@0: // Extract upper nybble and scale appropriately rlm@0: int s = ((int16_t) nybbles >> right_shift) << left_shift; rlm@0: rlm@0: // Apply IIR filter (8 is the most commonly used) rlm@0: int const filter = brr_header & 0x0C; rlm@0: int const p1 = pos [brr_buf_size - 1]; rlm@0: int const p2 = pos [brr_buf_size - 2] >> 1; rlm@0: if ( filter >= 8 ) rlm@0: { rlm@0: s += p1; rlm@0: s -= p2; rlm@0: if ( filter == 8 ) // s += p1 * 0.953125 - p2 * 0.46875 rlm@0: { rlm@0: s += p2 >> 4; rlm@0: s += (p1 * -3) >> 6; rlm@0: } rlm@0: else // s += p1 * 0.8984375 - p2 * 0.40625 rlm@0: { rlm@0: s += (p1 * -13) >> 7; rlm@0: s += (p2 * 3) >> 4; rlm@0: } rlm@0: } rlm@0: else if ( filter ) // s += p1 * 0.46875 rlm@0: { rlm@0: s += p1 >> 1; rlm@0: s += (-p1) >> 5; rlm@0: } rlm@0: rlm@0: // Adjust and write sample rlm@0: CLAMP16( s ); rlm@0: s = (int16_t) (s * 2); rlm@0: pos [brr_buf_size] = pos [0] = s; // second copy simplifies wrap-around rlm@0: } rlm@0: rlm@0: if ( pos >= &v->buf [brr_buf_size] ) rlm@0: pos = v->buf; rlm@0: v->buf_pos = pos; rlm@0: } rlm@0: } rlm@0: skip_brr: rlm@0: // Next voice rlm@0: vbit <<= 1; rlm@0: v_regs += 0x10; rlm@0: v++; rlm@0: } rlm@0: while ( vbit < 0x100 ); rlm@0: rlm@0: // Echo position rlm@0: int echo_offset = m.echo_offset; rlm@0: uint8_t* const echo_ptr = &ram [(REG(esa) * 0x100 + echo_offset) & 0xFFFF]; rlm@0: if ( !echo_offset ) rlm@0: m.echo_length = (REG(edl) & 0x0F) * 0x800; rlm@0: echo_offset += 4; rlm@0: if ( echo_offset >= m.echo_length ) rlm@0: echo_offset = 0; rlm@0: m.echo_offset = echo_offset; rlm@0: rlm@0: // FIR rlm@0: int echo_in_l = GET_LE16SA( echo_ptr + 0 ); rlm@0: int echo_in_r = GET_LE16SA( echo_ptr + 2 ); rlm@0: rlm@0: int (*echo_hist_pos) [2] = m.echo_hist_pos; rlm@0: if ( ++echo_hist_pos >= &m.echo_hist [echo_hist_size] ) rlm@0: echo_hist_pos = m.echo_hist; rlm@0: m.echo_hist_pos = echo_hist_pos; rlm@0: rlm@0: echo_hist_pos [0] [0] = echo_hist_pos [8] [0] = echo_in_l; rlm@0: echo_hist_pos [0] [1] = echo_hist_pos [8] [1] = echo_in_r; rlm@0: rlm@0: #define CALC_FIR_( i, in ) ((in) * (int8_t) REG(fir + i * 0x10)) rlm@0: echo_in_l = CALC_FIR_( 7, echo_in_l ); rlm@0: echo_in_r = CALC_FIR_( 7, echo_in_r ); rlm@0: rlm@0: #define CALC_FIR( i, ch ) CALC_FIR_( i, echo_hist_pos [i + 1] [ch] ) rlm@0: #define DO_FIR( i )\ rlm@0: echo_in_l += CALC_FIR( i, 0 );\ rlm@0: echo_in_r += CALC_FIR( i, 1 ); rlm@0: DO_FIR( 0 ); rlm@0: DO_FIR( 1 ); rlm@0: DO_FIR( 2 ); rlm@0: #if defined (__MWERKS__) && __MWERKS__ < 0x3200 rlm@0: __eieio(); // keeps compiler from stupidly "caching" things in memory rlm@0: #endif rlm@0: DO_FIR( 3 ); rlm@0: DO_FIR( 4 ); rlm@0: DO_FIR( 5 ); rlm@0: DO_FIR( 6 ); rlm@0: rlm@0: // Echo out rlm@0: if ( !(REG(flg) & 0x20) ) rlm@0: { rlm@0: int l = (echo_out_l >> 7) + ((echo_in_l * (int8_t) REG(efb)) >> 14); rlm@0: int r = (echo_out_r >> 7) + ((echo_in_r * (int8_t) REG(efb)) >> 14); rlm@0: rlm@0: // just to help pass more validation tests rlm@0: #if SPC_MORE_ACCURACY rlm@0: l &= ~1; rlm@0: r &= ~1; rlm@0: #endif rlm@0: rlm@0: CLAMP16( l ); rlm@0: CLAMP16( r ); rlm@0: rlm@0: SET_LE16A( echo_ptr + 0, l ); rlm@0: SET_LE16A( echo_ptr + 2, r ); rlm@0: } rlm@0: rlm@0: // Sound out rlm@0: int l = (main_out_l * mvoll + echo_in_l * (int8_t) REG(evoll)) >> 14; rlm@0: int r = (main_out_r * mvolr + echo_in_r * (int8_t) REG(evolr)) >> 14; rlm@0: rlm@0: CLAMP16( l ); rlm@0: CLAMP16( r ); rlm@0: rlm@0: if ( (REG(flg) & 0x40) ) rlm@0: { rlm@0: l = 0; rlm@0: r = 0; rlm@0: } rlm@0: rlm@0: sample_t* out = m.out; rlm@0: WRITE_SAMPLES( l, r, out ); rlm@0: m.out = out; rlm@0: } rlm@0: while ( --count ); rlm@0: } rlm@0: rlm@0: rlm@0: //// Setup rlm@0: rlm@0: void SPC_DSP::mute_voices( int mask ) rlm@0: { rlm@0: m.mute_mask = mask; rlm@0: for ( int i = 0; i < voice_count; i++ ) rlm@0: { rlm@0: m.voices [i].enabled = (mask >> i & 1) - 1; rlm@0: update_voice_vol( i * 0x10 ); rlm@0: } rlm@0: } rlm@0: rlm@0: void SPC_DSP::init( void* ram_64k ) rlm@0: { rlm@0: m.ram = (uint8_t*) ram_64k; rlm@0: mute_voices( 0 ); rlm@0: disable_surround( false ); rlm@0: set_output( 0, 0 ); rlm@0: reset(); rlm@0: rlm@0: #ifndef NDEBUG rlm@0: // be sure this sign-extends rlm@0: assert( (int16_t) 0x8000 == -0x8000 ); rlm@0: rlm@0: // be sure right shift preserves sign rlm@0: assert( (-1 >> 1) == -1 ); rlm@0: rlm@0: // check clamp macro rlm@0: int i; rlm@0: i = +0x8000; CLAMP16( i ); assert( i == +0x7FFF ); rlm@0: i = -0x8001; CLAMP16( i ); assert( i == -0x8000 ); rlm@0: rlm@0: blargg_verify_byte_order(); rlm@0: #endif rlm@0: } rlm@0: rlm@0: void SPC_DSP::soft_reset_common() rlm@0: { rlm@0: require( m.ram ); // init() must have been called already rlm@0: rlm@0: m.noise = 0x4000; rlm@0: m.echo_hist_pos = m.echo_hist; rlm@0: m.every_other_sample = 1; rlm@0: m.echo_offset = 0; rlm@0: m.phase = 0; rlm@0: rlm@0: init_counter(); rlm@0: } rlm@0: rlm@0: void SPC_DSP::soft_reset() rlm@0: { rlm@0: REG(flg) = 0xE0; rlm@0: soft_reset_common(); rlm@0: } rlm@0: rlm@0: void SPC_DSP::load( uint8_t const regs [register_count] ) rlm@0: { rlm@0: memcpy( m.regs, regs, sizeof m.regs ); rlm@0: memset( &m.regs [register_count], 0, offsetof (state_t,ram) - register_count ); rlm@0: rlm@0: // Internal state rlm@0: int i; rlm@0: for ( i = voice_count; --i >= 0; ) rlm@0: { rlm@0: voice_t& v = m.voices [i]; rlm@0: v.brr_offset = 1; rlm@0: v.buf_pos = v.buf; rlm@0: } rlm@0: m.new_kon = REG(kon); rlm@0: rlm@0: mute_voices( m.mute_mask ); rlm@0: soft_reset_common(); rlm@0: } rlm@0: rlm@0: void SPC_DSP::reset() { load( initial_regs ); }