bindings_test_plugin.c File Reference

#include <math.h>
#include <stdlib.h>
#include "lv2/lv2plug.in/ns/lv2core/lv2.h"

Classes
struct	Test

Macros
#define	TEST_URI   "http://example.org/lilv-bindings-test-plugin"

Enumerations
enum	PortIndex { TEST_CONTROL_IN = 0 , TEST_CONTROL_OUT = 1 , TEST_AUDIO_IN = 2 , TEST_AUDIO_OUT = 3 }

Functions
static void	run (LV2_Handle instance, uint32_t n_samples)
static void	deactivate (LV2_Handle instance)

Variables
static const LV2_Descriptor	descriptor

Macro Definition Documentation

TEST_URI

#define TEST_URI   "http://example.org/lilv-bindings-test-plugin"

Include standard C headers LV2 headers are based on the URI of the specification they come from, so a consistent convention can be used even for unofficial extensions. The URI of the core LV2 specification is http://lv2plug.in/ns/lv2core, by replacing http:/ with LV2 any header in the specification bundle can be included, in this case lv2.h. The URI is the identifier for a plugin, and how the host associates this implementation in code with its description in data. In this plugin it is only used once in the code, but defining the plugin URI at the top of the file is a good convention to follow. If this URI does not match that used in the data files, the host will fail to load the plugin.

Enumeration Type Documentation

PortIndex

enum PortIndex

In code, ports are referred to by index. An enumeration of port indices should be defined for readability.

Enumerator
TEST_CONTROL_IN
TEST_CONTROL_OUT
TEST_AUDIO_IN
TEST_AUDIO_OUT

Function Documentation

deactivate()

void deactivate ( LV2_Handle instance )

static

The deactivate() method is the counterpart to activate() called by the host after running the plugin. It indicates that the host will not call run() again until another call to activate() and is mainly useful for more advanced plugins with ``live'' characteristics such as those with auxiliary processing threads. As with activate(), this plugin has no use for this information so this method does nothing.

This method is in the ``instantiation'' threading class, so no other methods on this instance will be called concurrently with it.

run()

void run ( LV2_Handle instance, uint32_t n_samples )

static

The instantiate() function is called by the host to create a new plugin instance. The host passes the plugin descriptor, sample rate, and bundle path for plugins that need to load additional resources (e.g. waveforms). The features parameter contains host-provided features defined in LV2 extensions, but this simple plugin does not use any.

This function is in the ``instantiation'' threading class, so no other methods on this instance will be called concurrently with it. */ static LV2_Handle instantiate(const LV2_Descriptor* descriptor, double rate, const char* bundle_path, const LV2_Feature* const* features) { Test* test = (Test*)malloc(sizeof(Test));

return (LV2_Handle)test; }

/** The connect_port() method is called by the host to connect a particular port to a buffer. The plugin must store the data location, but data may not be accessed except in run().

This method is in the ``audio'' threading class, and is called in the same context as run(). */ static void connect_port(LV2_Handle instance, uint32_t port, void* data) { }

/** The activate() method is called by the host to initialise and prepare the plugin instance for running. The plugin must reset all internal state except for buffer locations set by connect_port(). Since this plugin has no other internal state, this method does nothing.

This method is in the ``instantiation'' threading class, so no other methods on this instance will be called concurrently with it. */ static void activate(LV2_Handle instance) { }

/** Process a block of audio (audio thread, must be RT safe).

Variable Documentation

descriptor

const LV2_Descriptor descriptor

static

Initial value:

                                       = {
        TEST_URI,
        instantiate,
        connect_port,
        activate,
        run,
        deactivate,
        cleanup,
        extension_data
}

Destroy a plugin instance (counterpart to instantiate()).

This method is in the ``instantiation'' threading class, so no other methods on this instance will be called concurrently with it. */ static void cleanup(LV2_Handle instance) { free(instance); }

/** The extension_data function returns any extension data supported by the plugin. Note that this is not an instance method, but a function on the plugin descriptor. It is usually used by plugins to implement additional interfaces. This plugin does not have any extension data, so this function returns NULL.

This method is in the ``discovery'' threading class, so no other functions or methods in this plugin library will be called concurrently with it. */ static const void* extension_data(const char* uri) { return NULL; }

/** Define the LV2_Descriptor for this plugin. It is best to define descriptors statically to avoid leaking memory and non-portable shared library constructors and destructors to clean up properly.