diff options
Diffstat (limited to 'src/sketch')
| -rw-r--r-- | src/sketch/root.zig | 3 | ||||
| -rw-r--r-- | src/sketch/sfxr.zig | 267 |
2 files changed, 270 insertions, 0 deletions
diff --git a/src/sketch/root.zig b/src/sketch/root.zig index c70b326..1270b5d 100644 --- a/src/sketch/root.zig +++ b/src/sketch/root.zig @@ -41,6 +41,8 @@ pub const List = @import("list.zig").List; /// Data computed in draw from a few State fields, kept in Session and rebuilt when they change (or after a reload). pub const Derived = @import("derived.zig").Derived; pub const web = @import("web.zig"); +/// sfxr's sound effects, rendered to samples for `host.newSound`. +pub const sfxr = @import("sfxr.zig"); const request = @import("request.zig"); pub const Request = request.Request; pub const Handled = request.Handled; @@ -456,6 +458,7 @@ test { _ = @import("clock.zig"); _ = @import("list.zig"); _ = @import("derived.zig"); + _ = sfxr; } test "setup receives session resources without a Frame and reports errors" { diff --git a/src/sketch/sfxr.zig b/src/sketch/sfxr.zig new file mode 100644 index 0000000..01657b5 --- /dev/null +++ b/src/sketch/sfxr.zig @@ -0,0 +1,267 @@ +//! sfxr, DrPetter's sound-effect generator (blips, coins, lasers, +//! explosions): one waveform through an envelope, pitch slides, vibrato, +//! arpeggio, duty sweep, a phaser and two filters, 8× oversampled. Pure and +//! deterministic: the same `Params` and rate give the same samples, so a +//! sketch renders its sounds whenever it likes and plays them as voices: +//! +//! const n = sk.sfxr.render(.{ .freq = 0.5, .decay = 0.2 }, f.in.sample_rate, &buf); +//! ss.blip = f.host.newSound(buf[0..n]); +//! +//! Ported from 02-dont-rat-me-out's synth.zig. sfxr's knobs count in +//! samples at 44.1 kHz; at another rate every length, step and filter +//! coefficient is scaled to keep the same durations, pitches and cutoffs +//! (to first order for the slides and filters), and at 44.1 kHz the +//! samples are the original's to the bit. +const std = @import("std"); + +/// The rate sfxr's knobs were tuned at. +pub const reference_rate = 44_100; + +pub const Wave = enum(u8) { square, sawtooth, sine, noise }; + +/// All sfxr knobs. Most are 0..1, a few -1..1. +pub const Params = struct { + wave: Wave = .square, + // envelope + attack: f32 = 0.0, + sustain: f32 = 0.3, + punch: f32 = 0.0, + decay: f32 = 0.4, + // frequency + freq: f32 = 0.3, + freq_limit: f32 = 0.0, + freq_ramp: f32 = 0.0, + freq_dramp: f32 = 0.0, + // vibrato + vibrato_depth: f32 = 0.0, + vibrato_speed: f32 = 0.0, + // arpeggio + arp_mod: f32 = 0.0, + arp_speed: f32 = 0.0, + // square duty + duty: f32 = 0.0, + duty_ramp: f32 = 0.0, + // phaser + phaser_offset: f32 = 0.0, + phaser_ramp: f32 = 0.0, + // filters + lpf_freq: f32 = 1.0, + lpf_ramp: f32 = 0.0, + lpf_resonance: f32 = 0.0, + hpf_freq: f32 = 0.0, + hpf_ramp: f32 = 0.0, + // repeat + repeat_speed: f32 = 0.0, + // output + volume: f32 = 0.5, +}; + +inline fn sq(x: f32) f32 { + return x * x; +} +inline fn cube(x: f32) f32 { + return x * x * x; +} +inline fn xs(s: *u32) u32 { + s.* ^= s.* << 13; + s.* ^= s.* >> 17; + s.* ^= s.* << 5; + return s.*; +} +fn frnd(s: *u32, range: f32) f32 { + return @as(f32, @floatFromInt(xs(s))) / 4294967295.0 * range; +} + +/// Synthesizes `p` at `rate` samples a second into `out` (mono, -1..1). +/// Returns the number of samples written: the envelope's length, or less +/// when `out` is shorter or the pitch falls to `freq_limit`. +pub fn render(p: Params, rate: u32, out: []f32) usize { + // Samples at `rate` per sample at 44.1 kHz: lengths grow by it, steps + // per sample shrink by it. + const k: f64 = @as(f64, @floatFromInt(rate)) / reference_rate; + const kf: f32 = @floatCast(k); + var rng: u32 = 0x52ad4326; + + var fperiod: f64 = 100.0 / (@as(f64, p.freq) * p.freq + 0.001) * k; + var period: i32 = @intFromFloat(fperiod); + const fmaxperiod: f64 = 100.0 / (@as(f64, p.freq_limit) * p.freq_limit + 0.001) * k; + var fslide: f64 = 1.0 - @as(f64, cube(p.freq_ramp)) * 0.01 / k; + const fdslide: f64 = -@as(f64, cube(p.freq_dramp)) * 0.000001 / (k * k); + + var square_duty: f32 = 0.5 - p.duty * 0.5; + const square_slide: f32 = -p.duty_ramp * 0.00005 / kf; + + const arp_mod: f64 = if (p.arp_mod >= 0) 1.0 - @as(f64, sq(p.arp_mod)) * 0.9 else 1.0 + @as(f64, sq(p.arp_mod)) * 10.0; + var arp_time: i32 = 0; + var arp_limit: i32 = @intFromFloat((sq(p.arp_speed) * 20000 + 32) * kf); + if (p.arp_speed == 1.0) arp_limit = 0; + + var env_vol: f32 = 0; + var env_stage: usize = 0; + var env_time: i32 = 0; + const env_length = [3]i32{ + @intFromFloat(p.attack * p.attack * 100000 * kf), + @intFromFloat(p.sustain * p.sustain * 100000 * kf), + @intFromFloat(p.decay * p.decay * 100000 * kf), + }; + + var fphase: f32 = sq(p.phaser_offset) * 1020 * kf; + if (p.phaser_offset < 0) fphase = -fphase; + var fdphase: f32 = sq(p.phaser_ramp) * 1.0; + if (p.phaser_ramp < 0) fdphase = -fdphase; + var iphase: i32 = @intFromFloat(@min(@abs(fphase), 1023)); + var ipp: i32 = 0; + var phaser_buffer: [1024]f32 = @splat(0); + + var noise_buffer: [32]f32 = undefined; + for (&noise_buffer) |*nb| nb.* = frnd(&rng, 2) - 1; + + var fltp: f32 = 0; + var fltdp: f32 = 0; + var fltw: f32 = cube(p.lpf_freq) * 0.1 / kf; + const fltw_d: f32 = 1.0 + p.lpf_ramp * 0.0001 / kf; + var fltdmp: f32 = 5.0 / (1.0 + sq(p.lpf_resonance) * 20) * (0.01 + fltw); + if (fltdmp > 0.8) fltdmp = 0.8; + var fltphp: f32 = 0; + var flthp: f32 = sq(p.hpf_freq) * 0.1 / kf; + const flthp_d: f32 = 1.0 + p.hpf_ramp * 0.0003 / kf; + + var vib_phase: f32 = 0; + const vib_speed: f32 = sq(p.vibrato_speed) * 0.01 / kf; + const vib_amp: f32 = p.vibrato_depth * 0.5; + + var rep_time: i32 = 0; + var rep_limit: i32 = @intFromFloat((sq(1 - p.repeat_speed) * 20000 + 32) * kf); + if (p.repeat_speed == 0) rep_limit = 0; + + var phase: i32 = 0; + var n: usize = 0; + var finished = false; + while (!finished and n < out.len) : (n += 1) { + rep_time += 1; + if (rep_limit != 0 and rep_time >= rep_limit) { + rep_time = 0; + fperiod = 100.0 / (@as(f64, p.freq) * p.freq + 0.001) * k; + period = @intFromFloat(fperiod); + fslide = 1.0 - @as(f64, cube(p.freq_ramp)) * 0.01 / k; + arp_time = 0; + arp_limit = @intFromFloat((sq(p.arp_speed) * 20000 + 32) * kf); + if (p.arp_speed == 1.0) arp_limit = 0; + } + + arp_time += 1; + if (arp_limit != 0 and arp_time >= arp_limit) { + arp_limit = 0; + fperiod *= arp_mod; + } + + fslide += fdslide; + fperiod *= fslide; + if (fperiod > fmaxperiod) { + fperiod = fmaxperiod; + if (p.freq_limit > 0) finished = true; + } + + var rfperiod: f32 = @floatCast(fperiod); + if (vib_amp > 0) { + vib_phase += vib_speed; + rfperiod = @floatCast(fperiod * (1.0 + @as(f64, @sin(vib_phase) * vib_amp))); + } + period = @intFromFloat(rfperiod); + if (period < 8) period = 8; + + square_duty += square_slide; + square_duty = std.math.clamp(square_duty, 0, 0.5); + + env_time += 1; + if (env_time > env_length[env_stage]) { + env_time = 0; + env_stage += 1; + if (env_stage == 3) finished = true; + } + env_vol = switch (env_stage) { + 0 => @as(f32, @floatFromInt(env_time)) / @as(f32, @floatFromInt(@max(1, env_length[0]))), + 1 => 1.0 + (1.0 - @as(f32, @floatFromInt(env_time)) / @as(f32, @floatFromInt(@max(1, env_length[1])))) * 2.0 * p.punch, + else => 1.0 - @as(f32, @floatFromInt(env_time)) / @as(f32, @floatFromInt(@max(1, env_length[2]))), + }; + + fphase += fdphase; + iphase = @intFromFloat(@min(@abs(fphase), 1023)); + + flthp *= flthp_d; + flthp = std.math.clamp(flthp, 0.00001, 0.1); + + var ssample: f32 = 0; + var oi: u32 = 0; + while (oi < 8) : (oi += 1) { + var sample: f32 = 0; + phase += 1; + if (phase >= period) { + phase = @mod(phase, period); + if (p.wave == .noise) for (&noise_buffer) |*nb| { + nb.* = frnd(&rng, 2) - 1; + }; + } + const fp: f32 = @as(f32, @floatFromInt(phase)) / @as(f32, @floatFromInt(period)); + sample = switch (p.wave) { + .square => if (fp < square_duty) 0.5 else -0.5, + .sawtooth => 1.0 - fp * 2, + .sine => @sin(fp * 2.0 * std.math.pi), + .noise => noise_buffer[@intCast(@as(i32, @intFromFloat(fp * 32)) & 31)], + }; + + const pp = fltp; + fltw *= fltw_d; + fltw = std.math.clamp(fltw, 0, 0.1); + if (p.lpf_freq != 1.0) { + fltdp += (sample - fltp) * fltw; + fltdp -= fltdp * fltdmp; + } else { + fltp = sample; + fltdp = 0; + } + fltp += fltdp; + fltphp += fltp - pp; + fltphp -= fltphp * flthp; + sample = fltphp; + phaser_buffer[@intCast(ipp & 1023)] = sample; + sample += phaser_buffer[@intCast((ipp - iphase + 1024) & 1023)]; + ipp = (ipp + 1) & 1023; + + ssample += sample * env_vol; + } + ssample = ssample / 8.0 * p.volume * 2.0; + out[n] = std.math.clamp(ssample, -1, 1); + } + return n; +} + +/// One parameter set per wave, between them every knob: a coin with punch, +/// arpeggio and a duty sweep; an explosion through both filters; a laser +/// with vibrato, phaser, repeat and a pitch limit; a rising sine. +const sets = [_]Params{ + .{ .wave = .square, .sustain = 0.1, .punch = 0.5, .decay = 0.3, .freq = 0.45, .freq_ramp = -0.2, .arp_mod = 0.4, .arp_speed = 0.6, .duty = 0.3, .duty_ramp = 0.2 }, + .{ .wave = .noise, .sustain = 0.2, .decay = 0.4, .freq = 0.2, .freq_ramp = -0.1, .lpf_freq = 0.6, .lpf_ramp = -0.1, .lpf_resonance = 0.4, .hpf_freq = 0.1, .hpf_ramp = 0.05 }, + .{ .wave = .sawtooth, .sustain = 0.25, .decay = 0.2, .freq = 0.5, .freq_limit = 0.1, .freq_dramp = 0.1, .vibrato_depth = 0.3, .vibrato_speed = 0.5, .phaser_offset = 0.3, .phaser_ramp = -0.1, .repeat_speed = 0.5 }, + .{ .wave = .sine, .attack = 0.2, .sustain = 0.2, .decay = 0.2, .freq = 0.3, .freq_ramp = 0.1, .freq_limit = 0.2, .volume = 0.8 }, +}; + +test "sfxr renders the original's samples at 44.1 kHz, and as long a sound at 48 kHz" { + // Length and Wyhash of the samples the original (02-dont-rat-me-out + // synth.zig) rendered for each set at 44.1 kHz. + const original = [_]struct { usize, u64 }{ + .{ 10003, 0xb969b441e8bd800 }, + .{ 20003, 0x5fc62aaf3122de5a }, + .{ 10253, 0x8d81ee15b98f33ac }, + .{ 12003, 0xe656fadd21b7dedb }, + }; + const out = try std.testing.allocator.alloc(f32, 2 * 48_000); + defer std.testing.allocator.free(out); + for (sets, original) |p, want| { + const n = render(p, reference_rate, out); + try std.testing.expectEqual(want[0], n); + try std.testing.expectEqual(want[1], std.hash.Wyhash.hash(0, std.mem.sliceAsBytes(out[0..n]))); + const at48 = render(p, 48_000, out); + try std.testing.expectApproxEqRel(@as(f64, @floatFromInt(n)) * 48_000 / reference_rate, @as(f64, @floatFromInt(at48)), 0.01); + } +} |
