From 41a8b18d6611787ed80ef56bd5b9be8ef53e278d Mon Sep 17 00:00:00 2001 From: Luna Date: Mon, 8 Jul 2019 12:38:16 -0300 Subject: [PATCH 1/5] add basic runner --- src/main.zig | 3 +++ src/runner.zig | 30 ++++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 src/runner.zig diff --git a/src/main.zig b/src/main.zig index f75c1ef..63d2089 100644 --- a/src/main.zig +++ b/src/main.zig @@ -17,6 +17,7 @@ const std = @import("std"); const langs = @import("lang.zig"); +const runners = @import("runner.zig"); const c = @cImport({ @cInclude("assert.h"); @@ -304,6 +305,7 @@ pub fn main() !void { const allocator = &arena.allocator; var lang = langs.Lang.init(allocator); + var runner = runners.Runner.init(allocator); //defer lang.deinit(); var args_it = std.process.args(); @@ -324,6 +326,7 @@ pub fn main() !void { _ = try file.read(data); var cmds = try lang.parse(data); + try runner.runCommands(cmds); var it = cmds.iterator(); while (it.next()) |cmd| { cmd.print(); diff --git a/src/runner.zig b/src/runner.zig new file mode 100644 index 0000000..0b81ba7 --- /dev/null +++ b/src/runner.zig @@ -0,0 +1,30 @@ +const std = @import("std"); +const lang = @import("lang.zig"); + +pub const RunError = error{UnknownCommand}; + +pub const Runner = struct { + allocator: *std.mem.Allocator, + + pub fn init(allocator: *std.mem.Allocator) Runner { + return Runner{ .allocator = allocator }; + } + + fn runCommand(self: *Runner, cmd: *lang.Command) !void { + return switch (cmd.command) { + .Noop => {}, + else => blk: { + std.debug.warn("Unknown command: {}\n", cmd.command); + break :blk RunError.UnknownCommand; + }, + }; + } + + pub fn runCommands(self: *Runner, cmds: lang.CommandList) !void { + var it = cmds.iterator(); + + while (it.next()) |cmd| { + try self.runCommand(cmd); + } + } +}; From 87459939cf0a0f5844a203623c81d1d6aed10057 Mon Sep 17 00:00:00 2001 From: Luna Date: Mon, 8 Jul 2019 13:13:03 -0300 Subject: [PATCH 2/5] add debug flag to runCommands --- src/main.zig | 12 ++++++------ src/runner.zig | 7 ++++++- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/main.zig b/src/main.zig index 63d2089..dab0623 100644 --- a/src/main.zig +++ b/src/main.zig @@ -302,12 +302,16 @@ fn print_usage() !void { pub fn main() !void { var arena = std.heap.ArenaAllocator.init(std.heap.c_allocator); + defer arena.deinit(); + const allocator = &arena.allocator; var lang = langs.Lang.init(allocator); - var runner = runners.Runner.init(allocator); //defer lang.deinit(); + var runner = runners.Runner.init(allocator); + //defer runner.deinit(); + var args_it = std.process.args(); const exe_name = try (args_it.next(allocator) orelse @panic("expected exe name")); @@ -326,11 +330,7 @@ pub fn main() !void { _ = try file.read(data); var cmds = try lang.parse(data); - try runner.runCommands(cmds); - var it = cmds.iterator(); - while (it.next()) |cmd| { - cmd.print(); - } + try runner.runCommands(cmds, true); } pub fn oldMain() !void { diff --git a/src/runner.zig b/src/runner.zig index 0b81ba7..c1ac101 100644 --- a/src/runner.zig +++ b/src/runner.zig @@ -20,10 +20,15 @@ pub const Runner = struct { }; } - pub fn runCommands(self: *Runner, cmds: lang.CommandList) !void { + 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); } } From e2f95665294986d9961c9cda6f6d48a5c7682bbb Mon Sep 17 00:00:00 2001 From: Luna Date: Mon, 8 Jul 2019 13:55:54 -0300 Subject: [PATCH 3/5] add basic resolution of arguments --- src/lang.zig | 1 + src/runner.zig | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/src/lang.zig b/src/lang.zig index 0916aeb..8b91e8f 100644 --- a/src/lang.zig +++ b/src/lang.zig @@ -52,6 +52,7 @@ pub const Lang = struct { while (splitted_it.next()) |stmt_orig| { var stmt = std.mem.trimRight(u8, stmt_orig, "\n"); + stmt = std.mem.trimLeft(u8, stmt, "\n"); if (stmt.len == 0) continue; diff --git a/src/runner.zig b/src/runner.zig index c1ac101..8d6eed6 100644 --- a/src/runner.zig +++ b/src/runner.zig @@ -10,9 +10,49 @@ pub const Runner = struct { return Runner{ .allocator = allocator }; } + 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; + } + + pub 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); + } + fn runCommand(self: *Runner, cmd: *lang.Command) !void { return switch (cmd.command) { .Noop => {}, + .Load => blk: { + var path = cmd.args.at(0); + try self.loadCmd(path); + break :blk; + }, + //.Quicksave => try self.quicksaveCmd(), else => blk: { std.debug.warn("Unknown command: {}\n", cmd.command); break :blk RunError.UnknownCommand; From 1b8784dc8fe8cecf879a80adc449bf53848c3247 Mon Sep 17 00:00:00 2001 From: Luna Date: Mon, 8 Jul 2019 14:43:58 -0300 Subject: [PATCH 4/5] add Image struct wrapper around libsndfile, finish loadCmd --- src/image.zig | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/main.zig | 8 +++--- src/runner.zig | 35 ++++++++++++++++++++++-- 3 files changed, 111 insertions(+), 5 deletions(-) create mode 100644 src/image.zig diff --git a/src/image.zig b/src/image.zig new file mode 100644 index 0000000..0def9ba --- /dev/null +++ b/src/image.zig @@ -0,0 +1,73 @@ +const std = @import("std"); +const c = @cImport({ + @cInclude("sndfile.h"); +}); + +pub const ImageError = error{OpenFail}; + +/// Low level integration function with libsndfile. +fn sopen( + allocator: *std.mem.Allocator, + path: []const u8, + mode: i32, + fmt: *c.SF_INFO, +) !*c.SNDFILE { + var cstr_path = try std.cstr.addNullByte(allocator, path); + defer allocator.free(cstr_path); + + var file = c.sf_open(cstr_path.ptr, mode, fmt); + const st: i32 = c.sf_error(file); + + if (st != 0) { + std.debug.warn( + "Failed to open {} ({})\n", + path, + c.sf_error_number(st), + ); + + return ImageError.OpenFail; + } + + return file.?; +} + +pub const Image = struct { + allocator: *std.mem.Allocator, + sndfile: *c.SNDFILE, + path: []const u8, + + /// Open a BMP file. + pub fn open(allocator: *std.mem.Allocator, path: []const u8) !*Image { + var in_fmt = c.SF_INFO{ + .frames = c_int(0), + .samplerate = c_int(44100), + .channels = c_int(1), + .format = c.SF_FORMAT_ULAW | c.SF_FORMAT_RAW | c.SF_ENDIAN_BIG, + .sections = c_int(0), + .seekable = c_int(0), + }; + + var sndfile = try sopen(allocator, path, c.SFM_READ, &in_fmt); + var image = try allocator.create(Image); + + image.* = Image{ + .allocator = allocator, + .sndfile = sndfile, + .path = path, + }; + + return image; + } + + pub fn close(self: *Image) void { + var st: i32 = c.sf_close(self.sndfile); + + if (st != 0) { + std.debug.warn( + "Failed to close {} ({})\n", + self.path, + c.sf_error_number(st), + ); + } + } +}; diff --git a/src/main.zig b/src/main.zig index dab0623..ddfeea5 100644 --- a/src/main.zig +++ b/src/main.zig @@ -22,12 +22,13 @@ const runners = @import("runner.zig"); const c = @cImport({ @cInclude("assert.h"); @cInclude("math.h"); - @cInclude("sndfile.h"); @cInclude("stdarg.h"); @cInclude("stdio.h"); @cInclude("stdlib.h"); @cInclude("string.h"); + @cInclude("sndfile.h"); + @cInclude("lilv/lilv.h"); @cInclude("lv2/core/lv2.h"); @@ -310,7 +311,7 @@ pub fn main() !void { //defer lang.deinit(); var runner = runners.Runner.init(allocator); - //defer runner.deinit(); + defer runner.deinit(); var args_it = std.process.args(); @@ -450,7 +451,8 @@ pub fn oldMain() !void { var out_fmt = c.SF_INFO{ .frames = c_int(0), .samplerate = c_int(44100), - .channels = @intCast(c_int, self.n_audio_out), + //.channels = @intCast(c_int, self.n_audio_out), + .channels = c_int(1), .format = c.SF_FORMAT_ULAW | c.SF_FORMAT_RAW, .sections = c_int(0), .seekable = c_int(0), diff --git a/src/runner.zig b/src/runner.zig index 8d6eed6..797e249 100644 --- a/src/runner.zig +++ b/src/runner.zig @@ -1,15 +1,28 @@ const std = @import("std"); const lang = @import("lang.zig"); +const images = @import("image.zig"); -pub const RunError = error{UnknownCommand}; +const Image = images.Image; + +pub const RunError = error{ + UnknownCommand, + NoBMP, +}; 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 @@ -36,12 +49,27 @@ pub const Runner = struct { self.allocator, [_][]const u8{path}, ); + return resolved_path; } - pub fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void { + 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; + } + + self.image = try Image.open(self.allocator, load_path); } fn runCommand(self: *Runner, cmd: *lang.Command) !void { @@ -52,6 +80,8 @@ pub const Runner = struct { try self.loadCmd(path); break :blk; }, + + .Quicksave => {}, //.Quicksave => try self.quicksaveCmd(), else => blk: { std.debug.warn("Unknown command: {}\n", cmd.command); @@ -60,6 +90,7 @@ pub const Runner = struct { }; } + /// Run a list of commands. pub fn runCommands( self: *Runner, cmds: lang.CommandList, From 276100c55692c6f65f4f87efbadd3cfb63b410a3 Mon Sep 17 00:00:00 2001 From: Luna Date: Mon, 8 Jul 2019 15:40:31 -0300 Subject: [PATCH 5/5] add implementation for quicksave command --- src/runner.zig | 66 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 64 insertions(+), 2 deletions(-) diff --git a/src/runner.zig b/src/runner.zig index 797e249..90ccd08 100644 --- a/src/runner.zig +++ b/src/runner.zig @@ -7,6 +7,7 @@ const Image = images.Image; pub const RunError = error{ UnknownCommand, NoBMP, + ImageRequired, }; pub const Runner = struct { @@ -72,6 +73,68 @@ pub const Runner = struct { 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 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); + } + fn runCommand(self: *Runner, cmd: *lang.Command) !void { return switch (cmd.command) { .Noop => {}, @@ -81,8 +144,7 @@ pub const Runner = struct { break :blk; }, - .Quicksave => {}, - //.Quicksave => try self.quicksaveCmd(), + .Quicksave => try self.quicksaveCmd(), else => blk: { std.debug.warn("Unknown command: {}\n", cmd.command); break :blk RunError.UnknownCommand;