2 Copyright (C) 2009 Paul Davis
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.
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.
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.
21 #include "libardour-config.h"
26 #include <jack/weakjack.h> // so that we can test for new functions at runtime
28 #include "pbd/error.h"
29 #include "pbd/compose.h"
31 #include "ardour/debug.h"
32 #include "ardour/port.h"
33 #include "ardour/audioengine.h"
34 #include "pbd/failed_constructor.h"
39 using namespace ARDOUR
;
42 AudioEngine
* Port::_engine
= 0;
43 bool Port::_connecting_blocked
= false;
44 pframes_t
Port::_global_port_buffer_offset
= 0;
45 pframes_t
Port::_cycle_nframes
= 0;
47 /** @param n Port short name */
48 Port::Port (std::string
const & n
, DataType t
, Flags f
)
49 : _port_buffer_offset (0)
52 , _last_monitor (false)
54 _private_playback_latency
.min
= 0;
55 _private_playback_latency
.max
= 0;
56 _private_capture_latency
.min
= 0;
57 _private_capture_latency
.max
= 0;
59 /* Unfortunately we have to pass the DataType into this constructor so that
60 we can create the right kind of JACK port; aside from this we'll use the
61 virtual function type () to establish type.
64 assert (_name
.find_first_of (':') == std::string::npos
);
66 if (!_engine
->connected()) {
67 throw failed_constructor ();
70 if ((_jack_port
= jack_port_register (_engine
->jack (), _name
.c_str (), t
.to_jack_type (), _flags
, 0)) == 0) {
71 cerr
<< "Failed to register JACK port, reason is unknown from here\n";
72 throw failed_constructor ();
76 /** Port destructor */
79 if (_engine
->jack ()) {
80 jack_port_unregister (_engine
->jack (), _jack_port
);
84 /** @return true if this port is connected to anything */
86 Port::connected () const
88 return (jack_port_connected (_jack_port
) != 0);
92 Port::disconnect_all ()
94 jack_port_disconnect (_engine
->jack(), _jack_port
);
95 _connections
.clear ();
100 /** @param o Port name
101 * @return true if this port is connected to o, otherwise false.
104 Port::connected_to (std::string
const & o
) const
106 if (!_engine
->connected()) {
107 /* in some senses, this answer isn't the right one all the time,
108 because we know about our connections and will re-establish
109 them when we reconnect to JACK.
114 return jack_port_connected_to (_jack_port
,
115 _engine
->make_port_name_non_relative(o
).c_str ());
118 /** @param o Filled in with port full names of ports that we are connected to */
120 Port::get_connections (std::vector
<std::string
> & c
) const
124 if (_engine
->connected()) {
125 const char** jc
= jack_port_get_connections (_jack_port
);
127 for (int i
= 0; jc
[i
]; ++i
) {
144 Port::connect (std::string
const & other
)
146 std::string
const other_shrt
= _engine
->make_port_name_non_relative (other
);
147 std::string
const this_shrt
= _engine
->make_port_name_non_relative (_name
);
151 if (_connecting_blocked
) {
155 if (sends_output ()) {
156 r
= jack_connect (_engine
->jack (), this_shrt
.c_str (), other_shrt
.c_str ());
158 r
= jack_connect (_engine
->jack (), other_shrt
.c_str (), this_shrt
.c_str());
162 _connections
.insert (other
);
169 Port::disconnect (std::string
const & other
)
171 std::string
const other_shrt
= _engine
->make_port_name_non_relative (other
);
172 std::string
const this_shrt
= _engine
->make_port_name_non_relative (_name
);
176 if (sends_output ()) {
177 r
= jack_disconnect (_engine
->jack (), this_shrt
.c_str (), other_shrt
.c_str ());
179 r
= jack_disconnect (_engine
->jack (), other_shrt
.c_str (), this_shrt
.c_str ());
183 _connections
.erase (other
);
191 Port::connected_to (Port
* o
) const
193 return connected_to (o
->name ());
197 Port::connect (Port
* o
)
199 return connect (o
->name ());
203 Port::disconnect (Port
* o
)
205 return disconnect (o
->name ());
209 Port::set_engine (AudioEngine
* e
)
215 Port::ensure_monitor_input (bool yn
)
217 jack_port_ensure_monitor (_jack_port
, yn
);
221 Port::monitoring_input () const
223 return jack_port_monitoring_input (_jack_port
);
229 _last_monitor
= false;
233 Port::cycle_start (pframes_t nframes
)
235 _port_buffer_offset
= 0;
239 Port::increment_port_buffer_offset (pframes_t nframes
)
241 _port_buffer_offset
+= nframes
;
245 Port::set_public_latency_range (jack_latency_range_t
& range
, bool playback
) const
247 /* this sets the visible latency that the rest of JACK sees. because we do latency
248 compensation, all (most) of our visible port latency values are identical.
251 if (!jack_port_set_latency_range
) {
255 DEBUG_TRACE (DEBUG::Latency
,
256 string_compose ("SET PORT %1 %4 PUBLIC latency now [%2 - %3]\n",
257 name(), range
.min
, range
.max
,
258 (playback
? "PLAYBACK" : "CAPTURE")));;
260 jack_port_set_latency_range (_jack_port
,
261 (playback
? JackPlaybackLatency
: JackCaptureLatency
),
266 Port::set_private_latency_range (jack_latency_range_t
& range
, bool playback
)
269 _private_playback_latency
= range
;
270 DEBUG_TRACE (DEBUG::Latency
, string_compose (
271 "SET PORT %1 playback PRIVATE latency now [%2 - %3]\n",
273 _private_playback_latency
.min
,
274 _private_playback_latency
.max
));
276 _private_capture_latency
= range
;
277 DEBUG_TRACE (DEBUG::Latency
, string_compose (
278 "SET PORT %1 capture PRIVATE latency now [%2 - %3]\n",
280 _private_capture_latency
.min
,
281 _private_capture_latency
.max
));
284 /* push to public (JACK) location so that everyone else can see it */
286 set_public_latency_range (range
, playback
);
289 const jack_latency_range_t
&
290 Port::private_latency_range (bool playback
) const
293 DEBUG_TRACE (DEBUG::Latency
, string_compose (
294 "GET PORT %1 playback PRIVATE latency now [%2 - %3]\n",
296 _private_playback_latency
.min
,
297 _private_playback_latency
.max
));
298 return _private_playback_latency
;
300 DEBUG_TRACE (DEBUG::Latency
, string_compose (
301 "GET PORT %1 capture PRIVATE latency now [%2 - %3]\n",
303 _private_playback_latency
.min
,
304 _private_playback_latency
.max
));
305 return _private_capture_latency
;
310 Port::public_latency_range (bool playback
) const
312 jack_latency_range_t r
;
314 jack_port_get_latency_range (_jack_port
,
315 sends_output() ? JackPlaybackLatency
: JackCaptureLatency
,
317 DEBUG_TRACE (DEBUG::Latency
, string_compose (
318 "GET PORT %1: %4 PUBLIC latency range %2 .. %3\n",
319 name(), r
.min
, r
.max
,
320 sends_output() ? "PLAYBACK" : "CAPTURE"));
325 Port::get_connected_latency_range (jack_latency_range_t
& range
, bool playback
) const
327 if (!jack_port_get_latency_range
) {
331 vector
<string
> connections
;
332 jack_client_t
* jack
= _engine
->jack();
337 PBD::warning
<< _("get_connected_latency_range() called while disconnected from JACK") << endmsg
;
341 get_connections (connections
);
343 if (!connections
.empty()) {
345 range
.min
= ~((jack_nframes_t
) 0);
348 DEBUG_TRACE (DEBUG::Latency
, string_compose ("%1: %2 connections to check for latency range\n", name(), connections
.size()));
350 for (vector
<string
>::const_iterator c
= connections
.begin();
351 c
!= connections
.end(); ++c
) {
353 jack_latency_range_t lr
;
355 if (!AudioEngine::instance()->port_is_mine (*c
)) {
357 /* port belongs to some other JACK client, use
358 * JACK to lookup its latency information.
361 jack_port_t
* remote_port
= jack_port_by_name (_engine
->jack(), (*c
).c_str());
364 jack_port_get_latency_range (
366 (playback
? JackPlaybackLatency
: JackCaptureLatency
),
369 DEBUG_TRACE (DEBUG::Latency
, string_compose (
370 "\t%1 <-> %2 : latter has latency range %3 .. %4\n",
371 name(), *c
, lr
.min
, lr
.max
));
373 range
.min
= min (range
.min
, lr
.min
);
374 range
.max
= max (range
.max
, lr
.max
);
379 /* port belongs to this instance of ardour,
380 so look up its latency information
381 internally, because our published/public
382 values already contain our plugin
383 latency compensation.
386 Port
* remote_port
= AudioEngine::instance()->get_port_by_name (*c
);
388 lr
= remote_port
->private_latency_range ((playback
? JackPlaybackLatency
: JackCaptureLatency
));
389 DEBUG_TRACE (DEBUG::Latency
, string_compose (
390 "\t%1 <-LOCAL-> %2 : latter has latency range %3 .. %4\n",
391 name(), *c
, lr
.min
, lr
.max
));
393 range
.min
= min (range
.min
, lr
.min
);
394 range
.max
= max (range
.max
, lr
.max
);
400 DEBUG_TRACE (DEBUG::Latency
, string_compose ("%1: not connected to anything\n", name()));
405 DEBUG_TRACE (DEBUG::Latency
, string_compose ("%1: final connected latency range [ %2 .. %3 ] \n", name(), range
.min
, range
.max
));
411 jack_client_t
* jack
= _engine
->jack();
417 _jack_port
= jack_port_register (jack
, _name
.c_str(), type().to_jack_type(), _flags
, 0);
419 if (_jack_port
== 0) {
420 PBD::error
<< string_compose (_("could not reregister %1"), _name
) << endmsg
;
433 /* caller must hold process lock; intended to be used only after reestablish() */
435 for (std::set
<string
>::iterator i
= _connections
.begin(); i
!= _connections
.end(); ++i
) {
444 /** @param n Short port name (no JACK client name) */
446 Port::set_name (std::string
const & n
)
452 int const r
= jack_port_set_name (_jack_port
, n
.c_str());
462 Port::request_monitor_input (bool yn
)
464 jack_port_request_monitor (_jack_port
, yn
);
468 Port::physically_connected () const
470 const char** jc
= jack_port_get_connections (_jack_port
);
473 for (int i
= 0; jc
[i
]; ++i
) {
475 jack_port_t
* port
= jack_port_by_name (_engine
->jack(), jc
[i
]);
477 if (port
&& (jack_port_flags (port
) & JackPortIsPhysical
)) {