Make the configuration penalty subtler about inputs
[ardour.git] / libs / ardour / luaproc.cc
index 0c5581e2a04fca6f7276d6223919ff8d8b1af864..09be770b0a9bd2b4719acfdfffe68d58832d124e 100644 (file)
@@ -380,31 +380,49 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
        // preferred setting (provided by plugin_insert)
        const int preferred_out = out.n_audio ();
 
-       int midi_out = _has_midi_output ? 1 : 0;
+       int midi_out = -1;
        int audio_out = -1;
        float penalty = 9999;
        bool found = false;
 
-#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 FOUNDCFG_PENALTY(in, out, p) {                              \
+  _output_configs.insert (out);                                     \
+  if (p < penalty) {                                                \
+    audio_out = (out);                                              \
+    midi_out = possible_midiout;                                    \
+    if (imprecise) {                                                \
+      imprecise->set (DataType::AUDIO, (in));                       \
+      imprecise->set (DataType::MIDI, possible_midiin);             \
+    }                                                               \
+    penalty = p;                                                    \
+    found = true;                                                   \
+  }                                                                 \
 }
 
-#define ANYTHINGGOES                               \
+#define FOUNDCFG_IMPRECISE(in, out) {                               \
+  const float p = fabsf ((float)(out) - preferred_out) *            \
+                      (((out) > preferred_out) ? 1.1 : 1)           \
+                + fabsf ((float)(in) - audio_in) *                  \
+                      (((in) > audio_in) ? 275 : 250);              \
+  FOUNDCFG_PENALTY(in, out, p);                                     \
+}
+
+#define FOUNDCFG(out)                                               \
+  FOUNDCFG_IMPRECISE(audio_in, out)
+
+#define ANYTHINGGOES                                                \
   _output_configs.insert (0);
 
-#define UPTO(nch) {                                \
-  for (int n = 1; n < nch; ++n) {                  \
-    _output_configs.insert (n);                    \
-  }                                                \
+#define UPTO(nch) {                                                 \
+  for (int n = 1; n < nch; ++n) {                                   \
+    _output_configs.insert (n);                                     \
+  }                                                                 \
 }
 
+       if (imprecise) {
+               *imprecise = in;
+       }
+
        for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
                luabridge::LuaRef io (i.value ());
                if (!io.isTable()) {
@@ -414,6 +432,7 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                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_midiout = _has_midi_output ? 1 : 0;
 
                if (midi_in > 0 && possible_midiin == 0 && !imprecise) {
                        continue;
@@ -421,60 +440,41 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
 
                // 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;
+                       FOUNDCFG_PENALTY(audio_in, preferred_out, -1);
                }
 
                // "imprecise" matches
                if (possible_out == 0) {
-                       if (possible_in == 0) {
-                               if (_has_midi_output && audio_in == 0) {
-                                       // special case midi filters & generators
-                                       audio_out = 0;
-                                       found = true;
+                       /* skip configurations with no audio output, unless
+                        * the plugin is a midi filter or generator */
+                       if (possible_in == 0 && _has_midi_output) {
+                               if (audio_in == 0) {
+                                       FOUNDCFG(possible_out);
                                        break;
+                               } else if (imprecise) {
+                                       // TODO hide audio input from plugin
+                                       FOUNDCFG_IMPRECISE (possible_in, possible_out);
                                }
                        }
                        continue;
                }
 
-               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) */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out < -2) {
-                               /* variable number of outputs up to -N, */
-                               FOUNDCFG (min (-possible_out, preferred_out));
-                               UPTO (-possible_out);
-                       } else {
-                               /* exact number of outputs */
-                               FOUNDCFG (possible_out);
-                       }
-               }
-
-               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 */
+                       } 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) {
-                               /* explicitly variable number of outputs, pick maximum */
-                               FOUNDCFG (max (-possible_out, preferred_out));
-                               /* and try min, too, in case the penalty is lower */
+                               /* 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 {
@@ -483,109 +483,41 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
                        }
                }
 
-               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) */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out < -2) {
-                               /* 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 */
-                               FOUNDCFG (possible_out);
-                       }
-               }
-
-               if (possible_in < -2) {
-                       /* explicit variable number of inputs */
-                       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) */
-                               FOUNDCFG (preferred_out);
-                               ANYTHINGGOES;
-                       } else if (possible_out < -2) {
-                               /* variable number of outputs up to -N, */
-                               FOUNDCFG (min (-possible_out, preferred_out));
-                               UPTO (-possible_out)
+               if (possible_in < -2 || possible_in >= 0) {
+                       /* specified number, exact or up to */
+                       int desired_in;
+                       if (possible_in >= 0) {
+                               /* configuration can only match possible_in */
+                               desired_in = possible_in;
                        } else {
-                               /* exact number of outputs */
-                               FOUNDCFG (possible_out);
+                               /* configuration can match up to -possible_in */
+                               desired_in = min (-possible_in, audio_in);
                        }
-               }
-
-               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);
+                       if (!imprecise && audio_in != desired_in) {
+                               /* skip that configuration, it cannot match
+                                * the required audio input count, and we
+                                * cannot ask for change via \imprecise */
+                       } else if (possible_out == -1 || possible_out == -2) {
+                               /* any output configuration possible
+                                * out == -2 is invalid, interpreted as out == -1.
+                                * Really imprecise only if desired_in != audio_in */
+                               FOUNDCFG_IMPRECISE (desired_in, preferred_out);
                                ANYTHINGGOES;
                        } else if (possible_out < -2) {
-                               /* > 0, < -2 is not specified
-                                * interpret as up to -N */
-                               FOUNDCFG (min (-possible_out, preferred_out));
+                               /* variable number of outputs up to -N
+                                * not specified if in > 0, but we accept it anyway.
+                                * Really imprecise only if desired_in != audio_in */
+                               FOUNDCFG_IMPRECISE (desired_in, min (-possible_out, preferred_out));
                                UPTO (-possible_out)
                        } else {
-                               /* exact number of outputs */
-                               FOUNDCFG (possible_out);
-                       }
-               }
-       }
-
-       if (found && imprecise) {
-               *imprecise = in;
-       }
-
-       if (!found && imprecise) {
-               /* try harder */
-               for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
-                       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;
-
-                       if (possible_out == 0 && possible_in == 0 && _has_midi_output) {
-                               assert (audio_in > 0); // no input is handled above
-                               // TODO hide audio input from plugin
-                               imprecise->set (DataType::AUDIO, 0);
-                               audio_out = 0;
-                               found = true;
-                               continue;
-                       }
-
-                       assert (possible_in > 0); // all other cases will have been matched 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);
+                               /* exact number of outputs
+                                * Really imprecise only if desired_in != audio_in */
+                               FOUNDCFG_IMPRECISE (desired_in, possible_out);
                        }
                        // ideally we'll also find the closest, best matching
                        // input configuration with minimal output penalty...
                }
+
        }
 
        if (!found) {
@@ -593,7 +525,6 @@ LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, Chan
        }
 
        if (imprecise) {
-               imprecise->set (DataType::MIDI, _has_midi_input ? 1 : 0);
                _selected_in = *imprecise;
        } else {
                _selected_in = in;