add Image struct wrapper around libsndfile, finish loadCmd

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),
+            );
+        }
+    }
+};

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),

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,