variable plugin port config.
[ardour.git] / libs / ardour / luaproc.cc
index 2669f3a03fdf9afd53a5dd441b8e0b4fd37033e4..baeb9409f402efb8468145c93b9c7f6d561b0fcf 100644 (file)
@@ -31,6 +31,8 @@
 #include "ardour/plugin.h"
 #include "ardour/session.h"
 
+#include "LuaBridge/LuaBridge.h"
+
 #include "i18n.h"
 
 using namespace ARDOUR;
@@ -43,9 +45,9 @@ LuaProc::LuaProc (AudioEngine& engine,
        , _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)
+       , _lua_has_inline_display (false)
        , _control_data (0)
        , _shadow_data (0)
        , _has_midi_input (false)
@@ -66,9 +68,9 @@ LuaProc::LuaProc (const LuaProc &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)
+       , _lua_has_inline_display (false)
        , _control_data (0)
        , _shadow_data (0)
        , _has_midi_input (false)
@@ -101,7 +103,6 @@ LuaProc::~LuaProc () {
 #endif
        lua.do_command ("collectgarbage();");
        delete (_lua_dsp);
-       delete (_lua_params);
        delete [] _control_data;
        delete [] _shadow_data;
 }
@@ -113,9 +114,7 @@ LuaProc::init ()
        _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);
@@ -149,12 +148,14 @@ LuaProc::init ()
 void
 LuaProc::lua_print (std::string s) {
        std::cout <<"LuaProc: " << s << "\n";
+       PBD::error << "LuaProc: " << s << "\n";
 }
 
 bool
 LuaProc::load_script ()
 {
        assert (!_lua_dsp); // don't allow to re-initialize
+       LuaPluginInfoPtr lpi;
 
        // TODO: refine APIs; function arguments..
        // - perform channel-map in ardour (silent/scratch buffers) ?
@@ -166,7 +167,7 @@ LuaProc::load_script ()
 
        try {
                LuaScriptInfoPtr lsi = LuaScripting::script_info (_script);
-               LuaPluginInfoPtr lpi (new LuaPluginInfo (lsi));
+               lpi = LuaPluginInfoPtr (new LuaPluginInfo (lsi));
                assert (lpi);
                set_info (lpi);
                _mempool.set_name ("LuaProc: " + lsi->name);
@@ -215,6 +216,7 @@ LuaProc::load_script ()
                        ;
                }
        }
+       lpi->_is_instrument = _has_midi_input;
 
        _ctrl_params.clear ();
 
@@ -231,8 +233,6 @@ LuaProc::load_script ()
 
                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; }
@@ -242,17 +242,51 @@ LuaProc::load_script ()
                                if (!i.value ()["min"].isNumber ())  { return false; }
                                if (!i.value ()["max"].isNumber ())  { return false; }
 
+                               int pn = i.key ().cast<int> ();
                                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> ()));
+                                       _ctrl_params.push_back (std::make_pair (false, pn));
                                }
                                else if (type == "output") {
-                                       _ctrl_params.push_back (std::make_pair (true, i.key ().cast<int> ()));
+                                       _ctrl_params.push_back (std::make_pair (true, pn));
                                } else {
                                        return false;
                                }
-                               assert (i.key ().cast<int> () == (int) _ctrl_params.size ());
+                               assert (pn == (int) _ctrl_params.size ());
+
+                               //_param_desc[pn] = boost::shared_ptr<ParameterDescriptor> (new ParameterDescriptor());
+                               luabridge::LuaRef lr = i.value ();
+
+                               if (type == "input") {
+                                       _param_desc[pn].normal     = lr["default"].cast<float> ();
+                               } else {
+                                       _param_desc[pn].normal     = lr["min"].cast<float> (); // output-port, no default
+                               }
+                               _param_desc[pn].lower        = lr["min"].cast<float> ();
+                               _param_desc[pn].upper        = lr["max"].cast<float> ();
+                               _param_desc[pn].toggled      = lr["toggled"].isBoolean () && (lr["toggled"]).cast<bool> ();
+                               _param_desc[pn].logarithmic  = lr["logarithmic"].isBoolean () && (lr["logarithmic"]).cast<bool> ();
+                               _param_desc[pn].integer_step = lr["integer"].isBoolean () && (lr["integer"]).cast<bool> ();
+                               _param_desc[pn].sr_dependent = lr["ratemult"].isBoolean () && (lr["ratemult"]).cast<bool> ();
+                               _param_desc[pn].enumeration  = lr["enum"].isBoolean () && (lr["enum"]).cast<bool> ();
+
+                               if (lr["unit"].isString ()) {
+                                       std::string unit = lr["unit"].cast<std::string> ();
+                                       if (unit == "dB")             { _param_desc[pn].unit = ParameterDescriptor::DB; }
+                                       else if (unit == "Hz")        { _param_desc[pn].unit = ParameterDescriptor::HZ; }
+                                       else if (unit == "Midi Note") { _param_desc[pn].unit = ParameterDescriptor::MIDI_NOTE; }
+                               }
+                               _param_desc[pn].label        = (lr["name"]).cast<std::string> ();
+                               _param_desc[pn].scale_points = parse_scale_points (&lr);
+
+                               luabridge::LuaRef doc = lr["doc"];
+                               if (doc.isString ()) {
+                                       _param_doc[pn] = doc.cast<std::string> ();
+                               } else {
+                                       _param_doc[pn] = "";
+                               }
+                               assert (!(_param_desc[pn].toggled && _param_desc[pn].logarithmic));
                        }
                }
        }
@@ -274,9 +308,12 @@ LuaProc::load_script ()
 }
 
 bool
-LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
+LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, ChanCount* imprecise)
 {
-       if (in.n_midi() > 0 && !_has_midi_input) {
+       // caller must hold process lock (no concurrent calls to interpreter
+       _output_configs.clear ();
+
+       if (in.n_midi() > 0 && !_has_midi_input && !imprecise) {
                return false;
        }
 
@@ -286,14 +323,9 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
                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);
                }
@@ -313,14 +345,14 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
                return false;
        }
 
-       int32_t audio_in = in.n_audio ();
-       int32_t audio_out;
+       bool found = false;
+       bool exact_match = false;
+       const int32_t audio_in = in.n_audio ();
+       int32_t midi_out = 0; // TODO handle  _has_midi_output
 
-       if (in.n_midi() > 0 && audio_in == 0) {
-               audio_out = 2; // prefer stereo version if available.
-       } else {
-               audio_out = audio_in;
-       }
+       // preferred setting (provided by plugin_insert)
+       assert (out.n_audio () > 0);
+       const int preferred_out = out.n_audio ();
 
        for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
                assert (i.value ().type () == LUA_TTABLE);
@@ -330,16 +362,37 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
                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;
+               if ((possible_in == audio_in) && (possible_out == preferred_out)) {
+                       _output_configs.insert (preferred_out);
+                       exact_match = true;
+                       found = true;
+                       break;
                }
        }
 
        /* now allow potentially "imprecise" matches */
-       audio_out = -1;
-       bool found = false;
+       int32_t audio_out = -1;
+       float penalty = 9999;
+
+#define FOUNDCFG(nch) {                            \
+  float p = fabsf ((float)(nch) - preferred_out);  \
+  _output_configs.insert (nch);                    \
+  if ((nch) > preferred_out) { p *= 1.1; }         \
+  if (p < penalty) {                               \
+    audio_out = (nch);                             \
+    penalty = p;                                   \
+    found = true;                                  \
+  }                                                \
+}
+
+#define ANYTHINGGOES                               \
+  _output_configs.insert (0);
+
+#define UPTO(nch) {                                \
+  for (int n = 1; n < nch; ++n) {                  \
+    _output_configs.insert (n);                    \
+  }                                                \
+}
 
        for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
                assert (i.value ().type () == LUA_TTABLE);
@@ -354,113 +407,137 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
                if (possible_in == 0) {
                        /* no inputs, generators & instruments */
                        if (possible_out == -1) {
-                               /* any configuration possible, provide stereo output */
-                               audio_out = 2;
-                               found = true;
+                               /* any configuration possible, stereo output */
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out == -2) {
                                /* invalid, should be (0, -1) */
-                               audio_out = 2;
-                               found = true;
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* variable number of outputs. -> whatever */
-                               audio_out = 2;
-                               found = true;
+                               /* variable number of outputs up to -N, */
+                               FOUNDCFG (min (-possible_out, preferred_out));
+                               UPTO (-possible_out);
                        } else {
                                /* exact number of outputs */
-                               audio_out = possible_out;
-                               found = true;
+                               FOUNDCFG (possible_out);
                        }
                }
 
                if (possible_in == -1) {
                        /* wildcard for input */
                        if (possible_out == -1) {
-                               /* out much match in */
-                               audio_out = audio_in;
-                               found = true;
+                               /* out must match in */
+                               FOUNDCFG (audio_in);
                        } else if (possible_out == -2) {
                                /* any configuration possible, pick matching */
-                               audio_out = audio_in;
-                               found = true;
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out < -2) {
                                /* explicitly variable number of outputs, pick maximum */
-                               audio_out = -possible_out;
-                               found = true;
+                               FOUNDCFG (max (-possible_out, preferred_out));
+                               /* and try min, too, in case the penalty is lower */
+                               FOUNDCFG (min (-possible_out, preferred_out));
+                               UPTO (-possible_out)
                        } else {
                                /* exact number of outputs */
-                               audio_out = possible_out;
-                               found = true;
+                               FOUNDCFG (possible_out);
                        }
                }
 
                if (possible_in == -2) {
-
                        if (possible_out == -1) {
                                /* any configuration possible, pick matching */
-                               audio_out = audio_in;
-                               found = true;
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out == -2) {
                                /* invalid. interpret as (-1, -1) */
-                               audio_out = audio_in;
-                               found = true;
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* explicitly variable number of outputs, pick maximum */
-                               audio_out = -possible_out;
-                               found = true;
+                               /* invalid,  interpret as (<-2, <-2)
+                                * variable number of outputs up to -N, */
+                               FOUNDCFG (min (-possible_out, preferred_out));
+                               UPTO (-possible_out)
                        } else {
                                /* exact number of outputs */
-                               audio_out = possible_out;
-                               found = true;
+                               FOUNDCFG (possible_out);
                        }
                }
 
                if (possible_in < -2) {
                        /* explicit variable number of inputs */
-                       if (audio_in > -possible_in) {
-                               /* request is too large */
+                       if (audio_in > -possible_in && imprecise != NULL) {
+                               // hide inputs ports
+                               imprecise->set (DataType::AUDIO, -possible_in);
                        }
-                       if (possible_out == -1) {
-                               /* any output configuration possible, provide stereo out */
-                               audio_out = 2;
-                               found = true;
+
+                       if (audio_in > -possible_in && imprecise == NULL) {
+                               /* request is too large */
+                       } else if (possible_out == -1) {
+                               /* any output configuration possible */
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out == -2) {
                                /* invalid. interpret as (<-2, -1) */
-                               audio_out = 2;
-                               found = true;
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* explicitly variable number of outputs, pick stereo */
-                               audio_out = 2;
-                               found = true;
+                               /* variable number of outputs up to -N, */
+                               FOUNDCFG (min (-possible_out, preferred_out));
+                               UPTO (-possible_out)
                        } else {
                                /* exact number of outputs */
-                               audio_out = possible_out;
-                               found = true;
+                               FOUNDCFG (possible_out);
                        }
                }
 
                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;
+                               /* any output configuration possible */
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out == -2) {
                                /* invalid. interpret as (>0, -1) */
-                               audio_out = 2;
-                               found = true;
+                               FOUNDCFG (preferred_out);
+                               ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* explicitly variable number of outputs, pick maximum */
-                               audio_out = -possible_out;
-                               found = true;
+                               /* > 0, < -2 is not specified
+                                * interpret as up to -N */
+                               FOUNDCFG (min (-possible_out, preferred_out));
+                               UPTO (-possible_out)
                        } else {
                                /* exact number of outputs */
-                               audio_out = possible_out;
-                               found = true;
+                               FOUNDCFG (possible_out);
                        }
                }
+       }
 
-               if (found) {
-                       break;
+       if (!found && imprecise) {
+               /* try harder */
+               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"];
+
+                       assert (possible_in > 0); // all other cases will have been matched above
+                       assert (possible_out !=0 || possible_in !=0); // already handled above
+
+                       imprecise->set (DataType::AUDIO, possible_in);
+                       if (possible_out == -1 || possible_out == -2) {
+                               FOUNDCFG (2);
+                       } else if (possible_out < -2) {
+                               /* explicitly variable number of outputs, pick maximum */
+                               FOUNDCFG (min (-possible_out, preferred_out));
+                       } else {
+                               /* exact number of outputs */
+                               FOUNDCFG (possible_out);
+                       }
+                       // ideally we'll also find the closest, best matching
+                       // input configuration with minimal output penalty...
                }
        }
 
@@ -468,8 +545,13 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out)
                return false;
        }
 
-       out.set (DataType::MIDI, 0);
-       out.set (DataType::AUDIO, audio_out);
+       if (exact_match) {
+               out.set (DataType::MIDI, midi_out); // currently always zero
+               out.set (DataType::AUDIO, preferred_out);
+       } else {
+               out.set (DataType::MIDI, midi_out); // currently always zero
+               out.set (DataType::AUDIO, audio_out);
+       }
        return true;
 }
 
@@ -489,7 +571,7 @@ LuaProc::configure_io (ChanCount in, ChanCount out)
                try {
                        lua_dsp_configure (&in, &out);
                } catch (luabridge::LuaException const& e) {
-                       ;
+                       return false;
                }
        }
 
@@ -531,7 +613,6 @@ LuaProc::connect_and_run (BufferSet& bufs,
 
        try {
                if (_lua_does_channelmapping) {
-                       Glib::Threads::Mutex::Lock lm (debug_hack);
                        // run the DSP function
                        (*_lua_dsp)(&bufs, in, out, nframes, offset);
                } else {
@@ -595,13 +676,13 @@ LuaProc::connect_and_run (BufferSet& bufs,
                        }
 
 
-                       Glib::Threads::Mutex::Lock lm (debug_hack);
                        // run the DSP function
                        (*_lua_dsp)(in_map, out_map, nframes);
                }
        } catch (luabridge::LuaException const& e) {
+               PBD::error << "LuaException: " << e.what () << "\n";
 #ifndef NDEBUG
-               printf ("LuaException: %s\n", e.what ());
+               std::cerr << "LuaException: " << e.what () << "\n";
 #endif
                return -1;
        }
@@ -749,9 +830,7 @@ LuaProc::default_value (uint32_t port)
                return 0;
        }
        int lp = _ctrl_params[port].second;
-       Glib::Threads::Mutex::Lock lm (debug_hack);
-       luabridge::LuaRef lr = (*_lua_params)[lp];
-       return (lr["default"]).cast<float> ();
+       return _param_desc[lp].normal;
 }
 
 void
@@ -780,36 +859,20 @@ LuaProc::get_parameter_descriptor (uint32_t port, ParameterDescriptor& desc) con
 {
        assert (port <= parameter_count ());
        int lp = _ctrl_params[port].second;
+       const ParameterDescriptor& d (_param_desc.find(lp)->second);
+
+       desc.lower        = d.lower;
+       desc.upper        = d.upper;
+       desc.normal       = d.normal;
+       desc.toggled      = d.toggled;
+       desc.logarithmic  = d.logarithmic;
+       desc.integer_step = d.integer_step;
+       desc.sr_dependent = d.sr_dependent;
+       desc.enumeration  = d.enumeration;
+       desc.unit         = d.unit;
+       desc.label        = d.label;
+       desc.scale_points = d.scale_points;
 
-       Glib::Threads::Mutex::Lock lm (debug_hack);
-       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;
 }
@@ -818,13 +881,7 @@ std::string
 LuaProc::get_parameter_docs (uint32_t port) const {
        assert (port <= parameter_count ());
        int lp = _ctrl_params[port].second;
-       Glib::Threads::Mutex::Lock lm (debug_hack);
-       luabridge::LuaRef lr = (*_lua_params)[lp];
-       luabridge::LuaRef doc = lr["doc"];
-       if (doc.isString ()) {
-               return doc.cast<std::string> ();
-       }
-       return "";
+       return _param_doc.find(lp)->second;
 }
 
 uint32_t
@@ -869,12 +926,9 @@ LuaProc::describe_parameter (Evoral::Parameter param)
 {
        if (param.type () == PluginAutomation && param.id () < parameter_count ()) {
                int lp = _ctrl_params[param.id ()].second;
-               Glib::Threads::Mutex::Lock lm (debug_hack);
-               luabridge::LuaRef lr = (*_lua_params)[lp];
-               return (lr["name"]).cast<std::string> ();
-       } else {
-               return "??";
+               return _param_desc[lp].label;
        }
+       return "??";
 }
 
 void
@@ -890,19 +944,15 @@ LuaProc::print_parameter (uint32_t param, char* buf, uint32_t len) const
 }
 
 boost::shared_ptr<ScalePoints>
-LuaProc::get_scale_points (uint32_t port) const
+LuaProc::parse_scale_points (luabridge::LuaRef* lr)
 {
-       int lp = _ctrl_params[port].second;
-       Glib::Threads::Mutex::Lock lm (debug_hack);
-       luabridge::LuaRef lr = (*_lua_params)[lp];
-
-       if (!lr["scalepoints"].isTable()) {
+       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"]);
+       luabridge::LuaRef scalepoints ((*lr)["scalepoints"]);
 
        for (luabridge::Iterator i (scalepoints); !i.isNil (); ++i) {
                if (!i.key ().isString ())    { continue; }
@@ -918,6 +968,12 @@ LuaProc::get_scale_points (uint32_t port) const
        return boost::shared_ptr<ScalePoints> ();
 }
 
+boost::shared_ptr<ScalePoints>
+LuaProc::get_scale_points (uint32_t port) const
+{
+       int lp = _ctrl_params[port].second;
+       return _param_desc.find(lp)->second.scale_points;
+}
 
 void
 LuaProc::setup_lua_inline_gui (LuaState *lua_gui)
@@ -927,10 +983,7 @@ LuaProc::setup_lua_inline_gui (LuaState *lua_gui)
        LuaBindings::common (LG);
        LuaBindings::dsp (LG);
 
-#ifndef NDEBUG
        lua_gui->Print.connect (sigc::mem_fun (*this, &LuaProc::lua_print));
-#endif
-
        lua_gui->do_command ("function ardour () end");
        lua_gui->do_command (_script);