//! 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); } }