Merge some cases to avoid duplicated logic
[ardour.git] / libs / ardour / luaproc.cc
index c7f44d9cd406704379729fb99559a202216a1fed..cfe66820672791e1dd6aed60f1ab61bd7d2e1596 100644 (file)
@@ -22,7 +22,7 @@
 #include <glibmm/fileutils.h>
 
 #include "pbd/gstdio_compat.h"
-
+#include "pbd/locale_guard.h"
 #include "pbd/pthread_utils.h"
 
 #include "ardour/audio_buffer.h"
@@ -49,7 +49,7 @@ LuaProc::LuaProc (AudioEngine& engine,
        , _mempool ("LuaProc", 2097152)
 #ifdef USE_TLSF
        , lua (lua_newstate (&PBD::TLSF::lalloc, &_mempool))
-#elif define USE_MALLOC
+#elif defined USE_MALLOC
        , lua ()
 #else
        , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
@@ -79,7 +79,7 @@ LuaProc::LuaProc (const LuaProc &other)
        , _mempool ("LuaProc", 2097152)
 #ifdef USE_TLSF
        , lua (lua_newstate (&PBD::TLSF::lalloc, &_mempool))
-#elif define USE_MALLOC
+#elif defined USE_MALLOC
        , lua ()
 #else
        , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
@@ -346,10 +346,6 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
        // caller must hold process lock (no concurrent calls to interpreter
        _output_configs.clear ();
 
-       if (in.n_midi() > 0 && !_has_midi_input && !imprecise) {
-               return false;
-       }
-
        lua_State* L = lua.getState ();
        luabridge::LuaRef ioconfig = luabridge::getGlobal (L, "dsp_ioconfig");
        if (!ioconfig.isFunction ()) {
@@ -378,34 +374,16 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                return false;
        }
 
-       bool found = false;
-       bool exact_match = false;
-       const int32_t audio_in = in.n_audio ();
-       int32_t midi_out = _has_midi_output ? 1 : 0;
+       const int audio_in = in.n_audio ();
+       const int midi_in = in.n_midi ();
 
        // preferred setting (provided by plugin_insert)
-       assert (out.n_audio () > 0 || midi_out > 0);
        const int preferred_out = out.n_audio ();
 
-       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 == preferred_out)) {
-                       _output_configs.insert (preferred_out);
-                       exact_match = true;
-                       found = true;
-                       break;
-               }
-       }
-
-       /* now allow potentially "imprecise" matches */
-       int32_t audio_out = -1;
+       int midi_out = _has_midi_output ? 1 : 0;
+       int audio_out = -1;
        float penalty = 9999;
+       bool found = false;
 
 #define FOUNDCFG(nch) {                            \
   float p = fabsf ((float)(nch) - preferred_out);  \
@@ -428,12 +406,30 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
 }
 
        for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
-               assert (i.value ().type () == LUA_TTABLE);
                luabridge::LuaRef io (i.value ());
+               if (!io.isTable()) {
+                       continue;
+               }
+
+               int possible_in = io["audio_in"].isNumber() ? io["audio_in"] : -1;
+               int possible_out = io["audio_out"].isNumber() ? io["audio_out"] : -1;
+               int possible_midiin = _has_midi_input ? 1 : 0;
 
-               int possible_in = io["audio_in"];
-               int possible_out = io["audio_out"];
+               if (midi_in > 0 && possible_midiin == 0 && !imprecise) {
+                       continue;
+               }
 
+               // exact match
+               if ((possible_in == audio_in) && (possible_out == preferred_out)) {
+                       _output_configs.insert (preferred_out);
+                       audio_out = preferred_out;
+                       /* Set penalty so low that this output configuration
+                        * will trump any other one */
+                       penalty = -1;
+                       found = true;
+               }
+
+               // "imprecise" matches
                if (possible_out == 0) {
                        if (possible_in == 0) {
                                if (_has_midi_output && audio_in == 0) {
@@ -448,12 +444,9 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
 
                if (possible_in == 0) {
                        /* no inputs, generators & instruments */
-                       if (possible_out == -1) {
-                               /* any configuration possible, stereo output */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out == -2) {
-                               /* invalid, should be (0, -1) */
+                       if (possible_out == -1 || possible_out == -2) {
+                               /* any output configuration possible
+                                * out == -2 is invalid, interpreted as out == -1 */
                                FOUNDCFG (preferred_out);
                                ANYTHINGGOES;
                        } else if (possible_out < -2) {
@@ -466,39 +459,20 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                        }
                }
 
-               if (possible_in == -1) {
+               if (possible_in == -1 || possible_in == -2) {
                        /* wildcard for input */
-                       if (possible_out == -1) {
-                               /* out must match in */
+                       if (possible_out == possible_in) {
+                               /* either both -1 or both -2 (invalid and
+                                * interpreted as both -1): out must match in */
                                FOUNDCFG (audio_in);
-                       } else if (possible_out == -2) {
-                               /* any configuration possible, pick matching */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out < -2) {
-                               /* explicitly variable number of outputs, pick maximum */
-                               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 */
-                               FOUNDCFG (possible_out);
-                       }
-               }
-
-               if (possible_in == -2) {
-                       if (possible_out == -1) {
-                               /* any configuration possible, pick matching */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out == -2) {
-                               /* invalid. interpret as (-1, -1) */
+                       } else if (possible_out == -3 - possible_in) {
+                               /* one is -1, the other is -2: any output configuration
+                                * possible, pick what the insert prefers */
                                FOUNDCFG (preferred_out);
                                ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* invalid,  interpret as (<-2, <-2)
-                                * variable number of outputs up to -N, */
+                               /* variable number of outputs up to -N,
+                                * invalid if in == -2 but we accept it anyway */
                                FOUNDCFG (min (-possible_out, preferred_out));
                                UPTO (-possible_out)
                        } else {
@@ -507,25 +481,20 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                        }
                }
 
-               if (possible_in < -2) {
-                       /* explicit variable number of inputs */
-                       if (audio_in > -possible_in && imprecise != NULL) {
-                               // hide inputs ports
-                               imprecise->set (DataType::AUDIO, -possible_in);
-                       }
-
-                       if (audio_in > -possible_in && imprecise == NULL) {
+               if (possible_in < -2 || possible_in > 0) {
+                       /* specified number, exact or up to */
+                       if (possible_in < -2 && audio_in > -possible_in && !imprecise) {
                                /* 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) */
+                       } else if (possible_in > 0 && audio_in != possible_in) {
+                               /* this configuration needed exacty possible_in inputs */
+                       } else if (possible_out == -1 || possible_out == -2) {
+                               /* any output configuration possible
+                                * out == -2 is invalid, interpreted as out == -1 */
                                FOUNDCFG (preferred_out);
                                ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* variable number of outputs up to -N, */
+                               /* variable number of outputs up to -N
+                                * not specified if in > 0, but we accept it anyway */
                                FOUNDCFG (min (-possible_out, preferred_out));
                                UPTO (-possible_out)
                        } else {
@@ -534,41 +503,22 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                        }
                }
 
-               if (possible_in && (possible_in == audio_in)) {
-                       /* exact number of inputs ... must match obviously */
-                       if (possible_out == -1) {
-                               /* any output configuration possible */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out == -2) {
-                               /* invalid. interpret as (>0, -1) */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out < -2) {
-                               /* > 0, < -2 is not specified
-                                * interpret as up to -N */
-                               FOUNDCFG (min (-possible_out, preferred_out));
-                               UPTO (-possible_out)
-                       } else {
-                               /* exact number of outputs */
-                               FOUNDCFG (possible_out);
-                       }
-               }
        }
 
        if (found && imprecise) {
                *imprecise = in;
-               imprecise->set (DataType::MIDI, _has_midi_input ? 1 : 0);
        }
 
        if (!found && imprecise) {
                /* try harder */
                for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
-                       assert (i.value ().type () == LUA_TTABLE);
                        luabridge::LuaRef io (i.value ());
+                       if (!io.isTable()) {
+                               continue;
+                       }
 
-                       int possible_in = io["audio_in"];
-                       int possible_out = io["audio_out"];
+                       int possible_in = io["audio_in"].isNumber() ? io["audio_in"] : -1;
+                       int possible_out = io["audio_out"].isNumber() ? io["audio_out"] : -1;
 
                        if (possible_out == 0 && possible_in == 0 && _has_midi_output) {
                                assert (audio_in > 0); // no input is handled above
@@ -580,7 +530,6 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                        }
 
                        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) {
@@ -608,13 +557,8 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                _selected_in = in;
        }
 
-       if (exact_match) {
-               out.set (DataType::MIDI, midi_out);
-               out.set (DataType::AUDIO, preferred_out);
-       } else {
-               out.set (DataType::MIDI, midi_out);
-               out.set (DataType::AUDIO, audio_out);
-       }
+       out.set (DataType::MIDI, midi_out);
+       out.set (DataType::AUDIO, audio_out);
        _selected_out = out;
 
        return true;
@@ -658,7 +602,6 @@ LuaProc::configure_io (ChanCount in, ChanCount out)
                                                        lin.set (DataType::MIDI, c);
                                                }
                                        }
-                                       _info->n_inputs = lin;
                                        if (io["midi_out"].type() == LUA_TNUMBER) {
                                                const int c = io["midi_out"].cast<int> ();
                                                if (c >= 0) {
@@ -1214,10 +1157,11 @@ LuaProc::load_preset (PresetRecord r)
                                XMLProperty const * value = (*j)->property (X_("value"));
                                assert (index);
                                assert (value);
+                               LocaleGuard lg;
                                set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
                        }
                }
-               return true;
+               return Plugin::load_preset(r);
        }
        return false;
 }