const std = @import("std"); const lang = @import("lang.zig"); const images = @import("image.zig"); const plugin = @import("plugin.zig"); const custom = @import("custom.zig"); const magick = @import("magick.zig"); const Position = plugin.Position; const ParamList = plugin.ParamList; const ParamMap = plugin.ParamMap; const Image = images.Image; pub const RunError = error{ UnknownCommand, NoBMP, ImageRequired, }; pub const Runner = struct { allocator: *std.mem.Allocator, /// The currently opened image in the runner image: ?*Image = null, /// If the runner is in REPL mode repl: bool = false, pub fn init(allocator: *std.mem.Allocator, repl: bool) Runner { return Runner{ .allocator = allocator, .repl = repl, }; } pub fn deinit(self: *Runner) void { if (self.image) |image| { image.close(); } } pub fn clone(self: *Runner) !Runner { var cloned_image = if (self.image) |image| try image.clone() else null; return Runner{ .allocator = self.allocator, .image = cloned_image }; } fn resolveArg(self: *Runner, load_path: []const u8) ![]const u8 { if (load_path[0] == ':') { // parse the index from 1 to end var index = try std.fmt.parseInt(usize, load_path[1..], 10); // don't care about the 'repl' being prepended when we're in repl if (self.repl) index += 1; var args_it = std.process.args(); _ = args_it.skip(); var i: usize = 0; while (i <= index) : (i += 1) { _ = args_it.skip(); } const arg = try (args_it.next(self.allocator) orelse @panic("expected argument")); return arg; } else { return load_path; } } fn resolveArgPath(self: *Runner, path_or_argidx: []const u8) ![]const u8 { const path = try self.resolveArg(path_or_argidx); const resolved_path = try std.fs.path.resolve( self.allocator, &[_][]const u8{path}, ); return resolved_path; } fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void { var load_path = try self.resolveArgPath(path_or_argidx); std.debug.warn("\tload path: {}\n", .{load_path}); // we could use ImageMagick to convert from X to BMP // but i can't find an easy way to do things in memory. // the upside is that this allows some pre-processing by the user // before loading the file into scritcher. for example, you can start // krita/gimp and make it export a bmp and while in the program you can // apply filters, etc. if (!std.mem.endsWith(u8, load_path, ".bmp") and !std.mem.endsWith(u8, load_path, ".ppm")) { std.debug.warn("Only BMP files are allowed to be loaded.\n", .{}); return RunError.NoBMP; } // we don't copy load_path into a temporary file because we're already // loading it under the SFM_READ mode, which won't cause any destructive // operations on the file. self.image = try Image.open(self.allocator, load_path); } fn getImage(self: *Runner) !*Image { if (self.image) |image| { return image; } else { std.debug.warn("image is required!\n", .{}); return RunError.ImageRequired; } } fn makeGlitchedPath(self: *Runner) ![]const u8 { // we want to transform basename, if it is "x.bmp" to "x_gN.bmp", where // N is the maximum non-used integer. var image = try self.getImage(); const basename = std.fs.path.basename(image.path); const dirname = std.fs.path.dirname(image.path).?; var dir = try std.fs.cwd().openDir(dirname, .{ .iterate = true }); defer dir.close(); const period_idx = std.mem.lastIndexOf(u8, basename, ".").?; const extension = basename[period_idx..basename.len]; // starts_with would be "x_g", we want to find all files in the directory // that start with that name. const starts_with = try std.fmt.allocPrint(self.allocator, "{}_g", .{ basename[0..period_idx], }); defer self.allocator.free(starts_with); var max: usize = 0; var it = dir.iterate(); while (try it.next()) |entry| { switch (entry.kind) { .File => blk: { if (!std.mem.startsWith(u8, entry.name, starts_with)) break :blk {}; // we want to get the N in x_gN.ext const entry_gidx = std.mem.lastIndexOf(u8, entry.name, "_g").?; const entry_pidx_opt = std.mem.lastIndexOf(u8, entry.name, "."); if (entry_pidx_opt == null) break :blk {}; const entry_pidx = entry_pidx_opt.?; // if N isn't a number, we just ignore that file const idx_str = entry.name[entry_gidx + 2 .. entry_pidx]; const idx = std.fmt.parseInt(usize, idx_str, 10) catch |err| { break :blk {}; }; if (idx > max) max = idx; }, else => {}, } } const out_path = try std.fmt.allocPrint(self.allocator, "{}/{}{}{}", .{ dirname, starts_with, max + 1, extension, }); return out_path; } fn quicksaveCmd(self: *Runner) !void { var image = try self.getImage(); const out_path = try self.makeGlitchedPath(); try image.saveTo(out_path); } fn runQSCmd(self: *Runner, program: []const u8) !void { var image = try self.getImage(); const out_path = try self.makeGlitchedPath(); try image.saveTo(out_path); var proc = try std.ChildProcess.init( &[_][]const u8{ program, out_path }, self.allocator, ); defer proc.deinit(); std.debug.warn("running '{} {}'\n", .{ program, out_path }); _ = 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); } fn wildNoiseCmd(self: *Runner, pos: Position, map: *ParamMap) !void { var image = try self.getImage(); try image.runCustomPlugin(custom.WildNoise, pos, *ParamMap, map); } fn writeCmd(self: *Runner, pos: Position, map: *ParamMap) !void { var image = try self.getImage(); try image.runCustomPlugin(custom.Write, pos, *ParamMap, map); } fn embedCmd(self: *Runner, pos: Position, path: []const u8) !void { var image = try self.getImage(); try image.runCustomPlugin(custom.Embed, pos, []const u8, path); } fn rotateCmd( self: *Runner, deg: f32, bgfill: []const u8, ) !void { var image = try self.getImage(); var c_bgfill = try std.cstr.addNullByte(self.allocator, bgfill); defer self.allocator.free(c_bgfill); 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, .index = command.index, }; var params = ParamList.init(self.allocator); defer params.deinit(); const typ = @TypeOf(command); inline for (@typeInfo(typ).Struct.fields) |cmd_field| { // ignore fields that can't be symbols for lv2 execution comptime { if (std.mem.eql(u8, cmd_field.name, "base") or std.mem.eql(u8, cmd_field.name, "split") or std.mem.eql(u8, cmd_field.name, "index")) { continue; } } try params.append(plugin.Param{ .sym = cmd_field.name, .value = @field(command, cmd_field.name), }); } var image = try self.getImage(); try image.runPlugin(typ.lv2_url, pos, params); } fn newRunCommandSingle( self: *@This(), cmd: lang.NewCommand, comptime tag: lang.NewCommand.Tag, ) !void { comptime const typ = lang.NewCommand.tagToType(tag); const command = cmd.cast(typ).?; inline for (@typeInfo(typ).Struct.decls) |decl| { comptime { if (!std.mem.eql(u8, decl.name, "command_type")) { continue; } } const ctype = typ.command_type; switch (ctype) { .lv2_command => try self.executeLV2Command(command.*), else => @panic("TODO support command type"), } } } fn newRunCommand(self: *@This(), cmd: lang.NewCommand) !void { // .load => try self.newRunCommandSingle(cmd, .load), switch (cmd.tag) { .load => { const command = cmd.cast(lang.NewCommand.Load).?; try self.loadCmd(command.path); }, .quicksave => { try self.quicksaveCmd(); }, .amp => try self.newRunCommandSingle(cmd, .amp), .rflanger => try self.newRunCommandSingle(cmd, .rflanger), .eq => try self.newRunCommandSingle(cmd, .eq), .phaser => try self.newRunCommandSingle(cmd, .phaser), // .mbeq => try self.newRunCommandSingle(cmd, .mbeq), // .chorus => try self.newRunCommandSingle(cmd, .chorus), // .pitchscaler => try self.newRunCommandSingle(cmd, .pitchscaler), // .reverb => try self.newRunCommandSingle(cmd, .reverb), // .highpass => try self.newRunCommandSingle(cmd, .highpass), // .delay => try self.newRunCommandSingle(cmd, .delay), // .vinyl => try self.newRunCommandSingle(cmd, .vinyl), // .revdelay => try self.newRunCommandSingle(cmd, .revdelay), // .gate => try self.newRunCommandSingle(cmd, .gate), // .detune => try self.newRunCommandSingle(cmd, .detune), // .overdrive => try self.newRunCommandSingle(cmd, .overdrive), // .degrade => try self.newRunCommandSingle(cmd, .degrade), // .repsycho => try self.newRunCommandSingle(cmd, .repsycho), // .talkbox => try self.newRunCommandSingle(cmd, .talkbox), // .dyncomp => try self.newRunCommandSingle(cmd, .dyncomp), // .thruzero => try self.newRunCommandSingle(cmd, .thruzero), // .foverdrive => try self.newRunCommandSingle(cmd, .foverdrive), // .gverb => try self.newRunCommandSingle(cmd, .gverb), // .invert => try self.newRunCommandSingle(cmd, .invert), // .tapedelay => try self.newRunCommandSingle(cmd, .tapedelay), // .moddelay => try self.newRunCommandSingle(cmd, .moddelay), // .multichorus => try self.newRunCommandSingle(cmd, .multichorus), // .saturator => try self.newRunCommandSingle(cmd, .saturator), // .vintagedelay => try self.newRunCommandSingle(cmd, .vintagedelay), else => { std.debug.warn("TODO support {}\n", .{@tagName(cmd.tag)}); @panic("TODO support tag"); }, } } fn runCommand(self: *Runner, cmd: *lang.Command) !void { var params = ParamList.init(self.allocator); defer params.deinit(); var map = ParamMap.init(self.allocator); defer map.deinit(); return switch (cmd.command) { .Noop => {}, .Load => blk: { var path = cmd.args.items[0]; try self.loadCmd(path); // TODO is this needed? break :blk; }, .Quicksave => try self.quicksaveCmd(), .RunQS => try self.runQSCmd(cmd.args.items[0]), .Phaser => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "lfo_rate"); try cmd.appendParam(¶ms, "lfo_depth"); try cmd.appendParam(¶ms, "fb"); try cmd.appendParam(¶ms, "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(¶ms, "voices"); try cmd.appendParam(¶ms, "delay_base"); try cmd.appendParam(¶ms, "voice_spread"); try cmd.appendParam(¶ms, "detune"); try cmd.appendParam(¶ms, "law_freq"); try cmd.appendParam(¶ms, "attendb"); try self.chorusCmd(pos, params); }, .PitchScaler => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "mult"); try self.pitchScalerCmd(pos, params); }, .Reverb => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "roomLength"); try cmd.appendParam(¶ms, "roomWidth"); try cmd.appendParam(¶ms, "roomHeight"); try cmd.appendParam(¶ms, "sourceLR"); try cmd.appendParam(¶ms, "sourceFB"); try cmd.appendParam(¶ms, "listLR"); try cmd.appendParam(¶ms, "listFB"); try cmd.appendParam(¶ms, "hpf"); try cmd.appendParam(¶ms, "warmth"); try cmd.appendParam(¶ms, "diffusion"); try self.reverbCmd(pos, params); }, .Highpass => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "freq"); try cmd.appendParam(¶ms, "gain"); try cmd.appendParam(¶ms, "noClip"); try self.highpassCmd(pos, params); }, .Delay => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "seed"); try cmd.appendParam(¶ms, "gain"); try cmd.appendParam(¶ms, "feedback_pc"); try cmd.appendParam(¶ms, "tap_count"); try cmd.appendParam(¶ms, "first_delay"); try cmd.appendParam(¶ms, "delay_range"); try cmd.appendParam(¶ms, "delay_scale"); try cmd.appendParam(¶ms, "delay_rand_pc"); try cmd.appendParam(¶ms, "gain_scale"); try cmd.appendParam(¶ms, "wet"); try self.delayCmd(pos, params); }, .Vinyl => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "year"); try cmd.appendParam(¶ms, "rpm"); try cmd.appendParam(¶ms, "warp"); try cmd.appendParam(¶ms, "click"); try cmd.appendParam(¶ms, "wear"); try self.vinylCmd(pos, params); }, .RevDelay => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "delay_time"); try cmd.appendParam(¶ms, "dry_level"); try cmd.appendParam(¶ms, "wet_level"); try cmd.appendParam(¶ms, "feedback"); try cmd.appendParam(¶ms, "xfade_samp"); try self.revDelayCmd(pos, params); }, .Noise => blk: { const pos = try cmd.consumePosition(); try cmd.appendParamMap(&map, "seed"); try cmd.appendParamMap(&map, "fill_bytes"); try self.noiseCmd(pos, &map); }, .WildNoise => blk: { const pos = try cmd.consumePosition(); try cmd.appendParamMap(&map, "seed"); try cmd.appendParamMap(&map, "fill_bytes"); try self.wildNoiseCmd(pos, &map); }, .Write => blk: { const pos = try cmd.consumePosition(); try cmd.appendParamMap(&map, "data"); try self.writeCmd(pos, &map); }, .Embed => blk: { const pos = try cmd.consumePosition(); const path = cmd.args.items[2]; try self.embedCmd(pos, path); }, .Rotate => blk: { const deg = try cmd.floatArgAt(0); const bgfill = try cmd.argAt(1); try self.rotateCmd(deg, bgfill); }, .Gate => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "switch"); try cmd.appendParam(¶ms, "threshold"); try cmd.appendParam(¶ms, "attack"); try cmd.appendParam(¶ms, "hold"); try cmd.appendParam(¶ms, "decay"); try cmd.appendParam(¶ms, "gaterange"); try self.gateCmd(pos, params); }, .Detune => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "detune"); try cmd.appendParam(¶ms, "mix"); try cmd.appendParam(¶ms, "output"); try cmd.appendParam(¶ms, "latency"); try self.detuneCmd(pos, params); }, .Overdrive => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "drive"); try cmd.appendParam(¶ms, "muffle"); try cmd.appendParam(¶ms, "output"); try self.overdriveCmd(pos, params); }, .Degrade => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "headroom"); try cmd.appendParam(¶ms, "quant"); try cmd.appendParam(¶ms, "rate"); try cmd.appendParam(¶ms, "post_filt"); try cmd.appendParam(¶ms, "non_lin"); try cmd.appendParam(¶ms, "output"); try self.degradeCmd(pos, params); }, .RePsycho => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "tune"); try cmd.appendParam(¶ms, "fine"); try cmd.appendParam(¶ms, "decay"); try cmd.appendParam(¶ms, "thresh"); try cmd.appendParam(¶ms, "hold"); try cmd.appendParam(¶ms, "mix"); try cmd.appendParam(¶ms, "quality"); try self.repsychoCmd(pos, params); }, .TalkBox => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "wet"); try cmd.appendParam(¶ms, "dry"); try cmd.appendParam(¶ms, "carrier"); try cmd.appendParam(¶ms, "quality"); try self.talkboxCmd(pos, params); }, .DynComp => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "enable"); try cmd.appendParam(¶ms, "hold"); try cmd.appendParam(¶ms, "inputgain"); try cmd.appendParam(¶ms, "threshold"); try cmd.appendParam(¶ms, "ratio"); try cmd.appendParam(¶ms, "attack"); try cmd.appendParam(¶ms, "release"); try cmd.appendParam(¶ms, "gain_min"); try cmd.appendParam(¶ms, "gain_max"); try cmd.appendParam(¶ms, "rms"); try self.dynCompCmd(pos, params); }, .ThruZero => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "rate"); try cmd.appendParam(¶ms, "mix"); try cmd.appendParam(¶ms, "feedback"); try cmd.appendParam(¶ms, "depth_mod"); try self.thruZeroCmd(pos, params); }, .Foverdrive => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "drive"); try self.foverdriveCmd(pos, params); }, .Gverb => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "roomsize"); try cmd.appendParam(¶ms, "revtime"); try cmd.appendParam(¶ms, "damping"); try cmd.appendParam(¶ms, "inputbandwidth"); try cmd.appendParam(¶ms, "drylevel"); try cmd.appendParam(¶ms, "earlylevel"); try cmd.appendParam(¶ms, "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(¶ms, "speed"); try cmd.appendParam(¶ms, "da_db"); try cmd.appendParam(¶ms, "t1d"); try cmd.appendParam(¶ms, "t1a_db"); try cmd.appendParam(¶ms, "t2d"); try cmd.appendParam(¶ms, "t2a_db"); try cmd.appendParam(¶ms, "t3d"); try cmd.appendParam(¶ms, "t3a_db"); try cmd.appendParam(¶ms, "t4d"); try cmd.appendParam(¶ms, "t4a_db"); try self.tapedelayCmd(pos, params); }, .ModDelay => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "base"); try self.moddelayCmd(pos, params); }, .MultiChorus => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "min_delay"); try cmd.appendParam(¶ms, "mod_depth"); try cmd.appendParam(¶ms, "mod_rate"); try cmd.appendParam(¶ms, "stereo"); try cmd.appendParam(¶ms, "voices"); try cmd.appendParam(¶ms, "vphase"); try cmd.appendParam(¶ms, "amount"); try cmd.appendParam(¶ms, "dry"); try cmd.appendParam(¶ms, "freq"); try cmd.appendParam(¶ms, "freq2"); try cmd.appendParam(¶ms, "q"); try cmd.appendParam(¶ms, "overlap"); try cmd.appendParam(¶ms, "level_in"); try cmd.appendParam(¶ms, "level_out"); try cmd.appendParam(¶ms, "lfo"); try self.multichorusCmd(pos, params); }, .Saturator => { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "bypass"); try cmd.appendParam(¶ms, "level_in"); try cmd.appendParam(¶ms, "level_out"); try cmd.appendParam(¶ms, "mix"); try cmd.appendParam(¶ms, "drive"); try cmd.appendParam(¶ms, "blend"); try cmd.appendParam(¶ms, "lp_pre_freq"); try cmd.appendParam(¶ms, "hp_pre_freq"); try cmd.appendParam(¶ms, "lp_post_freq"); try cmd.appendParam(¶ms, "hp_post_freq"); try cmd.appendParam(¶ms, "p_freq"); try cmd.appendParam(¶ms, "p_level"); try cmd.appendParam(¶ms, "p_q"); try cmd.appendParam(¶ms, "pre"); try cmd.appendParam(¶ms, "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(¶ms, param); } try self.vintagedelayCmd(pos, params); }, else => blk: { std.debug.warn("Unsupported command: {}\n", .{cmd.command}); break :blk RunError.UnknownCommand; }, }; } /// Run a list of commands. pub fn runCommands( self: *Runner, cmds: lang.CommandList, debug_flag: bool, ) !void { for (cmds.items) |cmd| { cmd.print(); try self.newRunCommand(cmd.*); } } }; test "running noop" { const allocator = std.heap.direct_allocator; var cmds = lang.CommandList.init(allocator); defer cmds.deinit(); var cmd_ptr = try allocator.create(lang.Command); cmd_ptr.* = lang.Command{ .command = .Noop, .args = lang.ArgList.init(allocator), }; try cmds.append(cmd_ptr); var runner = Runner.init(allocator); defer runner.deinit(); try runner.runCommands(cmds, false); }