diff options
Diffstat (limited to 'src/jalv.c')
| -rw-r--r-- | src/jalv.c | 2134 |
1 files changed, 925 insertions, 1209 deletions
@@ -1,264 +1,180 @@ -/* - Copyright 2007-2016 David Robillard <http://drobilla.net> - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ +// Copyright 2007-2024 David Robillard <d@drobilla.net> +// SPDX-License-Identifier: ISC -#define _POSIX_C_SOURCE 200809L /* for mkdtemp */ -#define _DARWIN_C_SOURCE /* for mkdtemp on OSX */ +#include "jalv.h" +#include "backend.h" +#include "comm.h" +#include "control.h" +#include "dumper.h" +#include "features.h" +#include "frontend.h" #include "jalv_config.h" -#include "jalv_internal.h" -#include "lv2_evbuf.h" +#include "log.h" +#include "macros.h" +#include "mapper.h" +#include "nodes.h" +#include "options.h" +#include "port.h" +#include "process.h" +#include "process_setup.h" +#include "settings.h" +#include "state.h" +#include "string_utils.h" +#include "types.h" +#include "urids.h" #include "worker.h" -#include "lv2/atom/atom.h" -#include "lv2/buf-size/buf-size.h" -#include "lv2/data-access/data-access.h" -#include "lv2/options/options.h" -#include "lv2/parameters/parameters.h" -#include "lv2/patch/patch.h" -#include "lv2/port-groups/port-groups.h" -#include "lv2/port-props/port-props.h" -#include "lv2/presets/presets.h" -#include "lv2/state/state.h" -#include "lv2/time/time.h" -#include "lv2/ui/ui.h" -#include "lv2/urid/urid.h" -#include "lv2/worker/worker.h" - -#include "lilv/lilv.h" - -#ifdef HAVE_SUIL -#include "suil/suil.h" -#endif - -#ifdef _WIN32 -# include <io.h> /* for _mktemp */ -# define snprintf _snprintf -#else -# include <unistd.h> +#include <lilv/lilv.h> +#include <lv2/atom/atom.h> +#include <lv2/atom/forge.h> +#include <lv2/atom/util.h> +#include <lv2/buf-size/buf-size.h> +#include <lv2/core/lv2.h> +#include <lv2/data-access/data-access.h> +#include <lv2/instance-access/instance-access.h> +#include <lv2/log/log.h> +#include <lv2/patch/patch.h> +#include <lv2/state/state.h> +#include <lv2/ui/ui.h> +#include <lv2/urid/urid.h> +#include <lv2/worker/worker.h> +#include <zix/allocator.h> +#include <zix/filesystem.h> +#include <zix/path.h> +#include <zix/ring.h> +#include <zix/sem.h> +#include <zix/status.h> + +#if USE_SUIL +# include <suil/suil.h> #endif -#include <assert.h> -#include <math.h> -#include <signal.h> +#include <stdbool.h> +#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> -#include <sys/stat.h> -#include <sys/types.h> - -#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" -#define NS_XSD "http://www.w3.org/2001/XMLSchema#" - -#ifndef MIN -# define MIN(a, b) (((a) < (b)) ? (a) : (b)) -#endif -#ifndef MAX -# define MAX(a, b) (((a) > (b)) ? (a) : (b)) -#endif - -#ifndef ARRAY_SIZE -# define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) -#endif +/** + Size factor for UI ring buffers. -/* Size factor for UI ring buffers. The ring size is a few times the size of - an event output to give the UI a chance to keep up. Experiments with Ingen, - which can highly saturate its event output, led me to this value. It - really ought to be enough for anybody(TM). + The ring size is a few times the size of an event output to give the UI a + chance to keep up. Experiments with Ingen, which can highly saturate its + event output, led me to this value. It really ought to be enough for + anybody(TM). */ #define N_BUFFER_CYCLES 16 -static ZixSem* exit_sem = NULL; /**< Exit semaphore used by signal handler*/ - -static LV2_URID -map_uri(LV2_URID_Map_Handle handle, - const char* uri) -{ - Jalv* jalv = (Jalv*)handle; - zix_sem_wait(&jalv->symap_lock); - const LV2_URID id = symap_map(jalv->symap, uri); - zix_sem_post(&jalv->symap_lock); - return id; -} - -static const char* -unmap_uri(LV2_URID_Unmap_Handle handle, - LV2_URID urid) -{ - Jalv* jalv = (Jalv*)handle; - zix_sem_wait(&jalv->symap_lock); - const char* uri = symap_unmap(jalv->symap, urid); - zix_sem_post(&jalv->symap_lock); - return uri; -} - -#define NS_EXT "http://lv2plug.in/ns/ext/" - -/** These features have no data */ +/// These features have no data static const LV2_Feature static_features[] = { - { LV2_STATE__loadDefaultState, NULL }, - { LV2_BUF_SIZE__powerOf2BlockLength, NULL }, - { LV2_BUF_SIZE__fixedBlockLength, NULL }, - { LV2_BUF_SIZE__boundedBlockLength, NULL } }; + {LV2_STATE__loadDefaultState, NULL}, + {LV2_BUF_SIZE__powerOf2BlockLength, NULL}, + {LV2_BUF_SIZE__fixedBlockLength, NULL}, + {LV2_BUF_SIZE__boundedBlockLength, NULL}}; -/** Return true iff Jalv supports the given feature. */ +/// Return true iff Jalv supports the given feature static bool -feature_is_supported(Jalv* jalv, const char* uri) +feature_is_supported(const Jalv* jalv, const char* uri) { - if (!strcmp(uri, "http://lv2plug.in/ns/lv2core#isLive")) { - return true; - } - - for (const LV2_Feature*const* f = jalv->feature_list; *f; ++f) { - if (!strcmp(uri, (*f)->URI)) { - return true; - } - } - return false; -} - -/** Abort and exit on error */ -static void -die(const char* msg) -{ - fprintf(stderr, "%s\n", msg); - exit(EXIT_FAILURE); + if (!strcmp(uri, "http://lv2plug.in/ns/lv2core#isLive") || + !strcmp(uri, "http://lv2plug.in/ns/lv2core#inPlaceBroken")) { + return true; + } + + for (const LV2_Feature* const* f = jalv->feature_list; *f; ++f) { + if (!strcmp(uri, (*f)->URI)) { + return true; + } + } + return false; } /** - Create a port structure from data description. This is called before plugin - and Jack instantiation. The remaining instance-specific setup - (e.g. buffers) is done later in activate_port(). -*/ -static void -create_port(Jalv* jalv, - uint32_t port_index, - float default_value) -{ - struct Port* const port = &jalv->ports[port_index]; - - port->lilv_port = lilv_plugin_get_port_by_index(jalv->plugin, port_index); - port->sys_port = NULL; - port->evbuf = NULL; - port->buf_size = 0; - port->index = port_index; - port->control = 0.0f; - port->flow = FLOW_UNKNOWN; - - const bool optional = lilv_port_has_property( - jalv->plugin, port->lilv_port, jalv->nodes.lv2_connectionOptional); - - /* Set the port flow (input or output) */ - if (lilv_port_is_a(jalv->plugin, port->lilv_port, jalv->nodes.lv2_InputPort)) { - port->flow = FLOW_INPUT; - } else if (lilv_port_is_a(jalv->plugin, port->lilv_port, - jalv->nodes.lv2_OutputPort)) { - port->flow = FLOW_OUTPUT; - } else if (!optional) { - die("Mandatory port has unknown type (neither input nor output)"); - } - - const bool hidden = !jalv->opts.show_hidden && - lilv_port_has_property(jalv->plugin, - port->lilv_port, - jalv->nodes.pprops_notOnGUI); - - /* Set control values */ - if (lilv_port_is_a(jalv->plugin, port->lilv_port, jalv->nodes.lv2_ControlPort)) { - port->type = TYPE_CONTROL; - port->control = isnan(default_value) ? 0.0f : default_value; - if (!hidden) { - add_control(&jalv->controls, new_port_control(jalv, port->index)); - } - } else if (lilv_port_is_a(jalv->plugin, port->lilv_port, - jalv->nodes.lv2_AudioPort)) { - port->type = TYPE_AUDIO; -#ifdef HAVE_JACK_METADATA - } else if (lilv_port_is_a(jalv->plugin, port->lilv_port, - jalv->nodes.lv2_CVPort)) { - port->type = TYPE_CV; -#endif - } else if (lilv_port_is_a(jalv->plugin, port->lilv_port, - jalv->nodes.atom_AtomPort)) { - port->type = TYPE_EVENT; - } else if (!optional) { - die("Mandatory port has unknown data type"); - } - - LilvNode* min_size = lilv_port_get( - jalv->plugin, port->lilv_port, jalv->nodes.rsz_minimumSize); - if (min_size && lilv_node_is_int(min_size)) { - port->buf_size = lilv_node_as_int(min_size); - jalv->opts.buffer_size = MAX( - jalv->opts.buffer_size, port->buf_size * N_BUFFER_CYCLES); - } - lilv_node_free(min_size); -} + Create a port structure from data description. -/** - Create port structures from data (via create_port()) for all ports. + This is called before plugin and Jack instantiation. The remaining + instance-specific setup (e.g. buffers) is done later in activate_port(). */ -void -jalv_create_ports(Jalv* jalv) +static int +create_port(Jalv* jalv, uint32_t port_index) { - jalv->num_ports = lilv_plugin_get_num_ports(jalv->plugin); - jalv->ports = (struct Port*)calloc(jalv->num_ports, sizeof(struct Port)); - float* default_values = (float*)calloc( - lilv_plugin_get_num_ports(jalv->plugin), sizeof(float)); - lilv_plugin_get_port_ranges_float(jalv->plugin, NULL, NULL, default_values); - - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - create_port(jalv, i, default_values[i]); - } - - const LilvPort* control_input = lilv_plugin_get_port_by_designation( - jalv->plugin, jalv->nodes.lv2_InputPort, jalv->nodes.lv2_control); - if (control_input) { - jalv->control_in = lilv_port_get_index(jalv->plugin, control_input); - } - - free(default_values); + JalvPort* const port = &jalv->ports[port_index]; + + port->lilv_port = lilv_plugin_get_port_by_index(jalv->plugin, port_index); + port->index = port_index; + port->flow = FLOW_UNKNOWN; + + JalvProcessPort* const pport = &jalv->process.ports[port_index]; + if (jalv_process_port_init(&jalv->process.ports[port_index], + &jalv->nodes, + jalv->plugin, + port->lilv_port)) { + return 1; + } + + port->type = pport->type; + port->flow = pport->flow; + + if (lilv_port_is_a( + jalv->plugin, port->lilv_port, jalv->nodes.lv2_ControlPort)) { + const bool hidden = !jalv->opts.show_hidden && + lilv_port_has_property(jalv->plugin, + port->lilv_port, + jalv->nodes.pprops_notOnGUI); + + if (!hidden) { + add_control(&jalv->controls, + new_port_control(jalv->world, + jalv->plugin, + port->lilv_port, + port->index, + jalv->settings.sample_rate, + &jalv->nodes, + &jalv->forge)); + } + } + + // Store index if this is the designated control input port + if (jalv->process.control_in == UINT32_MAX && pport->is_primary && + port->flow == FLOW_INPUT && port->type == TYPE_EVENT) { + jalv->process.control_in = port_index; + } + + // Update maximum buffer sizes + const uint32_t buf_size = pport->buf_size; + jalv->opts.ring_size = MAX(jalv->opts.ring_size, buf_size * N_BUFFER_CYCLES); + if (port->flow == FLOW_OUTPUT) { + jalv->ui_msg_size = MAX(jalv->ui_msg_size, buf_size); + } + + return 0; } -/** - Allocate port buffers (only necessary for MIDI). -*/ -void -jalv_allocate_port_buffers(Jalv* jalv) +/// Create port structures from data (via create_port()) for all ports +static int +jalv_create_ports(Jalv* jalv) { - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - struct Port* const port = &jalv->ports[i]; - switch (port->type) { - case TYPE_EVENT: { - lv2_evbuf_free(port->evbuf); - const size_t buf_size = (port->buf_size > 0) - ? port->buf_size - : jalv->midi_buf_size; - port->evbuf = lv2_evbuf_new( - buf_size, - jalv->map.map(jalv->map.handle, - lilv_node_as_string(jalv->nodes.atom_Chunk)), - jalv->map.map(jalv->map.handle, - lilv_node_as_string(jalv->nodes.atom_Sequence))); - lilv_instance_connect_port( - jalv->instance, i, lv2_evbuf_get_buffer(port->evbuf)); - } - default: break; - } - } + const uint32_t n_ports = lilv_plugin_get_num_ports(jalv->plugin); + + jalv->num_ports = n_ports; + jalv->ports = (JalvPort*)calloc(n_ports, sizeof(JalvPort)); + jalv->process.num_ports = n_ports; + jalv->process.ports = + (JalvProcessPort*)calloc(n_ports, sizeof(JalvProcessPort)); + + // Allocate control port buffers array and set to default values + jalv->process.controls_buf = (float*)calloc(n_ports, sizeof(float)); + lilv_plugin_get_port_ranges_float( + jalv->plugin, NULL, NULL, jalv->process.controls_buf); + + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + if (create_port(jalv, i)) { + return 1; + } + } + + return 0; } /** @@ -267,1063 +183,863 @@ jalv_allocate_port_buffers(Jalv* jalv) TODO: Build an index to make this faster, currently O(n) which may be a problem when restoring the state of plugins with many ports. */ -struct Port* +JalvPort* jalv_port_by_symbol(Jalv* jalv, const char* sym) { - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - struct Port* const port = &jalv->ports[i]; - const LilvNode* port_sym = lilv_port_get_symbol(jalv->plugin, - port->lilv_port); + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + JalvPort* const port = &jalv->ports[i]; + const LilvNode* port_sym = + lilv_port_get_symbol(jalv->plugin, port->lilv_port); - if (!strcmp(lilv_node_as_string(port_sym), sym)) { - return port; - } - } + if (!strcmp(lilv_node_as_string(port_sym), sym)) { + return port; + } + } - return NULL; + return NULL; } -ControlID* +static ControlID* jalv_control_by_symbol(Jalv* jalv, const char* sym) { - for (size_t i = 0; i < jalv->controls.n_controls; ++i) { - if (!strcmp(lilv_node_as_string(jalv->controls.controls[i]->symbol), - sym)) { - return jalv->controls.controls[i]; - } - } - return NULL; + for (size_t i = 0; i < jalv->controls.n_controls; ++i) { + if (!strcmp(lilv_node_as_string(jalv->controls.controls[i]->symbol), sym)) { + return jalv->controls.controls[i]; + } + } + return NULL; } -void +static void jalv_create_controls(Jalv* jalv, bool writable) { - const LilvPlugin* plugin = jalv->plugin; - LilvWorld* world = jalv->world; - LilvNode* patch_writable = lilv_new_uri(world, LV2_PATCH__writable); - LilvNode* patch_readable = lilv_new_uri(world, LV2_PATCH__readable); - - LilvNodes* properties = lilv_world_find_nodes( - world, - lilv_plugin_get_uri(plugin), - writable ? patch_writable : patch_readable, - NULL); - LILV_FOREACH(nodes, p, properties) { - const LilvNode* property = lilv_nodes_get(properties, p); - ControlID* record = NULL; - - if (!writable && lilv_world_ask(world, - lilv_plugin_get_uri(plugin), - patch_writable, - property)) { - // Find existing writable control - for (size_t i = 0; i < jalv->controls.n_controls; ++i) { - if (lilv_node_equals(jalv->controls.controls[i]->node, property)) { - record = jalv->controls.controls[i]; - record->is_readable = true; - break; - } - } - - if (record) { - continue; - } - } - - record = new_property_control(jalv, property); - if (writable) { - record->is_writable = true; - } else { - record->is_readable = true; - } - - if (record->value_type) { - add_control(&jalv->controls, record); - } else { - fprintf(stderr, "Parameter <%s> has unknown value type, ignored\n", - lilv_node_as_string(record->node)); - free(record); - } - } - lilv_nodes_free(properties); - - lilv_node_free(patch_readable); - lilv_node_free(patch_writable); + const LilvPlugin* plugin = jalv->plugin; + LilvWorld* world = jalv->world; + LilvNode* patch_writable = lilv_new_uri(world, LV2_PATCH__writable); + LilvNode* patch_readable = lilv_new_uri(world, LV2_PATCH__readable); + + LilvNodes* properties = + lilv_world_find_nodes(world, + lilv_plugin_get_uri(plugin), + writable ? patch_writable : patch_readable, + NULL); + LILV_FOREACH (nodes, p, properties) { + const LilvNode* property = lilv_nodes_get(properties, p); + ControlID* record = NULL; + + if (!writable && + lilv_world_ask( + world, lilv_plugin_get_uri(plugin), patch_writable, property)) { + // Find existing writable control + for (size_t i = 0; i < jalv->controls.n_controls; ++i) { + if (lilv_node_equals(jalv->controls.controls[i]->node, property)) { + record = jalv->controls.controls[i]; + record->is_readable = true; + break; + } + } + + if (record) { + continue; + } + } + + record = new_property_control(jalv->world, + property, + &jalv->nodes, + jalv_mapper_urid_map(jalv->mapper), + &jalv->forge); + + if (writable) { + record->is_writable = true; + } else { + record->is_readable = true; + } + + if (record->value_type) { + add_control(&jalv->controls, record); + } else { + jalv_log(JALV_LOG_WARNING, + "Parameter <%s> has unknown value type, ignored\n", + lilv_node_as_string(record->node)); + free(record); + } + } + lilv_nodes_free(properties); + + lilv_node_free(patch_readable); + lilv_node_free(patch_writable); } -void -jalv_set_control(const ControlID* control, - uint32_t size, - LV2_URID type, - const void* body) +static void +jalv_send_to_plugin(void* const jalv_handle, + const uint32_t port_index, + const uint32_t buffer_size, + const uint32_t protocol, + const void* const buffer) { - Jalv* jalv = control->jalv; - if (control->type == PORT && type == jalv->forge.Float) { - struct Port* port = &control->jalv->ports[control->index]; - port->control = *(const float*)body; - } else if (control->type == PROPERTY) { - // Copy forge since it is used by process thread - LV2_Atom_Forge forge = jalv->forge; - LV2_Atom_Forge_Frame frame; - uint8_t buf[1024]; - lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf)); - - lv2_atom_forge_object(&forge, &frame, 0, jalv->urids.patch_Set); - lv2_atom_forge_key(&forge, jalv->urids.patch_property); - lv2_atom_forge_urid(&forge, control->property); - lv2_atom_forge_key(&forge, jalv->urids.patch_value); - lv2_atom_forge_atom(&forge, size, type); - lv2_atom_forge_write(&forge, body, size); - - const LV2_Atom* atom = lv2_atom_forge_deref(&forge, frame.ref); - jalv_ui_write(jalv, - jalv->control_in, - lv2_atom_total_size(atom), - jalv->urids.atom_eventTransfer, - atom); - } + Jalv* const jalv = (Jalv*)jalv_handle; + JalvProcess* const proc = &jalv->process; + ZixStatus st = ZIX_STATUS_SUCCESS; + + if (port_index >= jalv->num_ports) { + jalv_log(JALV_LOG_ERR, "UI wrote to invalid port index %u\n", port_index); + + } else if (protocol == 0U) { + if (buffer_size != sizeof(float)) { + st = ZIX_STATUS_BAD_ARG; + } else { + const float value = *(const float*)buffer; + st = jalv_write_control(proc->ui_to_plugin, port_index, value); + } + + } else if (protocol == jalv->urids.atom_eventTransfer) { + const LV2_Atom* const atom = (const LV2_Atom*)buffer; + if (buffer_size < sizeof(LV2_Atom) || + (sizeof(LV2_Atom) + atom->size != buffer_size)) { + st = ZIX_STATUS_BAD_ARG; + } else { + jalv_dump_atom(jalv->dumper, stdout, "UI => Plugin", atom, 36); + st = jalv_write_event( + proc->ui_to_plugin, port_index, atom->size, atom->type, atom + 1U); + } + + } else { + jalv_log(JALV_LOG_ERR, + "UI wrote with unsupported protocol %u (%s)\n", + protocol, + jalv_mapper_unmap_uri(jalv->mapper, protocol)); + } + + if (st) { + jalv_log(JALV_LOG_ERR, + "Failed to write to plugin from UI (%s)\n", + zix_strerror(st)); + } } void -jalv_ui_instantiate(Jalv* jalv, const char* native_ui_type, void* parent) +jalv_set_control(Jalv* jalv, + const ControlID* control, + uint32_t size, + LV2_URID type, + const void* body) { -#ifdef HAVE_SUIL - jalv->ui_host = suil_host_new(jalv_ui_write, jalv_ui_port_index, NULL, NULL); - - const LV2_Feature parent_feature = { - LV2_UI__parent, parent - }; - const LV2_Feature instance_feature = { - NS_EXT "instance-access", lilv_instance_get_handle(jalv->instance) - }; - const LV2_Feature data_feature = { - LV2_DATA_ACCESS_URI, &jalv->features.ext_data - }; - const LV2_Feature idle_feature = { - LV2_UI__idleInterface, NULL - }; - const LV2_Feature* ui_features[] = { - &jalv->features.map_feature, - &jalv->features.unmap_feature, - &instance_feature, - &data_feature, - &jalv->features.log_feature, - &parent_feature, - &jalv->features.options_feature, - &idle_feature, - &jalv->features.request_value_feature, - NULL - }; - - const char* bundle_uri = lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui)); - const char* binary_uri = lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui)); - char* bundle_path = lilv_file_uri_parse(bundle_uri, NULL); - char* binary_path = lilv_file_uri_parse(binary_uri, NULL); - - jalv->ui_instance = suil_instance_new( - jalv->ui_host, - jalv, - native_ui_type, - lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)), - lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)), - lilv_node_as_uri(jalv->ui_type), - bundle_path, - binary_path, - ui_features); - - lilv_free(binary_path); - lilv_free(bundle_path); -#endif + if (control->type == PORT && type == jalv->forge.Float) { + const float value = *(const float*)body; + jalv_write_control(jalv->process.ui_to_plugin, control->id.index, value); + } else if (control->type == PROPERTY && + jalv->process.control_in != UINT32_MAX) { + LV2_Atom_Forge_Frame frame; + lv2_atom_forge_set_buffer(&jalv->forge, jalv->ui_msg, jalv->ui_msg_size); + + lv2_atom_forge_object(&jalv->forge, &frame, 0, jalv->urids.patch_Set); + lv2_atom_forge_key(&jalv->forge, jalv->urids.patch_property); + lv2_atom_forge_urid(&jalv->forge, control->id.property); + lv2_atom_forge_key(&jalv->forge, jalv->urids.patch_value); + lv2_atom_forge_atom(&jalv->forge, size, type); + lv2_atom_forge_write(&jalv->forge, body, size); + + const LV2_Atom* atom = lv2_atom_forge_deref(&jalv->forge, frame.ref); + jalv_send_to_plugin(jalv, + jalv->process.control_in, + lv2_atom_total_size(atom), + jalv->urids.atom_eventTransfer, + atom); + } } -bool -jalv_ui_is_resizable(Jalv* jalv) +#if USE_SUIL +static uint32_t +jalv_ui_port_index(void* const controller, const char* symbol) { - if (!jalv->ui) { - return false; - } - - const LilvNode* s = lilv_ui_get_uri(jalv->ui); - LilvNode* p = lilv_new_uri(jalv->world, LV2_CORE__optionalFeature); - LilvNode* fs = lilv_new_uri(jalv->world, LV2_UI__fixedSize); - LilvNode* nrs = lilv_new_uri(jalv->world, LV2_UI__noUserResize); - - LilvNodes* fs_matches = lilv_world_find_nodes(jalv->world, s, p, fs); - LilvNodes* nrs_matches = lilv_world_find_nodes(jalv->world, s, p, nrs); + Jalv* const jalv = (Jalv*)controller; + JalvPort* const port = jalv_port_by_symbol(jalv, symbol); - lilv_nodes_free(nrs_matches); - lilv_nodes_free(fs_matches); - lilv_node_free(nrs); - lilv_node_free(fs); - lilv_node_free(p); - - return !fs_matches && !nrs_matches; -} - -void -jalv_ui_write(void* const jalv_handle, - uint32_t port_index, - uint32_t buffer_size, - uint32_t protocol, - const void* buffer) -{ - Jalv* const jalv = (Jalv*)jalv_handle; - - if (protocol != 0 && protocol != jalv->urids.atom_eventTransfer) { - fprintf(stderr, "UI write with unsupported protocol %d (%s)\n", - protocol, unmap_uri(jalv, protocol)); - return; - } - - if (port_index >= jalv->num_ports) { - fprintf(stderr, "UI write to out of range port index %d\n", - port_index); - return; - } - - if (jalv->opts.dump && protocol == jalv->urids.atom_eventTransfer) { - const LV2_Atom* atom = (const LV2_Atom*)buffer; - char* str = sratom_to_turtle( - jalv->sratom, &jalv->unmap, "jalv:", NULL, NULL, - atom->type, atom->size, LV2_ATOM_BODY_CONST(atom)); - jalv_ansi_start(stdout, 36); - printf("\n## UI => Plugin (%u bytes) ##\n%s\n", atom->size, str); - jalv_ansi_reset(stdout); - free(str); - } - - char buf[sizeof(ControlChange) + buffer_size]; - ControlChange* ev = (ControlChange*)buf; - ev->index = port_index; - ev->protocol = protocol; - ev->size = buffer_size; - memcpy(ev->body, buffer, buffer_size); - zix_ring_write(jalv->ui_events, buf, sizeof(buf)); + return port ? port->index : LV2UI_INVALID_PORT_INDEX; } +#endif void -jalv_apply_ui_events(Jalv* jalv, uint32_t nframes) -{ - if (!jalv->has_ui) { - return; - } - - ControlChange ev; - const size_t space = zix_ring_read_space(jalv->ui_events); - for (size_t i = 0; i < space; i += sizeof(ev) + ev.size) { - zix_ring_read(jalv->ui_events, (char*)&ev, sizeof(ev)); - char body[ev.size]; - if (zix_ring_read(jalv->ui_events, body, ev.size) != ev.size) { - fprintf(stderr, "error: Error reading from UI ring buffer\n"); - break; - } - assert(ev.index < jalv->num_ports); - struct Port* const port = &jalv->ports[ev.index]; - if (ev.protocol == 0) { - assert(ev.size == sizeof(float)); - port->control = *(float*)body; - } else if (ev.protocol == jalv->urids.atom_eventTransfer) { - LV2_Evbuf_Iterator e = lv2_evbuf_end(port->evbuf); - const LV2_Atom* const atom = (const LV2_Atom*)body; - lv2_evbuf_write(&e, nframes, 0, atom->type, atom->size, - (const uint8_t*)LV2_ATOM_BODY_CONST(atom)); - } else { - fprintf(stderr, "error: Unknown control change protocol %d\n", - ev.protocol); - } - } -} - -uint32_t -jalv_ui_port_index(void* const controller, const char* symbol) +jalv_ui_instantiate(Jalv* jalv, const char* native_ui_type, void* parent) { - Jalv* const jalv = (Jalv*)controller; - struct Port* port = jalv_port_by_symbol(jalv, symbol); - - return port ? port->index : LV2UI_INVALID_PORT_INDEX; +#if USE_SUIL + const LilvInstance* const instance = jalv->process.instance; + + jalv->ui_host = + suil_host_new(jalv_send_to_plugin, jalv_ui_port_index, NULL, NULL); + + const LV2_Feature parent_feature = {LV2_UI__parent, parent}; + + const LV2_Feature instance_feature = {LV2_INSTANCE_ACCESS_URI, + lilv_instance_get_handle(instance)}; + + const LV2_Feature data_feature = {LV2_DATA_ACCESS_URI, + &jalv->features.ext_data}; + + const LV2_Feature idle_feature = {LV2_UI__idleInterface, NULL}; + + const LV2_Feature* ui_features[] = {&jalv->features.map_feature, + &jalv->features.unmap_feature, + &instance_feature, + &data_feature, + &jalv->features.log_feature, + &parent_feature, + &jalv->features.options_feature, + &idle_feature, + &jalv->features.request_value_feature, + NULL}; + + const char* bundle_uri = lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui)); + const char* binary_uri = lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui)); + char* bundle_path = lilv_file_uri_parse(bundle_uri, NULL); + char* binary_path = lilv_file_uri_parse(binary_uri, NULL); + + jalv->ui_instance = + suil_instance_new(jalv->ui_host, + jalv, + native_ui_type, + lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)), + lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)), + lilv_node_as_uri(jalv->ui_type), + bundle_path, + binary_path, + ui_features); + + lilv_free(binary_path); + lilv_free(bundle_path); +#else + (void)jalv; + (void)native_ui_type; + (void)parent; +#endif } void jalv_init_ui(Jalv* jalv) { - // Set initial control port values - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - if (jalv->ports[i].type == TYPE_CONTROL) { - jalv_ui_port_event(jalv, i, - sizeof(float), 0, - &jalv->ports[i].control); - } - } - - if (jalv->control_in != (uint32_t)-1) { - // Send patch:Get message for initial parameters/etc - LV2_Atom_Forge forge = jalv->forge; - LV2_Atom_Forge_Frame frame; - uint8_t buf[1024]; - lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf)); - lv2_atom_forge_object(&forge, &frame, 0, jalv->urids.patch_Get); - - const LV2_Atom* atom = lv2_atom_forge_deref(&forge, frame.ref); - jalv_ui_write(jalv, - jalv->control_in, - lv2_atom_total_size(atom), - jalv->urids.atom_eventTransfer, - atom); - lv2_atom_forge_pop(&forge, &frame); - } -} - -bool -jalv_send_to_ui(Jalv* jalv, - uint32_t port_index, - uint32_t type, - uint32_t size, - const void* body) -{ - /* TODO: Be more disciminate about what to send */ - char evbuf[sizeof(ControlChange) + sizeof(LV2_Atom)]; - ControlChange* ev = (ControlChange*)evbuf; - ev->index = port_index; - ev->protocol = jalv->urids.atom_eventTransfer; - ev->size = sizeof(LV2_Atom) + size; - - LV2_Atom* atom = (LV2_Atom*)ev->body; - atom->type = type; - atom->size = size; - - if (zix_ring_write_space(jalv->plugin_events) >= sizeof(evbuf) + size) { - zix_ring_write(jalv->plugin_events, evbuf, sizeof(evbuf)); - zix_ring_write(jalv->plugin_events, (const char*)body, size); - return true; - } else { - fprintf(stderr, "Plugin => UI buffer overflow!\n"); - return false; - } + // Set initial control port values + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + if (jalv->ports[i].type == TYPE_CONTROL) { + jalv_frontend_port_event( + jalv, i, sizeof(float), 0, &jalv->process.controls_buf[i]); + } + } + + if (jalv->process.control_in != UINT32_MAX) { + // Send patch:Get message for initial parameters/etc + LV2_Atom_Forge_Frame frame; + uint64_t buf[4U] = {0U, 0U, 0U, 0U}; + lv2_atom_forge_set_buffer(&jalv->forge, (uint8_t*)buf, sizeof(buf)); + lv2_atom_forge_object(&jalv->forge, &frame, 0, jalv->urids.patch_Get); + + const LV2_Atom* atom = lv2_atom_forge_deref(&jalv->forge, frame.ref); + jalv_send_to_plugin(jalv, + jalv->process.control_in, + lv2_atom_total_size(atom), + jalv->urids.atom_eventTransfer, + atom); + lv2_atom_forge_pop(&jalv->forge, &frame); + } } -bool -jalv_run(Jalv* jalv, uint32_t nframes) +static int +ring_error(const char* const message) { - /* Read and apply control change events from UI */ - jalv_apply_ui_events(jalv, nframes); - - /* Run plugin for this cycle */ - lilv_instance_run(jalv->instance, nframes); - - /* Process any worker replies. */ - jalv_worker_emit_responses(&jalv->state_worker, jalv->instance); - jalv_worker_emit_responses(&jalv->worker, jalv->instance); - - /* Notify the plugin the run() cycle is finished */ - if (jalv->worker.iface && jalv->worker.iface->end_run) { - jalv->worker.iface->end_run(jalv->instance->lv2_handle); - } - - /* Check if it's time to send updates to the UI */ - jalv->event_delta_t += nframes; - bool send_ui_updates = false; - float update_frames = jalv->sample_rate / jalv->ui_update_hz; - if (jalv->has_ui && (jalv->event_delta_t > update_frames)) { - send_ui_updates = true; - jalv->event_delta_t = 0; - } - - return send_ui_updates; + jalv_log(JALV_LOG_ERR, "%s", message); + return 1; } int jalv_update(Jalv* jalv) { - /* Check quit flag and close if set. */ - if (zix_sem_try_wait(&jalv->done)) { - jalv_close_ui(jalv); - return 0; - } - - /* Emit UI events. */ - ControlChange ev; - const size_t space = zix_ring_read_space(jalv->plugin_events); - for (size_t i = 0; - i + sizeof(ev) < space; - i += sizeof(ev) + ev.size) { - /* Read event header to get the size */ - zix_ring_read(jalv->plugin_events, (char*)&ev, sizeof(ev)); - - /* Resize read buffer if necessary */ - jalv->ui_event_buf = realloc(jalv->ui_event_buf, ev.size); - void* const buf = jalv->ui_event_buf; - - /* Read event body */ - zix_ring_read(jalv->plugin_events, (char*)buf, ev.size); - - if (jalv->opts.dump && ev.protocol == jalv->urids.atom_eventTransfer) { - /* Dump event in Turtle to the console */ - LV2_Atom* atom = (LV2_Atom*)buf; - char* str = sratom_to_turtle( - jalv->ui_sratom, &jalv->unmap, "jalv:", NULL, NULL, - atom->type, atom->size, LV2_ATOM_BODY(atom)); - jalv_ansi_start(stdout, 35); - printf("\n## Plugin => UI (%u bytes) ##\n%s\n", atom->size, str); - jalv_ansi_reset(stdout); - free(str); - } - - jalv_ui_port_event(jalv, ev.index, ev.size, ev.protocol, buf); - - if (ev.protocol == 0 && jalv->opts.print_controls) { - jalv_print_control(jalv, &jalv->ports[ev.index], *(float*)buf); - } - } - - return 1; + // Check quit flag and close if set + if (!zix_sem_try_wait(&jalv->done)) { + jalv_frontend_close(jalv); + return 0; + } + + // Emit UI events + ZixRing* const ring = jalv->process.plugin_to_ui; + JalvMessageHeader header = {NO_MESSAGE, 0U}; + const size_t space = zix_ring_read_space(ring); + for (size_t i = 0; i < space; i += sizeof(header) + header.size) { + // Read message header (which includes the body size) + if (zix_ring_read(ring, &header, sizeof(header)) != sizeof(header)) { + return ring_error("Failed to read header from process ring\n"); + } + + // Read message body + void* const body = jalv->ui_msg; + if (zix_ring_read(ring, body, header.size) != header.size) { + return ring_error("Failed to read message from process ring\n"); + } + + if (header.type == CONTROL_PORT_CHANGE) { + const JalvControlChange* const msg = (const JalvControlChange*)body; + jalv_frontend_port_event(jalv, msg->port_index, sizeof(float), 0, body); + } else if (header.type == EVENT_TRANSFER) { + const JalvEventTransfer* const msg = (const JalvEventTransfer*)body; + jalv_dump_atom(jalv->dumper, stdout, "Plugin => UI", &msg->atom, 35); + jalv_frontend_port_event(jalv, + msg->port_index, + sizeof(LV2_Atom) + msg->atom.size, + jalv->urids.atom_eventTransfer, + &msg->atom); + } else if (header.type == LATENCY_CHANGE) { + jalv_backend_recompute_latencies(jalv->backend); + } else { + return ring_error("Unknown message type received from process ring\n"); + } + } + + return 1; } static bool jalv_apply_control_arg(Jalv* jalv, const char* s) { - char sym[256]; - float val = 0.0f; - if (sscanf(s, "%[^=]=%f", sym, &val) != 2) { - fprintf(stderr, "warning: Ignoring invalid value `%s'\n", s); - return false; - } - - ControlID* control = jalv_control_by_symbol(jalv, sym); - if (!control) { - fprintf(stderr, "warning: Ignoring value for unknown control `%s'\n", sym); - return false; - } - - jalv_set_control(control, sizeof(float), jalv->urids.atom_Float, &val); - printf("%s = %f\n", sym, val); - - return true; -} - -static void -signal_handler(ZIX_UNUSED int sig) -{ - zix_sem_post(exit_sem); + char sym[256] = {'\0'}; + float val = 0.0f; + if (sscanf(s, "%240[^=]=%f", sym, &val) != 2) { + jalv_log(JALV_LOG_WARNING, "Ignoring invalid value `%s'\n", s); + return false; + } + + const ControlID* control = jalv_control_by_symbol(jalv, sym); + if (!control) { + jalv_log( + JALV_LOG_WARNING, "Ignoring value for unknown control `%s'\n", sym); + return false; + } + + jalv_set_control(jalv, control, sizeof(float), jalv->urids.atom_Float, &val); + jalv_log(JALV_LOG_INFO, "%s = %f\n", sym, val); + + return true; } static void init_feature(LV2_Feature* const dest, const char* const URI, void* data) { - dest->URI = URI; - dest->data = data; -} - -static void -setup_signals(Jalv* const jalv) -{ - exit_sem = &jalv->done; - -#ifdef HAVE_SIGACTION - struct sigaction action; - sigemptyset(&action.sa_mask); - action.sa_flags = 0; - action.sa_handler = signal_handler; - sigaction(SIGINT, &action, NULL); - sigaction(SIGTERM, &action, NULL); -#else - /* May not work in combination with fgets in the console interface */ - signal(SIGINT, signal_handler); - signal(SIGTERM, signal_handler); -#endif + dest->URI = URI; + dest->data = data; } static const LilvUI* jalv_select_custom_ui(const Jalv* const jalv) { - const char* const native_ui_type_uri = jalv_native_ui_type(); - - if (jalv->opts.ui_uri) { - // Specific UI explicitly requested by user - LilvNode* uri = lilv_new_uri(jalv->world, jalv->opts.ui_uri); - const LilvUI* ui = lilv_uis_get_by_uri(jalv->uis, uri); - - lilv_node_free(uri); - return ui; - } - -#ifdef HAVE_SUIL - if (native_ui_type_uri) { - // Try to find an embeddable UI - LilvNode* native_type = lilv_new_uri(jalv->world, native_ui_type_uri); - - LILV_FOREACH (uis, u, jalv->uis) { - const LilvUI* ui = lilv_uis_get(jalv->uis, u); - const LilvNode* type = NULL; - const bool supported = lilv_ui_is_supported( - ui, suil_ui_supported, native_type, &type); - - if (supported) { - lilv_node_free(native_type); - return ui; - } - } - - lilv_node_free(native_type); - } + const char* const native_ui_type_uri = jalv_frontend_ui_type(); + + if (jalv->opts.ui_uri) { + // Specific UI explicitly requested by user + LilvNode* uri = lilv_new_uri(jalv->world, jalv->opts.ui_uri); + const LilvUI* ui = lilv_uis_get_by_uri(jalv->uis, uri); + + lilv_node_free(uri); + return ui; + } + +#if USE_SUIL + if (native_ui_type_uri) { + // Try to find an embeddable UI + LilvNode* native_type = lilv_new_uri(jalv->world, native_ui_type_uri); + + LILV_FOREACH (uis, u, jalv->uis) { + const LilvUI* ui = lilv_uis_get(jalv->uis, u); + const LilvNode* type = NULL; + const bool supported = + lilv_ui_is_supported(ui, suil_ui_supported, native_type, &type); + + if (supported) { + lilv_node_free(native_type); + return ui; + } + } + + lilv_node_free(native_type); + } #endif - if (!native_ui_type_uri && jalv->opts.show_ui) { - // Try to find a UI with ui:showInterface - LILV_FOREACH (uis, u, jalv->uis) { - const LilvUI* ui = lilv_uis_get(jalv->uis, u); - const LilvNode* ui_node = lilv_ui_get_uri(ui); + if (!native_ui_type_uri && jalv->opts.show_ui) { + // Try to find a UI with ui:showInterface + LILV_FOREACH (uis, u, jalv->uis) { + const LilvUI* ui = lilv_uis_get(jalv->uis, u); + const LilvNode* ui_node = lilv_ui_get_uri(ui); - lilv_world_load_resource(jalv->world, ui_node); + lilv_world_load_resource(jalv->world, ui_node); - const bool supported = lilv_world_ask(jalv->world, - ui_node, - jalv->nodes.lv2_extensionData, - jalv->nodes.ui_showInterface); + const bool supported = lilv_world_ask(jalv->world, + ui_node, + jalv->nodes.lv2_extensionData, + jalv->nodes.ui_showInterface); - lilv_world_unload_resource(jalv->world, ui_node); + lilv_world_unload_resource(jalv->world, ui_node); - if (supported) { - return ui; - } - } - } + if (supported) { + return ui; + } + } + } - return NULL; + return NULL; } -int -jalv_open(Jalv* const jalv, int* argc, char*** argv) +static void +jalv_init_features(Jalv* const jalv) { - jalv->prog_name = (*argv)[0]; - jalv->block_length = 4096; /* Should be set by backend */ - jalv->midi_buf_size = 1024; /* Should be set by backend */ - jalv->play_state = JALV_PAUSED; - jalv->bpm = 120.0f; - jalv->control_in = (uint32_t)-1; - -#ifdef HAVE_SUIL - suil_init(argc, argv, SUIL_ARG_NONE); -#endif + // urid:map + init_feature(&jalv->features.map_feature, + LV2_URID__map, + jalv_mapper_urid_map(jalv->mapper)); + + // urid:unmap + init_feature(&jalv->features.unmap_feature, + LV2_URID__unmap, + jalv_mapper_urid_unmap(jalv->mapper)); + + // state:makePath + jalv->features.make_path.handle = jalv; + jalv->features.make_path.path = jalv_make_path; + init_feature(&jalv->features.make_path_feature, + LV2_STATE__makePath, + &jalv->features.make_path); + + // worker:schedule (normal) + jalv->features.sched.schedule_work = jalv_worker_schedule; + init_feature( + &jalv->features.sched_feature, LV2_WORKER__schedule, &jalv->features.sched); + + // worker:schedule (state) + jalv->features.ssched.schedule_work = jalv_worker_schedule; + init_feature(&jalv->features.state_sched_feature, + LV2_WORKER__schedule, + &jalv->features.ssched); + + // log:log + jalv->features.llog.handle = &jalv->log; + jalv->features.llog.printf = jalv_printf; + jalv->features.llog.vprintf = jalv_vprintf; + init_feature(&jalv->features.log_feature, LV2_LOG__log, &jalv->features.llog); + + // (options:options is initialized later by jalv_init_options()) + + // state:threadSafeRestore + init_feature( + &jalv->features.safe_restore_feature, LV2_STATE__threadSafeRestore, NULL); + + // ui:requestValue + jalv->features.request_value.handle = jalv; + init_feature(&jalv->features.request_value_feature, + LV2_UI__requestValue, + &jalv->features.request_value); +} - if (jalv_init(argc, argv, &jalv->opts)) { - jalv_close(jalv); - return -1; - } - - if (jalv->opts.uuid) { - printf("UUID: %s\n", jalv->opts.uuid); - } - - jalv->symap = symap_new(); - zix_sem_init(&jalv->symap_lock, 1); - zix_sem_init(&jalv->work_lock, 1); - - jalv->map.handle = jalv; - jalv->map.map = map_uri; - init_feature(&jalv->features.map_feature, LV2_URID__map, &jalv->map); - - jalv->worker.jalv = jalv; - jalv->state_worker.jalv = jalv; - - jalv->unmap.handle = jalv; - jalv->unmap.unmap = unmap_uri; - init_feature(&jalv->features.unmap_feature, LV2_URID__unmap, &jalv->unmap); - - lv2_atom_forge_init(&jalv->forge, &jalv->map); - - jalv->env = serd_env_new(NULL); - serd_env_set_prefix_from_strings( - jalv->env, (const uint8_t*)"patch", (const uint8_t*)LV2_PATCH_PREFIX); - serd_env_set_prefix_from_strings( - jalv->env, (const uint8_t*)"time", (const uint8_t*)LV2_TIME_PREFIX); - serd_env_set_prefix_from_strings( - jalv->env, (const uint8_t*)"xsd", (const uint8_t*)NS_XSD); - - jalv->sratom = sratom_new(&jalv->map); - jalv->ui_sratom = sratom_new(&jalv->map); - sratom_set_env(jalv->sratom, jalv->env); - sratom_set_env(jalv->ui_sratom, jalv->env); - - jalv->urids.atom_Float = symap_map(jalv->symap, LV2_ATOM__Float); - jalv->urids.atom_Int = symap_map(jalv->symap, LV2_ATOM__Int); - jalv->urids.atom_Object = symap_map(jalv->symap, LV2_ATOM__Object); - jalv->urids.atom_Path = symap_map(jalv->symap, LV2_ATOM__Path); - jalv->urids.atom_String = symap_map(jalv->symap, LV2_ATOM__String); - jalv->urids.atom_eventTransfer = symap_map(jalv->symap, LV2_ATOM__eventTransfer); - jalv->urids.bufsz_maxBlockLength = symap_map(jalv->symap, LV2_BUF_SIZE__maxBlockLength); - jalv->urids.bufsz_minBlockLength = symap_map(jalv->symap, LV2_BUF_SIZE__minBlockLength); - jalv->urids.bufsz_sequenceSize = symap_map(jalv->symap, LV2_BUF_SIZE__sequenceSize); - jalv->urids.log_Error = symap_map(jalv->symap, LV2_LOG__Error); - jalv->urids.log_Trace = symap_map(jalv->symap, LV2_LOG__Trace); - jalv->urids.log_Warning = symap_map(jalv->symap, LV2_LOG__Warning); - jalv->urids.midi_MidiEvent = symap_map(jalv->symap, LV2_MIDI__MidiEvent); - jalv->urids.param_sampleRate = symap_map(jalv->symap, LV2_PARAMETERS__sampleRate); - jalv->urids.patch_Get = symap_map(jalv->symap, LV2_PATCH__Get); - jalv->urids.patch_Put = symap_map(jalv->symap, LV2_PATCH__Put); - jalv->urids.patch_Set = symap_map(jalv->symap, LV2_PATCH__Set); - jalv->urids.patch_body = symap_map(jalv->symap, LV2_PATCH__body); - jalv->urids.patch_property = symap_map(jalv->symap, LV2_PATCH__property); - jalv->urids.patch_value = symap_map(jalv->symap, LV2_PATCH__value); - jalv->urids.time_Position = symap_map(jalv->symap, LV2_TIME__Position); - jalv->urids.time_bar = symap_map(jalv->symap, LV2_TIME__bar); - jalv->urids.time_barBeat = symap_map(jalv->symap, LV2_TIME__barBeat); - jalv->urids.time_beatUnit = symap_map(jalv->symap, LV2_TIME__beatUnit); - jalv->urids.time_beatsPerBar = symap_map(jalv->symap, LV2_TIME__beatsPerBar); - jalv->urids.time_beatsPerMinute = symap_map(jalv->symap, LV2_TIME__beatsPerMinute); - jalv->urids.time_frame = symap_map(jalv->symap, LV2_TIME__frame); - jalv->urids.time_speed = symap_map(jalv->symap, LV2_TIME__speed); - jalv->urids.ui_updateRate = symap_map(jalv->symap, LV2_UI__updateRate); - -#ifdef _WIN32 - jalv->temp_dir = jalv_strdup("jalvXXXXXX"); - _mktemp(jalv->temp_dir); -#else - char* templ = jalv_strdup("/tmp/jalv-XXXXXX"); - jalv->temp_dir = jalv_strjoin(mkdtemp(templ), "/"); - free(templ); -#endif +static void +jalv_init_ui_settings(Jalv* const jalv) +{ + const JalvOptions* const opts = &jalv->opts; + JalvSettings* const settings = &jalv->settings; + + if (!settings->ring_size) { + /* The UI ring is fed by plugin output ports (usually one), and the UI + updates roughly once per cycle. The ring size is a few times the size + of the MIDI output to give the UI a chance to keep up. */ + settings->ring_size = settings->midi_buf_size * N_BUFFER_CYCLES; + } + + if (opts->update_rate <= 0.0f) { + // Calculate a reasonable UI update frequency + settings->ui_update_hz = jalv_frontend_refresh_rate(jalv); + } + + if (opts->scale_factor <= 0.0f) { + // Calculate the monitor's scale factor + settings->ui_scale_factor = jalv_frontend_scale_factor(jalv); + } + + // The UI can only go so fast, clamp to reasonable limits + settings->ui_update_hz = MAX(1.0f, MIN(60.0f, settings->ui_update_hz)); + settings->ring_size = MAX(4096, settings->ring_size); + jalv_log(JALV_LOG_INFO, "Comm buffers: %u bytes\n", settings->ring_size); + jalv_log(JALV_LOG_INFO, "Update rate: %.01f Hz\n", settings->ui_update_hz); + jalv_log(JALV_LOG_INFO, "Scale factor: %.01f\n", settings->ui_scale_factor); +} - jalv->features.make_path.handle = jalv; - jalv->features.make_path.path = jalv_make_path; - init_feature(&jalv->features.make_path_feature, - LV2_STATE__makePath, &jalv->features.make_path); - - jalv->features.sched.handle = &jalv->worker; - jalv->features.sched.schedule_work = jalv_worker_schedule; - init_feature(&jalv->features.sched_feature, - LV2_WORKER__schedule, &jalv->features.sched); - - jalv->features.ssched.handle = &jalv->state_worker; - jalv->features.ssched.schedule_work = jalv_worker_schedule; - init_feature(&jalv->features.state_sched_feature, - LV2_WORKER__schedule, &jalv->features.ssched); - - jalv->features.llog.handle = jalv; - jalv->features.llog.printf = jalv_printf; - jalv->features.llog.vprintf = jalv_vprintf; - init_feature(&jalv->features.log_feature, - LV2_LOG__log, &jalv->features.llog); - - jalv->features.request_value.handle = jalv; - init_feature(&jalv->features.request_value_feature, - LV2_UI__requestValue, &jalv->features.request_value); - - zix_sem_init(&jalv->done, 0); - - zix_sem_init(&jalv->paused, 0); - zix_sem_init(&jalv->worker.sem, 0); - - /* Find all installed plugins */ - LilvWorld* world = lilv_world_new(); - lilv_world_load_all(world); - jalv->world = world; - const LilvPlugins* plugins = lilv_world_get_all_plugins(world); - - /* Cache URIs for concepts we'll use */ - jalv->nodes.atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort); - jalv->nodes.atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk); - jalv->nodes.atom_Float = lilv_new_uri(world, LV2_ATOM__Float); - jalv->nodes.atom_Path = lilv_new_uri(world, LV2_ATOM__Path); - jalv->nodes.atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence); - jalv->nodes.lv2_AudioPort = lilv_new_uri(world, LV2_CORE__AudioPort); - jalv->nodes.lv2_CVPort = lilv_new_uri(world, LV2_CORE__CVPort); - jalv->nodes.lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort); - jalv->nodes.lv2_InputPort = lilv_new_uri(world, LV2_CORE__InputPort); - jalv->nodes.lv2_OutputPort = lilv_new_uri(world, LV2_CORE__OutputPort); - jalv->nodes.lv2_connectionOptional = lilv_new_uri(world, LV2_CORE__connectionOptional); - jalv->nodes.lv2_control = lilv_new_uri(world, LV2_CORE__control); - jalv->nodes.lv2_default = lilv_new_uri(world, LV2_CORE__default); - jalv->nodes.lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration); - jalv->nodes.lv2_extensionData = lilv_new_uri(world, LV2_CORE__extensionData); - jalv->nodes.lv2_integer = lilv_new_uri(world, LV2_CORE__integer); - jalv->nodes.lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum); - jalv->nodes.lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum); - jalv->nodes.lv2_name = lilv_new_uri(world, LV2_CORE__name); - jalv->nodes.lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency); - jalv->nodes.lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate); - jalv->nodes.lv2_symbol = lilv_new_uri(world, LV2_CORE__symbol); - jalv->nodes.lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled); - jalv->nodes.midi_MidiEvent = lilv_new_uri(world, LV2_MIDI__MidiEvent); - jalv->nodes.pg_group = lilv_new_uri(world, LV2_PORT_GROUPS__group); - jalv->nodes.pprops_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic); - jalv->nodes.pprops_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI); - jalv->nodes.pprops_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps); - jalv->nodes.pset_Preset = lilv_new_uri(world, LV2_PRESETS__Preset); - jalv->nodes.pset_bank = lilv_new_uri(world, LV2_PRESETS__bank); - jalv->nodes.rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment"); - jalv->nodes.rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label"); - jalv->nodes.rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range"); - jalv->nodes.rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize); - jalv->nodes.ui_showInterface = lilv_new_uri(world, LV2_UI__showInterface); - jalv->nodes.work_interface = lilv_new_uri(world, LV2_WORKER__interface); - jalv->nodes.work_schedule = lilv_new_uri(world, LV2_WORKER__schedule); - jalv->nodes.end = NULL; - - /* Get plugin URI from loaded state or command line */ - LilvState* state = NULL; - LilvNode* plugin_uri = NULL; - if (jalv->opts.load) { - struct stat info; - stat(jalv->opts.load, &info); - if (S_ISDIR(info.st_mode)) { - char* path = jalv_strjoin(jalv->opts.load, "/state.ttl"); - state = lilv_state_new_from_file(jalv->world, &jalv->map, NULL, path); - free(path); - } else { - state = lilv_state_new_from_file(jalv->world, &jalv->map, NULL, - jalv->opts.load); - } - if (!state) { - fprintf(stderr, "Failed to load state from %s\n", jalv->opts.load); - jalv_close(jalv); - return -2; - } - plugin_uri = lilv_node_duplicate(lilv_state_get_plugin_uri(state)); - } else if (*argc > 1) { - plugin_uri = lilv_new_uri(world, (*argv)[*argc - 1]); - } - - if (!plugin_uri) { - fprintf(stderr, "Missing plugin URI, try lv2ls to list plugins\n"); - jalv_close(jalv); - return -3; - } - - /* Find plugin */ - printf("Plugin: %s\n", lilv_node_as_string(plugin_uri)); - jalv->plugin = lilv_plugins_get_by_uri(plugins, plugin_uri); - lilv_node_free(plugin_uri); - if (!jalv->plugin) { - fprintf(stderr, "Failed to find plugin\n"); - jalv_close(jalv); - return -4; - } - - /* Load preset, if specified */ - if (jalv->opts.preset) { - LilvNode* preset = lilv_new_uri(jalv->world, jalv->opts.preset); - - jalv_load_presets(jalv, NULL, NULL); - state = lilv_state_new_from_world(jalv->world, &jalv->map, preset); - jalv->preset = state; - lilv_node_free(preset); - if (!state) { - fprintf(stderr, "Failed to find preset <%s>\n", jalv->opts.preset); - jalv_close(jalv); - return -5; - } - } - - /* Check for thread-safe state restore() method. */ - LilvNode* state_threadSafeRestore = lilv_new_uri( - jalv->world, LV2_STATE__threadSafeRestore); - if (lilv_plugin_has_feature(jalv->plugin, state_threadSafeRestore)) { - jalv->safe_restore = true; - } - lilv_node_free(state_threadSafeRestore); - - if (!state) { - /* Not restoring state, load the plugin as a preset to get default */ - state = lilv_state_new_from_world( - jalv->world, &jalv->map, lilv_plugin_get_uri(jalv->plugin)); - } - - /* Get a plugin UI */ - jalv->uis = lilv_plugin_get_uis(jalv->plugin); - if (!jalv->opts.generic_ui) { - if ((jalv->ui = jalv_select_custom_ui(jalv))) { - const char* host_type_uri = jalv_native_ui_type(); - if (host_type_uri) { - LilvNode* host_type = lilv_new_uri(jalv->world, host_type_uri); - - if (!lilv_ui_is_supported(jalv->ui, - suil_ui_supported, - host_type, - &jalv->ui_type)) { - jalv->ui = NULL; - } - - lilv_node_free(host_type); - } - } - } - - /* Create ringbuffers for UI if necessary */ - if (jalv->ui) { - fprintf(stderr, "UI: %s\n", - lilv_node_as_uri(lilv_ui_get_uri(jalv->ui))); - } else { - fprintf(stderr, "UI: None\n"); - } - - /* Create port and control structures */ - jalv_create_ports(jalv); - jalv_create_controls(jalv, true); - jalv_create_controls(jalv, false); - - if (!(jalv->backend = jalv_backend_init(jalv))) { - fprintf(stderr, "Failed to connect to audio system\n"); - jalv_close(jalv); - return -6; - } - - printf("Sample rate: %u Hz\n", (uint32_t)jalv->sample_rate); - printf("Block length: %u frames\n", jalv->block_length); - printf("MIDI buffers: %zu bytes\n", jalv->midi_buf_size); - - if (jalv->opts.buffer_size == 0) { - /* The UI ring is fed by plugin output ports (usually one), and the UI - updates roughly once per cycle. The ring size is a few times the - size of the MIDI output to give the UI a chance to keep up. The UI - should be able to keep up with 4 cycles, and tests show this works - for me, but this value might need increasing to avoid overflows. - */ - jalv->opts.buffer_size = jalv->midi_buf_size * N_BUFFER_CYCLES; - } - - if (jalv->opts.update_rate == 0.0) { - /* Calculate a reasonable UI update frequency. */ - jalv->ui_update_hz = jalv_ui_refresh_rate(jalv); - } else { - /* Use user-specified UI update rate. */ - jalv->ui_update_hz = jalv->opts.update_rate; - jalv->ui_update_hz = MAX(1.0f, jalv->ui_update_hz); - } - - /* The UI can only go so fast, clamp to reasonable limits */ - jalv->ui_update_hz = MIN(60, jalv->ui_update_hz); - jalv->opts.buffer_size = MAX(4096, jalv->opts.buffer_size); - fprintf(stderr, "Comm buffers: %d bytes\n", jalv->opts.buffer_size); - fprintf(stderr, "Update rate: %.01f Hz\n", jalv->ui_update_hz); - - /* Build options array to pass to plugin */ - const LV2_Options_Option options[ARRAY_SIZE(jalv->features.options)] = { - { LV2_OPTIONS_INSTANCE, 0, jalv->urids.param_sampleRate, - sizeof(float), jalv->urids.atom_Float, &jalv->sample_rate }, - { LV2_OPTIONS_INSTANCE, 0, jalv->urids.bufsz_minBlockLength, - sizeof(int32_t), jalv->urids.atom_Int, &jalv->block_length }, - { LV2_OPTIONS_INSTANCE, 0, jalv->urids.bufsz_maxBlockLength, - sizeof(int32_t), jalv->urids.atom_Int, &jalv->block_length }, - { LV2_OPTIONS_INSTANCE, 0, jalv->urids.bufsz_sequenceSize, - sizeof(int32_t), jalv->urids.atom_Int, &jalv->midi_buf_size }, - { LV2_OPTIONS_INSTANCE, 0, jalv->urids.ui_updateRate, - sizeof(float), jalv->urids.atom_Float, &jalv->ui_update_hz }, - { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL } - }; - memcpy(jalv->features.options, options, sizeof(jalv->features.options)); - - init_feature(&jalv->features.options_feature, - LV2_OPTIONS__options, - (void*)jalv->features.options); - - init_feature(&jalv->features.safe_restore_feature, - LV2_STATE__threadSafeRestore, - NULL); - - /* Create Plugin <=> UI communication buffers */ - jalv->ui_events = zix_ring_new(jalv->opts.buffer_size); - jalv->plugin_events = zix_ring_new(jalv->opts.buffer_size); - zix_ring_mlock(jalv->ui_events); - zix_ring_mlock(jalv->plugin_events); - - /* Build feature list for passing to plugins */ - const LV2_Feature* const features[] = { - &jalv->features.map_feature, - &jalv->features.unmap_feature, - &jalv->features.sched_feature, - &jalv->features.log_feature, - &jalv->features.options_feature, - &static_features[0], - &static_features[1], - &static_features[2], - &static_features[3], - NULL - }; - jalv->feature_list = calloc(1, sizeof(features)); - if (!jalv->feature_list) { - fprintf(stderr, "Failed to allocate feature list\n"); - jalv_close(jalv); - return -7; - } - memcpy(jalv->feature_list, features, sizeof(features)); - - /* Check that any required features are supported */ - LilvNodes* req_feats = lilv_plugin_get_required_features(jalv->plugin); - LILV_FOREACH(nodes, f, req_feats) { - const char* uri = lilv_node_as_uri(lilv_nodes_get(req_feats, f)); - if (!feature_is_supported(jalv, uri)) { - fprintf(stderr, "Feature %s is not supported\n", uri); - jalv_close(jalv); - return -8; - } - } - lilv_nodes_free(req_feats); - - /* Instantiate the plugin */ - jalv->instance = lilv_plugin_instantiate( - jalv->plugin, jalv->sample_rate, jalv->feature_list); - if (!jalv->instance) { - fprintf(stderr, "Failed to instantiate plugin.\n"); - jalv_close(jalv); - return -9; - } - - jalv->features.ext_data.data_access = - lilv_instance_get_descriptor(jalv->instance)->extension_data; - - fprintf(stderr, "\n"); - if (!jalv->buf_size_set) { - jalv_allocate_port_buffers(jalv); - } - - /* Create workers if necessary */ - if (lilv_plugin_has_extension_data(jalv->plugin, jalv->nodes.work_interface)) { - const LV2_Worker_Interface* iface = (const LV2_Worker_Interface*) - lilv_instance_get_extension_data(jalv->instance, LV2_WORKER__interface); - - jalv_worker_init(jalv, &jalv->worker, iface, true); - if (jalv->safe_restore) { - jalv_worker_init(jalv, &jalv->state_worker, iface, false); - } - } - - /* Apply loaded state to plugin instance if necessary */ - if (state) { - jalv_apply_state(jalv, state); - } - - if (jalv->opts.controls) { - for (char** c = jalv->opts.controls; *c; ++c) { - jalv_apply_control_arg(jalv, *c); - } - } - - /* Create Jack ports and connect plugin ports to buffers */ - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - jalv_backend_activate_port(jalv, i); - } - - /* Print initial control values */ - for (size_t i = 0; i < jalv->controls.n_controls; ++i) { - ControlID* control = jalv->controls.controls[i]; - if (control->type == PORT && control->is_writable) { - struct Port* port = &jalv->ports[control->index]; - jalv_print_control(jalv, port, port->control); - } - } - - /* Activate plugin */ - lilv_instance_activate(jalv->instance); - - /* Discover UI */ - jalv->has_ui = jalv_discover_ui(jalv); - - /* Activate Jack */ - jalv_backend_activate(jalv); - jalv->play_state = JALV_RUNNING; - - return 0; +static LilvState* +initial_state(LilvWorld* const world, + LV2_URID_Map* const urid_map, + const char* const state_path) +{ + LilvState* state = NULL; + if (state_path) { + if (zix_file_type(state_path) == ZIX_FILE_TYPE_DIRECTORY) { + char* const path = zix_path_join(NULL, state_path, "state.ttl"); + state = lilv_state_new_from_file(world, urid_map, NULL, path); + free(path); + } else { + state = lilv_state_new_from_file(world, urid_map, NULL, state_path); + } + } + return state; } int -jalv_close(Jalv* const jalv) +jalv_open(Jalv* const jalv, int* argc, char*** argv) { - jalv->exit = true; - - fprintf(stderr, "Exiting...\n"); - - /* Terminate the worker */ - jalv_worker_finish(&jalv->worker); - - /* Deactivate audio */ - jalv_backend_deactivate(jalv); - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - if (jalv->ports[i].evbuf) { - lv2_evbuf_free(jalv->ports[i].evbuf); - } - } - jalv_backend_close(jalv); - - /* Destroy the worker */ - jalv_worker_destroy(&jalv->worker); - - /* Deactivate plugin */ -#ifdef HAVE_SUIL - suil_instance_free(jalv->ui_instance); +#if USE_SUIL + suil_init(argc, argv, SUIL_ARG_NONE); #endif - if (jalv->instance) { - lilv_instance_deactivate(jalv->instance); - lilv_instance_free(jalv->instance); - } - - /* Clean up */ - free(jalv->ports); - zix_ring_free(jalv->ui_events); - zix_ring_free(jalv->plugin_events); - for (LilvNode** n = (LilvNode**)&jalv->nodes; *n; ++n) { - lilv_node_free(*n); - } - symap_free(jalv->symap); - zix_sem_destroy(&jalv->symap_lock); -#ifdef HAVE_SUIL - suil_host_free(jalv->ui_host); + + // Parse command-line arguments + JalvFrontendArgs args = {argc, argv}; + const int ret = jalv_frontend_init(&args, &jalv->opts); + if (ret) { + return ret; + } + + JalvSettings* const settings = &jalv->settings; + + settings->block_length = 4096U; + settings->midi_buf_size = 1024U; + settings->ring_size = jalv->opts.ring_size; + settings->ui_update_hz = jalv->opts.update_rate; + settings->ui_scale_factor = jalv->opts.scale_factor; + + // Load the LV2 world + LilvWorld* const world = lilv_world_new(); + lilv_world_load_all(world); + + jalv->world = world; + jalv->mapper = jalv_mapper_new(); + jalv->log.urids = &jalv->urids; + jalv->log.tracing = jalv->opts.trace; + + // Set up atom dumping for debugging if enabled + LV2_URID_Map* const urid_map = jalv_mapper_urid_map(jalv->mapper); + LV2_URID_Unmap* const urid_unmap = jalv_mapper_urid_unmap(jalv->mapper); + if (jalv->opts.dump) { + jalv->dumper = jalv_dumper_new(urid_map, urid_unmap); + } + + zix_sem_init(&jalv->work_lock, 1); + zix_sem_init(&jalv->done, 0); + jalv_init_urids(jalv->mapper, &jalv->urids); + jalv_init_nodes(world, &jalv->nodes); + jalv_init_features(jalv); + lv2_atom_forge_init(&jalv->forge, urid_map); + + // Create temporary directory for plugin state + jalv->temp_dir = zix_create_temporary_directory(NULL, "jalvXXXXXX"); + if (!jalv->temp_dir) { + jalv_log(JALV_LOG_WARNING, "Failed to create temporary state directory\n"); + } + + // Load initial state given in options if any + LilvState* state = initial_state(world, urid_map, jalv->opts.load); + if (jalv->opts.load && !state) { + jalv_log(JALV_LOG_ERR, "Failed to load state from %s\n", jalv->opts.load); + return -2; + } + + // Get plugin URI from loaded state or command line + LilvNode* plugin_uri = NULL; + if (state) { + plugin_uri = lilv_node_duplicate(lilv_state_get_plugin_uri(state)); + } else if (*args.argc == 0) { + if (!(plugin_uri = jalv_frontend_select_plugin(jalv))) { + jalv_log(JALV_LOG_ERR, "Missing plugin URI, try lv2ls to list plugins\n"); + return -3; + } + } else if (*args.argc == 1) { + plugin_uri = lilv_new_uri(world, (*args.argv)[0]); + } else { + jalv_log(JALV_LOG_ERR, "Unexpected trailing arguments\n"); + return -1; + } + + // Find plugin + const char* const plugin_uri_str = lilv_node_as_string(plugin_uri); + const LilvPlugins* const plugins = lilv_world_get_all_plugins(world); + jalv_log(JALV_LOG_INFO, "Plugin: %s\n", plugin_uri_str); + jalv->plugin = lilv_plugins_get_by_uri(plugins, plugin_uri); + lilv_node_free(plugin_uri); + if (!jalv->plugin) { + jalv_log(JALV_LOG_ERR, "Failed to find plugin\n"); + return -4; + } + + if (!jalv->opts.name) { + jalv->opts.name = + jalv_strdup(lilv_node_as_string(lilv_plugin_get_name(jalv->plugin))); + } + + // Create workers if necessary + if (lilv_plugin_has_extension_data(jalv->plugin, + jalv->nodes.work_interface)) { + jalv->process.worker = jalv_worker_new(&jalv->work_lock, true); + jalv->features.sched.handle = jalv->process.worker; + if (jalv->safe_restore) { + jalv->process.state_worker = jalv_worker_new(&jalv->work_lock, false); + jalv->features.ssched.handle = jalv->process.state_worker; + } + } + + // Load preset, if specified + if (jalv->opts.preset) { + LilvNode* preset = lilv_new_uri(jalv->world, jalv->opts.preset); + + jalv_load_presets(jalv, NULL, NULL); + state = lilv_state_new_from_world(jalv->world, urid_map, preset); + jalv->preset = state; + lilv_node_free(preset); + if (!state) { + jalv_log(JALV_LOG_ERR, "Failed to find preset <%s>\n", jalv->opts.preset); + return -5; + } + } + + // Check for thread-safe state restore() method + jalv->safe_restore = + lilv_plugin_has_feature(jalv->plugin, jalv->nodes.state_threadSafeRestore); + + if (!state) { + // Not restoring state, load the plugin as a preset to get default + state = lilv_state_new_from_world( + jalv->world, urid_map, lilv_plugin_get_uri(jalv->plugin)); + } + + // Get a plugin UI + jalv->uis = lilv_plugin_get_uis(jalv->plugin); + if (!jalv->opts.generic_ui) { + if ((jalv->ui = jalv_select_custom_ui(jalv))) { +#if USE_SUIL + const char* host_type_uri = jalv_frontend_ui_type(); + if (host_type_uri) { + LilvNode* host_type = lilv_new_uri(jalv->world, host_type_uri); + + if (!lilv_ui_is_supported( + jalv->ui, suil_ui_supported, host_type, &jalv->ui_type)) { + jalv->ui = NULL; + } + + lilv_node_free(host_type); + } #endif - for (unsigned i = 0; i < jalv->controls.n_controls; ++i) { - ControlID* const control = jalv->controls.controls[i]; - lilv_node_free(control->node); - lilv_node_free(control->symbol); - lilv_node_free(control->label); - lilv_node_free(control->group); - lilv_node_free(control->min); - lilv_node_free(control->max); - lilv_node_free(control->def); - free(control); - } - free(jalv->controls.controls); - - if (jalv->sratom) { - sratom_free(jalv->sratom); - } - if (jalv->ui_sratom) { - sratom_free(jalv->ui_sratom); - } - lilv_uis_free(jalv->uis); - lilv_world_free(jalv->world); - - zix_sem_destroy(&jalv->done); - - remove(jalv->temp_dir); - free(jalv->temp_dir); - free(jalv->ui_event_buf); - free(jalv->feature_list); - - free(jalv->opts.name); - free(jalv->opts.uuid); - free(jalv->opts.load); - free(jalv->opts.controls); - - return 0; + jalv_log(JALV_LOG_INFO, + "UI: %s\n", + lilv_node_as_uri(lilv_ui_get_uri(jalv->ui))); + } + } + + // Initialize process thread + const uint32_t update_frames = + (uint32_t)(settings->sample_rate / settings->ui_update_hz); + jalv_process_init(&jalv->process, &jalv->urids, jalv->mapper, update_frames); + + // Create port structures + if (jalv_create_ports(jalv)) { + return -10; + } + + // Create input and output control structures + jalv_create_controls(jalv, true); + jalv_create_controls(jalv, false); + + if (jalv_backend_open(jalv->backend, + &jalv->urids, + &jalv->settings, + &jalv->process, + &jalv->done, + jalv->opts.name, + jalv->opts.name_exact)) { + jalv_log(JALV_LOG_ERR, "Failed to connect to audio system\n"); + return -6; + } + + jalv_log( + JALV_LOG_INFO, "Sample rate: %u Hz\n", (uint32_t)settings->sample_rate); + jalv_log(JALV_LOG_INFO, "Block length: %u frames\n", settings->block_length); + jalv_log(JALV_LOG_INFO, "MIDI buffers: %zu bytes\n", settings->midi_buf_size); + + jalv_init_ui_settings(jalv); + jalv_init_lv2_options(&jalv->features, &jalv->urids, settings); + + // Create Plugin => UI communication buffers + jalv->ui_msg = zix_aligned_alloc(NULL, 8U, jalv->ui_msg_size); + + // Build feature list for passing to plugins + const LV2_Feature* const features[] = {&jalv->features.map_feature, + &jalv->features.unmap_feature, + &jalv->features.sched_feature, + &jalv->features.log_feature, + &jalv->features.options_feature, + &static_features[0], + &static_features[1], + &static_features[2], + &static_features[3], + NULL}; + + jalv->feature_list = (const LV2_Feature**)calloc(1, sizeof(features)); + if (!jalv->feature_list) { + jalv_log(JALV_LOG_ERR, "Failed to allocate feature list\n"); + return -7; + } + memcpy(jalv->feature_list, features, sizeof(features)); + + // Check that any required features are supported + LilvNodes* req_feats = lilv_plugin_get_required_features(jalv->plugin); + LILV_FOREACH (nodes, f, req_feats) { + const char* uri = lilv_node_as_uri(lilv_nodes_get(req_feats, f)); + if (!feature_is_supported(jalv, uri)) { + jalv_log(JALV_LOG_ERR, "Feature %s is not supported\n", uri); + return -8; + } + } + lilv_nodes_free(req_feats); + + // Instantiate the plugin + LilvInstance* const instance = lilv_plugin_instantiate( + jalv->plugin, settings->sample_rate, jalv->feature_list); + if (!instance) { + jalv_log(JALV_LOG_ERR, "Failed to instantiate plugin\n"); + return -9; + } + + // Point things to the instance that require it + + // jalv->process.instance = instance; + jalv->features.ext_data.data_access = + lilv_instance_get_descriptor(instance)->extension_data; + + const LV2_Worker_Interface* worker_iface = + (const LV2_Worker_Interface*)lilv_instance_get_extension_data( + instance, LV2_WORKER__interface); + + jalv_worker_attach(jalv->process.worker, worker_iface, instance->lv2_handle); + jalv_worker_attach( + jalv->process.state_worker, worker_iface, instance->lv2_handle); + jalv_log(JALV_LOG_INFO, "\n"); + + // Allocate port buffers + jalv_process_activate( + &jalv->process, &jalv->urids, instance, &jalv->settings); + + // Apply loaded state to plugin instance if necessary + if (state) { + jalv_apply_state(jalv, state); + lilv_state_free(state); + } + + // Apply initial controls from command-line arguments + if (jalv->opts.controls) { + for (char** c = jalv->opts.controls; *c; ++c) { + jalv_apply_control_arg(jalv, *c); + } + } + + // Create Jack ports and connect plugin ports to buffers + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + jalv_backend_activate_port(jalv->backend, &jalv->process, i); + } + + // Discover UI + jalv->process.has_ui = jalv_frontend_discover(jalv); + return 0; } int -main(int argc, char** argv) +jalv_activate(Jalv* const jalv) { - Jalv jalv; - memset(&jalv, '\0', sizeof(Jalv)); + jalv->process.run_state = JALV_RUNNING; - if (jalv_open(&jalv, &argc, &argv)) { - return EXIT_FAILURE; - } + if (jalv->backend) { + if (jalv->process.worker) { + jalv_worker_launch(jalv->process.worker); + } + lilv_instance_activate(jalv->process.instance); + jalv_backend_activate(jalv->backend); + } - /* Set up signal handlers */ - setup_signals(&jalv); + return 0; +} - /* Run UI (or prompt at console) */ - jalv_open_ui(&jalv); +int +jalv_deactivate(Jalv* const jalv) +{ + if (jalv->backend) { + jalv_backend_deactivate(jalv->backend); + } + if (jalv->process.instance) { + lilv_instance_deactivate(jalv->process.instance); + } + if (jalv->process.worker) { + jalv_worker_exit(jalv->process.worker); + } + + jalv->process.run_state = JALV_PAUSED; + return 0; +} - /* Wait for finish signal from UI or signal handler */ - zix_sem_wait(&jalv.done); +int +jalv_close(Jalv* const jalv) +{ + // Stop audio processing, free event port buffers, and close backend + jalv_deactivate(jalv); + jalv_process_deactivate(&jalv->process); + if (jalv->backend) { + jalv_backend_close(jalv->backend); + } + + // Free UI and plugin instances +#if USE_SUIL + suil_instance_free(jalv->ui_instance); +#endif + if (jalv->process.instance) { + lilv_instance_free(jalv->process.instance); + } + + // Clean up + lilv_state_free(jalv->preset); + free(jalv->ports); + jalv_process_cleanup(&jalv->process); + zix_aligned_free(NULL, jalv->ui_msg); + free(jalv->process.controls_buf); + jalv_free_nodes(&jalv->nodes); +#if USE_SUIL + suil_host_free(jalv->ui_host); +#endif - return jalv_close(&jalv); + for (unsigned i = 0; i < jalv->controls.n_controls; ++i) { + free_control(jalv->controls.controls[i]); + } + free(jalv->controls.controls); + + jalv_dumper_free(jalv->dumper); + lilv_uis_free(jalv->uis); + jalv_mapper_free(jalv->mapper); + lilv_world_free(jalv->world); + + zix_sem_destroy(&jalv->done); + + if (jalv->temp_dir) { + // Remove temporary state directory + const ZixStatus zst = zix_remove(jalv->temp_dir); + if (zst) { + jalv_log(JALV_LOG_WARNING, + "Failed to remove temporary directory %s (%s)\n", + jalv->temp_dir, + zix_strerror(zst)); + } + } + + zix_free(NULL, jalv->temp_dir); + free(jalv->feature_list); + + free(jalv->opts.name); + free(jalv->opts.load); + free(jalv->opts.controls); + + return 0; } |