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_by_name (_engine->jack(), _name.c_str()) == NULL) {
  59                 cerr << "Port name " << _name << " does not currently exist\n";
  60         } else {
  61                 cerr << "Port name " << _name << " is already registered\n";
  62         }
  63
  64         if ((_jack_port = jack_port_register (_engine->jack (), _name.c_str (), t.to_jack_type (), _flags, 0)) == 0) {
  65                 cerr << "Failed to register JACK port, reason is unknown from here\n";
  66                 throw failed_constructor ();
  67         }
  68 }
  69
  70 /** Port destructor */
  71 Port::~Port ()
  72 {
  73         if (_engine->jack ()) {
  74                 jack_port_unregister (_engine->jack (), _jack_port);
  75         }
  76 }
  77
  78 /** @return true if this port is connected to anything */
  79 bool
  80 Port::connected () const
  81 {
  82         return (jack_port_connected (_jack_port) != 0);
  83 }
  84
  85 int
  86 Port::disconnect_all ()
  87 {
  88         jack_port_disconnect (_engine->jack(), _jack_port);
  89         _connections.clear ();
  90
  91         return 0;
  92 }
  93
  94 /** @param o Port name
  95  * @return true if this port is connected to o, otherwise false.
  96  */
  97 bool
  98 Port::connected_to (std::string const & o) const
  99 {
 100         return jack_port_connected_to (_jack_port, _engine->make_port_name_non_relative(o).c_str ());
 101 }
 102
 103 /** @param o Filled in with port full names of ports that we are connected to */
 104 int
 105 Port::get_connections (std::vector<std::string> & c) const
 106 {
 107         int n = 0;
 108
 109         const char** jc = jack_port_get_connections (_jack_port);
 110         if (jc) {
 111                 for (int i = 0; jc[i]; ++i) {
 112                         c.push_back (jc[i]);
 113                         ++n;
 114                 }
 115
 116                 jack_free (jc);
 117         }
 118
 119         return n;
 120 }
 121
 122 int
 123 Port::connect (std::string const & other)
 124 {
 125         /* caller must hold process lock */
 126
 127         std::string const other_shrt = _engine->make_port_name_non_relative (other);
 128         std::string const this_shrt = _engine->make_port_name_non_relative (_name);
 129
 130         int r = 0;
 131
 132         if (_connecting_blocked) {
 133                 return r;
 134         }
 135
 136         if (sends_output ()) {
 137                 r = jack_connect (_engine->jack (), this_shrt.c_str (), other_shrt.c_str ());
 138         } else {
 139                 r = jack_connect (_engine->jack (), other_shrt.c_str (), this_shrt.c_str());
 140         }
 141
 142         if (r == 0) {
 143                 _connections.insert (other);
 144         }
 145
 146         return r;
 147 }
 148
 149 int
 150 Port::disconnect (std::string const & other)
 151 {
 152         /* caller must hold process lock */
 153
 154         std::string const other_shrt = _engine->make_port_name_non_relative (other);
 155         std::string const this_shrt = _engine->make_port_name_non_relative (_name);
 156
 157         int r = 0;
 158
 159         if (sends_output ()) {
 160                 r = jack_disconnect (_engine->jack (), this_shrt.c_str (), other_shrt.c_str ());
 161         } else {
 162                 r = jack_disconnect (_engine->jack (), other_shrt.c_str (), this_shrt.c_str ());
 163         }
 164
 165         if (r == 0) {
 166                 _connections.erase (other);
 167         }
 168
 169         return r;
 170 }
 171
 172
 173 bool
 174 Port::connected_to (Port* o) const
 175 {
 176         return connected_to (o->name ());
 177 }
 178
 179 int
 180 Port::connect (Port* o)
 181 {
 182         return connect (o->name ());
 183 }
 184
 185 int
 186 Port::disconnect (Port* o)
 187 {
 188         return disconnect (o->name ());
 189 }
 190
 191 void
 192 Port::set_engine (AudioEngine* e)
 193 {
 194         _engine = e;
 195 }
 196
 197 void
 198 Port::ensure_monitor_input (bool yn)
 199 {
 200         jack_port_ensure_monitor (_jack_port, yn);
 201 }
 202
 203 bool
 204 Port::monitoring_input () const
 205 {
 206         return jack_port_monitoring_input (_jack_port);
 207 }
 208
 209 void
 210 Port::reset ()
 211 {
 212         _last_monitor = false;
 213
 214         // XXX
 215         // _metering = 0;
 216         // reset_meters ();
 217 }
 218
 219 void
 220 Port::recompute_total_latency () const
 221 {
 222 #ifdef HAVE_JACK_RECOMPUTE_LATENCY
 223         jack_client_t* jack = _engine->jack();
 224
 225         if (!jack) {
 226                 return;
 227         }
 228
 229         jack_recompute_total_latency (jack, _jack_port);
 230 #endif
 231 }
 232
 233 nframes_t
 234 Port::total_latency () const
 235 {
 236         jack_client_t* jack = _engine->jack();
 237
 238         if (!jack) {
 239                 return 0;
 240         }
 241
 242         return jack_port_get_total_latency (jack, _jack_port);
 243 }
 244
 245 int
 246 Port::reestablish ()
 247 {
 248         jack_client_t* jack = _engine->jack();
 249
 250         if (!jack) {
 251                 return -1;
 252         }
 253
 254         cerr << "RE-REGISTER: " << _name.c_str() << endl;
 255         _jack_port = jack_port_register (jack, _name.c_str(), type().to_jack_type(), _flags, 0);
 256
 257         if (_jack_port == 0) {
 258                 PBD::error << string_compose (_("could not reregister %1"), _name) << endmsg;
 259                 return -1;
 260         }
 261
 262         reset ();
 263
 264         return 0;
 265 }
 266
 267
 268 int
 269 Port::reconnect ()
 270 {
 271         /* caller must hold process lock; intended to be used only after reestablish() */
 272
 273         for (std::set<string>::iterator i = _connections.begin(); i != _connections.end(); ++i) {
 274                 if (connect (*i)) {
 275                         return -1;
 276                 }
 277         }
 278
 279         return 0;
 280 }
 281
 282 /** @param n Short port name (no JACK client name) */
 283 int
 284 Port::set_name (std::string const & n)
 285 {
 286         if (n == _name) {
 287                 return 0;
 288         }
 289
 290         int const r = jack_port_set_name (_jack_port, n.c_str());
 291
 292         if (r == 0) {
 293                 _name = n;
 294         }
 295
 296         return r;
 297 }
 298
 299 void
 300 Port::request_monitor_input (bool yn)
 301 {
 302         jack_port_request_monitor (_jack_port, yn);
 303 }
 304
 305 void
 306 Port::set_latency (nframes_t n)
 307 {
 308         jack_port_set_latency (_jack_port, n);
 309 }
 310
 311 bool
 312 Port::physically_connected () const
 313 {
 314         const char** jc = jack_port_get_connections (_jack_port);
 315
 316         if (jc) {
 317                 for (int i = 0; jc[i]; ++i) {
 318
 319                         jack_port_t* port = jack_port_by_name (_engine->jack(), jc[i]);
 320
 321                         if (port && (jack_port_flags (port) & JackPortIsPhysical)) {
 322                                 jack_free (jc);
 323                                 return true;
 324                         }
 325                 }
 326
 327                 jack_free (jc);
 328         }
 329
 330         return false;
 331 }
 332