libs/ardour/port.cc

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include "ardour/port.h"
  25 #include "ardour/audioengine.h"
  26 #include "pbd/failed_constructor.h"
  27 #include "pbd/error.h"
  28 #include "pbd/compose.h"
  29 #include <stdexcept>
  30
  31 #include "i18n.h"
  32
  33 using namespace std;
  34 using namespace ARDOUR;
  35
  36 AudioEngine* Port::_engine = 0;
  37 nframes_t Port::_buffer_size = 0;
  38 bool Port::_connecting_blocked = false;
  39
  40 /** @param n Port short name */
  41 Port::Port (std::string const & n, DataType t, Flags f)
  42         : _last_monitor (false)
  43         , _name (n)
  44         , _flags (f)
  45 {
  46
  47         /* Unfortunately we have to pass the DataType into this constructor so that we can
  48            create the right kind of JACK port; aside from this we'll use the virtual function type ()
  49            to establish type.
  50         */
  51
  52         assert (_name.find_first_of (':') == std::string::npos);
  53
  54         if (!_engine->connected()) {
  55                 throw failed_constructor ();
  56         }
  57
  58         if ((_jack_port = jack_port_register (_engine->jack (), _name.c_str (), t.to_jack_type (), _flags, 0)) == 0) {
  59                 cerr << "Failed to register JACK port, reason is unknown from here\n";
  60                 throw failed_constructor ();
  61         }
  62 }
  63
  64 /** Port destructor */
  65 Port::~Port ()
  66 {
  67         if (_engine->jack ()) {
  68                 jack_port_unregister (_engine->jack (), _jack_port);
  69         }
  70 }
  71
  72 /** @return true if this port is connected to anything */
  73 bool
  74 Port::connected () const
  75 {
  76         return (jack_port_connected (_jack_port) != 0);
  77 }
  78
  79 int
  80 Port::disconnect_all ()
  81 {
  82         jack_port_disconnect (_engine->jack(), _jack_port);
  83         _connections.clear ();
  84
  85         return 0;
  86 }
  87
  88 /** @param o Port name
  89  * @return true if this port is connected to o, otherwise false.
  90  */
  91 bool
  92 Port::connected_to (std::string const & o) const
  93 {
  94         return jack_port_connected_to (_jack_port, _engine->make_port_name_non_relative(o).c_str ());
  95 }
  96
  97 /** @param o Filled in with port full names of ports that we are connected to */
  98 int
  99 Port::get_connections (std::vector<std::string> & c) const
 100 {
 101         int n = 0;
 102
 103         const char** jc = jack_port_get_connections (_jack_port);
 104         if (jc) {
 105                 for (int i = 0; jc[i]; ++i) {
 106                         c.push_back (jc[i]);
 107                         ++n;
 108                 }
 109
 110                 jack_free (jc);
 111         }
 112
 113         return n;
 114 }
 115
 116 int
 117 Port::connect (std::string const & other)
 118 {
 119         std::string const other_shrt = _engine->make_port_name_non_relative (other);
 120         std::string const this_shrt = _engine->make_port_name_non_relative (_name);
 121
 122         int r = 0;
 123
 124         if (_connecting_blocked) {
 125                 return r;
 126         }
 127
 128         if (sends_output ()) {
 129                 r = jack_connect (_engine->jack (), this_shrt.c_str (), other_shrt.c_str ());
 130         } else {
 131                 r = jack_connect (_engine->jack (), other_shrt.c_str (), this_shrt.c_str());
 132         }
 133
 134         if (r == 0) {
 135                 _connections.insert (other);
 136         }
 137
 138         return r;
 139 }
 140
 141 int
 142 Port::disconnect (std::string const & other)
 143 {
 144         std::string const other_shrt = _engine->make_port_name_non_relative (other);
 145         std::string const this_shrt = _engine->make_port_name_non_relative (_name);
 146
 147         int r = 0;
 148
 149         if (sends_output ()) {
 150                 r = jack_disconnect (_engine->jack (), this_shrt.c_str (), other_shrt.c_str ());
 151         } else {
 152                 r = jack_disconnect (_engine->jack (), other_shrt.c_str (), this_shrt.c_str ());
 153         }
 154
 155         if (r == 0) {
 156                 _connections.erase (other);
 157         }
 158
 159         return r;
 160 }
 161
 162
 163 bool
 164 Port::connected_to (Port* o) const
 165 {
 166         return connected_to (o->name ());
 167 }
 168
 169 int
 170 Port::connect (Port* o)
 171 {
 172         return connect (o->name ());
 173 }
 174
 175 int
 176 Port::disconnect (Port* o)
 177 {
 178         return disconnect (o->name ());
 179 }
 180
 181 void
 182 Port::set_engine (AudioEngine* e)
 183 {
 184         _engine = e;
 185 }
 186
 187 void
 188 Port::ensure_monitor_input (bool yn)
 189 {
 190         jack_port_ensure_monitor (_jack_port, yn);
 191 }
 192
 193 bool
 194 Port::monitoring_input () const
 195 {
 196         return jack_port_monitoring_input (_jack_port);
 197 }
 198
 199 void
 200 Port::reset ()
 201 {
 202         _last_monitor = false;
 203
 204         // XXX
 205         // _metering = 0;
 206         // reset_meters ();
 207 }
 208
 209 void
 210 Port::recompute_total_latency () const
 211 {
 212 #ifdef HAVE_JACK_RECOMPUTE_LATENCY
 213         jack_client_t* jack = _engine->jack();
 214
 215         if (!jack) {
 216                 return;
 217         }
 218
 219         jack_recompute_total_latency (jack, _jack_port);
 220 #endif
 221 }
 222
 223 nframes_t
 224 Port::total_latency () const
 225 {
 226         jack_client_t* jack = _engine->jack();
 227
 228         if (!jack) {
 229                 return 0;
 230         }
 231
 232         return jack_port_get_total_latency (jack, _jack_port);
 233 }
 234
 235 int
 236 Port::reestablish ()
 237 {
 238         jack_client_t* jack = _engine->jack();
 239
 240         if (!jack) {
 241                 return -1;
 242         }
 243
 244         cerr << "RE-REGISTER: " << _name.c_str() << endl;
 245         _jack_port = jack_port_register (jack, _name.c_str(), type().to_jack_type(), _flags, 0);
 246
 247         if (_jack_port == 0) {
 248                 PBD::error << string_compose (_("could not reregister %1"), _name) << endmsg;
 249                 return -1;
 250         }
 251
 252         reset ();
 253
 254         return 0;
 255 }
 256
 257
 258 int
 259 Port::reconnect ()
 260 {
 261         /* caller must hold process lock; intended to be used only after reestablish() */
 262
 263         for (std::set<string>::iterator i = _connections.begin(); i != _connections.end(); ++i) {
 264                 if (connect (*i)) {
 265                         return -1;
 266                 }
 267         }
 268
 269         return 0;
 270 }
 271
 272 /** @param n Short port name (no JACK client name) */
 273 int
 274 Port::set_name (std::string const & n)
 275 {
 276         if (n == _name) {
 277                 return 0;
 278         }
 279
 280         int const r = jack_port_set_name (_jack_port, n.c_str());
 281
 282         if (r == 0) {
 283                 _name = n;
 284         }
 285
 286         return r;
 287 }
 288
 289 void
 290 Port::request_monitor_input (bool yn)
 291 {
 292         jack_port_request_monitor (_jack_port, yn);
 293 }
 294
 295 void
 296 Port::set_latency (nframes_t n)
 297 {
 298         jack_port_set_latency (_jack_port, n);
 299 }
 300
 301 bool
 302 Port::physically_connected () const
 303 {
 304         const char** jc = jack_port_get_connections (_jack_port);
 305
 306         if (jc) {
 307                 for (int i = 0; jc[i]; ++i) {
 308
 309                         jack_port_t* port = jack_port_by_name (_engine->jack(), jc[i]);
 310
 311                         if (port && (jack_port_flags (port) & JackPortIsPhysical)) {
 312                                 jack_free (jc);
 313                                 return true;
 314                         }
 315                 }
 316
 317                 jack_free (jc);
 318         }
 319
 320         return false;
 321 }
 322