libs/ardour/session.cc

   1 /*
   2     Copyright (C) 1999-2010 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 #include <stdint.h>
  21
  22 #include <algorithm>
  23 #include <string>
  24 #include <vector>
  25 #include <sstream>
  26 #include <fstream>
  27 #include <cstdio> /* sprintf(3) ... grrr */
  28 #include <cmath>
  29 #include <cerrno>
  30 #include <unistd.h>
  31 #include <limits.h>
  32
  33 #include <glibmm/thread.h>
  34 #include <glibmm/miscutils.h>
  35 #include <glibmm/fileutils.h>
  36
  37 #include <boost/algorithm/string/erase.hpp>
  38
  39 #include "pbd/error.h"
  40 #include "pbd/boost_debug.h"
  41 #include "pbd/pathscanner.h"
  42 #include "pbd/stl_delete.h"
  43 #include "pbd/basename.h"
  44 #include "pbd/stacktrace.h"
  45 #include "pbd/file_utils.h"
  46 #include "pbd/convert.h"
  47 #include "pbd/strsplit.h"
  48
  49 #include "ardour/amp.h"
  50 #include "ardour/analyser.h"
  51 #include "ardour/audio_buffer.h"
  52 #include "ardour/audio_diskstream.h"
  53 #include "ardour/audio_port.h"
  54 #include "ardour/audio_track.h"
  55 #include "ardour/audioengine.h"
  56 #include "ardour/audiofilesource.h"
  57 #include "ardour/audioplaylist.h"
  58 #include "ardour/audioregion.h"
  59 #include "ardour/auditioner.h"
  60 #include "ardour/buffer_manager.h"
  61 #include "ardour/buffer_set.h"
  62 #include "ardour/bundle.h"
  63 #include "ardour/butler.h"
  64 #include "ardour/click.h"
  65 #include "ardour/configuration.h"
  66 #include "ardour/control_protocol_manager.h"
  67 #include "ardour/crossfade.h"
  68 #include "ardour/cycle_timer.h"
  69 #include "ardour/data_type.h"
  70 #include "ardour/debug.h"
  71 #include "ardour/filename_extensions.h"
  72 #include "ardour/internal_send.h"
  73 #include "ardour/io_processor.h"
  74 #include "ardour/midi_diskstream.h"
  75 #include "ardour/midi_playlist.h"
  76 #include "ardour/midi_region.h"
  77 #include "ardour/midi_track.h"
  78 #include "ardour/midi_ui.h"
  79 #include "ardour/named_selection.h"
  80 #include "ardour/process_thread.h"
  81 #include "ardour/playlist.h"
  82 #include "ardour/plugin_insert.h"
  83 #include "ardour/port_insert.h"
  84 #include "ardour/processor.h"
  85 #include "ardour/rc_configuration.h"
  86 #include "ardour/recent_sessions.h"
  87 #include "ardour/region_factory.h"
  88 #include "ardour/return.h"
  89 #include "ardour/route_group.h"
  90 #include "ardour/send.h"
  91 #include "ardour/session.h"
  92 #include "ardour/session_directory.h"
  93 #include "ardour/session_directory.h"
  94 #include "ardour/session_metadata.h"
  95 #include "ardour/session_playlists.h"
  96 #include "ardour/slave.h"
  97 #include "ardour/smf_source.h"
  98 #include "ardour/source_factory.h"
  99 #include "ardour/tape_file_matcher.h"
 100 #include "ardour/tempo.h"
 101 #include "ardour/utils.h"
 102 #include "ardour/graph.h"
 103 #include "ardour/speakers.h"
 104 #include "ardour/operations.h"
 105
 106 #include "midi++/port.h"
 107 #include "midi++/mmc.h"
 108 #include "midi++/manager.h"
 109
 110 #include "i18n.h"
 111
 112 using namespace std;
 113 using namespace ARDOUR;
 114 using namespace PBD;
 115
 116 bool Session::_disable_all_loaded_plugins = false;
 117
 118 PBD::Signal1<void,std::string> Session::Dialog;
 119 PBD::Signal0<int> Session::AskAboutPendingState;
 120 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
 121 PBD::Signal0<void> Session::SendFeedback;
 122 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
 123
 124 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
 125 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
 126 PBD::Signal0<void> Session::AutoBindingOn;
 127 PBD::Signal0<void> Session::AutoBindingOff;
 128 PBD::Signal2<void,std::string, std::string> Session::Exported;
 129 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
 130 PBD::Signal0<void> Session::Quit;
 131
 132 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
 133 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
 134
 135 Session::Session (AudioEngine &eng,
 136                   const string& fullpath,
 137                   const string& snapshot_name,
 138                   BusProfile* bus_profile,
 139                   string mix_template)
 140         : _engine (eng)
 141         , _target_transport_speed (0.0)
 142         , _requested_return_frame (-1)
 143         , _session_dir (new SessionDirectory(fullpath))
 144         , state_tree (0)
 145         , _state_of_the_state (Clean)
 146         , _butler (new Butler (*this))
 147         , _post_transport_work (0)
 148         , _send_timecode_update (false)
 149         , _all_route_group (new RouteGroup (*this, "all"))
 150         , route_graph (new Graph(*this))
 151         , routes (new RouteList)
 152         , _total_free_4k_blocks (0)
 153         , _bundles (new BundleList)
 154         , _bundle_xml_node (0)
 155         , _current_trans (0)
 156         , _click_io ((IO*) 0)
 157         , click_data (0)
 158         , click_emphasis_data (0)
 159         , main_outs (0)
 160         , _metadata (new SessionMetadata())
 161         , _have_rec_enabled_track (false)
 162         , _suspend_timecode_transmission (0)
 163 {
 164         _locations = new Locations (*this);
 165
 166         playlists.reset (new SessionPlaylists);
 167
 168         _all_route_group->set_active (true, this);
 169
 170         interpolation.add_channel_to (0, 0);
 171
 172         if (!eng.connected()) {
 173                 throw failed_constructor();
 174         }
 175
 176         n_physical_outputs = _engine.n_physical_outputs ();
 177         n_physical_inputs =  _engine.n_physical_inputs ();
 178
 179         first_stage_init (fullpath, snapshot_name);
 180
 181         _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
 182
 183         if (_is_new) {
 184                 if (create (mix_template, bus_profile)) {
 185                         destroy ();
 186                         throw failed_constructor ();
 187                 }
 188         }
 189
 190         if (second_stage_init ()) {
 191                 destroy ();
 192                 throw failed_constructor ();
 193         }
 194
 195         store_recent_sessions(_name, _path);
 196
 197         bool was_dirty = dirty();
 198
 199         _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 200
 201         Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
 202         config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
 203
 204         if (was_dirty) {
 205                 DirtyChanged (); /* EMIT SIGNAL */
 206         }
 207
 208         StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
 209         EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
 210
 211         _is_new = false;
 212 }
 213
 214 Session::~Session ()
 215 {
 216         destroy ();
 217 }
 218
 219 void
 220 Session::destroy ()
 221 {
 222         vector<void*> debug_pointers;
 223
 224         /* if we got to here, leaving pending capture state around
 225            is a mistake.
 226         */
 227
 228         remove_pending_capture_state ();
 229
 230         _state_of_the_state = StateOfTheState (CannotSave|Deletion);
 231
 232         _engine.remove_session ();
 233
 234         /* clear history so that no references to objects are held any more */
 235
 236         _history.clear ();
 237
 238         /* clear state tree so that no references to objects are held any more */
 239
 240         delete state_tree;
 241
 242         /* reset dynamic state version back to default */
 243
 244         Stateful::loading_state_version = 0;
 245
 246         _butler->drop_references ();
 247         delete _butler;
 248         delete midi_control_ui;
 249         delete _all_route_group;
 250
 251         if (click_data != default_click) {
 252                 delete [] click_data;
 253         }
 254
 255         if (click_emphasis_data != default_click_emphasis) {
 256                 delete [] click_emphasis_data;
 257         }
 258
 259         clear_clicks ();
 260
 261         /* clear out any pending dead wood from RCU managed objects */
 262
 263         routes.flush ();
 264         _bundles.flush ();
 265
 266         AudioDiskstream::free_working_buffers();
 267
 268         /* tell everyone who is still standing that we're about to die */
 269         drop_references ();
 270
 271         /* tell everyone to drop references and delete objects as we go */
 272
 273         DEBUG_TRACE (DEBUG::Destruction, "delete named selections\n");
 274         named_selections.clear ();
 275
 276         DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
 277         RegionFactory::delete_all_regions ();
 278
 279         DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
 280
 281         /* reset these three references to special routes before we do the usual route delete thing */
 282
 283         auditioner.reset ();
 284         _master_out.reset ();
 285         _monitor_out.reset ();
 286
 287         {
 288                 RCUWriter<RouteList> writer (routes);
 289                 boost::shared_ptr<RouteList> r = writer.get_copy ();
 290
 291                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 292                         DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
 293                         (*i)->drop_references ();
 294                 }
 295
 296                 r->clear ();
 297                 /* writer goes out of scope and updates master */
 298         }
 299         routes.flush ();
 300
 301         DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
 302         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 303                 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
 304                 i->second->drop_references ();
 305         }
 306
 307         sources.clear ();
 308
 309         DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
 310         for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
 311
 312                 delete *i;
 313         }
 314
 315         Crossfade::set_buffer_size (0);
 316
 317         /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
 318         playlists.reset ();
 319
 320         delete _locations;
 321
 322         DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
 323
 324 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
 325         boost_debug_list_ptrs ();
 326 #endif
 327 }
 328
 329 void
 330 Session::when_engine_running ()
 331 {
 332         string first_physical_output;
 333
 334         BootMessage (_("Set block size and sample rate"));
 335
 336         set_block_size (_engine.frames_per_cycle());
 337         set_frame_rate (_engine.frame_rate());
 338
 339         BootMessage (_("Using configuration"));
 340
 341         boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
 342         boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
 343
 344         Config->map_parameters (ff);
 345         config.map_parameters (ft);
 346
 347         /* every time we reconnect, recompute worst case output latencies */
 348
 349         _engine.Running.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies, this));
 350
 351         if (synced_to_jack()) {
 352                 _engine.transport_stop ();
 353         }
 354
 355         if (config.get_jack_time_master()) {
 356                 _engine.transport_locate (_transport_frame);
 357         }
 358
 359         _clicking = false;
 360
 361         try {
 362                 XMLNode* child = 0;
 363
 364                 _click_io.reset (new ClickIO (*this, "click"));
 365
 366                 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
 367
 368                         /* existing state for Click */
 369                         int c;
 370
 371                         if (Stateful::loading_state_version < 3000) {
 372                                 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
 373                         } else {
 374                                 c = _click_io->set_state (*child->children().front(), Stateful::loading_state_version);
 375                         }
 376
 377
 378                         if (c == 0) {
 379                                 _clicking = Config->get_clicking ();
 380
 381                         } else {
 382
 383                                 error << _("could not setup Click I/O") << endmsg;
 384                                 _clicking = false;
 385                         }
 386
 387
 388                 } else {
 389
 390                         /* default state for Click: dual-mono to first 2 physical outputs */
 391
 392                         vector<string> outs;
 393                         _engine.get_physical_outputs (DataType::AUDIO, outs);
 394
 395                         for (uint32_t physport = 0; physport < 2; ++physport) {
 396                                 if (outs.size() > physport) {
 397                                         if (_click_io->add_port (outs[physport], this)) {
 398                                                 // relax, even though its an error
 399                                         }
 400                                 }
 401                         }
 402
 403                         if (_click_io->n_ports () > ChanCount::ZERO) {
 404                                 _clicking = Config->get_clicking ();
 405                         }
 406                 }
 407         }
 408
 409         catch (failed_constructor& err) {
 410                 error << _("cannot setup Click I/O") << endmsg;
 411         }
 412
 413         BootMessage (_("Compute I/O Latencies"));
 414
 415         if (_clicking) {
 416                 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
 417         }
 418
 419         BootMessage (_("Set up standard connections"));
 420
 421         vector<string> inputs[DataType::num_types];
 422         vector<string> outputs[DataType::num_types];
 423         for (uint32_t i = 0; i < DataType::num_types; ++i) {
 424                 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
 425                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
 426         }
 427
 428         /* Create a set of Bundle objects that map
 429            to the physical I/O currently available.  We create both
 430            mono and stereo bundles, so that the common cases of mono
 431            and stereo tracks get bundles to put in their mixer strip
 432            in / out menus.  There may be a nicer way of achieving that;
 433            it doesn't really scale that well to higher channel counts
 434         */
 435
 436         /* mono output bundles */
 437
 438         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
 439                 char buf[32];
 440                 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
 441
 442                 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
 443                 c->add_channel (_("mono"), DataType::AUDIO);
 444                 c->set_port (0, outputs[DataType::AUDIO][np]);
 445
 446                 add_bundle (c);
 447         }
 448
 449         /* stereo output bundles */
 450
 451         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
 452                 if (np + 1 < outputs[DataType::AUDIO].size()) {
 453                         char buf[32];
 454                         snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
 455                         boost::shared_ptr<Bundle> c (new Bundle (buf, true));
 456                         c->add_channel (_("L"), DataType::AUDIO);
 457                         c->set_port (0, outputs[DataType::AUDIO][np]);
 458                         c->add_channel (_("R"), DataType::AUDIO);
 459                         c->set_port (1, outputs[DataType::AUDIO][np + 1]);
 460
 461                         add_bundle (c);
 462                 }
 463         }
 464
 465         /* mono input bundles */
 466
 467         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
 468                 char buf[32];
 469                 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
 470
 471                 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
 472                 c->add_channel (_("mono"), DataType::AUDIO);
 473                 c->set_port (0, inputs[DataType::AUDIO][np]);
 474
 475                 add_bundle (c);
 476         }
 477
 478         /* stereo input bundles */
 479
 480         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
 481                 if (np + 1 < inputs[DataType::AUDIO].size()) {
 482                         char buf[32];
 483                         snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
 484
 485                         boost::shared_ptr<Bundle> c (new Bundle (buf, false));
 486                         c->add_channel (_("L"), DataType::AUDIO);
 487                         c->set_port (0, inputs[DataType::AUDIO][np]);
 488                         c->add_channel (_("R"), DataType::AUDIO);
 489                         c->set_port (1, inputs[DataType::AUDIO][np + 1]);
 490
 491                         add_bundle (c);
 492                 }
 493         }
 494
 495         /* MIDI input bundles */
 496
 497         for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
 498                 string n = inputs[DataType::MIDI][np];
 499                 boost::erase_first (n, X_("alsa_pcm:"));
 500
 501                 boost::shared_ptr<Bundle> c (new Bundle (n, false));
 502                 c->add_channel ("", DataType::MIDI);
 503                 c->set_port (0, inputs[DataType::MIDI][np]);
 504                 add_bundle (c);
 505         }
 506
 507         /* MIDI output bundles */
 508
 509         for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
 510                 string n = outputs[DataType::MIDI][np];
 511                 boost::erase_first (n, X_("alsa_pcm:"));
 512
 513                 boost::shared_ptr<Bundle> c (new Bundle (n, true));
 514                 c->add_channel ("", DataType::MIDI);
 515                 c->set_port (0, outputs[DataType::MIDI][np]);
 516                 add_bundle (c);
 517         }
 518
 519         BootMessage (_("Setup signal flow and plugins"));
 520
 521         ControlProtocolManager::instance().set_session (this);
 522
 523         /* This must be done after the ControlProtocolManager set_session above,
 524            as it will set states for ports which the ControlProtocolManager creates.
 525         */
 526         MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
 527
 528         /* And this must be done after the MIDI::Manager::set_port_states as
 529          * it will try to make connections whose details are loaded by set_port_states.
 530          */
 531
 532         hookup_io ();
 533
 534         if (_is_new && !no_auto_connect()) {
 535
 536                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
 537
 538                 /* don't connect the master bus outputs if there is a monitor bus */
 539
 540                 if (_master_out && Config->get_auto_connect_standard_busses() && !_monitor_out) {
 541
 542                         /* if requested auto-connect the outputs to the first N physical ports.
 543                          */
 544
 545                         uint32_t limit = _master_out->n_outputs().n_total();
 546
 547                         for (uint32_t n = 0; n < limit; ++n) {
 548                                 Port* p = _master_out->output()->nth (n);
 549                                 string connect_to;
 550                                 if (outputs[p->type()].size() > n) {
 551                                         connect_to = outputs[p->type()][n];
 552                                 }
 553
 554                                 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
 555                                         if (_master_out->output()->connect (p, connect_to, this)) {
 556                                                 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
 557                                                       << endmsg;
 558                                                 break;
 559                                         }
 560                                 }
 561                         }
 562                 }
 563
 564                 if (_monitor_out) {
 565
 566                         /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
 567                            are undefined, at best.
 568                          */
 569
 570                         /* control out listens to master bus (but ignores it
 571                            under some conditions)
 572                         */
 573
 574                         uint32_t limit = _monitor_out->n_inputs().n_audio();
 575
 576                         if (_master_out) {
 577                                 for (uint32_t n = 0; n < limit; ++n) {
 578                                         AudioPort* p = _monitor_out->input()->ports().nth_audio_port (n);
 579                                         AudioPort* o = _master_out->output()->ports().nth_audio_port (n);
 580
 581                                         if (o) {
 582                                                 string connect_to = o->name();
 583                                                 if (_monitor_out->input()->connect (p, connect_to, this)) {
 584                                                         error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
 585                                                               << endmsg;
 586                                                         break;
 587                                                 }
 588                                         }
 589                                 }
 590                         }
 591
 592                         /* if control out is not connected, connect control out to physical outs
 593                         */
 594
 595                         if (!_monitor_out->output()->connected ()) {
 596
 597                                 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
 598
 599                                         boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
 600
 601                                         if (b) {
 602                                                 _monitor_out->output()->connect_ports_to_bundle (b, this);
 603                                         } else {
 604                                                 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
 605                                                                            Config->get_monitor_bus_preferred_bundle())
 606                                                         << endmsg;
 607                                         }
 608
 609                                 } else {
 610
 611                                         /* Monitor bus is audio only */
 612                                         uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
 613                                         uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
 614
 615                                         if (mod != 0) {
 616
 617                                                 for (uint32_t n = 0; n < limit; ++n) {
 618
 619                                                         Port* p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
 620                                                         string connect_to;
 621                                                         if (outputs[DataType::AUDIO].size() > (n % mod)) {
 622                                                                 connect_to = outputs[DataType::AUDIO][n % mod];
 623                                                         }
 624
 625                                                         if (!connect_to.empty()) {
 626                                                                 if (_monitor_out->output()->connect (p, connect_to, this)) {
 627                                                                         error << string_compose (
 628                                                                                         _("cannot connect control output %1 to %2"),
 629                                                                                         n, connect_to)
 630                                                                                 << endmsg;
 631                                                                         break;
 632                                                                 }
 633                                                         }
 634                                                 }
 635                                         }
 636                                 }
 637                         }
 638                 }
 639         }
 640
 641         _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
 642
 643         /* hook us up to the engine */
 644
 645         BootMessage (_("Connect to engine"));
 646         _engine.set_session (this);
 647
 648         update_latency_compensation (true);
 649 }
 650
 651 void
 652 Session::hookup_io ()
 653 {
 654         /* stop graph reordering notifications from
 655            causing resorts, etc.
 656         */
 657
 658         _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
 659
 660         if (!auditioner) {
 661
 662                 /* we delay creating the auditioner till now because
 663                    it makes its own connections to ports.
 664                 */
 665
 666                 try {
 667                         boost::shared_ptr<Auditioner> a (new Auditioner (*this));
 668                         if (a->init()) {
 669                                 throw failed_constructor ();
 670                         }
 671                         a->use_new_diskstream ();
 672                         auditioner = a;
 673                 }
 674
 675                 catch (failed_constructor& err) {
 676                         warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
 677                 }
 678         }
 679
 680         /* load bundles, which we may have postponed earlier on */
 681         if (_bundle_xml_node) {
 682                 load_bundles (*_bundle_xml_node);
 683                 delete _bundle_xml_node;
 684         }
 685
 686         /* Tell all IO objects to connect themselves together */
 687
 688         IO::enable_connecting ();
 689         MIDI::Port::MakeConnections ();
 690
 691         /* Now reset all panners */
 692
 693         Delivery::reset_panners ();
 694
 695         /* Connect tracks to monitor/listen bus if there is one.  Note that in an
 696            existing session, the internal sends will already exist, but we want the
 697            routes to notice that they connect to the control out specifically.
 698         */
 699
 700         if (_monitor_out) {
 701                 boost::shared_ptr<RouteList> r = routes.reader ();
 702                 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
 703
 704                         if ((*x)->is_monitor()) {
 705
 706                                 /* relax */
 707
 708                         } else if ((*x)->is_master()) {
 709
 710                                 /* relax */
 711
 712                         } else {
 713
 714                                 (*x)->listen_via_monitor ();
 715                         }
 716                 }
 717         }
 718
 719         /* Anyone who cares about input state, wake up and do something */
 720
 721         IOConnectionsComplete (); /* EMIT SIGNAL */
 722
 723         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
 724
 725         /* now handle the whole enchilada as if it was one
 726            graph reorder event.
 727         */
 728
 729         graph_reordered ();
 730
 731         /* update the full solo state, which can't be
 732            correctly determined on a per-route basis, but
 733            needs the global overview that only the session
 734            has.
 735         */
 736
 737         update_route_solo_state ();
 738 }
 739
 740 void
 741 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
 742 {
 743         boost::shared_ptr<Track> track = wp.lock ();
 744         if (!track) {
 745                 return;
 746         }
 747
 748         boost::shared_ptr<Playlist> playlist;
 749
 750         if ((playlist = track->playlist()) != 0) {
 751                 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
 752                 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
 753                 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
 754         }
 755 }
 756
 757 bool
 758 Session::record_enabling_legal () const
 759 {
 760         /* this used to be in here, but survey says.... we don't need to restrict it */
 761         // if (record_status() == Recording) {
 762         //      return false;
 763         // }
 764
 765         if (Config->get_all_safe()) {
 766                 return false;
 767         }
 768         return true;
 769 }
 770
 771 void
 772 Session::set_track_monitor_input_status (bool yn)
 773 {
 774         boost::shared_ptr<RouteList> rl = routes.reader ();
 775         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 776                 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
 777                 if (tr && tr->record_enabled ()) {
 778                         //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
 779                         tr->monitor_input (yn);
 780                 }
 781         }
 782 }
 783
 784 void
 785 Session::reset_input_monitor_state ()
 786 {
 787         if (transport_rolling()) {
 788                 set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
 789         } else {
 790                 set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring);
 791         }
 792 }
 793
 794 void
 795 Session::auto_punch_start_changed (Location* location)
 796 {
 797         replace_event (SessionEvent::PunchIn, location->start());
 798
 799         if (get_record_enabled() && config.get_punch_in()) {
 800                 /* capture start has been changed, so save new pending state */
 801                 save_state ("", true);
 802         }
 803 }
 804
 805 void
 806 Session::auto_punch_end_changed (Location* location)
 807 {
 808         framepos_t when_to_stop = location->end();
 809         // when_to_stop += _worst_output_latency + _worst_input_latency;
 810         replace_event (SessionEvent::PunchOut, when_to_stop);
 811 }
 812
 813 void
 814 Session::auto_punch_changed (Location* location)
 815 {
 816         framepos_t when_to_stop = location->end();
 817
 818         replace_event (SessionEvent::PunchIn, location->start());
 819         //when_to_stop += _worst_output_latency + _worst_input_latency;
 820         replace_event (SessionEvent::PunchOut, when_to_stop);
 821 }
 822
 823 void
 824 Session::auto_loop_changed (Location* location)
 825 {
 826         replace_event (SessionEvent::AutoLoop, location->end(), location->start());
 827
 828         if (transport_rolling() && play_loop) {
 829
 830
 831                 // if (_transport_frame > location->end()) {
 832
 833                 if (_transport_frame < location->start() || _transport_frame > location->end()) {
 834                         // relocate to beginning of loop
 835                         clear_events (SessionEvent::LocateRoll);
 836
 837                         request_locate (location->start(), true);
 838
 839                 }
 840                 else if (Config->get_seamless_loop() && !loop_changing) {
 841
 842                         // schedule a locate-roll to refill the diskstreams at the
 843                         // previous loop end
 844                         loop_changing = true;
 845
 846                         if (location->end() > last_loopend) {
 847                                 clear_events (SessionEvent::LocateRoll);
 848                                 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
 849                                 queue_event (ev);
 850                         }
 851
 852                 }
 853         }
 854
 855         last_loopend = location->end();
 856 }
 857
 858 void
 859 Session::set_auto_punch_location (Location* location)
 860 {
 861         Location* existing;
 862
 863         if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
 864                 punch_connections.drop_connections();
 865                 existing->set_auto_punch (false, this);
 866                 remove_event (existing->start(), SessionEvent::PunchIn);
 867                 clear_events (SessionEvent::PunchOut);
 868                 auto_punch_location_changed (0);
 869         }
 870
 871         set_dirty();
 872
 873         if (location == 0) {
 874                 return;
 875         }
 876
 877         if (location->end() <= location->start()) {
 878                 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
 879                 return;
 880         }
 881
 882         punch_connections.drop_connections ();
 883
 884         location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
 885         location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
 886         location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
 887
 888         location->set_auto_punch (true, this);
 889
 890         auto_punch_changed (location);
 891
 892         auto_punch_location_changed (location);
 893 }
 894
 895 void
 896 Session::set_auto_loop_location (Location* location)
 897 {
 898         Location* existing;
 899
 900         if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
 901                 loop_connections.drop_connections ();
 902                 existing->set_auto_loop (false, this);
 903                 remove_event (existing->end(), SessionEvent::AutoLoop);
 904                 auto_loop_location_changed (0);
 905         }
 906
 907         set_dirty();
 908
 909         if (location == 0) {
 910                 return;
 911         }
 912
 913         if (location->end() <= location->start()) {
 914                 error << _("Session: you can't use a mark for auto loop") << endmsg;
 915                 return;
 916         }
 917
 918         last_loopend = location->end();
 919
 920         loop_connections.drop_connections ();
 921
 922         location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
 923         location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
 924         location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
 925
 926         location->set_auto_loop (true, this);
 927
 928         /* take care of our stuff first */
 929
 930         auto_loop_changed (location);
 931
 932         /* now tell everyone else */
 933
 934         auto_loop_location_changed (location);
 935 }
 936
 937 void
 938 Session::locations_added (Location *)
 939 {
 940         set_dirty ();
 941 }
 942
 943 void
 944 Session::locations_changed ()
 945 {
 946         _locations->apply (*this, &Session::handle_locations_changed);
 947 }
 948
 949 void
 950 Session::handle_locations_changed (Locations::LocationList& locations)
 951 {
 952         Locations::LocationList::iterator i;
 953         Location* location;
 954         bool set_loop = false;
 955         bool set_punch = false;
 956
 957         for (i = locations.begin(); i != locations.end(); ++i) {
 958
 959                 location =* i;
 960
 961                 if (location->is_auto_punch()) {
 962                         set_auto_punch_location (location);
 963                         set_punch = true;
 964                 }
 965                 if (location->is_auto_loop()) {
 966                         set_auto_loop_location (location);
 967                         set_loop = true;
 968                 }
 969
 970                 if (location->is_session_range()) {
 971                         _session_range_location = location;
 972                 }
 973         }
 974
 975         if (!set_loop) {
 976                 set_auto_loop_location (0);
 977         }
 978         if (!set_punch) {
 979                 set_auto_punch_location (0);
 980         }
 981
 982         set_dirty();
 983 }
 984
 985 void
 986 Session::enable_record ()
 987 {
 988         if (_transport_speed < 0.0) {
 989                 /* no recording in reverse */
 990                 return;
 991         }
 992
 993         while (1) {
 994                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
 995
 996                 if (rs == Recording) {
 997                         break;
 998                 }
 999
1000                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1001
1002                         _last_record_location = _transport_frame;
1003                         MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1004
1005                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1006                                 set_track_monitor_input_status (true);
1007                         }
1008
1009                         RecordStateChanged ();
1010                         break;
1011                 }
1012         }
1013 }
1014
1015 void
1016 Session::disable_record (bool rt_context, bool force)
1017 {
1018         RecordState rs;
1019
1020         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1021
1022                 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1023                         g_atomic_int_set (&_record_status, Disabled);
1024                         MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1025                 } else {
1026                         if (rs == Recording) {
1027                                 g_atomic_int_set (&_record_status, Enabled);
1028                         }
1029                 }
1030
1031                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1032                         set_track_monitor_input_status (false);
1033                 }
1034
1035                 RecordStateChanged (); /* emit signal */
1036
1037                 if (!rt_context) {
1038                         remove_pending_capture_state ();
1039                 }
1040         }
1041 }
1042
1043 void
1044 Session::step_back_from_record ()
1045 {
1046         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1047
1048                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1049                         set_track_monitor_input_status (false);
1050                 }
1051         }
1052 }
1053
1054 void
1055 Session::maybe_enable_record ()
1056 {
1057         if (_step_editors > 0) {
1058                 return;
1059         }
1060
1061         g_atomic_int_set (&_record_status, Enabled);
1062
1063         /* This function is currently called from somewhere other than an RT thread.
1064            This save_state() call therefore doesn't impact anything.  Doing it here
1065            means that we save pending state of which sources the next record will use,
1066            which gives us some chance of recovering from a crash during the record.
1067         */
1068
1069         save_state ("", true);
1070
1071         if (_transport_speed) {
1072                 if (!config.get_punch_in()) {
1073                         enable_record ();
1074                 }
1075         } else {
1076                 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1077                 RecordStateChanged (); /* EMIT SIGNAL */
1078         }
1079
1080         set_dirty();
1081 }
1082
1083 framepos_t
1084 Session::audible_frame () const
1085 {
1086         framepos_t ret;
1087         framepos_t tf;
1088         framecnt_t offset;
1089
1090         /* the first of these two possible settings for "offset"
1091            mean that the audible frame is stationary until
1092            audio emerges from the latency compensation
1093            "pseudo-pipeline".
1094
1095            the second means that the audible frame is stationary
1096            until audio would emerge from a physical port
1097            in the absence of any plugin latency compensation
1098         */
1099
1100         offset = worst_playback_latency ();
1101
1102         if (offset > current_block_size) {
1103                 offset -= current_block_size;
1104         } else {
1105                 /* XXX is this correct? if we have no external
1106                    physical connections and everything is internal
1107                    then surely this is zero? still, how
1108                    likely is that anyway?
1109                 */
1110                 offset = current_block_size;
1111         }
1112
1113         if (synced_to_jack()) {
1114                 tf = _engine.transport_frame();
1115         } else {
1116                 tf = _transport_frame;
1117         }
1118
1119         ret = tf;
1120
1121         if (!non_realtime_work_pending()) {
1122
1123                 /* MOVING */
1124
1125                 /* Check to see if we have passed the first guaranteed
1126                    audible frame past our last start position. if not,
1127                    return that last start point because in terms
1128                    of audible frames, we have not moved yet.
1129
1130                    `Start position' in this context means the time we last
1131                    either started or changed transport direction.
1132                 */
1133
1134                 if (_transport_speed > 0.0f) {
1135
1136                         if (!play_loop || !have_looped) {
1137                                 if (tf < _last_roll_or_reversal_location + offset) {
1138                                         return _last_roll_or_reversal_location;
1139                                 }
1140                         }
1141
1142
1143                         /* forwards */
1144                         ret -= offset;
1145
1146                 } else if (_transport_speed < 0.0f) {
1147
1148                         /* XXX wot? no backward looping? */
1149
1150                         if (tf > _last_roll_or_reversal_location - offset) {
1151                                 return _last_roll_or_reversal_location;
1152                         } else {
1153                                 /* backwards */
1154                                 ret += offset;
1155                         }
1156                 }
1157         }
1158
1159         return ret;
1160 }
1161
1162 void
1163 Session::set_frame_rate (framecnt_t frames_per_second)
1164 {
1165         /** \fn void Session::set_frame_size(framecnt_t)
1166                 the AudioEngine object that calls this guarantees
1167                 that it will not be called while we are also in
1168                 ::process(). Its fine to do things that block
1169                 here.
1170         */
1171
1172         _base_frame_rate = frames_per_second;
1173
1174         sync_time_vars();
1175
1176         Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
1177
1178         clear_clicks ();
1179
1180         // XXX we need some equivalent to this, somehow
1181         // SndFileSource::setup_standard_crossfades (frames_per_second);
1182
1183         set_dirty();
1184
1185         /* XXX need to reset/reinstantiate all LADSPA plugins */
1186 }
1187
1188 void
1189 Session::set_block_size (pframes_t nframes)
1190 {
1191         /* the AudioEngine guarantees
1192            that it will not be called while we are also in
1193            ::process(). It is therefore fine to do things that block
1194            here.
1195         */
1196
1197         {
1198                 current_block_size = nframes;
1199
1200                 ensure_buffers ();
1201
1202                 boost::shared_ptr<RouteList> r = routes.reader ();
1203
1204                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1205                         (*i)->set_block_size (nframes);
1206                 }
1207
1208                 boost::shared_ptr<RouteList> rl = routes.reader ();
1209                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1210                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1211                         if (tr) {
1212                                 tr->set_block_size (nframes);
1213                         }
1214                 }
1215
1216                 set_worst_io_latencies ();
1217         }
1218 }
1219
1220 struct RouteSorter {
1221     /** @return true to run r1 before r2, otherwise false */
1222     bool sort_by_rec_enabled (const boost::shared_ptr<Route>& r1, const boost::shared_ptr<Route>& r2) {
1223             if (r1->record_enabled()) {
1224                     if (r2->record_enabled()) {
1225                             /* both rec-enabled, just use signal order */
1226                             return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1227                     } else {
1228                             /* r1 rec-enabled, r2 not rec-enabled, run r2 early */
1229                             return false;
1230                     }
1231             } else {
1232                     if (r2->record_enabled()) {
1233                             /* r2 rec-enabled, r1 not rec-enabled, run r1 early */
1234                             return true;
1235                     } else {
1236                             /* neither rec-enabled, use signal order */
1237                             return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1238                     }
1239             }
1240     }
1241
1242     bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
1243             if (r2->feeds (r1)) {
1244                     /* r1 fed by r2; run r2 early */
1245                     return false;
1246             } else if (r1->feeds (r2)) {
1247                     /* r2 fed by r1; run r1 early */
1248                     return true;
1249             } else {
1250                     if (r1->not_fed ()) {
1251                             if (r2->not_fed ()) {
1252                                     /* no ardour-based connections inbound to either route. */
1253                                     return sort_by_rec_enabled (r1, r2);
1254                             } else {
1255                                     /* r2 has connections, r1 does not; run r1 early */
1256                                     return true;
1257                             }
1258                     } else {
1259                             if (r2->not_fed()) {
1260                                     /* r1 has connections, r2 does not; run r2 early */
1261                                     return false;
1262                             } else {
1263                                     /* both r1 and r2 have connections, but not to each other. just use signal order */
1264                                     return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1265                             }
1266                     }
1267             }
1268     }
1269 };
1270
1271 static void
1272 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1273 {
1274         boost::shared_ptr<Route> r2;
1275
1276         if (r1->feeds (rbase) && rbase->feeds (r1)) {
1277                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1278                 return;
1279         }
1280
1281         /* make a copy of the existing list of routes that feed r1 */
1282
1283         Route::FedBy existing (r1->fed_by());
1284
1285         /* for each route that feeds r1, recurse, marking it as feeding
1286            rbase as well.
1287         */
1288
1289         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1290                 if (!(r2 = i->r.lock ())) {
1291                         /* (*i) went away, ignore it */
1292                         continue;
1293                 }
1294
1295                 /* r2 is a route that feeds r1 which somehow feeds base. mark
1296                    base as being fed by r2
1297                 */
1298
1299                 rbase->add_fed_by (r2, i->sends_only);
1300
1301                 if (r2 != rbase) {
1302
1303                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1304                            stop here.
1305                         */
1306
1307                         if (r1->feeds (r2) && r2->feeds (r1)) {
1308                                 continue;
1309                         }
1310
1311                         /* now recurse, so that we can mark base as being fed by
1312                            all routes that feed r2
1313                         */
1314
1315                         trace_terminal (r2, rbase);
1316                 }
1317
1318         }
1319 }
1320
1321 void
1322 Session::resort_routes ()
1323 {
1324         /* don't do anything here with signals emitted
1325            by Routes while we are being destroyed.
1326         */
1327
1328         if (_state_of_the_state & Deletion) {
1329                 return;
1330         }
1331
1332         {
1333                 RCUWriter<RouteList> writer (routes);
1334                 boost::shared_ptr<RouteList> r = writer.get_copy ();
1335                 resort_routes_using (r);
1336                 /* writer goes out of scope and forces update */
1337         }
1338
1339         //route_graph->dump(1);
1340
1341 #ifndef NDEBUG
1342         boost::shared_ptr<RouteList> rl = routes.reader ();
1343         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1344                 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1345
1346                 const Route::FedBy& fb ((*i)->fed_by());
1347
1348                 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1349                         boost::shared_ptr<Route> sf = f->r.lock();
1350                         if (sf) {
1351                                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1352                         }
1353                 }
1354         }
1355 #endif
1356
1357 }
1358 void
1359 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1360 {
1361         RouteList::iterator i, j;
1362
1363         for (i = r->begin(); i != r->end(); ++i) {
1364
1365                 (*i)->clear_fed_by ();
1366
1367                 for (j = r->begin(); j != r->end(); ++j) {
1368
1369                         /* although routes can feed themselves, it will
1370                            cause an endless recursive descent if we
1371                            detect it. so don't bother checking for
1372                            self-feeding.
1373                         */
1374
1375                         if (*j == *i) {
1376                                 continue;
1377                         }
1378
1379                         bool via_sends_only;
1380
1381                         if ((*j)->direct_feeds (*i, &via_sends_only)) {
1382                                 (*i)->add_fed_by (*j, via_sends_only);
1383                         }
1384                 }
1385         }
1386
1387         for (i = r->begin(); i != r->end(); ++i) {
1388                 trace_terminal (*i, *i);
1389         }
1390
1391         RouteSorter cmp;
1392         r->sort (cmp);
1393
1394         route_graph->rechain (r);
1395
1396 #ifndef NDEBUG
1397         DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1398         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1399                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1400                                                            (*i)->name(), (*i)->order_key ("signal")));
1401         }
1402 #endif
1403
1404 }
1405
1406 /** Find a route name starting with \a base, maybe followed by the
1407  *  lowest \a id.  \a id will always be added if \a definitely_add_number
1408  *  is true on entry; otherwise it will only be added if required
1409  *  to make the name unique.
1410  *
1411  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1412  *  The available route name with the lowest ID will be used, and \a id
1413  *  will be set to the ID.
1414  *
1415  *  \return false if a route name could not be found, and \a track_name
1416  *  and \a id do not reflect a free route name.
1417  */
1418 bool
1419 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1420 {
1421         if (!definitely_add_number && route_by_name (base) == 0) {
1422                 /* juse use the base */
1423                 snprintf (name, name_len, "%s", base.c_str());
1424                 return true;
1425         }
1426
1427         do {
1428                 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1429
1430                 if (route_by_name (name) == 0) {
1431                         return true;
1432                 }
1433
1434                 ++id;
1435
1436         } while (id < (UINT_MAX-1));
1437
1438         return false;
1439 }
1440
1441 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1442 void
1443 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1444 {
1445         in  = ChanCount::ZERO;
1446         out = ChanCount::ZERO;
1447
1448         boost::shared_ptr<RouteList> r = routes.reader ();
1449
1450         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1451                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1452                 if (tr && !tr->is_hidden()) {
1453                         in  += tr->n_inputs();
1454                         out += tr->n_outputs();
1455                 }
1456         }
1457 }
1458
1459 /** Caller must not hold process lock
1460  *  @param name_template string to use for the start of the name, or "" to use "Midi".
1461  */
1462 list<boost::shared_ptr<MidiTrack> >
1463 Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1464 {
1465         char track_name[32];
1466         uint32_t track_id = 0;
1467         string port;
1468         RouteList new_routes;
1469         list<boost::shared_ptr<MidiTrack> > ret;
1470         uint32_t control_id;
1471
1472         control_id = ntracks() + nbusses();
1473
1474         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi");
1475
1476         while (how_many) {
1477                 if (!find_route_name (name_template.empty() ? _("Midi") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1478                         error << "cannot find name for new midi track" << endmsg;
1479                         goto failed;
1480                 }
1481
1482                 boost::shared_ptr<MidiTrack> track;
1483
1484                 try {
1485                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1486
1487                         if (track->init ()) {
1488                                 goto failed;
1489                         }
1490
1491                         track->use_new_diskstream();
1492
1493 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1494                         boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1495 #endif
1496                         {
1497                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1498                                 if (track->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
1499                                         error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1500                                         goto failed;
1501                                 }
1502
1503                                 if (track->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
1504                                         error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1505                                         goto failed;
1506                                 }
1507                         }
1508
1509                         track->non_realtime_input_change();
1510
1511                         if (route_group) {
1512                                 route_group->add (track);
1513                         }
1514
1515                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1516                         track->set_remote_control_id (control_id);
1517
1518                         new_routes.push_back (track);
1519                         ret.push_back (track);
1520                 }
1521
1522                 catch (failed_constructor &err) {
1523                         error << _("Session: could not create new midi track.") << endmsg;
1524                         goto failed;
1525                 }
1526
1527                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1528
1529                         error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1530                         goto failed;
1531                 }
1532
1533                 --how_many;
1534         }
1535
1536   failed:
1537         if (!new_routes.empty()) {
1538                 add_routes (new_routes, true, true);
1539         }
1540
1541         return ret;
1542 }
1543
1544 void
1545 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1546 {
1547         boost::shared_ptr<Route> midi_track (wmt.lock());
1548
1549         if (!midi_track) {
1550                 return;
1551         }
1552
1553         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1554
1555                 if (change.after.n_audio() <= change.before.n_audio()) {
1556                         return;
1557                 }
1558
1559                 /* new audio ports: make sure the audio goes somewhere useful,
1560                    unless the user has no-auto-connect selected.
1561
1562                    The existing ChanCounts don't matter for this call as they are only
1563                    to do with matching input and output indices, and we are only changing
1564                    outputs here.
1565                 */
1566
1567                 ChanCount dummy;
1568
1569                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1570         }
1571 }
1572
1573 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1574  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1575  *  @param output_start As \a input_start, but for outputs.
1576  */
1577 void
1578 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1579                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1580 {
1581         if (!IO::connecting_legal) {
1582                 return;
1583         }
1584
1585         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
1586
1587         if (with_lock) {
1588                 lm.acquire ();
1589         }
1590
1591         /* If both inputs and outputs are auto-connected to physical ports,
1592            use the max of input and output offsets to ensure auto-connected
1593            port numbers always match up (e.g. the first audio input and the
1594            first audio output of the route will have the same physical
1595            port number).  Otherwise just use the lowest input or output
1596            offset possible.
1597         */
1598
1599         DEBUG_TRACE (DEBUG::Graph,
1600                      string_compose("Auto-connect: existing in = %1 out = %2\n",
1601                                     existing_inputs, existing_outputs));
1602
1603         const bool in_out_physical =
1604                 (Config->get_input_auto_connect() & AutoConnectPhysical)
1605                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1606                 && connect_inputs;
1607
1608         const ChanCount in_offset = in_out_physical
1609                 ? ChanCount::max(existing_inputs, existing_outputs)
1610                 : existing_inputs;
1611
1612         const ChanCount out_offset = in_out_physical
1613                 ? ChanCount::max(existing_inputs, existing_outputs)
1614                 : existing_outputs;
1615
1616         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1617                 vector<string> physinputs;
1618                 vector<string> physoutputs;
1619
1620                 _engine.get_physical_outputs (*t, physoutputs);
1621                 _engine.get_physical_inputs (*t, physinputs);
1622
1623                 if (!physinputs.empty() && connect_inputs) {
1624                         uint32_t nphysical_in = physinputs.size();
1625
1626                         DEBUG_TRACE (DEBUG::Graph,
1627                                      string_compose("There are %1 physical inputs of type %2\n",
1628                                                     nphysical_in, *t));
1629
1630                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1631                                 string port;
1632
1633                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1634                                         DEBUG_TRACE (DEBUG::Graph,
1635                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
1636                                                                     in_offset.get(*t), i, nphysical_in,
1637                                                                     (in_offset.get(*t) + i) % nphysical_in));
1638                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1639                                 }
1640
1641                                 DEBUG_TRACE (DEBUG::Graph,
1642                                              string_compose("Connect route %1 IN to %2\n",
1643                                                             route->name(), port));
1644
1645                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1646                                         break;
1647                                 }
1648
1649                                 ChanCount one_added (*t, 1);
1650                                 existing_inputs += one_added;
1651                         }
1652                 }
1653
1654                 if (!physoutputs.empty()) {
1655                         uint32_t nphysical_out = physoutputs.size();
1656                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1657                                 string port;
1658
1659                                 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1660                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1661                                 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1662                                         /* master bus is audio only */
1663                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1664                                                 port = _master_out->input()->ports().port(*t,
1665                                                                 i % _master_out->input()->n_ports().get(*t))->name();
1666                                         }
1667                                 }
1668
1669                                 DEBUG_TRACE (DEBUG::Graph,
1670                                              string_compose("Connect route %1 OUT to %2\n",
1671                                                             route->name(), port));
1672
1673                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
1674                                         break;
1675                                 }
1676
1677                                 ChanCount one_added (*t, 1);
1678                                 existing_outputs += one_added;
1679                         }
1680                 }
1681         }
1682 }
1683
1684 /** Caller must not hold process lock
1685  *  @param name_template string to use for the start of the name, or "" to use "Audio".
1686  */
1687 list< boost::shared_ptr<AudioTrack> >
1688 Session::new_audio_track (
1689         int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template
1690         )
1691 {
1692         char track_name[32];
1693         uint32_t track_id = 0;
1694         string port;
1695         RouteList new_routes;
1696         list<boost::shared_ptr<AudioTrack> > ret;
1697         uint32_t control_id;
1698
1699         control_id = ntracks() + nbusses() + 1;
1700
1701         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
1702
1703         while (how_many) {
1704                 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1705                         error << "cannot find name for new audio track" << endmsg;
1706                         goto failed;
1707                 }
1708
1709                 boost::shared_ptr<AudioTrack> track;
1710
1711                 try {
1712                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1713
1714                         if (track->init ()) {
1715                                 goto failed;
1716                         }
1717
1718                         track->use_new_diskstream();
1719
1720 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1721                         boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1722 #endif
1723                         {
1724                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1725
1726                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1727                                         error << string_compose (
1728                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
1729                                                 input_channels, output_channels)
1730                                               << endmsg;
1731                                         goto failed;
1732                                 }
1733
1734                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1735                                         error << string_compose (
1736                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
1737                                                 input_channels, output_channels)
1738                                               << endmsg;
1739                                         goto failed;
1740                                 }
1741                         }
1742
1743                         if (route_group) {
1744                                 route_group->add (track);
1745                         }
1746
1747                         track->non_realtime_input_change();
1748
1749                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1750                         track->set_remote_control_id (control_id);
1751                         ++control_id;
1752
1753                         new_routes.push_back (track);
1754                         ret.push_back (track);
1755                 }
1756
1757                 catch (failed_constructor &err) {
1758                         error << _("Session: could not create new audio track.") << endmsg;
1759                         goto failed;
1760                 }
1761
1762                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1763
1764                         error << pfe.what() << endmsg;
1765                         goto failed;
1766                 }
1767
1768                 --how_many;
1769         }
1770
1771   failed:
1772         if (!new_routes.empty()) {
1773                 add_routes (new_routes, true, true);
1774         }
1775
1776         return ret;
1777 }
1778
1779 void
1780 Session::set_remote_control_ids ()
1781 {
1782         RemoteModel m = Config->get_remote_model();
1783         bool emit_signal = false;
1784
1785         boost::shared_ptr<RouteList> r = routes.reader ();
1786
1787         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1788                 if (MixerOrdered == m) {
1789                         int32_t order = (*i)->order_key(N_("signal"));
1790                         (*i)->set_remote_control_id (order+1, false);
1791                         emit_signal = true;
1792                 } else if (EditorOrdered == m) {
1793                         int32_t order = (*i)->order_key(N_("editor"));
1794                         (*i)->set_remote_control_id (order+1, false);
1795                         emit_signal = true;
1796                 } else if (UserOrdered == m) {
1797                         //do nothing ... only changes to remote id's are initiated by user
1798                 }
1799         }
1800
1801         if (emit_signal) {
1802                 Route::RemoteControlIDChange();
1803         }
1804 }
1805
1806 /** Caller must not hold process lock.
1807  *  @param name_template string to use for the start of the name, or "" to use "Bus".
1808  */
1809 RouteList
1810 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1811 {
1812         char bus_name[32];
1813         uint32_t bus_id = 0;
1814         string port;
1815         RouteList ret;
1816         uint32_t control_id;
1817
1818         control_id = ntracks() + nbusses() + 1;
1819
1820         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
1821
1822         while (how_many) {
1823                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1824                         error << "cannot find name for new audio bus" << endmsg;
1825                         goto failure;
1826                 }
1827
1828                 try {
1829                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1830
1831                         if (bus->init ()) {
1832                                 goto failure;
1833                         }
1834
1835 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1836                         boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1837 #endif
1838                         {
1839                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1840
1841                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1842                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1843                                                                  input_channels, output_channels)
1844                                               << endmsg;
1845                                         goto failure;
1846                                 }
1847
1848
1849                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1850                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1851                                                                  input_channels, output_channels)
1852                                               << endmsg;
1853                                         goto failure;
1854                                 }
1855                         }
1856
1857                         if (route_group) {
1858                                 route_group->add (bus);
1859                         }
1860                         bus->set_remote_control_id (control_id);
1861                         ++control_id;
1862
1863                         bus->add_internal_return ();
1864
1865                         ret.push_back (bus);
1866                 }
1867
1868
1869                 catch (failed_constructor &err) {
1870                         error << _("Session: could not create new audio route.") << endmsg;
1871                         goto failure;
1872                 }
1873
1874                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1875                         error << pfe.what() << endmsg;
1876                         goto failure;
1877                 }
1878
1879
1880                 --how_many;
1881         }
1882
1883   failure:
1884         if (!ret.empty()) {
1885                 add_routes (ret, true, true);
1886         }
1887
1888         return ret;
1889
1890 }
1891
1892 RouteList
1893 Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
1894 {
1895         char name[32];
1896         RouteList ret;
1897         uint32_t control_id;
1898         XMLTree tree;
1899         uint32_t number = 0;
1900
1901         if (!tree.read (template_path.c_str())) {
1902                 return ret;
1903         }
1904
1905         XMLNode* node = tree.root();
1906
1907         control_id = ntracks() + nbusses() + 1;
1908
1909         while (how_many) {
1910
1911                 XMLNode node_copy (*node); // make a copy so we can change the name if we need to
1912
1913                 std::string node_name = IO::name_from_state (*node_copy.children().front());
1914
1915                 /* generate a new name by adding a number to the end of the template name */
1916                 if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name), true)) {
1917                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
1918                         /*NOTREACHED*/
1919                 }
1920
1921                 /* set IO children to use the new name */
1922                 XMLNodeList const & children = node_copy.children ();
1923                 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
1924                         if ((*i)->name() == IO::state_node_name) {
1925                                 IO::set_name_in_state (**i, name);
1926                         }
1927                 }
1928
1929                 Track::zero_diskstream_id_in_xml (node_copy);
1930
1931                 try {
1932                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
1933
1934                         if (route == 0) {
1935                                 error << _("Session: cannot create track/bus from template description") << endmsg;
1936                                 goto out;
1937                         }
1938
1939                         if (boost::dynamic_pointer_cast<Track>(route)) {
1940                                 /* force input/output change signals so that the new diskstream
1941                                    picks up the configuration of the route. During session
1942                                    loading this normally happens in a different way.
1943                                 */
1944
1945                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1946
1947                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
1948                                 change.after = route->input()->n_ports();
1949                                 route->input()->changed (change, this);
1950                                 change.after = route->output()->n_ports();
1951                                 route->output()->changed (change, this);
1952                         }
1953
1954                         route->set_remote_control_id (control_id);
1955                         ++control_id;
1956
1957                         ret.push_back (route);
1958                 }
1959
1960                 catch (failed_constructor &err) {
1961                         error << _("Session: could not create new route from template") << endmsg;
1962                         goto out;
1963                 }
1964
1965                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1966                         error << pfe.what() << endmsg;
1967                         goto out;
1968                 }
1969
1970                 --how_many;
1971         }
1972
1973   out:
1974         if (!ret.empty()) {
1975                 add_routes (ret, true, true);
1976         }
1977
1978         return ret;
1979 }
1980
1981 void
1982 Session::add_routes (RouteList& new_routes, bool auto_connect, bool save)
1983 {
1984         ChanCount existing_inputs;
1985         ChanCount existing_outputs;
1986
1987         count_existing_track_channels (existing_inputs, existing_outputs);
1988
1989         {
1990                 RCUWriter<RouteList> writer (routes);
1991                 boost::shared_ptr<RouteList> r = writer.get_copy ();
1992                 r->insert (r->end(), new_routes.begin(), new_routes.end());
1993
1994                 /* if there is no control out and we're not in the middle of loading,
1995                    resort the graph here. if there is a control out, we will resort
1996                    toward the end of this method. if we are in the middle of loading,
1997                    we will resort when done.
1998                 */
1999
2000                 if (!_monitor_out && IO::connecting_legal) {
2001                         resort_routes_using (r);
2002                 }
2003         }
2004
2005         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2006
2007                 boost::weak_ptr<Route> wpr (*x);
2008                 boost::shared_ptr<Route> r (*x);
2009
2010                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2011                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2012                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2013                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2014                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2015                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2016                 r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
2017
2018                 if (r->is_master()) {
2019                         _master_out = r;
2020                 }
2021
2022                 if (r->is_monitor()) {
2023                         _monitor_out = r;
2024                 }
2025
2026                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2027                 if (tr) {
2028                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2029                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2030                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2031
2032                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2033                         if (mt) {
2034                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2035                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2036                         }
2037                 }
2038
2039                 if (auto_connect) {
2040                         auto_connect_route (r, existing_inputs, existing_outputs, true);
2041                 }
2042         }
2043
2044         if (_monitor_out && IO::connecting_legal) {
2045
2046                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2047                         if ((*x)->is_monitor()) {
2048                                 /* relax */
2049                         } else if ((*x)->is_master()) {
2050                                 /* relax */
2051                         } else {
2052                                 (*x)->listen_via_monitor ();
2053                         }
2054                 }
2055
2056                 resort_routes ();
2057         }
2058
2059         set_dirty();
2060
2061         if (save) {
2062                 save_state (_current_snapshot_name);
2063         }
2064
2065         RouteAdded (new_routes); /* EMIT SIGNAL */
2066         Route::RemoteControlIDChange (); /* EMIT SIGNAL */
2067 }
2068
2069 void
2070 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2071 {
2072         boost::shared_ptr<RouteList> r = routes.reader ();
2073         boost::shared_ptr<Send> s;
2074
2075         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2076                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2077                         s->amp()->gain_control()->set_value (0.0);
2078                 }
2079         }
2080 }
2081
2082 void
2083 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2084 {
2085         boost::shared_ptr<RouteList> r = routes.reader ();
2086         boost::shared_ptr<Send> s;
2087
2088         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2089                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2090                         s->amp()->gain_control()->set_value (1.0);
2091                 }
2092         }
2093 }
2094
2095 void
2096 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2097 {
2098         boost::shared_ptr<RouteList> r = routes.reader ();
2099         boost::shared_ptr<Send> s;
2100
2101         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2102                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2103                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2104                 }
2105         }
2106 }
2107
2108 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2109 void
2110 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2111 {
2112         boost::shared_ptr<RouteList> r = routes.reader ();
2113         boost::shared_ptr<RouteList> t (new RouteList);
2114
2115         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2116                 if (include_buses || boost::dynamic_pointer_cast<Track>(*i)) {
2117                         t->push_back (*i);
2118                 }
2119         }
2120
2121         add_internal_sends (dest, p, t);
2122 }
2123
2124 void
2125 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2126 {
2127         if (dest->is_monitor() || dest->is_master()) {
2128                 return;
2129         }
2130
2131         if (!dest->internal_return()) {
2132                 dest->add_internal_return();
2133         }
2134
2135         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2136
2137                 if ((*i)->is_monitor() || (*i)->is_master() || (*i) == dest) {
2138                         continue;
2139                 }
2140
2141                 (*i)->listen_via (dest, p);
2142         }
2143
2144         graph_reordered ();
2145 }
2146
2147 void
2148 Session::remove_route (boost::shared_ptr<Route> route)
2149 {
2150         if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
2151                 return;
2152         }
2153
2154         route->set_solo (false, this);
2155
2156         {
2157                 RCUWriter<RouteList> writer (routes);
2158                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2159
2160                 rs->remove (route);
2161
2162                 /* deleting the master out seems like a dumb
2163                    idea, but its more of a UI policy issue
2164                    than our concern.
2165                 */
2166
2167                 if (route == _master_out) {
2168                         _master_out = boost::shared_ptr<Route> ();
2169                 }
2170
2171                 if (route == _monitor_out) {
2172
2173                         /* cancel control outs for all routes */
2174
2175                         for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2176                                 (*r)->drop_listen (_monitor_out);
2177                         }
2178
2179                         _monitor_out.reset ();
2180                 }
2181
2182                 /* writer goes out of scope, forces route list update */
2183         }
2184
2185         update_route_solo_state ();
2186
2187         // We need to disconnect the route's inputs and outputs
2188
2189         route->input()->disconnect (0);
2190         route->output()->disconnect (0);
2191
2192         /* if the route had internal sends sending to it, remove them */
2193         if (route->internal_return()) {
2194
2195                 boost::shared_ptr<RouteList> r = routes.reader ();
2196                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2197                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2198                         if (s) {
2199                                 (*i)->remove_processor (s);
2200                         }
2201                 }
2202         }
2203
2204         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2205         if (mt && mt->step_editing()) {
2206                 if (_step_editors > 0) {
2207                         _step_editors--;
2208                 }
2209         }
2210
2211         update_latency_compensation ();
2212         set_dirty();
2213
2214         /* Re-sort routes to remove the graph's current references to the one that is
2215          * going away, then flush old references out of the graph.
2216          */
2217
2218         resort_routes ();
2219         route_graph->clear_other_chain ();
2220
2221         /* get rid of it from the dead wood collection in the route list manager */
2222
2223         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2224
2225         routes.flush ();
2226
2227         /* try to cause everyone to drop their references */
2228
2229         route->drop_references ();
2230
2231         sync_order_keys (N_("session"));
2232
2233         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2234
2235         /* save the new state of the world */
2236
2237         if (save_state (_current_snapshot_name)) {
2238                 save_history (_current_snapshot_name);
2239         }
2240 }
2241
2242 void
2243 Session::route_mute_changed (void* /*src*/)
2244 {
2245         set_dirty ();
2246 }
2247
2248 void
2249 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2250 {
2251         boost::shared_ptr<Route> route = wpr.lock();
2252         if (!route) {
2253                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2254                 return;
2255         }
2256
2257         if (route->listening_via_monitor ()) {
2258
2259                 if (Config->get_exclusive_solo()) {
2260                         /* new listen: disable all other listen */
2261                         boost::shared_ptr<RouteList> r = routes.reader ();
2262                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2263                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2264                                         continue;
2265                                 }
2266                                 (*i)->set_listen (false, this);
2267                         }
2268                 }
2269
2270                 _listen_cnt++;
2271
2272         } else if (_listen_cnt > 0) {
2273
2274                 _listen_cnt--;
2275         }
2276
2277         update_route_solo_state ();
2278 }
2279 void
2280 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2281 {
2282         boost::shared_ptr<Route> route = wpr.lock ();
2283
2284         if (!route) {
2285                 /* should not happen */
2286                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2287                 return;
2288         }
2289
2290         bool send_changed = false;
2291
2292         if (route->solo_isolated()) {
2293                 if (_solo_isolated_cnt == 0) {
2294                         send_changed = true;
2295                 }
2296                 _solo_isolated_cnt++;
2297         } else if (_solo_isolated_cnt > 0) {
2298                 _solo_isolated_cnt--;
2299                 if (_solo_isolated_cnt == 0) {
2300                         send_changed = true;
2301                 }
2302         }
2303
2304         if (send_changed) {
2305                 IsolatedChanged (); /* EMIT SIGNAL */
2306         }
2307 }
2308
2309 void
2310 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2311 {
2312         if (!self_solo_change) {
2313                 // session doesn't care about changes to soloed-by-others
2314                 return;
2315         }
2316
2317         if (solo_update_disabled) {
2318                 // We know already
2319                 return;
2320         }
2321
2322         boost::shared_ptr<Route> route = wpr.lock ();
2323
2324         if (!route) {
2325                 /* should not happen */
2326                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2327                 return;
2328         }
2329
2330         boost::shared_ptr<RouteList> r = routes.reader ();
2331         int32_t delta;
2332
2333         if (route->self_soloed()) {
2334                 delta = 1;
2335         } else {
2336                 delta = -1;
2337         }
2338
2339         RouteGroup* rg = route->route_group ();
2340         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2341
2342         if (delta == 1 && Config->get_exclusive_solo()) {
2343
2344                 /* new solo: disable all other solos, but not the group if its solo-enabled */
2345
2346                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2347                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2348                             (leave_group_alone && ((*i)->route_group() == rg))) {
2349                                 continue;
2350                         }
2351                         (*i)->set_solo (false, this);
2352                 }
2353         }
2354
2355         solo_update_disabled = true;
2356
2357         RouteList uninvolved;
2358
2359         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2360                 bool via_sends_only;
2361                 bool in_signal_flow;
2362
2363                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2364                     (leave_group_alone && ((*i)->route_group() == rg))) {
2365                         continue;
2366                 }
2367
2368                 in_signal_flow = false;
2369
2370                 if ((*i)->feeds (route, &via_sends_only)) {
2371                         if (!via_sends_only) {
2372                                 if (!route->soloed_by_others_upstream()) {
2373                                         (*i)->mod_solo_by_others_downstream (delta);
2374                                 }
2375                                 in_signal_flow = true;
2376                         }
2377                 }
2378
2379                 if (route->feeds (*i, &via_sends_only)) {
2380                         (*i)->mod_solo_by_others_upstream (delta);
2381                         in_signal_flow = true;
2382                 }
2383
2384                 if (!in_signal_flow) {
2385                         uninvolved.push_back (*i);
2386                 }
2387         }
2388
2389         solo_update_disabled = false;
2390         update_route_solo_state (r);
2391
2392         /* now notify that the mute state of the routes not involved in the signal
2393            pathway of the just-solo-changed route may have altered.
2394         */
2395
2396         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2397                 (*i)->mute_changed (this);
2398         }
2399
2400         SoloChanged (); /* EMIT SIGNAL */
2401         set_dirty();
2402 }
2403
2404 void
2405 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2406 {
2407         /* now figure out if anything that matters is soloed (or is "listening")*/
2408
2409         bool something_soloed = false;
2410         uint32_t listeners = 0;
2411         uint32_t isolated = 0;
2412
2413         if (!r) {
2414                 r = routes.reader();
2415         }
2416
2417         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2418                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2419                         something_soloed = true;
2420                 }
2421
2422                 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2423                         if (Config->get_solo_control_is_listen_control()) {
2424                                 listeners++;
2425                         } else {
2426                                 (*i)->set_listen (false, this);
2427                         }
2428                 }
2429
2430                 if ((*i)->solo_isolated()) {
2431                         isolated++;
2432                 }
2433         }
2434
2435         if (something_soloed != _non_soloed_outs_muted) {
2436                 _non_soloed_outs_muted = something_soloed;
2437                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2438         }
2439
2440         _listen_cnt = listeners;
2441
2442         if (isolated != _solo_isolated_cnt) {
2443                 _solo_isolated_cnt = isolated;
2444                 IsolatedChanged (); /* EMIT SIGNAL */
2445         }
2446 }
2447
2448 boost::shared_ptr<RouteList>
2449 Session::get_routes_with_internal_returns() const
2450 {
2451         boost::shared_ptr<RouteList> r = routes.reader ();
2452         boost::shared_ptr<RouteList> rl (new RouteList);
2453
2454         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2455                 if ((*i)->internal_return ()) {
2456                         rl->push_back (*i);
2457                 }
2458         }
2459         return rl;
2460 }
2461
2462 bool
2463 Session::io_name_is_legal (const std::string& name)
2464 {
2465         boost::shared_ptr<RouteList> r = routes.reader ();
2466
2467         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2468                 if ((*i)->name() == name) {
2469                         return false;
2470                 }
2471
2472                 if ((*i)->has_io_processor_named (name)) {
2473                         return false;
2474                 }
2475         }
2476
2477         return true;
2478 }
2479
2480 void
2481 Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool others_on)
2482 {
2483         RouteList rl;
2484         vector<string> connections;
2485
2486         PortSet& ps (rt->input()->ports());
2487
2488         for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2489                 p->get_connections (connections);
2490         }
2491
2492         for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2493                 routes_using_input_from (*s, rl);
2494         }
2495
2496         /* scan all relevant routes to see if others are on or off */
2497
2498         bool others_are_already_on = false;
2499
2500         for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2501                 if ((*r) != rt) {
2502                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2503                         if (mt) {
2504                                 if (mt->input_active()) {
2505                                         others_are_already_on = true;
2506                                         break;
2507                                 }
2508                         }
2509                 }
2510         }
2511
2512         /* globally reverse other routes */
2513
2514         for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2515                 if ((*r) != rt) {
2516                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2517                         if (mt) {
2518                                 mt->set_input_active (!others_are_already_on);
2519                         }
2520                 }
2521         }
2522 }
2523
2524 void
2525 Session::routes_using_input_from (const string& str, RouteList& rl)
2526 {
2527         boost::shared_ptr<RouteList> r = routes.reader ();
2528
2529         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2530                 if ((*i)->input()->connected_to (str)) {
2531                         rl.push_back (*i);
2532                 }
2533         }
2534 }
2535
2536 boost::shared_ptr<Route>
2537 Session::route_by_name (string name)
2538 {
2539         boost::shared_ptr<RouteList> r = routes.reader ();
2540
2541         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2542                 if ((*i)->name() == name) {
2543                         return *i;
2544                 }
2545         }
2546
2547         return boost::shared_ptr<Route> ((Route*) 0);
2548 }
2549
2550 boost::shared_ptr<Route>
2551 Session::route_by_id (PBD::ID id)
2552 {
2553         boost::shared_ptr<RouteList> r = routes.reader ();
2554
2555         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2556                 if ((*i)->id() == id) {
2557                         return *i;
2558                 }
2559         }
2560
2561         return boost::shared_ptr<Route> ((Route*) 0);
2562 }
2563
2564 boost::shared_ptr<Route>
2565 Session::route_by_remote_id (uint32_t id)
2566 {
2567         boost::shared_ptr<RouteList> r = routes.reader ();
2568
2569         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2570                 if ((*i)->remote_control_id() == id) {
2571                         return *i;
2572                 }
2573         }
2574
2575         return boost::shared_ptr<Route> ((Route*) 0);
2576 }
2577
2578 void
2579 Session::playlist_region_added (boost::weak_ptr<Region> w)
2580 {
2581         boost::shared_ptr<Region> r = w.lock ();
2582         if (!r) {
2583                 return;
2584         }
2585
2586         /* These are the operations that are currently in progress... */
2587         list<GQuark> curr = _current_trans_quarks;
2588         curr.sort ();
2589
2590         /* ...and these are the operations during which we want to update
2591            the session range location markers.
2592         */
2593         list<GQuark> ops;
2594         ops.push_back (Operations::capture);
2595         ops.push_back (Operations::paste);
2596         ops.push_back (Operations::duplicate_region);
2597         ops.push_back (Operations::insert_file);
2598         ops.push_back (Operations::insert_region);
2599         ops.push_back (Operations::drag_region_brush);
2600         ops.push_back (Operations::region_drag);
2601         ops.push_back (Operations::selection_grab);
2602         ops.push_back (Operations::region_fill);
2603         ops.push_back (Operations::fill_selection);
2604         ops.push_back (Operations::create_region);
2605         ops.push_back (Operations::region_copy);
2606         ops.push_back (Operations::fixed_time_region_copy);
2607         ops.sort ();
2608
2609         /* See if any of the current operations match the ones that we want */
2610         list<GQuark> in;
2611         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2612
2613         /* If so, update the session range markers */
2614         if (!in.empty ()) {
2615                 maybe_update_session_range (r->position (), r->last_frame ());
2616         }
2617 }
2618
2619 /** Update the session range markers if a is before the current start or
2620  *  b is after the current end.
2621  */
2622 void
2623 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2624 {
2625         if (_state_of_the_state & Loading) {
2626                 return;
2627         }
2628
2629         if (_session_range_location == 0) {
2630
2631                 add_session_range_location (a, b);
2632
2633         } else {
2634
2635                 if (a < _session_range_location->start()) {
2636                         _session_range_location->set_start (a);
2637                 }
2638
2639                 if (b > _session_range_location->end()) {
2640                         _session_range_location->set_end (b);
2641                 }
2642         }
2643 }
2644
2645 void
2646 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2647 {
2648         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2649                 maybe_update_session_range (i->to, i->to + i->length);
2650         }
2651 }
2652
2653 void
2654 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2655 {
2656         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2657                 maybe_update_session_range (i->from, i->to);
2658         }
2659 }
2660
2661 /* Region management */
2662
2663 boost::shared_ptr<Region>
2664 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2665 {
2666         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2667         RegionFactory::RegionMap::const_iterator i;
2668         boost::shared_ptr<Region> region;
2669
2670         Glib::Mutex::Lock lm (region_lock);
2671
2672         for (i = regions.begin(); i != regions.end(); ++i) {
2673
2674                 region = i->second;
2675
2676                 if (region->whole_file()) {
2677
2678                         if (child->source_equivalent (region)) {
2679                                 return region;
2680                         }
2681                 }
2682         }
2683
2684         return boost::shared_ptr<Region> ();
2685 }
2686
2687 int
2688 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2689 {
2690         set<boost::shared_ptr<Region> > relevant_regions;
2691
2692         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2693                 RegionFactory::get_regions_using_source (*s, relevant_regions);
2694         }
2695
2696         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2697                 set<boost::shared_ptr<Region> >::iterator tmp;
2698
2699                 tmp = r;
2700                 ++tmp;
2701
2702                 playlists->destroy_region (*r);
2703                 RegionFactory::map_remove (*r);
2704
2705                 (*r)->drop_sources ();
2706                 (*r)->drop_references ();
2707
2708                 relevant_regions.erase (r);
2709
2710                 r = tmp;
2711         }
2712
2713         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2714
2715                 {
2716                         Glib::Mutex::Lock ls (source_lock);
2717                         /* remove from the main source list */
2718                         sources.erase ((*s)->id());
2719                 }
2720
2721                 (*s)->mark_for_remove ();
2722                 (*s)->drop_references ();
2723
2724                 s = srcs.erase (s);
2725         }
2726
2727         return 0;
2728 }
2729
2730 int
2731 Session::remove_last_capture ()
2732 {
2733         list<boost::shared_ptr<Source> > srcs;
2734
2735         boost::shared_ptr<RouteList> rl = routes.reader ();
2736         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2737                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2738                 if (!tr) {
2739                         continue;
2740                 }
2741
2742                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
2743
2744                 if (!l.empty()) {
2745                         srcs.insert (srcs.end(), l.begin(), l.end());
2746                         l.clear ();
2747                 }
2748         }
2749
2750         destroy_sources (srcs);
2751
2752         save_state (_current_snapshot_name);
2753
2754         return 0;
2755 }
2756
2757 /* Source Management */
2758
2759 void
2760 Session::add_source (boost::shared_ptr<Source> source)
2761 {
2762         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2763         pair<SourceMap::iterator,bool> result;
2764
2765         entry.first = source->id();
2766         entry.second = source;
2767
2768         {
2769                 Glib::Mutex::Lock lm (source_lock);
2770                 result = sources.insert (entry);
2771         }
2772
2773         if (result.second) {
2774
2775                 /* yay, new source */
2776
2777                 set_dirty();
2778
2779                 boost::shared_ptr<AudioFileSource> afs;
2780
2781                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2782                         if (Config->get_auto_analyse_audio()) {
2783                                 Analyser::queue_source_for_analysis (source, false);
2784                         }
2785                 }
2786
2787                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
2788         }
2789 }
2790
2791 void
2792 Session::remove_source (boost::weak_ptr<Source> src)
2793 {
2794         if (_state_of_the_state & Deletion) {
2795                 return;
2796         }
2797
2798         SourceMap::iterator i;
2799         boost::shared_ptr<Source> source = src.lock();
2800
2801         if (!source) {
2802                 return;
2803         }
2804
2805         {
2806                 Glib::Mutex::Lock lm (source_lock);
2807
2808                 if ((i = sources.find (source->id())) != sources.end()) {
2809                         sources.erase (i);
2810                 }
2811         }
2812
2813         if (!_state_of_the_state & InCleanup) {
2814
2815                 /* save state so we don't end up with a session file
2816                    referring to non-existent sources.
2817                 */
2818
2819                 save_state (_current_snapshot_name);
2820         }
2821 }
2822
2823 boost::shared_ptr<Source>
2824 Session::source_by_id (const PBD::ID& id)
2825 {
2826         Glib::Mutex::Lock lm (source_lock);
2827         SourceMap::iterator i;
2828         boost::shared_ptr<Source> source;
2829
2830         if ((i = sources.find (id)) != sources.end()) {
2831                 source = i->second;
2832         }
2833
2834         return source;
2835 }
2836
2837 boost::shared_ptr<Source>
2838 Session::source_by_path_and_channel (const string& path, uint16_t chn)
2839 {
2840         Glib::Mutex::Lock lm (source_lock);
2841
2842         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2843                 boost::shared_ptr<AudioFileSource> afs
2844                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2845
2846                 if (afs && afs->path() == path && chn == afs->channel()) {
2847                         return afs;
2848                 }
2849         }
2850         return boost::shared_ptr<Source>();
2851 }
2852
2853 uint32_t
2854 Session::count_sources_by_origin (const string& path)
2855 {
2856         uint32_t cnt = 0;
2857         Glib::Mutex::Lock lm (source_lock);
2858
2859         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2860                 boost::shared_ptr<FileSource> fs
2861                         = boost::dynamic_pointer_cast<FileSource>(i->second);
2862
2863                 if (fs && fs->origin() == path) {
2864                         ++cnt;
2865                 }
2866         }
2867
2868         return cnt;
2869 }
2870
2871
2872 string
2873 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
2874 {
2875         string look_for;
2876         string old_basename = PBD::basename_nosuffix (oldname);
2877         string new_legalized = legalize_for_path (newname);
2878
2879         /* note: we know (or assume) the old path is already valid */
2880
2881         if (destructive) {
2882
2883                 /* destructive file sources have a name of the form:
2884
2885                     /path/to/Tnnnn-NAME(%[LR])?.wav
2886
2887                     the task here is to replace NAME with the new name.
2888                 */
2889
2890                 string dir;
2891                 string prefix;
2892                 string::size_type dash;
2893
2894                 dir = Glib::path_get_dirname (path);
2895                 path = Glib::path_get_basename (path);
2896
2897                 /* '-' is not a legal character for the NAME part of the path */
2898
2899                 if ((dash = path.find_last_of ('-')) == string::npos) {
2900                         return "";
2901                 }
2902
2903                 prefix = path.substr (0, dash);
2904
2905                 path += prefix;
2906                 path += '-';
2907                 path += new_legalized;
2908                 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
2909                 path = Glib::build_filename (dir, path);
2910
2911         } else {
2912
2913                 /* non-destructive file sources have a name of the form:
2914
2915                     /path/to/NAME-nnnnn(%[LR])?.ext
2916
2917                     the task here is to replace NAME with the new name.
2918                 */
2919
2920                 string dir;
2921                 string suffix;
2922                 string::size_type dash;
2923                 string::size_type postfix;
2924
2925                 dir = Glib::path_get_dirname (path);
2926                 path = Glib::path_get_basename (path);
2927
2928                 /* '-' is not a legal character for the NAME part of the path */
2929
2930                 if ((dash = path.find_last_of ('-')) == string::npos) {
2931                         return "";
2932                 }
2933
2934                 suffix = path.substr (dash+1);
2935
2936                 // Suffix is now everything after the dash. Now we need to eliminate
2937                 // the nnnnn part, which is done by either finding a '%' or a '.'
2938
2939                 postfix = suffix.find_last_of ("%");
2940                 if (postfix == string::npos) {
2941                         postfix = suffix.find_last_of ('.');
2942                 }
2943
2944                 if (postfix != string::npos) {
2945                         suffix = suffix.substr (postfix);
2946                 } else {
2947                         error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
2948                         return "";
2949                 }
2950
2951                 const uint32_t limit = 10000;
2952                 char buf[PATH_MAX+1];
2953
2954                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2955
2956                         snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
2957
2958                         if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
2959                                 path = Glib::build_filename (dir, buf);
2960                                 break;
2961                         }
2962
2963                         path = "";
2964                 }
2965
2966                 if (path.empty()) {
2967                         fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
2968                                                  newname) << endl;
2969                         /*NOTREACHED*/
2970                 }
2971         }
2972
2973         return path;
2974 }
2975
2976 /** Return the full path (in some session directory) for a new within-session source.
2977  * \a name must be a session-unique name that does not contain slashes
2978  *         (e.g. as returned by new_*_source_name)
2979  */
2980 string
2981 Session::new_source_path_from_name (DataType type, const string& name)
2982 {
2983         assert(name.find("/") == string::npos);
2984
2985         SessionDirectory sdir(get_best_session_directory_for_new_source());
2986
2987         sys::path p;
2988         if (type == DataType::AUDIO) {
2989                 p = sdir.sound_path();
2990         } else if (type == DataType::MIDI) {
2991                 p = sdir.midi_path();
2992         } else {
2993                 error << "Unknown source type, unable to create file path" << endmsg;
2994                 return "";
2995         }
2996
2997         p /= name;
2998         return p.to_string();
2999 }
3000
3001 string
3002 Session::peak_path (string base) const
3003 {
3004         sys::path peakfile_path(_session_dir->peak_path());
3005         peakfile_path /= base + peakfile_suffix;
3006         return peakfile_path.to_string();
3007 }
3008
3009 /** Return a unique name based on \a base for a new internal audio source */
3010 string
3011 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3012 {
3013         uint32_t cnt;
3014         char buf[PATH_MAX+1];
3015         const uint32_t limit = 10000;
3016         string legalized;
3017         string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3018
3019         buf[0] = '\0';
3020         legalized = legalize_for_path (base);
3021
3022         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3023         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3024
3025                 vector<space_and_path>::iterator i;
3026                 uint32_t existing = 0;
3027
3028                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3029
3030                         if (destructive) {
3031
3032                                 if (nchan < 2) {
3033                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3034                                                   cnt, legalized.c_str(), ext.c_str());
3035                                 } else if (nchan == 2) {
3036                                         if (chan == 0) {
3037                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3038                                                           cnt, legalized.c_str(), ext.c_str());
3039                                         } else {
3040                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3041                                                           cnt, legalized.c_str(), ext.c_str());
3042                                         }
3043                                 } else if (nchan < 26) {
3044                                         snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3045                                                   cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3046                                 } else {
3047                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3048                                                   cnt, legalized.c_str(), ext.c_str());
3049                                 }
3050
3051                         } else {
3052
3053                                 if (nchan < 2) {
3054                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3055                                 } else if (nchan == 2) {
3056                                         if (chan == 0) {
3057                                                 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3058                                         } else {
3059                                                 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3060                                         }
3061                                 } else if (nchan < 26) {
3062                                         snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3063                                 } else {
3064                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3065                                 }
3066                         }
3067
3068                         SessionDirectory sdir((*i).path);
3069
3070                         string spath = sdir.sound_path().to_string();
3071
3072                         /* note that we search *without* the extension so that
3073                            we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3074                            in the event that this new name is required for
3075                            a file format change.
3076                         */
3077
3078                         if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3079                                 existing++;
3080                                 break;
3081                         }
3082                 }
3083
3084                 if (existing == 0) {
3085                         break;
3086                 }
3087
3088                 if (cnt > limit) {
3089                         error << string_compose(
3090                                         _("There are already %1 recordings for %2, which I consider too many."),
3091                                         limit, base) << endmsg;
3092                         destroy ();
3093                         throw failed_constructor();
3094                 }
3095         }
3096
3097         return Glib::path_get_basename (buf);
3098 }
3099
3100 /** Create a new within-session audio source */
3101 boost::shared_ptr<AudioFileSource>
3102 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3103 {
3104         const string name    = new_audio_source_name (n, n_chans, chan, destructive);
3105         const string path    = new_source_path_from_name(DataType::AUDIO, name);
3106
3107         return boost::dynamic_pointer_cast<AudioFileSource> (
3108                 SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
3109 }
3110
3111 /** Return a unique name based on \a base for a new internal MIDI source */
3112 string
3113 Session::new_midi_source_name (const string& base)
3114 {
3115         uint32_t cnt;
3116         char buf[PATH_MAX+1];
3117         const uint32_t limit = 10000;
3118         string legalized;
3119
3120         buf[0] = '\0';
3121         legalized = legalize_for_path (base);
3122
3123         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3124         for (cnt = 1; cnt <= limit; ++cnt) {
3125
3126                 vector<space_and_path>::iterator i;
3127                 uint32_t existing = 0;
3128
3129                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3130
3131                         SessionDirectory sdir((*i).path);
3132
3133                         sys::path p = sdir.midi_path();
3134                         p /= legalized;
3135
3136                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
3137
3138                         if (sys::exists (buf)) {
3139                                 existing++;
3140                         }
3141                 }
3142
3143                 if (existing == 0) {
3144                         break;
3145                 }
3146
3147                 if (cnt > limit) {
3148                         error << string_compose(
3149                                         _("There are already %1 recordings for %2, which I consider too many."),
3150                                         limit, base) << endmsg;
3151                         destroy ();
3152                         throw failed_constructor();
3153                 }
3154         }
3155
3156         return Glib::path_get_basename(buf);
3157 }
3158
3159
3160 /** Create a new within-session MIDI source */
3161 boost::shared_ptr<MidiSource>
3162 Session::create_midi_source_for_session (Track* track, string const & n)
3163 {
3164         /* try to use the existing write source for the track, to keep numbering sane
3165          */
3166
3167         if (track) {
3168                 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3169                   assert (mt);
3170                 */
3171
3172                 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3173
3174                 if (!l.empty()) {
3175                         assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3176                         return boost::dynamic_pointer_cast<MidiSource> (l.front());
3177                 }
3178         }
3179
3180         const string name = new_midi_source_name (n);
3181         const string path = new_source_path_from_name (DataType::MIDI, name);
3182
3183         return boost::dynamic_pointer_cast<SMFSource> (
3184                 SourceFactory::createWritable (
3185                         DataType::MIDI, *this, path, string(), false, frame_rate()));
3186 }
3187
3188
3189 void
3190 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3191 {
3192         if (playlist->hidden()) {
3193                 return;
3194         }
3195
3196         playlists->add (playlist);
3197
3198         if (unused) {
3199                 playlist->release();
3200         }
3201
3202         set_dirty();
3203 }
3204
3205 void
3206 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3207 {
3208         if (_state_of_the_state & Deletion) {
3209                 return;
3210         }
3211
3212         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3213
3214         if (!playlist) {
3215                 return;
3216         }
3217
3218         playlists->remove (playlist);
3219
3220         set_dirty();
3221 }
3222
3223 void
3224 Session::set_audition (boost::shared_ptr<Region> r)
3225 {
3226         pending_audition_region = r;
3227         add_post_transport_work (PostTransportAudition);
3228         _butler->schedule_transport_work ();
3229 }
3230
3231 void
3232 Session::audition_playlist ()
3233 {
3234         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3235         ev->region.reset ();
3236         queue_event (ev);
3237 }
3238
3239 void
3240 Session::non_realtime_set_audition ()
3241 {
3242         if (!pending_audition_region) {
3243                 auditioner->audition_current_playlist ();
3244         } else {
3245                 auditioner->audition_region (pending_audition_region);
3246                 pending_audition_region.reset ();
3247         }
3248         AuditionActive (true); /* EMIT SIGNAL */
3249 }
3250
3251 void
3252 Session::audition_region (boost::shared_ptr<Region> r)
3253 {
3254         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3255         ev->region = r;
3256         queue_event (ev);
3257 }
3258
3259 void
3260 Session::cancel_audition ()
3261 {
3262         if (auditioner->auditioning()) {
3263                 auditioner->cancel_audition ();
3264                 AuditionActive (false); /* EMIT SIGNAL */
3265         }
3266 }
3267
3268 bool
3269 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3270 {
3271         if (a->is_monitor()) {
3272                 return true;
3273         }
3274         if (b->is_monitor()) {
3275                 return false;
3276         }
3277         return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3278 }
3279
3280 bool
3281 Session::is_auditioning () const
3282 {
3283         /* can be called before we have an auditioner object */
3284         if (auditioner) {
3285                 return auditioner->auditioning();
3286         } else {
3287                 return false;
3288         }
3289 }
3290
3291 void
3292 Session::graph_reordered ()
3293 {
3294         /* don't do this stuff if we are setting up connections
3295            from a set_state() call or creating new tracks. Ditto for deletion.
3296         */
3297
3298         if (_state_of_the_state & (InitialConnecting|Deletion)) {
3299                 return;
3300         }
3301
3302         /* every track/bus asked for this to be handled but it was deferred because
3303            we were connecting. do it now.
3304         */
3305
3306         request_input_change_handling ();
3307
3308         resort_routes ();
3309
3310         /* force all diskstreams to update their capture offset values to
3311            reflect any changes in latencies within the graph.
3312         */
3313
3314         boost::shared_ptr<RouteList> rl = routes.reader ();
3315         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3316                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3317                 if (tr) {
3318                         tr->set_capture_offset ();
3319                 }
3320         }
3321 }
3322
3323 framecnt_t
3324 Session::available_capture_duration ()
3325 {
3326         float sample_bytes_on_disk = 4.0; // keep gcc happy
3327
3328         switch (config.get_native_file_data_format()) {
3329         case FormatFloat:
3330                 sample_bytes_on_disk = 4.0;
3331                 break;
3332
3333         case FormatInt24:
3334                 sample_bytes_on_disk = 3.0;
3335                 break;
3336
3337         case FormatInt16:
3338                 sample_bytes_on_disk = 2.0;
3339                 break;
3340
3341         default:
3342                 /* impossible, but keep some gcc versions happy */
3343                 fatal << string_compose (_("programming error: %1"),
3344                                          X_("illegal native file data format"))
3345                       << endmsg;
3346                 /*NOTREACHED*/
3347         }
3348
3349         double scale = 4096.0 / sample_bytes_on_disk;
3350
3351         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3352                 return max_framecnt;
3353         }
3354
3355         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3356 }
3357
3358 void
3359 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3360 {
3361         {
3362                 RCUWriter<BundleList> writer (_bundles);
3363                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3364                 b->push_back (bundle);
3365         }
3366
3367         BundleAdded (bundle); /* EMIT SIGNAL */
3368
3369         set_dirty();
3370 }
3371
3372 void
3373 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3374 {
3375         bool removed = false;
3376
3377         {
3378                 RCUWriter<BundleList> writer (_bundles);
3379                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3380                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3381
3382                 if (i != b->end()) {
3383                         b->erase (i);
3384                         removed = true;
3385                 }
3386         }
3387
3388         if (removed) {
3389                  BundleRemoved (bundle); /* EMIT SIGNAL */
3390         }
3391
3392         set_dirty();
3393 }
3394
3395 boost::shared_ptr<Bundle>
3396 Session::bundle_by_name (string name) const
3397 {
3398         boost::shared_ptr<BundleList> b = _bundles.reader ();
3399
3400         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3401                 if ((*i)->name() == name) {
3402                         return* i;
3403                 }
3404         }
3405
3406         return boost::shared_ptr<Bundle> ();
3407 }
3408
3409 void
3410 Session::tempo_map_changed (const PropertyChange&)
3411 {
3412         clear_clicks ();
3413
3414         playlists->update_after_tempo_map_change ();
3415
3416         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3417
3418         set_dirty ();
3419 }
3420
3421 void
3422 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3423 {
3424         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3425                 (*i)->recompute_frames_from_bbt ();
3426         }
3427 }
3428
3429 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3430  * the given count with the current block size.
3431  */
3432 void
3433 Session::ensure_buffers (ChanCount howmany)
3434 {
3435         BufferManager::ensure_buffers (howmany);
3436 }
3437
3438 void
3439 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3440 {
3441         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3442                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3443         }
3444 }
3445
3446 uint32_t
3447 Session::next_insert_id ()
3448 {
3449         /* this doesn't really loop forever. just think about it */
3450
3451         while (true) {
3452                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3453                         if (!insert_bitset[n]) {
3454                                 insert_bitset[n] = true;
3455                                 return n;
3456
3457                         }
3458                 }
3459
3460                 /* none available, so resize and try again */
3461
3462                 insert_bitset.resize (insert_bitset.size() + 16, false);
3463         }
3464 }
3465
3466 uint32_t
3467 Session::next_send_id ()
3468 {
3469         /* this doesn't really loop forever. just think about it */
3470
3471         while (true) {
3472                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3473                         if (!send_bitset[n]) {
3474                                 send_bitset[n] = true;
3475                                 return n;
3476
3477                         }
3478                 }
3479
3480                 /* none available, so resize and try again */
3481
3482                 send_bitset.resize (send_bitset.size() + 16, false);
3483         }
3484 }
3485
3486 uint32_t
3487 Session::next_return_id ()
3488 {
3489         /* this doesn't really loop forever. just think about it */
3490
3491         while (true) {
3492                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3493                         if (!return_bitset[n]) {
3494                                 return_bitset[n] = true;
3495                                 return n;
3496
3497                         }
3498                 }
3499
3500                 /* none available, so resize and try again */
3501
3502                 return_bitset.resize (return_bitset.size() + 16, false);
3503         }
3504 }
3505
3506 void
3507 Session::mark_send_id (uint32_t id)
3508 {
3509         if (id >= send_bitset.size()) {
3510                 send_bitset.resize (id+16, false);
3511         }
3512         if (send_bitset[id]) {
3513                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3514         }
3515         send_bitset[id] = true;
3516 }
3517
3518 void
3519 Session::mark_return_id (uint32_t id)
3520 {
3521         if (id >= return_bitset.size()) {
3522                 return_bitset.resize (id+16, false);
3523         }
3524         if (return_bitset[id]) {
3525                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3526         }
3527         return_bitset[id] = true;
3528 }
3529
3530 void
3531 Session::mark_insert_id (uint32_t id)
3532 {
3533         if (id >= insert_bitset.size()) {
3534                 insert_bitset.resize (id+16, false);
3535         }
3536         if (insert_bitset[id]) {
3537                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3538         }
3539         insert_bitset[id] = true;
3540 }
3541
3542 void
3543 Session::unmark_send_id (uint32_t id)
3544 {
3545         if (id < send_bitset.size()) {
3546                 send_bitset[id] = false;
3547         }
3548 }
3549
3550 void
3551 Session::unmark_return_id (uint32_t id)
3552 {
3553         if (id < return_bitset.size()) {
3554                 return_bitset[id] = false;
3555         }
3556 }
3557
3558 void
3559 Session::unmark_insert_id (uint32_t id)
3560 {
3561         if (id < insert_bitset.size()) {
3562                 insert_bitset[id] = false;
3563         }
3564 }
3565
3566
3567 /* Named Selection management */
3568
3569 boost::shared_ptr<NamedSelection>
3570 Session::named_selection_by_name (string name)
3571 {
3572         Glib::Mutex::Lock lm (named_selection_lock);
3573         for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3574                 if ((*i)->name == name) {
3575                         return *i;
3576                 }
3577         }
3578         return boost::shared_ptr<NamedSelection>();
3579 }
3580
3581 void
3582 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3583 {
3584         {
3585                 Glib::Mutex::Lock lm (named_selection_lock);
3586                 named_selections.insert (named_selections.begin(), named_selection);
3587         }
3588
3589         set_dirty();
3590
3591         NamedSelectionAdded (); /* EMIT SIGNAL */
3592 }
3593
3594 void
3595 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3596 {
3597         bool removed = false;
3598
3599         {
3600                 Glib::Mutex::Lock lm (named_selection_lock);
3601
3602                 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3603
3604                 if (i != named_selections.end()) {
3605                         named_selections.erase (i);
3606                         set_dirty();
3607                         removed = true;
3608                 }
3609         }
3610
3611         if (removed) {
3612                  NamedSelectionRemoved (); /* EMIT SIGNAL */
3613         }
3614 }
3615
3616 void
3617 Session::reset_native_file_format ()
3618 {
3619         boost::shared_ptr<RouteList> rl = routes.reader ();
3620         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3621                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3622                 if (tr) {
3623                         /* don't save state as we do this, there's no point
3624                          */
3625
3626                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3627                         tr->reset_write_sources (false);
3628                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3629                 }
3630         }
3631 }
3632
3633 bool
3634 Session::route_name_unique (string n) const
3635 {
3636         boost::shared_ptr<RouteList> r = routes.reader ();
3637
3638         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3639                 if ((*i)->name() == n) {
3640                         return false;
3641                 }
3642         }
3643
3644         return true;
3645 }
3646
3647 bool
3648 Session::route_name_internal (string n) const
3649 {
3650         if (auditioner && auditioner->name() == n) {
3651                 return true;
3652         }
3653
3654         if (_click_io && _click_io->name() == n) {
3655                 return true;
3656         }
3657
3658         return false;
3659 }
3660
3661 int
3662 Session::freeze_all (InterThreadInfo& itt)
3663 {
3664         boost::shared_ptr<RouteList> r = routes.reader ();
3665
3666         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3667
3668                 boost::shared_ptr<Track> t;
3669
3670                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3671                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3672                            of every track.
3673                         */
3674                         t->freeze_me (itt);
3675                 }
3676         }
3677
3678         return 0;
3679 }
3680
3681 boost::shared_ptr<Region>
3682 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3683                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3684                           InterThreadInfo& itt, bool enable_processing)
3685 {
3686         boost::shared_ptr<Region> result;
3687         boost::shared_ptr<Playlist> playlist;
3688         boost::shared_ptr<AudioFileSource> fsource;
3689         uint32_t x;
3690         char buf[PATH_MAX+1];
3691         ChanCount diskstream_channels (track.n_channels());
3692         framepos_t position;
3693         framecnt_t this_chunk;
3694         framepos_t to_do;
3695         BufferSet buffers;
3696         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3697         const string sound_dir = sdir.sound_path().to_string();
3698         framepos_t len = end - start;
3699         bool need_block_size_reset = false;
3700         string ext;
3701         ChanCount const max_proc = track.max_processor_streams ();
3702
3703         if (end <= start) {
3704                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3705                                          end, start) << endmsg;
3706                 return result;
3707         }
3708
3709         const framecnt_t chunk_size = (256 * 1024)/4;
3710
3711         // block all process callback handling
3712
3713         block_processing ();
3714
3715         /* call tree *MUST* hold route_lock */
3716
3717         if ((playlist = track.playlist()) == 0) {
3718                 goto out;
3719         }
3720
3721         /* external redirects will be a problem */
3722
3723         if (track.has_external_redirects()) {
3724                 goto out;
3725         }
3726
3727         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3728
3729         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3730
3731                 for (x = 0; x < 99999; ++x) {
3732                         snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
3733                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3734                                 break;
3735                         }
3736                 }
3737
3738                 if (x == 99999) {
3739                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3740                         goto out;
3741                 }
3742
3743                 try {
3744                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3745                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3746                 }
3747
3748                 catch (failed_constructor& err) {
3749                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3750                         goto out;
3751                 }
3752
3753                 srcs.push_back (fsource);
3754         }
3755
3756         /* tell redirects that care that we are about to use a much larger blocksize */
3757
3758         need_block_size_reset = true;
3759         track.set_block_size (chunk_size);
3760
3761         /* XXX need to flush all redirects */
3762
3763         position = start;
3764         to_do = len;
3765
3766         /* create a set of reasonably-sized buffers */
3767         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
3768         buffers.set_count (max_proc);
3769
3770         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3771                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3772                 if (afs)
3773                         afs->prepare_for_peakfile_writes ();
3774         }
3775
3776         while (to_do && !itt.cancel) {
3777
3778                 this_chunk = min (to_do, chunk_size);
3779
3780                 if (track.export_stuff (buffers, start, this_chunk, enable_processing)) {
3781                         goto out;
3782                 }
3783
3784                 uint32_t n = 0;
3785                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3786                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3787
3788                         if (afs) {
3789                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
3790                                         goto out;
3791                                 }
3792                         }
3793                 }
3794
3795                 start += this_chunk;
3796                 to_do -= this_chunk;
3797
3798                 itt.progress = (float) (1.0 - ((double) to_do / len));
3799
3800         }
3801
3802         if (!itt.cancel) {
3803
3804                 time_t now;
3805                 struct tm* xnow;
3806                 time (&now);
3807                 xnow = localtime (&now);
3808
3809                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3810                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3811
3812                         if (afs) {
3813                                 afs->update_header (position, *xnow, now);
3814                                 afs->flush_header ();
3815                         }
3816                 }
3817
3818                 /* construct a region to represent the bounced material */
3819
3820                 PropertyList plist;
3821
3822                 plist.add (Properties::start, 0);
3823                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
3824                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
3825
3826                 result = RegionFactory::create (srcs, plist);
3827
3828         }
3829
3830   out:
3831         if (!result) {
3832                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3833                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3834
3835                         if (afs) {
3836                                 afs->mark_for_remove ();
3837                         }
3838
3839                         (*src)->drop_references ();
3840                 }
3841
3842         } else {
3843                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3844                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3845
3846                         if (afs)
3847                                 afs->done_with_peakfile_writes ();
3848                 }
3849         }
3850
3851
3852         if (need_block_size_reset) {
3853                 track.set_block_size (get_block_size());
3854         }
3855
3856         unblock_processing ();
3857
3858         return result;
3859 }
3860
3861 gain_t*
3862 Session::gain_automation_buffer() const
3863 {
3864         return ProcessThread::gain_automation_buffer ();
3865 }
3866
3867 pan_t**
3868 Session::pan_automation_buffer() const
3869 {
3870         return ProcessThread::pan_automation_buffer ();
3871 }
3872
3873 BufferSet&
3874 Session::get_silent_buffers (ChanCount count)
3875 {
3876         return ProcessThread::get_silent_buffers (count);
3877 }
3878
3879 BufferSet&
3880 Session::get_scratch_buffers (ChanCount count)
3881 {
3882         return ProcessThread::get_scratch_buffers (count);
3883 }
3884
3885 BufferSet&
3886 Session::get_mix_buffers (ChanCount count)
3887 {
3888         return ProcessThread::get_mix_buffers (count);
3889 }
3890
3891 uint32_t
3892 Session::ntracks () const
3893 {
3894         uint32_t n = 0;
3895         boost::shared_ptr<RouteList> r = routes.reader ();
3896
3897         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3898                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3899                         ++n;
3900                 }
3901         }
3902
3903         return n;
3904 }
3905
3906 uint32_t
3907 Session::nbusses () const
3908 {
3909         uint32_t n = 0;
3910         boost::shared_ptr<RouteList> r = routes.reader ();
3911
3912         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3913                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
3914                         ++n;
3915                 }
3916         }
3917
3918         return n;
3919 }
3920
3921 void
3922 Session::add_automation_list(AutomationList *al)
3923 {
3924         automation_lists[al->id()] = al;
3925 }
3926
3927 void
3928 Session::sync_order_keys (std::string const & base)
3929 {
3930         if (deletion_in_progress()) {
3931                 return;
3932         }
3933
3934         if (!Config->get_sync_all_route_ordering()) {
3935                 /* leave order keys as they are */
3936                 return;
3937         }
3938
3939         boost::shared_ptr<RouteList> r = routes.reader ();
3940
3941         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3942                 (*i)->sync_order_keys (base);
3943         }
3944
3945         Route::SyncOrderKeys (base); // EMIT SIGNAL
3946
3947         /* this might not do anything */
3948
3949         set_remote_control_ids ();
3950 }
3951
3952 /** @return true if there is at least one record-enabled track, otherwise false */
3953 bool
3954 Session::have_rec_enabled_track () const
3955 {
3956         return g_atomic_int_get (&_have_rec_enabled_track) == 1;
3957 }
3958
3959 /** Update the state of our rec-enabled tracks flag */
3960 void
3961 Session::update_have_rec_enabled_track ()
3962 {
3963         boost::shared_ptr<RouteList> rl = routes.reader ();
3964         RouteList::iterator i = rl->begin();
3965         while (i != rl->end ()) {
3966
3967                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3968                 if (tr && tr->record_enabled ()) {
3969                         break;
3970                 }
3971
3972                 ++i;
3973         }
3974
3975         int const old = g_atomic_int_get (&_have_rec_enabled_track);
3976
3977         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
3978
3979         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
3980                 RecordStateChanged (); /* EMIT SIGNAL */
3981         }
3982 }
3983
3984 void
3985 Session::listen_position_changed ()
3986 {
3987         boost::shared_ptr<RouteList> r = routes.reader ();
3988
3989         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3990                 (*i)->listen_position_changed ();
3991         }
3992 }
3993
3994 void
3995 Session::solo_control_mode_changed ()
3996 {
3997         /* cancel all solo or all listen when solo control mode changes */
3998
3999         if (soloing()) {
4000                 set_solo (get_routes(), false);
4001         } else if (listening()) {
4002                 set_listen (get_routes(), false);
4003         }
4004 }
4005
4006 /** Called when anything about any of our route groups changes (membership, state etc.) */
4007 void
4008 Session::route_group_changed ()
4009 {
4010         RouteGroupChanged (); /* EMIT SIGNAL */
4011 }
4012
4013 vector<SyncSource>
4014 Session::get_available_sync_options () const
4015 {
4016         vector<SyncSource> ret;
4017
4018         ret.push_back (JACK);
4019         ret.push_back (MTC);
4020         ret.push_back (MIDIClock);
4021
4022         return ret;
4023 }
4024
4025 boost::shared_ptr<RouteList>
4026 Session::get_routes_with_regions_at (framepos_t const p) const
4027 {
4028         boost::shared_ptr<RouteList> r = routes.reader ();
4029         boost::shared_ptr<RouteList> rl (new RouteList);
4030
4031         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4032                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4033                 if (!tr) {
4034                         continue;
4035                 }
4036
4037                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4038                 if (!pl) {
4039                         continue;
4040                 }
4041
4042                 if (pl->has_region_at (p)) {
4043                         rl->push_back (*i);
4044                 }
4045         }
4046
4047         return rl;
4048 }
4049
4050 void
4051 Session::goto_end ()
4052 {
4053         if (_session_range_location) {
4054                 request_locate (_session_range_location->end(), false);
4055         } else {
4056                 request_locate (0, false);
4057         }
4058 }
4059
4060 void
4061 Session::goto_start ()
4062 {
4063         if (_session_range_location) {
4064                 request_locate (_session_range_location->start(), false);
4065         } else {
4066                 request_locate (0, false);
4067         }
4068 }
4069
4070 framepos_t
4071 Session::current_start_frame () const
4072 {
4073         return _session_range_location ? _session_range_location->start() : 0;
4074 }
4075
4076 framepos_t
4077 Session::current_end_frame () const
4078 {
4079         return _session_range_location ? _session_range_location->end() : 0;
4080 }
4081
4082 void
4083 Session::add_session_range_location (framepos_t start, framepos_t end)
4084 {
4085         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4086         _locations->add (_session_range_location);
4087 }
4088
4089 /** Called when one of our routes' order keys has changed */
4090 void
4091 Session::route_order_key_changed ()
4092 {
4093         RouteOrderKeyChanged (); /* EMIT SIGNAL */
4094 }
4095
4096 void
4097 Session::step_edit_status_change (bool yn)
4098 {
4099         bool send = false;
4100
4101         bool val = false;
4102         if (yn) {
4103                 send = (_step_editors == 0);
4104                 val = true;
4105
4106                 _step_editors++;
4107         } else {
4108                 send = (_step_editors == 1);
4109                 val = false;
4110
4111                 if (_step_editors > 0) {
4112                         _step_editors--;
4113                 }
4114         }
4115
4116         if (send) {
4117                 StepEditStatusChange (val);
4118         }
4119 }
4120
4121
4122 void
4123 Session::start_time_changed (framepos_t old)
4124 {
4125         /* Update the auto loop range to match the session range
4126            (unless the auto loop range has been changed by the user)
4127         */
4128
4129         Location* s = _locations->session_range_location ();
4130         if (s == 0) {
4131                 return;
4132         }
4133
4134         Location* l = _locations->auto_loop_location ();
4135
4136         if (l->start() == old) {
4137                 l->set_start (s->start(), true);
4138         }
4139 }
4140
4141 void
4142 Session::end_time_changed (framepos_t old)
4143 {
4144         /* Update the auto loop range to match the session range
4145            (unless the auto loop range has been changed by the user)
4146         */
4147
4148         Location* s = _locations->session_range_location ();
4149         if (s == 0) {
4150                 return;
4151         }
4152
4153         Location* l = _locations->auto_loop_location ();
4154
4155         if (l->end() == old) {
4156                 l->set_end (s->end(), true);
4157         }
4158 }
4159
4160 string
4161 Session::source_search_path (DataType type) const
4162 {
4163         string search_path;
4164
4165         if (session_dirs.size() == 1) {
4166                 switch (type) {
4167                 case DataType::AUDIO:
4168                         search_path = _session_dir->sound_path().to_string();
4169                         break;
4170                 case DataType::MIDI:
4171                         search_path = _session_dir->midi_path().to_string();
4172                         break;
4173                 }
4174         } else {
4175                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4176                         SessionDirectory sdir (i->path);
4177                         if (!search_path.empty()) {
4178                                 search_path += ':';
4179                         }
4180                         switch (type) {
4181                         case DataType::AUDIO:
4182                                 search_path += sdir.sound_path().to_string();
4183                                 break;
4184                         case DataType::MIDI:
4185                                 search_path += sdir.midi_path().to_string();
4186                                 break;
4187                         }
4188                 }
4189         }
4190
4191         /* now add user-specified locations
4192          */
4193
4194         vector<string> dirs;
4195
4196         switch (type) {
4197         case DataType::AUDIO:
4198                 split (config.get_audio_search_path (), dirs, ':');
4199                 break;
4200         case DataType::MIDI:
4201                 split (config.get_midi_search_path (), dirs, ':');
4202                 break;
4203         }
4204
4205         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4206                 search_path += ':';
4207                 search_path += *i;
4208
4209         }
4210
4211         return search_path;
4212 }
4213
4214 void
4215 Session::ensure_search_path_includes (const string& path, DataType type)
4216 {
4217         string search_path;
4218         vector<string> dirs;
4219
4220         if (path == ".") {
4221                 return;
4222         }
4223
4224         switch (type) {
4225         case DataType::AUDIO:
4226                 search_path = config.get_audio_search_path ();
4227                 break;
4228         case DataType::MIDI:
4229                 search_path = config.get_midi_search_path ();
4230                 break;
4231         }
4232
4233         split (search_path, dirs, ':');
4234
4235         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4236                 if (*i == path) {
4237                         return;
4238                 }
4239         }
4240
4241         if (!search_path.empty()) {
4242                 search_path += ':';
4243         }
4244
4245         search_path += path;
4246
4247         switch (type) {
4248         case DataType::AUDIO:
4249                 config.set_audio_search_path (search_path);
4250                 break;
4251         case DataType::MIDI:
4252                 config.set_midi_search_path (search_path);
4253                 break;
4254         }
4255 }
4256
4257 boost::shared_ptr<Speakers>
4258 Session::get_speakers()
4259 {
4260         return _speakers;
4261 }
4262
4263 list<string>
4264 Session::unknown_processors () const
4265 {
4266         list<string> p;
4267
4268         boost::shared_ptr<RouteList> r = routes.reader ();
4269         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4270                 list<string> t = (*i)->unknown_processors ();
4271                 copy (t.begin(), t.end(), back_inserter (p));
4272         }
4273
4274         p.sort ();
4275         p.unique ();
4276
4277         return p;
4278 }
4279
4280 void
4281 Session::update_latency (bool playback)
4282 {
4283         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4284
4285         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4286                 return;
4287         }
4288
4289         boost::shared_ptr<RouteList> r = routes.reader ();
4290         framecnt_t max_latency = 0;
4291
4292         if (playback) {
4293                 /* reverse the list so that we work backwards from the last route to run to the first */
4294                 reverse (r->begin(), r->end());
4295         }
4296
4297         /* compute actual latency values for the given direction and store them all in per-port
4298            structures. this will also publish the same values (to JACK) so that computation of latency
4299            for routes can consistently use public latency values.
4300         */
4301
4302         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4303                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4304         }
4305
4306         /* because we latency compensate playback, our published playback latencies should
4307            be the same for all output ports - all material played back by ardour has
4308            the same latency, whether its caused by plugins or by latency compensation. since
4309            these may differ from the values computed above, reset all playback port latencies
4310            to the same value.
4311         */
4312
4313         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4314
4315         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4316                 (*i)->set_public_port_latencies (max_latency, playback);
4317         }
4318
4319         if (playback) {
4320
4321                 post_playback_latency ();
4322
4323         } else {
4324
4325                 post_capture_latency ();
4326         }
4327
4328         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4329 }
4330
4331 void
4332 Session::post_playback_latency ()
4333 {
4334         set_worst_playback_latency ();
4335
4336         boost::shared_ptr<RouteList> r = routes.reader ();
4337         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4338                 if (!(*i)->is_hidden() && ((*i)->active())) {
4339                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4340                 }
4341
4342                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4343                         (*i)->set_latency_compensation (_worst_track_latency);
4344                 }
4345         }
4346 }
4347
4348 void
4349 Session::post_capture_latency ()
4350 {
4351         set_worst_capture_latency ();
4352
4353         /* reflect any changes in capture latencies into capture offsets
4354          */
4355
4356         boost::shared_ptr<RouteList> rl = routes.reader();
4357         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4358                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4359                 if (tr) {
4360                         tr->set_capture_offset ();
4361                 }
4362         }
4363 }
4364
4365 void
4366 Session::set_worst_io_latencies ()
4367 {
4368         set_worst_playback_latency ();
4369         set_worst_capture_latency ();
4370 }
4371
4372 void
4373 Session::set_worst_playback_latency ()
4374 {
4375         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4376                 return;
4377         }
4378
4379         _worst_output_latency = 0;
4380
4381         if (!_engine.connected()) {
4382                 return;
4383         }
4384
4385         boost::shared_ptr<RouteList> r = routes.reader ();
4386
4387         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4388                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4389         }
4390
4391         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4392 }
4393
4394 void
4395 Session::set_worst_capture_latency ()
4396 {
4397         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4398                 return;
4399         }
4400
4401         _worst_input_latency = 0;
4402
4403         if (!_engine.connected()) {
4404                 return;
4405         }
4406
4407         boost::shared_ptr<RouteList> r = routes.reader ();
4408
4409         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4410                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4411         }
4412
4413         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4414 }
4415
4416 void
4417 Session::update_latency_compensation (bool force_whole_graph)
4418 {
4419         bool some_track_latency_changed = false;
4420
4421         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4422                 return;
4423         }
4424
4425         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4426
4427         _worst_track_latency = 0;
4428
4429         boost::shared_ptr<RouteList> r = routes.reader ();
4430
4431         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4432                 if (!(*i)->is_hidden() && ((*i)->active())) {
4433                         framecnt_t tl;
4434                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4435                                 some_track_latency_changed = true;
4436                         }
4437                         _worst_track_latency = max (tl, _worst_track_latency);
4438                 }
4439         }
4440
4441         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4442                                                      (some_track_latency_changed ? "yes" : "no")));
4443
4444         if (force_whole_graph || some_track_latency_changed) {
4445                 /* trigger a full recompute of latency numbers for the graph.
4446                    everything else that we need to do will be done in the latency
4447                    callback.
4448                 */
4449                 _engine.update_total_latencies ();
4450                 return; // everything else will be done in the latency callback
4451         }
4452
4453         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n")
4454 }
4455