summaryrefslogtreecommitdiff
path: root/src/sketch/sfxr.zig
blob: 01657b5848714e27316449d040e14c441e6c4318 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
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);
    }
}