src/lang.zig

@@ -88,30 +88,30 @@ pub const Command = struct {
             .rflanger => RFlanger,
             .eq => Eq,
             .phaser => Phaser,
-            .mbeq => Mbeq,
+            // .mbeq => Mbeq,
-            .chorus => Chorus,
+            // .chorus => Chorus,
-            .pitchscaler => Pitchscaler,
+            // .pitchscaler => Pitchscaler,
-            .reverb => Reverb,
+            // .reverb => Reverb,
-            .highpass => Highpass,
+            // .highpass => Highpass,
-            .delay => Delay,
+            // .delay => Delay,
-            .vinyl => Vinyl,
+            // .vinyl => Vinyl,
-            .revdelay => Revdelay,
+            // .revdelay => Revdelay,
-            .gate => Gate,
+            // .gate => Gate,
-            .detune => Detune,
+            // .detune => Detune,
-            .overdrive => Overdrive,
+            // .overdrive => Overdrive,
-            .degrade => Degrade,
+            // .degrade => Degrade,
-            .repsycho => Repsycho,
+            // .repsycho => Repsycho,
-            .talkbox => Talkbox,
+            // .talkbox => Talkbox,
-            .dyncomp => Dyncomp,
+            // .dyncomp => Dyncomp,
-            .thruzero => Thruzero,
+            // .thruzero => Thruzero,
-            .foverdrive => Foverdrive,
+            // .foverdrive => Foverdrive,
-            .gverb => Gverb,
+            // .gverb => Gverb,
-            .invert => Invert,
+            // .invert => Invert,
-            .tapedelay => Tapedelay,
+            // .tapedelay => Tapedelay,
-            .moddelay => Moddelay,
+            // .moddelay => Moddelay,
-            .multichorus => Multichorus,
+            // .multichorus => Multichorus,
-            .saturator => Saturator,
+            // .saturator => Saturator,
-            .vintagedelay => Vintagedelay,
+            // .vintagedelay => Vintagedelay,
 
             else => @panic("TODO"),
         };
@@ -175,252 +175,12 @@ pub const Command = struct {
     );
 
     pub const Phaser = LV2Command(
-        .phaser,
+        .rflanger,
         "http://plugin.org.uk/swh-plugins/lfoPhaser",
         struct {
             lfo_rate: f32, lfo_depth: f32, fb: f32, spread: f32
         },
     );
-
-    pub const Mbeq = LV2Command(
-        .mbeq,
-        "http://plugin.org.uk/swh-plugins/mbeq",
-        struct {
-            band_1: f32,
-            band_2: f32,
-            band_3: f32,
-            band_4: f32,
-            band_5: f32,
-            band_6: f32,
-            band_7: f32,
-            band_8: f32,
-            band_9: f32,
-            band_10: f32,
-            band_11: f32,
-            band_12: f32,
-            band_13: f32,
-            band_14: f32,
-            band_15: f32,
-        },
-    );
-
-    pub const Chorus = LV2Command(
-        .chorus,
-        "http://plugin.org.uk/swh-plugins/multivoiceChorus",
-        struct {
-            voices: f32,
-            delay_base: f32,
-            voice_spread: f32,
-            detune: f32,
-            law_freq: f32,
-            attendb: f32,
-        },
-    );
-
-    pub const Pitchscaler = LV2Command(
-        .pitchscaler,
-        "http://plugin.org.uk/swh-plugins/pitchScaleHQ",
-        struct { mult: f32 },
-    );
-
-    pub const Reverb = LV2Command(
-        .reverb,
-        "http://invadarecords.com/plugins/lv2/erreverb/mono",
-        struct {
-            roomLength: f32,
-            roomWidth: f32,
-            roomHeight: f32,
-            sourceLR: f32,
-            sourceFB: f32,
-            listLR: f32,
-            listFB: f32,
-            hpf: f32,
-            warmth: f32,
-            diffusion: f32,
-        },
-    );
-
-    pub const Highpass = LV2Command(.highpass, "http://invadarecords.com/plugins/lv2/filter/hpf/mono", struct {
-        freq: f32,
-        gain: f32,
-        noClip: f32,
-    });
-
-    pub const Delay = LV2Command(.delay, "http://plugin.org.uk/swh-plugins/delayorama", struct {
-        seed: f32,
-        gain: f32,
-        feedback_pc: f32,
-        tap_count: f32,
-        first_delay: f32,
-        delay_range: f32,
-        delay_scale: f32,
-        delay_rand_pc: f32,
-        gain_scale: f32,
-        wet: f32,
-    });
-
-    pub const Vinyl = LV2Command(.vinyl, "http://plugin.org.uk/swh-plugins/vynil", struct {
-        year: f32,
-        rpm: f32,
-        warp: f32,
-        click: f32,
-        wear: f32,
-    });
-
-    pub const Revdelay = LV2Command(.revdelay, "http://plugin.org.uk/swh-plugins/revdelay", struct {
-        delay_time: f32,
-        dry_level: f32,
-        wet_level: f32,
-        feedback: f32,
-        xfade_samp: f32,
-    });
-    // pub const  Noise= LV2Command(.,,struct{});
-    pub const Gate = LV2Command(.gate, "http://hippie.lt/lv2/gate", struct {
-        @"switch": f32,
-        threshold: f32,
-        attack: f32,
-        hold: f32,
-        decay: f32,
-        gaterange: f32,
-    });
-    pub const Detune = LV2Command(.detune, "http://drobilla.net/plugins/mda/Detune", struct {
-        detune: f32,
-        mix: f32,
-        output: f32,
-        latency: f32,
-    });
-    pub const Overdrive = LV2Command(.overdrive, "http://drobilla.net/plugins/mda/Overdrive", struct {
-        drive: f32,
-        muffle: f32,
-        output: f32,
-    });
-    pub const Degrade = LV2Command(.degrade, "http://drobilla.net/plugins/mda/Degrade", struct {
-        headroom: f32,
-        quant: f32,
-        rate: f32,
-        post_filt: f32,
-        non_lin: f32,
-        output: f32,
-    });
-    pub const Repsycho = LV2Command(.repsycho, "http://drobilla.net/plugins/mda/RePsycho", struct {
-        tune: f32,
-        fine: f32,
-        decay: f32,
-        thresh: f32,
-        hold: f32,
-        mix: f32,
-        quality: f32,
-    });
-    pub const Talkbox = LV2Command(.talkbox, "http://drobilla.net/plugins/mda/TalkBox", struct {
-        wet: f32,
-        dry: f32,
-        carrier: f32,
-        quality: f32,
-    });
-    pub const Dyncomp = LV2Command(.dyncomp, "http://gareus.org/oss/lv2/darc#mono", struct {
-        enable: f32,
-        hold: f32,
-        inputgain: f32,
-        threshold: f32,
-        ratio: f32,
-        attack: f32,
-        release: f32,
-        gain_min: f32,
-        gain_max: f32,
-        rms: f32,
-    });
-    pub const Foverdrive = LV2Command(.foverdrive, "http://plugin.org.uk/swh-plugins/foverdrive", struct {
-        drive: f32,
-    });
-    pub const Thruzero = LV2Command(.thruzero, "http://drobilla.net/plugins/mda/ThruZero", struct {
-        rate: f32, mix: f32, feedback: f32, depth_mod: f32
-    });
-
-    pub const Gverb = LV2Command(.gverb, "http://plugin.org.uk/swh-plugins/gverb", struct {
-        roomsize: f32,
-        revtime: f32,
-        damping: f32,
-        inputbandwidth: f32,
-        drylevel: f32,
-        earlylevel: f32,
-        taillevel: f32,
-    });
-    pub const Invert = LV2Command(.invert, "http://plugin.org.uk/swh-plugins/inv", struct {});
-    pub const Tapedelay = LV2Command(.tapedelay, "http://plugin.org.uk/swh-plugins/tapeDelay", struct {
-        speed: f32,
-        da_db: f32,
-
-        t1d: f32,
-        t1a_db: f32,
-
-        t2d: f32,
-        t2a_db: f32,
-
-        t3d: f32,
-        t3a_db: f32,
-
-        t4d: f32,
-        t4a_db: f32,
-    });
-    pub const Moddelay = LV2Command(.moddelay, "http://plugin.org.uk/swh-plugins/modDelay", struct {
-        base: f32,
-    });
-
-    pub const Multichorus = LV2Command(.multichorus, "http://calf.sourceforge.net/plugins/MultiChorus", struct {
-        min_delay: f32,
-        mod_depth: f32,
-        mod_rate: f32,
-        stereo: f32,
-        voices: f32,
-        vphase: f32,
-        amount: f32,
-        dry: f32,
-        freq: f32,
-        freq2: f32,
-        q: f32,
-        overlap: f32,
-        level_in: f32,
-        level_out: f32,
-        lfo: f32,
-    });
-    pub const Saturator = LV2Command(.saturator, "http://calf.sourceforge.net/plugins/Saturator", struct {
-        bypass: f32,
-        level_in: f32,
-        level_out: f32,
-        mix: f32,
-        drive: f32,
-        blend: f32,
-        lp_pre_freq: f32,
-        hp_pre_freq: f32,
-        lp_post_freq: f32,
-        hp_post_freq: f32,
-        p_freq: f32,
-        p_level: f32,
-        p_q: f32,
-        pre: f32,
-        post: f32,
-    });
-    pub const Vintagedelay = LV2Command(.vintagedelay, "http://calf.sourceforge.net/plugins/VintageDelay", struct {
-        level_in: f32,
-        level_out: f32,
-        subdiv: f32,
-        time_l: f32,
-        time_r: f32,
-        feedback: f32,
-        amount: f32,
-        mix_mode: f32,
-        medium: f32,
-        dry: f32,
-        width: f32,
-        fragmentation: f32,
-        pbeats: f32,
-        pfrag: f32,
-        timing: f32,
-        bpm: f32,
-        ms: f32,
-        hz: f32,
-        bpm_host: f32,
-    });
 };
 
 pub const CommandList = std.ArrayList(*Command);

src/runner.zig

@@ -190,6 +190,78 @@ pub const Runner = struct {
         _ = try proc.spawnAndWait();
     }
 
+    /// Run the http://lv2plug.in/plugins/eg-amp plugin over the file.
+    fn ampCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://lv2plug.in/plugins/eg-amp", pos, params);
+    }
+
+    fn rFlangerCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/retroFlange", pos, params);
+    }
+
+    fn eqCmd(self: *Runner, position: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/dj_eq_mono", position, params);
+    }
+
+    fn phaserCmd(self: *Runner, position: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/lfoPhaser", position, params);
+    }
+
+    fn mbeqCmd(self: *Runner, position: Position, bands: []const f32) !void {
+        var image = try self.getImage();
+        var params = ParamList.init(self.allocator);
+        defer params.deinit();
+
+        for (bands) |band_value, idx| {
+            var sym = try std.fmt.allocPrint(self.allocator, "band_{}", .{idx + 1});
+            try params.append(plugin.Param{
+                .sym = sym,
+                .value = band_value,
+            });
+        }
+
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/mbeq", position, params);
+    }
+
+    fn chorusCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/multivoiceChorus", pos, params);
+    }
+
+    fn pitchScalerCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/pitchScaleHQ", pos, params);
+    }
+
+    fn reverbCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://invadarecords.com/plugins/lv2/erreverb/mono", pos, params);
+    }
+
+    fn highpassCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://invadarecords.com/plugins/lv2/filter/hpf/mono", pos, params);
+    }
+
+    fn delayCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/delayorama", pos, params);
+    }
+
+    fn vinylCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/vynil", pos, params);
+    }
+
+    fn revDelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/revdelay", pos, params);
+    }
+
     fn noiseCmd(self: *Runner, pos: Position, map: *ParamMap) !void {
         var image = try self.getImage();
         try image.runCustomPlugin(custom.RandomNoise, pos, *ParamMap, map);
@@ -222,6 +294,86 @@ pub const Runner = struct {
         try magick.runRotate(image, deg, c_bgfill);
     }
 
+    fn gateCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://hippie.lt/lv2/gate", pos, params);
+    }
+
+    fn detuneCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://drobilla.net/plugins/mda/Detune", pos, params);
+    }
+
+    fn overdriveCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://drobilla.net/plugins/mda/Overdrive", pos, params);
+    }
+
+    fn degradeCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://drobilla.net/plugins/mda/Degrade", pos, params);
+    }
+
+    fn repsychoCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://drobilla.net/plugins/mda/RePsycho", pos, params);
+    }
+
+    fn talkboxCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://drobilla.net/plugins/mda/TalkBox", pos, params);
+    }
+
+    fn dynCompCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://gareus.org/oss/lv2/darc#mono", pos, params);
+    }
+
+    fn foverdriveCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/foverdrive", pos, params);
+    }
+
+    fn thruZeroCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://drobilla.net/plugins/mda/ThruZero", pos, params);
+    }
+
+    fn gverbCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/gverb", pos, params);
+    }
+
+    fn invertCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/inv", pos, params);
+    }
+
+    fn tapedelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/tapeDelay", pos, params);
+    }
+
+    fn moddelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://plugin.org.uk/swh-plugins/modDelay", pos, params);
+    }
+
+    fn multichorusCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://calf.sourceforge.net/plugins/MultiChorus", pos, params);
+    }
+
+    fn saturatorCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://calf.sourceforge.net/plugins/Saturator", pos, params);
+    }
+
+    fn vintagedelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
+        var image = try self.getImage();
+        try image.runPlugin("http://calf.sourceforge.net/plugins/VintageDelay", pos, params);
+    }
+
     fn executeLV2Command(self: *@This(), command: var) !void {
         const pos = plugin.Position{
             .split = command.split,
@@ -280,30 +432,30 @@ pub const Runner = struct {
             .rflanger => try self.newRunCommandSingle(cmd, .rflanger),
             .eq => try self.newRunCommandSingle(cmd, .eq),
             .phaser => try self.newRunCommandSingle(cmd, .phaser),
-            .mbeq => try self.newRunCommandSingle(cmd, .mbeq),
+            // .mbeq => try self.newRunCommandSingle(cmd, .mbeq),
-            .chorus => try self.newRunCommandSingle(cmd, .chorus),
+            // .chorus => try self.newRunCommandSingle(cmd, .chorus),
-            .pitchscaler => try self.newRunCommandSingle(cmd, .pitchscaler),
+            // .pitchscaler => try self.newRunCommandSingle(cmd, .pitchscaler),
-            .reverb => try self.newRunCommandSingle(cmd, .reverb),
+            // .reverb => try self.newRunCommandSingle(cmd, .reverb),
-            .highpass => try self.newRunCommandSingle(cmd, .highpass),
+            // .highpass => try self.newRunCommandSingle(cmd, .highpass),
-            .delay => try self.newRunCommandSingle(cmd, .delay),
+            // .delay => try self.newRunCommandSingle(cmd, .delay),
-            .vinyl => try self.newRunCommandSingle(cmd, .vinyl),
+            // .vinyl => try self.newRunCommandSingle(cmd, .vinyl),
-            .revdelay => try self.newRunCommandSingle(cmd, .revdelay),
+            // .revdelay => try self.newRunCommandSingle(cmd, .revdelay),
-            .gate => try self.newRunCommandSingle(cmd, .gate),
+            // .gate => try self.newRunCommandSingle(cmd, .gate),
-            .detune => try self.newRunCommandSingle(cmd, .detune),
+            // .detune => try self.newRunCommandSingle(cmd, .detune),
-            .overdrive => try self.newRunCommandSingle(cmd, .overdrive),
+            // .overdrive => try self.newRunCommandSingle(cmd, .overdrive),
-            .degrade => try self.newRunCommandSingle(cmd, .degrade),
+            // .degrade => try self.newRunCommandSingle(cmd, .degrade),
-            .repsycho => try self.newRunCommandSingle(cmd, .repsycho),
+            // .repsycho => try self.newRunCommandSingle(cmd, .repsycho),
-            .talkbox => try self.newRunCommandSingle(cmd, .talkbox),
+            // .talkbox => try self.newRunCommandSingle(cmd, .talkbox),
-            .dyncomp => try self.newRunCommandSingle(cmd, .dyncomp),
+            // .dyncomp => try self.newRunCommandSingle(cmd, .dyncomp),
-            .thruzero => try self.newRunCommandSingle(cmd, .thruzero),
+            // .thruzero => try self.newRunCommandSingle(cmd, .thruzero),
-            .foverdrive => try self.newRunCommandSingle(cmd, .foverdrive),
+            // .foverdrive => try self.newRunCommandSingle(cmd, .foverdrive),
-            .gverb => try self.newRunCommandSingle(cmd, .gverb),
+            // .gverb => try self.newRunCommandSingle(cmd, .gverb),
-            .invert => try self.newRunCommandSingle(cmd, .invert),
+            // .invert => try self.newRunCommandSingle(cmd, .invert),
-            .tapedelay => try self.newRunCommandSingle(cmd, .tapedelay),
+            // .tapedelay => try self.newRunCommandSingle(cmd, .tapedelay),
-            .moddelay => try self.newRunCommandSingle(cmd, .moddelay),
+            // .moddelay => try self.newRunCommandSingle(cmd, .moddelay),
-            .multichorus => try self.newRunCommandSingle(cmd, .multichorus),
+            // .multichorus => try self.newRunCommandSingle(cmd, .multichorus),
-            .saturator => try self.newRunCommandSingle(cmd, .saturator),
+            // .saturator => try self.newRunCommandSingle(cmd, .saturator),
-            .vintagedelay => try self.newRunCommandSingle(cmd, .vintagedelay),
+            // .vintagedelay => try self.newRunCommandSingle(cmd, .vintagedelay),
 
             else => {
                 std.debug.warn("TODO support {}\n", .{@tagName(cmd.tag)});
@@ -331,6 +483,112 @@ pub const Runner = struct {
             .Quicksave => try self.quicksaveCmd(),
             .RunQS => try self.runQSCmd(cmd.args.items[0]),
 
+            .Phaser => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "lfo_rate");
+                try cmd.appendParam(&params, "lfo_depth");
+                try cmd.appendParam(&params, "fb");
+                try cmd.appendParam(&params, "spread");
+
+                try self.phaserCmd(pos, params);
+            },
+
+            .Mbeq => blk: {
+                const pos = try cmd.consumePosition();
+                const bands = try cmd.floatArgMany(self.allocator, 2, 15, @as(f32, 0));
+                defer self.allocator.free(bands);
+
+                try self.mbeqCmd(pos, bands);
+            },
+
+            .Chorus => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "voices");
+                try cmd.appendParam(&params, "delay_base");
+                try cmd.appendParam(&params, "voice_spread");
+                try cmd.appendParam(&params, "detune");
+                try cmd.appendParam(&params, "law_freq");
+                try cmd.appendParam(&params, "attendb");
+
+                try self.chorusCmd(pos, params);
+            },
+
+            .PitchScaler => blk: {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "mult");
+                try self.pitchScalerCmd(pos, params);
+            },
+
+            .Reverb => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "roomLength");
+                try cmd.appendParam(&params, "roomWidth");
+                try cmd.appendParam(&params, "roomHeight");
+                try cmd.appendParam(&params, "sourceLR");
+                try cmd.appendParam(&params, "sourceFB");
+                try cmd.appendParam(&params, "listLR");
+                try cmd.appendParam(&params, "listFB");
+                try cmd.appendParam(&params, "hpf");
+                try cmd.appendParam(&params, "warmth");
+                try cmd.appendParam(&params, "diffusion");
+
+                try self.reverbCmd(pos, params);
+            },
+
+            .Highpass => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "freq");
+                try cmd.appendParam(&params, "gain");
+                try cmd.appendParam(&params, "noClip");
+
+                try self.highpassCmd(pos, params);
+            },
+
+            .Delay => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "seed");
+                try cmd.appendParam(&params, "gain");
+                try cmd.appendParam(&params, "feedback_pc");
+                try cmd.appendParam(&params, "tap_count");
+                try cmd.appendParam(&params, "first_delay");
+                try cmd.appendParam(&params, "delay_range");
+                try cmd.appendParam(&params, "delay_scale");
+                try cmd.appendParam(&params, "delay_rand_pc");
+                try cmd.appendParam(&params, "gain_scale");
+                try cmd.appendParam(&params, "wet");
+
+                try self.delayCmd(pos, params);
+            },
+
+            .Vinyl => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "year");
+                try cmd.appendParam(&params, "rpm");
+                try cmd.appendParam(&params, "warp");
+                try cmd.appendParam(&params, "click");
+                try cmd.appendParam(&params, "wear");
+
+                try self.vinylCmd(pos, params);
+            },
+
+            .RevDelay => blk: {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "delay_time");
+                try cmd.appendParam(&params, "dry_level");
+                try cmd.appendParam(&params, "wet_level");
+                try cmd.appendParam(&params, "feedback");
+                try cmd.appendParam(&params, "xfade_samp");
+
+                try self.revDelayCmd(pos, params);
+            },
+
             .Noise => blk: {
                 const pos = try cmd.consumePosition();
 
@@ -367,6 +625,211 @@ pub const Runner = struct {
                 try self.rotateCmd(deg, bgfill);
             },
 
+            .Gate => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "switch");
+                try cmd.appendParam(&params, "threshold");
+                try cmd.appendParam(&params, "attack");
+                try cmd.appendParam(&params, "hold");
+                try cmd.appendParam(&params, "decay");
+                try cmd.appendParam(&params, "gaterange");
+                try self.gateCmd(pos, params);
+            },
+
+            .Detune => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "detune");
+                try cmd.appendParam(&params, "mix");
+                try cmd.appendParam(&params, "output");
+                try cmd.appendParam(&params, "latency");
+                try self.detuneCmd(pos, params);
+            },
+
+            .Overdrive => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "drive");
+                try cmd.appendParam(&params, "muffle");
+                try cmd.appendParam(&params, "output");
+                try self.overdriveCmd(pos, params);
+            },
+
+            .Degrade => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "headroom");
+                try cmd.appendParam(&params, "quant");
+                try cmd.appendParam(&params, "rate");
+                try cmd.appendParam(&params, "post_filt");
+                try cmd.appendParam(&params, "non_lin");
+                try cmd.appendParam(&params, "output");
+                try self.degradeCmd(pos, params);
+            },
+
+            .RePsycho => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "tune");
+                try cmd.appendParam(&params, "fine");
+                try cmd.appendParam(&params, "decay");
+                try cmd.appendParam(&params, "thresh");
+                try cmd.appendParam(&params, "hold");
+                try cmd.appendParam(&params, "mix");
+                try cmd.appendParam(&params, "quality");
+                try self.repsychoCmd(pos, params);
+            },
+
+            .TalkBox => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "wet");
+                try cmd.appendParam(&params, "dry");
+                try cmd.appendParam(&params, "carrier");
+                try cmd.appendParam(&params, "quality");
+                try self.talkboxCmd(pos, params);
+            },
+
+            .DynComp => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "enable");
+                try cmd.appendParam(&params, "hold");
+                try cmd.appendParam(&params, "inputgain");
+                try cmd.appendParam(&params, "threshold");
+                try cmd.appendParam(&params, "ratio");
+                try cmd.appendParam(&params, "attack");
+                try cmd.appendParam(&params, "release");
+                try cmd.appendParam(&params, "gain_min");
+                try cmd.appendParam(&params, "gain_max");
+                try cmd.appendParam(&params, "rms");
+                try self.dynCompCmd(pos, params);
+            },
+
+            .ThruZero => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "rate");
+                try cmd.appendParam(&params, "mix");
+                try cmd.appendParam(&params, "feedback");
+                try cmd.appendParam(&params, "depth_mod");
+                try self.thruZeroCmd(pos, params);
+            },
+
+            .Foverdrive => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "drive");
+                try self.foverdriveCmd(pos, params);
+            },
+
+            .Gverb => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "roomsize");
+                try cmd.appendParam(&params, "revtime");
+                try cmd.appendParam(&params, "damping");
+                try cmd.appendParam(&params, "inputbandwidth");
+                try cmd.appendParam(&params, "drylevel");
+                try cmd.appendParam(&params, "earlylevel");
+                try cmd.appendParam(&params, "taillevel");
+                try self.gverbCmd(pos, params);
+            },
+
+            .Invert => {
+                const pos = try cmd.consumePosition();
+                try self.gverbCmd(pos, params);
+            },
+
+            .TapeDelay => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "speed");
+                try cmd.appendParam(&params, "da_db");
+
+                try cmd.appendParam(&params, "t1d");
+                try cmd.appendParam(&params, "t1a_db");
+
+                try cmd.appendParam(&params, "t2d");
+                try cmd.appendParam(&params, "t2a_db");
+
+                try cmd.appendParam(&params, "t3d");
+                try cmd.appendParam(&params, "t3a_db");
+
+                try cmd.appendParam(&params, "t4d");
+                try cmd.appendParam(&params, "t4a_db");
+
+                try self.tapedelayCmd(pos, params);
+            },
+
+            .ModDelay => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "base");
+                try self.moddelayCmd(pos, params);
+            },
+
+            .MultiChorus => {
+                const pos = try cmd.consumePosition();
+                try cmd.appendParam(&params, "min_delay");
+                try cmd.appendParam(&params, "mod_depth");
+                try cmd.appendParam(&params, "mod_rate");
+                try cmd.appendParam(&params, "stereo");
+                try cmd.appendParam(&params, "voices");
+                try cmd.appendParam(&params, "vphase");
+                try cmd.appendParam(&params, "amount");
+                try cmd.appendParam(&params, "dry");
+                try cmd.appendParam(&params, "freq");
+                try cmd.appendParam(&params, "freq2");
+                try cmd.appendParam(&params, "q");
+                try cmd.appendParam(&params, "overlap");
+                try cmd.appendParam(&params, "level_in");
+                try cmd.appendParam(&params, "level_out");
+                try cmd.appendParam(&params, "lfo");
+                try self.multichorusCmd(pos, params);
+            },
+
+            .Saturator => {
+                const pos = try cmd.consumePosition();
+
+                try cmd.appendParam(&params, "bypass");
+                try cmd.appendParam(&params, "level_in");
+                try cmd.appendParam(&params, "level_out");
+                try cmd.appendParam(&params, "mix");
+                try cmd.appendParam(&params, "drive");
+                try cmd.appendParam(&params, "blend");
+                try cmd.appendParam(&params, "lp_pre_freq");
+                try cmd.appendParam(&params, "hp_pre_freq");
+                try cmd.appendParam(&params, "lp_post_freq");
+                try cmd.appendParam(&params, "hp_post_freq");
+                try cmd.appendParam(&params, "p_freq");
+                try cmd.appendParam(&params, "p_level");
+                try cmd.appendParam(&params, "p_q");
+                try cmd.appendParam(&params, "pre");
+                try cmd.appendParam(&params, "post");
+                try self.saturatorCmd(pos, params);
+            },
+
+            .VintageDelay => {
+                const pos = try cmd.consumePosition();
+                const PARAMS = [_][]const u8{
+                    "level_in",
+                    "level_out",
+                    "subdiv",
+                    "time_l",
+                    "time_r",
+                    "feedback",
+                    "amount",
+                    "mix_mode",
+                    "medium",
+                    "dry",
+                    "width",
+                    "fragmentation",
+                    "pbeats",
+                    "pfrag",
+                    "timing",
+                    "bpm",
+                    "ms",
+                    "hz",
+                    "bpm_host",
+                };
+
+                inline for (PARAMS) |param| {
+                    try cmd.appendParam(&params, param);
+                }
+
+                try self.vintagedelayCmd(pos, params);
+            },
+
             else => blk: {
                 std.debug.warn("Unsupported command: {}\n", .{cmd.command});
                 break :blk RunError.UnknownCommand;