ardour/livetrax
13
0
Fork 0
Code
72e6a79b69
livetrax/libs/plugins/a-fluidsynth.lv2/a-fluidsynth.cc
Robin Gareus 1528df2f5a
Compliant LV2 state path-mapping 
lv2 state mandates that
>  The plugin MUST use this function [ absolute_path] in order to
>  actually open or otherwise use any paths loaded from plugin state.
Previously the plugin uses the value directly. Also
>  The caller is responsible for freeing the returned value with free().
is now implemented on systems other than windows (where this is not
possible, since the memory must be free()ed in the same module where it
was allocated.
2018-12-19 22:28:40 +01:00

950 lines
26 KiB
C++
Raw Blame History

/* a-fluidsynth -- simple & robust x-platform fluidsynth LV2
*
* Copyright (C) 2016 Robin Gareus <robin@gareus.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <cstring>
#include <string>
#include <algorithm>
#include <map>
#include <vector>
#include <pthread.h>
#include <stdlib.h>
#include <math.h>
#define AFS_URN "urn:ardour:a-fluidsynth"
#ifdef HAVE_LV2_1_10_0
#define x_forge_object lv2_atom_forge_object
#else
#define x_forge_object lv2_atom_forge_blank
#endif
#ifdef LV2_EXTENDED
#include "../../ardour/ardour/lv2_extensions.h"
#endif
#include "fluidsynth.h"
#include <lv2/lv2plug.in/ns/lv2core/lv2.h>
#include <lv2/lv2plug.in/ns/ext/atom/atom.h>
#include <lv2/lv2plug.in/ns/ext/atom/forge.h>
#include <lv2/lv2plug.in/ns/ext/atom/util.h>
#include <lv2/lv2plug.in/ns/ext/log/logger.h>
#include <lv2/lv2plug.in/ns/ext/midi/midi.h>
#include <lv2/lv2plug.in/ns/ext/patch/patch.h>
#include <lv2/lv2plug.in/ns/ext/state/state.h>
#include <lv2/lv2plug.in/ns/ext/urid/urid.h>
#include <lv2/lv2plug.in/ns/ext/worker/worker.h>
enum {
FS_PORT_CONTROL = 0,
FS_PORT_NOTIFY,
FS_PORT_OUT_L,
FS_PORT_OUT_R,
FS_OUT_GAIN,
FS_REV_ENABLE,
FS_REV_ROOMSIZE,
FS_REV_DAMPING,
FS_REV_WIDTH,
FS_REV_LEVEL,
FS_CHR_ENABLE,
FS_CHR_N,
FS_CHR_SPEED,
FS_CHR_DEPTH,
FS_CHR_LEVEL,
FS_CHR_TYPE,
FS_PORT_LAST
};
enum {
CMD_APPLY = 0,
CMD_FREE = 1,
};
struct BankProgram {
BankProgram (const std::string& n, int b, int p)
: name (n)
, bank (b)
, program (p)
{}
BankProgram (const BankProgram& other)
: name (other.name)
, bank (other.bank)
, program (other.program)
{}
std::string name;
int bank;
int program;
};
typedef std::vector<BankProgram> BPList;
typedef std::map<int, BPList> BPMap;
typedef std::map<int, BankProgram> BPState;
typedef struct {
/* ports */
const LV2_Atom_Sequence* control;
LV2_Atom_Sequence* notify;
float* p_ports[FS_PORT_LAST];
float v_ports[FS_PORT_LAST];
/* fluid synth */
fluid_settings_t* settings;
fluid_synth_t* synth;
int synthId;
/* lv2 URIDs */
LV2_URID atom_Blank;
LV2_URID atom_Object;
LV2_URID atom_URID;
LV2_URID atom_Path;
LV2_URID midi_MidiEvent;
LV2_URID patch_Get;
LV2_URID patch_Set;
LV2_URID patch_property;
LV2_URID patch_value;
LV2_URID state_Changed;
LV2_URID afs_sf2file;
/* lv2 extensions */
LV2_Log_Log* log;
LV2_Log_Logger logger;
LV2_Worker_Schedule* schedule;
LV2_Atom_Forge forge;
LV2_Atom_Forge_Frame sample;
#ifdef LV2_EXTENDED
LV2_Midnam* midnam;
LV2_BankPatch* bankpatch;
BPMap presets;
#endif
pthread_mutex_t bp_lock;
/* state */
bool panic;
bool initialized;
bool inform_ui;
bool send_bankpgm;
char current_sf2_file_path[1024];
char queue_sf2_file_path[1024];
bool reinit_in_progress; // set in run, cleared in work_response
bool queue_reinit; // set in restore, cleared in work_response
BankProgram program_state[16];
fluid_midi_event_t* fmidi_event;
} AFluidSynth;
/* *****************************************************************************
* helpers
*/
static bool
load_sf2 (AFluidSynth* self, const char* fn)
{
const int synth_id = fluid_synth_sfload (self->synth, fn, 1);
#ifdef LV2_EXTENDED
pthread_mutex_lock (&self->bp_lock);
self->presets.clear ();
pthread_mutex_unlock (&self->bp_lock);
#endif
if (synth_id == FLUID_FAILED) {
return false;
}
fluid_sfont_t* const sfont = fluid_synth_get_sfont_by_id (self->synth, synth_id);
if (!sfont) {
return false;
}
int chn;
fluid_preset_t *preset;
fluid_sfont_iteration_start (sfont);
pthread_mutex_lock (&self->bp_lock);
for (chn = 0; (preset = fluid_sfont_iteration_next (sfont)); ++chn) {
if (chn < 16) {
fluid_synth_program_select (self->synth, chn, synth_id,
fluid_preset_get_banknum (preset), fluid_preset_get_num (preset));
}
#ifndef LV2_EXTENDED
else { break ; }
#else
self->presets[fluid_preset_get_banknum (preset)].push_back (
BankProgram (
fluid_preset_get_name (preset),
fluid_preset_get_banknum (preset),
fluid_preset_get_num (preset)));
#endif // LV2_EXTENDED
}
pthread_mutex_unlock (&self->bp_lock);
if (chn == 0) {
return false;
}
return true;
}
static const LV2_Atom*
parse_patch_msg (AFluidSynth* self, const LV2_Atom_Object* obj)
{
const LV2_Atom* property = NULL;
const LV2_Atom* file_path = NULL;
if (obj->body.otype != self->patch_Set) {
return NULL;
}
lv2_atom_object_get (obj, self->patch_property, &property, 0);
if (!property || property->type != self->atom_URID) {
return NULL;
} else if (((const LV2_Atom_URID*)property)->body != self->afs_sf2file) {
return NULL;
}
lv2_atom_object_get (obj, self->patch_value, &file_path, 0);
if (!file_path || file_path->type != self->atom_Path) {
return NULL;
}
return file_path;
}
static void
inform_ui (AFluidSynth* self)
{
if (strlen (self->current_sf2_file_path) == 0) {
return;
}
LV2_Atom_Forge_Frame sample;
lv2_atom_forge_frame_time (&self->forge, 0);
x_forge_object (&self->forge, &sample, 1, self->patch_Set);
lv2_atom_forge_property_head (&self->forge, self->patch_property, 0);
lv2_atom_forge_urid (&self->forge, self->afs_sf2file);
lv2_atom_forge_property_head (&self->forge, self->patch_value, 0);
lv2_atom_forge_path (&self->forge, self->current_sf2_file_path, strlen (self->current_sf2_file_path));
lv2_atom_forge_pop (&self->forge, &sample);
}
static float
db_to_coeff (float db)
{
if (db <= -80) { return 0; }
else if (db >= 20) { return 10; }
return powf (10.f, .05f * db);
}
/* *****************************************************************************
* LV2 Plugin
*/
static LV2_Handle
instantiate (const LV2_Descriptor* descriptor,
double rate,
const char* bundle_path,
const LV2_Feature* const* features)
{
AFluidSynth* self = (AFluidSynth*)calloc (1, sizeof (AFluidSynth));
if (!self) {
return NULL;
}
LV2_URID_Map* map = NULL;
for (int i=0; features[i] != NULL; ++i) {
if (!strcmp (features[i]->URI, LV2_URID__map)) {
map = (LV2_URID_Map*)features[i]->data;
} else if (!strcmp (features[i]->URI, LV2_LOG__log)) {
self->log = (LV2_Log_Log*)features[i]->data;
} else if (!strcmp (features[i]->URI, LV2_WORKER__schedule)) {
self->schedule = (LV2_Worker_Schedule*)features[i]->data;
#ifdef LV2_EXTENDED
} else if (!strcmp (features[i]->URI, LV2_MIDNAM__update)) {
self->midnam = (LV2_Midnam*)features[i]->data;
} else if (!strcmp (features[i]->URI, LV2_BANKPATCH__notify)) {
self->bankpatch = (LV2_BankPatch*)features[i]->data;
#endif
}
}
lv2_log_logger_init (&self->logger, map, self->log);
if (!map) {
lv2_log_error (&self->logger, "a-fluidsynth.lv2: Host does not support urid:map\n");
free (self);
return NULL;
}
if (!self->schedule) {
lv2_log_error (&self->logger, "a-fluidsynth.lv2: Host does not support worker:schedule\n");
free (self);
return NULL;
}
/* initialize fluid synth */
self->settings = new_fluid_settings ();
if (!self->settings) {
lv2_log_error (&self->logger, "a-fluidsynth.lv2: cannot allocate Fluid Settings\n");
free (self);
return NULL;
}
fluid_settings_setnum (self->settings, "synth.sample-rate", rate);
fluid_settings_setint (self->settings, "synth.parallel-render", 1);
fluid_settings_setint (self->settings, "synth.threadsafe-api", 0);
fluid_settings_setstr (self->settings, "synth.midi-bank-select", "mma");
self->synth = new_fluid_synth (self->settings);
if (!self->synth) {
lv2_log_error (&self->logger, "a-fluidsynth.lv2: cannot allocate Fluid Synth\n");
delete_fluid_settings (self->settings);
free (self);
return NULL;
}
fluid_synth_set_gain (self->synth, 1.0f);
fluid_synth_set_polyphony (self->synth, 32);
fluid_synth_set_sample_rate (self->synth, (float)rate);
self->fmidi_event = new_fluid_midi_event ();
if (!self->fmidi_event) {
lv2_log_error (&self->logger, "a-fluidsynth.lv2: cannot allocate Fluid Event\n");
delete_fluid_synth (self->synth);
delete_fluid_settings (self->settings);
free (self);
return NULL;
}
/* initialize plugin state */
pthread_mutex_init (&self->bp_lock, NULL);
#ifdef LV2_EXTENDED
self->presets = BPMap();
#endif
self->panic = false;
self->inform_ui = false;
self->send_bankpgm = true;
self->initialized = false;
self->reinit_in_progress = false;
self->queue_reinit = false;
for (int chn = 0; chn < 16; ++chn) {
self->program_state[chn].program = -1;
}
lv2_atom_forge_init (&self->forge, map);
/* map URIDs */
self->atom_Blank = map->map (map->handle, LV2_ATOM__Blank);
self->atom_Object = map->map (map->handle, LV2_ATOM__Object);
self->atom_Path = map->map (map->handle, LV2_ATOM__Path);
self->atom_URID = map->map (map->handle, LV2_ATOM__URID);
self->midi_MidiEvent = map->map (map->handle, LV2_MIDI__MidiEvent);
self->patch_Get = map->map (map->handle, LV2_PATCH__Get);
self->patch_Set = map->map (map->handle, LV2_PATCH__Set);
self->patch_property = map->map (map->handle, LV2_PATCH__property);
self->patch_value = map->map (map->handle, LV2_PATCH__value);
self->state_Changed = map->map (map->handle, "http://lv2plug.in/ns/ext/state#StateChanged");
self->afs_sf2file = map->map (map->handle, AFS_URN ":sf2file");
return (LV2_Handle)self;
}
static void
connect_port (LV2_Handle instance,
uint32_t port,
void* data)
{
AFluidSynth* self = (AFluidSynth*)instance;
switch (port) {
case FS_PORT_CONTROL:
self->control = (const LV2_Atom_Sequence*)data;
break;
case FS_PORT_NOTIFY:
self->notify = (LV2_Atom_Sequence*)data;
break;
default:
if (port < FS_PORT_LAST) {
self->p_ports[port] = (float*)data;
}
break;
}
}
static void
deactivate (LV2_Handle instance)
{
AFluidSynth* self = (AFluidSynth*)instance;
self->panic = true;
}
static void
run (LV2_Handle instance, uint32_t n_samples)
{
AFluidSynth* self = (AFluidSynth*)instance;
if (!self->control || !self->notify) {
return;
}
const uint32_t capacity = self->notify->atom.size;
lv2_atom_forge_set_buffer (&self->forge, (uint8_t*)self->notify, capacity);
lv2_atom_forge_sequence_head (&self->forge, &self->sample, 0);
if (!self->initialized || self->reinit_in_progress) {
memset (self->p_ports[FS_PORT_OUT_L], 0, n_samples * sizeof (float));
memset (self->p_ports[FS_PORT_OUT_R], 0, n_samples * sizeof (float));
} else if (self->panic) {
fluid_synth_all_notes_off (self->synth, -1);
fluid_synth_all_sounds_off (self->synth, -1);
self->panic = false;
}
if (self->initialized && !self->reinit_in_progress) {
bool rev_change = false;
bool chr_change = false;
// TODO clamp values to ranges
if (self->v_ports[FS_OUT_GAIN] != *self->p_ports[FS_OUT_GAIN]) {
fluid_synth_set_gain (self->synth, db_to_coeff (*self->p_ports[FS_OUT_GAIN]));
}
if (self->v_ports[FS_REV_ENABLE] != *self->p_ports[FS_REV_ENABLE]) {
fluid_synth_set_reverb_on (self->synth, *self->p_ports[FS_REV_ENABLE] > 0 ? 1 : 0);
rev_change = true;
}
if (self->v_ports[FS_CHR_ENABLE] != *self->p_ports[FS_CHR_ENABLE]) {
fluid_synth_set_chorus_on (self->synth, *self->p_ports[FS_CHR_ENABLE] > 0 ? 1 : 0);
chr_change = true;
}
for (uint32_t p = FS_REV_ROOMSIZE; p <= FS_REV_LEVEL && !rev_change; ++p) {
if (self->v_ports[p] != *self->p_ports[p]) {
rev_change = true;
}
}
for (uint32_t p = FS_CHR_N; p <= FS_CHR_TYPE && !chr_change; ++p) {
if (self->v_ports[p] != *self->p_ports[p]) {
chr_change = true;
}
}
if (rev_change) {
fluid_synth_set_reverb (self->synth,
*self->p_ports[FS_REV_ROOMSIZE],
*self->p_ports[FS_REV_DAMPING],
*self->p_ports[FS_REV_WIDTH],
*self->p_ports[FS_REV_LEVEL]);
}
if (chr_change) {
fluid_synth_set_chorus (self->synth,
rintf (*self->p_ports[FS_CHR_N]),
db_to_coeff (*self->p_ports[FS_CHR_LEVEL]),
*self->p_ports[FS_CHR_SPEED],
*self->p_ports[FS_CHR_DEPTH],
(*self->p_ports[FS_CHR_TYPE] > 0) ? FLUID_CHORUS_MOD_SINE : FLUID_CHORUS_MOD_TRIANGLE);
}
for (uint32_t p = FS_OUT_GAIN; p < FS_PORT_LAST; ++p) {
self->v_ports[p] = *self->p_ports[p];
}
}
uint32_t offset = 0;
LV2_ATOM_SEQUENCE_FOREACH (self->control, ev) {
const LV2_Atom_Object* obj = (LV2_Atom_Object*)&ev->body;
if (ev->body.type == self->atom_Blank || ev->body.type == self->atom_Object) {
if (obj->body.otype == self->patch_Get) {
self->inform_ui = false;
inform_ui (self);
}
else if (obj->body.otype == self->patch_Set) {
const LV2_Atom* file_path = parse_patch_msg (self, obj);
if (file_path && !self->reinit_in_progress && !self->queue_reinit) {
const char *fn = (const char*)(file_path+1);
strncpy (self->queue_sf2_file_path, fn, 1023);
self->queue_sf2_file_path[1023] = '\0';
self->reinit_in_progress = true;
int magic = 0x4711;
self->schedule->schedule_work (self->schedule->handle, sizeof (int), &magic);
}
}
}
else if (ev->body.type == self->midi_MidiEvent) {
if (ev->body.size > 3 || ev->time.frames >= n_samples) {
continue;
}
if (ev->time.frames > offset) {
fluid_synth_write_float (
self->synth,
ev->time.frames - offset,
&self->p_ports[FS_PORT_OUT_L][offset], 0, 1,
&self->p_ports[FS_PORT_OUT_R][offset], 0, 1);
}
offset = ev->time.frames;
const uint8_t* const data = (const uint8_t*)(ev + 1);
fluid_midi_event_set_type (self->fmidi_event, data[0] & 0xf0);
fluid_midi_event_set_channel (self->fmidi_event, data[0] & 0x0f);
if (ev->body.size > 1) {
fluid_midi_event_set_key (self->fmidi_event, data[1]);
}
if (ev->body.size > 2) {
if (0xe0 /*PITCH_BEND*/ == fluid_midi_event_get_type (self->fmidi_event)) {
fluid_midi_event_set_value (self->fmidi_event, 0);
fluid_midi_event_set_pitch (self->fmidi_event, ((data[2] & 0x7f) << 7) | (data[1] & 0x7f));
} else {
fluid_midi_event_set_value (self->fmidi_event, data[2]);
}
if (0xb0 /* CC */ == fluid_midi_event_get_type (self->fmidi_event)) {
int chn = fluid_midi_event_get_channel (self->fmidi_event);
assert (chn >= 0 && chn < 16);
if (data[1] == 0x00) {
self->program_state[chn].bank &= 0x7f;
self->program_state[chn].bank |= (data[2] &0x7f) << 7;
}
if (data[1] == 0x20) {
self->program_state[chn].bank &= 0x3F80;
self->program_state[chn].bank |= data[2] & 0x7f;
}
}
}
if (ev->body.size == 2 && 0xc0 /* Pgm */ == fluid_midi_event_get_type (self->fmidi_event)) {
int chn = fluid_midi_event_get_channel (self->fmidi_event);
assert (chn >= 0 && chn < 16);
self->program_state[chn].program = data[1];
#ifdef LV2_EXTENDED
if (self->bankpatch) {
self->bankpatch->notify (self->bankpatch->handle, chn,
self->program_state[chn].bank,
self->program_state[chn].program < 0 ? 255 : self->program_state[chn].program);
}
#endif
}
fluid_synth_handle_midi_event (self->synth, self->fmidi_event);
}
}
if (self->queue_reinit && !self->reinit_in_progress) {
self->reinit_in_progress = true;
int magic = 0x4711;
self->schedule->schedule_work (self->schedule->handle, sizeof (int), &magic);
}
/* inform the GUI */
if (self->inform_ui) {
self->inform_ui = false;
/* emit stateChanged */
LV2_Atom_Forge_Frame sample;
lv2_atom_forge_frame_time(&self->forge, 0);
x_forge_object(&self->forge, &sample, 1, self->state_Changed);
lv2_atom_forge_pop(&self->forge, &sample);
/* send .sf2 filename */
inform_ui (self);
#ifdef LV2_EXTENDED
self->midnam->update (self->midnam->handle);
#endif
}
#ifdef LV2_EXTENDED
if (self->send_bankpgm && self->bankpatch) {
self->send_bankpgm = false;
for (uint8_t chn = 0; chn < 16; ++chn) {
self->bankpatch->notify (self->bankpatch->handle, chn,
self->program_state[chn].bank,
self->program_state[chn].program < 0 ? 255 : self->program_state[chn].program);
}
}
#endif
if (n_samples > offset && self->initialized && !self->reinit_in_progress) {
fluid_synth_write_float (
self->synth,
n_samples - offset,
&self->p_ports[FS_PORT_OUT_L][offset], 0, 1,
&self->p_ports[FS_PORT_OUT_R][offset], 0, 1);
}
}
static void cleanup (LV2_Handle instance)
{
AFluidSynth* self = (AFluidSynth*)instance;
delete_fluid_synth (self->synth);
delete_fluid_settings (self->settings);
delete_fluid_midi_event (self->fmidi_event);
pthread_mutex_destroy (&self->bp_lock);
free (self);
}
/* *****************************************************************************
* LV2 Extensions
*/
static LV2_Worker_Status
work (LV2_Handle instance,
LV2_Worker_Respond_Function respond,
LV2_Worker_Respond_Handle handle,
uint32_t size,
const void* data)
{
AFluidSynth* self = (AFluidSynth*)instance;
if (size != sizeof (int)) {
return LV2_WORKER_ERR_UNKNOWN;
}
int magic = *((const int*)data);
if (magic != 0x4711) {
return LV2_WORKER_ERR_UNKNOWN;
}
self->initialized = load_sf2 (self, self->queue_sf2_file_path);
if (self->initialized) {
fluid_synth_all_notes_off (self->synth, -1);
fluid_synth_all_sounds_off (self->synth, -1);
self->panic = false;
// boostrap synth engine.
float l[1024];
float r[1024];
fluid_synth_write_float (self->synth, 1024, l, 0, 1, r, 0, 1);
}
respond (handle, 1, "");
return LV2_WORKER_SUCCESS;
}
static LV2_Worker_Status
work_response (LV2_Handle instance,
uint32_t size,
const void* data)
{
AFluidSynth* self = (AFluidSynth*)instance;
if (self->initialized) {
strcpy (self->current_sf2_file_path, self->queue_sf2_file_path);
for (int chn = 0; chn < 16; ++chn) {
if (self->program_state[chn].program < 0) {
continue;
}
/* cannot direcly call fluid_channel_set_bank_msb/fluid_channel_set_bank_lsb, use CCs */
fluid_midi_event_set_type (self->fmidi_event, 0xb0 /* CC */);
fluid_midi_event_set_channel (self->fmidi_event, chn);
fluid_midi_event_set_control (self->fmidi_event, 0x00); // BANK_SELECT_MSB
fluid_midi_event_set_value (self->fmidi_event, (self->program_state[chn].bank >> 7) & 0x7f);
fluid_synth_handle_midi_event (self->synth, self->fmidi_event);
fluid_midi_event_set_control (self->fmidi_event, 0x20); // BANK_SELECT_LSB
fluid_midi_event_set_value (self->fmidi_event, self->program_state[chn].bank & 0x7f);
fluid_synth_handle_midi_event (self->synth, self->fmidi_event);
fluid_synth_program_change (self->synth, chn, self->program_state[chn].program);
}
for (int chn = 0; chn < 16; ++chn) {
int sfid = 0;
int bank = 0;
int program = -1;
if (FLUID_OK == fluid_synth_get_program (self->synth, chn, &sfid, &bank, &program)) {
self->program_state[chn].bank = bank;
self->program_state[chn].program = program;
}
}
} else {
self->current_sf2_file_path[0] = 0;
}
self->reinit_in_progress = false;
self->inform_ui = true;
self->send_bankpgm = true;
self->queue_reinit = false;
return LV2_WORKER_SUCCESS;
}
static LV2_State_Status
save (LV2_Handle instance,
LV2_State_Store_Function store,
LV2_State_Handle handle,
uint32_t flags,
const LV2_Feature* const* features)
{
AFluidSynth* self = (AFluidSynth*)instance;
if (strlen (self->current_sf2_file_path) == 0) {
return LV2_STATE_ERR_NO_PROPERTY;
}
LV2_State_Map_Path* map_path = NULL;
for (int i = 0; features[i]; ++i) {
if (!strcmp (features[i]->URI, LV2_STATE__mapPath)) {
map_path = (LV2_State_Map_Path*) features[i]->data;
}
}
if (!map_path) {
return LV2_STATE_ERR_NO_FEATURE;
}
char* apath = map_path->abstract_path (map_path->handle, self->current_sf2_file_path);
store (handle, self->afs_sf2file,
apath, strlen (apath) + 1,
self->atom_Path, LV2_STATE_IS_POD);
#ifndef _WIN32 // TODO need lilv_free() -- https://github.com/drobilla/lilv/issues/14
free (apath);
#endif
return LV2_STATE_SUCCESS;
}
static LV2_State_Status
restore (LV2_Handle instance,
LV2_State_Retrieve_Function retrieve,
LV2_State_Handle handle,
uint32_t flags,
const LV2_Feature* const* features)
{
AFluidSynth* self = (AFluidSynth*)instance;
if (self->reinit_in_progress || self->queue_reinit) {
lv2_log_warning (&self->logger, "a-fluidsynth.lv2: sf2 load already queued.\n");
return LV2_STATE_ERR_UNKNOWN;
}
LV2_State_Map_Path* map_path = NULL;
for (int i = 0; features[i]; ++i) {
if (!strcmp (features[i]->URI, LV2_STATE__mapPath)) {
map_path = (LV2_State_Map_Path*) features[i]->data;
}
}
if (!map_path) {
return LV2_STATE_ERR_NO_FEATURE;
}
size_t size;
uint32_t type;
uint32_t valflags;
const void* value = retrieve (handle, self->afs_sf2file, &size, &type, &valflags);
if (value) {
char* apath = map_path->absolute_path (map_path->handle, (const char*) value);
strncpy (self->queue_sf2_file_path, apath, 1023);
printf ("XXX %s -> %s\n", (const char*) value, apath);
self->queue_sf2_file_path[1023] = '\0';
self->queue_reinit = true;
#ifndef _WIN32 // TODO need lilv_free() -- https://github.com/drobilla/lilv/issues/14
free (apath);
#endif
}
return LV2_STATE_SUCCESS;
}
static std::string xml_escape (const std::string& s)
{
std::string r (s);
std::replace (r.begin (), r.end(), '"', '\'');
size_t pos = 0;
while((pos = r.find ("&", pos)) != std::string::npos) {
r.replace (pos, 1, "&amp;");
pos += 4;
}
return r;
}
#ifdef LV2_EXTENDED
static char*
mn_file (LV2_Handle instance)
{
AFluidSynth* self = (AFluidSynth*)instance;
char* rv = NULL;
char tmp[1024];
rv = (char*) calloc (1, sizeof (char));
#define pf(...) \
do { \
snprintf (tmp, sizeof(tmp), __VA_ARGS__); \
tmp[sizeof(tmp) - 1] = '\0'; \
rv = (char*)realloc (rv, strlen (rv) + strlen(tmp) + 1); \
strcat (rv, tmp); \
} while (0)
pf ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE MIDINameDocument PUBLIC \"-//MIDI Manufacturers Association//DTD MIDINameDocument 1.0//EN\" \"http://dev.midi.org/dtds/MIDINameDocument10.dtd\">\n"
"<MIDINameDocument>\n"
" <Author/>\n"
" <MasterDeviceNames>\n"
" <Manufacturer>Ardour Foundation</Manufacturer>\n"
" <Model>%s:%p</Model>\n", AFS_URN, (void*) self);
pf (" <CustomDeviceMode Name=\"Default\">\n");
pf (" <ChannelNameSetAssignments>\n");
for (int c = 0; c < 16; ++c) {
pf (" <ChannelNameSetAssign Channel=\"%d\" NameSet=\"Presets\"/>\n", c + 1);
}
pf (" </ChannelNameSetAssignments>\n");
pf (" </CustomDeviceMode>\n");
// TODO collect used banks, std::set<> would be a nice here
pf (" <ChannelNameSet Name=\"Presets\">\n");
pf (" <AvailableForChannels>\n");
for (int c = 0; c < 16; ++c) {
pf (" <AvailableChannel Channel=\"%d\" Available=\"true\"/>\n", c + 1);
}
pf (" </AvailableForChannels>\n");
pf (" <UsesControlNameList Name=\"Controls\"/>\n");
int bn = 1;
pthread_mutex_lock (&self->bp_lock);
const BPMap& ps (self->presets);
pthread_mutex_unlock (&self->bp_lock);
for (BPMap::const_iterator i = ps.begin (); i != ps.end (); ++i, ++bn) {
pf (" <PatchBank Name=\"Patch Bank %d\">\n", i->first);
if (i->second.size() > 0) {
pf (" <MIDICommands>\n");
pf (" <ControlChange Control=\"0\" Value=\"%d\"/>\n", (i->first >> 7) & 127);
pf (" <ControlChange Control=\"32\" Value=\"%d\"/>\n", i->first & 127);
pf (" </MIDICommands>\n");
pf (" <PatchNameList>\n");
int n = 0;
for (BPList::const_iterator j = i->second.begin(); j != i->second.end(); ++j, ++n) {
pf (" <Patch Number=\"%d\" Name=\"%s\" ProgramChange=\"%d\"/>\n",
n, xml_escape (j->name).c_str(), j->program);
}
pf (" </PatchNameList>\n");
}
pf (" </PatchBank>\n");
}
pf (" </ChannelNameSet>\n");
pf (" <ControlNameList Name=\"Controls\">\n");
pf (" <Control Type=\"7bit\" Number=\"7\" Name=\"Channel Volume\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"10\" Name=\"Pan\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"39\" Name=\"Channel Volume (Fine)\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"42\" Name=\"Pan (Fine)\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"64\" Name=\"Damper Pedal (Sustain)\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"66\" Name=\"Sostenuto\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"91\" Name=\"Reverb\"/>\n");
pf (" <Control Type=\"7bit\" Number=\"93\" Name=\"Chorus\"/>\n");
pf (" </ControlNameList>\n");
pf (
" </MasterDeviceNames>\n"
"</MIDINameDocument>"
);
//printf("-----\n%s\n------\n", rv);
return rv;
}
static char*
mn_model (LV2_Handle instance)
{
AFluidSynth* self = (AFluidSynth*)instance;
char* rv = (char*) malloc (64 * sizeof (char));
snprintf (rv, 64, "%s:%p", AFS_URN, (void*) self);
rv[63] = 0;
return rv;
}
static void
mn_free (char* v)
{
free (v);
}
#endif
static const void*
extension_data (const char* uri)
{
if (!strcmp (uri, LV2_WORKER__interface)) {
static const LV2_Worker_Interface worker = { work, work_response, NULL };
return &worker;
}
else if (!strcmp (uri, LV2_STATE__interface)) {
static const LV2_State_Interface state = { save, restore };
return &state;
}
#ifdef LV2_EXTENDED
else if (!strcmp (uri, LV2_MIDNAM__interface)) {
static const LV2_Midnam_Interface midnam = { mn_file, mn_model, mn_free };
return &midnam;
}
#endif
return NULL;
}
static const LV2_Descriptor descriptor = {
AFS_URN,
instantiate,
connect_port,
NULL,
run,
deactivate,
cleanup,
extension_data
};
#undef LV2_SYMBOL_EXPORT
#ifdef _WIN32
# define LV2_SYMBOL_EXPORT __declspec(dllexport)
#else
# define LV2_SYMBOL_EXPORT __attribute__ ((visibility ("default")))
#endif
LV2_SYMBOL_EXPORT
const LV2_Descriptor*
lv2_descriptor (uint32_t index)
{
switch (index) {
case 0:
return &descriptor;
default:
return NULL;
}
}
View Git Blame Copy Permalink