16 Apr
2008
16 Apr
'08
1:48 p.m.
This software package contains libraries and programs that should make
it easier to write LV2 plugins and GUIs.
Download it: http://ll-plugins.nongnu.org/hacking.html
Read documentation: http://ll-plugins.nongnu.org/dox/lv2-c++-tools/
Or read a nice tutorial: http://ll-plugins.nongnu.org/lv2pftci/
To build and install, run
./configure
make
su -c 'make install'
You can pass some options to configure, e.g. --prefix=/usr to install
everything in /usr (the default is /usr/local).
This is a development tool, but I'm sending it to the LAU list as well
in case there are any not-yet-hackers who would like to start writing
effects or synths. It's easy, I promise. Here's the code you would need
to write for a simple gain effect:
#include <lv2plugin.hpp>
#include "gain.peg"
class Gain : public LV2::Plugin<Gain> {
public:
Gain(double rate) : LV2::Plugin<Gain>(p_n_ports) { }
void run(uint32_t nframes) {
for (uint32_t i = 0; i < nframes; ++i)
p(p_out)[i] = p(p_gain) * p(p_in);
}
};
static int _ = Gain::register_class("http://my.plugin/");
And here's the code you would need for a GUI for a synth plugin with a
button that sends a test tone:
#include <lv2gui.hpp>
#include "mysynth.peg"
class MySynthGUI : public LV2::GUI<MySynthGUI, LV2::WriteMIDI<true> > {
public:
MySynthGUI(const std::string& URI) : m_button("Click me!") {
m_button.signal_pressed().connect(mem_fun(*this, &MySynthGUI::send_note_on));
m_button.signal_released().connect(mem_fun(*this, &MySynthGUI::send_note_off));
pack_start(m_button);
}
protected:
void send_note_on() {
uint8_t event[] = { 0x90, 0x40, 0x40 };
write_midi(p_midi, 3, event);
}
void send_note_off() {
uint8_t event[] = { 0x80, 0x40, 0x40 };
write_midi(p_midi, 3, event);
}
Gtk::Button m_button;
};
static int _ = MySynthGUI::register_class("http://my.gui/");
See? Trivial. Read more in the tutorial linked above.
--ll
16 Apr
16 Apr
2:39 p.m.
(answering to LAD only)
Luthman va escriure:
This is a development tool, but I'm sending it to
the LAU list as well
in case there are any not-yet-hackers who would like to start writing
effects or synths. It's easy, I promise. Here's the code you would need
to write for a simple gain effect:
#include <lv2plugin.hpp>
#include "gain.peg"
class Gain : public LV2::Plugin<Gain> {
public:
Gain(double rate) : LV2::Plugin<Gain>(p_n_ports) { }
void run(uint32_t nframes) {
for (uint32_t i = 0; i < nframes; ++i)
p(p_out)[i] = p(p_gain) * p(p_in);
}
};
static int _ = Gain::register_class("http://my.plugin/");
This is simple indeed.
However, this code brings me some questions. Are all variables (p,
p_out, p_in, p_gain) declared as Plugin base class members?
It does not make much sense to me that "p_gain" is a generic
control/member?
What about p_n_ports? Seems undefined to me.
( Also i assume that p(p_in) should be p(p_in)[i] )
Hmmm, i smell that gain.peg might be the answer to some of this
questions. Could you explain what goes in there?
Thanks,
Pau
2:55 p.m.
On Wed, 2008-04-16 at 18:36 +0200, Pau Arumí Albó wrote:
Luthman va escriure:
float* p(uint32_t i) is a member function of LV2::Plugin that returns
the buffer for the port with index i. LV2::Plugin handles all port
connecting (unless you override connect_port()) so some way of accessing
the buffers is needed.
LV2 plugins have two parts, code (seen above) and data, which is stored
in RDF files. These data files contain, among other things, descriptions
of the plugin's ports. In this case the plugin has three ports, one
audio input, one audio output and one control input. Each port has an
index (starting from 0 and counting upwards) and a "symbol", in this
case "in", "out", and "gain".
The symbols are for the hosts to use as nice descriptive (and
programming language friendly) identifiers for ports in e.g. scripting.
In the code for the plugin code you need to reference the ports by
index. But lv2-c++-tools contains a program called lv2peg that generates
a C header file (gain.peg in this case) from an RDF data file, with an
enum that maps port symbols to indices, like this:
enum { p_in, p_out, p_gain, p_n_ports };
"p" is a prefix that was defined in the RDF file and is used in case
someone would have data for multiple plugins in the same RDF file.
So basically it's just a more descriptive way of referencing plugin
ports. You could just as well use the indices and the number of ports
directly and don't bother with lv2peg, but it's nice to have while
working on a plugin with lots of ports where you may remove and add
ports while hacking, or change ranges and default values (those things
are also included in the output of lv2peg). There is more info and some
examples at http://lv2plug.in/lv2pftci/
You are right that is should be p(p_in)[i] instead of p(p_in).
--ll
This is a development tool, but I'm sending
it to the LAU list as well
in case there are any not-yet-hackers who would like to start writing
effects or synths. It's easy, I promise. Here's the code you would need
to write for a simple gain effect:
#include <lv2plugin.hpp>
#include "gain.peg"
class Gain : public LV2::Plugin<Gain> {
public:
Gain(double rate) : LV2::Plugin<Gain>(p_n_ports) { }
void run(uint32_t nframes) {
for (uint32_t i = 0; i < nframes; ++i)
p(p_out)[i] = p(p_gain) * p(p_in);
}
};
static int _ = Gain::register_class("http://my.plugin/");
This is simple indeed.
However, this code brings me some questions. Are all variables (p,
p_out, p_in, p_gain) declared as Plugin base class members?
It does not make much sense to me that "p_gain" is a generic
control/member?
What about p_n_ports? Seems undefined to me.
( Also i assume that p(p_in) should be p(p_in)[i] )
Hmmm, i smell that gain.peg might be the answer to some of this
questions. Could you explain what goes in there?
17 Apr
17 Apr
9:11 a.m.
El dc 16 de 04 del 2008 a les 18:55 +0200, en/na Lars Luthman va
escriure:
On Wed, 2008-04-16 at 18:36 +0200, Pau Arumí Albó
wrote:
Now it all makes sense. Thanks.
However I'd like to see the entire example (the link lv2pftci seems
dead). If available, could you point to the generated gain.peg and the
human written RDF? (Or an equivalent example)
Cheers,
Pau
Luthman va escriure:
float* p(uint32_t i) is a member function of LV2::Plugin that returns
the buffer for the port with index i. LV2::Plugin handles all port
connecting (unless you override connect_port()) so some way of accessing
the buffers is needed.
LV2 plugins have two parts, code (seen above) and data, which is stored
in RDF files. These data files contain, among other things, descriptions
of the plugin's ports. In this case the plugin has three ports, one
audio input, one audio output and one control input. Each port has an
index (starting from 0 and counting upwards) and a "symbol", in this
case "in", "out", and "gain".
The symbols are for the hosts to use as nice descriptive (and
programming language friendly) identifiers for ports in e.g. scripting.
In the code for the plugin code you need to reference the ports by
index. But lv2-c++-tools contains a program called lv2peg that generates
a C header file (gain.peg in this case) from an RDF data file, with an
enum that maps port symbols to indices, like this:
enum { p_in, p_out, p_gain, p_n_ports };
"p" is a prefix that was defined in the RDF file and is used in case
someone would have data for multiple plugins in the same RDF file.
So basically it's just a more descriptive way of referencing plugin
ports. You could just as well use the indices and the number of ports
directly and don't bother with lv2peg, but it's nice to have while
working on a plugin with lots of ports where you may remove and add
ports while hacking, or change ranges and default values (those things
are also included in the output of lv2peg). There is more info and some
examples at http://lv2plug.in/lv2pftci/
This is a development tool, but I'm sending
it to the LAU list as well
in case there are any not-yet-hackers who would like to start writing
effects or synths. It's easy, I promise. Here's the code you would need
to write for a simple gain effect:
#include <lv2plugin.hpp>
#include "gain.peg"
class Gain : public LV2::Plugin<Gain> {
public:
Gain(double rate) : LV2::Plugin<Gain>(p_n_ports) { }
void run(uint32_t nframes) {
for (uint32_t i = 0; i < nframes; ++i)
p(p_out)[i] = p(p_gain) * p(p_in);
}
};
static int _ = Gain::register_class("http://my.plugin/");
This is simple indeed.
However, this code brings me some questions. Are all variables (p,
p_out, p_in, p_gain) declared as Plugin base class members?
It does not make much sense to me that "p_gain" is a generic
control/member?
What about p_n_ports? Seems undefined to me.
( Also i assume that p(p_in) should be p(p_in)[i] )
Hmmm, i smell that gain.peg might be the answer to some of this
questions. Could you explain what goes in there?
9:26 a.m.
On Thu, 2008-04-17 at 13:08 +0200, Pau Arumí wrote:
Sorry, I got my addresses mixed up. The correct one is
http://ll-plugins.nongnu.org/lv2pftci .
For the example in the thread above the RDF would look something like
this:
@prefix lv2: <http://lv2plug.in/ns/lv2core#>.
@prefix doap: <http://usefulinc.com/ns/doap#>.
@prefix ll: <http://ll-plugins.nongnu.org/lv2/namespace#>.
<http://my.plugin/>
a lv2:Plugin;
lv2:binary <gain.so>;
doap:name "Gain";
doap:license <http://usefulinc.com/doap/licenses/gpl>;
ll:pegName "p";
lv2:port [
a lv2:AudioPort, lv2:InputPort;
lv2:index 0;
lv2:symbol "in";
lv2:name "Input";
],
[
a lv2:AudioPort, lv2:OutputPort;
lv2:index 1;
lv2:symbol "out";
lv2:name "Output";
],
[
a lv2:ControlPort, lv2:OutputPort;
lv2:index 2;
lv2:symbol "gain";
lv2:name "Gain";
].
...and lv2peg would output this:
#ifndef gain_peg
#define gain_peg
#ifndef PEG_STRUCT
#define PEG_STRUCT
typedef struct {
float min;
float max;
float default_value;
char toggled;
char integer;
char logarithmic;
} peg_data_t;
#endif
/* <http://my.plugin/> */
static const char p_uri[] = "http://my.plugin/";
enum p_port_enum {
p_in,
p_out,
p_gain,
p_n_ports
};
static const peg_data_t p_ports[] = {
{ -3.40282e+38, 3.40282e+38, -3.40282e+38, 0, 0, 0 },
{ -3.40282e+38, 3.40282e+38, -3.40282e+38, 0, 0, 0 },
{ -3.40282e+38, 3.40282e+38, -3.40282e+38, 0, 0, 0 },
};
#endif /* gain_peg */
Since no ranges or default values are given for the ports -FLT_MAX and
FLT_MAX are used, that's where the 3.40282e+38s come from.
--ll
So basically
it's just a more descriptive way of referencing plugin
ports. You could just as well use the indices and the number of ports
directly and don't bother with lv2peg, but it's nice to have while
working on a plugin with lots of ports where you may remove and add
ports while hacking, or change ranges and default values (those things
are also included in the output of lv2peg). There is more info and some
examples at http://lv2plug.in/lv2pftci/
Now it all makes sense. Thanks.
However I'd like to see the entire example (the link lv2pftci seems
dead). If available, could you point to the generated gain.peg and the
human written RDF? (Or an equivalent example)
6059
days inactive
6060
days old
linux-audio-dev@lists.linuxaudio.org
5 comments
3 participants
participants (3)
-
Lars Luthman -
Pau Arumí -
Pau Arumí Albó