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