diff options
Diffstat (limited to 'core.lv2')
| -rw-r--r-- | core.lv2/lv2.h | 468 |
1 files changed, 244 insertions, 224 deletions
diff --git a/core.lv2/lv2.h b/core.lv2/lv2.h index f1758cf..4f41bde 100644 --- a/core.lv2/lv2.h +++ b/core.lv2/lv2.h @@ -3,7 +3,7 @@ * * Copyright (C) 2000-2002 Richard W.E. Furse, Paul Barton-Davis, * Stefan Westerfeld. - * Copyright (C) 2006-2010 Steve Harris, David Robillard. + * Copyright (C) 2006-2011 Steve Harris, David Robillard. * * This header is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published @@ -21,10 +21,11 @@ * USA. */ -/** @file lv2.h - * C header for the LV2 specification <http://lv2plug.in/ns/lv2core>. - * Revision: 4 - */ +/** + @file lv2.h + API for the LV2 specification <http://lv2plug.in/ns/lv2core>. + Revision: 4 +*/ #ifndef LV2_H_INCLUDED #define LV2_H_INCLUDED @@ -35,269 +36,288 @@ extern "C" { #endif - -/** Plugin Handle. - * - * This plugin handle indicates a particular instance of the plugin - * concerned. It is valid to compare this to NULL (0 for C++) but - * otherwise the host MUST NOT attempt to interpret it. The plugin - * may use it to reference internal instance data. */ +/** + Plugin Handle. + + This handle refers to a particular instance of a plugin. It is valid to + compare to NULL (or 0 for C++) but otherwise the host MUST NOT attempt to + interpret it. The plugin may use it to reference internal instance data. +*/ typedef void * LV2_Handle; - -/** Feature data. - * - * These are passed to a plugin's instantiate method to represent a special - * feature the host has which the plugin may depend on. This is to allow - * extensions to the LV2 specification without causing any breakage. - * Extensions may specify what data needs to be passed here. The base - * LV2 specification does not define any features; hosts are not required - * to use this facility. */ +/** + Feature data. + + These are passed to a plugin's instantiate method to represent a special + feature the host has which the plugin may depend on. This allows extensions + to the plugin interface without breaking the LV2 API. Extensions that + describe a feature MUST specify the @a URI and format of @a data that needs + to be used here. The core LV2 specification does not define any features; + hosts are not required to use this facility. +*/ typedef struct _LV2_Feature { - - /** A globally unique, case-sensitive identifier for this feature. - * - * This MUST be defined in the specification of any LV2 extension which - * defines a host feature. */ + /** + A globally unique, case-sensitive identifier (URI) for this feature. + */ const char * URI; - /** Pointer to arbitrary data. - * - * This is to allow hosts to pass data to a plugin (simple values, data - * structures, function pointers, etc) as part of a 'feature'. The LV2 - * specification makes no restrictions on the contents of this data. - * The data here MUST be cleary defined by the LV2 extension which defines - * this feature. - * If no data is required, this may be set to NULL. */ + /** + Pointer to arbitrary data. + + The format of this data is defined by the extension which describes the + feature with the given @a URI. The core LV2 specification makes no + restrictions on the format of this data. If no data is required, this + may be set to NULL if the relevant extension explicitly allows this. + */ void * data; - } LV2_Feature; - -/** Descriptor for a Plugin. - * - * This structure is used to describe a plugin type. It provides a number - * of functions to instantiate it, link it to buffers and run it. */ +/** + Descriptor for an LV2 Plugin. + + This structure is used to describe a plugin. It provides the functions + necessary to instantiate and use a plugin. +*/ typedef struct _LV2_Descriptor { - - /** 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. */ + /** + 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 ports with the same symbols. + Newer versions of a plugin MAY be released with the same URI if ports are + added, as long as all such ports are "connection optional". shortnames, + and roughly the same functionality. Newer versions of a plugin that + break these rules MUST have a different URI, e.g. by appending a version + number to the previous URI. + + When referring to plugins in a persistent serialisation (e.g. session or + patch files, network protocols, etc.), hosts MUST refer to a loaded + plugin by URI only. The rules above are designed such that, in the future, + loading a plugin with this URI will yield a plugin which can be used + identically (i.e. has identical ports) (though the plugin MAY be a newer + revision with additional "connection optional" ports. + */ const char * URI; - /** 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. */ + /** + Instantiate the plugin. + + 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. + + @param descriptor Descriptor of the plugin to instantiate. + + @param sample_rate Sample rate, in Hz, for the new plugin instance. + + @param bundle_path Path to the LV2 bundle which contains this plugin + binary. It MUST include the trailing directory separator (e.g. '/') so + that simply appending a filename will give the full path to that file in + the bundle. + + @param features 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 MUST + NOT use this as a discovery mechanism: instead, use the data file to + determinate what features are required, and do not attempt to load or + instantiate unsupported plugins at all. This parameter MUST NOT be NULL, + i.e. a host that supports no features MUST pass a single element array + containing NULL. + + @return A handle for the new plugin instance, or NULL if instantiation + has failed. + */ LV2_Handle (*instantiate)(const struct _LV2_Descriptor * descriptor, double sample_rate, const char * bundle_path, const LV2_Feature *const * features); - /** 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). */ + /** + Connect a port on a plugin instance to a memory location. + + 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). + + connect_port() MUST be called at least once for each port before run() + is called, unless that port is lv2:connectionOptional. 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. + + 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. + + @param instance Plugin instance containing the port. + + @param port Index of the port to connect. The host MUST NOT try to + connect a port index that is not defined in the plugin's RDF data. If + it does, the plugin's behaviour is undefined (a crash is likely). + + @param data_location Pointer to data of the type defined by the port + type in the plugin's data file (e.g. an array of float for an + lv2:AudioPort). This pointer must be stored by the plugin instance and + used to read/write data when run() is called. Data present at the time + of the connect_port() call MUST NOT be considered meaningful. + */ void (*connect_port)(LV2_Handle instance, uint32_t port, void * data_location); - /** 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(). */ + /** + Initialise a plugin instance and activate 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 this field may be NULL. + + 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(). + + The host MUST NOT call activate() again until deactivate() has been + called first. 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 activate(). + */ void (*activate)(LV2_Handle instance); - /** 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). */ + /** + Runs a plugin instance for a block. + + Note that if an activate() function exists then it must be called before + run(). If deactivate() is called for a plugin instance then run() may + not be called 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 for details). + + @param instance Instance to be run. + + @param sample_count The block size (in samples) for which the plugin + instance must run. + */ void (*run)(LV2_Handle instance, uint32_t 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. */ + /** + Deactivate a plugin instance (counterpart to activate()). + + Hosts MUST deactivate all activated instances 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. If + there is nothing for deactivate() to do then this field may be NULL + + Deactivation is not similar to pausing since the plugin instance will be + reinitialised by activate(). However, deactivate() itself MUST NOT fully + reset plugin state. For example, the host may deactivate a plugin, then + store its state (using some extension to do so). + + Hosts MUST NOT call deactivate() unless activate() was previously + called. Note that connect_port() may be called before or after + deactivate(). + */ void (*deactivate)(LV2_Handle instance); - /** 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. */ + /** + Clean up a plugin instance (counterpart to instantiate()). + + Once an instance of a plugin has been finished with it must 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); - /** 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); + /** + Return additional plugin data defined by some extenion. + A typical use of this facility is to return a struct containing function + pointers to extend the LV2_Descriptor API. + + The actual type and meaning of the returned object MUST be specified + precisely by the extension if it defines any extra data. This function + MUST return NULL for any unsupported URI. If a plugin does not support any + extensions that define extra data, this field may be NULL. + + @param uri URI of the extension. The plugin MUST return NULL if it does + not support the extension, but hosts MUST NOT use this as a discovery + mechanism. Hosts should only call this function for extensions known to + be supported by the plugin, as described in the plugin's 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, and returning a + struct is much better since it is extensible (e.g. fields can be added + by backwards compatible extensions). + */ + const void * (*extension_data)(const char * uri); } LV2_Descriptor; +/** + Prototype for plugin accessor function. + + The exact mechanism by which plugin libraries are loaded is host and system + dependent, however all hosts need to know is the URI of the plugin they wish + to load. Plugins are discovered via data files (not by loading libraries). + Documentation on best practices for plugin discovery can be found at + <http://lv2plug.in>, however it is expected that hosts use a library to + provide this functionality. + + A plugin library MUST include a function called "lv2_descriptor" with this + prototype. This function MUST have C-style linkage (if you are using C++ + this is taken care of by the 'extern "C"' clause at the top of this file). + + A host will find the plugin's library via data files, get the + lv2_descriptor() function from it, and proceed from there. + + Plugins are accessed by index using values from 0 upwards. Out of range + indices MUST result in this function returning NULL, so the host can + enumerate plugins by increasing @a index until NULL is returned. -/** Accessing Plugins. - * - * The exact mechanism by which plugins are loaded is host and system - * dependent, however all hosts need to know is the URI of the plugin they - * wish to load. Documentation on best practices for plugin discovery can - * be found at <http://lv2plug.in>, however it is expected that hosts use - * a library to provide this functionality. - * - * A plugin programmer MUST include a function called "lv2_descriptor" - * with the following function prototype within the shared object - * file. This function will have C-style linkage (if you are using - * C++ this is taken care of by the 'extern "C"' clause at the top of - * this file). - * - * A host will find the plugin shared object file by one means or another, - * find the lv2_descriptor() function, call it, and proceed from there. - * - * Plugin types are accessed by index (not ID) using values from 0 - * upwards. Out of range indexes MUST result in this function returning - * NULL, so the plugin count can be determined by checking for the least - * index that results in NULL being returned. Index has no meaning, - * hosts MUST NOT depend on it remaining constant (e.g. when serialising) - * in any way. */ + Note that @a index has no meaning, hosts MUST NOT depend on it remaining + constant in any way. In particular, hosts MUST NOT refer to plugins by + library path and index in persistent serialisations (e.g. save files). + In other words, the index is NOT a plugin ID. +*/ const LV2_Descriptor * lv2_descriptor(uint32_t index); - -/** Datatype corresponding to the lv2_descriptor() function. */ +/** + Type of the lv2_descriptor() function in a plugin library. +*/ typedef const LV2_Descriptor * (*LV2_Descriptor_Function)(uint32_t index); - -/* Put this (LV2_SYMBOL_EXPORT) before any functions that are to be loaded - * by the host as a symbol from the dynamic library. */ +/** + Put this (LV2_SYMBOL_EXPORT) before any functions that are to be loaded + by the host as a symbol from the dynamic library. +*/ #ifdef WIN32 #define LV2_SYMBOL_EXPORT __declspec(dllexport) #else #define LV2_SYMBOL_EXPORT #endif - #ifdef __cplusplus } #endif |