Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+463
View File
@@ -0,0 +1,463 @@
/*
* XSID.dll for VCC - CoCo X-SID compatible cartridge interface
* v0.3.5 original-SID-clock compatibility build (2026-09-29)
*
* External interface is unchanged from locked v0.1.0:
* CoCo SCS $FF40-$FF5F -> SID register $00-$1F
* no cartridge ROM, no emulator-only registers
*
* Internal changes:
* - 250 kHz internal rendering (one sample every four SID clocks)
* - box integration/downsampling to VCC's scanline audio rate
* - filter state updated at 250 kHz rather than ~15.7 kHz
* - higher-precision accumulation until final 8-bit VCC conversion
* - deterministic envelope counter reset on gate transitions
*
* GPL-3.0-or-later.
*/
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef signed int s32;
typedef unsigned int size32;
#ifndef SID_CLOCK
#define SID_CLOCK 1000000u
#endif
#ifndef XSID_NAME
#define XSID_NAME "SID (1.000 MHz)"
#endif
#ifndef XSID_CATALOG
#define XSID_CATALOG "XSID-VCC-031-F"
#endif
#ifndef XSID_DESC
#define XSID_DESC "CoCo X-SID write-only cartridge emulation, original SID 1.000 MHz clock"
#endif
#define VCC_AUDIO_RATE 44100u
#define INTERNAL_DIV 4u
#define PHASE_MASK 0x00ffffffu
#define OUTPUT_FULLSCALE_DIV 48 /* calibrated: 3 voices at ENV=255,VOL=15 reach ~127 without gain clipping */
#define CTRL_GATE 0x01
#define CTRL_SYNC 0x02
#define CTRL_RING 0x04
#define CTRL_TEST 0x08
#define CTRL_TRI 0x10
#define CTRL_SAW 0x20
#define CTRL_PULSE 0x40
#define CTRL_NOISE 0x80
typedef struct Voice {
u32 phase;
u32 prev_phase;
u32 noise;
u32 rate_counter;
u8 env;
u8 env_state;
u8 prev_gate;
u8 pad;
} Voice;
static u8 regs[32];
static Voice voice[3];
static u32 sid_cycle_fraction;
static u8 render_divider;
static s32 filt_lp;
static s32 filt_bp;
static s32 last_subsample_q8;
static s32 quant_error_q8;
static u8 last_osc3;
static u8 last_env3;
static const u16 rate_period[16] = {
9, 32, 63, 95, 149, 220, 267, 313,
392, 977, 1954, 3126, 3907, 11720, 19532, 31251
};
/* Q15 Chamberlin/SVF frequency coefficient indexed by cutoff >> 3.
Internal sample rate is SID_CLOCK / INTERNAL_DIV = 250 kHz. */
static const u16 filter_fc_q15[256] = {
25, 49, 77, 106, 135, 166, 196, 227,
259, 291, 323, 355, 388, 420, 453, 486,
520, 553, 587, 621, 655, 689, 723, 757,
792, 826, 861, 896, 931, 966, 1001, 1036,
1071, 1107, 1142, 1178, 1213, 1249, 1285, 1320,
1356, 1392, 1428, 1465, 1501, 1537, 1573, 1610,
1646, 1683, 1719, 1756, 1792, 1829, 1866, 1903,
1940, 1977, 2014, 2051, 2088, 2125, 2162, 2199,
2237, 2274, 2311, 2349, 2386, 2424, 2461, 2499,
2537, 2574, 2612, 2650, 2688, 2725, 2763, 2801,
2839, 2877, 2915, 2953, 2991, 3030, 3068, 3106,
3144, 3182, 3221, 3259, 3297, 3336, 3374, 3413,
3451, 3490, 3528, 3567, 3606, 3644, 3683, 3722,
3760, 3799, 3838, 3877, 3916, 3954, 3993, 4032,
4071, 4110, 4149, 4188, 4227, 4266, 4305, 4345,
4384, 4423, 4462, 4501, 4541, 4580, 4619, 4659,
4698, 4737, 4777, 4816, 4856, 4895, 4934, 4974,
5014, 5053, 5093, 5132, 5172, 5211, 5251, 5291,
5330, 5370, 5410, 5450, 5489, 5529, 5569, 5609,
5649, 5689, 5729, 5768, 5808, 5848, 5888, 5928,
5968, 6008, 6048, 6088, 6128, 6169, 6209, 6249,
6289, 6329, 6369, 6409, 6450, 6490, 6530, 6570,
6611, 6651, 6691, 6731, 6772, 6812, 6853, 6893,
6933, 6974, 7014, 7055, 7095, 7135, 7176, 7216,
7257, 7297, 7338, 7379, 7419, 7460, 7500, 7541,
7581, 7622, 7663, 7703, 7744, 7785, 7825, 7866,
7907, 7948, 7988, 8029, 8070, 8111, 8151, 8192,
8233, 8274, 8315, 8356, 8397, 8437, 8478, 8519,
8560, 8601, 8642, 8683, 8724, 8765, 8806, 8847,
8888, 8929, 8970, 9011, 9052, 9093, 9134, 9175,
9216, 9257, 9298, 9339, 9381, 9422, 9463, 9504,
9545, 9586, 9627, 9669, 9710, 9751, 9792, 9834
};
/* Q15 damping indexed by SID resonance nibble. */
static const u16 filter_damp_q15[16] = {
44237, 41615, 38994, 36372, 33751, 31130, 28508, 25887, 23265, 20644, 18022, 15401, 12780, 10158, 7537, 4915
};
static s32 clamp_s32(s32 x, s32 lo, s32 hi)
{
if (x < lo) return lo;
if (x > hi) return hi;
return x;
}
static void clear_state(void)
{
u32 i;
for (i = 0; i < 32; ++i) regs[i] = 0;
for (i = 0; i < 3; ++i) {
voice[i].phase = 0;
voice[i].prev_phase = 0;
voice[i].noise = 0x7ffff8u;
voice[i].rate_counter = 0;
voice[i].env = 0;
voice[i].env_state = 0;
voice[i].prev_gate = 0;
voice[i].pad = 0;
}
sid_cycle_fraction = 0;
render_divider = 0;
filt_lp = 0;
filt_bp = 0;
last_subsample_q8 = 0;
quant_error_q8 = 0;
last_osc3 = 0;
last_env3 = 0;
}
static u16 voice_freq(u32 v)
{
u32 b = v * 7u;
return (u16)((u16)regs[b] | ((u16)regs[b + 1u] << 8));
}
static u16 voice_pw(u32 v)
{
u32 b = v * 7u;
return (u16)(((u16)regs[b + 2u] | ((u16)regs[b + 3u] << 8)) & 0x0fffu);
}
static u8 voice_ctrl(u32 v) { return regs[v * 7u + 4u]; }
static u8 voice_ad(u32 v) { return regs[v * 7u + 5u]; }
static u8 voice_sr(u32 v) { return regs[v * 7u + 6u]; }
static u32 env_effective_period(u8 env, u16 base)
{
u32 mult = 1;
if (env < 0x5d) mult = 2;
if (env < 0x36) mult = 4;
if (env < 0x1a) mult = 8;
if (env < 0x0e) mult = 16;
if (env < 0x06) mult = 30;
return ((u32)base) * mult;
}
static void clock_envelope(u32 v)
{
Voice *p = &voice[v];
u8 ad = voice_ad(v);
u8 sr = voice_sr(v);
u8 gate = (u8)(voice_ctrl(v) & CTRL_GATE);
u8 sustain = (u8)((sr >> 4) * 17u);
u16 period;
if (gate != p->prev_gate) {
p->rate_counter = 0;
p->env_state = gate ? 1u : 0u;
p->prev_gate = gate;
}
if (p->env_state == 1u) {
period = rate_period[(ad >> 4) & 15u];
if (++p->rate_counter >= period) {
p->rate_counter = 0;
if (p->env < 255u) ++p->env;
else p->env_state = 2u;
}
} else if (p->env_state == 2u) {
if (p->env > sustain) {
period = rate_period[ad & 15u];
if (++p->rate_counter >= env_effective_period(p->env, period)) {
p->rate_counter = 0;
--p->env;
}
}
} else if (p->env > 0u) {
period = rate_period[sr & 15u];
if (++p->rate_counter >= env_effective_period(p->env, period)) {
p->rate_counter = 0;
--p->env;
}
}
}
static void clock_oscillators_once(void)
{
u32 v;
u8 msb_rise[3];
for (v = 0; v < 3; ++v) {
Voice *p = &voice[v];
u8 ctrl = voice_ctrl(v);
p->prev_phase = p->phase;
if (ctrl & CTRL_TEST) {
p->phase = 0;
p->noise = 0x7ffff8u;
} else {
p->phase = (p->phase + (u32)voice_freq(v)) & PHASE_MASK;
if (!(p->prev_phase & 0x080000u) && (p->phase & 0x080000u)) {
u32 fb = ((p->noise >> 22) ^ (p->noise >> 17)) & 1u;
p->noise = ((p->noise << 1) | fb) & 0x7fffffu;
if (!p->noise) p->noise = 0x7ffff8u;
}
}
msb_rise[v] = (u8)((!(p->prev_phase & 0x800000u) &&
(p->phase & 0x800000u)) ? 1u : 0u);
}
for (v = 0; v < 3; ++v) {
u32 mod = (v + 2u) % 3u;
if ((voice_ctrl(v) & CTRL_SYNC) && msb_rise[mod])
voice[v].phase = 0;
}
for (v = 0; v < 3; ++v) clock_envelope(v);
}
static u16 noise12(u32 n)
{
u16 x = 0;
x |= (u16)(((n >> 22) & 1u) << 11);
x |= (u16)(((n >> 20) & 1u) << 10);
x |= (u16)(((n >> 16) & 1u) << 9);
x |= (u16)(((n >> 13) & 1u) << 8);
x |= (u16)(((n >> 11) & 1u) << 7);
x |= (u16)(((n >> 7) & 1u) << 6);
x |= (u16)(((n >> 4) & 1u) << 5);
x |= (u16)(((n >> 2) & 1u) << 4);
x |= (u16)((n >> 8) & 0x0fu);
return x & 0x0fffu;
}
static u16 waveform12(u32 v)
{
Voice *p = &voice[v];
u8 ctrl = voice_ctrl(v);
u16 out = 0x0fffu;
u8 any = 0;
u16 tri, saw, pulse, noise;
u32 mod = (v + 2u) % 3u;
if (ctrl & CTRL_TEST) return 0;
saw = (u16)((p->phase >> 12) & 0x0fffu);
tri = (u16)((p->phase >> 11) & 0x0fffu);
if (p->phase & 0x800000u) tri ^= 0x0fffu;
if ((ctrl & CTRL_RING) && (voice[mod].phase & 0x800000u))
tri ^= 0x0fffu;
pulse = (u16)(((p->phase >> 12) & 0x0fffu) >= voice_pw(v)
? 0x0fffu : 0u);
noise = noise12(p->noise);
if (ctrl & CTRL_TRI) { out &= tri; any = 1; }
if (ctrl & CTRL_SAW) { out &= saw; any = 1; }
if (ctrl & CTRL_PULSE) { out &= pulse; any = 1; }
if (ctrl & CTRL_NOISE) { out &= noise; any = 1; }
if (!any) out = 0;
return out;
}
/* Return one internal 250 kHz sample in signed Q8 VCC-DAC units.
+/-127.0 is represented as +/-32512. */
static s32 render_subsample_q8(void)
{
s32 routed = 0;
s32 direct = 0;
s32 voice_out[3];
u32 v;
u8 route = regs[0x17] & 0x07u;
u8 mode = regs[0x18] & 0x70u;
u8 vol = regs[0x18] & 0x0fu;
u16 cutoff = (u16)(((u16)regs[0x15] & 7u) |
((u16)regs[0x16] << 3));
u8 res = (u8)(regs[0x17] >> 4);
for (v = 0; v < 3; ++v) {
u16 w = waveform12(v);
s32 centered = (s32)w - 2048;
voice_out[v] = (centered * (s32)voice[v].env) >> 8;
}
last_osc3 = (u8)(waveform12(2) >> 4);
last_env3 = voice[2].env;
for (v = 0; v < 3; ++v) {
if (route & (1u << v)) routed += voice_out[v];
else if (!(v == 2u && (regs[0x18] & 0x80u)))
direct += voice_out[v];
}
if (route) {
s32 f = (s32)filter_fc_q15[cutoff >> 3];
s32 damp = (s32)filter_damp_q15[res];
s32 notch = routed - ((filt_bp * damp) >> 15);
s32 hp;
filt_lp += (f * filt_bp) >> 15;
hp = notch - filt_lp;
filt_bp += (f * hp) >> 15;
filt_lp = clamp_s32(filt_lp, -32768, 32768);
filt_bp = clamp_s32(filt_bp, -32768, 32768);
hp = clamp_s32(hp, -32768, 32768);
if (mode & 0x10u) direct += filt_lp;
if (mode & 0x20u) direct += filt_bp;
if (mode & 0x40u) direct += hp;
if (!(mode & 0x70u)) direct += routed;
} else {
/* Avoid stale filter energy bursting when routing is later enabled. */
filt_lp -= filt_lp >> 8;
filt_bp -= filt_bp >> 8;
}
/* Maximum-clean output calibration.
At VOL=15, three simultaneously full-scale unfiltered voices reach
approximately the VCC signed 8-bit rail. A smaller divisor would
necessarily clip that valid SID worst case, so OUTPUT_FULLSCALE_DIV=48
is the maximum fixed clean gain. Lower SID master-volume values retain
their programmed proportional level. */
direct = (direct * (s32)vol * 256) / (15 * OUTPUT_FULLSCALE_DIV);
direct = clamp_s32(direct, -32512, 32512);
return direct;
}
static u8 sid_read(u8 reg)
{
reg &= 0x1fu;
if (reg == 0x19u || reg == 0x1au) return 0xffu;
if (reg == 0x1bu) return last_osc3;
if (reg == 0x1cu) return last_env3;
if (reg >= 0x1du) return 0xffu;
return regs[reg];
}
static void sid_write(u8 reg, u8 value)
{
reg &= 0x1fu;
if (reg <= 0x18u) regs[reg] = value;
}
__declspec(dllexport) const char* PakGetName(void)
{
return XSID_NAME;
}
__declspec(dllexport) const char* PakGetCatalogId(void)
{
return XSID_CATALOG;
}
__declspec(dllexport) const char* PakGetDescription(void)
{
return XSID_DESC;
}
__declspec(dllexport) void PakInitialize(size32 slot_id,
const char* configuration_path, void* vcc_window, const void* callbacks)
{
(void)slot_id; (void)configuration_path; (void)vcc_window; (void)callbacks;
clear_state();
}
__declspec(dllexport) void PakTerminate(void)
{
}
__declspec(dllexport) void PakReset(void)
{
clear_state();
}
__declspec(dllexport) void PakWritePort(u8 port, u8 data)
{
if (port >= 0x40u && port <= 0x5fu)
sid_write((u8)(port - 0x40u), data);
}
__declspec(dllexport) u8 PakReadPort(u8 port)
{
if (port >= 0x40u && port <= 0x5fu)
return 0xffu;
return 0xffu;
}
__declspec(dllexport) u8 PakReadMemoryByte(u16 address)
{
(void)address;
return 0xffu;
}
__declspec(dllexport) u16 PakSampleAudio(void)
{
u32 cycles;
s32 sum_q8 = 0;
u32 count = 0;
s32 average_q8;
s32 shaped_q8;
s32 quantized;
u8 b;
sid_cycle_fraction += SID_CLOCK;
cycles = sid_cycle_fraction / VCC_AUDIO_RATE;
sid_cycle_fraction -= cycles * VCC_AUDIO_RATE;
while (cycles--) {
clock_oscillators_once();
if (++render_divider >= INTERNAL_DIV) {
render_divider = 0;
last_subsample_q8 = render_subsample_q8();
sum_q8 += last_subsample_q8;
++count;
}
}
if (count) average_q8 = sum_q8 / (s32)count;
else average_q8 = last_subsample_q8;
/* First-order error feedback keeps quiet envelopes from turning into
strongly tonal 8-bit quantization steps. */
shaped_q8 = average_q8 + quant_error_q8;
quantized = (shaped_q8 >= 0)
? ((shaped_q8 + 128) >> 8)
: -(((-shaped_q8) + 128) >> 8);
quantized = clamp_s32(quantized, -127, 127);
quant_error_q8 = shaped_q8 - (quantized * 256);
quant_error_q8 = clamp_s32(quant_error_q8, -255, 255);
b = (u8)(quantized + 128);
return (u16)(((u16)b << 8) | b);
}