scritcher/src/runner.zig

197 lines
6.2 KiB
Zig
Raw Normal View History

2019-07-08 15:38:16 +00:00
const std = @import("std");
const lang = @import("lang.zig");
const images = @import("image.zig");
2019-07-09 01:40:52 +00:00
const plugin = @import("plugin.zig");
2019-07-08 15:38:16 +00:00
const Image = images.Image;
pub const RunError = error{
UnknownCommand,
NoBMP,
ImageRequired,
};
2019-07-08 15:38:16 +00:00
pub const Runner = struct {
allocator: *std.mem.Allocator,
image: ?*Image = null,
2019-07-08 15:38:16 +00:00
pub fn init(allocator: *std.mem.Allocator) Runner {
return Runner{ .allocator = allocator };
}
pub fn deinit(self: *Runner) void {
if (self.image) |image| {
image.close();
}
}
2019-07-08 16:55:54 +00:00
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},
);
2019-07-08 16:55:54 +00:00
return resolved_path;
}
fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void {
2019-07-08 16:55:54 +00:00
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;
}
2019-07-09 01:40:52 +00:00
// TODO, copy load_path into a temporary file, then use that
// file to work on things.
self.image = try Image.open(self.allocator, load_path);
2019-07-08 16:55:54 +00:00
}
fn getImage(self: *Runner) !*Image {
if (self.image) |image| {
return image;
} else {
std.debug.warn("image is required!\n");
return RunError.ImageRequired;
}
}
fn quicksaveCmd(self: *Runner) !void {
// 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, "{}_g{}{}", starts_with, max + 1, extension);
std.debug.warn("out path: {}\n", out_path);
}
2019-07-09 01:40:52 +00:00
/// Run the http://lv2plug.in/plugins/eg-amp plugin over the file.
fn ampCmd(self: *Runner, split: i32, index: i32, gain: f32) !void {
var param = try self.allocator.create(plugin.Param);
defer self.allocator.destroy(param);
param.* = Param{ .sym = "gain", .value = gain };
var params = plugin.ParamList.init(self.allocator);
defer params.deinit();
// TODO impl this
try image.runPlugin(
"http://lv2plug.in/plugins/eg-amp",
plugin.Position{ .split = split, .index = index },
params,
);
}
2019-07-08 15:38:16 +00:00
fn runCommand(self: *Runner, cmd: *lang.Command) !void {
return switch (cmd.command) {
.Noop => {},
2019-07-08 16:55:54 +00:00
.Load => blk: {
var path = cmd.args.at(0);
try self.loadCmd(path);
break :blk;
},
.Quicksave => try self.quicksaveCmd(),
2019-07-09 01:40:52 +00:00
// .Amp => blk: {
// const split = try cmd.intArgAt(0);
// const index = try cmd.intArgAt(1);
// const gain = try cmd.floatArgAt(2);
// try self.ampCmd(split, index, gain);
// }
2019-07-08 15:38:16 +00:00
else => blk: {
std.debug.warn("Unknown command: {}\n", cmd.command);
break :blk RunError.UnknownCommand;
},
};
}
/// Run a list of commands.
2019-07-08 16:13:03 +00:00
pub fn runCommands(
self: *Runner,
cmds: lang.CommandList,
debug_flag: bool,
) !void {
2019-07-08 15:38:16 +00:00
var it = cmds.iterator();
while (it.next()) |cmd| {
2019-07-08 16:13:03 +00:00
if (debug_flag) cmd.print();
2019-07-08 15:38:16 +00:00
try self.runCommand(cmd);
}
}
};