/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /*************************************************************************** * lv2.cc * * Wed Jul 13 13:50:33 CEST 2011 * Copyright 2011 Bent Bisballe Nyeng * deva@aasimon.org ****************************************************************************/ /* * This file is part of DrumGizmo. * * DrumGizmo 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 of the License, or * (at your option) any later version. * * DrumGizmo 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 DrumGizmo; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include #include #include "lv2_gui.h" #include "lv2_instance.h" #include #define MIDI_EVENT_URI "http://lv2plug.in/ns/ext/midi#MidiEvent" #define NS_ATOM "http://lv2plug.in/ns/ext/atom#" #define NS_DG "http://drumgizmo.org/lv2/atom#" /* * Stuff to handle DrumGizmo* transmission from instance to GUI. */ static LV2_DrumGizmo_Descriptor dg_descriptor; static DrumGizmo *dg_get_pci(LV2_Handle instance) { DGLV2 *dglv2 = (DGLV2 *)instance; return dglv2->dg; } /* * Stuff to save/restore plugin state. */ /* void dg_save(LV2_Handle instance, LV2_State_Store_Function store, void* callback_data, uint32_t flags, const LV2_Feature *const * features) { DGLV2 *dglv2 = (DGLV2 *)instance; printf("dg_save\n"); std::string config = dglv2->dg->configString(); printf("%s\n", config.c_str()); store(callback_data, dglv2->urimap->uri_to_id(dglv2->urimap->callback_data, NULL, NS_DG "config"), config.data(), config.length(), dglv2->urimap->uri_to_id(dglv2->urimap->callback_data, NULL, NS_ATOM "String"), LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE); } void dg_restore(LV2_Handle instance, LV2_State_Retrieve_Function retrieve, void* callback_data, uint32_t flags, const LV2_Feature *const * features) { DGLV2 *dglv2 = (DGLV2 *)instance; printf("dg_restore\n"); size_t size; uint32_t type; // uint32_t flags; const char* data = (const char*)retrieve(callback_data, dglv2->urimap->uri_to_id(dglv2->urimap->callback_data, NULL, NS_DG "config"), &size, &type, &flags); std::string config; config.append(data, size); dglv2->dg->setConfigString(config); dglv2->in->loadMidiMap(dglv2->dg->midimapfile); } */ LV2_State_Status dg_save(LV2_Handle instance, LV2_State_Store_Function store, LV2_State_Handle handle, uint32_t flags, const LV2_Feature *const * features) { DGLV2 *dglv2 = (DGLV2 *)instance; printf("dg_save\n"); std::string config = dglv2->dg->configString(); printf("%s\n", config.c_str()); store(handle, dglv2->urimap->uri_to_id(dglv2->urimap->callback_data, NULL, NS_DG "config"), config.c_str(), config.length() + 1, // Careful! Need space for terminator dglv2->urimap->uri_to_id(dglv2->urimap->callback_data, NULL, NS_ATOM "chunk"), LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE); /* MyPlugin* plugin = (MyPlugin*)instance; const char* greeting = plugin->state.greeting; store(handle, plugin->uris.my_greeting, greeting, strlen(greeting) + 1, // Careful! Need space for terminator plugin->uris.atom_String, LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE); */ printf("dg_save\n"); return LV2_STATE_SUCCESS; } LV2_State_Status dg_restore(LV2_Handle instance, LV2_State_Retrieve_Function retrieve, LV2_State_Handle handle, uint32_t flags, const LV2_Feature *const * features) { DGLV2 *dglv2 = (DGLV2 *)instance; DEBUG(lv2, "dg_restore begin\n"); size_t size; uint32_t type; // uint32_t flags; const char* data = (const char*)retrieve(handle, dglv2->urimap->uri_to_id(dglv2->urimap->callback_data, NULL, NS_DG "config"), &size, &type, &flags); DEBUG(lv2, "Config string size: %d, data*: %p\n", (int)size, data); if(data && size) { std::string config; config.append(data, size - 1); dglv2->dg->setConfigString(config); //dglv2->in->loadMidiMap(dglv2->dg->midimapfile); } /* MyPlugin* plugin = (MyPlugin*)instance; size_t size; uint32_t type; uint32_t flags; const char* greeting = retrieve( handle, plugin->uris.my_greeting, &size, &type, &flags); if (greeting) { free(plugin->state->greeting); plugin->state->greeting = strdup(greeting); } else { plugin->state->greeting = strdup(DEFAULT_GREETING); } */ DEBUG(lv2, "dg_restore done\n"); return LV2_STATE_SUCCESS; } static LV2_State_Interface dg_persist = { dg_save, dg_restore }; /** A globally unique, case-sensitive identifier for this plugin type. * * All plugins with the same URI MUST be compatible in terms of 'port * signature', meaning they have the same number of ports, same port * shortnames, and roughly the same functionality. URIs should * probably contain a version number (or similar) for this reason. * * Rationale: When serializing session/patch/etc files, hosts MUST * refer to a loaded plugin by the plugin URI only. In the future * loading a plugin with this URI MUST yield a plugin with the * same ports (etc) which is 100% compatible. */ #define DRUMGIZMO_URI "http://drumgizmo.org/lv2" /** Function pointer that instantiates a plugin. * * A handle is returned indicating the new plugin instance. The * instantiation function accepts a sample rate as a parameter as well * as the plugin descriptor from which this instantiate function was * found. This function must return NULL if instantiation fails. * * bundle_path is a string of the path to the LV2 bundle which contains * this plugin binary. It MUST include the trailing directory separator * (e.g. '/') so that BundlePath + filename gives the path to a file * in the bundle. * * features is a NULL terminated array of LV2_Feature structs which * represent the features the host supports. Plugins may refuse to * instantiate if required features are not found here (however hosts * SHOULD NOT use this as a discovery mechanism, instead reading the * data file before attempting to instantiate the plugin). This array * must always exist; if a host has no features, it MUST pass a single * element array containing NULL (to simplify plugins). * * Note that instance initialisation should generally occur in * activate() rather than here. If a host calls instantiate, it MUST * call cleanup() at some point in the future. */ LV2_Handle instantiate(const struct _LV2_Descriptor *descriptor, double sample_rate, const char *bundle_path, const LV2_Feature *const *features) { DGLV2 *dglv2 = new DGLV2; dglv2->urimap = NULL; for (int i = 0 ; features[i] ; i++) { printf("DG: feature: %s\n", features[i]->URI); if (!strcmp(features[i]->URI, LV2_URI_MAP_URI)) { dglv2->urimap = (LV2_URI_Map_Feature*)features[i]->data; } if (!strcmp(features[i]->URI, LV2_STATE__makePath)) { dglv2->makepath = (LV2_State_Make_Path*)features[i]->data; } } dg_descriptor.get_pci = dg_get_pci; dglv2->in = new InputLV2(); dglv2->out = new OutputLV2(); dglv2->buffer = NULL; dglv2->buffer_size = 0; /* char* path = dglv2->makepath->path(dglv2->makepath->handle, "hello.txt"); FILE* myfile = fopen(path, "w"); fprintf(myfile, "world"); fclose(myfile); */ dglv2->dg = new DrumGizmo(dglv2->out, dglv2->in); dglv2->dg->setSamplerate(sample_rate); // dglv2->dg->loadkit(getenv("DRUMGIZMO_DRUMKIT")); // dglv2->dg->init(true); return (LV2_Handle)dglv2; } /** Function pointer that connects a port on a plugin instance to a memory * location where the block of data for the port will be read/written. * * The data location is expected to be of the type defined in the * plugin's data file (e.g. an array of float for an lv2:AudioPort). * Memory issues are managed by the host. The plugin must read/write * the data at these locations every time run() is called, data * present at the time of this connection call MUST NOT be * considered meaningful. * * The host MUST NOT try to connect a data buffer to a port index * that is not defined in the RDF data for the plugin. If it does, * the plugin's behaviour is undefined. * * connect_port() may be called more than once for a plugin instance * to allow the host to change the buffers that the plugin is reading * or writing. These calls may be made before or after activate() * or deactivate() calls. Note that there may be realtime constraints * on connect_port (see lv2:hardRTCapable in lv2.ttl). * * connect_port() MUST be called at least once for each port before * run() is called. The plugin must pay careful attention to the block * size passed to the run function as the block allocated may only just * be large enough to contain the block of data (typically samples), and * is not guaranteed to be constant. * * Plugin writers should be aware that the host may elect to use the * same buffer for more than one port and even use the same buffer for * both input and output (see lv2:inPlaceBroken in lv2.ttl). * However, overlapped buffers or use of a single buffer for both * audio and control data may result in unexpected behaviour. * * If the plugin has the feature lv2:hardRTCapable then there are * various things that the plugin MUST NOT do within the connect_port() * function (see lv2.ttl). */ void connect_port(LV2_Handle instance, uint32_t port, void *data_location) { DGLV2 *dglv2 = (DGLV2 *)instance; if(port == 0) {// MIDI in dglv2->in->eventPort = (LV2_Event_Buffer*)data_location; } else {// Audio Port if(port - 1 < NUM_OUTPUTS) { dglv2->out->outputPorts[port - 1].samples = (sample_t*)data_location; dglv2->out->outputPorts[port - 1].size = 0; } } } /** Function pointer that initialises a plugin instance and activates * it for use. * * This is separated from instantiate() to aid real-time support and so * that hosts can reinitialise a plugin instance by calling deactivate() * and then activate(). In this case the plugin instance must reset all * state information dependent on the history of the plugin instance * except for any data locations provided by connect_port(). If there * is nothing for activate() to do then the plugin writer may provide * a NULL rather than an empty function. * * When present, hosts MUST call this function once before run() * is called for the first time. This call SHOULD be made as close * to the run() call as possible and indicates to real-time plugins * that they are now live, however plugins MUST NOT rely on a prompt * call to run() after activate(). activate() may not be called again * unless deactivate() is called first (after which activate() may be * called again, followed by deactivate, etc. etc.). If a host calls * activate, it MUST call deactivate at some point in the future. * * Note that connect_port() may be called before or after a call to * activate(). */ void activate(LV2_Handle instance) { DGLV2 *dglv2 = (DGLV2 *)instance; //dglv2->dg->run(); (void)dglv2; } /** Function pointer that runs a plugin instance for a block. * * Two parameters are required: the first is a handle to the particular * instance to be run and the second indicates the block size (in * samples) for which the plugin instance may run. * * Note that if an activate() function exists then it must be called * before run(). If deactivate() is called for a plugin instance then * the plugin instance may not be reused until activate() has been * called again. * * If the plugin has the feature lv2:hardRTCapable then there are * various things that the plugin MUST NOT do within the run() * function (see lv2.ttl). */ void run(LV2_Handle instance, uint32_t sample_count) { static size_t pos = 0; DGLV2 *dglv2 = (DGLV2 *)instance; // The buffer is not used anymore - declared NULL in 'instantiate'. /* if(dglv2->buffer_size != sample_count) { if(dglv2->buffer) free(dglv2->buffer); dglv2->buffer_size = sample_count; dglv2->buffer = (sample_t*)malloc(sizeof(sample_t) * dglv2->buffer_size); printf("(Re)allocate buffer: %d samples\n", dglv2->buffer_size); } */ dglv2->dg->run(pos, dglv2->buffer, sample_count); pos += sample_count; } /** This is the counterpart to activate() (see above). If there is * nothing for deactivate() to do then the plugin writer may provide * a NULL rather than an empty function. * * Hosts must deactivate all activated units after they have been run() * for the last time. This call SHOULD be made as close to the last * run() call as possible and indicates to real-time plugins that * they are no longer live, however plugins MUST NOT rely on prompt * deactivation. Note that connect_port() may be called before or * after a call to deactivate(). * * Note that deactivation is not similar to pausing as the plugin * instance will be reinitialised when activate() is called to reuse it. * Hosts MUST NOT call deactivate() unless activate() was previously * called. */ void deactivate(LV2_Handle instance) { DGLV2 *dglv2 = (DGLV2 *)instance; dglv2->dg->stop(); } /** This is the counterpart to instantiate() (see above). Once an instance * of a plugin has been finished with it can be deleted using this * function. The instance handle passed ceases to be valid after * this call. * * If activate() was called for a plugin instance then a corresponding * call to deactivate() MUST be made before cleanup() is called. * Hosts MUST NOT call cleanup() unless instantiate() was previously * called. */ void cleanup(LV2_Handle instance) { DGLV2 *dglv2 = (DGLV2 *)instance; delete dglv2->dg; delete dglv2->in; delete dglv2->out; } /** Function pointer that can be used to return additional instance data for * a plugin defined by some extenion (e.g. a struct containing additional * function pointers). * * The actual type and meaning of the returned object MUST be specified * precisely by the extension if it defines any extra data. If a particular * extension does not define extra instance data, this function MUST return * NULL for that extension's URI. If a plugin does not support any * extensions that define extra instance data, this function pointer may be * set to NULL rather than providing an empty function. * * The only parameter is the URI of the extension. The plugin MUST return * NULL if it does not support the extension, but hosts SHOULD NOT use this * as a discovery method (e.g. hosts should only call this function for * extensions known to be supported by the plugin from the data file). * * The host is never responsible for freeing the returned value. * * NOTE: This function should return a struct (likely containing function * pointers) and NOT a direct function pointer. Standard C and C++ do not * allow type casts from void* to a function pointer type. To provide * additional functions a struct should be returned containing the extra * function pointers (which is valid standard code, and a much better idea * for extensibility anyway). */ const void* extension_data(const char *uri) { printf("extension_data(%s)\n", uri); if(!strcmp(uri, PLUGIN_INSTANCE_URI)) return &dg_descriptor; if(!strcmp(uri, LV2_STATE__interface)) return &dg_persist; return NULL; } #ifdef __cplusplus extern "C" { #endif static const LV2_Descriptor descriptor = { DRUMGIZMO_URI, instantiate, connect_port, activate, run, deactivate, cleanup, extension_data }; LV2_SYMBOL_EXPORT const LV2_Descriptor* lv2_descriptor(uint32_t index) { switch (index) { case 0: return &descriptor; default: return NULL; } } #ifdef __cplusplus } #endif