send a slightly more useful message if a control protocol's probe() method fails

[ardour.git] / libs / ardour / port_manager.cc

diff --git a/libs/ardour/port_manager.cc b/libs/ardour/port_manager.cc
index 93cb5fbb1acadabbc9ce46d1915786337862b331..408e7804603eb73961284584529f3ee63f08fd7b 100644 (file)
--- a/libs/ardour/port_manager.cc
+++ b/libs/ardour/port_manager.cc
@@ -17,6 +17,13 @@
 
 */
 
+#ifdef COMPILER_MSVC
+#include <io.h> // Microsoft's nearest equivalent to <unistd.h>
+#include <ardourext/misc.h>
+#else
+#include <regex.h>
+#endif
+
 #include "pbd/convert.h"
 #include "pbd/error.h"
 
@@ -28,8 +35,9 @@
 #include "ardour/midiport_manager.h"
 #include "ardour/port_manager.h"
 #include "ardour/profile.h"
+#include "ardour/session.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace ARDOUR;
 using namespace PBD;
@@ -293,24 +301,28 @@ PortManager::port_registration_failure (const std::string& portname)
 }
 
 boost::shared_ptr<Port>
-PortManager::register_port (DataType dtype, const string& portname, bool input, bool async)
+PortManager::register_port (DataType dtype, const string& portname, bool input, bool async, PortFlags flags)
 {
        boost::shared_ptr<Port> newport;
 
+       /* limit the possible flags that can be set */
+
+       flags = PortFlags (flags & (Hidden|Shadow|IsTerminal));
+
        try {
                if (dtype == DataType::AUDIO) {
                        DEBUG_TRACE (DEBUG::Ports, string_compose ("registering AUDIO port %1, input %2\n",
                                                                   portname, input));
-                       newport.reset (new AudioPort (portname, (input ? IsInput : IsOutput)));
+                       newport.reset (new AudioPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags)));
                } else if (dtype == DataType::MIDI) {
                        if (async) {
                                DEBUG_TRACE (DEBUG::Ports, string_compose ("registering ASYNC MIDI port %1, input %2\n",
                                                                           portname, input));
-                               newport.reset (new AsyncMIDIPort (portname, (input ? IsInput : IsOutput)));
+                               newport.reset (new AsyncMIDIPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags)));
                        } else {
                                DEBUG_TRACE (DEBUG::Ports, string_compose ("registering MIDI port %1, input %2\n",
                                                                           portname, input));
-                               newport.reset (new MidiPort (portname, (input ? IsInput : IsOutput)));
+                               newport.reset (new MidiPort (portname, PortFlags ((input ? IsInput : IsOutput) | flags)));
                        }
                } else {
                        throw PortRegistrationFailure("unable to create port (unknown type)");
@@ -338,20 +350,26 @@ PortManager::register_port (DataType dtype, const string& portname, bool input,
 }
 
 boost::shared_ptr<Port>
-PortManager::register_input_port (DataType type, const string& portname, bool async)
+PortManager::register_input_port (DataType type, const string& portname, bool async, PortFlags extra_flags)
 {
-       return register_port (type, portname, true, async);
+       return register_port (type, portname, true, async, extra_flags);
 }
 
 boost::shared_ptr<Port>
-PortManager::register_output_port (DataType type, const string& portname, bool async)
+PortManager::register_output_port (DataType type, const string& portname, bool async, PortFlags extra_flags)
 {
-       return register_port (type, portname, false, async);
+       return register_port (type, portname, false, async, extra_flags);
 }
 
 int
 PortManager::unregister_port (boost::shared_ptr<Port> port)
 {
+       /* This is a little subtle. We do not call the backend's port
+        * unregistration code from here. That is left for the Port
+        * destructor. We are trying to drop references to the Port object
+        * here, so that its destructor will run and it will unregister itself.
+        */
+
        /* caller must hold process lock */
 
        {
@@ -665,9 +683,21 @@ PortManager::cycle_end (pframes_t nframes)
 }
 
 void
-PortManager::silence (pframes_t nframes)
+PortManager::silence (pframes_t nframes, Session *s)
 {
        for (Ports::iterator i = _cycle_ports->begin(); i != _cycle_ports->end(); ++i) {
+               if (s && i->second == s->mtc_output_port ()) {
+                       continue;
+               }
+               if (s && i->second == s->midi_clock_output_port ()) {
+                       continue;
+               }
+               if (s && i->second == s->ltc_output_port ()) {
+                       continue;
+               }
+               if (boost::dynamic_pointer_cast<AsyncMIDIPort>(i->second)) {
+                       continue;
+               }
                if (i->second->sends_output()) {
                        i->second->get_buffer(nframes).silence(nframes);
                }
@@ -757,3 +787,36 @@ PortManager::port_engine()
        assert (_backend);
        return *_backend;
 }
+
+bool
+PortManager::port_is_control_only (std::string const& name)
+{
+       static regex_t compiled_pattern;
+       static string pattern;
+
+       if (pattern.empty()) {
+
+               /* This is a list of regular expressions that match ports
+                * related to physical MIDI devices that we do not want to
+                * expose as normal physical ports.
+                */
+
+               const char * const control_only_ports[] = {
+                       X_(".*Ableton Push.*"),
+                       X_(".*FaderPort .*"),
+               };
+
+               pattern = "(";
+               for (size_t n = 0; n < sizeof (control_only_ports)/sizeof (control_only_ports[0]); ++n) {
+                       if (n > 0) {
+                               pattern += '|';
+                       }
+                       pattern += control_only_ports[n];
+               }
+               pattern += ')';
+
+               regcomp (&compiled_pattern, pattern.c_str(), REG_EXTENDED|REG_NOSUB);
+       }
+
+       return regexec (&compiled_pattern, name.c_str(), 0, 0, 0) == 0;
+}