luna/scritcher
1
2
Fork 0
Code Issues Pull requests Releases Activity

Compare commits

base: luna:master
Branches Tags
luna:master
luna:better-lilv
luna:declarative-commands
luna:embed-mp3
luna:repl
luna:zig-bug-report
luna:rotate-command
luna:noise-command
..
compare: luna:declarative-commands
Branches Tags
luna:master
luna:better-lilv
luna:declarative-commands
luna:embed-mp3
luna:repl
luna:zig-bug-report
luna:rotate-command
luna:noise-command

No commits in common. "master" and "declarative-commands" have entirely different histories.
master ... declarativ

12 changed files with 324 additions and 491 deletions
Show stats Expand all files Collapse all files

2
.gitignore vendored
View file

@ -1,5 +1,3 @@
zig-cache/
zig-out/
*.mp3
*.wav
build_runner.zig

68
build.zig
View file

@ -1,6 +1,7 @@
const std = @import("std");
const builds = @import("std").build;
const Builder = @import("std").build.Builder;
fn setupLinks(step: *std.Build.Step.Compile) void {
fn setupLinks(step: *builds.LibExeObjStep) void {
step.linkSystemLibrary("c");
step.linkSystemLibrary("lilv-0");
@ -10,64 +11,27 @@ fn setupLinks(step: *std.Build.Step.Compile) void {
step.linkSystemLibrary("GraphicsMagickWand");
step.linkSystemLibrary("GraphicsMagick");
step.addIncludePath(.{ .path = "/usr/include/GraphicsMagick" });
step.addIncludePath(.{ .path = "/usr/include" });
const possible_lilv_include_dirs = [_][]const u8{
"/usr/include/lilv-0/lilv",
"/usr/include/lilv-0",
};
var found_any_lilv = false;
for (possible_lilv_include_dirs) |possible_lilv_dir| {
var possible_dir = std.fs.cwd().openDir(possible_lilv_dir, .{}) catch |err| {
std.debug.print("possible lilv {s} fail: {s}\n", .{ possible_lilv_dir, @errorName(err) });
continue;
};
possible_dir.close();
found_any_lilv = true;
std.debug.print("found lilv at '{s}'\n", .{possible_lilv_dir});
step.addIncludePath(.{ .path = possible_lilv_dir });
}
if (!found_any_lilv) {
std.debug.print("No LILV library was found :(\n", .{});
@panic("no lilv found");
}
step.addIncludeDir("/usr/include/lilv-0");
step.addIncludeDir("/usr/include/GraphicsMagick");
}
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const exe = b.addExecutable("scritcher", "src/main.zig");
exe.setBuildMode(mode);
exe.install();
const exe = b.addExecutable(.{
.name = "scritcher",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
setupLinks(exe);
b.installArtifact(exe);
const run_cmd = b.addRunArtifact(exe);
const test_obj_step = b.addTest("src/main.zig");
setupLinks(test_obj_step);
if (b.args) |args| {
run_cmd.addArgs(args);
}
const run_cmd = exe.run();
run_cmd.step.dependOn(b.getInstallStep());
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
const test_step = b.addTest(.{
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
setupLinks(test_step);
const run_unit_tests = b.addRunArtifact(test_step);
const test_cmd = b.step("test", "run unit tests");
test_cmd.dependOn(&run_unit_tests.step);
const test_step = b.step("test", "Run tests");
test_step.dependOn(&test_obj_step.step);
}

5
src/bmp_valid.zig
View file

@ -1,10 +1,11 @@
const std = @import("std");
const log = std.log.scoped(.scritcher_bmp);
pub const BMPValidError = error{InvalidMagic};
const VALID_MAGICS = [_][]const u8{
"BM",
"BA",
"CI",
"CP",
"IC",
@ -19,7 +20,7 @@ pub fn magicValid(magic: []const u8) !void {
}
if (!valid) {
log.debug("\tINVALID HEADER: '{s}'", .{magic});
std.debug.warn("\tINVALID HEADER: '{}'\n", .{magic});
return BMPValidError.InvalidMagic;
}
}

46
src/custom.zig
View file

@ -4,7 +4,6 @@ const lv2 = @import("lv2_helpers.zig");
const plugins = @import("plugin.zig");
const image = @import("image.zig");
const log = std.log.scoped(.scritcher_custom);
const c = lv2.c;
const RunBuffers = plugins.RunBuffers;
@ -12,20 +11,20 @@ const RunBuffers = plugins.RunBuffers;
pub const RandomNoise = struct {
r: std.rand.DefaultPrng,
rand_buf: ?[]f32 = null,
allocator: ?std.mem.Allocator = null,
allocator: ?*std.mem.Allocator = null,
cnt: usize = 0,
pub fn init(
allocator: std.mem.Allocator,
params: anytype,
allocator: *std.mem.Allocator,
params: var,
) ?RandomNoise {
var r = std.rand.DefaultPrng.init(params.seed);
if (params.fill_bytes > 0) {
var rand_buf = allocator.alloc(f32, params.fill_bytes) catch return null;
for (rand_buf, 0..) |_, idx| {
rand_buf[idx] = r.random().float(f32);
for (rand_buf) |_, idx| {
rand_buf[idx] = r.random.float(f32);
}
return RandomNoise{
@ -52,7 +51,7 @@ pub const RandomNoise = struct {
bufs.out[0] = rand_buf[self.cnt];
self.cnt += 1;
} else {
bufs.out[0] = self.r.random().float(f32);
bufs.out[0] = self.r.random.float(f32);
}
}
};
@ -60,20 +59,20 @@ pub const RandomNoise = struct {
pub const WildNoise = struct {
r: std.rand.DefaultPrng,
rand_buf: ?[]f32 = null,
allocator: ?std.mem.Allocator = null,
allocator: ?*std.mem.Allocator = null,
cnt: usize = 0,
pub fn init(
allocator: std.mem.Allocator,
params: anytype,
allocator: *std.mem.Allocator,
params: var,
) ?WildNoise {
var r = std.rand.DefaultPrng.init(params.seed);
if (params.fill_bytes > 0) {
var rand_buf = allocator.alloc(f32, params.fill_bytes) catch return null;
for (rand_buf, 0..) |_, idx| {
rand_buf[idx] = @as(f32, @floatFromInt(r.random().int(u1)));
for (rand_buf) |_, idx| {
rand_buf[idx] = @intToFloat(f32, r.random.int(u1));
}
return WildNoise{
@ -99,7 +98,7 @@ pub const WildNoise = struct {
bufs.out[0] = rand_buf[self.cnt];
self.cnt += 1;
} else {
bufs.out[0] = @as(f32, @floatFromInt(self.r.random().int(u1)));
bufs.out[0] = @intToFloat(f32, self.r.random.int(u1));
}
}
};
@ -112,18 +111,15 @@ pub const Write = struct {
data: f32,
pub fn init(
allocator: std.mem.Allocator,
params: anytype,
allocator: *std.mem.Allocator,
params: var,
) Write {
_ = allocator;
return Write{
.data = params.data,
};
}
pub fn deinit(self: *Write) void {
_ = self;
}
pub fn deinit(self: *Write) void {}
pub fn run(self: *Write, bufs: *RunBuffers) void {
bufs.out[0] = self.data;
@ -131,13 +127,13 @@ pub const Write = struct {
};
pub const Embed = struct {
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
filepath: []const u8,
sndfile: *c.SNDFILE = undefined,
buf: []f32 = undefined,
pub fn init(allocator: std.mem.Allocator, params: anytype) @This() {
pub fn init(allocator: *std.mem.Allocator, params: var) @This() {
return Embed{
.allocator = allocator,
.filepath = params.path,
@ -163,12 +159,10 @@ pub const Embed = struct {
image.sseek(self.sndfile, 0);
self.buf = try self.allocator.alloc(f32, @as(usize, @intCast(in_fmt.channels)));
self.buf = try self.allocator.alloc(f32, @intCast(usize, in_fmt.channels));
}
pub fn deinit(self: *@This()) void {
_ = self;
}
pub fn deinit(self: *@This()) void {}
pub fn run(self: *@This(), bufs: *RunBuffers) void {
const read_bytes = c.sf_readf_float(self.sndfile, self.buf.ptr, 1);
@ -180,7 +174,7 @@ pub const Embed = struct {
if (read_bytes < 0) {
const st: i32 = c.sf_error(self.sndfile);
log.debug("Failed to read {s} ({s})", .{
std.debug.warn("Failed to read {} ({})\n", .{
self.filepath,
c.sf_error_number(st),
});

150
src/image.zig
View file

@ -3,7 +3,6 @@ const lv2 = @import("lv2_helpers.zig");
const c = lv2.c;
const bmp = @import("bmp_valid.zig");
const log = std.log.scoped(.scritcher_image);
const plugins = @import("plugin.zig");
/// Buffer size for main image copying.
@ -21,19 +20,19 @@ pub const ImageError = error{
/// Low level integration function with libsndfile.
pub fn sopen(
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
path: []const u8,
mode: i32,
fmt: *c.SF_INFO,
) !*c.SNDFILE {
const cstr_path = try allocator.dupeZ(u8, path);
var cstr_path = try std.cstr.addNullByte(allocator, path);
defer allocator.free(cstr_path);
const file = c.sf_open(cstr_path.ptr, mode, fmt);
var file = c.sf_open(cstr_path.ptr, mode, fmt);
const st: i32 = c.sf_error(file);
if (st != 0) {
log.debug("Failed to open {s} ({s})", .{
std.debug.warn("Failed to open {} ({})\n", .{
path,
c.sf_error_number(st),
});
@ -43,12 +42,12 @@ pub fn sopen(
const frames_on_end = c.sf_seek(file, 0, c.SEEK_END);
_ = c.sf_seek(file, 0, c.SEEK_SET);
try std.testing.expectEqual(fmt.frames, frames_on_end);
std.testing.expectEqual(fmt.frames, frames_on_end);
const frames_on_end_by_end = c.sf_seek(file, frames_on_end, c.SEEK_SET);
try std.testing.expectEqual(frames_on_end, frames_on_end_by_end);
std.testing.expectEqual(frames_on_end, frames_on_end_by_end);
log.debug("frames on end: {}, frame on end (2): {}", .{ frames_on_end, frames_on_end_by_end });
std.debug.warn("frames on end: {}, frame on end (2): {}\n", .{ frames_on_end, frames_on_end_by_end });
return file.?;
}
@ -57,30 +56,30 @@ pub fn swrite(file: *c.SNDFILE, buf: [*]f32, frames: i64) !void {
const count = c.sf_writef_float(file, buf, frames);
if (count != frames) {
log.debug("Wanted to write {}, got {}", .{ frames, count });
std.debug.warn("Wanted to write {}, got {}\n", .{ frames, count });
return ImageError.WriteFail;
}
}
pub fn sseek(file: *c.SNDFILE, offset: usize) void {
const offset_i64 = @as(i64, @intCast(offset));
const offset_i64 = @intCast(i64, offset);
const frames = c.sf_seek(file, offset_i64, c.SEEK_SET);
const frames_current = c.sf_seek(file, 0, c.SEEK_CUR);
std.debug.assert(frames == frames_current);
std.testing.expectEqual(frames, frames_current);
if (frames != offset_i64) {
log.debug("failed to seek to {} (seeked {} frames, offset_i64={})", .{ offset, frames, offset_i64 });
std.debug.warn("failed to seek to {} (seeked {} frames, offset_i64={})\n", .{ offset, frames, offset_i64 });
}
}
/// Caller owns the returned memory.
pub fn temporaryName(allocator: std.mem.Allocator) ![]u8 {
pub fn temporaryName(allocator: *std.mem.Allocator) ![]u8 {
const template_start = "/temp/temp_";
const template = "/tmp/temp_XXXXXXXXXXXXXXXXXXXXX";
var nam = try allocator.alloc(u8, template.len);
std.mem.copyForwards(u8, nam, template);
std.mem.copy(u8, nam, template);
const seed = @as(u64, @truncate(@as(u128, @bitCast(std.time.nanoTimestamp()))));
const seed = @truncate(u64, @bitCast(u128, std.time.nanoTimestamp()));
var r = std.rand.DefaultPrng.init(seed);
var fill = nam[template_start.len..nam.len];
@ -88,17 +87,17 @@ pub fn temporaryName(allocator: std.mem.Allocator) ![]u8 {
var i: usize = 0;
while (i < 100) : (i += 1) {
// generate a random uppercase letter, that is, 65 + random number.
for (fill, 0..) |_, f_idx| {
const idx = @as(u8, @intCast(r.random().uintLessThan(u5, 24)));
const letter = @as(u8, 65) + idx;
for (fill) |_, f_idx| {
var idx = @intCast(u8, r.random.uintLessThan(u5, 24));
var letter = @as(u8, 65) + idx;
fill[f_idx] = letter;
}
// if we fail to access it, we assume it doesn't exist and return it.
var tmp_file: std.fs.File = std.fs.cwd().openFile(
nam,
.{ .mode = .read_only },
) catch |err| {
.{ .read = true, .write = false },
) catch |err| blk: {
if (err == error.FileNotFound) return nam else continue;
};
@ -122,7 +121,7 @@ pub fn mkSfInfo() c.SF_INFO {
}
pub const Image = struct {
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
/// Pointer to the underlying libsndfile's SNDFILE struct.
sndfile: *c.SNDFILE,
@ -137,11 +136,11 @@ pub const Image = struct {
curpath: []const u8,
/// Open a BMP image for later.
pub fn open(allocator: std.mem.Allocator, path: []const u8) !*Image {
pub fn open(allocator: *std.mem.Allocator, path: []const u8) !*Image {
var in_fmt = mkSfInfo();
const sndfile = try sopen(allocator, path, c.SFM_READ, &in_fmt);
var sndfile = try sopen(allocator, path, c.SFM_READ, &in_fmt);
const image = try allocator.create(Image);
var image = try allocator.create(Image);
std.debug.assert(in_fmt.frames > @as(i64, 0));
std.debug.assert(in_fmt.seekable == @as(i32, 1));
@ -151,7 +150,7 @@ pub const Image = struct {
.sndfile = sndfile,
.path = path,
.curpath = path,
.frames = @as(usize, @intCast(in_fmt.frames)),
.frames = @intCast(usize, in_fmt.frames),
};
return image;
@ -160,10 +159,10 @@ pub const Image = struct {
pub fn clone(self: *Image) !*Image {
var in_fmt = mkSfInfo();
// clone sndfile
const sndfile = try sopen(self.allocator, self.curpath, c.SFM_READ, &in_fmt);
std.debug.assert(self.frames == @as(usize, @intCast(in_fmt.frames)));
var sndfile = try sopen(self.allocator, self.curpath, c.SFM_READ, &in_fmt);
std.testing.expectEqual(self.frames, @intCast(usize, in_fmt.frames));
const image = try self.allocator.create(Image);
var image = try self.allocator.create(Image);
std.debug.assert(in_fmt.frames > @as(i64, 0));
std.debug.assert(in_fmt.seekable == @as(i32, 1));
@ -173,37 +172,35 @@ pub const Image = struct {
.sndfile = sndfile,
.path = self.path,
.curpath = self.curpath,
.frames = @as(usize, @intCast(in_fmt.frames)),
.frames = @intCast(usize, in_fmt.frames),
};
return image;
}
pub fn close(self: *Image) void {
const st: i32 = c.sf_close(self.sndfile);
//self.allocator.free(self.path);
//self.allocator.free(self.curpath);
var st: i32 = c.sf_close(self.sndfile);
if (st != 0) {
log.debug("Failed to close {s} ({s})", .{
std.debug.warn("Failed to close {} ({})\n", .{
self.path,
c.sf_error_number(st),
});
}
self.allocator.free(self.path);
self.allocator.free(self.curpath);
var allocator = self.allocator;
self.* = undefined;
allocator.destroy(self);
}
pub fn read(self: *Image, file_chans: c_int, buf: []f32) bool {
const n_read: c.sf_count_t = c.sf_readf_float(self.sndfile, buf.ptr, 1);
const buf_chans = @as(c_int, @intCast(buf.len));
var file = file_opt.?;
const n_read: c.sf_count_t = c.sf_readf_float(file, buf.ptr, 1);
const buf_chans = @intCast(c_int, buf.len);
var i = file_chans - 1;
while (i < buf_chans) : (i += 1) {
//buf[@intCast(usize, i)] = buf[i % file_chans];
buf[@as(usize, @intCast(i))] = buf[@as(usize, @intCast(@mod(i, file_chans)))];
buf[@intCast(usize, i)] = buf[@intCast(usize, @mod(i, file_chans))];
}
return n_read == 1;
@ -227,7 +224,7 @@ pub const Image = struct {
sseek(out_file, start);
while (i <= end) : (i += buf.len) {
log.debug("\t\ti={d}, buf.len={d}, end={d}", .{ i, buf.len, end });
std.debug.warn("\t\ti={}, buf.len={}, end={}\n", .{ i, buf.len, end });
sseek(self.sndfile, i);
sseek(out_file, i);
@ -237,13 +234,13 @@ pub const Image = struct {
var view: []f32 = buf[0..buf.len];
if (bytes_until_end < buf.len) {
read_bytes = c.sf_readf_float(self.sndfile, buf.ptr, @as(i64, @intCast(bytes_until_end)));
read_bytes = c.sf_readf_float(self.sndfile, buf.ptr, @intCast(i64, bytes_until_end));
view = buf[0..bytes_until_end];
} else {
read_bytes = c.sf_readf_float(self.sndfile, buf.ptr, @as(i64, @intCast(buf.len)));
read_bytes = c.sf_readf_float(self.sndfile, buf.ptr, @intCast(i64, buf.len));
}
try swrite(out_file, view.ptr, @as(i64, @intCast(view.len)));
try swrite(out_file, view.ptr, @intCast(i64, view.len));
}
sseek(self.sndfile, end);
@ -252,8 +249,8 @@ pub const Image = struct {
fn getSeekPos(self: *Image, position: plugins.Position) plugins.SeekPos {
const file_end = self.frames;
const seek_pos = position.seekPos(file_end);
log.debug("\tstart {d} end {d}", .{ seek_pos.start, seek_pos.end });
var seek_pos = position.seekPos(file_end);
std.debug.warn("\tstart {} end {}\n", .{ seek_pos.start, seek_pos.end });
return seek_pos;
}
@ -264,9 +261,9 @@ pub const Image = struct {
// std.testing.expectEqual(self.frames, @intCast(usize, in_fmt.frames));
self.curpath = path;
self.frames = @as(usize, @intCast(in_fmt.frames));
self.frames = @intCast(usize, in_fmt.frames);
log.debug("\timage: reopened on '{s}' (frames={d}, fmt.frames={d})", .{
std.debug.warn("\timage: reopened on '{}' (frames={}, fmt.frames={})\n", .{
self.curpath,
self.frames,
in_fmt.frames,
@ -274,7 +271,7 @@ pub const Image = struct {
}
pub fn checkValid(self: *Image) !void {
var file = try std.fs.cwd().openFile(self.path, .{ .mode = .read_only });
var file = try std.fs.cwd().openFile(self.path, .{ .read = true });
defer file.close();
// main bmp header:
@ -306,34 +303,33 @@ pub const Image = struct {
defer ctx.deinit();
var ports = try lv2.setupPorts(&ctx);
defer ctx.allocator.free(ports);
if (ctx.n_audio_in > 2) {
log.debug("plugin <{s}> has more than two inputs.", .{plugin_uri});
std.debug.warn("plugin <{}> has more than two inputs.\n", .{plugin_uri});
return ImageError.InvalidPlugin;
}
if (ctx.n_audio_out > 2) {
log.debug("plugin <{s}> has more than two outputs.", .{plugin_uri});
std.debug.warn("plugin <{}> has more than two outputs.\n", .{plugin_uri});
return ImageError.InvalidPlugin;
}
// now, for each param for the plugin, we find its port, and set
// the value for the port there.
for (params.items) |param| {
const sym_cstr = try self.allocator.dupeZ(u8, param.sym);
var sym_cstr = try std.cstr.addNullByte(self.allocator, param.sym);
defer self.allocator.free(sym_cstr);
const sym = c.lilv_new_string(ctx.world, sym_cstr.ptr);
const port = c.lilv_plugin_get_port_by_symbol(ctx.plugin, sym) orelse {
log.debug("assert fail: symbol {s} not found on port", .{param.sym});
var sym = c.lilv_new_string(ctx.world, sym_cstr.ptr);
const port = c.lilv_plugin_get_port_by_symbol(ctx.plugin, sym) orelse blk: {
std.debug.warn("assert fail: symbol {} not found on port\n", .{param.sym});
return ImageError.InvalidSymbol;
};
c.lilv_node_free(sym);
const idx = c.lilv_port_get_index(ctx.plugin, port);
log.debug("\tset sym={s}, idx={d} to val={}", .{
var idx = c.lilv_port_get_index(ctx.plugin, port);
std.debug.warn("\tset sym={}, idx={} to val={}\n", .{
param.sym,
idx,
param.value,
@ -343,11 +339,11 @@ pub const Image = struct {
// now we need to generate a temporary file and put the output of
// running the plugin on that file
const tmpnam = try temporaryName(self.allocator);
log.debug("\trunning plugin from '{s}' to '{s}'", .{ self.curpath, tmpnam });
var tmpnam = try temporaryName(self.allocator);
std.debug.warn("\trunning plugin from '{}' to '{}'\n", .{ self.curpath, tmpnam });
var out_fmt = mkSfInfo();
const out_file = try sopen(self.allocator, tmpnam, c.SFM_WRITE, &out_fmt);
var out_file = try sopen(self.allocator, tmpnam, c.SFM_WRITE, &out_fmt);
var rctx = try plugins.RunContext.init(self.allocator, ctx.plugin);
defer rctx.deinit();
@ -377,10 +373,10 @@ pub const Image = struct {
sseek(self.sndfile, seek_pos.start);
var i: usize = seek_pos.start;
log.debug("\tseek pos start: {d} end: {d}", .{ seek_pos.start, seek_pos.end });
std.debug.warn("\tseek pos start: {} end: {}\n", .{ seek_pos.start, seek_pos.end });
var inbuf = &rctx.buffers.in;
const outbuf = &rctx.buffers.out;
var outbuf = &rctx.buffers.out;
while (i <= seek_pos.end) : (i += 1) {
inbuf[0] = 0;
@ -388,7 +384,7 @@ pub const Image = struct {
const read_bytes = c.sf_readf_float(self.sndfile, inbuf, 1);
if (read_bytes == 0) {
log.debug("WARN! reached EOF at idx={d}", .{i});
std.debug.warn("WARN! reached EOF at idx={}\n", .{i});
break;
}
@ -416,12 +412,12 @@ pub const Image = struct {
try self.reopen(tmpnam);
try self.checkValid();
const time_taken = timer.read();
log.debug("\ttook {d:.2}ms running plugin", .{time_taken / std.time.us_per_ms});
var time_taken = timer.read();
std.debug.warn("\ttook {d:.2}ms running plugin\n", .{time_taken / std.time.us_per_ms});
}
pub fn saveTo(self: *Image, out_path: []const u8) !void {
log.debug("\timg: copy from '{s}' to '{s}'", .{ self.curpath, out_path });
std.debug.warn("\timg: copy from '{}' to '{}'\n", .{ self.curpath, out_path });
try std.fs.copyFileAbsolute(self.curpath, out_path, .{});
}
@ -429,9 +425,9 @@ pub const Image = struct {
self: *Image,
comptime Plugin: type,
position: plugins.Position,
extra: anytype,
extra: var,
) !void {
const plugin_opt: ?Plugin = Plugin.init(self.allocator, extra);
var plugin_opt: ?Plugin = Plugin.init(self.allocator, extra);
if (plugin_opt == null) {
return ImageError.PluginLoadFail;
}
@ -448,11 +444,11 @@ pub const Image = struct {
// the code here is a copypaste of runPlugin() without the specific
// lilv things.
const tmpnam = try temporaryName(self.allocator);
log.debug("\trunning CUSTOM plugin from '{s}' to '{s}'", .{ self.curpath, tmpnam });
var tmpnam = try temporaryName(self.allocator);
std.debug.warn("\trunning CUSTOM plugin from '{}' to '{}'\n", .{ self.curpath, tmpnam });
var out_fmt = mkSfInfo();
const out_file = try sopen(self.allocator, tmpnam, c.SFM_WRITE, &out_fmt);
var out_file = try sopen(self.allocator, tmpnam, c.SFM_WRITE, &out_fmt);
var bufs = plugins.RunBuffers{};
const seek_pos = self.getSeekPos(position);
@ -476,15 +472,15 @@ pub const Image = struct {
sseek(self.sndfile, seek_pos.start);
var i: usize = seek_pos.start;
log.debug("\tseek pos start: {d} end: {d}", .{ seek_pos.start, seek_pos.end });
std.debug.warn("\tseek pos start: {} end: {}\n", .{ seek_pos.start, seek_pos.end });
const inbuf = &bufs.in;
const outbuf = &bufs.out;
var inbuf = &bufs.in;
var outbuf = &bufs.out;
while (i <= seek_pos.end) : (i += 1) {
const read_bytes = c.sf_readf_float(self.sndfile, inbuf, 1);
if (read_bytes == 0) {
log.debug("WARN! reached EOF at idx={d}", .{i});
std.debug.warn("WARN! reached EOF at idx={}\n", .{i});
break;
}

212
src/lang.zig
View file

@ -3,7 +3,6 @@ const std = @import("std");
const plugin = @import("plugin.zig");
const custom = @import("custom.zig");
const log = std.log.scoped(.scritcher_lang);
pub const ParseError = error{ParseFail};
pub const CommandType = enum {
@ -94,7 +93,7 @@ pub const Command = struct {
rotate,
};
pub fn tagToType(comptime tag: Tag) type {
pub fn tagToType(tag: Tag) type {
return switch (tag) {
.noop => Noop,
.load => Load,
@ -136,6 +135,8 @@ pub const Command = struct {
.embed => Embed,
.rotate => Rotate,
else => @panic("TODO"),
};
}
@ -143,23 +144,11 @@ pub const Command = struct {
if (base.tag != T.base_tag)
return null;
//const baseInt = @intFromPtr(base);
//log.debug("casting from {d}", .{baseInt});
//log.debug("aligns from 8? {d}", .{baseInt % 8});
//log.debug("align T: {d} {s}", .{ @alignOf(*T), @typeName(T) });
//log.debug("align base: {d} {s}", .{ @alignOf(*const @This()), @typeName(@This()) });
const base_aligned: *const @This() = @alignCast(base);
const parented = @as(*const T, @alignCast(@fieldParentPtr("base", base_aligned)));
const ptr: *const T = @alignCast(parented);
//log.debug("align: {d}\n", .{@alignOf(@TypeOf(ptr))});
return ptr;
return @fieldParentPtr(T, "base", base);
}
pub fn print(base: *const @This()) void {
log.debug("tag: {}", .{base.tag});
std.debug.warn("tag: {}\n", .{base.tag});
}
pub const Noop = struct {
@ -170,7 +159,7 @@ pub const Command = struct {
pub const Load = struct {
pub const base_tag = Tag.load;
base: Command,
path: []const u8,
path: []u8,
};
pub const Quicksave = struct {
@ -212,25 +201,33 @@ pub const Command = struct {
pub const Amp = LV2Command(
.amp,
"http://lv2plug.in/plugins/eg-amp",
struct { gain: f32 },
struct {
gain: f32
},
);
pub const RFlanger = LV2Command(
.rflanger,
"http://plugin.org.uk/swh-plugins/retroFlange",
struct { delay_depth_avg: f32, law_freq: f32 },
struct {
delay_depth_avg: f32, law_freq: f32
},
);
pub const Eq = LV2Command(
.rflanger,
"http://plugin.org.uk/swh-plugins/dj_eq_mono",
struct { lo: f32, mid: f32, hi: f32 },
struct {
lo: f32, mid: f32, hi: f32
},
);
pub const Phaser = LV2Command(
.phaser,
"http://plugin.org.uk/swh-plugins/lfoPhaser",
struct { lfo_rate: f32, lfo_depth: f32, fb: f32, spread: f32 },
struct {
lfo_rate: f32, lfo_depth: f32, fb: f32, spread: f32
},
);
pub const Mbeq = LV2Command(
@ -383,7 +380,9 @@ pub const Command = struct {
pub const Foverdrive = LV2Command(.foverdrive, "http://plugin.org.uk/swh-plugins/foverdrive", struct {
drive: f32,
});
pub const Thruzero = LV2Command(.thruzero, "http://drobilla.net/plugins/mda/ThruZero", struct { rate: f32, mix: f32, feedback: f32, depth_mod: f32 });
pub const Thruzero = LV2Command(.thruzero, "http://drobilla.net/plugins/mda/ThruZero", struct {
rate: f32, mix: f32, feedback: f32, depth_mod: f32
});
pub const Gverb = LV2Command(.gverb, "http://plugin.org.uk/swh-plugins/gverb", struct {
roomsize: f32,
@ -477,94 +476,50 @@ pub const Command = struct {
});
};
const CmdArrayList = std.ArrayList(*Command);
pub const CommandList = struct {
list: CmdArrayList,
const Self = @This();
pub fn init(allocator: std.mem.Allocator) Self {
return .{
.list = CmdArrayList.init(allocator),
};
}
pub fn deinit(self: *Self) void {
for (self.list.items) |cmd_ptr| {
inline for (@typeInfo(Command.Tag).Enum.fields) |field| {
if (cmd_ptr.tag == @field(Command.Tag, field.name)) {
const actual_tag =
@field(Command.Tag, field.name);
// if we find a match on the tag, we can get the type
const typ = Command.tagToType(actual_tag);
const inner_command = cmd_ptr.cast(typ).?;
inline for (@typeInfo(typ).Struct.fields) |cmd_field| {
switch (cmd_field.type) {
[]u8, []const u8 => self.list.allocator.free(@field(inner_command, cmd_field.name)),
else => {},
}
}
}
}
//TODO this is ian invalid free
//self.list.allocator.destroy(cmd_ptr);
}
self.list.deinit();
}
pub fn append(self: *Self, cmd: *Command) !void {
return try self.list.append(cmd);
}
};
pub const CommandList = std.ArrayList(*Command);
/// A parser.
pub const Lang = struct {
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
has_error: bool = false,
line: usize = 0,
pub fn init(allocator: std.mem.Allocator) Lang {
pub fn init(allocator: *std.mem.Allocator) Lang {
return Lang{
.allocator = allocator,
};
}
pub fn deinit(self: *Lang) void {
_ = self;
}
pub fn deinit(self: *Lang) void {}
pub fn reset(self: *Lang) void {
self.has_error = false;
self.line = 0;
}
fn doError(self: *Lang, comptime fmt: []const u8, args: anytype) void {
log.warn("ERROR! at line {}: ", .{self.line});
log.warn(fmt, args);
fn doError(self: *Lang, comptime fmt: []const u8, args: var) void {
std.debug.warn("ERROR! at line {}: ", .{self.line});
std.debug.warn(fmt, args);
std.debug.warn("\n", .{});
self.has_error = true;
}
fn parseCommandArguments(
self: *@This(),
comptime command_struct: type,
tok_it: *std.mem.SplitIterator(u8, .sequence),
tok_it: *std.mem.TokenIterator,
commands: *CommandList,
) !void {
// Based on the command struct fields, we can parse the arguments.
var cmd = try self.allocator.create(command_struct);
// we already add the command to the list to prevent memory leaks
// by commands that error out
try commands.append(&cmd.base);
const is_lv2_command = switch (command_struct.base_tag) {
.noop, .load, .quicksave, .runqs, .rotate => false,
else => true,
};
// TODO: crash when no arguments are left but we still need
// arguments...
if (is_lv2_command) {
const split = tok_it.next();
if (split == null) {
@ -584,16 +539,16 @@ pub const Lang = struct {
inline for (@typeInfo(@TypeOf(cmd.parameters)).Struct.fields) |cmd_field| {
const maybe_arg = tok_it.next();
if (maybe_arg == null) {
self.doError("Expected parameter for {s}, got nothing", .{cmd_field.name});
self.doError("Expected parameter for {}, got nothing", .{cmd_field.name});
return;
}
const arg = maybe_arg.?;
const arg_value = switch (cmd_field.type) {
const arg_value = switch (cmd_field.field_type) {
f32 => try std.fmt.parseFloat(f32, arg),
u64 => try std.fmt.parseInt(u64, arg, 10),
usize => try std.fmt.parseInt(usize, arg, 10),
[]const u8 => @as([]const u8, try self.allocator.dupe(u8, arg)),
[]const u8 => try self.allocator.dupe(u8, arg),
else => @compileError("parameter struct has unsupported type " ++ @typeName(cmd_field.field_type)),
};
@ -606,23 +561,17 @@ pub const Lang = struct {
continue;
}
}
const arg_opt = tok_it.next();
if (arg_opt == null) {
self.doError("Expected parameter for {s}, got nothing", .{cmd_field.name});
return;
}
const arg = arg_opt.?;
const argument_value = switch (cmd_field.type) {
const arg = tok_it.next().?;
const argument_value = switch (cmd_field.field_type) {
usize => try std.fmt.parseInt(usize, arg, 10),
i32 => try std.fmt.parseInt(i32, arg, 10),
f32 => try std.fmt.parseFloat(f32, arg),
[]const u8 => @as([]const u8, try self.allocator.dupe(u8, arg)),
[]u8 => try self.allocator.dupe(u8, arg),
[]const u8 => try self.allocator.dupe(u8, arg),
else => @compileError("Invalid parameter type (" ++ @typeName(cmd_field.field_type) ++ ") left on command struct " ++ @typeName(command_struct) ++ "."),
};
log.debug("parsing {s}, arg of type {s} => {any}", .{
std.debug.warn("parsing {}, arg of type {} => {}\n", .{
@typeName(command_struct),
@typeName(@TypeOf(argument_value)),
argument_value,
@ -634,13 +583,14 @@ pub const Lang = struct {
cmd.base.tag = command_struct.base_tag;
const command = cmd.base.cast(command_struct).?;
log.debug("cmd: {}", .{command});
std.debug.warn("cmd: {}\n", .{command});
try commands.append(&cmd.base);
}
pub fn parse(self: *Lang, data: []const u8) !CommandList {
var splitted_it = std.mem.split(u8, data, ";");
var splitted_it = std.mem.split(data, ";");
var cmds = CommandList.init(self.allocator);
errdefer cmds.deinit();
while (splitted_it.next()) |stmt_orig| {
self.line += 1;
@ -651,9 +601,9 @@ pub const Lang = struct {
if (std.mem.startsWith(u8, stmt, "#")) continue;
// TODO better tokenizer instead of just tokenize(" ")...maybe????
var tok_it = std.mem.splitSequence(u8, stmt, " ");
var tok_it = std.mem.tokenize(stmt, " ");
const cmd_opt = tok_it.next();
var cmd_opt = tok_it.next();
if (cmd_opt == null) {
self.doError("No command given", .{});
continue;
@ -663,51 +613,38 @@ pub const Lang = struct {
var found: bool = false;
inline for (@typeInfo(Command).Struct.decls) |cmd_struct_decl| {
switch (cmd_struct_decl.data) {
.Type => |typ| switch (@typeInfo(typ)) {
.Struct => {},
else => continue,
},
else => continue,
}
const struct_name = cmd_struct_decl.name;
const cmd_struct_type = @field(Command, struct_name);
const info_of_info = @typeInfo(@TypeOf(cmd_struct_type));
switch (info_of_info) {
.Type => {},
else => continue,
}
const info = @typeInfo(cmd_struct_type);
switch (info) {
.Struct => {},
else => continue,
}
comptime var lowered_command_name = [_]u8{0} ** struct_name.len;
var runtime_lowered_command_name = [_]u8{0} ** struct_name.len;
comptime {
for (struct_name, 0..) |c, i| {
for (struct_name) |c, i| {
lowered_command_name[i] = std.ascii.toLower(c);
}
}
const c_l = lowered_command_name;
std.mem.copyForwards(u8, &runtime_lowered_command_name, &c_l);
// if we have a match, we know the proper struct type
// to use. this actually works compared to storing command_struct
// in a variable because then that variable must be comptime.
// the drawback of this approach is that our emitted code is basically linear
// because we don't use the hashmap anymore.
//
// Attempting to use ComptimeHashMap hits compiler bugs and I'm
// not sure if we can map strings to *types* in it.
// because we don't use the hashmap anymore. maybe #5359 can help.
if ((!found) and std.mem.eql(u8, &runtime_lowered_command_name, command_string)) {
if (std.mem.eql(u8, &lowered_command_name, command_string)) {
found = true;
const cmd_struct_type = cmd_struct_decl.data.Type;
try self.parseCommandArguments(cmd_struct_type, &tok_it, &cmds);
}
}
if (!found) {
self.doError("Unknown command '{s}' ({d} bytes)", .{ command_string, command_string.len });
self.doError("Unknown command '{}' ({})", .{ command_string, command_string.len });
continue;
}
}
@ -719,18 +656,18 @@ pub const Lang = struct {
};
test "noop" {
var lang = Lang.init(std.testing.allocator);
var lang = Lang.init(std.heap.direct_allocator);
defer lang.deinit();
var cmds = try lang.parse("noop;");
defer cmds.deinit();
try std.testing.expectEqual(cmds.list.items.len, 1);
try std.testing.expectEqual(cmds.list.items[0].tag, .noop);
std.testing.expectEqual(cmds.len, 1);
std.testing.expectEqual(cmds.items[0].command, .Noop);
}
test "load, phaser, quicksave" {
var lang = Lang.init(std.testing.allocator);
var lang = Lang.init(std.heap.direct_allocator);
defer lang.deinit();
const prog =
@ -742,21 +679,8 @@ test "load, phaser, quicksave" {
var cmds = try lang.parse(prog);
defer cmds.deinit();
try std.testing.expectEqual(cmds.list.items.len, 3);
try std.testing.expectEqual(cmds.list.items[0].tag, .load);
try std.testing.expectEqual(cmds.list.items[1].tag, .phaser);
try std.testing.expectEqual(cmds.list.items[2].tag, .quicksave);
}
test "load, phaser with errors, quicksave" {
var lang = Lang.init(std.testing.allocator);
defer lang.deinit();
const prog =
\\load :0;
\\phaser 3 1 25;
\\quicksave;
;
try std.testing.expectError(error.ParseFail, lang.parse(prog));
std.testing.expectEqual(cmds.len, 3);
std.testing.expectEqual(cmds.items[0].command, .Load);
std.testing.expectEqual(cmds.items[1].command, .Phaser);
std.testing.expectEqual(cmds.items[2].command, .Quicksave);
}

42
src/lv2_helpers.zig
View file

@ -1,12 +1,10 @@
const std = @import("std");
const plugin = @import("plugin.zig");
const log = std.log.scoped(.scritcher_lv2);
pub const c = @cImport({
@cInclude("sndfile.h");
@cInclude("lilv/lilv.h");
@cInclude("lv2.h");
@cInclude("lv2/core/lv2.h");
});
pub fn Lv2Core(comptime ns: []const u8) []const u8 {
@ -23,7 +21,7 @@ const LV2_CORE__connectionOptional = Lv2Core("#connectionOptional");
pub fn lilv_instance_connect_port(
instance: [*c]c.LilvInstance,
port_index: u32,
data_location: ?*anyopaque,
data_location: ?*c_void,
) void {
instance.?.*.lv2_descriptor.?.*.connect_port.?(instance.?.*.lv2_handle, port_index, data_location);
}
@ -61,16 +59,14 @@ pub const Port = struct {
/// Setup ports for a given plugin. Gives an array to pointers of Port structs.
/// This setup is required so we link the plugin to the ports later on, and
/// also link our buffers, and control values.
///
/// Caller owns returned memory.
pub fn setupPorts(ctx: *plugin.Context) ![]Port {
const world = ctx.world;
var world = ctx.world;
const n_ports: u32 = c.lilv_plugin_get_num_ports(ctx.plugin);
var ports = try ctx.allocator.alloc(Port, n_ports);
for (ports, 0..) |_, idx| {
const port: *Port = &ports[idx];
for (ports) |_, idx| {
var port: *Port = &ports[idx];
port.* = Port{
.lilv_port = null,
.ptype = .Control,
@ -81,24 +77,24 @@ pub fn setupPorts(ctx: *plugin.Context) ![]Port {
};
}
const values: []f32 = try ctx.allocator.alloc(f32, n_ports);
var values: []f32 = try ctx.allocator.alloc(f32, n_ports);
defer ctx.allocator.free(values);
c.lilv_plugin_get_port_ranges_float(ctx.plugin, null, null, values.ptr);
const lv2_InputPort = c.lilv_new_uri(world, LV2_CORE__InputPort.ptr).?;
//defer std.heap.c_allocator.destroy(lv2_InputPort);
var lv2_InputPort = c.lilv_new_uri(world, LV2_CORE__InputPort.ptr);
defer std.heap.c_allocator.destroy(lv2_InputPort);
const lv2_OutputPort = c.lilv_new_uri(world, LV2_CORE__OutputPort.ptr).?;
//defer std.heap.c_allocator.destroy(lv2_OutputPort);
var lv2_OutputPort = c.lilv_new_uri(world, LV2_CORE__OutputPort.ptr);
defer std.heap.c_allocator.destroy(lv2_OutputPort);
const lv2_AudioPort = c.lilv_new_uri(world, LV2_CORE__AudioPort.ptr).?;
//defer std.heap.c_allocator.destroy(lv2_AudioPort);
var lv2_AudioPort = c.lilv_new_uri(world, LV2_CORE__AudioPort.ptr);
defer std.heap.c_allocator.destroy(lv2_AudioPort);
const lv2_ControlPort = c.lilv_new_uri(world, LV2_CORE__ControlPort.ptr).?;
//defer std.heap.c_allocator.destroy(lv2_ControlPort);
var lv2_ControlPort = c.lilv_new_uri(world, LV2_CORE__ControlPort.ptr);
defer std.heap.c_allocator.destroy(lv2_ControlPort);
const lv2_connection_string = c.lilv_new_uri(world, LV2_CORE__connectionOptional.ptr).?;
//defer std.heap.c_allocator.destroy(lv2_connection_string);
var lv2_connectionOptional = c.lilv_new_uri(world, LV2_CORE__connectionOptional.ptr);
defer std.heap.c_allocator.destroy(lv2_connectionOptional);
var i: u32 = 0;
while (i < n_ports) : (i += 1) {
@ -115,12 +111,12 @@ pub fn setupPorts(ctx: *plugin.Context) ![]Port {
port.value = values[i];
}
port.optional = c.lilv_port_has_property(ctx.plugin, lport, lv2_connection_string);
port.optional = c.lilv_port_has_property(ctx.plugin, lport, lv2_connectionOptional);
if (c.lilv_port_is_a(ctx.plugin, lport, lv2_InputPort)) {
port.is_input = true;
} else if (!c.lilv_port_is_a(ctx.plugin, lport, lv2_OutputPort) and !port.optional) {
log.debug("Port {d} is neither input or output", .{i});
std.debug.warn("Port {} is neither input or output\n", .{i});
return error.UnassignedIOPort;
}
@ -136,7 +132,7 @@ pub fn setupPorts(ctx: *plugin.Context) ![]Port {
ctx.n_audio_out += 1;
}
} else if (!port.optional) {
log.debug("Port {d} has unsupported type", .{i});
std.debug.warn("Port {} has unsupported type\n", .{i});
return error.UnsupportedPortType;
}
}

18
src/magick.zig
View file

@ -2,7 +2,6 @@
const std = @import("std");
const images = @import("image.zig");
const log = std.log.scoped(.scritcher_magick);
const Image = images.Image;
const mc = @cImport({
@ -15,7 +14,7 @@ pub const MagickContext = struct {
pub fn init() !MagickContext {
mc.InitializeMagick(null);
const wand = mc.NewMagickWand();
var wand = mc.NewMagickWand();
if (wand == null) return error.WandCreateFail;
return MagickContext{
@ -29,7 +28,6 @@ pub const MagickContext = struct {
}
pub fn doErr(self: *MagickContext) !void {
_ = self;
return error.WandError;
}
};
@ -38,10 +36,10 @@ fn magickLoad(image: *Image) !MagickContext {
var mctx = try MagickContext.init();
errdefer mctx.deinit();
const curpath = try image.allocator.dupeZ(u8, image.curpath);
var curpath = try std.cstr.addNullByte(image.allocator, image.curpath);
defer image.allocator.free(curpath);
log.debug("loading '{s}'", .{curpath});
std.debug.warn("loading '{}'\n", .{curpath});
if (mc.MagickReadImage(mctx.wand, curpath.ptr) != 1)
return error.MagickReadFail;
@ -52,16 +50,16 @@ fn magickLoad(image: *Image) !MagickContext {
fn magickSave(image: *Image, wand: *mc.MagickWand) !void {
const allocator = image.allocator;
const tmpnam = try images.temporaryName(allocator);
const c_tmpnam = try allocator.dupeZ(u8, tmpnam);
var tmpnam = try images.temporaryName(allocator);
var c_tmpnam = try std.cstr.addNullByte(allocator, tmpnam);
defer allocator.free(c_tmpnam);
log.debug("\tmagick: saving to '{s}'..", .{c_tmpnam});
std.debug.warn("\tmagick: saving to '{}'..", .{c_tmpnam});
if (mc.MagickWriteImage(wand, c_tmpnam.ptr) != 1)
return error.MagickWriteFail;
log.debug("OK", .{});
std.debug.warn("OK\n", .{});
try image.reopen(tmpnam);
}
@ -72,7 +70,7 @@ pub fn runRotate(image: *Image, deg: f32, bgfill: []const u8) !void {
var mctx = try magickLoad(image);
defer mctx.deinit();
const bg = mc.NewPixelWand();
var bg = mc.NewPixelWand();
defer mc.DestroyPixelWand(bg);
if (mc.PixelSetColor(bg, bgfill.ptr) != 1)

113
src/main.zig
View file

@ -3,8 +3,6 @@ const langs = @import("lang.zig");
const runners = @import("runner.zig");
const printer = @import("printer.zig");
const log = std.log.scoped(.scritcher);
test "scritcher" {
_ = @import("lang.zig");
_ = @import("runner.zig");
@ -18,30 +16,30 @@ const readline = @cImport({
@cInclude("readline/history.h");
});
fn wrapInCmdList(allocator: std.mem.Allocator, cmd: *langs.Command) !langs.CommandList {
fn wrapInCmdList(allocator: *std.mem.Allocator, cmd: *langs.Command) !langs.CommandList {
var cmds = langs.CommandList.init(allocator);
try cmds.append(cmd);
return cmds;
}
fn copyCommandToHeap(allocator: std.mem.Allocator, command: langs.Command, comptime tag: langs.Command.Tag) !*langs.Command {
fn copyCommandToHeap(allocator: *std.mem.Allocator, command: langs.Command, comptime tag: langs.Command.Tag) !*langs.Command {
const CommandStruct = langs.Command.tagToType(tag);
const casted = command.cast(CommandStruct).?;
var heap_cmd = try allocator.create(CommandStruct);
heap_cmd.* = casted.*;
log.debug("casted: {}", .{casted});
log.debug("heap_cmd: {}", .{heap_cmd});
@memcpy(
@ptrCast([*]u8, &heap_cmd),
@ptrCast([*]const u8, &casted),
@sizeOf(CommandStruct),
);
return &heap_cmd.base;
}
pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
pub fn doRepl(allocator: *std.mem.Allocator, args_it: var) !void {
var stdout_file = std.io.getStdOut();
const stdout = &stdout_file.writer();
const scri_path = (args_it.next() orelse @panic("expected scri path"));
errdefer allocator.free(scri_path);
defer allocator.free(scri_path);
const stdout = &stdout_file.outStream();
const scri_path = try (args_it.next(allocator) orelse @panic("expected scri path"));
var file_read_opt: ?std.fs.File = std.fs.cwd().openFile(scri_path, .{}) catch |err| blk: {
if (err == error.FileNotFound) break :blk null;
@ -56,18 +54,18 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
defer lang.deinit();
if (total_bytes > 0) {
const scri_existing = try allocator.alloc(u8, total_bytes);
// this MUST BE long lived (a reference to it is kept inside
// existing_cmds, and then passed along to cmds),
// we can't defer them here
var scri_existing = try allocator.alloc(u8, total_bytes);
_ = try file_read_opt.?.read(scri_existing);
defer allocator.free(scri_existing);
// we can't defer this directly because we copy the
// Command pointers to the cmds list. running deinit() directly
// would cause those pointers to be freed.
// we can defer this because we copy the Command structs back to cmds
var existing_cmds = try lang.parse(scri_existing);
defer existing_cmds.list.deinit();
defer existing_cmds.deinit();
// copy the existing command list into the repl's command list
for (existing_cmds.list.items) |existing_cmd| {
for (existing_cmds.items) |existing_cmd| {
try cmds.append(existing_cmd);
}
} else {
@ -77,7 +75,7 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
// TODO: deliberate memleak here. we only allocate this
// command once, for the start of the file, so.
var load_cmd = try allocator.create(langs.Command.Load);
load_cmd.path = ":0";
std.mem.copy(u8, load_cmd.path, ":0");
load_cmd.base.tag = langs.Command.Tag.load;
// taking address is fine, because load_cmd lives in the lifetime
@ -89,14 +87,14 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
file_read.close();
}
var file = try std.fs.cwd().createFile(scri_path, .{
var file = try std.fs.cwd().openFile(scri_path, .{
.write = true,
.read = false,
.truncate = true,
});
defer file.close();
var out = file.writer();
const stream = &out;
var out = file.outStream();
var stream = &out;
// since we opened the file for writing, it becomes empty, so, to ensure
// we don't fuck up later on, we print cmds before starting the repl
@ -120,7 +118,7 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
// run the load command
try runner.runCommands(cmds, true);
const wanted_runner: []const u8 = std.posix.getenv("SCRITCHER_RUNNER") orelse "ristretto";
const wanted_runner: []const u8 = std.os.getenv("SCRITCHER_RUNNER") orelse "ristretto";
var runqs_cmd = langs.Command.RunQS{
.base = langs.Command{ .tag = langs.Command.Tag.runqs },
@ -132,13 +130,13 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
var rd_line = readline.readline("> ");
if (rd_line == null) {
log.debug("leaving from eof", .{});
std.debug.warn("leaving from eof\n", .{});
break;
}
readline.add_history(rd_line);
//defer std.heap.c_allocator.destroy(rd_line);
const line = rd_line[0..std.mem.len(rd_line)];
var line = rd_line[0..std.mem.len(rd_line)];
if (std.mem.eql(u8, line, "push")) {
const heap_cmd = switch (current.tag) {
@ -200,20 +198,21 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
try printer.printList(cmds, stream);
continue;
} else if (std.mem.eql(u8, line, "quit") or std.mem.eql(u8, line, "q")) {
log.debug("leaving", .{});
std.debug.warn("leaving\n", .{});
break;
} else if (std.mem.startsWith(u8, line, "#")) {
continue;
}
var cmds_parsed = lang.parse(line) catch |err| {
log.debug("repl: error while parsing: {}", .{err});
std.debug.warn("repl: error while parsing: {}\n", .{err});
continue;
};
// no command? ignore!
if (cmds_parsed.list.items.len == 0) continue;
current = cmds_parsed.list.items[0].*;
if (cmds_parsed.items.len == 0) continue;
current = cmds_parsed.items[0].*;
// by cloning the parent runner, we can iteratively write
// whatever command we want and only commit the good results
@ -230,21 +229,25 @@ pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void {
}
}
fn doHelp() void {
log.debug("scritcher!", .{});
log.debug("usage: scritcher [run|help|repl]", .{});
log.debug("\tscritcher run path_to_script.scri path_to_input_file.bmp", .{});
log.debug("\tscritcher repl path_to_script.scri path_to_input_file.bmp", .{});
}
pub fn main() !void {
const allocator = std.heap.page_allocator;
fn doRun(allocator: std.mem.Allocator, args_it: anytype) !void {
var lang = langs.Lang.init(allocator);
defer lang.deinit();
var runner = runners.Runner.init(allocator, false);
defer runner.deinit();
const scri_path = (args_it.next() orelse @panic("run: expected scri path"));
var args_it = std.process.args();
// TODO print help
_ = try (args_it.next(allocator) orelse @panic("expected exe name"));
const scri_path = try (args_it.next(allocator) orelse @panic("expected scri path or 'repl'"));
if (std.mem.eql(u8, scri_path, "repl")) {
return try doRepl(allocator, &args_it);
}
var file = try std.fs.cwd().openFile(scri_path, .{});
defer file.close();
@ -252,7 +255,7 @@ fn doRun(allocator: std.mem.Allocator, args_it: anytype) !void {
// sadly, we read it all into memory. such is life
const total_bytes = try file.getEndPos();
const data = try allocator.alloc(u8, total_bytes);
var data = try allocator.alloc(u8, total_bytes);
defer allocator.free(data);
_ = try file.read(data);
@ -261,33 +264,3 @@ fn doRun(allocator: std.mem.Allocator, args_it: anytype) !void {
try runner.runCommands(cmds, true);
}
pub fn main() !void {
var allocator_instance = std.heap.GeneralPurposeAllocator(.{}){};
defer {
_ = allocator_instance.deinit();
}
const allocator = allocator_instance.allocator();
var args_it = try std.process.argsWithAllocator(allocator);
defer args_it.deinit();
_ = args_it.skip();
const cli_command_opt = args_it.next();
if (cli_command_opt == null) {
return doHelp();
}
const cli_command = cli_command_opt.?;
if (std.mem.eql(u8, cli_command, "help")) {
return doHelp();
} else if (std.mem.eql(u8, cli_command, "repl")) {
return try doRepl(allocator, &args_it);
} else if (std.mem.eql(u8, cli_command, "run")) {
return try doRun(allocator, &args_it);
} else {
log.debug("unknown command: '{s}'", .{cli_command});
return error.UnknownCommand;
}
}

35
src/plugin.zig
View file

@ -3,7 +3,6 @@ const std = @import("std");
const lv2 = @import("lv2_helpers.zig");
const c = lv2.c;
const log = std.log.scoped(.scritcher_plugin);
const ImageError = @import("image.zig").ImageError;
/// Control port
@ -36,7 +35,7 @@ pub const Position = struct {
pub fn seekPos(self: Position, total_size: usize) SeekPos {
std.debug.assert(self.index <= self.split);
const tot = total_size / self.split;
var tot = total_size / self.split;
return SeekPos{
.start = self.index * tot,
@ -47,7 +46,7 @@ pub const Position = struct {
/// Represents the starting context for a single plugin run.
pub const Context = struct {
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
world: *c.LilvWorld,
plugin: *const c.LilvPlugin,
@ -75,12 +74,10 @@ pub const RunContext = struct {
instance: *c.LilvInstance,
pub fn init(
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
plugin: *const c.LilvPlugin,
) !RunContext {
_ = allocator; // TODO batch RunBuffers?
const instance = c.lilv_plugin_instantiate(plugin, @as(f64, 44100), null);
var instance = c.lilv_plugin_instantiate(plugin, @as(f64, 44100), null);
errdefer c.lilv_instance_free(instance);
if (instance == null) {
@ -101,13 +98,13 @@ pub const RunContext = struct {
var i: usize = 0;
var o: usize = 0;
for (ports, 0..) |_, p_idx| {
const p = @as(u32, @intCast(p_idx));
for (ports) |_, p_idx| {
var p = @intCast(u32, p_idx);
var port: *lv2.Port = &ports[p_idx];
switch (port.ptype) {
.Control => lv2.lilv_instance_connect_port(self.instance, p, &port.value),
.Audio => {
.Audio => blk: {
if (port.is_input) {
lv2.lilv_instance_connect_port(
self.instance,
@ -124,31 +121,31 @@ pub const RunContext = struct {
o += 1;
}
},
// else => lv2.lilv_instance_connect_port(self.instance, p, null),
else => lv2.lilv_instance_connect_port(self.instance, p, null),
}
}
}
};
pub fn makeContext(allocator: std.mem.Allocator, plugin_uri: []const u8) !Context {
const cstr_plugin_uri = try allocator.dupeZ(u8, plugin_uri);
pub fn makeContext(allocator: *std.mem.Allocator, plugin_uri: []const u8) !Context {
const cstr_plugin_uri = try std.cstr.addNullByte(allocator, plugin_uri);
defer allocator.free(cstr_plugin_uri);
const world: *c.LilvWorld = c.lilv_world_new().?;
var world: *c.LilvWorld = c.lilv_world_new().?;
errdefer c.lilv_world_free(world);
c.lilv_world_load_all(world);
const uri: *c.LilvNode = c.lilv_new_uri(world, cstr_plugin_uri.ptr) orelse {
log.debug("Invalid plugin URI <{s}>", .{plugin_uri});
var uri: *c.LilvNode = c.lilv_new_uri(world, cstr_plugin_uri.ptr) orelse blk: {
std.debug.warn("Invalid plugin URI <{}>\n", .{plugin_uri});
return ImageError.InvalidPlugin;
};
defer c.lilv_node_free(uri);
const plugins: *const c.LilvPlugins = c.lilv_world_get_all_plugins(world).?;
const plugins: *const c.LilvPlugins = c.lilv_world_get_all_plugins(world);
const plugin: *const c.LilvPlugin = c.lilv_plugins_get_by_uri(plugins, uri) orelse {
log.debug("Plugin <{s}> not found", .{plugin_uri});
var plugin: *const c.LilvPlugin = c.lilv_plugins_get_by_uri(plugins, uri) orelse blk: {
std.debug.warn("Plugin <{}> not found\n", .{plugin_uri});
return ImageError.UnknownPlugin;
};

33
src/printer.zig
View file

@ -1,51 +1,54 @@
const std = @import("std");
const langs = @import("lang.zig");
const log = std.log.scoped(.scritcher_printer);
fn printCommandWithParams(stream: anytype, command: anytype) !void {
fn printCommandWithParams(stream: var, command: var) !void {
const Parameters = @TypeOf(command.parameters);
try stream.print(" {d} {d}", .{ command.split, command.index });
try stream.print(" {} {}", .{ command.split, command.index });
inline for (@typeInfo(Parameters).Struct.fields) |field| {
if (field.type == f32 or field.type == f64) {
try stream.print(" {}", .{@field(command.parameters, field.name)});
} else if (field.type == usize or field.type == u64) {
if (field.field_type == f32 or field.field_type == f64) {
try stream.print(" {d}", .{@field(command.parameters, field.name)});
} else {
try stream.print(" {s}", .{@field(command.parameters, field.name)});
try stream.print(" {}", .{@field(command.parameters, field.name)});
}
}
}
fn printCommand(stream: anytype, cmd: *langs.Command, comptime tag: langs.Command.Tag) !void {
fn printCommand(stream: var, cmd: *langs.Command, comptime tag: langs.Command.Tag) !void {
const CommandStruct = langs.Command.tagToType(tag);
const casted = cmd.cast(CommandStruct).?;
// TODO move this to Tag method?
const is_typed = switch (tag) {
.noop, .load, .quicksave, .runqs, .rotate => false,
else => true,
};
const ctype = CommandStruct.command_type;
switch (ctype) {
.lv2_command => try printCommandWithParams(stream, casted),
.custom_command => try printCommandWithParams(stream, casted),
else => @panic("TODO support command type"),
}
}
pub fn printList(list: langs.CommandList, stream: anytype) !void {
for (list.list.items) |cmd| {
pub fn printList(list: langs.CommandList, stream: var) !void {
for (list.items) |cmd| {
const command = @tagName(cmd.tag);
try stream.print("{s}", .{command});
try stream.print("{}", .{command});
switch (cmd.tag) {
.load => {
const load = cmd.cast(langs.Command.Load).?;
try stream.print(" {s}", .{load.path});
try stream.print(" {}", .{load.path});
},
.runqs => {
const runqs = cmd.cast(langs.Command.RunQS).?;
try stream.print(" {s}", .{runqs.program});
try stream.print(" {}", .{runqs.program});
},
.noop, .quicksave => {},
.rotate => {
const rotate = cmd.cast(langs.Command.Rotate).?;
try stream.print(" {d} {s}", .{ rotate.deg, rotate.bgfill });
try stream.print(" {d} {}", .{ rotate.deg, rotate.bgfill });
},
.amp => try printCommand(stream, cmd, .amp),

91
src/runner.zig
View file

@ -5,8 +5,6 @@ const plugin = @import("plugin.zig");
const custom = @import("custom.zig");
const magick = @import("magick.zig");
const log = std.log.scoped(.scritcher_runner);
const Position = plugin.Position;
const ParamList = plugin.ParamList;
const ParamMap = plugin.ParamMap;
@ -20,7 +18,7 @@ pub const RunError = error{
};
pub const Runner = struct {
allocator: std.mem.Allocator,
allocator: *std.mem.Allocator,
/// The currently opened image in the runner
image: ?*Image = null,
@ -28,9 +26,9 @@ pub const Runner = struct {
/// If the runner is in REPL mode
repl: bool,
args: []const [:0]u8,
args: [][]u8,
pub fn init(allocator: std.mem.Allocator, repl: bool) Runner {
pub fn init(allocator: *std.mem.Allocator, repl: bool) Runner {
return Runner{
.allocator = allocator,
.repl = repl,
@ -42,12 +40,10 @@ pub const Runner = struct {
if (self.image) |image| {
image.close();
}
std.process.argsFree(self.allocator, self.args);
}
pub fn clone(self: *Runner) !Runner {
const cloned_image = if (self.image) |image| try image.clone() else null;
var cloned_image = if (self.image) |image| try image.clone() else null;
return Runner{
.allocator = self.allocator,
.image = cloned_image,
@ -57,7 +53,6 @@ pub const Runner = struct {
}
fn resolveArg(self: *Runner, load_path: []const u8) ![]const u8 {
std.debug.assert(load_path.len > 0);
if (load_path[0] == ':') {
// parse the index from 1 to end
var index = try std.fmt.parseInt(usize, load_path[1..], 10);
@ -68,20 +63,19 @@ pub const Runner = struct {
// 'scritcher repl ./script ./image'
// ':0' should ALWAYS point to the image.
if (self.repl) index += 3 else index += 3;
if (self.repl) index += 3 else index += 2;
for (self.args, 0..) |arg, idx| {
log.debug("arg{d} = {s}", .{ idx, arg });
std.debug.warn("ARGS!! {} \n", .{self.args.len});
for (self.args) |arg, idx| {
std.debug.warn("arg{} = {}\n", .{ idx, arg });
}
log.debug("fetch arg idx={d}", .{index});
log.debug("fetch arg val={s}", .{self.args[index]});
std.debug.warn("fetch arg idx={}, val={}\n", .{ index, self.args[index] });
return self.args[index];
} else {
return load_path;
}
}
// Caller owns returned memory.
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(
@ -93,8 +87,8 @@ pub const Runner = struct {
}
fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void {
const load_path = try self.resolveArgPath(path_or_argidx);
log.debug("\tload path: {s}", .{load_path});
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.
@ -104,14 +98,13 @@ pub const Runner = struct {
// 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")) {
log.debug("Only BMP files are allowed to be loaded. Got path '{s}'", .{load_path});
std.debug.warn("Only BMP files are allowed to be loaded. Got path '{}'\n", .{load_path});
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.
if (self.image) |image| image.close();
self.image = try Image.open(self.allocator, load_path);
}
@ -119,16 +112,15 @@ pub const Runner = struct {
if (self.image) |image| {
return image;
} else {
log.debug("image is required!", .{});
std.debug.warn("image is required!\n", .{});
return RunError.ImageRequired;
}
}
/// Caller owns returned memory.
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.
const image = try self.getImage();
var image = try self.getImage();
const basename = std.fs.path.basename(image.path);
const dirname = std.fs.path.dirname(image.path).?;
@ -141,7 +133,7 @@ pub const Runner = struct {
// 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, "{s}_g", .{
const starts_with = try std.fmt.allocPrint(self.allocator, "{}_g", .{
basename[0..period_idx],
});
defer self.allocator.free(starts_with);
@ -152,7 +144,7 @@ pub const Runner = struct {
while (try it.next()) |entry| {
switch (entry.kind) {
.file => blk: {
.File => blk: {
if (!std.mem.startsWith(u8, entry.name, starts_with)) break :blk {};
// we want to get the N in x_gN.ext
@ -166,8 +158,6 @@ pub const Runner = struct {
// 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| {
log.debug("ignoring file {s}", .{@errorName(err)});
break :blk {};
};
@ -177,7 +167,7 @@ pub const Runner = struct {
}
}
const out_path = try std.fmt.allocPrint(self.allocator, "{s}/{s}{d}{s}", .{
const out_path = try std.fmt.allocPrint(self.allocator, "{}/{}{}{}", .{
dirname,
starts_with,
max + 1,
@ -190,38 +180,36 @@ pub const Runner = struct {
fn quicksaveCmd(self: *Runner) !void {
var image = try self.getImage();
const out_path = try self.makeGlitchedPath();
defer self.allocator.free(out_path);
try image.saveTo(out_path);
}
fn runQSCmd(self: *Runner, cmd: *lang.Command) !void {
fn runQSCmd(self: *Runner, cmd: lang.Command) !void {
const runqs = cmd.cast(lang.Command.RunQS).?;
var image = try self.getImage();
const out_path = try self.makeGlitchedPath();
defer self.allocator.free(out_path);
try image.saveTo(out_path);
var proc = std.ChildProcess.init(
var proc = try std.ChildProcess.init(
&[_][]const u8{ runqs.program, out_path },
self.allocator,
);
//defer proc.deinit();
defer proc.deinit();
log.debug("running '{s} {s}'", .{ runqs.program, out_path });
std.debug.warn("running '{} {}'\n", .{ runqs.program, out_path });
_ = try proc.spawnAndWait();
}
fn rotateCmd(self: *Runner, cmd: *lang.Command) !void {
fn rotateCmd(self: *Runner, cmd: lang.Command) !void {
const rotate_cmd = cmd.cast(lang.Command.Rotate).?;
const image = try self.getImage();
const c_bgfill = try self.allocator.dupeZ(u8, rotate_cmd.bgfill);
var image = try self.getImage();
var c_bgfill = try std.cstr.addNullByte(self.allocator, rotate_cmd.bgfill);
defer self.allocator.free(c_bgfill);
try magick.runRotate(image, rotate_cmd.deg, c_bgfill);
}
fn executeLV2Command(self: *@This(), command: anytype) !void {
fn executeLV2Command(self: *@This(), command: var) !void {
const pos = plugin.Position{
.split = command.split,
.index = command.index,
@ -243,7 +231,7 @@ pub const Runner = struct {
try image.runPlugin(typ.lv2_url, pos, params);
}
fn executeCustomCommand(self: *@This(), command: anytype) !void {
fn executeCustomCommand(self: *@This(), command: var) !void {
const pos = plugin.Position{
.split = command.split,
.index = command.index,
@ -255,19 +243,20 @@ pub const Runner = struct {
fn runSingleCommand(
self: *@This(),
cmd: *lang.Command,
cmd: lang.Command,
comptime tag: lang.Command.Tag,
) !void {
const typ = lang.Command.tagToType(tag);
comptime const typ = lang.Command.tagToType(tag);
const command = cmd.cast(typ).?;
const ctype = typ.command_type;
switch (ctype) {
.lv2_command => try self.executeLV2Command(command.*),
.custom_command => try self.executeCustomCommand(command.*),
else => @panic("TODO support command type"),
}
}
fn runCommand(self: *@This(), cmd: *lang.Command) !void {
fn runCommand(self: *@This(), cmd: lang.Command) !void {
switch (cmd.tag) {
.noop => {},
.load => {
@ -319,26 +308,26 @@ pub const Runner = struct {
cmds: lang.CommandList,
debug_flag: bool,
) !void {
_ = debug_flag;
for (cmds.list.items) |cmd| {
for (cmds.items) |cmd| {
cmd.print();
try self.runCommand(cmd);
try self.runCommand(cmd.*);
}
}
};
test "running noop" {
const allocator = std.testing.allocator;
const allocator = std.heap.direct_allocator;
var cmds = lang.CommandList.init(allocator);
defer cmds.deinit();
const command = lang.Command{ .tag = .noop };
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 noop = try allocator.create(lang.Command.Noop);
noop.* = lang.Command.Noop{ .base = command };
try cmds.append(&noop.base);
var runner = Runner.init(allocator, false);
var runner = Runner.init(allocator);
defer runner.deinit();
try runner.runCommands(cmds, false);