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 Position = plugin.Position; const ParamList = plugin.ParamList; const Image = images.Image; pub const RunError = error{ UnknownCommand, NoBMP, ImageRequired, }; pub const Runner = struct { allocator: *std.mem.Allocator, image: ?*Image = null, pub fn init(allocator: *std.mem.Allocator) Runner { return Runner{ .allocator = allocator, }; } pub fn deinit(self: *Runner) void { if (self.image) |image| { image.close(); } } fn resolveArg(self: *Runner, load_path: []const u8) ![]const u8 { if (load_path[0] == ':') { // parse the index from 1 to end const index = try std.fmt.parseInt(usize, load_path[1..], 10); 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("load 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")) { 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.Dir.open(self.allocator, dirname); 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], ); var max: usize = 0; while (try dir.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 '{} {}'", 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, params: ParamList) !void { var image = try self.getImage(); image.runCustomPlugin(custom.RandomNoise, pos); } fn runCommand(self: *Runner, cmd: *lang.Command) !void { var params = ParamList.init(self.allocator); defer params.deinit(); return switch (cmd.command) { .Noop => {}, .Load => blk: { var path = cmd.args.at(0); try self.loadCmd(path); break :blk; }, .Quicksave => try self.quicksaveCmd(), .RunQS => try self.runQSCmd(cmd.args.at(0)), .Amp => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "gain"); try self.ampCmd(pos, params); }, .RFlanger => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "delay_depth_avg"); try cmd.appendParam(¶ms, "law_freq"); try self.rFlangerCmd(pos, params); }, .Eq => blk: { const pos = try cmd.consumePosition(); try cmd.appendParam(¶ms, "lo"); try cmd.appendParam(¶ms, "mid"); try cmd.appendParam(¶ms, "hi"); try self.eqCmd(pos, params); }, .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, f32(0)); 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, "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 self.noiseCmd(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 { var it = cmds.iterator(); while (it.next()) |cmd| { if (debug_flag) cmd.print(); try self.runCommand(cmd); } } };