mirror of
https://github.com/Ardour/ardour.git
synced 2025-12-15 19:16:40 +01:00
Implement Lua DSP processor/plugin
This commit is contained in:
Robin Gareus
parent
d8008b2db1
commit
51385ced3c
8 changed files with 1084 additions and 1 deletions
156
libs/ardour/ardour/luaproc.h
Normal file
156
libs/ardour/ardour/luaproc.h
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
Copyright (C) 2016 Robin Gareus <robin@gareus.org>
|
||||
Copyright (C) 2006 Paul Davis
|
||||
|
||||
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 of the License, 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, write to the Free Software Foundation, Inc.,
|
||||
675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef __ardour_luaproc_h__
|
||||
#define __ardour_luaproc_h__
|
||||
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#include "pbd/reallocpool.h"
|
||||
#include "pbd/stateful.h"
|
||||
|
||||
#include "ardour/types.h"
|
||||
#include "ardour/plugin.h"
|
||||
#include "ardour/luascripting.h"
|
||||
|
||||
#include "lua/luastate.h"
|
||||
#include "LuaBridge/LuaBridge.h"
|
||||
|
||||
namespace ARDOUR {
|
||||
|
||||
class LIBARDOUR_API LuaProc : public ARDOUR::Plugin {
|
||||
public:
|
||||
LuaProc (AudioEngine&, Session&, const std::string&);
|
||||
LuaProc (const LuaProc &);
|
||||
~LuaProc ();
|
||||
|
||||
/* Plugin interface */
|
||||
|
||||
std::string unique_id() const { return get_info()->unique_id; }
|
||||
const char* name() const { return get_info()->name.c_str(); }
|
||||
const char* label() const { return get_info()->name.c_str(); }
|
||||
const char* maker() const { return get_info()->creator.c_str(); }
|
||||
|
||||
uint32_t parameter_count() const;
|
||||
float default_value (uint32_t port);
|
||||
void set_parameter (uint32_t port, float val);
|
||||
float get_parameter (uint32_t port) const;
|
||||
int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const;
|
||||
uint32_t nth_parameter (uint32_t port, bool& ok) const;
|
||||
|
||||
std::string get_docs () const { return _docs; }
|
||||
std::string get_parameter_docs (uint32_t) const;
|
||||
|
||||
std::set<Evoral::Parameter> automatable() const;
|
||||
|
||||
void activate () { }
|
||||
void deactivate () { }
|
||||
void cleanup () { }
|
||||
|
||||
int set_block_size (pframes_t /*nframes*/) { return 0; }
|
||||
framecnt_t signal_latency() const { return 0; }
|
||||
|
||||
int connect_and_run (BufferSet& bufs,
|
||||
ChanMapping in, ChanMapping out,
|
||||
pframes_t nframes, framecnt_t offset);
|
||||
|
||||
std::string describe_parameter (Evoral::Parameter);
|
||||
void print_parameter (uint32_t, char*, uint32_t len) const;
|
||||
boost::shared_ptr<ScalePoints> get_scale_points(uint32_t port_index) const;
|
||||
|
||||
bool parameter_is_audio (uint32_t) const { return false; }
|
||||
bool parameter_is_control (uint32_t) const { return true; }
|
||||
bool parameter_is_input (uint32_t) const;
|
||||
bool parameter_is_output (uint32_t) const;
|
||||
|
||||
std::string state_node_name() const { return "luaproc"; }
|
||||
void add_state (XMLNode *) const;
|
||||
int set_state (const XMLNode&, int version);
|
||||
int set_script_from_state (const XMLNode&);
|
||||
|
||||
bool load_preset (PresetRecord) { return false; }
|
||||
bool has_editor() const { return false; }
|
||||
|
||||
bool can_support_io_configuration (const ChanCount& in, ChanCount& out);
|
||||
bool configure_io (ChanCount in, ChanCount out);
|
||||
|
||||
ChanCount output_streams() const { return _configured_out; }
|
||||
ChanCount input_streams() const { return _configured_in; }
|
||||
|
||||
std::string do_save_preset (std::string) { return ""; }
|
||||
void do_remove_preset (std::string) { }
|
||||
|
||||
|
||||
private:
|
||||
void find_presets () { }
|
||||
|
||||
/* END Plugin interface */
|
||||
protected:
|
||||
const std::string& script() const { return _script; }
|
||||
|
||||
private:
|
||||
PBD::ReallocPool _mempool;
|
||||
LuaState lua;
|
||||
luabridge::LuaRef * _lua_dsp;
|
||||
luabridge::LuaRef * _lua_params;
|
||||
std::string _script;
|
||||
std::string _docs;
|
||||
bool _lua_does_channelmapping;
|
||||
|
||||
void init ();
|
||||
bool load_script ();
|
||||
void lua_print (std::string s);
|
||||
|
||||
std::vector<std::pair<bool, int> > _ctrl_params;
|
||||
float* _control_data;
|
||||
float* _shadow_data;
|
||||
|
||||
ChanCount _configured_in;
|
||||
ChanCount _configured_out;
|
||||
|
||||
bool _has_midi_input;
|
||||
bool _has_midi_output;
|
||||
|
||||
#ifdef WITH_LUAPROC_STATS
|
||||
int64_t _stats_avg[2];
|
||||
int64_t _stats_max[2];
|
||||
int64_t _stats_cnt;
|
||||
#endif
|
||||
};
|
||||
|
||||
class LIBARDOUR_API LuaPluginInfo : public PluginInfo
|
||||
{
|
||||
public:
|
||||
LuaPluginInfo (LuaScriptInfoPtr lsi);
|
||||
~LuaPluginInfo () { };
|
||||
|
||||
PluginPtr load (Session& session);
|
||||
std::vector<Plugin::PresetRecord> get_presets (bool user_only) const;
|
||||
|
||||
bool is_instrument () const { return false; }
|
||||
bool reconfigurable_io() const { return true; }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<LuaPluginInfo> LuaPluginInfoPtr;
|
||||
|
||||
} // namespace ARDOUR
|
||||
|
||||
#endif // __ardour_luaproc_h__
|
||||
|
|
@ -28,6 +28,7 @@ namespace ARDOUR {
|
|||
LV2,
|
||||
Windows_VST,
|
||||
LXVST,
|
||||
Lua,
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
897
libs/ardour/luaproc.cc
Normal file
897
libs/ardour/luaproc.cc
Normal file
|
|
@ -0,0 +1,897 @@
|
|||
/*
|
||||
Copyright (C) 2016 Robin Gareus <robin@gareus.org>
|
||||
Copyright (C) 2006 Paul Davis
|
||||
|
||||
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 of the License, 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, write to the Free Software Foundation, Inc.,
|
||||
675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <glib.h>
|
||||
#include "pbd/gstdio_compat.h"
|
||||
|
||||
#include "pbd/pthread_utils.h"
|
||||
|
||||
#include "ardour/audio_buffer.h"
|
||||
#include "ardour/buffer_set.h"
|
||||
#include "ardour/luabindings.h"
|
||||
#include "ardour/luaproc.h"
|
||||
#include "ardour/luascripting.h"
|
||||
#include "ardour/midi_buffer.h"
|
||||
#include "ardour/plugin.h"
|
||||
#include "ardour/session.h"
|
||||
|
||||
#include "i18n.h"
|
||||
|
||||
using namespace ARDOUR;
|
||||
using namespace PBD;
|
||||
|
||||
LuaProc::LuaProc (AudioEngine& engine,
|
||||
Session& session,
|
||||
const std::string &script)
|
||||
: Plugin (engine, session)
|
||||
, _mempool ("LuaProc", 1048576) // 1 MB is plenty. (64K would be enough)
|
||||
, lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
|
||||
, _lua_dsp (0)
|
||||
, _lua_params (0)
|
||||
, _script (script)
|
||||
, _lua_does_channelmapping (false)
|
||||
, _control_data (0)
|
||||
, _shadow_data (0)
|
||||
, _has_midi_input (false)
|
||||
, _has_midi_output (false)
|
||||
{
|
||||
init ();
|
||||
|
||||
/* when loading a session, or pasing a processor,
|
||||
* the script is set during set_state();
|
||||
*/
|
||||
if (!_script.empty () && load_script ()) {
|
||||
throw failed_constructor ();
|
||||
}
|
||||
}
|
||||
|
||||
LuaProc::LuaProc (const LuaProc &other)
|
||||
: Plugin (other)
|
||||
, _mempool ("LuaProc", 1048576) // 1 MB is plenty. (64K would be enough)
|
||||
, lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
|
||||
, _lua_dsp (0)
|
||||
, _lua_params (0)
|
||||
, _script (other.script ())
|
||||
, _lua_does_channelmapping (false)
|
||||
, _control_data (0)
|
||||
, _shadow_data (0)
|
||||
, _has_midi_input (false)
|
||||
, _has_midi_output (false)
|
||||
{
|
||||
init ();
|
||||
|
||||
if (load_script ()) {
|
||||
throw failed_constructor ();
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < parameter_count (); ++i) {
|
||||
_control_data[i] = other._shadow_data[i];
|
||||
_shadow_data[i] = other._shadow_data[i];
|
||||
}
|
||||
}
|
||||
|
||||
LuaProc::~LuaProc () {
|
||||
#ifdef WITH_LUAPROC_STATS
|
||||
if (_info && _stats_cnt > 0) {
|
||||
printf ("LuaProc: '%s' run() avg: %.3f max: %.3f [ms]\n",
|
||||
_info->name.c_str (),
|
||||
0.0001f * _stats_avg[0] / (float) _stats_cnt,
|
||||
0.0001f * _stats_max[0]);
|
||||
printf ("LuaProc: '%s' gc() avg: %.3f max: %.3f [ms]\n",
|
||||
_info->name.c_str (),
|
||||
0.0001f * _stats_avg[1] / (float) _stats_cnt,
|
||||
0.0001f * _stats_max[1]);
|
||||
}
|
||||
#endif
|
||||
lua.do_command ("collectgarbage();");
|
||||
delete (_lua_dsp);
|
||||
delete (_lua_params);
|
||||
delete [] _control_data;
|
||||
delete [] _shadow_data;
|
||||
}
|
||||
|
||||
void
|
||||
LuaProc::init ()
|
||||
{
|
||||
#ifdef WITH_LUAPROC_STATS
|
||||
_stats_avg[0] = _stats_avg[1] = _stats_max[0] = _stats_max[1] = _stats_cnt = 0;
|
||||
#endif
|
||||
|
||||
#ifndef NDEBUG
|
||||
lua.Print.connect (sigc::mem_fun (*this, &LuaProc::lua_print));
|
||||
#endif
|
||||
// register session object
|
||||
lua_State* L = lua.getState ();
|
||||
LuaBindings::stddef (L);
|
||||
LuaBindings::common (L);
|
||||
LuaBindings::dsp (L);
|
||||
|
||||
// add session to global lua namespace
|
||||
luabridge::push <Session *> (L, &_session);
|
||||
lua_setglobal (L, "Session");
|
||||
|
||||
// sandbox
|
||||
lua.do_command ("io = nil os = nil loadfile = nil require = nil dofile = nil package = nil debug = nil");
|
||||
#if 0
|
||||
lua.do_command ("for n in pairs(_G) do print(n) end print ('----')"); // print global env
|
||||
#endif
|
||||
lua.do_command ("function ardour () end");
|
||||
}
|
||||
|
||||
void
|
||||
LuaProc::lua_print (std::string s) {
|
||||
std::cout <<"LuaProc: " << s << "\n";
|
||||
}
|
||||
|
||||
bool
|
||||
LuaProc::load_script ()
|
||||
{
|
||||
assert (!_lua_dsp); // don't allow to re-initialize
|
||||
|
||||
// TODO: refine APIs; function arguments..
|
||||
// - perform channel-map in ardour (silent/scratch buffers) ?
|
||||
// - control-port API (explicit get/set functions ??)
|
||||
// - latency reporting (global var? ctrl-port? set-function ?)
|
||||
// - MIDI -> sparse table of events
|
||||
// { [sample] => { Event }, .. }
|
||||
// or { { sample, Event }, .. }
|
||||
|
||||
try {
|
||||
LuaScriptInfoPtr lsi = LuaScripting::script_info (_script);
|
||||
LuaPluginInfoPtr lpi (new LuaPluginInfo (lsi));
|
||||
assert (lpi);
|
||||
set_info (lpi);
|
||||
_mempool.set_name ("LuaProc: " + lsi->name);
|
||||
_docs = lsi->description;
|
||||
} catch (failed_constructor& err) {
|
||||
return true;
|
||||
}
|
||||
|
||||
lua_State* L = lua.getState ();
|
||||
lua.do_command (_script);
|
||||
|
||||
// check if script has a DSP callback
|
||||
luabridge::LuaRef lua_dsp_run = luabridge::getGlobal (L, "dsp_run");
|
||||
luabridge::LuaRef lua_dsp_map = luabridge::getGlobal (L, "dsp_runmap");
|
||||
|
||||
if ((lua_dsp_run.type () != LUA_TFUNCTION) == (lua_dsp_map.type () != LUA_TFUNCTION)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (lua_dsp_run.type () == LUA_TFUNCTION) {
|
||||
_lua_dsp = new luabridge::LuaRef (lua_dsp_run);
|
||||
}
|
||||
else if (lua_dsp_map.type () == LUA_TFUNCTION) {
|
||||
_lua_dsp = new luabridge::LuaRef (lua_dsp_map);
|
||||
_lua_does_channelmapping = true;
|
||||
}
|
||||
else {
|
||||
assert (0);
|
||||
}
|
||||
|
||||
// initialize the DSP if needed
|
||||
luabridge::LuaRef lua_dsp_init = luabridge::getGlobal (L, "dsp_init");
|
||||
if (lua_dsp_init.type () == LUA_TFUNCTION) {
|
||||
try {
|
||||
lua_dsp_init (_session.nominal_frame_rate ());
|
||||
} catch (luabridge::LuaException const& e) {
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
luabridge::LuaRef lua_dsp_midi_in = luabridge::getGlobal (L, "dsp_midi_input");
|
||||
if (lua_dsp_midi_in.type () == LUA_TFUNCTION) {
|
||||
try {
|
||||
_has_midi_input = lua_dsp_midi_in ();
|
||||
} catch (luabridge::LuaException const& e) {
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
_ctrl_params.clear ();
|
||||
|
||||
luabridge::LuaRef lua_params = luabridge::getGlobal (L, "dsp_params");
|
||||
if (lua_params.isFunction ()) {
|
||||
|
||||
// call function // add try {} catch (luabridge::LuaException const& e)
|
||||
luabridge::LuaRef params = lua_params ();
|
||||
|
||||
if (params.isTable ()) {
|
||||
|
||||
_lua_params = new luabridge::LuaRef (params);
|
||||
|
||||
for (luabridge::Iterator i (params); !i.isNil (); ++i) {
|
||||
// required fields
|
||||
if (!i.key ().isNumber ()) { return false; }
|
||||
if (!i.value ().isTable ()) { return false; }
|
||||
if (!i.value ()["type"].isString ()) { return false; }
|
||||
if (!i.value ()["name"].isString ()) { return false; }
|
||||
if (!i.value ()["min"].isNumber ()) { return false; }
|
||||
if (!i.value ()["max"].isNumber ()) { return false; }
|
||||
|
||||
std::string type = i.value ()["type"].cast<std::string> ();
|
||||
if (type == "input") {
|
||||
if (!i.value ()["default"].isNumber ()) { return false; }
|
||||
_ctrl_params.push_back (std::make_pair (false, i.key ().cast<int> ()));
|
||||
}
|
||||
else if (type == "output") {
|
||||
_ctrl_params.push_back (std::make_pair (true, i.key ().cast<int> ()));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
assert (i.key ().cast<int> () == (int) _ctrl_params.size ());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_control_data = new float[parameter_count ()];
|
||||
_shadow_data = new float[parameter_count ()];
|
||||
|
||||
for (uint32_t i = 0; i < parameter_count (); ++i) {
|
||||
if (parameter_is_input (i)) {
|
||||
_control_data[i] = _shadow_data[i] = default_value (i);
|
||||
}
|
||||
}
|
||||
|
||||
// expose ctrl-ports to global lua namespace
|
||||
luabridge::push <float *> (L, _control_data);
|
||||
lua_setglobal (L, "CtrlPorts");
|
||||
|
||||
return false; // no error
|
||||
}
|
||||
|
||||
bool
|
||||
LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
|
||||
{
|
||||
if (in.n_midi() > 0 && !_has_midi_input) {
|
||||
return false;
|
||||
}
|
||||
|
||||
lua_State* L = lua.getState ();
|
||||
luabridge::LuaRef ioconfig = luabridge::getGlobal (L, "dsp_ioconfig");
|
||||
if (!ioconfig.isFunction ()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
luabridge::LuaRef table = luabridge::getGlobal (L, "table"); //lua std lib
|
||||
luabridge::LuaRef tablesort = table["sort"];
|
||||
assert (tablesort.isFunction ());
|
||||
|
||||
luabridge::LuaRef *_iotable = NULL; // can't use reference :(
|
||||
try {
|
||||
luabridge::LuaRef iotable = ioconfig ();
|
||||
tablesort (iotable);
|
||||
if (iotable.isTable ()) {
|
||||
_iotable = new luabridge::LuaRef (iotable);
|
||||
}
|
||||
} catch (luabridge::LuaException const& e) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!_iotable) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// now we can reference it.
|
||||
luabridge::LuaRef iotable (*_iotable);
|
||||
delete _iotable;
|
||||
|
||||
if ((iotable).length () < 1) {
|
||||
return false;
|
||||
}
|
||||
|
||||
int32_t audio_in = in.n_audio ();
|
||||
int32_t audio_out;
|
||||
|
||||
if (in.n_midi() > 0 && audio_in == 0) {
|
||||
audio_out = 2; // prefer stereo version if available.
|
||||
} else {
|
||||
audio_out = audio_in;
|
||||
}
|
||||
|
||||
for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
|
||||
assert (i.value ().type () == LUA_TTABLE);
|
||||
luabridge::LuaRef io (i.value ());
|
||||
|
||||
int possible_in = io["audio_in"];
|
||||
int possible_out = io["audio_out"];
|
||||
|
||||
// exact match
|
||||
if ((possible_in == audio_in) && (possible_out == audio_out)) {
|
||||
out.set (DataType::MIDI, 0);
|
||||
out.set (DataType::AUDIO, audio_out);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/* now allow potentially "imprecise" matches */
|
||||
audio_out = -1;
|
||||
bool found = false;
|
||||
|
||||
for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
|
||||
assert (i.value ().type () == LUA_TTABLE);
|
||||
luabridge::LuaRef io (i.value ());
|
||||
|
||||
int possible_in = io["audio_in"];
|
||||
int possible_out = io["audio_out"];
|
||||
|
||||
if (possible_out == 0) {
|
||||
continue;
|
||||
}
|
||||
if (possible_in == 0) {
|
||||
/* no inputs, generators & instruments */
|
||||
if (possible_out == -1) {
|
||||
/* any configuration possible, provide stereo output */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else if (possible_out == -2) {
|
||||
/* invalid, should be (0, -1) */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else if (possible_out < -2) {
|
||||
/* variable number of outputs. -> whatever */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else {
|
||||
/* exact number of outputs */
|
||||
audio_out = possible_out;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (possible_in == -1) {
|
||||
/* wildcard for input */
|
||||
if (possible_out == -1) {
|
||||
/* out much match in */
|
||||
audio_out = audio_in;
|
||||
found = true;
|
||||
} else if (possible_out == -2) {
|
||||
/* any configuration possible, pick matching */
|
||||
audio_out = audio_in;
|
||||
found = true;
|
||||
} else if (possible_out < -2) {
|
||||
/* explicitly variable number of outputs, pick maximum */
|
||||
audio_out = -possible_out;
|
||||
found = true;
|
||||
} else {
|
||||
/* exact number of outputs */
|
||||
audio_out = possible_out;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (possible_in == -2) {
|
||||
|
||||
if (possible_out == -1) {
|
||||
/* any configuration possible, pick matching */
|
||||
audio_out = audio_in;
|
||||
found = true;
|
||||
} else if (possible_out == -2) {
|
||||
/* invalid. interpret as (-1, -1) */
|
||||
audio_out = audio_in;
|
||||
found = true;
|
||||
} else if (possible_out < -2) {
|
||||
/* explicitly variable number of outputs, pick maximum */
|
||||
audio_out = -possible_out;
|
||||
found = true;
|
||||
} else {
|
||||
/* exact number of outputs */
|
||||
audio_out = possible_out;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (possible_in < -2) {
|
||||
/* explicit variable number of inputs */
|
||||
if (audio_in > -possible_in) {
|
||||
/* request is too large */
|
||||
}
|
||||
if (possible_out == -1) {
|
||||
/* any output configuration possible, provide stereo out */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else if (possible_out == -2) {
|
||||
/* invalid. interpret as (<-2, -1) */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else if (possible_out < -2) {
|
||||
/* explicitly variable number of outputs, pick stereo */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else {
|
||||
/* exact number of outputs */
|
||||
audio_out = possible_out;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (possible_in && (possible_in == audio_in)) {
|
||||
/* exact number of inputs ... must match obviously */
|
||||
if (possible_out == -1) {
|
||||
/* any output configuration possible, provide stereo output */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else if (possible_out == -2) {
|
||||
/* invalid. interpret as (>0, -1) */
|
||||
audio_out = 2;
|
||||
found = true;
|
||||
} else if (possible_out < -2) {
|
||||
/* explicitly variable number of outputs, pick maximum */
|
||||
audio_out = -possible_out;
|
||||
found = true;
|
||||
} else {
|
||||
/* exact number of outputs */
|
||||
audio_out = possible_out;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (found) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) {
|
||||
return false;
|
||||
}
|
||||
|
||||
out.set (DataType::MIDI, 0);
|
||||
out.set (DataType::AUDIO, audio_out);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
LuaProc::configure_io (ChanCount in, ChanCount out)
|
||||
{
|
||||
_configured_in = in;
|
||||
_configured_out = out;
|
||||
|
||||
_configured_in.set (DataType::MIDI, _has_midi_input ? 1 : 0);
|
||||
_configured_out.set (DataType::MIDI, _has_midi_output ? 1 : 0);
|
||||
|
||||
// configure the DSP if needed
|
||||
lua_State* L = lua.getState ();
|
||||
luabridge::LuaRef lua_dsp_configure = luabridge::getGlobal (L, "dsp_configure");
|
||||
if (lua_dsp_configure.type () == LUA_TFUNCTION) {
|
||||
try {
|
||||
lua_dsp_configure (&in, &out);
|
||||
} catch (luabridge::LuaException const& e) {
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
_info->n_inputs = _configured_in;
|
||||
_info->n_outputs = _configured_out;
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
LuaProc::connect_and_run (BufferSet& bufs,
|
||||
ChanMapping in, ChanMapping out,
|
||||
pframes_t nframes, framecnt_t offset)
|
||||
{
|
||||
if (!_lua_dsp) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Plugin::connect_and_run (bufs, in, out, nframes, offset);
|
||||
|
||||
// This is needed for ARDOUR::Session requests :(
|
||||
if (! SessionEvent::has_per_thread_pool ()) {
|
||||
char name[64];
|
||||
snprintf (name, 64, "Proc-%p", this);
|
||||
pthread_set_name (name);
|
||||
SessionEvent::create_per_thread_pool (name, 64);
|
||||
PBD::notify_event_loops_about_thread_creation (pthread_self(), name, 64);
|
||||
}
|
||||
|
||||
uint32_t const n = parameter_count ();
|
||||
for (uint32_t i = 0; i < n; ++i) {
|
||||
if (parameter_is_control (i) && parameter_is_input (i)) {
|
||||
_control_data[i] = _shadow_data[i];
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef WITH_LUAPROC_STATS
|
||||
int64_t t0 = g_get_monotonic_time ();
|
||||
#endif
|
||||
|
||||
try {
|
||||
if (_lua_does_channelmapping) {
|
||||
// run the DSP function
|
||||
(*_lua_dsp)(&bufs, in, out, nframes, offset);
|
||||
} else {
|
||||
// map buffers
|
||||
BufferSet& silent_bufs = _session.get_silent_buffers (ChanCount (DataType::AUDIO, 1));
|
||||
BufferSet& scratch_bufs = _session.get_scratch_buffers (ChanCount (DataType::AUDIO, 1));
|
||||
|
||||
lua_State* L = lua.getState ();
|
||||
luabridge::LuaRef in_map (luabridge::newTable (L));
|
||||
luabridge::LuaRef out_map (luabridge::newTable (L));
|
||||
|
||||
const uint32_t audio_in = _configured_in.n_audio ();
|
||||
const uint32_t audio_out = _configured_out.n_audio ();
|
||||
const uint32_t midi_in = _configured_in.n_midi ();
|
||||
|
||||
for (uint32_t ap = 0; ap < audio_in; ++ap) {
|
||||
bool valid;
|
||||
const uint32_t buf_index = in.get(DataType::AUDIO, ap, &valid);
|
||||
if (valid) {
|
||||
in_map[ap + 1] = bufs.get_audio (buf_index).data (offset);
|
||||
} else {
|
||||
in_map[ap + 1] = silent_bufs.get_audio (0).data (offset);
|
||||
}
|
||||
}
|
||||
for (uint32_t ap = 0; ap < audio_out; ++ap) {
|
||||
bool valid;
|
||||
const uint32_t buf_index = out.get(DataType::AUDIO, ap, &valid);
|
||||
if (valid) {
|
||||
out_map[ap + 1] = bufs.get_audio (buf_index).data (offset);
|
||||
} else {
|
||||
out_map[ap + 1] = scratch_bufs.get_audio (0).data (offset);
|
||||
}
|
||||
}
|
||||
|
||||
luabridge::LuaRef lua_midi_tbl (luabridge::newTable (L));
|
||||
int e = 1; // > 1 port, we merge events (unsorted)
|
||||
for (uint32_t mp = 0; mp < midi_in; ++mp) {
|
||||
bool valid;
|
||||
const uint32_t idx = in.get(DataType::MIDI, mp, &valid);
|
||||
if (valid) {
|
||||
for (MidiBuffer::iterator m = bufs.get_midi(idx).begin();
|
||||
m != bufs.get_midi(idx).end(); ++m, ++e) {
|
||||
const Evoral::MIDIEvent<framepos_t> ev(*m, false);
|
||||
luabridge::LuaRef lua_midi_data (luabridge::newTable (L));
|
||||
const uint8_t* data = ev.buffer();
|
||||
for (uint32_t i = 0; i < ev.size(); ++i) {
|
||||
lua_midi_data [i + 1] = data[i];
|
||||
}
|
||||
luabridge::LuaRef lua_midi_event (luabridge::newTable (L));
|
||||
lua_midi_event["time"] = 1 + (*m).time();
|
||||
lua_midi_event["data"] = lua_midi_data;
|
||||
lua_midi_tbl[e] = lua_midi_event;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (_has_midi_input) {
|
||||
// XXX TODO This needs a better solution than global namespace
|
||||
luabridge::push (L, lua_midi_tbl);
|
||||
lua_setglobal (L, "mididata");
|
||||
}
|
||||
|
||||
|
||||
// run the DSP function
|
||||
(*_lua_dsp)(in_map, out_map, nframes);
|
||||
}
|
||||
} catch (luabridge::LuaException const& e) {
|
||||
#ifndef NDEBUG
|
||||
printf ("LuaException: %s\n", e.what ());
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
#ifdef WITH_LUAPROC_STATS
|
||||
int64_t t1 = g_get_monotonic_time ();
|
||||
#endif
|
||||
lua.collect_garbage (); // rt-safe, slight *regular* performance overhead
|
||||
#ifdef WITH_LUAPROC_STATS
|
||||
++_stats_cnt;
|
||||
int64_t t2 = g_get_monotonic_time ();
|
||||
int64_t ela0 = t1 - t0;
|
||||
int64_t ela1 = t2 - t1;
|
||||
if (ela0 > _stats_max[0]) _stats_max[0] = ela0;
|
||||
if (ela1 > _stats_max[1]) _stats_max[1] = ela1;
|
||||
_stats_avg[0] += ela0;
|
||||
_stats_avg[1] += ela1;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
LuaProc::add_state (XMLNode* root) const
|
||||
{
|
||||
gchar* b64 = g_base64_encode ((const guchar*)_script.c_str (), _script.size ());
|
||||
std::string b64s (b64);
|
||||
g_free (b64);
|
||||
XMLNode* script_node = new XMLNode (X_("script"));
|
||||
script_node->add_property (X_("lua"), LUA_VERSION);
|
||||
script_node->add_content (b64s);
|
||||
root->add_child_nocopy (*script_node);
|
||||
}
|
||||
|
||||
int
|
||||
LuaProc::set_script_from_state (const XMLNode& node)
|
||||
{
|
||||
XMLNode* child;
|
||||
if (node.name () != state_node_name ()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((child = node.child (X_("script"))) != 0) {
|
||||
for (XMLNodeList::const_iterator n = child->children ().begin (); n != child->children ().end (); ++n) {
|
||||
if (!(*n)->is_content ()) { continue; }
|
||||
gsize size;
|
||||
guchar* buf = g_base64_decode ((*n)->content ().c_str (), &size);
|
||||
_script = std::string ((const char*)buf, size);
|
||||
g_free (buf);
|
||||
if (load_script ()) {
|
||||
PBD::error << _("Failed to load Lua script from session state.") << endmsg;
|
||||
#ifndef NDEBUG
|
||||
std::cerr << "Failed Lua Script: " << _script << std::endl;
|
||||
#endif
|
||||
_script = "";
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (_script.empty ()) {
|
||||
PBD::error << _("Session State for LuaProcessor did not include a Lua script.") << endmsg;
|
||||
return -1;
|
||||
}
|
||||
if (!_lua_dsp) {
|
||||
PBD::error << _("Invalid/incompatible Lua script found for LuaProcessor.") << endmsg;
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
LuaProc::set_state (const XMLNode& node, int version)
|
||||
{
|
||||
if (_script.empty ()) {
|
||||
if (set_script_from_state (node)) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
return Plugin::set_state (node, version);
|
||||
}
|
||||
|
||||
uint32_t
|
||||
LuaProc::parameter_count () const
|
||||
{
|
||||
return _ctrl_params.size ();
|
||||
}
|
||||
|
||||
float
|
||||
LuaProc::default_value (uint32_t port)
|
||||
{
|
||||
if (_ctrl_params[port].first) {
|
||||
assert (0);
|
||||
return 0;
|
||||
}
|
||||
int lp = _ctrl_params[port].second;
|
||||
luabridge::LuaRef lr = (*_lua_params)[lp];
|
||||
return (lr["default"]).cast<float> ();
|
||||
}
|
||||
|
||||
void
|
||||
LuaProc::set_parameter (uint32_t port, float val)
|
||||
{
|
||||
assert (port < parameter_count ());
|
||||
if (get_parameter (port) == val) {
|
||||
return;
|
||||
}
|
||||
_shadow_data[port] = val;
|
||||
Plugin::set_parameter (port, val);
|
||||
}
|
||||
|
||||
float
|
||||
LuaProc::get_parameter (uint32_t port) const
|
||||
{
|
||||
if (parameter_is_input (port)) {
|
||||
return _shadow_data[port];
|
||||
} else {
|
||||
return _control_data[port];
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
LuaProc::get_parameter_descriptor (uint32_t port, ParameterDescriptor& desc) const
|
||||
{
|
||||
assert (port <= parameter_count ());
|
||||
int lp = _ctrl_params[port].second;
|
||||
|
||||
luabridge::LuaRef lr = (*_lua_params)[lp];
|
||||
desc.lower = (lr["min"]).cast<float> ();
|
||||
desc.upper = (lr["max"]).cast<float> ();
|
||||
|
||||
if (_ctrl_params[port].first) {
|
||||
desc.normal = desc.lower; // output-port, no default
|
||||
} else {
|
||||
desc.normal = (lr["default"]).cast<float> ();
|
||||
}
|
||||
|
||||
desc.toggled = lr["toggled"].isBoolean () && (lr["toggled"]).cast<bool> ();
|
||||
desc.logarithmic = lr["logarithmic"].isBoolean () && (lr["logarithmic"]).cast<bool> ();
|
||||
desc.integer_step = lr["integer"].isBoolean () && (lr["integer"]).cast<bool> ();
|
||||
desc.sr_dependent = lr["ratemult"].isBoolean () && (lr["ratemult"]).cast<bool> ();
|
||||
desc.enumeration = lr["enum"].isBoolean () && (lr["enum"]).cast<bool> ();
|
||||
|
||||
// TODO check if assignments make sense, e.g
|
||||
assert (!(desc.toggled && desc.logarithmic));
|
||||
|
||||
if (lr["unit"].isString ()) {
|
||||
std::string unit = lr["unit"].cast<std::string> ();
|
||||
if (unit == "dB") { desc.unit = ParameterDescriptor::DB; }
|
||||
else if (unit == "Hz") { desc.unit = ParameterDescriptor::HZ; }
|
||||
else if (unit == "Midi Note") { desc.unit = ParameterDescriptor::MIDI_NOTE; }
|
||||
}
|
||||
|
||||
desc.label = (lr["name"]).cast<std::string> ();
|
||||
desc.scale_points = get_scale_points (port);
|
||||
desc.update_steps ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::string
|
||||
LuaProc::get_parameter_docs (uint32_t port) const {
|
||||
assert (port <= parameter_count ());
|
||||
int lp = _ctrl_params[port].second;
|
||||
luabridge::LuaRef lr = (*_lua_params)[lp];
|
||||
luabridge::LuaRef doc = lr["doc"];
|
||||
if (doc.isString ()) {
|
||||
return doc.cast<std::string> ();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
uint32_t
|
||||
LuaProc::nth_parameter (uint32_t port, bool& ok) const
|
||||
{
|
||||
if (port < _ctrl_params.size ()) {
|
||||
ok = true;
|
||||
return port;
|
||||
}
|
||||
ok = false;
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool
|
||||
LuaProc::parameter_is_input (uint32_t port) const
|
||||
{
|
||||
assert (port < _ctrl_params.size ());
|
||||
return (!_ctrl_params[port].first);
|
||||
}
|
||||
|
||||
bool
|
||||
LuaProc::parameter_is_output (uint32_t port) const
|
||||
{
|
||||
assert (port < _ctrl_params.size ());
|
||||
return (_ctrl_params[port].first);
|
||||
}
|
||||
|
||||
std::set<Evoral::Parameter>
|
||||
LuaProc::automatable () const
|
||||
{
|
||||
std::set<Evoral::Parameter> automatables;
|
||||
for (uint32_t i = 0; i < _ctrl_params.size (); ++i) {
|
||||
if (parameter_is_input (i)) {
|
||||
automatables.insert (automatables.end (), Evoral::Parameter (PluginAutomation, 0, i));
|
||||
}
|
||||
}
|
||||
return automatables;
|
||||
}
|
||||
|
||||
std::string
|
||||
LuaProc::describe_parameter (Evoral::Parameter param)
|
||||
{
|
||||
if (param.type () == PluginAutomation && param.id () < parameter_count ()) {
|
||||
int lp = _ctrl_params[param.id ()].second;
|
||||
luabridge::LuaRef lr = (*_lua_params)[lp];
|
||||
return (lr["name"]).cast<std::string> ();
|
||||
} else {
|
||||
return "??";
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
LuaProc::print_parameter (uint32_t param, char* buf, uint32_t len) const
|
||||
{
|
||||
if (buf && len) {
|
||||
if (param < parameter_count ()) {
|
||||
snprintf (buf, len, "%.3f", get_parameter (param));
|
||||
} else {
|
||||
strcat (buf, "0");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
boost::shared_ptr<ScalePoints>
|
||||
LuaProc::get_scale_points (uint32_t port) const
|
||||
{
|
||||
int lp = _ctrl_params[port].second;
|
||||
luabridge::LuaRef lr = (*_lua_params)[lp];
|
||||
|
||||
if (!lr["scalepoints"].isTable()) {
|
||||
return boost::shared_ptr<ScalePoints> ();
|
||||
}
|
||||
|
||||
int cnt = 0;
|
||||
boost::shared_ptr<ScalePoints> rv = boost::shared_ptr<ScalePoints>(new ScalePoints());
|
||||
luabridge::LuaRef scalepoints (lr["scalepoints"]);
|
||||
|
||||
for (luabridge::Iterator i (scalepoints); !i.isNil (); ++i) {
|
||||
if (!i.key ().isString ()) { continue; }
|
||||
if (!i.value ().isNumber ()) { continue; }
|
||||
rv->insert(make_pair(i.key ().cast<std::string> (),
|
||||
i.value ().cast<float> ()));
|
||||
++cnt;
|
||||
}
|
||||
|
||||
if (rv->size() > 0) {
|
||||
return rv;
|
||||
}
|
||||
return boost::shared_ptr<ScalePoints> ();
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
#include <glibmm/miscutils.h>
|
||||
#include <glibmm/fileutils.h>
|
||||
|
||||
LuaPluginInfo::LuaPluginInfo (LuaScriptInfoPtr lsi) {
|
||||
if (lsi->type != LuaScriptInfo::DSP) {
|
||||
throw failed_constructor ();
|
||||
}
|
||||
|
||||
path = lsi->path;
|
||||
name = lsi->name;
|
||||
creator = lsi->author;
|
||||
category = lsi->category;
|
||||
unique_id = "luascript"; // the interpreter is not unique.
|
||||
|
||||
n_inputs.set (DataType::AUDIO, 1);
|
||||
n_outputs.set (DataType::AUDIO, 1);
|
||||
type = Lua;
|
||||
}
|
||||
|
||||
PluginPtr
|
||||
LuaPluginInfo::load (Session& session)
|
||||
{
|
||||
std::string script = "";
|
||||
if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
|
||||
return PluginPtr ();
|
||||
}
|
||||
|
||||
try {
|
||||
script = Glib::file_get_contents (path);
|
||||
} catch (Glib::FileError err) {
|
||||
return PluginPtr ();
|
||||
}
|
||||
|
||||
if (script.empty ()) {
|
||||
return PluginPtr ();
|
||||
}
|
||||
|
||||
try {
|
||||
PluginPtr plugin (new LuaProc (session.engine (), session, script));
|
||||
return plugin;
|
||||
} catch (failed_constructor& err) {
|
||||
;
|
||||
}
|
||||
return PluginPtr ();
|
||||
}
|
||||
|
||||
std::vector<Plugin::PresetRecord>
|
||||
LuaPluginInfo::get_presets (bool /*user_only*/) const
|
||||
{
|
||||
std::vector<Plugin::PresetRecord> p;
|
||||
return p;
|
||||
}
|
||||
|
|
@ -46,6 +46,7 @@
|
|||
#include "ardour/chan_count.h"
|
||||
#include "ardour/chan_mapping.h"
|
||||
#include "ardour/data_type.h"
|
||||
#include "ardour/luaproc.h"
|
||||
#include "ardour/midi_buffer.h"
|
||||
#include "ardour/midi_state_tracker.h"
|
||||
#include "ardour/plugin.h"
|
||||
|
|
@ -162,6 +163,13 @@ ARDOUR::find_plugin(Session& session, string identifier, PluginType type)
|
|||
PluginInfoList plugs;
|
||||
|
||||
switch (type) {
|
||||
case ARDOUR::Lua:
|
||||
{
|
||||
PluginPtr plugin (new LuaProc (session.engine(), session, ""));
|
||||
return plugin;
|
||||
}
|
||||
break;
|
||||
|
||||
case ARDOUR::LADSPA:
|
||||
plugs = mgr.ladspa_plugin_info();
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@
|
|||
#include "ardour/debug.h"
|
||||
#include "ardour/event_type_map.h"
|
||||
#include "ardour/ladspa_plugin.h"
|
||||
#include "ardour/luaproc.h"
|
||||
#include "ardour/plugin.h"
|
||||
#include "ardour/plugin_insert.h"
|
||||
|
||||
|
|
@ -671,6 +672,7 @@ boost::shared_ptr<Plugin>
|
|||
PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
|
||||
{
|
||||
boost::shared_ptr<LadspaPlugin> lp;
|
||||
boost::shared_ptr<LuaProc> lua;
|
||||
#ifdef LV2_SUPPORT
|
||||
boost::shared_ptr<LV2Plugin> lv2p;
|
||||
#endif
|
||||
|
|
@ -686,6 +688,8 @@ PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
|
|||
|
||||
if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
|
||||
return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
|
||||
} else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
|
||||
return boost::shared_ptr<Plugin> (new LuaProc (*lua));
|
||||
#ifdef LV2_SUPPORT
|
||||
} else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
|
||||
return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
|
||||
|
|
@ -1035,6 +1039,8 @@ PluginInsert::set_state(const XMLNode& node, int version)
|
|||
type = ARDOUR::LXVST;
|
||||
} else if (prop->value() == X_("audiounit")) {
|
||||
type = ARDOUR::AudioUnit;
|
||||
} else if (prop->value() == X_("luaproc")) {
|
||||
type = ARDOUR::Lua;
|
||||
} else {
|
||||
error << string_compose (_("unknown plugin type %1 in plugin insert state"),
|
||||
prop->value())
|
||||
|
|
@ -1096,6 +1102,15 @@ PluginInsert::set_state(const XMLNode& node, int version)
|
|||
return -1;
|
||||
}
|
||||
|
||||
if (type == ARDOUR::Lua) {
|
||||
XMLNode *ls = node.child (plugin->state_node_name().c_str());
|
||||
// we need to load the script to set the name and parameters.
|
||||
boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
|
||||
if (ls && lp) {
|
||||
lp->set_script_from_state (*ls);
|
||||
}
|
||||
}
|
||||
|
||||
// The name of the PluginInsert comes from the plugin, nothing else
|
||||
_name = plugin->get_info()->name;
|
||||
|
||||
|
|
|
|||
|
|
@ -1102,6 +1102,10 @@ PluginManager::save_statuses ()
|
|||
case LXVST:
|
||||
ofs << "LXVST";
|
||||
break;
|
||||
case Lua:
|
||||
assert (0);
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
|
||||
ofs << ' ';
|
||||
|
|
|
|||
|
|
@ -2972,7 +2972,8 @@ Route::set_processor_state (const XMLNode& node)
|
|||
} else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
|
||||
prop->value() == "lv2" ||
|
||||
prop->value() == "windows-vst" ||
|
||||
prop->value() == "lxvst" ||
|
||||
prop->value() == "lxvst" ||
|
||||
prop->value() == "luaproc" ||
|
||||
prop->value() == "audiounit") {
|
||||
|
||||
if (_session.get_disable_all_loaded_plugins ()) {
|
||||
|
|
|
|||
|
|
@ -112,6 +112,7 @@ libardour_sources = [
|
|||
'ltc_file_reader.cc',
|
||||
'ltc_slave.cc',
|
||||
'luabindings.cc',
|
||||
'luaproc.cc',
|
||||
'luascripting.cc',
|
||||
'meter.cc',
|
||||
'midi_automation_list_binder.cc',
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue