protected:
friend class Route;
void schedule_curve_reallocation ();
- void update_latency_compensation (bool, bool, bool force=false);
+ void update_latency_compensation (bool force = false);
private:
int create (const std::string& mix_template, BusProfile*);
bool _was_seamless;
void set_worst_io_latencies ();
+ void set_worst_playback_latency ();
+ void set_worst_capture_latency ();
void set_worst_io_latencies_x (IOChange, void *) {
set_worst_io_latencies ();
}
+ void post_capture_latency ();
+ void post_playback_latency ();
void update_latency_compensation_proxy (void* ignored);
SerializedRCUManager<RouteList> routes;
- void add_routes (RouteList&, bool save);
+ void add_routes (RouteList&, bool auto_connect, bool save);
uint32_t destructive_index;
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
bool find_route_name (std::string const &, uint32_t& id, char* name, size_t name_len, bool);
void count_existing_route_channels (ChanCount& in, ChanCount& out);
- void auto_connect_route (
- Route* route,
- ChanCount& existing_inputs,
- ChanCount& existing_outputs,
- bool connect_inputs = true,
- ChanCount input_start = ChanCount (),
- ChanCount output_start = ChanCount ()
- );
+ void auto_connect_route (Route*,
+ ChanCount& existing_inputs,
+ ChanCount& existing_outputs,
+ bool with_lock,
+ bool connect_inputs = true,
+ ChanCount input_start = ChanCount (),
+ ChanCount output_start = ChanCount ());
+
+ void auto_connect_route (boost::shared_ptr<Route> route,
+ ChanCount& existing_inputs,
+ ChanCount& existing_outputs,
+ bool with_lock,
+ bool connect_inputs = true,
+ ChanCount input_start = ChanCount (),
+ ChanCount output_start = ChanCount ()) {
+ auto_connect_route (route.get(), existing_inputs, existing_outputs, with_lock, connect_inputs, input_start, output_start);
+ }
+
/* mixer stuff */
remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
}
}
-
+
get_input_sources ();
set_capture_offset ();
set_align_style_from_io ();
-
+
input_change_pending = IOChange::NoChange;
/* implicit unlock */
connections.clear ();
+ cerr << "Getting Nth connection from io " << n << " = " << _io->nth(n) << endl;
+
if (_io->nth (n)->get_connections (connections) == 0) {
+ cerr << "\tThere were NO connections, apparently ...\n";
if ((*chan)->source) {
// _source->disable_metering ();
}
(*chan)->source = 0;
} else {
+ cerr << "\tThere were some connections, apparently ... to " << connections[0] << endl;
(*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
}
}
boost::shared_ptr<ChannelList> c = channels.reader();
+ cerr << "Checking " << c->size() << " for physical connections\n";
+
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
+ cerr << "Channel connected via " << (*chan)->source << endl;
if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
+ cerr << "\tchannel has physical connection to " << (*chan)->source->name() << endl;
have_physical = true;
break;
}
}
+ cerr << "\tphysical? " << have_physical << endl;
if (have_physical) {
set_align_style (ExistingMaterial);
, _flags (f)
, _last_monitor (false)
{
+ _private_playback_latency.min = 0;
+ _private_playback_latency.max = 0;
+ _private_capture_latency.min = 0;
+ _private_capture_latency.max = 0;
/* Unfortunately we have to pass the DataType into this constructor so that we can
create the right kind of JACK port; aside from this we'll use the virtual function type ()
if (!jack_port_set_latency_range) {
return;
}
-
- DEBUG_TRACE (DEBUG::Latency, string_compose ("PORT %1 %4 latency now [%2 - %3]\n", name(),
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("SET PORT %1 %4 PUBLIC latency now [%2 - %3]\n", name(),
range.min,
range.max,
(playback ? "PLAYBACK" : "CAPTURE")));;
{
if (playback) {
_private_playback_latency = range;
- DEBUG_TRACE (DEBUG::Latency, string_compose ("PORT %1 playback latency now [%2 - %3]\n", name(),
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("SET PORT %1 playback PRIVATE latency now [%2 - %3]\n", name(),
_private_playback_latency.min,
_private_playback_latency.max));
} else {
_private_capture_latency = range;
- DEBUG_TRACE (DEBUG::Latency, string_compose ("PORT %1 capture latency now [%2 - %3]\n", name(),
- _private_playback_latency.min,
- _private_playback_latency.max));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("SET PORT %1 capture PRIVATE latency now [%2 - %3]\n", name(),
+ _private_capture_latency.min,
+ _private_capture_latency.max));
}
/* push to public (JACK) location so that everyone else can see it */
Port::private_latency_range (bool playback) const
{
if (playback) {
- return _private_playback_latency;
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("GET PORT %1 playback PRIVATE latency now [%2 - %3]\n", name(),
+ _private_playback_latency.min,
+ _private_playback_latency.max));
+ return _private_playback_latency;
} else {
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("GET PORT %1 capture PRIVATE latency now [%2 - %3]\n", name(),
+ _private_playback_latency.min,
+ _private_playback_latency.max));
return _private_capture_latency;
}
}
jack_port_get_latency_range (_jack_port,
sends_output() ? JackPlaybackLatency : JackCaptureLatency,
&r);
- DEBUG_TRACE (DEBUG::Latency, string_compose ("PORT %1: %4 public latency range %2 .. %3\n",
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("GET PORT %1: %4 PUBLIC latency range %2 .. %3\n",
name(), r.min, r.max,
sends_output() ? "PLAYBACK" : "CAPTURE"));
return r;
range.max = 0;
for (vector<string>::iterator c = connections.begin(); c != connections.end(); ++c) {
+
+ cerr << "Connection between " << name() << " and " << *c << endl;
+
jack_port_t* remote_port = jack_port_by_name (_engine->jack(), (*c).c_str());
jack_latency_range_t lr;
if (remote_port) {
jack_port_get_latency_range (remote_port, (playback ? JackPlaybackLatency : JackCaptureLatency), &lr);
- DEBUG_TRACE (DEBUG::Latency, string_compose ("\t\%1 has latency range %2 .. %3\n", *c, lr.min, lr.max));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("\t%1 <-> %2 : latter has latency range %3 .. %4\n", name(), *c, lr.min, lr.max));
range.min = min (range.min, lr.min);
range.max = max (range.max, lr.max);
+ } else {
+ cerr << "\t NO PORT BY NAME!\n";
}
}
processor->activate ();
}
- processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false, false));
+ processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
_output->set_user_latency (0);
}
}
}
- (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false, false));
+ (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
}
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false, false));
+ (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
boost::shared_ptr<PluginInsert> pi;
and we are master (as an auto-connect in this situation would cause a
feedback loop)
*/
+
AutoConnectOption ac = Config->get_output_auto_connect ();
+
if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
ChanCount start = change.before;
already there
*/
start.set (*i, start.get (*i) + 1);
-
- _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
+
+ _session.auto_connect_route (this, dummy, dummy, false, false, ChanCount(), change.before);
}
}
}
Route::set_user_latency (framecnt_t nframes)
{
_output->set_user_latency (nframes);
- _session.update_latency_compensation (false, false);
+ _session.update_latency_compensation ();
}
void
#endif
}
-void
-Session::set_worst_io_latencies ()
-{
- if (_state_of_the_state & InitialConnecting) {
- return;
- }
-
- _worst_output_latency = 0;
- _worst_input_latency = 0;
-
- if (!_engine.connected()) {
- return;
- }
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
- _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
- }
-
- DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1 Worst input latency: %2\n",
- _worst_output_latency, _worst_input_latency));
-}
-
void
Session::when_engine_running ()
{
BootMessage (_("Connect to engine"));
_engine.set_session (this);
- update_latency_compensation (false, false, true);
+ update_latency_compensation (true);
}
void
{
in = ChanCount::ZERO;
out = ChanCount::ZERO;
+
boost::shared_ptr<RouteList> r = routes.reader ();
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
in += (*i)->n_inputs();
{
char track_name[32];
uint32_t track_id = 0;
- ChanCount existing_inputs;
- ChanCount existing_outputs;
string port;
RouteList new_routes;
list<boost::shared_ptr<MidiTrack> > ret;
uint32_t control_id;
- count_existing_route_channels (existing_inputs, existing_outputs);
-
control_id = ntracks() + nbusses();
bool const use_number = (how_many != 1);
}
}
- auto_connect_route (track.get(), existing_inputs, existing_outputs);
-
track->non_realtime_input_change();
if (route_group) {
failed:
if (!new_routes.empty()) {
- add_routes (new_routes, false);
+ add_routes (new_routes, true, false);
save_state (_current_snapshot_name);
}
return ret;
}
-/** Caller must hold process lock.
- * @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
+/** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
* @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
* @param output_start As \a input_start, but for outputs.
*/
void
-Session::auto_connect_route (
- Route* route, ChanCount& existing_inputs, ChanCount& existing_outputs, bool connect_inputs, ChanCount input_start, ChanCount output_start
- )
+Session::auto_connect_route (Route* route, ChanCount& existing_inputs, ChanCount& existing_outputs,
+ bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
{
+ if (!IO::connecting_legal) {
+ return;
+ }
+
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
+
+ if (with_lock) {
+ lm.acquire ();
+ }
+
/* If both inputs and outputs are auto-connected to physical ports,
use the max of input and output offsets to ensure auto-connected
port numbers always match up (e.g. the first audio input and the
offset possible.
*/
+ cerr << "ACR: existing in = " << existing_inputs << " out = " << existing_outputs << endl;
+
const bool in_out_physical =
(Config->get_input_auto_connect() & AutoConnectPhysical)
&& (Config->get_output_auto_connect() & AutoConnectPhysical)
&& connect_inputs;
- const ChanCount in_offset = in_out_physical
- ? ChanCount::max(existing_inputs, existing_outputs)
- : existing_inputs;
+ const ChanCount in_offset = existing_inputs;
const ChanCount out_offset = in_out_physical
? ChanCount::max(existing_inputs, existing_outputs)
if (!physinputs.empty() && connect_inputs) {
uint32_t nphysical_in = physinputs.size();
+
+ cerr << "There are " << nphysical_in << " physical inputs of type " << *t << endl;
+
for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
string port;
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
+ cerr << "Get index " << in_offset.get(*t) << " + " << i << " % " << nphysical_in << " = "
+ << (in_offset.get(*t) + i) % nphysical_in
+ << endl;
port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
}
+ cerr << "Connect route " << route->name() << " IN to " << port << endl;
+
if (!port.empty() && route->input()->connect (
route->input()->ports().port(*t, i), port, this)) {
break;
}
}
+ cerr << "Connect route " << route->name() << " OUT to " << port << endl;
+
if (!port.empty() && route->output()->connect (
route->output()->ports().port(*t, i), port, this)) {
break;
}
}
}
-
- existing_inputs += route->n_inputs();
- existing_outputs += route->n_outputs();
}
/** Caller must not hold process lock
{
char track_name[32];
uint32_t track_id = 0;
- ChanCount existing_inputs;
- ChanCount existing_outputs;
string port;
RouteList new_routes;
list<boost::shared_ptr<AudioTrack> > ret;
uint32_t control_id;
- count_existing_route_channels (existing_inputs, existing_outputs);
-
control_id = ntracks() + nbusses() + 1;
bool const use_number = (how_many != 1);
<< endmsg;
goto failed;
}
-
- auto_connect_route (track.get(), existing_inputs, existing_outputs);
}
if (route_group) {
failed:
if (!new_routes.empty()) {
- add_routes (new_routes, true);
+ add_routes (new_routes, true, true);
}
return ret;
{
char bus_name[32];
uint32_t bus_id = 0;
- ChanCount existing_inputs;
- ChanCount existing_outputs;
string port;
RouteList ret;
uint32_t control_id;
- count_existing_route_channels (existing_inputs, existing_outputs);
-
control_id = ntracks() + nbusses() + 1;
bool const use_number = (how_many != 1);
<< endmsg;
goto failure;
}
-
- auto_connect_route (bus.get(), existing_inputs, existing_outputs, false);
}
if (route_group) {
failure:
if (!ret.empty()) {
- add_routes (ret, true);
+ add_routes (ret, true, true);
}
return ret;
out:
if (!ret.empty()) {
- add_routes (ret, true);
+ add_routes (ret, true, true);
}
return ret;
}
void
-Session::add_routes (RouteList& new_routes, bool save)
+Session::add_routes (RouteList& new_routes, bool auto_connect, bool save)
{
{
RCUWriter<RouteList> writer (routes);
mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
}
}
- }
+
+ if (auto_connect) {
+
+ ChanCount existing_inputs;
+ ChanCount existing_outputs;
+
+ count_existing_route_channels (existing_inputs, existing_outputs);
+
+ auto_connect_route (r, existing_inputs, existing_outputs, true);
+ }
+ }
if (_monitor_out && IO::connecting_legal) {
}
}
- update_latency_compensation (false, false);
+ update_latency_compensation ();
set_dirty();
/* Re-sort routes to remove the graph's current references to the one that is
{
DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
boost::shared_ptr<RouteList> r = routes.reader ();
framecnt_t max_latency = 0;
reverse (r->begin(), r->end());
}
+ /* compute actual latency values for the given direction and store them all in per-port
+ structures. this will also publish the same values (to JACK) so that computation of latency
+ for routes can consistently use public latency values.
+ */
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
}
- DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
+ if (playback) {
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->set_public_port_latencies (max_latency, playback);
+ post_playback_latency ();
+
+ /* because we latency compensate playback, our published playback latencies should
+ be the same for all output ports - all material played back by ardour has
+ the same latency, whether its caused by plugins or by latency compensation. since
+ these may differ from the values computed above, reset all playback port latencies
+ to the same value.
+ */
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->set_public_port_latencies (max_latency, playback);
+ }
+
+
+
+ } else {
+
+ post_capture_latency ();
}
DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
}
+
+void
+Session::post_playback_latency ()
+{
+ set_worst_playback_latency ();
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_hidden() && ((*i)->active())) {
+ _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
+ }
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->set_latency_compensation (_worst_track_latency);
+ }
+ }
+}
+
+void
+Session::post_capture_latency ()
+{
+ set_worst_capture_latency ();
+
+ /* reflect any changes in capture latencies into capture offsets
+ */
+
+ boost::shared_ptr<RouteList> rl = routes.reader();
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->set_capture_offset ();
+ }
+ }
+}
+
+void
+Session::set_worst_io_latencies ()
+{
+ set_worst_playback_latency ();
+ set_worst_capture_latency ();
+}
+
+void
+Session::set_worst_playback_latency ()
+{
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
+ _worst_output_latency = 0;
+
+ if (!_engine.connected()) {
+ return;
+ }
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
+}
+
+void
+Session::set_worst_capture_latency ()
+{
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
+ _worst_input_latency = 0;
+
+ if (!_engine.connected()) {
+ return;
+ }
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
+}
+
+void
+Session::update_latency_compensation (bool force_whole_graph)
+{
+ bool update_jack = false;
+
+ if (_state_of_the_state & Deletion) {
+ return;
+ }
+
+ DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
+
+ _worst_track_latency = 0;
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_hidden() && ((*i)->active())) {
+ framecnt_t tl;
+ if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
+ update_jack = true;
+ }
+ _worst_track_latency = max (tl, _worst_track_latency);
+ }
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
+ (update_jack ? "yes" : "no")));
+
+ if (force_whole_graph || update_jack) {
+ /* trigger a full recompute of latency numbers for the graph.
+ everything else that we need to do will be done in the latency
+ callback.
+ */
+ _engine.update_total_latencies ();
+ return; // everything else will be done in the latency callback
+ }
+
+
+
+ DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n")
+}
+
}
if (!rl.empty()) {
- add_routes (rl, false);
+ add_routes (rl, false, false);
}
/* this allows the user to override settings with an environment variable.
new_routes.push_back (route);
}
- add_routes (new_routes, false);
+ add_routes (new_routes, false, false);
return 0;
}
}
if (_engine.running()) {
- update_latency_compensation (true, abort);
+ PostTransportWork ptw = post_transport_work ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->nonrealtime_handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
+ }
+ update_latency_compensation ();
}
bool const auto_return_enabled =
return;
}
- update_latency_compensation (false, false);
+ update_latency_compensation ();
resort_routes ();
}
-void
-Session::update_latency_compensation (bool with_stop, bool abort, bool force_whole_graph)
-{
- bool update_jack = false;
- PostTransportWork ptw;
-
- if (_state_of_the_state & Deletion) {
- return;
- }
-
- _worst_track_latency = 0;
- ptw = post_transport_work();
-
- DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n")
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-
- if (with_stop) {
- (*i)->nonrealtime_handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
- }
-
- framecnt_t old_latency = (*i)->signal_latency ();
- framecnt_t new_latency = (*i)->update_signal_latency ();
-
- if (old_latency != new_latency) {
- update_jack = true;
- }
-
- if (!(*i)->is_hidden() && ((*i)->active())) {
- _worst_track_latency = max (_worst_track_latency, new_latency);
- }
- }
-
- if (force_whole_graph || update_jack) {
- /* trigger a full recompute of latency numbers for the graph
- */
- _engine.update_total_latencies ();
- }
-
- DEBUG_TRACE(DEBUG::Latency, string_compose("worst case route internal latency was %1\n", _worst_track_latency));
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->set_latency_compensation (_worst_track_latency);
- }
-
- set_worst_io_latencies ();
-
- /* reflect any changes in latencies into capture offsets
- */
-
- boost::shared_ptr<RouteList> rl = routes.reader();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr) {
- tr->set_capture_offset ();
- }
- }
- DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n")
-}
-
void
Session::allow_auto_play (bool yn)
{
projects / ardour.git / commitdiff