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