141 lines
4.5 KiB
Zig
141 lines
4.5 KiB
Zig
const std = @import("std");
|
|
const plugin = @import("plugin.zig");
|
|
|
|
pub const c = @cImport({
|
|
@cInclude("sndfile.h");
|
|
@cInclude("lilv/lilv.h");
|
|
@cInclude("lv2/core/lv2.h");
|
|
});
|
|
|
|
pub fn Lv2Core(comptime ns: []const u8) []const u8 {
|
|
const LV2_CORE_URI = "http://lv2plug.in/ns/lv2core";
|
|
return LV2_CORE_URI ++ ns ++ [_]u8{0};
|
|
}
|
|
|
|
const LV2_CORE__InputPort = Lv2Core("#InputPort");
|
|
const LV2_CORE__OutputPort = Lv2Core("#OutputPort");
|
|
const LV2_CORE__AudioPort = Lv2Core("#AudioPort");
|
|
const LV2_CORE__ControlPort = Lv2Core("#ControlPort");
|
|
const LV2_CORE__connectionOptional = Lv2Core("#connectionOptional");
|
|
|
|
pub fn lilv_instance_connect_port(
|
|
instance: [*c]c.LilvInstance,
|
|
port_index: u32,
|
|
data_location: ?*c_void,
|
|
) void {
|
|
instance.?.*.lv2_descriptor.?.*.connect_port.?(instance.?.*.lv2_handle, port_index, data_location);
|
|
}
|
|
|
|
pub fn lilv_instance_activate(instance: [*c]c.LilvInstance) void {
|
|
if (instance.?.*.lv2_descriptor.?.*.activate != null) {
|
|
instance.?.*.lv2_descriptor.?.*.activate.?(instance.?.*.lv2_handle);
|
|
}
|
|
}
|
|
|
|
pub fn lilv_instance_run(instance: [*c]c.LilvInstance, sample_count: u32) void {
|
|
instance.?.*.lv2_descriptor.?.*.run.?(instance.?.*.lv2_handle, sample_count);
|
|
}
|
|
|
|
pub fn lilv_instance_deactivate(instance: [*c]c.LilvInstance) void {
|
|
if (instance.?.*.lv2_descriptor.?.*.deactivate != null) {
|
|
instance.?.*.lv2_descriptor.?.*.deactivate.?(instance.?.*.lv2_handle);
|
|
}
|
|
}
|
|
|
|
pub const PortType = enum {
|
|
Control,
|
|
Audio,
|
|
};
|
|
|
|
pub const Port = struct {
|
|
lilv_port: ?*const c.LilvPort,
|
|
ptype: PortType,
|
|
index: u32,
|
|
value: f32,
|
|
is_input: bool,
|
|
optional: bool,
|
|
};
|
|
|
|
/// 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.
|
|
pub fn setupPorts(ctx: *plugin.Context) ![]Port {
|
|
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) |_, idx| {
|
|
var port: *Port = &ports[idx];
|
|
port.* = Port{
|
|
.lilv_port = null,
|
|
.ptype = .Control,
|
|
.index = @as(f32, 0),
|
|
.value = @as(f32, 0),
|
|
.is_input = false,
|
|
.optional = false,
|
|
};
|
|
}
|
|
|
|
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);
|
|
var lv2_InputPort = c.lilv_new_uri(world, LV2_CORE__InputPort.ptr);
|
|
defer std.heap.c_allocator.destroy(lv2_InputPort);
|
|
|
|
var lv2_OutputPort = c.lilv_new_uri(world, LV2_CORE__OutputPort.ptr);
|
|
defer std.heap.c_allocator.destroy(lv2_OutputPort);
|
|
|
|
var lv2_AudioPort = c.lilv_new_uri(world, LV2_CORE__AudioPort.ptr);
|
|
defer std.heap.c_allocator.destroy(lv2_AudioPort);
|
|
|
|
var lv2_ControlPort = c.lilv_new_uri(world, LV2_CORE__ControlPort.ptr);
|
|
defer std.heap.c_allocator.destroy(lv2_ControlPort);
|
|
|
|
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) {
|
|
var port: *Port = &ports[i];
|
|
|
|
const lport = c.lilv_plugin_get_port_by_index(ctx.plugin, i).?;
|
|
|
|
port.lilv_port = lport;
|
|
port.index = i;
|
|
|
|
if (std.math.isNan(values[i])) {
|
|
port.value = @as(f32, 0);
|
|
} else {
|
|
port.value = values[i];
|
|
}
|
|
|
|
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) {
|
|
std.debug.warn("Port {} is neither input or output\n", i);
|
|
return error.UnassignedIOPort;
|
|
}
|
|
|
|
// check if port is an audio or control port
|
|
if (c.lilv_port_is_a(ctx.plugin, lport, lv2_ControlPort)) {
|
|
port.ptype = .Control;
|
|
} else if (c.lilv_port_is_a(ctx.plugin, lport, lv2_AudioPort)) {
|
|
port.ptype = .Audio;
|
|
|
|
if (port.is_input) {
|
|
ctx.n_audio_in += 1;
|
|
} else {
|
|
ctx.n_audio_out += 1;
|
|
}
|
|
} else if (!port.optional) {
|
|
std.debug.warn("Port {} has unsupported type\n", i);
|
|
return error.UnsupportedPortType;
|
|
}
|
|
}
|
|
|
|
return ports;
|
|
}
|