mirror of
https://github.com/exoticorn/microw8.git
synced 2026-01-20 11:16:42 +01:00
222 lines
10 KiB
Plaintext
222 lines
10 KiB
Plaintext
const GesChannelState.Trigger = 0;
|
|
const GesChannelState.EnvState = 1;
|
|
const GesChannelState.EnvVol = 2;
|
|
const GesChannelState.Phase = 4;
|
|
const GesChannelState.Size = 8;
|
|
|
|
const GesState.Filter = GesChannelState.Size * 4;
|
|
const GesState.Size = GesState.Filter + 8*4;
|
|
|
|
const GesStateOffset = 32;
|
|
const GesBufferOffset = 32 + GesState.Size;
|
|
|
|
export fn gesSnd(t: i32) -> f32 {
|
|
let baseAddr = 0!0x12c78;
|
|
if !(t & 127) {
|
|
let i: i32;
|
|
loop clearLoop {
|
|
(baseAddr + i)!GesBufferOffset = 0;
|
|
branch_if (i := i + 4) < 128*4: clearLoop;
|
|
}
|
|
|
|
let ch: i32;
|
|
loop channelLoop {
|
|
let lazy channelState = baseAddr + GesStateOffset + ch * GesChannelState.Size;
|
|
let lazy channelReg = baseAddr + ch * 6;
|
|
let envState = channelState?GesChannelState.EnvState;
|
|
let envVol = i32.load16_u(channelState, GesChannelState.EnvVol);
|
|
|
|
let lazy oldTrigger = channelState?GesChannelState.Trigger;
|
|
let lazy ctrl = channelReg?0;
|
|
if (oldTrigger ^ ctrl) & (ctrl | 2) & 3 {
|
|
envState = 1;
|
|
envVol = 0;
|
|
}
|
|
channelState?GesChannelState.Trigger = ctrl;
|
|
|
|
if envState {
|
|
let lazy attack = channelReg?4 & 15;
|
|
envVol = envVol + 12 * pow(1.675, (15 - attack) as f32) as i32;
|
|
if envVol >= 65535 {
|
|
envVol = 65535;
|
|
envState = 0;
|
|
}
|
|
} else {
|
|
let inline decay = (channelReg - (ctrl & 1))?5 >> 4;
|
|
let inline dec = 8 * pow(1.5625, (15 - decay) as f32) as i32;
|
|
envVol = envVol - ((dec * (envVol + 8192)) >> 16);
|
|
let inline sustain = (channelReg?5 & 15) << 12;
|
|
let lazy targetVol = (ctrl & 1) * sustain;
|
|
if envVol < targetVol {
|
|
envVol = targetVol;
|
|
}
|
|
}
|
|
channelState?GesChannelState.EnvState = envState;
|
|
|
|
i32.store16(envVol, channelState, GesChannelState.EnvVol);
|
|
|
|
let inline note = i32.load16_u(channelReg, 2);
|
|
let lazy freq = 440 as f32 * pow(2.0, (note - 69*256) as f32 / (12*256) as f32);
|
|
let phaseInc = (freq * (65536.0 / 44100.0)) as i32;
|
|
|
|
let phase = channelState!GesChannelState.Phase;
|
|
|
|
let inline pulseWidth = channelReg?1;
|
|
let phaseShift = (pulseWidth - 128) * 255;
|
|
let invPhaseInc = 1 as f32 / phaseInc as f32;
|
|
|
|
i = 0;
|
|
let wave = ctrl >> 6;
|
|
if wave < 2 {
|
|
if wave {
|
|
let pulsePhase1 = pulseWidth << 23;
|
|
let pulsePhase2 = (511 - pulseWidth) << 23;
|
|
loop sawLoop {
|
|
let p = (phase ^ 32768) << 16;
|
|
let saw = (p >> 16) - polyBlep(phase, invPhaseInc, -32767);
|
|
let saw2 = select(p #>= pulsePhase1 & p #< pulsePhase2, -saw, saw);
|
|
let saw2 = saw2 -
|
|
polyBlep((p - pulsePhase1) >> 16, invPhaseInc, -saw) -
|
|
polyBlep((p - pulsePhase2) >> 16, invPhaseInc, saw);
|
|
(baseAddr + i)!(GesBufferOffset + 128*4) = saw2;
|
|
phase = phase + phaseInc;
|
|
branch_if (i := i + 4) < 64*4: sawLoop;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
let pulsePhase = 32768 + pulseWidth * 128;
|
|
loop rectLoop {
|
|
(baseAddr + i)!(GesBufferOffset + 128*4) = select((phase & 65535) < pulsePhase, -32768, 32767) -
|
|
polyBlep(phase, invPhaseInc, -32767) -
|
|
polyBlep(phase - pulsePhase, invPhaseInc, 32767);
|
|
phase = phase + phaseInc;
|
|
branch_if (i := i + 4) < 64*4: rectLoop;
|
|
}
|
|
}
|
|
} else {
|
|
if wave == 2 {
|
|
let scale = pulseWidth + 256;
|
|
loop triLoop {
|
|
let s = phase << 16;
|
|
s = (s ^ (s >> 31));
|
|
s = (s >> 8) * scale;
|
|
s = (s ^ (s >> 31));
|
|
(baseAddr + i)!(GesBufferOffset + 128*4) = (s >> 15) - 32768;
|
|
phase = phase + phaseInc;
|
|
branch_if (i := i + 4) < 64*4: triLoop;
|
|
}
|
|
} else {
|
|
loop noiseLoop {
|
|
let s = phase >> 12;
|
|
let inline pulse = ((phase >> 8) & 255) >= pulseWidth;
|
|
s = s * 0x6746ba73;
|
|
s = s ^ (s >> 15) * pulse;
|
|
(baseAddr + i)!(GesBufferOffset + 128*4) = (s * 0x835776c7) >> 16;
|
|
phase = phase + phaseInc;
|
|
branch_if (i := i + 4) < 64*4: noiseLoop;
|
|
}
|
|
}
|
|
}
|
|
|
|
channelState!GesChannelState.Phase = phase;
|
|
|
|
if ctrl & 32 {
|
|
let lazy modSrc = (ch - 1) & 3;
|
|
let inline channelState = baseAddr + GesStateOffset + modSrc * GesChannelState.Size;
|
|
let inline channelReg = baseAddr + modSrc * 6;
|
|
|
|
let inline note = i32.load16_u(channelReg, 2);
|
|
let inline freq = 440 as f32 * pow(2.0, (note - 69*256) as f32 / (12*256) as f32);
|
|
let phaseInc = (freq * (65536.0 / 44100.0)) as i32;
|
|
|
|
let phase = channelState!GesChannelState.Phase;
|
|
if modSrc > ch {
|
|
phase = phase - (phaseInc << 6);
|
|
}
|
|
|
|
i = 0;
|
|
loop ringLoop {
|
|
let s = phase << 16;
|
|
s = (s ^ (s >> 31));
|
|
(baseAddr + i)!(GesBufferOffset + 128*4) = ((baseAddr + i)!(GesBufferOffset + 128*4) * ((s >> 15) - 32768)) >> 15;
|
|
phase = phase + phaseInc;
|
|
branch_if (i := i + 4) < 64*4: ringLoop;
|
|
}
|
|
}
|
|
|
|
let channelVol = ((baseAddr + (ch >> 1))?24 >> ((ch & 1) * 4)) & 15;
|
|
envVol = envVol * channelVol / 15;
|
|
|
|
let leftVol = (select(ctrl & 16, 0x3d5b, 0x6a79) >> (ch * 4)) & 15;
|
|
let rightVol = 16 - leftVol;
|
|
|
|
let lazy filter = (ctrl >> 2) & 3;
|
|
|
|
i = 0;
|
|
if filter < 2 {
|
|
if filter {
|
|
let f = (4096 as f32 - min(4096 as f32, 4096 as f32 * exp(freq * (-8.0 * 3.141 / 44100.0)))) as i32;
|
|
let low = (baseAddr + ch * 8)!(GesStateOffset + GesState.Filter);
|
|
loop filterLoop {
|
|
let in = ((baseAddr + i)!(GesBufferOffset + 128*4) * envVol) >> 18;
|
|
low = low + (((in - low) * f) >> 12);
|
|
(baseAddr + i * 2)!GesBufferOffset = (baseAddr + i * 2)!GesBufferOffset + ((low * leftVol) >> 4);
|
|
(baseAddr + i * 2)!(GesBufferOffset + 4) = (baseAddr + i * 2)!(GesBufferOffset + 4) + ((low * rightVol) >> 4);
|
|
branch_if (i := i + 4) < 64*4: filterLoop;
|
|
(baseAddr + ch * 8)!(GesStateOffset + GesState.Filter) = low;
|
|
(baseAddr + ch * 8)!(GesStateOffset + GesState.Filter + 4) = 0;
|
|
}
|
|
} else {
|
|
loop mixLoop {
|
|
let sample = ((baseAddr + i)!(GesBufferOffset + 128*4) * envVol) >> 18;
|
|
(baseAddr + i * 2)!GesBufferOffset = (baseAddr + i * 2)!GesBufferOffset + ((sample * leftVol) >> 4);
|
|
(baseAddr + i * 2)!(GesBufferOffset + 4) = (baseAddr + i * 2)!(GesBufferOffset + 4) + ((sample * rightVol) >> 4);
|
|
branch_if (i := i + 4) < 64*4: mixLoop;
|
|
(baseAddr + ch * 8)!(GesStateOffset + GesState.Filter) = sample;
|
|
(baseAddr + ch * 8)!(GesStateOffset + GesState.Filter + 4) = 0;
|
|
}
|
|
}
|
|
} else {
|
|
filter = filter - 2;
|
|
let ctrl = (baseAddr + filter)?26;
|
|
let note = i32.load16_u(baseAddr + filter * 2, 28);
|
|
let inline freq = 440 as f32 * pow(2.0, (note - 69*256) as f32 / (12*256) as f32);
|
|
let F = (8192 as f32 * sin(min(0.25, freq / 44100 as f32) * 3.1415)) as i32;
|
|
let Q = 8192 - (ctrl >> 4) * (7000/15);
|
|
let Qlimit = (8192*4096/F - F/2) * 3 / 4;
|
|
if Q > Qlimit {
|
|
Q = Qlimit;
|
|
}
|
|
let low_out = ctrl & 1;
|
|
let high_out = (ctrl >> 1) & 1;
|
|
let band_out = (ctrl >> 2) & 1;
|
|
let low = (baseAddr + ch * 8)!(GesStateOffset + GesState.Filter);
|
|
let band = (baseAddr + ch * 8)!(GesStateOffset + GesState.Filter + 4);
|
|
loop filterLoop {
|
|
let in = ((baseAddr + i)!(GesBufferOffset + 128*4) * envVol) >> 18;
|
|
|
|
let high = in - low - ((band * Q) >> 12);
|
|
band = band + ((F * high) >> 12);
|
|
low = low + ((F * band) >> 12);
|
|
|
|
let sample = low * low_out + high * high_out + band * band_out;
|
|
(baseAddr + i * 2)!GesBufferOffset = (baseAddr + i * 2)!GesBufferOffset + ((sample * leftVol) >> 4);
|
|
(baseAddr + i * 2)!(GesBufferOffset + 4) = (baseAddr + i * 2)!(GesBufferOffset + 4) + ((sample * rightVol) >> 4);
|
|
branch_if (i := i + 4) < 64*4: filterLoop;
|
|
(baseAddr + ch * 8)!(GesStateOffset + GesState.Filter) = low;
|
|
(baseAddr + ch * 8)!(GesStateOffset + GesState.Filter + 4) = band;
|
|
}
|
|
}
|
|
|
|
branch_if (ch := ch + 1) < 4: channelLoop;
|
|
}
|
|
}
|
|
((baseAddr + (t & 127) * 4)!GesBufferOffset) as f32 / 32768 as f32
|
|
}
|
|
|
|
fn polyBlep(transientPhase: i32, invPhaseInc: f32, magnitude: i32) -> i32 {
|
|
let lazy t = ((transientPhase << 16) >> 16) as f32 * invPhaseInc;
|
|
let lazy x = max(0 as f32, 1 as f32 - abs(t));
|
|
(f32.copysign(x * x, t) * magnitude as f32) as i32
|
|
} |