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 <cstdio> /* sprintf(3) ... grrr */
  27 #include <cmath>
  28 #include <cerrno>
  29 #include <unistd.h>
  30 #include <limits.h>
  31
  32 #include <glibmm/threads.h>
  33 #include <glibmm/miscutils.h>
  34 #include <glibmm/fileutils.h>
  35
  36 #include <boost/algorithm/string/erase.hpp>
  37
  38 #include "pbd/basename.h"
  39 #include "pbd/convert.h"
  40 #include "pbd/error.h"
  41 #include "pbd/file_utils.h"
  42 #include "pbd/md5.h"
  43 #include "pbd/pthread_utils.h"
  44 #include "pbd/search_path.h"
  45 #include "pbd/stacktrace.h"
  46 #include "pbd/stl_delete.h"
  47 #include "pbd/replace_all.h"
  48 #include "pbd/unwind.h"
  49
  50 #include "ardour/amp.h"
  51 #include "ardour/analyser.h"
  52 #include "ardour/async_midi_port.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/auditioner.h"
  60 #include "ardour/boost_debug.h"
  61 #include "ardour/buffer_manager.h"
  62 #include "ardour/buffer_set.h"
  63 #include "ardour/bundle.h"
  64 #include "ardour/butler.h"
  65 #include "ardour/click.h"
  66 #include "ardour/control_protocol_manager.h"
  67 #include "ardour/data_type.h"
  68 #include "ardour/debug.h"
  69 #include "ardour/directory_names.h"
  70 #ifdef USE_TRACKS_CODE_FEATURES
  71 #include "ardour/engine_state_controller.h"
  72 #endif
  73 #include "ardour/filename_extensions.h"
  74 #include "ardour/gain_control.h"
  75 #include "ardour/graph.h"
  76 #include "ardour/luabindings.h"
  77 #include "ardour/midiport_manager.h"
  78 #include "ardour/scene_changer.h"
  79 #include "ardour/midi_patch_manager.h"
  80 #include "ardour/midi_track.h"
  81 #include "ardour/midi_ui.h"
  82 #include "ardour/operations.h"
  83 #include "ardour/playlist.h"
  84 #include "ardour/playlist_factory.h"
  85 #include "ardour/plugin.h"
  86 #include "ardour/plugin_insert.h"
  87 #include "ardour/process_thread.h"
  88 #include "ardour/profile.h"
  89 #include "ardour/rc_configuration.h"
  90 #include "ardour/recent_sessions.h"
  91 #include "ardour/region.h"
  92 #include "ardour/region_factory.h"
  93 #include "ardour/revision.h"
  94 #include "ardour/route_graph.h"
  95 #include "ardour/route_group.h"
  96 #include "ardour/send.h"
  97 #include "ardour/session.h"
  98 #include "ardour/session_directory.h"
  99 #include "ardour/session_playlists.h"
 100 #include "ardour/smf_source.h"
 101 #include "ardour/solo_isolate_control.h"
 102 #include "ardour/source_factory.h"
 103 #include "ardour/speakers.h"
 104 #include "ardour/tempo.h"
 105 #include "ardour/ticker.h"
 106 #include "ardour/track.h"
 107 #include "ardour/user_bundle.h"
 108 #include "ardour/utils.h"
 109 #include "ardour/vca_manager.h"
 110 #include "ardour/vca.h"
 111
 112 #include "midi++/port.h"
 113 #include "midi++/mmc.h"
 114
 115 #include "LuaBridge/LuaBridge.h"
 116
 117 #include "pbd/i18n.h"
 118
 119 #include <glibmm/checksum.h>
 120
 121 namespace ARDOUR {
 122 class MidiSource;
 123 class Processor;
 124 class Speakers;
 125 }
 126
 127 using namespace std;
 128 using namespace ARDOUR;
 129 using namespace PBD;
 130
 131 bool Session::_disable_all_loaded_plugins = false;
 132 bool Session::_bypass_all_loaded_plugins = false;
 133 guint Session::_name_id_counter = 0;
 134
 135 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
 136 PBD::Signal1<void,std::string> Session::Dialog;
 137 PBD::Signal0<int> Session::AskAboutPendingState;
 138 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
 139 PBD::Signal2<void, framecnt_t, framecnt_t> Session::NotifyAboutSampleRateMismatch;
 140 PBD::Signal0<void> Session::SendFeedback;
 141 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
 142
 143 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
 144 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
 145 PBD::Signal2<void,std::string, std::string> Session::Exported;
 146 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
 147 PBD::Signal0<void> Session::Quit;
 148 PBD::Signal0<void> Session::FeedbackDetected;
 149 PBD::Signal0<void> Session::SuccessfulGraphSort;
 150 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
 151
 152 const framecnt_t Session::bounce_chunk_size = 8192;
 153 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
 154 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
 155
 156 // seconds should be added after the region exceeds end marker
 157 #ifdef USE_TRACKS_CODE_FEATURES
 158 const uint32_t Session::session_end_shift = 5;
 159 #else
 160 const uint32_t Session::session_end_shift = 0;
 161 #endif
 162
 163 /** @param snapshot_name Snapshot name, without .ardour suffix */
 164 Session::Session (AudioEngine &eng,
 165                   const string& fullpath,
 166                   const string& snapshot_name,
 167                   BusProfile* bus_profile,
 168                   string mix_template)
 169         : playlists (new SessionPlaylists)
 170         , _engine (eng)
 171         , process_function (&Session::process_with_events)
 172         , _bounce_processing_active (false)
 173         , waiting_for_sync_offset (false)
 174         , _base_frame_rate (0)
 175         , _nominal_frame_rate (0)
 176         , _current_frame_rate (0)
 177         , transport_sub_state (0)
 178         , _record_status (Disabled)
 179         , _transport_frame (0)
 180         , _session_range_location (0)
 181         , _session_range_end_is_free (true)
 182         , _slave (0)
 183         , _silent (false)
 184         , _transport_speed (0)
 185         , _default_transport_speed (1.0)
 186         , _last_transport_speed (0)
 187         , _target_transport_speed (0.0)
 188         , auto_play_legal (false)
 189         , _last_slave_transport_frame (0)
 190         , maximum_output_latency (0)
 191         , _requested_return_frame (-1)
 192         , current_block_size (0)
 193         , _worst_output_latency (0)
 194         , _worst_input_latency (0)
 195         , _worst_track_latency (0)
 196         , _have_captured (false)
 197         , _non_soloed_outs_muted (false)
 198         , _listening (false)
 199         , _listen_cnt (0)
 200         , _solo_isolated_cnt (0)
 201         , _writable (false)
 202         , _was_seamless (Config->get_seamless_loop ())
 203         , _under_nsm_control (false)
 204         , _xrun_count (0)
 205         , delta_accumulator_cnt (0)
 206         , average_slave_delta (1800) // !!! why 1800 ???
 207         , average_dir (0)
 208         , have_first_delta_accumulator (false)
 209         , _slave_state (Stopped)
 210         , _mtc_active (false)
 211         , _ltc_active (false)
 212         , post_export_sync (false)
 213         , post_export_position (0)
 214         , _exporting (false)
 215         , _export_rolling (false)
 216         , _realtime_export (false)
 217         , _region_export (false)
 218         , _export_preroll (0)
 219         , _export_latency (0)
 220         , _pre_export_mmc_enabled (false)
 221         , _name (snapshot_name)
 222         , _is_new (true)
 223         , _send_qf_mtc (false)
 224         , _pframes_since_last_mtc (0)
 225         , session_midi_feedback (0)
 226         , play_loop (false)
 227         , loop_changing (false)
 228         , last_loopend (0)
 229         , _session_dir (new SessionDirectory (fullpath))
 230         , _current_snapshot_name (snapshot_name)
 231         , state_tree (0)
 232         , state_was_pending (false)
 233         , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
 234         , _suspend_save (0)
 235         , _save_queued (false)
 236         , _last_roll_location (0)
 237         , _last_roll_or_reversal_location (0)
 238         , _last_record_location (0)
 239         , pending_locate_roll (false)
 240         , pending_locate_frame (0)
 241         , pending_locate_flush (false)
 242         , pending_abort (false)
 243         , pending_auto_loop (false)
 244         , _mempool ("Session", 2097152)
 245         , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
 246         , _n_lua_scripts (0)
 247         , _butler (new Butler (*this))
 248         , _post_transport_work (0)
 249         ,  cumulative_rf_motion (0)
 250         , rf_scale (1.0)
 251         , _locations (new Locations (*this))
 252         , _ignore_skips_updates (false)
 253         , _rt_thread_active (false)
 254         , _rt_emit_pending (false)
 255         , _ac_thread_active (false)
 256         , _latency_recompute_pending (0)
 257         , step_speed (0)
 258         , outbound_mtc_timecode_frame (0)
 259         , next_quarter_frame_to_send (-1)
 260         , _frames_per_timecode_frame (0)
 261         , _frames_per_hour (0)
 262         , _timecode_frames_per_hour (0)
 263         , last_timecode_valid (false)
 264         , last_timecode_when (0)
 265         , _send_timecode_update (false)
 266         , ltc_encoder (0)
 267         , ltc_enc_buf(0)
 268         , ltc_buf_off (0)
 269         , ltc_buf_len (0)
 270         , ltc_speed (0)
 271         , ltc_enc_byte (0)
 272         , ltc_enc_pos (0)
 273         , ltc_enc_cnt (0)
 274         , ltc_enc_off (0)
 275         , restarting (false)
 276         , ltc_prev_cycle (0)
 277         , ltc_timecode_offset (0)
 278         , ltc_timecode_negative_offset (false)
 279         , midi_control_ui (0)
 280         , _tempo_map (0)
 281         , _all_route_group (new RouteGroup (*this, "all"))
 282         , routes (new RouteList)
 283         , _adding_routes_in_progress (false)
 284         , _reconnecting_routes_in_progress (false)
 285         , _route_deletion_in_progress (false)
 286         , destructive_index (0)
 287         , _track_number_decimals(1)
 288         , default_fade_steepness (0)
 289         , default_fade_msecs (0)
 290         , _total_free_4k_blocks (0)
 291         , _total_free_4k_blocks_uncertain (false)
 292         , no_questions_about_missing_files (false)
 293         , _playback_load (0)
 294         , _capture_load (0)
 295         , _bundles (new BundleList)
 296         , _bundle_xml_node (0)
 297         , _current_trans (0)
 298         , _clicking (false)
 299         , click_data (0)
 300         , click_emphasis_data (0)
 301         , click_length (0)
 302         , click_emphasis_length (0)
 303         , _clicks_cleared (0)
 304         , _play_range (false)
 305         , _range_selection (-1,-1)
 306         , _object_selection (-1,-1)
 307         , main_outs (0)
 308         , first_file_data_format_reset (true)
 309         , first_file_header_format_reset (true)
 310         , have_looped (false)
 311         , _have_rec_enabled_track (false)
 312         , _have_rec_disabled_track (true)
 313         , _step_editors (0)
 314         , _suspend_timecode_transmission (0)
 315         ,  _speakers (new Speakers)
 316         , _ignore_route_processor_changes (0)
 317         , midi_clock (0)
 318         , _scene_changer (0)
 319         , _midi_ports (0)
 320         , _mmc (0)
 321         , _vca_manager (new VCAManager (*this))
 322 {
 323         uint32_t sr = 0;
 324
 325         created_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
 326
 327         pthread_mutex_init (&_rt_emit_mutex, 0);
 328         pthread_cond_init (&_rt_emit_cond, 0);
 329
 330         pthread_mutex_init (&_auto_connect_mutex, 0);
 331         pthread_cond_init (&_auto_connect_cond, 0);
 332
 333         init_name_id_counter (1); // reset for new sessions, start at 1
 334         VCA::set_next_vca_number (1); // reset for new sessions, start at 1
 335
 336         pre_engine_init (fullpath);
 337
 338         setup_lua ();
 339
 340         if (_is_new) {
 341
 342                 Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
 343
 344 #ifdef USE_TRACKS_CODE_FEATURES
 345                 sr = EngineStateController::instance()->get_current_sample_rate();
 346 #endif
 347                 if (ensure_engine (sr, true)) {
 348                         destroy ();
 349                         throw SessionException (_("Cannot connect to audio/midi engine"));
 350                 }
 351
 352                 // set samplerate for plugins added early
 353                 // e.g from templates or MB channelstrip
 354                 set_block_size (_engine.samples_per_cycle());
 355                 set_frame_rate (_engine.sample_rate());
 356
 357                 if (create (mix_template, bus_profile)) {
 358                         destroy ();
 359                         throw SessionException (_("Session initialization failed"));
 360                 }
 361
 362                 /* if a mix template was provided, then ::create() will
 363                  * have copied it into the session and we need to load it
 364                  * so that we have the state ready for ::set_state()
 365                  * after the engine is started.
 366                  *
 367                  * Note that we do NOT try to get the sample rate from
 368                  * the template at this time, though doing so would
 369                  * be easy if we decided this was an appropriate part
 370                  * of a template.
 371                  */
 372
 373                 if (!mix_template.empty()) {
 374                         if (load_state (_current_snapshot_name)) {
 375                                 throw SessionException (_("Failed to load template/snapshot state"));
 376                         }
 377                         store_recent_templates (mix_template);
 378                 }
 379
 380                 /* load default session properties - if any */
 381                 config.load_state();
 382
 383         } else {
 384
 385                 if (load_state (_current_snapshot_name)) {
 386                         throw SessionException (_("Failed to load state"));
 387                 }
 388
 389                 /* try to get sample rate from XML state so that we
 390                  * can influence the SR if we set up the audio
 391                  * engine.
 392                  */
 393
 394                 if (state_tree) {
 395                         XMLProperty const * prop;
 396                         XMLNode const * root (state_tree->root());
 397                         if ((prop = root->property (X_("sample-rate"))) != 0) {
 398                                 sr = atoi (prop->value());
 399                         }
 400                 }
 401
 402                 if (ensure_engine (sr, false)) {
 403                         destroy ();
 404                         throw SessionException (_("Cannot connect to audio/midi engine"));
 405                 }
 406         }
 407
 408         if (post_engine_init ()) {
 409                 destroy ();
 410                 throw SessionException (_("Cannot configure audio/midi engine with session parameters"));
 411         }
 412
 413         store_recent_sessions (_name, _path);
 414
 415         bool was_dirty = dirty();
 416
 417         _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 418
 419         Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
 420         config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
 421
 422         if (was_dirty) {
 423                 DirtyChanged (); /* EMIT SIGNAL */
 424         }
 425
 426         StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
 427         EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
 428
 429         emit_thread_start ();
 430         auto_connect_thread_start ();
 431
 432         /* hook us up to the engine since we are now completely constructed */
 433
 434         BootMessage (_("Connect to engine"));
 435
 436         _engine.set_session (this);
 437         _engine.reset_timebase ();
 438
 439 #ifdef USE_TRACKS_CODE_FEATURES
 440
 441         EngineStateController::instance()->set_session(this);
 442
 443         if (_is_new ) {
 444                 if ( ARDOUR::Profile->get_trx () ) {
 445
 446                         /* Waves Tracks: fill session with tracks basing on the amount of inputs.
 447                          * each available input must have corresponding track when session starts.
 448                          */
 449
 450                         uint32_t how_many (0);
 451
 452                         std::vector<std::string> inputs;
 453                         EngineStateController::instance()->get_physical_audio_inputs(inputs);
 454
 455                         how_many = inputs.size();
 456
 457                         list<boost::shared_ptr<AudioTrack> > tracks;
 458
 459                         // Track names after driver
 460                         if (Config->get_tracks_auto_naming() == NameAfterDriver) {
 461                                 string track_name = "";
 462                                 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
 463                                         string track_name;
 464                                         track_name = inputs[i];
 465                                         replace_all (track_name, "system:capture", "");
 466
 467                                         list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
 468                                         tracks.insert(tracks.begin(), single_track.front());
 469                                 }
 470                         } else { // Default track names
 471                                 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
 472                         }
 473
 474                         if (tracks.size() != how_many) {
 475                                 destroy ();
 476                                 throw failed_constructor ();
 477                         }
 478                 }
 479         }
 480 #endif
 481
 482         _is_new = false;
 483         session_loaded ();
 484
 485         BootMessage (_("Session loading complete"));
 486 }
 487
 488 Session::~Session ()
 489 {
 490 #ifdef PT_TIMING
 491         ST.dump ("ST.dump");
 492 #endif
 493         destroy ();
 494 }
 495
 496 unsigned int
 497 Session::next_name_id ()
 498 {
 499         return g_atomic_int_add (&_name_id_counter, 1);
 500 }
 501
 502 unsigned int
 503 Session::name_id_counter ()
 504 {
 505         return g_atomic_int_get (&_name_id_counter);
 506 }
 507
 508 void
 509 Session::init_name_id_counter (guint n)
 510 {
 511         g_atomic_int_set (&_name_id_counter, n);
 512 }
 513
 514 int
 515 Session::ensure_engine (uint32_t desired_sample_rate, bool isnew)
 516 {
 517         if (_engine.current_backend() == 0) {
 518                 /* backend is unknown ... */
 519                 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
 520                 if (r.get_value_or (-1) != 0) {
 521                         return -1;
 522                 }
 523         } else if (!isnew && _engine.running() && _engine.sample_rate () == desired_sample_rate) {
 524                 /* keep engine */
 525         } else if (_engine.setup_required()) {
 526                 /* backend is known, but setup is needed */
 527                 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
 528                 if (r.get_value_or (-1) != 0) {
 529                         return -1;
 530                 }
 531         } else if (!_engine.running()) {
 532                 if (_engine.start()) {
 533                         return -1;
 534                 }
 535         }
 536
 537         /* at this point the engine should be running */
 538
 539         if (!_engine.running()) {
 540                 return -1;
 541         }
 542
 543         return immediately_post_engine ();
 544
 545 }
 546
 547 int
 548 Session::immediately_post_engine ()
 549 {
 550         /* Do various initializations that should take place directly after we
 551          * know that the engine is running, but before we either create a
 552          * session or set state for an existing one.
 553          */
 554
 555         if (how_many_dsp_threads () > 1) {
 556                 /* For now, only create the graph if we are using >1 DSP threads, as
 557                    it is a bit slower than the old code with 1 thread.
 558                 */
 559                 _process_graph.reset (new Graph (*this));
 560         }
 561
 562         /* every time we reconnect, recompute worst case output latencies */
 563
 564         _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
 565
 566         if (synced_to_engine()) {
 567                 _engine.transport_stop ();
 568         }
 569
 570         if (config.get_jack_time_master()) {
 571                 _engine.transport_locate (_transport_frame);
 572         }
 573
 574         try {
 575                 LocaleGuard lg;
 576                 BootMessage (_("Set up LTC"));
 577                 setup_ltc ();
 578                 BootMessage (_("Set up Click"));
 579                 setup_click ();
 580                 BootMessage (_("Set up standard connections"));
 581                 setup_bundles ();
 582         }
 583
 584         catch (failed_constructor& err) {
 585                 return -1;
 586         }
 587
 588         /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
 589          * can we do that? */
 590          _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
 591
 592         return 0;
 593 }
 594
 595 void
 596 Session::destroy ()
 597 {
 598         vector<void*> debug_pointers;
 599
 600         /* if we got to here, leaving pending capture state around
 601            is a mistake.
 602         */
 603
 604         remove_pending_capture_state ();
 605
 606         Analyser::flush ();
 607
 608         _state_of_the_state = StateOfTheState (CannotSave|Deletion);
 609
 610         /* stop autoconnecting */
 611         auto_connect_thread_terminate ();
 612
 613         /* disconnect from any and all signals that we are connected to */
 614
 615         Port::PortSignalDrop (); /* EMIT SIGNAL */
 616         drop_connections ();
 617
 618         /* shutdown control surface protocols while we still have ports
 619            and the engine to move data to any devices.
 620         */
 621
 622         ControlProtocolManager::instance().drop_protocols ();
 623
 624         MIDI::Name::MidiPatchManager::instance().remove_search_path(session_directory().midi_patch_path());
 625
 626         _engine.remove_session ();
 627
 628 #ifdef USE_TRACKS_CODE_FEATURES
 629         EngineStateController::instance()->remove_session();
 630 #endif
 631
 632         /* deregister all ports - there will be no process or any other
 633          * callbacks from the engine any more.
 634          */
 635
 636         Port::PortDrop (); /* EMIT SIGNAL */
 637
 638         ltc_tx_cleanup();
 639
 640         /* clear history so that no references to objects are held any more */
 641
 642         _history.clear ();
 643
 644         /* clear state tree so that no references to objects are held any more */
 645
 646         delete state_tree;
 647         state_tree = 0;
 648
 649         // unregister all lua functions, drop held references (if any)
 650         (*_lua_cleanup)();
 651         lua.do_command ("Session = nil");
 652         delete _lua_run;
 653         delete _lua_add;
 654         delete _lua_del;
 655         delete _lua_list;
 656         delete _lua_save;
 657         delete _lua_load;
 658         delete _lua_cleanup;
 659         lua.collect_garbage ();
 660
 661         /* reset dynamic state version back to default */
 662         Stateful::loading_state_version = 0;
 663
 664         _butler->drop_references ();
 665         delete _butler;
 666         _butler = 0;
 667
 668         delete _all_route_group;
 669
 670         DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
 671         for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
 672                 delete *i;
 673         }
 674
 675         if (click_data != default_click) {
 676                 delete [] click_data;
 677         }
 678
 679         if (click_emphasis_data != default_click_emphasis) {
 680                 delete [] click_emphasis_data;
 681         }
 682
 683         clear_clicks ();
 684
 685         /* need to remove auditioner before monitoring section
 686          * otherwise it is re-connected */
 687         auditioner.reset ();
 688
 689         /* drop references to routes held by the monitoring section
 690          * specifically _monitor_out aux/listen references */
 691         remove_monitor_section();
 692
 693         /* clear out any pending dead wood from RCU managed objects */
 694
 695         routes.flush ();
 696         _bundles.flush ();
 697
 698         AudioDiskstream::free_working_buffers();
 699
 700         /* tell everyone who is still standing that we're about to die */
 701         drop_references ();
 702
 703         /* tell everyone to drop references and delete objects as we go */
 704
 705         DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
 706         RegionFactory::delete_all_regions ();
 707
 708         /* Do this early so that VCAs no longer hold references to routes */
 709
 710         DEBUG_TRACE (DEBUG::Destruction, "delete vcas\n");
 711         delete _vca_manager;
 712
 713         DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
 714
 715         /* reset these three references to special routes before we do the usual route delete thing */
 716
 717         _master_out.reset ();
 718         _monitor_out.reset ();
 719
 720         {
 721                 RCUWriter<RouteList> writer (routes);
 722                 boost::shared_ptr<RouteList> r = writer.get_copy ();
 723
 724                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 725                         DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
 726                         (*i)->drop_references ();
 727                 }
 728
 729                 r->clear ();
 730                 /* writer goes out of scope and updates master */
 731         }
 732         routes.flush ();
 733
 734         {
 735                 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
 736                 Glib::Threads::Mutex::Lock lm (source_lock);
 737                 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 738                         DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
 739                         i->second->drop_references ();
 740                 }
 741
 742                 sources.clear ();
 743         }
 744
 745         /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
 746         playlists.reset ();
 747
 748         emit_thread_terminate ();
 749
 750         pthread_cond_destroy (&_rt_emit_cond);
 751         pthread_mutex_destroy (&_rt_emit_mutex);
 752
 753         pthread_cond_destroy (&_auto_connect_cond);
 754         pthread_mutex_destroy (&_auto_connect_mutex);
 755
 756         delete _scene_changer; _scene_changer = 0;
 757         delete midi_control_ui; midi_control_ui = 0;
 758
 759         delete _mmc; _mmc = 0;
 760         delete _midi_ports; _midi_ports = 0;
 761         delete _locations; _locations = 0;
 762
 763         delete midi_clock;
 764         delete _tempo_map;
 765
 766         /* clear event queue, the session is gone, nobody is interested in
 767          * those anymore, but they do leak memory if not removed
 768          */
 769         while (!immediate_events.empty ()) {
 770                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 771                 SessionEvent *ev = immediate_events.front ();
 772                 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Drop event: %1\n", enum_2_string (ev->type)));
 773                 immediate_events.pop_front ();
 774                 bool remove = true;
 775                 bool del = true;
 776                 switch (ev->type) {
 777                         case SessionEvent::AutoLoop:
 778                         case SessionEvent::AutoLoopDeclick:
 779                         case SessionEvent::Skip:
 780                         case SessionEvent::PunchIn:
 781                         case SessionEvent::PunchOut:
 782                         case SessionEvent::StopOnce:
 783                         case SessionEvent::RangeStop:
 784                         case SessionEvent::RangeLocate:
 785                                 remove = false;
 786                                 del = false;
 787                                 break;
 788                         case SessionEvent::RealTimeOperation:
 789                                 process_rtop (ev);
 790                                 del = false;
 791                         default:
 792                                 break;
 793                 }
 794                 if (remove) {
 795                         del = del && !_remove_event (ev);
 796                 }
 797                 if (del) {
 798                         delete ev;
 799                 }
 800         }
 801
 802         DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
 803
 804         BOOST_SHOW_POINTERS ();
 805 }
 806
 807 void
 808 Session::setup_ltc ()
 809 {
 810         XMLNode* child = 0;
 811
 812         _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
 813         _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
 814
 815         if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
 816                 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
 817         } else {
 818                 {
 819                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 820                         _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
 821                 }
 822                 reconnect_ltc_input ();
 823         }
 824
 825         if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
 826                 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
 827         } else {
 828                 {
 829                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 830                         _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
 831                 }
 832                 reconnect_ltc_output ();
 833         }
 834
 835         /* fix up names of LTC ports because we don't want the normal
 836          * IO style of NAME/TYPE-{in,out}N
 837          */
 838
 839         _ltc_input->nth (0)->set_name (X_("LTC-in"));
 840         _ltc_output->nth (0)->set_name (X_("LTC-out"));
 841 }
 842
 843 void
 844 Session::setup_click ()
 845 {
 846         _clicking = false;
 847
 848         boost::shared_ptr<AutomationList> gl (new AutomationList (Evoral::Parameter (GainAutomation)));
 849         boost::shared_ptr<GainControl> gain_control = boost::shared_ptr<GainControl> (new GainControl (*this, Evoral::Parameter(GainAutomation), gl));
 850
 851         _click_io.reset (new ClickIO (*this, X_("Click")));
 852         _click_gain.reset (new Amp (*this, _("Fader"), gain_control, true));
 853         _click_gain->activate ();
 854         if (state_tree) {
 855                 setup_click_state (state_tree->root());
 856         } else {
 857                 setup_click_state (0);
 858         }
 859 }
 860
 861 void
 862 Session::setup_click_state (const XMLNode* node)
 863 {
 864         const XMLNode* child = 0;
 865
 866         if (node && (child = find_named_node (*node, "Click")) != 0) {
 867
 868                 /* existing state for Click */
 869                 int c = 0;
 870
 871                 if (Stateful::loading_state_version < 3000) {
 872                         c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
 873                 } else {
 874                         const XMLNodeList& children (child->children());
 875                         XMLNodeList::const_iterator i = children.begin();
 876                         if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
 877                                 ++i;
 878                                 if (i != children.end()) {
 879                                         c = _click_gain->set_state (**i, Stateful::loading_state_version);
 880                                 }
 881                         }
 882                 }
 883
 884                 if (c == 0) {
 885                         _clicking = Config->get_clicking ();
 886
 887                 } else {
 888
 889                         error << _("could not setup Click I/O") << endmsg;
 890                         _clicking = false;
 891                 }
 892
 893
 894         } else {
 895
 896                 /* default state for Click: dual-mono to first 2 physical outputs */
 897
 898                 vector<string> outs;
 899                 _engine.get_physical_outputs (DataType::AUDIO, outs);
 900
 901                 for (uint32_t physport = 0; physport < 2; ++physport) {
 902                         if (outs.size() > physport) {
 903                                 if (_click_io->add_port (outs[physport], this)) {
 904                                         // relax, even though its an error
 905                                 }
 906                         }
 907                 }
 908
 909                 if (_click_io->n_ports () > ChanCount::ZERO) {
 910                         _clicking = Config->get_clicking ();
 911                 }
 912         }
 913 }
 914
 915 void
 916 Session::get_physical_ports (vector<string>& inputs, vector<string>& outputs, DataType type,
 917                              MidiPortFlags include, MidiPortFlags exclude)
 918 {
 919         _engine.get_physical_inputs (type, inputs, include, exclude);
 920         _engine.get_physical_outputs (type, outputs, include, exclude);
 921 }
 922
 923 void
 924 Session::setup_bundles ()
 925 {
 926
 927         {
 928                 RCUWriter<BundleList> writer (_bundles);
 929                 boost::shared_ptr<BundleList> b = writer.get_copy ();
 930                 for (BundleList::iterator i = b->begin(); i != b->end();) {
 931                         if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
 932                                 ++i;
 933                                 continue;
 934                         }
 935                         i = b->erase(i);
 936                 }
 937         }
 938
 939         vector<string> inputs[DataType::num_types];
 940         vector<string> outputs[DataType::num_types];
 941
 942         for (uint32_t i = 0; i < DataType::num_types; ++i) {
 943                 get_physical_ports (inputs[i], outputs[i], DataType (DataType::Symbol (i)),
 944                                     MidiPortFlags (0), /* no specific inclusions */
 945                                     MidiPortFlags (MidiPortControl|MidiPortVirtual) /* exclude control & virtual ports */
 946                         );
 947         }
 948
 949         /* Create a set of Bundle objects that map
 950            to the physical I/O currently available.  We create both
 951            mono and stereo bundles, so that the common cases of mono
 952            and stereo tracks get bundles to put in their mixer strip
 953            in / out menus.  There may be a nicer way of achieving that;
 954            it doesn't really scale that well to higher channel counts
 955         */
 956
 957         /* mono output bundles */
 958
 959         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
 960                 char buf[64];
 961                 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
 962                 if (!pn.empty()) {
 963                         snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
 964                 } else {
 965                         snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
 966                 }
 967
 968                 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
 969                 c->add_channel (_("mono"), DataType::AUDIO);
 970                 c->set_port (0, outputs[DataType::AUDIO][np]);
 971
 972                 add_bundle (c, false);
 973         }
 974
 975         /* stereo output bundles */
 976
 977         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
 978                 if (np + 1 < outputs[DataType::AUDIO].size()) {
 979                         char buf[32];
 980                         snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
 981                         boost::shared_ptr<Bundle> c (new Bundle (buf, true));
 982                         c->add_channel (_("L"), DataType::AUDIO);
 983                         c->set_port (0, outputs[DataType::AUDIO][np]);
 984                         c->add_channel (_("R"), DataType::AUDIO);
 985                         c->set_port (1, outputs[DataType::AUDIO][np + 1]);
 986
 987                         add_bundle (c, false);
 988                 }
 989         }
 990
 991         /* mono input bundles */
 992
 993         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
 994                 char buf[64];
 995                 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
 996                 if (!pn.empty()) {
 997                         snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
 998                 } else {
 999                         snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
1000                 }
1001
1002                 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1003                 c->add_channel (_("mono"), DataType::AUDIO);
1004                 c->set_port (0, inputs[DataType::AUDIO][np]);
1005
1006                 add_bundle (c, false);
1007         }
1008
1009         /* stereo input bundles */
1010
1011         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
1012                 if (np + 1 < inputs[DataType::AUDIO].size()) {
1013                         char buf[32];
1014                         snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1015
1016                         boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1017                         c->add_channel (_("L"), DataType::AUDIO);
1018                         c->set_port (0, inputs[DataType::AUDIO][np]);
1019                         c->add_channel (_("R"), DataType::AUDIO);
1020                         c->set_port (1, inputs[DataType::AUDIO][np + 1]);
1021
1022                         add_bundle (c, false);
1023                 }
1024         }
1025
1026         /* MIDI input bundles */
1027
1028         for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
1029                 string n = inputs[DataType::MIDI][np];
1030
1031                 std::string pn = _engine.get_pretty_name_by_name (n);
1032                 if (!pn.empty()) {
1033                         n = pn;
1034                 } else {
1035                         boost::erase_first (n, X_("alsa_pcm:"));
1036                 }
1037                 boost::shared_ptr<Bundle> c (new Bundle (n, false));
1038                 c->add_channel ("", DataType::MIDI);
1039                 c->set_port (0, inputs[DataType::MIDI][np]);
1040                 add_bundle (c, false);
1041         }
1042
1043         /* MIDI output bundles */
1044
1045         for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
1046                 string n = outputs[DataType::MIDI][np];
1047                 std::string pn = _engine.get_pretty_name_by_name (n);
1048                 if (!pn.empty()) {
1049                         n = pn;
1050                 } else {
1051                         boost::erase_first (n, X_("alsa_pcm:"));
1052                 }
1053                 boost::shared_ptr<Bundle> c (new Bundle (n, true));
1054                 c->add_channel ("", DataType::MIDI);
1055                 c->set_port (0, outputs[DataType::MIDI][np]);
1056                 add_bundle (c, false);
1057         }
1058
1059         // we trust the backend to only calls us if there's a change
1060         BundleAddedOrRemoved (); /* EMIT SIGNAL */
1061 }
1062
1063 void
1064 Session::auto_connect_master_bus ()
1065 {
1066         if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
1067                 return;
1068         }
1069
1070         // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
1071         // In this case it means "Multi Out" output mode
1072         if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
1073                 return;
1074         }
1075
1076         /* if requested auto-connect the outputs to the first N physical ports.
1077          */
1078
1079         uint32_t limit = _master_out->n_outputs().n_total();
1080         vector<string> outputs[DataType::num_types];
1081
1082         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1083                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1084         }
1085
1086         for (uint32_t n = 0; n < limit; ++n) {
1087                 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
1088                 string connect_to;
1089                 if (outputs[p->type()].size() > n) {
1090                         connect_to = outputs[p->type()][n];
1091                 }
1092
1093                 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
1094                         if (_master_out->output()->connect (p, connect_to, this)) {
1095                                 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
1096                                       << endmsg;
1097                                 break;
1098                         }
1099                 }
1100         }
1101 }
1102
1103 void
1104 Session::remove_monitor_section ()
1105 {
1106         if (!_monitor_out || Profile->get_trx()) {
1107                 return;
1108         }
1109
1110         /* force reversion to Solo-In-Place */
1111         Config->set_solo_control_is_listen_control (false);
1112
1113         /* if we are auditioning, cancel it ... this is a workaround
1114            to a problem (auditioning does not execute the process graph,
1115            which is needed to remove routes when using >1 core for processing)
1116         */
1117         cancel_audition ();
1118
1119         {
1120                 /* Hold process lock while doing this so that we don't hear bits and
1121                  * pieces of audio as we work on each route.
1122                  */
1123
1124                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1125
1126                 /* Connect tracks to monitor section. Note that in an
1127                    existing session, the internal sends will already exist, but we want the
1128                    routes to notice that they connect to the control out specifically.
1129                 */
1130
1131
1132                 boost::shared_ptr<RouteList> r = routes.reader ();
1133                 ProcessorChangeBlocker  pcb (this, false);
1134
1135                 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
1136
1137                         if ((*x)->is_monitor()) {
1138                                 /* relax */
1139                         } else if ((*x)->is_master()) {
1140                                 /* relax */
1141                         } else {
1142                                 (*x)->remove_aux_or_listen (_monitor_out);
1143                         }
1144                 }
1145         }
1146
1147         remove_route (_monitor_out);
1148         if (_state_of_the_state & Deletion) {
1149                 return;
1150         }
1151
1152         auto_connect_master_bus ();
1153
1154         if (auditioner) {
1155                 auditioner->connect ();
1156         }
1157
1158         Config->ParameterChanged ("use-monitor-bus");
1159 }
1160
1161 void
1162 Session::add_monitor_section ()
1163 {
1164         RouteList rl;
1165
1166         if (_monitor_out || !_master_out || Profile->get_trx()) {
1167                 return;
1168         }
1169
1170         boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), PresentationInfo::MonitorOut, DataType::AUDIO));
1171
1172         if (r->init ()) {
1173                 return;
1174         }
1175
1176         BOOST_MARK_ROUTE(r);
1177
1178         try {
1179                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1180                 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1181                 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1182         } catch (...) {
1183                 error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
1184                 return;
1185         }
1186
1187         rl.push_back (r);
1188         add_routes (rl, false, false, false, 0);
1189
1190         assert (_monitor_out);
1191
1192         /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1193            are undefined, at best.
1194         */
1195
1196         uint32_t limit = _monitor_out->n_inputs().n_audio();
1197
1198         if (_master_out) {
1199
1200                 /* connect the inputs to the master bus outputs. this
1201                  * represents a separate data feed from the internal sends from
1202                  * each route. as of jan 2011, it allows the monitor section to
1203                  * conditionally ignore either the internal sends or the normal
1204                  * input feed, but we should really find a better way to do
1205                  * this, i think.
1206                  */
1207
1208                 _master_out->output()->disconnect (this);
1209
1210                 for (uint32_t n = 0; n < limit; ++n) {
1211                         boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1212                         boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1213
1214                         if (o) {
1215                                 string connect_to = o->name();
1216                                 if (_monitor_out->input()->connect (p, connect_to, this)) {
1217                                         error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1218                                               << endmsg;
1219                                         break;
1220                                 }
1221                         }
1222                 }
1223         }
1224
1225         /* if monitor section is not connected, connect it to physical outs
1226          */
1227
1228         if ((Config->get_auto_connect_standard_busses () || Profile->get_mixbus ()) && !_monitor_out->output()->connected ()) {
1229
1230                 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1231
1232                         boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1233
1234                         if (b) {
1235                                 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1236                         } else {
1237                                 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1238                                                            Config->get_monitor_bus_preferred_bundle())
1239                                         << endmsg;
1240                         }
1241
1242                 } else {
1243
1244                         /* Monitor bus is audio only */
1245
1246                         vector<string> outputs[DataType::num_types];
1247
1248                         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1249                                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1250                         }
1251
1252                         uint32_t mod = outputs[DataType::AUDIO].size();
1253                         uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1254
1255                         if (mod != 0) {
1256
1257                                 for (uint32_t n = 0; n < limit; ++n) {
1258
1259                                         boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1260                                         string connect_to;
1261                                         if (outputs[DataType::AUDIO].size() > (n % mod)) {
1262                                                 connect_to = outputs[DataType::AUDIO][n % mod];
1263                                         }
1264
1265                                         if (!connect_to.empty()) {
1266                                                 if (_monitor_out->output()->connect (p, connect_to, this)) {
1267                                                         error << string_compose (
1268                                                                 _("cannot connect control output %1 to %2"),
1269                                                                 n, connect_to)
1270                                                               << endmsg;
1271                                                         break;
1272                                                 }
1273                                         }
1274                                 }
1275                         }
1276                 }
1277         }
1278
1279         /* Hold process lock while doing this so that we don't hear bits and
1280          * pieces of audio as we work on each route.
1281          */
1282
1283         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1284
1285         /* Connect tracks to monitor section. Note that in an
1286            existing session, the internal sends will already exist, but we want the
1287            routes to notice that they connect to the control out specifically.
1288         */
1289
1290
1291         boost::shared_ptr<RouteList> rls = routes.reader ();
1292
1293         ProcessorChangeBlocker  pcb (this, false /* XXX */);
1294
1295         for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1296
1297                 if ((*x)->is_monitor()) {
1298                         /* relax */
1299                 } else if ((*x)->is_master()) {
1300                         /* relax */
1301                 } else {
1302                         (*x)->enable_monitor_send ();
1303                 }
1304         }
1305
1306         if (auditioner) {
1307                 auditioner->connect ();
1308         }
1309         Config->ParameterChanged ("use-monitor-bus");
1310 }
1311
1312 void
1313 Session::reset_monitor_section ()
1314 {
1315         /* Process lock should be held by the caller.*/
1316
1317         if (!_monitor_out || Profile->get_trx()) {
1318                 return;
1319         }
1320
1321         uint32_t limit = _master_out->n_outputs().n_audio();
1322
1323         /* connect the inputs to the master bus outputs. this
1324          * represents a separate data feed from the internal sends from
1325          * each route. as of jan 2011, it allows the monitor section to
1326          * conditionally ignore either the internal sends or the normal
1327          * input feed, but we should really find a better way to do
1328          * this, i think.
1329          */
1330
1331         _master_out->output()->disconnect (this);
1332         _monitor_out->output()->disconnect (this);
1333
1334         // monitor section follow master bus - except midi
1335         ChanCount mon_chn (_master_out->output()->n_ports());
1336         mon_chn.set_midi (0);
1337
1338         _monitor_out->input()->ensure_io (mon_chn, false, this);
1339         _monitor_out->output()->ensure_io (mon_chn, false, this);
1340
1341         for (uint32_t n = 0; n < limit; ++n) {
1342                 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1343                 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1344
1345                 if (o) {
1346                         string connect_to = o->name();
1347                         if (_monitor_out->input()->connect (p, connect_to, this)) {
1348                                 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1349                                       << endmsg;
1350                                 break;
1351                         }
1352                 }
1353         }
1354
1355         /* connect monitor section to physical outs
1356          */
1357
1358         if (Config->get_auto_connect_standard_busses()) {
1359
1360                 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1361
1362                         boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1363
1364                         if (b) {
1365                                 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1366                         } else {
1367                                 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1368                                                            Config->get_monitor_bus_preferred_bundle())
1369                                         << endmsg;
1370                         }
1371
1372                 } else {
1373
1374                         /* Monitor bus is audio only */
1375
1376                         vector<string> outputs[DataType::num_types];
1377
1378                         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1379                                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1380                         }
1381
1382                         uint32_t mod = outputs[DataType::AUDIO].size();
1383                         uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1384
1385                         if (mod != 0) {
1386
1387                                 for (uint32_t n = 0; n < limit; ++n) {
1388
1389                                         boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1390                                         string connect_to;
1391                                         if (outputs[DataType::AUDIO].size() > (n % mod)) {
1392                                                 connect_to = outputs[DataType::AUDIO][n % mod];
1393                                         }
1394
1395                                         if (!connect_to.empty()) {
1396                                                 if (_monitor_out->output()->connect (p, connect_to, this)) {
1397                                                         error << string_compose (
1398                                                                 _("cannot connect control output %1 to %2"),
1399                                                                 n, connect_to)
1400                                                               << endmsg;
1401                                                         break;
1402                                                 }
1403                                         }
1404                                 }
1405                         }
1406                 }
1407         }
1408
1409         /* Connect tracks to monitor section. Note that in an
1410            existing session, the internal sends will already exist, but we want the
1411            routes to notice that they connect to the control out specifically.
1412         */
1413
1414
1415         boost::shared_ptr<RouteList> rls = routes.reader ();
1416
1417         ProcessorChangeBlocker pcb (this, false);
1418
1419         for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1420
1421                 if ((*x)->is_monitor()) {
1422                         /* relax */
1423                 } else if ((*x)->is_master()) {
1424                         /* relax */
1425                 } else {
1426                         (*x)->enable_monitor_send ();
1427                 }
1428         }
1429 }
1430
1431 void
1432 Session::hookup_io ()
1433 {
1434         /* stop graph reordering notifications from
1435            causing resorts, etc.
1436         */
1437
1438         _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1439
1440         if (!auditioner) {
1441
1442                 /* we delay creating the auditioner till now because
1443                    it makes its own connections to ports.
1444                 */
1445
1446                 try {
1447                         boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1448                         if (a->init()) {
1449                                 throw failed_constructor ();
1450                         }
1451                         a->use_new_diskstream ();
1452                         auditioner = a;
1453                 }
1454
1455                 catch (failed_constructor& err) {
1456                         warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1457                 }
1458         }
1459
1460         /* load bundles, which we may have postponed earlier on */
1461         if (_bundle_xml_node) {
1462                 load_bundles (*_bundle_xml_node);
1463                 delete _bundle_xml_node;
1464         }
1465
1466         /* Tell all IO objects to connect themselves together */
1467
1468         IO::enable_connecting ();
1469
1470         /* Now tell all "floating" ports to connect to whatever
1471            they should be connected to.
1472         */
1473
1474         AudioEngine::instance()->reconnect_ports ();
1475
1476         /* Anyone who cares about input state, wake up and do something */
1477
1478         IOConnectionsComplete (); /* EMIT SIGNAL */
1479
1480         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1481
1482         /* now handle the whole enchilada as if it was one
1483            graph reorder event.
1484         */
1485
1486         graph_reordered ();
1487
1488         /* update the full solo state, which can't be
1489            correctly determined on a per-route basis, but
1490            needs the global overview that only the session
1491            has.
1492         */
1493
1494         update_route_solo_state ();
1495 }
1496
1497 void
1498 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1499 {
1500         boost::shared_ptr<Track> track = wp.lock ();
1501         if (!track) {
1502                 return;
1503         }
1504
1505         boost::shared_ptr<Playlist> playlist;
1506
1507         if ((playlist = track->playlist()) != 0) {
1508                 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1509                 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1510                 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1511         }
1512 }
1513
1514 bool
1515 Session::record_enabling_legal () const
1516 {
1517         /* this used to be in here, but survey says.... we don't need to restrict it */
1518         // if (record_status() == Recording) {
1519         //      return false;
1520         // }
1521
1522         if (Config->get_all_safe()) {
1523                 return false;
1524         }
1525         return true;
1526 }
1527
1528 void
1529 Session::set_track_monitor_input_status (bool yn)
1530 {
1531         boost::shared_ptr<RouteList> rl = routes.reader ();
1532         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1533                 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1534                 if (tr && tr->rec_enable_control()->get_value()) {
1535                         //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1536                         tr->request_input_monitoring (yn);
1537                 }
1538         }
1539 }
1540
1541 void
1542 Session::auto_punch_start_changed (Location* location)
1543 {
1544         replace_event (SessionEvent::PunchIn, location->start());
1545
1546         if (get_record_enabled() && config.get_punch_in()) {
1547                 /* capture start has been changed, so save new pending state */
1548                 save_state ("", true);
1549         }
1550 }
1551
1552 void
1553 Session::auto_punch_end_changed (Location* location)
1554 {
1555         framepos_t when_to_stop = location->end();
1556         // when_to_stop += _worst_output_latency + _worst_input_latency;
1557         replace_event (SessionEvent::PunchOut, when_to_stop);
1558 }
1559
1560 void
1561 Session::auto_punch_changed (Location* location)
1562 {
1563         framepos_t when_to_stop = location->end();
1564
1565         replace_event (SessionEvent::PunchIn, location->start());
1566         //when_to_stop += _worst_output_latency + _worst_input_latency;
1567         replace_event (SessionEvent::PunchOut, when_to_stop);
1568 }
1569
1570 /** @param loc A loop location.
1571  *  @param pos Filled in with the start time of the required fade-out (in session frames).
1572  *  @param length Filled in with the length of the required fade-out.
1573  */
1574 void
1575 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1576 {
1577         pos = max (loc->start(), loc->end() - 64);
1578         length = loc->end() - pos;
1579 }
1580
1581 void
1582 Session::auto_loop_changed (Location* location)
1583 {
1584         replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1585         framepos_t dcp;
1586         framecnt_t dcl;
1587         auto_loop_declick_range (location, dcp, dcl);
1588
1589         if (transport_rolling() && play_loop) {
1590
1591                 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1592
1593                 // if (_transport_frame > location->end()) {
1594
1595                 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1596                         // relocate to beginning of loop
1597                         clear_events (SessionEvent::LocateRoll);
1598
1599                         request_locate (location->start(), true);
1600
1601                 }
1602                 else if (Config->get_seamless_loop() && !loop_changing) {
1603
1604                         // schedule a locate-roll to refill the diskstreams at the
1605                         // previous loop end
1606                         loop_changing = true;
1607
1608                         if (location->end() > last_loopend) {
1609                                 clear_events (SessionEvent::LocateRoll);
1610                                 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1611                                 queue_event (ev);
1612                         }
1613
1614                 }
1615         } else {
1616                 clear_events (SessionEvent::AutoLoopDeclick);
1617                 clear_events (SessionEvent::AutoLoop);
1618         }
1619
1620         /* possibly move playhead if not rolling; if we are rolling we'll move
1621            to the loop start on stop if that is appropriate.
1622          */
1623
1624         framepos_t pos;
1625
1626         if (!transport_rolling() && select_playhead_priority_target (pos)) {
1627                 if (pos == location->start()) {
1628                         request_locate (pos);
1629                 }
1630         }
1631
1632
1633         last_loopend = location->end();
1634         set_dirty ();
1635 }
1636
1637 void
1638 Session::set_auto_punch_location (Location* location)
1639 {
1640         Location* existing;
1641
1642         if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1643                 punch_connections.drop_connections();
1644                 existing->set_auto_punch (false, this);
1645                 remove_event (existing->start(), SessionEvent::PunchIn);
1646                 clear_events (SessionEvent::PunchOut);
1647                 auto_punch_location_changed (0);
1648         }
1649
1650         set_dirty();
1651
1652         if (location == 0) {
1653                 return;
1654         }
1655
1656         if (location->end() <= location->start()) {
1657                 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1658                 return;
1659         }
1660
1661         punch_connections.drop_connections ();
1662
1663         location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1664         location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1665         location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1666
1667         location->set_auto_punch (true, this);
1668
1669         auto_punch_changed (location);
1670
1671         auto_punch_location_changed (location);
1672 }
1673
1674 void
1675 Session::set_session_extents (framepos_t start, framepos_t end)
1676 {
1677         Location* existing;
1678         if ((existing = _locations->session_range_location()) == 0) {
1679                 //if there is no existing session, we need to make a new session location  (should never happen)
1680                 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
1681         }
1682
1683         if (end <= start) {
1684                 error << _("Session: you can't use that location for session start/end)") << endmsg;
1685                 return;
1686         }
1687
1688         existing->set( start, end );
1689
1690         set_dirty();
1691 }
1692
1693 void
1694 Session::set_auto_loop_location (Location* location)
1695 {
1696         Location* existing;
1697
1698         if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1699                 loop_connections.drop_connections ();
1700                 existing->set_auto_loop (false, this);
1701                 remove_event (existing->end(), SessionEvent::AutoLoop);
1702                 framepos_t dcp;
1703                 framecnt_t dcl;
1704                 auto_loop_declick_range (existing, dcp, dcl);
1705                 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1706                 auto_loop_location_changed (0);
1707         }
1708
1709         set_dirty();
1710
1711         if (location == 0) {
1712                 return;
1713         }
1714
1715         if (location->end() <= location->start()) {
1716                 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1717                 return;
1718         }
1719
1720         last_loopend = location->end();
1721
1722         loop_connections.drop_connections ();
1723
1724         location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1725         location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1726         location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1727         location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1728
1729         location->set_auto_loop (true, this);
1730
1731         if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1732                 // set all tracks to use internal looping
1733                 boost::shared_ptr<RouteList> rl = routes.reader ();
1734                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1735                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1736                         if (tr && !tr->hidden()) {
1737                                 tr->set_loop (location);
1738                         }
1739                 }
1740         }
1741
1742         /* take care of our stuff first */
1743
1744         auto_loop_changed (location);
1745
1746         /* now tell everyone else */
1747
1748         auto_loop_location_changed (location);
1749 }
1750
1751 void
1752 Session::update_marks (Location*)
1753 {
1754         set_dirty ();
1755 }
1756
1757 void
1758 Session::update_skips (Location* loc, bool consolidate)
1759 {
1760         if (_ignore_skips_updates) {
1761                 return;
1762         }
1763
1764         Locations::LocationList skips;
1765
1766         if (consolidate) {
1767                 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1768                 consolidate_skips (loc);
1769         }
1770
1771         sync_locations_to_skips ();
1772
1773         set_dirty ();
1774 }
1775
1776 void
1777 Session::consolidate_skips (Location* loc)
1778 {
1779         Locations::LocationList all_locations = _locations->list ();
1780
1781         for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1782
1783                 if (!(*l)->is_skip ()) {
1784                         ++l;
1785                         continue;
1786                 }
1787
1788                 /* don't test against self */
1789
1790                 if (*l == loc) {
1791                         ++l;
1792                         continue;
1793                 }
1794
1795                 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1796                 case Evoral::OverlapInternal:
1797                 case Evoral::OverlapExternal:
1798                 case Evoral::OverlapStart:
1799                 case Evoral::OverlapEnd:
1800                         /* adjust new location to cover existing one */
1801                         loc->set_start (min (loc->start(), (*l)->start()));
1802                         loc->set_end (max (loc->end(), (*l)->end()));
1803                         /* we don't need this one any more */
1804                         _locations->remove (*l);
1805                         /* the location has been deleted, so remove reference to it in our local list */
1806                         l = all_locations.erase (l);
1807                         break;
1808
1809                 case Evoral::OverlapNone:
1810                         ++l;
1811                         break;
1812                 }
1813         }
1814 }
1815
1816 void
1817 Session::sync_locations_to_skips ()
1818 {
1819         /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1820          * Session::_sync_locations_to_skips() from the audioengine thread.
1821          */
1822         clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1823 }
1824
1825 void
1826 Session::_sync_locations_to_skips ()
1827 {
1828         /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1829
1830         Locations::LocationList const & locs (_locations->list());
1831
1832         for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1833
1834                 Location* location = *i;
1835
1836                 if (location->is_skip() && location->is_skipping()) {
1837                         SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1838                         queue_event (ev);
1839                 }
1840         }
1841 }
1842
1843
1844 void
1845 Session::location_added (Location *location)
1846 {
1847         if (location->is_auto_punch()) {
1848                 set_auto_punch_location (location);
1849         }
1850
1851         if (location->is_auto_loop()) {
1852                 set_auto_loop_location (location);
1853         }
1854
1855         if (location->is_session_range()) {
1856                 /* no need for any signal handling or event setting with the session range,
1857                    because we keep a direct reference to it and use its start/end directly.
1858                 */
1859                 _session_range_location = location;
1860         }
1861
1862         if (location->is_mark()) {
1863                 /* listen for per-location signals that require us to do any * global updates for marks */
1864
1865                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1866                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1867                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1868                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1869         }
1870
1871         if (location->is_skip()) {
1872                 /* listen for per-location signals that require us to update skip-locate events */
1873
1874                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1875                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1876                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1877                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1878
1879                 update_skips (location, true);
1880         }
1881
1882         set_dirty ();
1883 }
1884
1885 void
1886 Session::location_removed (Location *location)
1887 {
1888         if (location->is_auto_loop()) {
1889                 set_auto_loop_location (0);
1890                 set_track_loop (false);
1891         }
1892
1893         if (location->is_auto_punch()) {
1894                 set_auto_punch_location (0);
1895         }
1896
1897         if (location->is_session_range()) {
1898                 /* this is never supposed to happen */
1899                 error << _("programming error: session range removed!") << endl;
1900         }
1901
1902         if (location->is_skip()) {
1903
1904                 update_skips (location, false);
1905         }
1906
1907         set_dirty ();
1908 }
1909
1910 void
1911 Session::locations_changed ()
1912 {
1913         _locations->apply (*this, &Session::_locations_changed);
1914 }
1915
1916 void
1917 Session::_locations_changed (const Locations::LocationList& locations)
1918 {
1919         /* There was some mass-change in the Locations object.
1920
1921            We might be re-adding a location here but it doesn't actually matter
1922            for all the locations that the Session takes an interest in.
1923         */
1924
1925         {
1926                 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
1927                 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1928                         location_added (*i);
1929                 }
1930         }
1931
1932         update_skips (NULL, false);
1933 }
1934
1935 void
1936 Session::enable_record ()
1937 {
1938         if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1939                 /* no recording at anything except normal speed */
1940                 return;
1941         }
1942
1943         while (1) {
1944                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1945
1946                 if (rs == Recording) {
1947                         break;
1948                 }
1949
1950                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1951
1952                         _last_record_location = _transport_frame;
1953                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1954
1955                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1956                                 set_track_monitor_input_status (true);
1957                         }
1958
1959                         RecordStateChanged ();
1960                         break;
1961                 }
1962         }
1963 }
1964
1965 void
1966 Session::set_all_tracks_record_enabled (bool enable )
1967 {
1968         boost::shared_ptr<RouteList> rl = routes.reader();
1969         set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), enable, Controllable::NoGroup);
1970 }
1971
1972 void
1973 Session::disable_record (bool rt_context, bool force)
1974 {
1975         RecordState rs;
1976
1977         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1978
1979                 if (!Config->get_latched_record_enable () || force) {
1980                         g_atomic_int_set (&_record_status, Disabled);
1981                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1982                 } else {
1983                         if (rs == Recording) {
1984                                 g_atomic_int_set (&_record_status, Enabled);
1985                         }
1986                 }
1987
1988                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1989                         set_track_monitor_input_status (false);
1990                 }
1991
1992                 RecordStateChanged (); /* emit signal */
1993
1994                 if (!rt_context) {
1995                         remove_pending_capture_state ();
1996                 }
1997         }
1998 }
1999
2000 void
2001 Session::step_back_from_record ()
2002 {
2003         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
2004
2005                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2006                         set_track_monitor_input_status (false);
2007                 }
2008
2009                 RecordStateChanged (); /* emit signal */
2010         }
2011 }
2012
2013 void
2014 Session::maybe_enable_record ()
2015 {
2016         if (_step_editors > 0) {
2017                 return;
2018         }
2019
2020         g_atomic_int_set (&_record_status, Enabled);
2021
2022         /* This function is currently called from somewhere other than an RT thread.
2023            This save_state() call therefore doesn't impact anything.  Doing it here
2024            means that we save pending state of which sources the next record will use,
2025            which gives us some chance of recovering from a crash during the record.
2026         */
2027
2028         save_state ("", true);
2029
2030         if (_transport_speed) {
2031                 if (!config.get_punch_in()) {
2032                         enable_record ();
2033                 }
2034         } else {
2035                 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
2036                 RecordStateChanged (); /* EMIT SIGNAL */
2037         }
2038
2039         set_dirty();
2040 }
2041
2042 framepos_t
2043 Session::audible_frame () const
2044 {
2045         framepos_t ret;
2046
2047         frameoffset_t offset = worst_playback_latency (); // - _engine.samples_since_cycle_start ();
2048         offset *= transport_speed ();
2049
2050         if (synced_to_engine()) {
2051                 /* Note: this is basically just sync-to-JACK */
2052                 ret = _engine.transport_frame();
2053         } else {
2054                 ret = _transport_frame;
2055         }
2056
2057         if (transport_rolling()) {
2058                 ret -= offset;
2059
2060                 /* Check to see if we have passed the first guaranteed
2061                  * audible frame past our last start position. if not,
2062                  * return that last start point because in terms
2063                  * of audible frames, we have not moved yet.
2064                  *
2065                  * `Start position' in this context means the time we last
2066                  * either started, located, or changed transport direction.
2067                  */
2068
2069                 if (_transport_speed > 0.0f) {
2070
2071                         if (!play_loop || !have_looped) {
2072                                 if (ret < _last_roll_or_reversal_location) {
2073                                         return _last_roll_or_reversal_location;
2074                                 }
2075                         } else {
2076                                 // latent loops
2077                                 Location *location = _locations->auto_loop_location();
2078                                 frameoffset_t lo = location->start() - ret;
2079                                 if (lo > 0) {
2080                                         ret = location->end () - lo;
2081                                 }
2082                         }
2083
2084                 } else if (_transport_speed < 0.0f) {
2085
2086                         /* XXX wot? no backward looping? */
2087
2088                         if (ret > _last_roll_or_reversal_location) {
2089                                 return _last_roll_or_reversal_location;
2090                         }
2091                 }
2092         }
2093
2094         return std::max ((framepos_t)0, ret);
2095 }
2096
2097 void
2098 Session::set_frame_rate (framecnt_t frames_per_second)
2099 {
2100         /** \fn void Session::set_frame_size(framecnt_t)
2101                 the AudioEngine object that calls this guarantees
2102                 that it will not be called while we are also in
2103                 ::process(). Its fine to do things that block
2104                 here.
2105         */
2106
2107         if (_base_frame_rate == 0) {
2108                 _base_frame_rate = frames_per_second;
2109         }
2110         else if (_base_frame_rate != frames_per_second && frames_per_second != _nominal_frame_rate) {
2111                 NotifyAboutSampleRateMismatch (_base_frame_rate, frames_per_second);
2112         }
2113         _nominal_frame_rate = frames_per_second;
2114
2115         sync_time_vars();
2116
2117         clear_clicks ();
2118         reset_write_sources (false);
2119
2120         // XXX we need some equivalent to this, somehow
2121         // SndFileSource::setup_standard_crossfades (frames_per_second);
2122
2123         set_dirty();
2124
2125         /* XXX need to reset/reinstantiate all LADSPA plugins */
2126 }
2127
2128 void
2129 Session::set_block_size (pframes_t nframes)
2130 {
2131         /* the AudioEngine guarantees
2132            that it will not be called while we are also in
2133            ::process(). It is therefore fine to do things that block
2134            here.
2135         */
2136
2137         {
2138                 current_block_size = nframes;
2139
2140                 ensure_buffers ();
2141
2142                 boost::shared_ptr<RouteList> r = routes.reader ();
2143
2144                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2145                         (*i)->set_block_size (nframes);
2146                 }
2147
2148                 boost::shared_ptr<RouteList> rl = routes.reader ();
2149                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2150                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2151                         if (tr) {
2152                                 tr->set_block_size (nframes);
2153                         }
2154                 }
2155
2156                 set_worst_io_latencies ();
2157         }
2158 }
2159
2160
2161 static void
2162 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2163 {
2164         boost::shared_ptr<Route> r2;
2165
2166         if (r1->feeds (rbase) && rbase->feeds (r1)) {
2167                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2168                 return;
2169         }
2170
2171         /* make a copy of the existing list of routes that feed r1 */
2172
2173         Route::FedBy existing (r1->fed_by());
2174
2175         /* for each route that feeds r1, recurse, marking it as feeding
2176            rbase as well.
2177         */
2178
2179         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2180                 if (!(r2 = i->r.lock ())) {
2181                         /* (*i) went away, ignore it */
2182                         continue;
2183                 }
2184
2185                 /* r2 is a route that feeds r1 which somehow feeds base. mark
2186                    base as being fed by r2
2187                 */
2188
2189                 rbase->add_fed_by (r2, i->sends_only);
2190
2191                 if (r2 != rbase) {
2192
2193                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2194                            stop here.
2195                         */
2196
2197                         if (r1->feeds (r2) && r2->feeds (r1)) {
2198                                 continue;
2199                         }
2200
2201                         /* now recurse, so that we can mark base as being fed by
2202                            all routes that feed r2
2203                         */
2204
2205                         trace_terminal (r2, rbase);
2206                 }
2207
2208         }
2209 }
2210
2211 void
2212 Session::resort_routes ()
2213 {
2214         /* don't do anything here with signals emitted
2215            by Routes during initial setup or while we
2216            are being destroyed.
2217         */
2218
2219         if (_state_of_the_state & (InitialConnecting | Deletion)) {
2220                 return;
2221         }
2222
2223         if (_route_deletion_in_progress) {
2224                 return;
2225         }
2226
2227         {
2228                 RCUWriter<RouteList> writer (routes);
2229                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2230                 resort_routes_using (r);
2231                 /* writer goes out of scope and forces update */
2232         }
2233
2234 #ifndef NDEBUG
2235         if (DEBUG_ENABLED(DEBUG::Graph)) {
2236                 boost::shared_ptr<RouteList> rl = routes.reader ();
2237                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2238                         DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2239
2240                         const Route::FedBy& fb ((*i)->fed_by());
2241
2242                         for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2243                                 boost::shared_ptr<Route> sf = f->r.lock();
2244                                 if (sf) {
2245                                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2246                                 }
2247                         }
2248                 }
2249         }
2250 #endif
2251
2252 }
2253
2254 /** This is called whenever we need to rebuild the graph of how we will process
2255  *  routes.
2256  *  @param r List of routes, in any order.
2257  */
2258
2259 void
2260 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2261 {
2262         /* We are going to build a directed graph of our routes;
2263            this is where the edges of that graph are put.
2264         */
2265
2266         GraphEdges edges;
2267
2268         /* Go through all routes doing two things:
2269          *
2270          * 1. Collect the edges of the route graph.  Each of these edges
2271          *    is a pair of routes, one of which directly feeds the other
2272          *    either by a JACK connection or by an internal send.
2273          *
2274          * 2. Begin the process of making routes aware of which other
2275          *    routes directly or indirectly feed them.  This information
2276          *    is used by the solo code.
2277          */
2278
2279         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2280
2281                 /* Clear out the route's list of direct or indirect feeds */
2282                 (*i)->clear_fed_by ();
2283
2284                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2285
2286                         bool via_sends_only;
2287
2288                         /* See if this *j feeds *i according to the current state of the JACK
2289                            connections and internal sends.
2290                         */
2291                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2292                                 /* add the edge to the graph (part #1) */
2293                                 edges.add (*j, *i, via_sends_only);
2294                                 /* tell the route (for part #2) */
2295                                 (*i)->add_fed_by (*j, via_sends_only);
2296                         }
2297                 }
2298         }
2299
2300         /* Attempt a topological sort of the route graph */
2301         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2302
2303         if (sorted_routes) {
2304                 /* We got a satisfactory topological sort, so there is no feedback;
2305                    use this new graph.
2306
2307                    Note: the process graph rechain does not require a
2308                    topologically-sorted list, but hey ho.
2309                 */
2310                 if (_process_graph) {
2311                         _process_graph->rechain (sorted_routes, edges);
2312                 }
2313
2314                 _current_route_graph = edges;
2315
2316                 /* Complete the building of the routes' lists of what directly
2317                    or indirectly feeds them.
2318                 */
2319                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2320                         trace_terminal (*i, *i);
2321                 }
2322
2323                 *r = *sorted_routes;
2324
2325 #ifndef NDEBUG
2326                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2327                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2328                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2329                 }
2330 #endif
2331
2332                 SuccessfulGraphSort (); /* EMIT SIGNAL */
2333
2334         } else {
2335                 /* The topological sort failed, so we have a problem.  Tell everyone
2336                    and stick to the old graph; this will continue to be processed, so
2337                    until the feedback is fixed, what is played back will not quite
2338                    reflect what is actually connected.  Note also that we do not
2339                    do trace_terminal here, as it would fail due to an endless recursion,
2340                    so the solo code will think that everything is still connected
2341                    as it was before.
2342                 */
2343
2344                 FeedbackDetected (); /* EMIT SIGNAL */
2345         }
2346
2347 }
2348
2349 /** Find a route name starting with \a base, maybe followed by the
2350  *  lowest \a id.  \a id will always be added if \a definitely_add_number
2351  *  is true on entry; otherwise it will only be added if required
2352  *  to make the name unique.
2353  *
2354  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2355  *  The available route name with the lowest ID will be used, and \a id
2356  *  will be set to the ID.
2357  *
2358  *  \return false if a route name could not be found, and \a track_name
2359  *  and \a id do not reflect a free route name.
2360  */
2361 bool
2362 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2363 {
2364         /* the base may conflict with ports that do not belong to existing
2365            routes, but hidden objects like the click track. So check port names
2366            before anything else.
2367         */
2368
2369         for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2370                 if (base == *reserved) {
2371                         /* Check if this reserved name already exists, and if
2372                            so, disallow it without a numeric suffix.
2373                         */
2374                         if (route_by_name (*reserved)) {
2375                                 definitely_add_number = true;
2376                                 if (id < 1) {
2377                                         id = 1;
2378                                 }
2379                         }
2380                         break;
2381                 }
2382         }
2383
2384         /* if we have "base 1" already, it doesn't make sense to add "base"
2385          * if "base 1" has been deleted, adding "base" is no worse than "base 1"
2386          */
2387         if (!definitely_add_number && route_by_name (base) == 0 && (route_by_name (string_compose("%1 1", base)) == 0)) {
2388                 /* just use the base */
2389                 name = base;
2390                 return true;
2391         }
2392
2393         do {
2394                 name = string_compose ("%1 %2", base, id);
2395
2396                 if (route_by_name (name) == 0) {
2397                         return true;
2398                 }
2399
2400                 ++id;
2401
2402         } while (id < (UINT_MAX-1));
2403
2404         return false;
2405 }
2406
2407 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2408 void
2409 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2410 {
2411         in  = ChanCount::ZERO;
2412         out = ChanCount::ZERO;
2413
2414         boost::shared_ptr<RouteList> r = routes.reader ();
2415
2416         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2417                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2418                 if (tr && !tr->is_auditioner()) {
2419                         in  += tr->n_inputs();
2420                         out += tr->n_outputs();
2421                 }
2422         }
2423 }
2424
2425 string
2426 Session::default_track_name_pattern (DataType t)
2427 {
2428         switch (t) {
2429         case DataType::AUDIO:
2430                 if (Profile->get_trx()) {
2431                         return _("Track ");
2432                 } else {
2433                         return _("Audio ");
2434                 }
2435                 break;
2436
2437         case DataType::MIDI:
2438                 return _("MIDI ");
2439         }
2440
2441         return "";
2442 }
2443
2444 /** Caller must not hold process lock
2445  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
2446  *  @param instrument plugin info for the instrument to insert pre-fader, if any
2447  */
2448 list<boost::shared_ptr<MidiTrack> >
2449 Session::new_midi_track (const ChanCount& input, const ChanCount& output,
2450                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2451                          RouteGroup* route_group, uint32_t how_many, string name_template, PresentationInfo::order_t order,
2452                          TrackMode mode)
2453 {
2454         string track_name;
2455         uint32_t track_id = 0;
2456         string port;
2457         RouteList new_routes;
2458         list<boost::shared_ptr<MidiTrack> > ret;
2459
2460         const string name_pattern = default_track_name_pattern (DataType::MIDI);
2461         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2462
2463         while (how_many) {
2464                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2465                         error << "cannot find name for new midi track" << endmsg;
2466                         goto failed;
2467                 }
2468
2469                 boost::shared_ptr<MidiTrack> track;
2470
2471                 try {
2472                         track.reset (new MidiTrack (*this, track_name, mode));
2473
2474                         if (track->init ()) {
2475                                 goto failed;
2476                         }
2477
2478                         if (Profile->get_mixbus ()) {
2479                                 track->set_strict_io (true);
2480                         }
2481
2482                         track->use_new_diskstream();
2483
2484                         BOOST_MARK_TRACK (track);
2485
2486                         {
2487                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2488                                 if (track->input()->ensure_io (input, false, this)) {
2489                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2490                                         goto failed;
2491                                 }
2492
2493                                 if (track->output()->ensure_io (output, false, this)) {
2494                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2495                                         goto failed;
2496                                 }
2497                         }
2498
2499                         track->non_realtime_input_change();
2500
2501                         if (route_group) {
2502                                 route_group->add (track);
2503                         }
2504
2505                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2506
2507                         new_routes.push_back (track);
2508                         ret.push_back (track);
2509                 }
2510
2511                 catch (failed_constructor &err) {
2512                         error << _("Session: could not create new midi track.") << endmsg;
2513                         goto failed;
2514                 }
2515
2516                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2517
2518                         error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
2519                         goto failed;
2520                 }
2521
2522                 --how_many;
2523         }
2524
2525   failed:
2526         if (!new_routes.empty()) {
2527                 StateProtector sp (this);
2528                 if (Profile->get_trx()) {
2529                         add_routes (new_routes, false, false, false, order);
2530                 } else {
2531                         add_routes (new_routes, true, true, false, order);
2532                 }
2533
2534                 if (instrument) {
2535                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2536                                 PluginPtr plugin = instrument->load (*this);
2537                                 if (!plugin) {
2538                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2539                                         continue;
2540                                 }
2541                                 if (pset) {
2542                                         plugin->load_preset (*pset);
2543                                 }
2544                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2545                                 (*r)->add_processor (p, PreFader);
2546                         }
2547                 }
2548         }
2549
2550         return ret;
2551 }
2552
2553 RouteList
2554 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2555                          PresentationInfo::Flag flag, PresentationInfo::order_t order)
2556 {
2557         string bus_name;
2558         uint32_t bus_id = 0;
2559         string port;
2560         RouteList ret;
2561
2562         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2563
2564         while (how_many) {
2565                 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2566                         error << "cannot find name for new midi bus" << endmsg;
2567                         goto failure;
2568                 }
2569
2570                 try {
2571                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2572
2573                         if (bus->init ()) {
2574                                 goto failure;
2575                         }
2576
2577                         if (Profile->get_mixbus ()) {
2578                                 bus->set_strict_io (true);
2579                         }
2580
2581                         BOOST_MARK_ROUTE(bus);
2582
2583                         {
2584                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2585
2586                                 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2587                                         error << _("cannot configure new midi bus input") << endmsg;
2588                                         goto failure;
2589                                 }
2590
2591
2592                                 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2593                                         error << _("cannot configure new midi bus output") << endmsg;
2594                                         goto failure;
2595                                 }
2596                         }
2597
2598                         if (route_group) {
2599                                 route_group->add (bus);
2600                         }
2601
2602                         bus->add_internal_return ();
2603                         ret.push_back (bus);
2604                 }
2605
2606                 catch (failed_constructor &err) {
2607                         error << _("Session: could not create new audio route.") << endmsg;
2608                         goto failure;
2609                 }
2610
2611                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2612                         error << pfe.what() << endmsg;
2613                         goto failure;
2614                 }
2615
2616
2617                 --how_many;
2618         }
2619
2620   failure:
2621         if (!ret.empty()) {
2622                 StateProtector sp (this);
2623                 add_routes (ret, false, false, false, order);
2624
2625                 if (instrument) {
2626                         for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2627                                 PluginPtr plugin = instrument->load (*this);
2628                                 if (!plugin) {
2629                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2630                                         continue;
2631                                 }
2632                                 if (pset) {
2633                                         plugin->load_preset (*pset);
2634                                 }
2635                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2636                                 (*r)->add_processor (p, PreFader);
2637                         }
2638                 }
2639         }
2640
2641         return ret;
2642
2643 }
2644
2645
2646 void
2647 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2648 {
2649         boost::shared_ptr<Route> midi_track (wmt.lock());
2650
2651         if (!midi_track) {
2652                 return;
2653         }
2654
2655         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2656
2657                 if (change.after.n_audio() <= change.before.n_audio()) {
2658                         return;
2659                 }
2660
2661                 /* new audio ports: make sure the audio goes somewhere useful,
2662                  * unless the user has no-auto-connect selected.
2663                  *
2664                  * The existing ChanCounts don't matter for this call as they are only
2665                  * to do with matching input and output indices, and we are only changing
2666                  * outputs here.
2667                  */
2668                 auto_connect_route (midi_track, false, ChanCount(), change.before);
2669         }
2670 }
2671
2672 #ifdef USE_TRACKS_CODE_FEATURES
2673
2674 static bool
2675 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2676 {
2677         return route1->remote_control_id() < route2->remote_control_id();
2678 }
2679
2680 void
2681 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2682 {
2683         // it is not allowed to perform connection
2684         if (!IO::connecting_legal) {
2685                 return;
2686         }
2687
2688         // if we are deleting routes we will call this once at the end
2689         if (_route_deletion_in_progress) {
2690                 return;
2691         }
2692
2693         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2694
2695         if (withLock) {
2696                 lm.acquire ();
2697         }
2698
2699         // We need to disconnect the route's inputs and outputs first
2700         // basing on autoconnect configuration
2701         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2702         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2703
2704         ChanCount existing_inputs;
2705         ChanCount existing_outputs;
2706         count_existing_track_channels (existing_inputs, existing_outputs);
2707
2708         //ChanCount inputs = ChanCount::ZERO;
2709         //ChanCount outputs = ChanCount::ZERO;
2710
2711         RouteList existing_routes = *routes.reader ();
2712         existing_routes.sort (compare_routes_by_remote_id);
2713
2714         {
2715                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2716
2717                 vector<string> physinputs;
2718                 vector<string> physoutputs;
2719
2720                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2721                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2722
2723                 uint32_t input_n = 0;
2724                 uint32_t output_n = 0;
2725                 RouteList::iterator rIter = existing_routes.begin();
2726                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2727                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2728                 for (; rIter != existing_routes.end(); ++rIter) {
2729                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2730                                 continue;
2731                         }
2732
2733                         if (current_output_auto_connection == AutoConnectPhysical) {
2734                                 (*rIter)->amp()->deactivate();
2735                         } else if (current_output_auto_connection == AutoConnectMaster) {
2736                                 (*rIter)->amp()->activate();
2737                         }
2738
2739                         if (reconnectIputs) {
2740                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2741
2742                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2743
2744                                         if (current_input_auto_connection & AutoConnectPhysical) {
2745
2746                                                 if ( input_n == physinputs.size() ) {
2747                                                         break;
2748                                                 }
2749
2750                                                 string port = physinputs[input_n];
2751
2752                                                 if (port.empty() ) {
2753                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2754                                                 }
2755
2756                                                 //GZ: check this; could be heavy
2757                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2758                                                 ++input_n;
2759                                         }
2760                                 }
2761                         }
2762
2763                         if (reconnectOutputs) {
2764
2765                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2766                                 if (current_output_auto_connection & AutoConnectPhysical) {
2767
2768                                         //GZ: check this; could be heavy
2769                                         (*rIter)->output()->disconnect (this);
2770                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2771
2772                                         //GZ: check this; could be heavy
2773                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2774
2775                                 } else if (current_output_auto_connection & AutoConnectMaster){
2776
2777                                         if (!reconnect_master) {
2778                                                 continue;
2779                                         }
2780
2781                                         //GZ: check this; could be heavy
2782                                         (*rIter)->output()->disconnect (this);
2783
2784                                         if (_master_out) {
2785                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2786                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2787                                         } else {
2788                                                 error << error << "Master bus is not available" << endmsg;
2789                                                 break;
2790                                         }
2791                                 }
2792
2793                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2794                                         if (current_output_auto_connection & AutoConnectPhysical) {
2795
2796                                                 if ( output_n == physoutputs.size() ) {
2797                                                         break;
2798                                                 }
2799
2800                                                 string port = physoutputs[output_n];
2801
2802                                                 if (port.empty() ) {
2803                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2804                                                 }
2805
2806                                                 //GZ: check this; could be heavy
2807                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2808                                                 ++output_n;
2809
2810                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2811
2812                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2813                                                         break;
2814                                                 }
2815
2816                                                 // connect to master bus
2817                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2818
2819                                                 if (port.empty() ) {
2820                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2821                                                 }
2822
2823
2824                                                 //GZ: check this; could be heavy
2825                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2826
2827                                         }
2828                                 }
2829                         }
2830                 }
2831
2832                 _master_out->output()->disconnect (this);
2833                 auto_connect_master_bus ();
2834         }
2835
2836         graph_reordered ();
2837
2838         session_routes_reconnected (); /* EMIT SIGNAL */
2839 }
2840
2841 void
2842 Session::reconnect_midi_scene_ports(bool inputs)
2843 {
2844     if (inputs ) {
2845
2846         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2847         if (scene_in_ptr) {
2848             scene_in_ptr->disconnect_all ();
2849
2850             std::vector<EngineStateController::MidiPortState> midi_port_states;
2851             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2852
2853             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2854
2855             for (; state_iter != midi_port_states.end(); ++state_iter) {
2856                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2857                     scene_in_ptr->connect (state_iter->name);
2858                 }
2859             }
2860         }
2861
2862     } else {
2863
2864         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2865
2866         if (scene_out_ptr ) {
2867             scene_out_ptr->disconnect_all ();
2868
2869             std::vector<EngineStateController::MidiPortState> midi_port_states;
2870             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2871
2872             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2873
2874             for (; state_iter != midi_port_states.end(); ++state_iter) {
2875                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2876                     scene_out_ptr->connect (state_iter->name);
2877                 }
2878             }
2879         }
2880     }
2881 }
2882
2883 void
2884 Session::reconnect_mtc_ports ()
2885 {
2886         boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2887
2888         if (!mtc_in_ptr) {
2889                 return;
2890         }
2891
2892         mtc_in_ptr->disconnect_all ();
2893
2894         std::vector<EngineStateController::MidiPortState> midi_port_states;
2895         EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2896
2897         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2898
2899         for (; state_iter != midi_port_states.end(); ++state_iter) {
2900                 if (state_iter->available && state_iter->mtc_in) {
2901                         mtc_in_ptr->connect (state_iter->name);
2902                 }
2903         }
2904
2905         if (!_midi_ports->mtc_input_port ()->connected () &&
2906             config.get_external_sync () &&
2907             (Config->get_sync_source () == MTC) ) {
2908                 config.set_external_sync (false);
2909         }
2910
2911         if ( ARDOUR::Profile->get_trx () ) {
2912                 // Tracks need this signal to update timecode_source_dropdown
2913                 MtcOrLtcInputPortChanged (); //emit signal
2914         }
2915 }
2916
2917 void
2918 Session::reconnect_mmc_ports(bool inputs)
2919 {
2920         if (inputs ) { // get all enabled midi input ports
2921
2922                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
2923                 if (mmc_in_ptr) {
2924                         mmc_in_ptr->disconnect_all ();
2925                         std::vector<std::string> enabled_midi_inputs;
2926                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
2927
2928                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
2929
2930                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
2931                                 mmc_in_ptr->connect (*port_iter);
2932                         }
2933
2934                 }
2935         } else { // get all enabled midi output ports
2936
2937                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
2938                 if (mmc_out_ptr ) {
2939                         mmc_out_ptr->disconnect_all ();
2940                         std::vector<std::string> enabled_midi_outputs;
2941                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
2942
2943                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
2944
2945                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
2946                                 mmc_out_ptr->connect (*port_iter);
2947                         }
2948                 }
2949         }
2950 }
2951
2952 #endif
2953
2954 void
2955 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
2956 {
2957         if (first_new_order == PresentationInfo::max_order) {
2958                 /* adding at end, no worries */
2959                 return;
2960         }
2961
2962         /* create a gap in the presentation info to accomodate @param how_many
2963          * new objects.
2964          */
2965         StripableList sl;
2966         get_stripables (sl);
2967
2968         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
2969                 boost::shared_ptr<Stripable> s (*si);
2970
2971                 if (s->is_monitor() || s->is_auditioner()) {
2972                         continue;
2973                 }
2974
2975                 if (s->presentation_info().order () >= first_new_order) {
2976                         s->set_presentation_order (s->presentation_info().order () + how_many);
2977                 }
2978         }
2979 }
2980
2981 /** Caller must not hold process lock
2982  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2983  */
2984 list< boost::shared_ptr<AudioTrack> >
2985 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
2986                           uint32_t how_many, string name_template, PresentationInfo::order_t order,
2987                           TrackMode mode)
2988 {
2989         string track_name;
2990         uint32_t track_id = 0;
2991         string port;
2992         RouteList new_routes;
2993         list<boost::shared_ptr<AudioTrack> > ret;
2994
2995         const string name_pattern = default_track_name_pattern (DataType::AUDIO);
2996         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2997
2998         while (how_many) {
2999
3000                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
3001                         error << "cannot find name for new audio track" << endmsg;
3002                         goto failed;
3003                 }
3004
3005                 boost::shared_ptr<AudioTrack> track;
3006
3007                 try {
3008                         track.reset (new AudioTrack (*this, track_name, mode));
3009
3010                         if (track->init ()) {
3011                                 goto failed;
3012                         }
3013
3014                         if (Profile->get_mixbus ()) {
3015                                 track->set_strict_io (true);
3016                         }
3017
3018                         if (ARDOUR::Profile->get_trx ()) {
3019                                 // TRACKS considers it's not a USE CASE, it's
3020                                 // a piece of behavior of the session model:
3021                                 //
3022                                 // Gain for a newly created route depends on
3023                                 // the current output_auto_connect mode:
3024                                 //
3025                                 //  0 for Stereo Out mode
3026                                 //  0 Multi Out mode
3027                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3028                                         track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3029                                 }
3030                         }
3031
3032                         track->use_new_diskstream();
3033
3034                         BOOST_MARK_TRACK (track);
3035
3036                         {
3037                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3038
3039                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3040                                         error << string_compose (
3041                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3042                                                 input_channels, output_channels)
3043                                               << endmsg;
3044                                         goto failed;
3045                                 }
3046
3047                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3048                                         error << string_compose (
3049                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3050                                                 input_channels, output_channels)
3051                                               << endmsg;
3052                                         goto failed;
3053                                 }
3054                         }
3055
3056                         if (route_group) {
3057                                 route_group->add (track);
3058                         }
3059
3060                         track->non_realtime_input_change();
3061
3062                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
3063
3064                         new_routes.push_back (track);
3065                         ret.push_back (track);
3066                 }
3067
3068                 catch (failed_constructor &err) {
3069                         error << _("Session: could not create new audio track.") << endmsg;
3070                         goto failed;
3071                 }
3072
3073                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3074
3075                         error << pfe.what() << endmsg;
3076                         goto failed;
3077                 }
3078
3079                 --how_many;
3080         }
3081
3082   failed:
3083         if (!new_routes.empty()) {
3084                 StateProtector sp (this);
3085                 if (Profile->get_trx()) {
3086                         add_routes (new_routes, false, false, false, order);
3087                 } else {
3088                         add_routes (new_routes, true, true, false, order);
3089                 }
3090         }
3091
3092         return ret;
3093 }
3094
3095 /** Caller must not hold process lock.
3096  *  @param name_template string to use for the start of the name, or "" to use "Bus".
3097  */
3098 RouteList
3099 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3100                           PresentationInfo::Flag flags, PresentationInfo::order_t order)
3101 {
3102         string bus_name;
3103         uint32_t bus_id = 0;
3104         string port;
3105         RouteList ret;
3106
3107         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3108
3109         while (how_many) {
3110                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3111                         error << "cannot find name for new audio bus" << endmsg;
3112                         goto failure;
3113                 }
3114
3115                 try {
3116                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3117
3118                         if (bus->init ()) {
3119                                 goto failure;
3120                         }
3121
3122                         if (Profile->get_mixbus ()) {
3123                                 bus->set_strict_io (true);
3124                         }
3125
3126                         BOOST_MARK_ROUTE(bus);
3127
3128                         {
3129                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3130
3131                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3132                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3133                                                                  input_channels, output_channels)
3134                                               << endmsg;
3135                                         goto failure;
3136                                 }
3137
3138
3139                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3140                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3141                                                                  input_channels, output_channels)
3142                                               << endmsg;
3143                                         goto failure;
3144                                 }
3145                         }
3146
3147                         if (route_group) {
3148                                 route_group->add (bus);
3149                         }
3150
3151                         bus->add_internal_return ();
3152                         ret.push_back (bus);
3153                 }
3154
3155                 catch (failed_constructor &err) {
3156                         error << _("Session: could not create new audio route.") << endmsg;
3157                         goto failure;
3158                 }
3159
3160                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3161                         error << pfe.what() << endmsg;
3162                         goto failure;
3163                 }
3164
3165
3166                 --how_many;
3167         }
3168
3169   failure:
3170         if (!ret.empty()) {
3171                 StateProtector sp (this);
3172                 if (Profile->get_trx()) {
3173                         add_routes (ret, false, false, false, order);
3174                 } else {
3175                         add_routes (ret, false, true, true, order); // autoconnect // outputs only
3176                 }
3177         }
3178
3179         return ret;
3180
3181 }
3182
3183 RouteList
3184 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3185                                   PlaylistDisposition pd)
3186 {
3187         XMLTree tree;
3188
3189         if (!tree.read (template_path.c_str())) {
3190                 return RouteList();
3191         }
3192
3193         return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3194 }
3195
3196 RouteList
3197 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3198 {
3199         RouteList ret;
3200         uint32_t number = 0;
3201         const uint32_t being_added = how_many;
3202         /* This will prevent the use of any existing XML-provided PBD::ID
3203            values by Stateful.
3204         */
3205         Stateful::ForceIDRegeneration force_ids;
3206         IO::disable_connecting ();
3207
3208         while (how_many) {
3209
3210                 /* We're going to modify the node contents a bit so take a
3211                  * copy. The node may be re-used when duplicating more than once.
3212                  */
3213
3214                 XMLNode node_copy (node);
3215
3216                 try {
3217                         string name;
3218
3219                         if (!name_base.empty()) {
3220
3221                                 /* if we're adding more than one routes, force
3222                                  * all the names of the new routes to be
3223                                  * numbered, via the final parameter.
3224                                  */
3225
3226                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3227                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3228                                         /*NOTREACHDE*/
3229                                 }
3230
3231                         } else {
3232
3233                                 string const route_name  = node_copy.property(X_("name"))->value ();
3234
3235                                 /* generate a new name by adding a number to the end of the template name */
3236                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3237                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3238                                         abort(); /*NOTREACHED*/
3239                                 }
3240                         }
3241
3242                         /* set this name in the XML description that we are about to use */
3243
3244                         if (pd == CopyPlaylist) {
3245                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3246                                 if (ds_node) {
3247                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3248                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3249                                         // Use same name as Route::set_name_in_state so playlist copy
3250                                         // is picked up when creating the Route in XMLRouteFactory below
3251                                         PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3252                                 }
3253                         }
3254
3255                         bool rename_playlist = (pd == CopyPlaylist || pd == NewPlaylist);
3256
3257                         Route::set_name_in_state (node_copy, name, rename_playlist);
3258
3259                         /* trim bitslots from listen sends so that new ones are used */
3260                         XMLNodeList children = node_copy.children ();
3261                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3262                                 if ((*i)->name() == X_("Processor")) {
3263                                         /* ForceIDRegeneration does not catch the following */
3264                                         XMLProperty const * role = (*i)->property (X_("role"));
3265                                         XMLProperty const * type = (*i)->property (X_("type"));
3266                                         if (role && role->value() == X_("Aux")) {
3267                                                 /* check if the target bus exists.
3268                                                  * we should not save aux-sends in templates.
3269                                                  */
3270                                                 XMLProperty const * target = (*i)->property (X_("target"));
3271                                                 if (!target) {
3272                                                         (*i)->add_property ("type", "dangling-aux-send");
3273                                                         continue;
3274                                                 }
3275                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3276                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3277                                                         (*i)->add_property ("type", "dangling-aux-send");
3278                                                         continue;
3279                                                 }
3280                                         }
3281                                         if (role && role->value() == X_("Listen")) {
3282                                                 (*i)->remove_property (X_("bitslot"));
3283                                         }
3284                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3285                                                 char buf[32];
3286                                                 Delivery::Role xrole;
3287                                                 uint32_t bitslot = 0;
3288                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3289                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3290                                                 snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
3291                                                 (*i)->remove_property (X_("bitslot"));
3292                                                 (*i)->remove_property (X_("name"));
3293                                                 (*i)->add_property ("bitslot", buf);
3294                                                 (*i)->add_property ("name", name);
3295                                         }
3296                                         else if (type && type->value() == X_("intreturn")) {
3297                                                 (*i)->remove_property (X_("bitslot"));
3298                                                 (*i)->add_property ("ignore-bitslot", "1");
3299                                         }
3300                                         else if (type && type->value() == X_("return")) {
3301                                                 // Return::set_state() generates a new one
3302                                                 (*i)->remove_property (X_("bitslot"));
3303                                         }
3304                                         else if (type && type->value() == X_("port")) {
3305                                                 // PortInsert::set_state() handles the bitslot
3306                                                 (*i)->remove_property (X_("bitslot"));
3307                                                 (*i)->add_property ("ignore-name", "1");
3308                                         }
3309                                 }
3310                         }
3311
3312                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3313
3314                         if (route == 0) {
3315                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3316                                 goto out;
3317                         }
3318
3319                         if (boost::dynamic_pointer_cast<Track>(route)) {
3320                                 /* force input/output change signals so that the new diskstream
3321                                    picks up the configuration of the route. During session
3322                                    loading this normally happens in a different way.
3323                                 */
3324
3325                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3326
3327                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3328                                 change.after = route->input()->n_ports();
3329                                 route->input()->changed (change, this);
3330                                 change.after = route->output()->n_ports();
3331                                 route->output()->changed (change, this);
3332                         }
3333
3334                         ret.push_back (route);
3335                 }
3336
3337                 catch (failed_constructor &err) {
3338                         error << _("Session: could not create new route from template") << endmsg;
3339                         goto out;
3340                 }
3341
3342                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3343                         error << pfe.what() << endmsg;
3344                         goto out;
3345                 }
3346
3347                 --how_many;
3348         }
3349
3350   out:
3351         if (!ret.empty()) {
3352                 StateProtector sp (this);
3353                 if (Profile->get_trx()) {
3354                         add_routes (ret, false, false, false, insert_at);
3355                 } else {
3356                         add_routes (ret, true, true, false, insert_at);
3357                 }
3358                 IO::enable_connecting ();
3359         }
3360
3361         return ret;
3362 }
3363
3364 void
3365 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3366 {
3367         try {
3368                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3369                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3370
3371         } catch (...) {
3372                 error << _("Adding new tracks/busses failed") << endmsg;
3373         }
3374
3375         graph_reordered ();
3376
3377         update_latency (true);
3378         update_latency (false);
3379
3380         set_dirty();
3381
3382         if (save) {
3383                 save_state (_current_snapshot_name);
3384         }
3385
3386         update_route_record_state ();
3387
3388         RouteAdded (new_routes); /* EMIT SIGNAL */
3389 }
3390
3391 void
3392 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3393 {
3394         ChanCount existing_inputs;
3395         ChanCount existing_outputs;
3396         uint32_t n_routes;
3397         uint32_t added = 0;
3398
3399         count_existing_track_channels (existing_inputs, existing_outputs);
3400
3401         {
3402                 RCUWriter<RouteList> writer (routes);
3403                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3404                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3405                 n_routes = r->size();
3406
3407                 /* if there is no control out and we're not in the middle of loading,
3408                  * resort the graph here. if there is a control out, we will resort
3409                  * toward the end of this method. if we are in the middle of loading,
3410                  * we will resort when done.
3411                  */
3412
3413                 if (!_monitor_out && IO::connecting_legal) {
3414                         resort_routes_using (r);
3415                 }
3416         }
3417
3418         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", order, new_routes.size()));
3419         ensure_route_presentation_info_gap (order, new_routes.size());
3420
3421         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3422
3423                 boost::weak_ptr<Route> wpr (*x);
3424                 boost::shared_ptr<Route> r (*x);
3425
3426                 r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3427                 r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3428                 r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3429
3430                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3431                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3432                 r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3433
3434                 if (r->is_master()) {
3435                         _master_out = r;
3436                 }
3437
3438                 if (r->is_monitor()) {
3439                         _monitor_out = r;
3440                 }
3441
3442                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3443                 if (tr) {
3444                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3445                         track_playlist_changed (boost::weak_ptr<Track> (tr));
3446                         tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3447
3448                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3449                         if (mt) {
3450                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3451                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3452                                 mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3453                         }
3454                 }
3455
3456                 if (!r->presentation_info().special()) {
3457
3458                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3459
3460                         /* presentation info order may already have been set from XML */
3461
3462                         if (!r->presentation_info().order_set()) {
3463
3464                                 if (order == PresentationInfo::max_order) {
3465                                         /* just add to the end */
3466                                         r->set_presentation_order (n_routes + added, false);
3467                                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3468                                 } else {
3469                                         r->set_presentation_order (order + added);
3470                                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3471                                 }
3472                         } else {
3473                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3474                         }
3475                 }
3476
3477 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3478                 /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3479                  * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3480                  */
3481                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3482                                                                r->name(),
3483                                                                r->presentation_info().order(),
3484                                                                enum_2_string (r->presentation_info().flags()),
3485                                                                r->presentation_info()));
3486 #endif
3487
3488
3489                 if (input_auto_connect || output_auto_connect) {
3490                         auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3491                         existing_inputs += r->n_inputs();
3492                         existing_outputs += r->n_outputs();
3493                 }
3494
3495                 ARDOUR::GUIIdle ();
3496         }
3497
3498         if (_monitor_out && IO::connecting_legal) {
3499                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3500
3501                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3502                         if ((*x)->is_monitor()) {
3503                                 /* relax */
3504                         } else if ((*x)->is_master()) {
3505                                 /* relax */
3506                         } else {
3507                                 (*x)->enable_monitor_send ();
3508                         }
3509                 }
3510         }
3511
3512         reassign_track_numbers ();
3513 }
3514
3515 void
3516 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3517 {
3518         boost::shared_ptr<RouteList> r = routes.reader ();
3519         boost::shared_ptr<Send> s;
3520
3521         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3522                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3523                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3524                 }
3525         }
3526 }
3527
3528 void
3529 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3530 {
3531         boost::shared_ptr<RouteList> r = routes.reader ();
3532         boost::shared_ptr<Send> s;
3533
3534         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3535                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3536                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3537                 }
3538         }
3539 }
3540
3541 void
3542 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3543 {
3544         boost::shared_ptr<RouteList> r = routes.reader ();
3545         boost::shared_ptr<Send> s;
3546
3547         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3548                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3549                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3550                 }
3551         }
3552 }
3553
3554 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3555 void
3556 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3557 {
3558         boost::shared_ptr<RouteList> r = routes.reader ();
3559         boost::shared_ptr<RouteList> t (new RouteList);
3560
3561         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3562                 /* no MIDI sends because there are no MIDI busses yet */
3563                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3564                         t->push_back (*i);
3565                 }
3566         }
3567
3568         add_internal_sends (dest, p, t);
3569 }
3570
3571 void
3572 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3573 {
3574         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3575                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3576         }
3577 }
3578
3579 void
3580 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3581 {
3582         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3583 }
3584
3585 void
3586 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3587 {
3588         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3589                 return;
3590         }
3591
3592         if (!dest->internal_return()) {
3593                 dest->add_internal_return ();
3594         }
3595
3596         sender->add_aux_send (dest, before);
3597
3598         graph_reordered ();
3599 }
3600
3601 void
3602 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3603 {
3604         { // RCU Writer scope
3605                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3606                 RCUWriter<RouteList> writer (routes);
3607                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3608
3609
3610                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3611
3612                         if (*iter == _master_out) {
3613                                 continue;
3614                         }
3615
3616                         /* speed up session deletion, don't do the solo dance */
3617                         if (0 == _state_of_the_state & Deletion) {
3618                                 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3619                         }
3620
3621                         rs->remove (*iter);
3622
3623                         /* deleting the master out seems like a dumb
3624                            idea, but its more of a UI policy issue
3625                            than our concern.
3626                         */
3627
3628                         if (*iter == _master_out) {
3629                                 _master_out = boost::shared_ptr<Route> ();
3630                         }
3631
3632                         if (*iter == _monitor_out) {
3633                                 _monitor_out.reset ();
3634                         }
3635
3636                         // We need to disconnect the route's inputs and outputs
3637
3638                         (*iter)->input()->disconnect (0);
3639                         (*iter)->output()->disconnect (0);
3640
3641                         /* if the route had internal sends sending to it, remove them */
3642                         if ((*iter)->internal_return()) {
3643
3644                                 boost::shared_ptr<RouteList> r = routes.reader ();
3645                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3646                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3647                                         if (s) {
3648                                                 (*i)->remove_processor (s);
3649                                         }
3650                                 }
3651                         }
3652
3653                         /* if the monitoring section had a pointer to this route, remove it */
3654                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3655                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3656                                 ProcessorChangeBlocker pcb (this, false);
3657                                 (*iter)->remove_aux_or_listen (_monitor_out);
3658                         }
3659
3660                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3661                         if (mt && mt->step_editing()) {
3662                                 if (_step_editors > 0) {
3663                                         _step_editors--;
3664                                 }
3665                         }
3666                 }
3667
3668                 /* writer goes out of scope, forces route list update */
3669
3670         } // end of RCU Writer scope
3671
3672         update_route_solo_state ();
3673         update_latency_compensation ();
3674         set_dirty();
3675
3676         /* Re-sort routes to remove the graph's current references to the one that is
3677          * going away, then flush old references out of the graph.
3678          * Wave Tracks: reconnect routes
3679          */
3680
3681 #ifdef USE_TRACKS_CODE_FEATURES
3682                 reconnect_existing_routes(true, false);
3683 #else
3684                 routes.flush (); // maybe unsafe, see below.
3685                 resort_routes ();
3686 #endif
3687
3688         if (_process_graph && !(_state_of_the_state & Deletion)) {
3689                 _process_graph->clear_other_chain ();
3690         }
3691
3692         /* get rid of it from the dead wood collection in the route list manager */
3693         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3694
3695         routes.flush ();
3696
3697         /* try to cause everyone to drop their references
3698          * and unregister ports from the backend
3699          */
3700
3701         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3702                 cerr << "Drop references to " << (*iter)->name() << endl;
3703                 (*iter)->drop_references ();
3704         }
3705
3706         if (_state_of_the_state & Deletion) {
3707                 return;
3708         }
3709
3710         PresentationInfo::Change(); /* EMIT SIGNAL */
3711
3712         /* save the new state of the world */
3713
3714         if (save_state (_current_snapshot_name)) {
3715                 save_history (_current_snapshot_name);
3716         }
3717
3718         update_route_record_state ();
3719 }
3720
3721 void
3722 Session::remove_route (boost::shared_ptr<Route> route)
3723 {
3724         boost::shared_ptr<RouteList> rl (new RouteList);
3725         rl->push_back (route);
3726         remove_routes (rl);
3727 }
3728
3729 void
3730 Session::route_mute_changed ()
3731 {
3732         set_dirty ();
3733 }
3734
3735 void
3736 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3737 {
3738         boost::shared_ptr<Route> route (wpr.lock());
3739
3740         if (!route) {
3741                 return;
3742         }
3743
3744         assert (Config->get_solo_control_is_listen_control());
3745
3746         if (route->solo_control()->soloed_by_self_or_masters()) {
3747
3748                 if (Config->get_exclusive_solo()) {
3749
3750                         RouteGroup* rg = route->route_group ();
3751                         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3752
3753                         boost::shared_ptr<RouteList> r = routes.reader ();
3754
3755                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3756                                 if ((*i) == route) {
3757                                         /* already changed */
3758                                         continue;
3759                                 }
3760
3761                                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3762                                         /* route does not get solo propagated to it */
3763                                         continue;
3764                                 }
3765
3766                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3767                                         /* this route is a part of the same solo group as the route
3768                                          * that was changed. Changing that route did change or will
3769                                          * change all group members appropriately, so we can ignore it
3770                                          * here
3771                                          */
3772                                         continue;
3773                                 }
3774                                 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3775                         }
3776                 }
3777
3778                 _listen_cnt++;
3779
3780         } else if (_listen_cnt > 0) {
3781
3782                 _listen_cnt--;
3783         }
3784 }
3785
3786 void
3787 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3788 {
3789         boost::shared_ptr<Route> route (wpr.lock());
3790
3791         if (!route) {
3792                 return;
3793         }
3794
3795         bool send_changed = false;
3796
3797         if (route->solo_isolate_control()->solo_isolated()) {
3798                 if (_solo_isolated_cnt == 0) {
3799                         send_changed = true;
3800                 }
3801                 _solo_isolated_cnt++;
3802         } else if (_solo_isolated_cnt > 0) {
3803                 _solo_isolated_cnt--;
3804                 if (_solo_isolated_cnt == 0) {
3805                         send_changed = true;
3806                 }
3807         }
3808
3809         if (send_changed) {
3810                 IsolatedChanged (); /* EMIT SIGNAL */
3811         }
3812 }
3813
3814 void
3815 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
3816 {
3817         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
3818
3819         boost::shared_ptr<Route> route (wpr.lock());
3820
3821         if (!route) {
3822                 return;
3823         }
3824
3825         if (Config->get_solo_control_is_listen_control()) {
3826                 route_listen_changed (group_override, wpr);
3827                 return;
3828         }
3829
3830         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: self %2 masters %3 transition %4\n", route->name(), route->self_soloed(), route->solo_control()->get_masters_value(), route->solo_control()->transitioned_into_solo()));
3831
3832         if (route->solo_control()->transitioned_into_solo() == 0) {
3833                 /* route solo changed by upstream/downstream or clear all solo state; not interesting
3834                    to Session.
3835                 */
3836                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 not self-soloed nor soloed by master (%2), ignoring\n", route->name(), route->solo_control()->get_masters_value()));
3837                 return;
3838         }
3839
3840         boost::shared_ptr<RouteList> r = routes.reader ();
3841         int32_t delta = route->solo_control()->transitioned_into_solo ();
3842
3843         /* the route may be a member of a group that has shared-solo
3844          * semantics. If so, then all members of that group should follow the
3845          * solo of the changed route. But ... this is optional, controlled by a
3846          * Controllable::GroupControlDisposition.
3847          *
3848          * The first argument to the signal that this method is connected to is the
3849          * GroupControlDisposition value that was used to change solo.
3850          *
3851          * If the solo change was done with group semantics (either InverseGroup
3852          * (force the entire group to change even if the group shared solo is
3853          * disabled) or UseGroup (use the group, which may or may not have the
3854          * shared solo property enabled)) then as we propagate the change to
3855          * the entire session we should IGNORE THE GROUP that the changed route
3856          * belongs to.
3857          */
3858
3859         RouteGroup* rg = route->route_group ();
3860         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3861
3862         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
3863
3864         if (delta == 1 && Config->get_exclusive_solo()) {
3865
3866                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3867
3868                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3869
3870                         if ((*i) == route) {
3871                                 /* already changed */
3872                                 continue;
3873                         }
3874
3875                         if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3876                                 /* route does not get solo propagated to it */
3877                                 continue;
3878                         }
3879
3880                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3881                                 /* this route is a part of the same solo group as the route
3882                                  * that was changed. Changing that route did change or will
3883                                  * change all group members appropriately, so we can ignore it
3884                                  * here
3885                                  */
3886                                 continue;
3887                         }
3888
3889                         (*i)->solo_control()->set_value (0.0, group_override);
3890                 }
3891         }
3892
3893         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3894
3895         RouteList uninvolved;
3896
3897         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3898
3899         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3900                 bool via_sends_only;
3901                 bool in_signal_flow;
3902
3903                 if ((*i) == route) {
3904                         /* already changed */
3905                         continue;
3906                 }
3907
3908                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3909                         /* route does not get solo propagated to it */
3910                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 excluded from solo because iso = %2 can_solo = %3\n", (*i)->name(), (*i)->solo_isolate_control()->solo_isolated(),
3911                                                                   (*i)->can_solo()));
3912                         continue;
3913                 }
3914
3915                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3916                         /* this route is a part of the same solo group as the route
3917                          * that was changed. Changing that route did change or will
3918                          * change all group members appropriately, so we can ignore it
3919                          * here
3920                          */
3921                         continue;
3922                 }
3923
3924                 in_signal_flow = false;
3925
3926                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3927
3928                 if ((*i)->feeds (route, &via_sends_only)) {
3929                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3930                         if (!via_sends_only) {
3931                                 if (!route->soloed_by_others_upstream()) {
3932                                         (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3933                                 } else {
3934                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
3935                                 }
3936                         } else {
3937                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3938                         }
3939                         in_signal_flow = true;
3940                 } else {
3941                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3942                 }
3943
3944                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3945
3946                 if (route->feeds (*i, &via_sends_only)) {
3947                         /* propagate solo upstream only if routing other than
3948                            sends is involved, but do consider the other route
3949                            (*i) to be part of the signal flow even if only
3950                            sends are involved.
3951                         */
3952                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3953                                                                   route->name(),
3954                                                                   (*i)->name(),
3955                                                                   via_sends_only,
3956                                                                   route->soloed_by_others_downstream(),
3957                                                                   route->soloed_by_others_upstream()));
3958                         if (!via_sends_only) {
3959                                 //NB. Triggers Invert Push, which handles soloed by downstream
3960                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3961                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3962                         } else {
3963                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3964                         }
3965                         in_signal_flow = true;
3966                 } else {
3967                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3968                 }
3969
3970                 if (!in_signal_flow) {
3971                         uninvolved.push_back (*i);
3972                 }
3973         }
3974
3975         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3976
3977         /* now notify that the mute state of the routes not involved in the signal
3978            pathway of the just-solo-changed route may have altered.
3979         */
3980
3981         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3982                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3983                 (*i)->act_on_mute ();
3984                 /* Session will emit SoloChanged() after all solo changes are
3985                  * complete, which should be used by UIs to update mute status
3986                  */
3987         }
3988 }
3989
3990 void
3991 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3992 {
3993         /* now figure out if anything that matters is soloed (or is "listening")*/
3994
3995         bool something_soloed = false;
3996         bool something_listening = false;
3997         uint32_t listeners = 0;
3998         uint32_t isolated = 0;
3999
4000         if (!r) {
4001                 r = routes.reader();
4002         }
4003
4004         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4005                 if ((*i)->can_solo()) {
4006                         if (Config->get_solo_control_is_listen_control()) {
4007                                 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4008                                         listeners++;
4009                                         something_listening = true;
4010                                 }
4011                         } else {
4012                                 (*i)->set_listen (false);
4013                                 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4014                                         something_soloed = true;
4015                                 }
4016                         }
4017                 }
4018
4019                 if ((*i)->solo_isolate_control()->solo_isolated()) {
4020                         isolated++;
4021                 }
4022         }
4023
4024         if (something_soloed != _non_soloed_outs_muted) {
4025                 _non_soloed_outs_muted = something_soloed;
4026                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4027         }
4028
4029         if (something_listening != _listening) {
4030                 _listening = something_listening;
4031                 SoloActive (_listening);
4032         }
4033
4034         _listen_cnt = listeners;
4035
4036         if (isolated != _solo_isolated_cnt) {
4037                 _solo_isolated_cnt = isolated;
4038                 IsolatedChanged (); /* EMIT SIGNAL */
4039         }
4040
4041         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4042                                                   something_soloed, listeners, isolated));
4043
4044
4045         SoloChanged (); /* EMIT SIGNAL */
4046         set_dirty();
4047 }
4048
4049 void
4050 Session::get_stripables (StripableList& sl) const
4051 {
4052         boost::shared_ptr<RouteList> r = routes.reader ();
4053         sl.insert (sl.end(), r->begin(), r->end());
4054
4055         VCAList v = _vca_manager->vcas ();
4056         sl.insert (sl.end(), v.begin(), v.end());
4057 }
4058
4059 boost::shared_ptr<RouteList>
4060 Session::get_routes_with_internal_returns() const
4061 {
4062         boost::shared_ptr<RouteList> r = routes.reader ();
4063         boost::shared_ptr<RouteList> rl (new RouteList);
4064
4065         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4066                 if ((*i)->internal_return ()) {
4067                         rl->push_back (*i);
4068                 }
4069         }
4070         return rl;
4071 }
4072
4073 bool
4074 Session::io_name_is_legal (const std::string& name) const
4075 {
4076         boost::shared_ptr<RouteList> r = routes.reader ();
4077
4078         for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4079                 if (name == *reserved) {
4080                         if (!route_by_name (*reserved)) {
4081                                 /* first instance of a reserved name is allowed */
4082                                 return true;
4083                         }
4084                         /* all other instances of a reserved name are not allowed */
4085                         return false;
4086                 }
4087         }
4088
4089         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4090                 if ((*i)->name() == name) {
4091                         return false;
4092                 }
4093
4094                 if ((*i)->has_io_processor_named (name)) {
4095                         return false;
4096                 }
4097         }
4098
4099         return true;
4100 }
4101
4102 void
4103 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4104 {
4105         RouteList rl2;
4106         vector<string> connections;
4107
4108         /* if we are passed only a single route and we're not told to turn
4109          * others off, then just do the simple thing.
4110          */
4111
4112         if (flip_others == false && rl->size() == 1) {
4113                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4114                 if (mt) {
4115                         mt->set_input_active (onoff);
4116                         return;
4117                 }
4118         }
4119
4120         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4121
4122                 PortSet& ps ((*rt)->input()->ports());
4123
4124                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4125                         p->get_connections (connections);
4126                 }
4127
4128                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4129                         routes_using_input_from (*s, rl2);
4130                 }
4131
4132                 /* scan all relevant routes to see if others are on or off */
4133
4134                 bool others_are_already_on = false;
4135
4136                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4137
4138                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4139
4140                         if (!mt) {
4141                                 continue;
4142                         }
4143
4144                         if ((*r) != (*rt)) {
4145                                 if (mt->input_active()) {
4146                                         others_are_already_on = true;
4147                                 }
4148                         } else {
4149                                 /* this one needs changing */
4150                                 mt->set_input_active (onoff);
4151                         }
4152                 }
4153
4154                 if (flip_others) {
4155
4156                         /* globally reverse other routes */
4157
4158                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4159                                 if ((*r) != (*rt)) {
4160                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4161                                         if (mt) {
4162                                                 mt->set_input_active (!others_are_already_on);
4163                                         }
4164                                 }
4165                         }
4166                 }
4167         }
4168 }
4169
4170 void
4171 Session::routes_using_input_from (const string& str, RouteList& rl)
4172 {
4173         boost::shared_ptr<RouteList> r = routes.reader();
4174
4175         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4176                 if ((*i)->input()->connected_to (str)) {
4177                         rl.push_back (*i);
4178                 }
4179         }
4180 }
4181
4182 boost::shared_ptr<Route>
4183 Session::route_by_name (string name) const
4184 {
4185         boost::shared_ptr<RouteList> r = routes.reader ();
4186
4187         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4188                 if ((*i)->name() == name) {
4189                         return *i;
4190                 }
4191         }
4192
4193         return boost::shared_ptr<Route> ((Route*) 0);
4194 }
4195
4196 boost::shared_ptr<Route>
4197 Session::route_by_id (PBD::ID id) const
4198 {
4199         boost::shared_ptr<RouteList> r = routes.reader ();
4200
4201         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4202                 if ((*i)->id() == id) {
4203                         return *i;
4204                 }
4205         }
4206
4207         return boost::shared_ptr<Route> ((Route*) 0);
4208 }
4209
4210 boost::shared_ptr<Processor>
4211 Session::processor_by_id (PBD::ID id) const
4212 {
4213         boost::shared_ptr<RouteList> r = routes.reader ();
4214
4215         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4216                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4217                 if (p) {
4218                         return p;
4219                 }
4220         }
4221
4222         return boost::shared_ptr<Processor> ();
4223 }
4224
4225 boost::shared_ptr<Track>
4226 Session::track_by_diskstream_id (PBD::ID id) const
4227 {
4228         boost::shared_ptr<RouteList> r = routes.reader ();
4229
4230         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4231                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4232                 if (t && t->using_diskstream_id (id)) {
4233                         return t;
4234                 }
4235         }
4236
4237         return boost::shared_ptr<Track> ();
4238 }
4239
4240 boost::shared_ptr<Route>
4241 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4242 {
4243         return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4244 }
4245
4246 boost::shared_ptr<Stripable>
4247 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4248 {
4249         StripableList sl;
4250         PresentationInfo::order_t match_cnt = 0;
4251
4252         get_stripables (sl);
4253         sl.sort (Stripable::PresentationOrderSorter());
4254
4255         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4256
4257                 if ((*s)->presentation_info().hidden()) {
4258                         /* if the caller didn't explicitly ask for hidden
4259                            stripables, ignore hidden ones. This matches
4260                            the semantics of the pre-PresentationOrder
4261                            "get by RID" logic of Ardour 4.x and earlier.
4262
4263                            XXX at some point we should likely reverse
4264                            the logic of the flags, because asking for "the
4265                            hidden stripables" is not going to be common,
4266                            whereas asking for visible ones is normal.
4267                         */
4268
4269                         if (! (flags & PresentationInfo::Hidden)) {
4270                                 continue;
4271                         }
4272                 }
4273
4274                 if ((*s)->presentation_info().flag_match (flags)) {
4275                         if (match_cnt++ == n) {
4276                                 return *s;
4277                         }
4278                 }
4279         }
4280
4281         /* there is no nth stripable that matches the given flags */
4282         return boost::shared_ptr<Stripable>();
4283 }
4284
4285 boost::shared_ptr<Route>
4286 Session::route_by_selected_count (uint32_t id) const
4287 {
4288         boost::shared_ptr<RouteList> r = routes.reader ();
4289
4290         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4291                 /* NOT IMPLEMENTED */
4292         }
4293
4294         return boost::shared_ptr<Route> ((Route*) 0);
4295 }
4296
4297 struct PresentationOrderSorter {
4298         bool operator() (boost::shared_ptr<Stripable> a, boost::shared_ptr<Stripable> b) {
4299                 if (a->presentation_info().special() && !b->presentation_info().special()) {
4300                         /* a is not ordered, b is; b comes before a */
4301                         return false;
4302                 } else if (!b->presentation_info().order_set() && a->presentation_info().order_set()) {
4303                         /* b is not ordered, a is; a comes before b */
4304                         return true;
4305                 } else {
4306                         return a->presentation_info().order() < b->presentation_info().order();
4307                 }
4308         }
4309 };
4310
4311 void
4312 Session::reassign_track_numbers ()
4313 {
4314         int64_t tn = 0;
4315         int64_t bn = 0;
4316         RouteList r (*(routes.reader ()));
4317         PresentationOrderSorter sorter;
4318         r.sort (sorter);
4319
4320         StateProtector sp (this);
4321
4322         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4323                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4324                         (*i)->set_track_number(++tn);
4325                 }
4326                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4327                         (*i)->set_track_number(--bn);
4328                 }
4329         }
4330         const uint32_t decimals = ceilf (log10f (tn + 1));
4331         const bool decimals_changed = _track_number_decimals != decimals;
4332         _track_number_decimals = decimals;
4333
4334         if (decimals_changed && config.get_track_name_number ()) {
4335                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4336                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4337                         if (t) {
4338                                 t->resync_track_name();
4339                         }
4340                 }
4341                 // trigger GUI re-layout
4342                 config.ParameterChanged("track-name-number");
4343         }
4344
4345 #ifndef NDEBUG
4346         if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4347                 boost::shared_ptr<RouteList> rl = routes.reader ();
4348                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4349                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4350                 }
4351         }
4352 #endif /* NDEBUG */
4353
4354 }
4355
4356 void
4357 Session::playlist_region_added (boost::weak_ptr<Region> w)
4358 {
4359         boost::shared_ptr<Region> r = w.lock ();
4360         if (!r) {
4361                 return;
4362         }
4363
4364         /* These are the operations that are currently in progress... */
4365         list<GQuark> curr = _current_trans_quarks;
4366         curr.sort ();
4367
4368         /* ...and these are the operations during which we want to update
4369            the session range location markers.
4370         */
4371         list<GQuark> ops;
4372         ops.push_back (Operations::capture);
4373         ops.push_back (Operations::paste);
4374         ops.push_back (Operations::duplicate_region);
4375         ops.push_back (Operations::insert_file);
4376         ops.push_back (Operations::insert_region);
4377         ops.push_back (Operations::drag_region_brush);
4378         ops.push_back (Operations::region_drag);
4379         ops.push_back (Operations::selection_grab);
4380         ops.push_back (Operations::region_fill);
4381         ops.push_back (Operations::fill_selection);
4382         ops.push_back (Operations::create_region);
4383         ops.push_back (Operations::region_copy);
4384         ops.push_back (Operations::fixed_time_region_copy);
4385         ops.sort ();
4386
4387         /* See if any of the current operations match the ones that we want */
4388         list<GQuark> in;
4389         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4390
4391         /* If so, update the session range markers */
4392         if (!in.empty ()) {
4393                 maybe_update_session_range (r->position (), r->last_frame ());
4394         }
4395 }
4396
4397 /** Update the session range markers if a is before the current start or
4398  *  b is after the current end.
4399  */
4400 void
4401 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4402 {
4403         if (_state_of_the_state & Loading) {
4404                 return;
4405         }
4406
4407         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4408
4409         if (_session_range_location == 0) {
4410
4411                 set_session_range_location (a, b + session_end_marker_shift_samples);
4412
4413         } else {
4414
4415                 if (a < _session_range_location->start()) {
4416                         _session_range_location->set_start (a);
4417                 }
4418
4419                 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4420                         _session_range_location->set_end (b);
4421                 }
4422         }
4423 }
4424
4425 void
4426 Session::set_end_is_free (bool yn)
4427 {
4428         _session_range_end_is_free = yn;
4429 }
4430
4431 void
4432 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4433 {
4434         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4435                 maybe_update_session_range (i->to, i->to + i->length);
4436         }
4437 }
4438
4439 void
4440 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4441 {
4442         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4443                 maybe_update_session_range (i->from, i->to);
4444         }
4445 }
4446
4447 /* Region management */
4448
4449 boost::shared_ptr<Region>
4450 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4451 {
4452         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4453         RegionFactory::RegionMap::const_iterator i;
4454         boost::shared_ptr<Region> region;
4455
4456         Glib::Threads::Mutex::Lock lm (region_lock);
4457
4458         for (i = regions.begin(); i != regions.end(); ++i) {
4459
4460                 region = i->second;
4461
4462                 if (region->whole_file()) {
4463
4464                         if (child->source_equivalent (region)) {
4465                                 return region;
4466                         }
4467                 }
4468         }
4469
4470         return boost::shared_ptr<Region> ();
4471 }
4472
4473 int
4474 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4475 {
4476         set<boost::shared_ptr<Region> > relevant_regions;
4477
4478         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4479                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4480         }
4481
4482         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4483                 set<boost::shared_ptr<Region> >::iterator tmp;
4484
4485                 tmp = r;
4486                 ++tmp;
4487
4488                 playlists->destroy_region (*r);
4489                 RegionFactory::map_remove (*r);
4490
4491                 (*r)->drop_sources ();
4492                 (*r)->drop_references ();
4493
4494                 relevant_regions.erase (r);
4495
4496                 r = tmp;
4497         }
4498
4499         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4500
4501                 {
4502                         Glib::Threads::Mutex::Lock ls (source_lock);
4503                         /* remove from the main source list */
4504                         sources.erase ((*s)->id());
4505                 }
4506
4507                 (*s)->mark_for_remove ();
4508                 (*s)->drop_references ();
4509
4510                 s = srcs.erase (s);
4511         }
4512
4513         return 0;
4514 }
4515
4516 int
4517 Session::remove_last_capture ()
4518 {
4519         list<boost::shared_ptr<Source> > srcs;
4520
4521         boost::shared_ptr<RouteList> rl = routes.reader ();
4522         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4523                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4524                 if (!tr) {
4525                         continue;
4526                 }
4527
4528                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4529
4530                 if (!l.empty()) {
4531                         srcs.insert (srcs.end(), l.begin(), l.end());
4532                         l.clear ();
4533                 }
4534         }
4535
4536         destroy_sources (srcs);
4537
4538         save_state (_current_snapshot_name);
4539
4540         return 0;
4541 }
4542
4543 /* Source Management */
4544
4545 void
4546 Session::add_source (boost::shared_ptr<Source> source)
4547 {
4548         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4549         pair<SourceMap::iterator,bool> result;
4550
4551         entry.first = source->id();
4552         entry.second = source;
4553
4554         {
4555                 Glib::Threads::Mutex::Lock lm (source_lock);
4556                 result = sources.insert (entry);
4557         }
4558
4559         if (result.second) {
4560
4561                 /* yay, new source */
4562
4563                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4564
4565                 if (fs) {
4566                         if (!fs->within_session()) {
4567                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4568                         }
4569                 }
4570
4571                 set_dirty();
4572
4573                 boost::shared_ptr<AudioFileSource> afs;
4574
4575                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4576                         if (Config->get_auto_analyse_audio()) {
4577                                 Analyser::queue_source_for_analysis (source, false);
4578                         }
4579                 }
4580
4581                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4582         }
4583 }
4584
4585 void
4586 Session::remove_source (boost::weak_ptr<Source> src)
4587 {
4588         if (_state_of_the_state & Deletion) {
4589                 return;
4590         }
4591
4592         SourceMap::iterator i;
4593         boost::shared_ptr<Source> source = src.lock();
4594
4595         if (!source) {
4596                 return;
4597         }
4598
4599         {
4600                 Glib::Threads::Mutex::Lock lm (source_lock);
4601
4602                 if ((i = sources.find (source->id())) != sources.end()) {
4603                         sources.erase (i);
4604                 }
4605         }
4606
4607         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4608
4609                 /* save state so we don't end up with a session file
4610                    referring to non-existent sources.
4611                 */
4612
4613                 save_state (_current_snapshot_name);
4614         }
4615 }
4616
4617 boost::shared_ptr<Source>
4618 Session::source_by_id (const PBD::ID& id)
4619 {
4620         Glib::Threads::Mutex::Lock lm (source_lock);
4621         SourceMap::iterator i;
4622         boost::shared_ptr<Source> source;
4623
4624         if ((i = sources.find (id)) != sources.end()) {
4625                 source = i->second;
4626         }
4627
4628         return source;
4629 }
4630
4631 boost::shared_ptr<AudioFileSource>
4632 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4633 {
4634         /* Restricted to audio files because only audio sources have channel
4635            as a property.
4636         */
4637
4638         Glib::Threads::Mutex::Lock lm (source_lock);
4639
4640         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4641                 boost::shared_ptr<AudioFileSource> afs
4642                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4643
4644                 if (afs && afs->path() == path && chn == afs->channel()) {
4645                         return afs;
4646                 }
4647         }
4648
4649         return boost::shared_ptr<AudioFileSource>();
4650 }
4651
4652 boost::shared_ptr<MidiSource>
4653 Session::midi_source_by_path (const std::string& path) const
4654 {
4655         /* Restricted to MIDI files because audio sources require a channel
4656            for unique identification, in addition to a path.
4657         */
4658
4659         Glib::Threads::Mutex::Lock lm (source_lock);
4660
4661         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4662                 boost::shared_ptr<MidiSource> ms
4663                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4664                 boost::shared_ptr<FileSource> fs
4665                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4666
4667                 if (ms && fs && fs->path() == path) {
4668                         return ms;
4669                 }
4670         }
4671
4672         return boost::shared_ptr<MidiSource>();
4673 }
4674
4675 uint32_t
4676 Session::count_sources_by_origin (const string& path)
4677 {
4678         uint32_t cnt = 0;
4679         Glib::Threads::Mutex::Lock lm (source_lock);
4680
4681         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4682                 boost::shared_ptr<FileSource> fs
4683                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4684
4685                 if (fs && fs->origin() == path) {
4686                         ++cnt;
4687                 }
4688         }
4689
4690         return cnt;
4691 }
4692
4693 static string
4694 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4695         if (hash) {
4696                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4697                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4698         } else {
4699                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4700         }
4701 }
4702
4703 string
4704 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4705 {
4706         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4707
4708         if (Glib::path_is_absolute (filepath)) {
4709
4710                 /* rip the session dir from the audiofile source */
4711
4712                 string session_path;
4713                 bool in_another_session = true;
4714
4715                 if (filepath.find (interchange_dir_string) != string::npos) {
4716
4717                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4718                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4719                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4720                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4721
4722                         /* see if it is within our session */
4723
4724                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4725                                 if (i->path == session_path) {
4726                                         in_another_session = false;
4727                                         break;
4728                                 }
4729                         }
4730                 } else {
4731                         in_another_session = false;
4732                 }
4733
4734
4735                 if (in_another_session) {
4736                         SessionDirectory sd (session_path);
4737                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4738                 }
4739         }
4740
4741         /* 1) if file belongs to this session
4742          * it may be a relative path (interchange/...)
4743          * or just basename (session_state, remove source)
4744          * -> just use the basename
4745          */
4746         std::string filename = Glib::path_get_basename (filepath);
4747         std::string path;
4748
4749         /* 2) if the file is outside our session dir:
4750          * (imported but not copied) add the path for check-summming */
4751         if (!in_session) {
4752                 path = Glib::path_get_dirname (filepath);
4753         }
4754
4755         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4756 }
4757
4758 string
4759 Session::new_audio_source_path_for_embedded (const std::string& path)
4760 {
4761         /* embedded source:
4762          *
4763          * we know that the filename is already unique because it exists
4764          * out in the filesystem.
4765          *
4766          * However, when we bring it into the session, we could get a
4767          * collision.
4768          *
4769          * Eg. two embedded files:
4770          *
4771          *          /foo/bar/baz.wav
4772          *          /frob/nic/baz.wav
4773          *
4774          * When merged into session, these collide.
4775          *
4776          * There will not be a conflict with in-memory sources
4777          * because when the source was created we already picked
4778          * a unique name for it.
4779          *
4780          * This collision is not likely to be common, but we have to guard
4781          * against it.  So, if there is a collision, take the md5 hash of the
4782          * the path, and use that as the filename instead.
4783          */
4784
4785         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4786         string base = Glib::path_get_basename (path);
4787         string newpath = Glib::build_filename (sdir.sound_path(), base);
4788
4789         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4790
4791                 MD5 md5;
4792
4793                 md5.digestString (path.c_str());
4794                 md5.writeToString ();
4795                 base = md5.digestChars;
4796
4797                 string ext = get_suffix (path);
4798
4799                 if (!ext.empty()) {
4800                         base += '.';
4801                         base += ext;
4802                 }
4803
4804                 newpath = Glib::build_filename (sdir.sound_path(), base);
4805
4806                 /* if this collides, we're screwed */
4807
4808                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4809                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4810                         return string();
4811                 }
4812
4813         }
4814
4815         return newpath;
4816 }
4817
4818 /** Return true if there are no audio file sources that use @param name as
4819  * the filename component of their path.
4820  *
4821  * Return false otherwise.
4822  *
4823  * This method MUST ONLY be used to check in-session, mono files since it
4824  * hard-codes the channel of the audio file source we are looking for as zero.
4825  *
4826  * If/when Ardour supports native files in non-mono formats, the logic here
4827  * will need to be revisited.
4828  */
4829 bool
4830 Session::audio_source_name_is_unique (const string& name)
4831 {
4832         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4833         vector<space_and_path>::iterator i;
4834         uint32_t existing = 0;
4835
4836         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4837
4838                 /* note that we search *without* the extension so that
4839                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4840                    in the event that this new name is required for
4841                    a file format change.
4842                 */
4843
4844                 const string spath = *i;
4845
4846                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4847                         existing++;
4848                         break;
4849                 }
4850
4851                 /* it is possible that we have the path already
4852                  * assigned to a source that has not yet been written
4853                  * (ie. the write source for a diskstream). we have to
4854                  * check this in order to make sure that our candidate
4855                  * path isn't used again, because that can lead to
4856                  * two Sources point to the same file with different
4857                  * notions of their removability.
4858                  */
4859
4860
4861                 string possible_path = Glib::build_filename (spath, name);
4862
4863                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4864                         existing++;
4865                         break;
4866                 }
4867         }
4868
4869         return (existing == 0);
4870 }
4871
4872 string
4873 Session::format_audio_source_name (const string& legalized_base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required, uint32_t cnt, bool related_exists)
4874 {
4875         ostringstream sstr;
4876         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4877
4878         if (Profile->get_trx() && destructive) {
4879                 sstr << 'T';
4880                 sstr << setfill ('0') << setw (4) << cnt;
4881                 sstr << legalized_base;
4882         } else {
4883                 sstr << legalized_base;
4884
4885                 if (take_required || related_exists) {
4886                         sstr << '-';
4887                         sstr << cnt;
4888                 }
4889         }
4890
4891         if (nchan == 2) {
4892                 if (chan == 0) {
4893                         sstr << "%L";
4894                 } else {
4895                         sstr << "%R";
4896                 }
4897         } else if (nchan > 2) {
4898                 if (nchan < 26) {
4899                         sstr << '%';
4900                         sstr << 'a' + chan;
4901                 } else {
4902                         /* XXX what? more than 26 channels! */
4903                         sstr << '%';
4904                         sstr << chan+1;
4905                 }
4906         }
4907
4908         sstr << ext;
4909
4910         return sstr.str();
4911 }
4912
4913 /** Return a unique name based on \a base for a new internal audio source */
4914 string
4915 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4916 {
4917         uint32_t cnt;
4918         string possible_name;
4919         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4920         string legalized;
4921         bool some_related_source_name_exists = false;
4922
4923         legalized = legalize_for_path (base);
4924
4925         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4926
4927         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4928
4929                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4930
4931                 if (audio_source_name_is_unique (possible_name)) {
4932                         break;
4933                 }
4934
4935                 some_related_source_name_exists = true;
4936
4937                 if (cnt > limit) {
4938                         error << string_compose(
4939                                         _("There are already %1 recordings for %2, which I consider too many."),
4940                                         limit, base) << endmsg;
4941                         destroy ();
4942                         throw failed_constructor();
4943                 }
4944         }
4945
4946         /* We've established that the new name does not exist in any session
4947          * directory, so now find out which one we should use for this new
4948          * audio source.
4949          */
4950
4951         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4952
4953         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4954
4955         return s;
4956 }
4957
4958 /** Return a unique name based on `base` for a new internal MIDI source */
4959 string
4960 Session::new_midi_source_path (const string& base)
4961 {
4962         uint32_t cnt;
4963         char buf[PATH_MAX+1];
4964         const uint32_t limit = 10000;
4965         string legalized;
4966         string possible_path;
4967         string possible_name;
4968
4969         buf[0] = '\0';
4970         legalized = legalize_for_path (base);
4971
4972         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4973         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4974
4975         /* - the main session folder is the first in the vector.
4976          * - after checking all locations for file-name uniqueness,
4977          *   we keep the one from the last iteration as new file name
4978          * - midi files are small and should just be kept in the main session-folder
4979          *
4980          * -> reverse the array, check main session folder last and use that as location
4981          *    for MIDI files.
4982          */
4983         std::reverse(sdirs.begin(), sdirs.end());
4984
4985         for (cnt = 1; cnt <= limit; ++cnt) {
4986
4987                 vector<space_and_path>::iterator i;
4988                 uint32_t existing = 0;
4989
4990                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4991
4992                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4993                         possible_name = buf;
4994
4995                         possible_path = Glib::build_filename (*i, possible_name);
4996
4997                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4998                                 existing++;
4999                         }
5000
5001                         if (midi_source_by_path (possible_path)) {
5002                                 existing++;
5003                         }
5004                 }
5005
5006                 if (existing == 0) {
5007                         break;
5008                 }
5009
5010                 if (cnt > limit) {
5011                         error << string_compose(
5012                                         _("There are already %1 recordings for %2, which I consider too many."),
5013                                         limit, base) << endmsg;
5014                         destroy ();
5015                         return 0;
5016                 }
5017         }
5018
5019         /* No need to "find best location" for software/app-based RAID, because
5020            MIDI is so small that we always put it in the same place.
5021         */
5022
5023         return possible_path;
5024 }
5025
5026
5027 /** Create a new within-session audio source */
5028 boost::shared_ptr<AudioFileSource>
5029 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5030 {
5031         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5032
5033         if (!path.empty()) {
5034                 return boost::dynamic_pointer_cast<AudioFileSource> (
5035                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
5036         } else {
5037                 throw failed_constructor ();
5038         }
5039 }
5040
5041 /** Create a new within-session MIDI source */
5042 boost::shared_ptr<MidiSource>
5043 Session::create_midi_source_for_session (string const & basic_name)
5044 {
5045         const string path = new_midi_source_path (basic_name);
5046
5047         if (!path.empty()) {
5048                 return boost::dynamic_pointer_cast<SMFSource> (
5049                         SourceFactory::createWritable (
5050                                 DataType::MIDI, *this, path, false, frame_rate()));
5051         } else {
5052                 throw failed_constructor ();
5053         }
5054 }
5055
5056 /** Create a new within-session MIDI source */
5057 boost::shared_ptr<MidiSource>
5058 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5059 {
5060         /* the caller passes in the track the source will be used in,
5061            so that we can keep the numbering sane.
5062
5063            Rationale: a track with the name "Foo" that has had N
5064            captures carried out so far will ALREADY have a write source
5065            named "Foo-N+1.mid" waiting to be used for the next capture.
5066
5067            If we call new_midi_source_name() we will get "Foo-N+2". But
5068            there is no region corresponding to "Foo-N+1", so when
5069            "Foo-N+2" appears in the track, the gap presents the user
5070            with odd behaviour - why did it skip past Foo-N+1?
5071
5072            We could explain this to the user in some odd way, but
5073            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5074            use "Foo-N+1" here.
5075
5076            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5077         */
5078
5079         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5080         assert (mt);
5081         std::string name = track->steal_write_source_name ();
5082
5083         if (name.empty()) {
5084                 return boost::shared_ptr<MidiSource>();
5085         }
5086
5087         /* MIDI files are small, just put them in the first location of the
5088            session source search path.
5089         */
5090
5091         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5092
5093         return boost::dynamic_pointer_cast<SMFSource> (
5094                 SourceFactory::createWritable (
5095                         DataType::MIDI, *this, path, false, frame_rate()));
5096 }
5097
5098
5099 void
5100 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5101 {
5102         if (playlist->hidden()) {
5103                 return;
5104         }
5105
5106         playlists->add (playlist);
5107
5108         if (unused) {
5109                 playlist->release();
5110         }
5111
5112         set_dirty();
5113 }
5114
5115 void
5116 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5117 {
5118         if (_state_of_the_state & Deletion) {
5119                 return;
5120         }
5121
5122         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5123
5124         if (!playlist) {
5125                 return;
5126         }
5127
5128         playlists->remove (playlist);
5129
5130         set_dirty();
5131 }
5132
5133 void
5134 Session::set_audition (boost::shared_ptr<Region> r)
5135 {
5136         pending_audition_region = r;
5137         add_post_transport_work (PostTransportAudition);
5138         _butler->schedule_transport_work ();
5139 }
5140
5141 void
5142 Session::audition_playlist ()
5143 {
5144         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5145         ev->region.reset ();
5146         queue_event (ev);
5147 }
5148
5149
5150 void
5151 Session::register_lua_function (
5152                 const std::string& name,
5153                 const std::string& script,
5154                 const LuaScriptParamList& args
5155                 )
5156 {
5157         Glib::Threads::Mutex::Lock lm (lua_lock);
5158
5159         lua_State* L = lua.getState();
5160
5161         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5162         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5163         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5164                 if ((*i)->optional && !(*i)->is_set) { continue; }
5165                 tbl_arg[(*i)->name] = (*i)->value;
5166         }
5167         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5168         set_dirty();
5169 }
5170
5171 void
5172 Session::unregister_lua_function (const std::string& name)
5173 {
5174         Glib::Threads::Mutex::Lock lm (lua_lock);
5175         (*_lua_del)(name); // throws luabridge::LuaException
5176         lua.collect_garbage ();
5177         set_dirty();
5178 }
5179
5180 std::vector<std::string>
5181 Session::registered_lua_functions ()
5182 {
5183         Glib::Threads::Mutex::Lock lm (lua_lock);
5184         std::vector<std::string> rv;
5185
5186         try {
5187                 luabridge::LuaRef list ((*_lua_list)());
5188                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5189                         if (!i.key ().isString ()) { assert(0); continue; }
5190                         rv.push_back (i.key ().cast<std::string> ());
5191                 }
5192         } catch (luabridge::LuaException const& e) { }
5193         return rv;
5194 }
5195
5196 #ifndef NDEBUG
5197 static void _lua_print (std::string s) {
5198         std::cout << "SessionLua: " << s << "\n";
5199 }
5200 #endif
5201
5202 void
5203 Session::try_run_lua (pframes_t nframes)
5204 {
5205         if (_n_lua_scripts == 0) return;
5206         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5207         if (tm.locked ()) {
5208                 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5209                 lua.collect_garbage_step ();
5210         }
5211 }
5212
5213 void
5214 Session::setup_lua ()
5215 {
5216 #ifndef NDEBUG
5217         lua.Print.connect (&_lua_print);
5218 #endif
5219         lua.tweak_rt_gc ();
5220         lua.do_command (
5221                         "function ArdourSession ()"
5222                         "  local self = { scripts = {}, instances = {} }"
5223                         ""
5224                         "  local remove = function (n)"
5225                         "   self.scripts[n] = nil"
5226                         "   self.instances[n] = nil"
5227                         "   Session:scripts_changed()" // call back
5228                         "  end"
5229                         ""
5230                         "  local addinternal = function (n, f, a)"
5231                         "   assert(type(n) == 'string', 'function-name must be string')"
5232                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5233                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5234                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5235                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5236                         "   local env = _ENV;  env.f = nil env.io = nil env.os = nil env.loadfile = nil env.require = nil env.dofile = nil env.package = nil env.debug = nil"
5237                         "   local env = { print = print, tostring = tostring, assert = assert, ipairs = ipairs, error = error, select = select, string = string, type = type, tonumber = tonumber, collectgarbage = collectgarbage, pairs = pairs, math = math, table = table, pcall = pcall, Session = Session, PBD = PBD, Timecode = Timecode, Evoral = Evoral, C = C, ARDOUR = ARDOUR }"
5238                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5239                         "   Session:scripts_changed()" // call back
5240                         "  end"
5241                         ""
5242                         "  local add = function (n, b, a)"
5243                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5244                         "   load (b)()" // assigns f
5245                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5246                         "   addinternal (n, load(f), a)"
5247                         "  end"
5248                         ""
5249                         "  local run = function (...)"
5250                         "   for n, s in pairs (self.instances) do"
5251                         "     local status, err = pcall (s, ...)"
5252                         "     if not status then"
5253                         "       print ('fn \"'.. n .. '\": ', err)"
5254                         "       remove (n)"
5255                         "      end"
5256                         "   end"
5257                         "   collectgarbage()"
5258                         "  end"
5259                         ""
5260                         "  local cleanup = function ()"
5261                         "   self.scripts = nil"
5262                         "   self.instances = nil"
5263                         "  end"
5264                         ""
5265                         "  local list = function ()"
5266                         "   local rv = {}"
5267                         "   for n, _ in pairs (self.scripts) do"
5268                         "     rv[n] = true"
5269                         "   end"
5270                         "   return rv"
5271                         "  end"
5272                         ""
5273                         "  local function basic_serialize (o)"
5274                         "    if type(o) == \"number\" then"
5275                         "     return tostring(o)"
5276                         "    else"
5277                         "     return string.format(\"%q\", o)"
5278                         "    end"
5279                         "  end"
5280                         ""
5281                         "  local function serialize (name, value)"
5282                         "   local rv = name .. ' = '"
5283                         "   collectgarbage()"
5284                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5285                         "    return rv .. basic_serialize(value) .. ' '"
5286                         "   elseif type(value) == \"table\" then"
5287                         "    rv = rv .. '{} '"
5288                         "    for k,v in pairs(value) do"
5289                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5290                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5291                         "     collectgarbage()" // string concatenation allocates a new string :(
5292                         "    end"
5293                         "    return rv;"
5294                         "   elseif type(value) == \"function\" then"
5295                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5296                         "   else"
5297                         "    error('cannot save a ' .. type(value))"
5298                         "   end"
5299                         "  end"
5300                         ""
5301                         ""
5302                         "  local save = function ()"
5303                         "   return (serialize('scripts', self.scripts))"
5304                         "  end"
5305                         ""
5306                         "  local restore = function (state)"
5307                         "   self.scripts = {}"
5308                         "   load (state)()"
5309                         "   for n, s in pairs (scripts) do"
5310                         "    addinternal (n, load(s['f']), s['a'])"
5311                         "   end"
5312                         "  end"
5313                         ""
5314                         " return { run = run, add = add, remove = remove,"
5315                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5316                         " end"
5317                         " "
5318                         " sess = ArdourSession ()"
5319                         " ArdourSession = nil"
5320                         " "
5321                         "function ardour () end"
5322                         );
5323
5324         lua_State* L = lua.getState();
5325
5326         try {
5327                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5328                 lua.do_command ("sess = nil"); // hide it.
5329                 lua.do_command ("collectgarbage()");
5330
5331                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5332                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5333                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5334                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5335                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5336                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5337                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5338         } catch (luabridge::LuaException const& e) {
5339                 fatal << string_compose (_("programming error: %1"),
5340                                 X_("Failed to setup Lua interpreter"))
5341                         << endmsg;
5342                 abort(); /*NOTREACHED*/
5343         }
5344
5345         LuaBindings::stddef (L);
5346         LuaBindings::common (L);
5347         LuaBindings::dsp (L);
5348         luabridge::push <Session *> (L, this);
5349         lua_setglobal (L, "Session");
5350 }
5351
5352 void
5353 Session::scripts_changed ()
5354 {
5355         assert (!lua_lock.trylock()); // must hold lua_lock
5356
5357         try {
5358                 luabridge::LuaRef list ((*_lua_list)());
5359                 int cnt = 0;
5360                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5361                         if (!i.key ().isString ()) { assert(0); continue; }
5362                         ++cnt;
5363                 }
5364                 _n_lua_scripts = cnt;
5365         } catch (luabridge::LuaException const& e) {
5366                 fatal << string_compose (_("programming error: %1"),
5367                                 X_("Indexing Lua Session Scripts failed."))
5368                         << endmsg;
5369                 abort(); /*NOTREACHED*/
5370         }
5371 }
5372
5373 void
5374 Session::non_realtime_set_audition ()
5375 {
5376         assert (pending_audition_region);
5377         auditioner->audition_region (pending_audition_region);
5378         pending_audition_region.reset ();
5379         AuditionActive (true); /* EMIT SIGNAL */
5380 }
5381
5382 void
5383 Session::audition_region (boost::shared_ptr<Region> r)
5384 {
5385         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5386         ev->region = r;
5387         queue_event (ev);
5388 }
5389
5390 void
5391 Session::cancel_audition ()
5392 {
5393         if (!auditioner) {
5394                 return;
5395         }
5396         if (auditioner->auditioning()) {
5397                 auditioner->cancel_audition ();
5398                 AuditionActive (false); /* EMIT SIGNAL */
5399         }
5400 }
5401
5402 bool
5403 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
5404 {
5405         if (a->is_monitor()) {
5406                 return true;
5407         }
5408         if (b->is_monitor()) {
5409                 return false;
5410         }
5411         return a->presentation_info().order() < b->presentation_info().order();
5412 }
5413
5414 bool
5415 Session::is_auditioning () const
5416 {
5417         /* can be called before we have an auditioner object */
5418         if (auditioner) {
5419                 return auditioner->auditioning();
5420         } else {
5421                 return false;
5422         }
5423 }
5424
5425 void
5426 Session::graph_reordered ()
5427 {
5428         /* don't do this stuff if we are setting up connections
5429            from a set_state() call or creating new tracks. Ditto for deletion.
5430         */
5431
5432         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5433                 return;
5434         }
5435
5436         /* every track/bus asked for this to be handled but it was deferred because
5437            we were connecting. do it now.
5438         */
5439
5440         request_input_change_handling ();
5441
5442         resort_routes ();
5443
5444         /* force all diskstreams to update their capture offset values to
5445            reflect any changes in latencies within the graph.
5446         */
5447
5448         boost::shared_ptr<RouteList> rl = routes.reader ();
5449         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5450                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5451                 if (tr) {
5452                         tr->set_capture_offset ();
5453                 }
5454         }
5455 }
5456
5457 /** @return Number of frames that there is disk space available to write,
5458  *  if known.
5459  */
5460 boost::optional<framecnt_t>
5461 Session::available_capture_duration ()
5462 {
5463         Glib::Threads::Mutex::Lock lm (space_lock);
5464
5465         if (_total_free_4k_blocks_uncertain) {
5466                 return boost::optional<framecnt_t> ();
5467         }
5468
5469         float sample_bytes_on_disk = 4.0; // keep gcc happy
5470
5471         switch (config.get_native_file_data_format()) {
5472         case FormatFloat:
5473                 sample_bytes_on_disk = 4.0;
5474                 break;
5475
5476         case FormatInt24:
5477                 sample_bytes_on_disk = 3.0;
5478                 break;
5479
5480         case FormatInt16:
5481                 sample_bytes_on_disk = 2.0;
5482                 break;
5483
5484         default:
5485                 /* impossible, but keep some gcc versions happy */
5486                 fatal << string_compose (_("programming error: %1"),
5487                                          X_("illegal native file data format"))
5488                       << endmsg;
5489                 abort(); /*NOTREACHED*/
5490         }
5491
5492         double scale = 4096.0 / sample_bytes_on_disk;
5493
5494         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5495                 return max_framecnt;
5496         }
5497
5498         return (framecnt_t) floor (_total_free_4k_blocks * scale);
5499 }
5500
5501 void
5502 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5503 {
5504         {
5505                 RCUWriter<BundleList> writer (_bundles);
5506                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5507                 b->push_back (bundle);
5508         }
5509
5510         if (emit_signal) {
5511                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5512         }
5513
5514         set_dirty();
5515 }
5516
5517 void
5518 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5519 {
5520         bool removed = false;
5521
5522         {
5523                 RCUWriter<BundleList> writer (_bundles);
5524                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5525                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5526
5527                 if (i != b->end()) {
5528                         b->erase (i);
5529                         removed = true;
5530                 }
5531         }
5532
5533         if (removed) {
5534                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5535         }
5536
5537         set_dirty();
5538 }
5539
5540 boost::shared_ptr<Bundle>
5541 Session::bundle_by_name (string name) const
5542 {
5543         boost::shared_ptr<BundleList> b = _bundles.reader ();
5544
5545         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5546                 if ((*i)->name() == name) {
5547                         return* i;
5548                 }
5549         }
5550
5551         return boost::shared_ptr<Bundle> ();
5552 }
5553
5554 void
5555 Session::tempo_map_changed (const PropertyChange&)
5556 {
5557         clear_clicks ();
5558
5559         playlists->update_after_tempo_map_change ();
5560
5561         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5562
5563         set_dirty ();
5564 }
5565
5566 void
5567 Session::gui_tempo_map_changed ()
5568 {
5569         clear_clicks ();
5570
5571         playlists->update_after_tempo_map_change ();
5572
5573         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5574 }
5575
5576 void
5577 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5578 {
5579         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5580                 (*i)->recompute_frames_from_bbt ();
5581         }
5582 }
5583
5584 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5585  * the given count with the current block size.
5586  */
5587 void
5588 Session::ensure_buffers (ChanCount howmany)
5589 {
5590         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5591 }
5592
5593 void
5594 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5595 {
5596         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5597                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5598         }
5599 }
5600
5601 uint32_t
5602 Session::next_insert_id ()
5603 {
5604         /* this doesn't really loop forever. just think about it */
5605
5606         while (true) {
5607                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5608                         if (!insert_bitset[n]) {
5609                                 insert_bitset[n] = true;
5610                                 return n;
5611
5612                         }
5613                 }
5614
5615                 /* none available, so resize and try again */
5616
5617                 insert_bitset.resize (insert_bitset.size() + 16, false);
5618         }
5619 }
5620
5621 uint32_t
5622 Session::next_send_id ()
5623 {
5624         /* this doesn't really loop forever. just think about it */
5625
5626         while (true) {
5627                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5628                         if (!send_bitset[n]) {
5629                                 send_bitset[n] = true;
5630                                 return n;
5631
5632                         }
5633                 }
5634
5635                 /* none available, so resize and try again */
5636
5637                 send_bitset.resize (send_bitset.size() + 16, false);
5638         }
5639 }
5640
5641 uint32_t
5642 Session::next_aux_send_id ()
5643 {
5644         /* this doesn't really loop forever. just think about it */
5645
5646         while (true) {
5647                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5648                         if (!aux_send_bitset[n]) {
5649                                 aux_send_bitset[n] = true;
5650                                 return n;
5651
5652                         }
5653                 }
5654
5655                 /* none available, so resize and try again */
5656
5657                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5658         }
5659 }
5660
5661 uint32_t
5662 Session::next_return_id ()
5663 {
5664         /* this doesn't really loop forever. just think about it */
5665
5666         while (true) {
5667                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5668                         if (!return_bitset[n]) {
5669                                 return_bitset[n] = true;
5670                                 return n;
5671
5672                         }
5673                 }
5674
5675                 /* none available, so resize and try again */
5676
5677                 return_bitset.resize (return_bitset.size() + 16, false);
5678         }
5679 }
5680
5681 void
5682 Session::mark_send_id (uint32_t id)
5683 {
5684         if (id >= send_bitset.size()) {
5685                 send_bitset.resize (id+16, false);
5686         }
5687         if (send_bitset[id]) {
5688                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5689         }
5690         send_bitset[id] = true;
5691 }
5692
5693 void
5694 Session::mark_aux_send_id (uint32_t id)
5695 {
5696         if (id >= aux_send_bitset.size()) {
5697                 aux_send_bitset.resize (id+16, false);
5698         }
5699         if (aux_send_bitset[id]) {
5700                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5701         }
5702         aux_send_bitset[id] = true;
5703 }
5704
5705 void
5706 Session::mark_return_id (uint32_t id)
5707 {
5708         if (id >= return_bitset.size()) {
5709                 return_bitset.resize (id+16, false);
5710         }
5711         if (return_bitset[id]) {
5712                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5713         }
5714         return_bitset[id] = true;
5715 }
5716
5717 void
5718 Session::mark_insert_id (uint32_t id)
5719 {
5720         if (id >= insert_bitset.size()) {
5721                 insert_bitset.resize (id+16, false);
5722         }
5723         if (insert_bitset[id]) {
5724                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5725         }
5726         insert_bitset[id] = true;
5727 }
5728
5729 void
5730 Session::unmark_send_id (uint32_t id)
5731 {
5732         if (id < send_bitset.size()) {
5733                 send_bitset[id] = false;
5734         }
5735 }
5736
5737 void
5738 Session::unmark_aux_send_id (uint32_t id)
5739 {
5740         if (id < aux_send_bitset.size()) {
5741                 aux_send_bitset[id] = false;
5742         }
5743 }
5744
5745 void
5746 Session::unmark_return_id (uint32_t id)
5747 {
5748         if (_state_of_the_state & Deletion) { return; }
5749         if (id < return_bitset.size()) {
5750                 return_bitset[id] = false;
5751         }
5752 }
5753
5754 void
5755 Session::unmark_insert_id (uint32_t id)
5756 {
5757         if (id < insert_bitset.size()) {
5758                 insert_bitset[id] = false;
5759         }
5760 }
5761
5762 void
5763 Session::reset_native_file_format ()
5764 {
5765         boost::shared_ptr<RouteList> rl = routes.reader ();
5766
5767         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5768                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5769                 if (tr) {
5770                         /* don't save state as we do this, there's no point
5771                          */
5772                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5773                         tr->reset_write_sources (false);
5774                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5775                 }
5776         }
5777 }
5778
5779 bool
5780 Session::route_name_unique (string n) const
5781 {
5782         boost::shared_ptr<RouteList> r = routes.reader ();
5783
5784         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5785                 if ((*i)->name() == n) {
5786                         return false;
5787                 }
5788         }
5789
5790         return true;
5791 }
5792
5793 bool
5794 Session::route_name_internal (string n) const
5795 {
5796         if (auditioner && auditioner->name() == n) {
5797                 return true;
5798         }
5799
5800         if (_click_io && _click_io->name() == n) {
5801                 return true;
5802         }
5803
5804         return false;
5805 }
5806
5807 int
5808 Session::freeze_all (InterThreadInfo& itt)
5809 {
5810         boost::shared_ptr<RouteList> r = routes.reader ();
5811
5812         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5813
5814                 boost::shared_ptr<Track> t;
5815
5816                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5817                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5818                            of every track.
5819                         */
5820                         t->freeze_me (itt);
5821                 }
5822         }
5823
5824         return 0;
5825 }
5826
5827 boost::shared_ptr<Region>
5828 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5829                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5830                           InterThreadInfo& itt,
5831                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5832                           bool for_export, bool for_freeze)
5833 {
5834         boost::shared_ptr<Region> result;
5835         boost::shared_ptr<Playlist> playlist;
5836         boost::shared_ptr<Source> source;
5837         ChanCount diskstream_channels (track.n_channels());
5838         framepos_t position;
5839         framecnt_t this_chunk;
5840         framepos_t to_do;
5841         framepos_t latency_skip;
5842         BufferSet buffers;
5843         framepos_t len = end - start;
5844         bool need_block_size_reset = false;
5845         ChanCount const max_proc = track.max_processor_streams ();
5846         string legal_playlist_name;
5847         string possible_path;
5848
5849         if (end <= start) {
5850                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5851                                          end, start) << endmsg;
5852                 return result;
5853         }
5854
5855         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5856                         include_endpoint, for_export, for_freeze);
5857
5858         if (diskstream_channels.n(track.data_type()) < 1) {
5859                 error << _("Cannot write a range with no data.") << endmsg;
5860                 return result;
5861         }
5862
5863         // block all process callback handling
5864
5865         block_processing ();
5866
5867         {
5868                 // synchronize with AudioEngine::process_callback()
5869                 // make sure processing is not currently running
5870                 // and processing_blocked() is honored before
5871                 // acquiring thread buffers
5872                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5873         }
5874
5875         _bounce_processing_active = true;
5876
5877         /* call tree *MUST* hold route_lock */
5878
5879         if ((playlist = track.playlist()) == 0) {
5880                 goto out;
5881         }
5882
5883         legal_playlist_name = legalize_for_path (playlist->name());
5884
5885         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5886
5887                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5888                 string path = ((track.data_type() == DataType::AUDIO)
5889                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5890                                : new_midi_source_path (legal_playlist_name));
5891
5892                 if (path.empty()) {
5893                         goto out;
5894                 }
5895
5896                 try {
5897                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5898                 }
5899
5900                 catch (failed_constructor& err) {
5901                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5902                         goto out;
5903                 }
5904
5905                 srcs.push_back (source);
5906         }
5907
5908         /* tell redirects that care that we are about to use a much larger
5909          * blocksize. this will flush all plugins too, so that they are ready
5910          * to be used for this process.
5911          */
5912
5913         need_block_size_reset = true;
5914         track.set_block_size (bounce_chunk_size);
5915         _engine.main_thread()->get_buffers ();
5916
5917         position = start;
5918         to_do = len;
5919         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5920
5921         /* create a set of reasonably-sized buffers */
5922         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5923                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5924         }
5925         buffers.set_count (max_proc);
5926
5927         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5928                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5929                 boost::shared_ptr<MidiSource> ms;
5930                 if (afs) {
5931                         afs->prepare_for_peakfile_writes ();
5932                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5933                         Source::Lock lock(ms->mutex());
5934                         ms->mark_streaming_write_started(lock);
5935                 }
5936         }
5937
5938         while (to_do && !itt.cancel) {
5939
5940                 this_chunk = min (to_do, bounce_chunk_size);
5941
5942                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5943                         goto out;
5944                 }
5945
5946                 start += this_chunk;
5947                 to_do -= this_chunk;
5948                 itt.progress = (float) (1.0 - ((double) to_do / len));
5949
5950                 if (latency_skip >= bounce_chunk_size) {
5951                         latency_skip -= bounce_chunk_size;
5952                         continue;
5953                 }
5954
5955                 const framecnt_t current_chunk = this_chunk - latency_skip;
5956
5957                 uint32_t n = 0;
5958                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5959                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5960                         boost::shared_ptr<MidiSource> ms;
5961
5962                         if (afs) {
5963                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5964                                         goto out;
5965                                 }
5966                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5967                                 Source::Lock lock(ms->mutex());
5968
5969                                 const MidiBuffer& buf = buffers.get_midi(0);
5970                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5971                                         Evoral::Event<framepos_t> ev = *i;
5972                                         ev.set_time(ev.time() - position);
5973                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5974                                 }
5975                         }
5976                 }
5977                 latency_skip = 0;
5978         }
5979
5980         /* post-roll, pick up delayed processor output */
5981         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5982
5983         while (latency_skip && !itt.cancel) {
5984                 this_chunk = min (latency_skip, bounce_chunk_size);
5985                 latency_skip -= this_chunk;
5986
5987                 buffers.silence (this_chunk, 0);
5988                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5989
5990                 uint32_t n = 0;
5991                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5992                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5993
5994                         if (afs) {
5995                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5996                                         goto out;
5997                                 }
5998                         }
5999                 }
6000         }
6001
6002         if (!itt.cancel) {
6003
6004                 time_t now;
6005                 struct tm* xnow;
6006                 time (&now);
6007                 xnow = localtime (&now);
6008
6009                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6010                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6011                         boost::shared_ptr<MidiSource> ms;
6012
6013                         if (afs) {
6014                                 afs->update_header (position, *xnow, now);
6015                                 afs->flush_header ();
6016                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6017                                 Source::Lock lock(ms->mutex());
6018                                 ms->mark_streaming_write_completed(lock);
6019                         }
6020                 }
6021
6022                 /* construct a region to represent the bounced material */
6023
6024                 PropertyList plist;
6025
6026                 plist.add (Properties::start, 0);
6027                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6028                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6029
6030                 result = RegionFactory::create (srcs, plist);
6031
6032         }
6033
6034   out:
6035         if (!result) {
6036                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6037                         (*src)->mark_for_remove ();
6038                         (*src)->drop_references ();
6039                 }
6040
6041         } else {
6042                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6043                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6044
6045                         if (afs)
6046                                 afs->done_with_peakfile_writes ();
6047                 }
6048         }
6049
6050         _bounce_processing_active = false;
6051
6052         if (need_block_size_reset) {
6053                 _engine.main_thread()->drop_buffers ();
6054                 track.set_block_size (get_block_size());
6055         }
6056
6057         unblock_processing ();
6058
6059         return result;
6060 }
6061
6062 gain_t*
6063 Session::gain_automation_buffer() const
6064 {
6065         return ProcessThread::gain_automation_buffer ();
6066 }
6067
6068 gain_t*
6069 Session::trim_automation_buffer() const
6070 {
6071         return ProcessThread::trim_automation_buffer ();
6072 }
6073
6074 gain_t*
6075 Session::send_gain_automation_buffer() const
6076 {
6077         return ProcessThread::send_gain_automation_buffer ();
6078 }
6079
6080 pan_t**
6081 Session::pan_automation_buffer() const
6082 {
6083         return ProcessThread::pan_automation_buffer ();
6084 }
6085
6086 BufferSet&
6087 Session::get_silent_buffers (ChanCount count)
6088 {
6089         return ProcessThread::get_silent_buffers (count);
6090 }
6091
6092 BufferSet&
6093 Session::get_scratch_buffers (ChanCount count, bool silence)
6094 {
6095         return ProcessThread::get_scratch_buffers (count, silence);
6096 }
6097
6098 BufferSet&
6099 Session::get_noinplace_buffers (ChanCount count)
6100 {
6101         return ProcessThread::get_noinplace_buffers (count);
6102 }
6103
6104 BufferSet&
6105 Session::get_route_buffers (ChanCount count, bool silence)
6106 {
6107         return ProcessThread::get_route_buffers (count, silence);
6108 }
6109
6110
6111 BufferSet&
6112 Session::get_mix_buffers (ChanCount count)
6113 {
6114         return ProcessThread::get_mix_buffers (count);
6115 }
6116
6117 uint32_t
6118 Session::ntracks () const
6119 {
6120         uint32_t n = 0;
6121         boost::shared_ptr<RouteList> r = routes.reader ();
6122
6123         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6124                 if (boost::dynamic_pointer_cast<Track> (*i)) {
6125                         ++n;
6126                 }
6127         }
6128
6129         return n;
6130 }
6131
6132 uint32_t
6133 Session::nbusses () const
6134 {
6135         uint32_t n = 0;
6136         boost::shared_ptr<RouteList> r = routes.reader ();
6137
6138         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6139                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6140                         ++n;
6141                 }
6142         }
6143
6144         return n;
6145 }
6146
6147 void
6148 Session::add_automation_list(AutomationList *al)
6149 {
6150         automation_lists[al->id()] = al;
6151 }
6152
6153 /** @return true if there is at least one record-enabled track, otherwise false */
6154 bool
6155 Session::have_rec_enabled_track () const
6156 {
6157         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6158 }
6159
6160 bool
6161 Session::have_rec_disabled_track () const
6162 {
6163     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6164 }
6165
6166 /** Update the state of our rec-enabled tracks flag */
6167 void
6168 Session::update_route_record_state ()
6169 {
6170         boost::shared_ptr<RouteList> rl = routes.reader ();
6171         RouteList::iterator i = rl->begin();
6172         while (i != rl->end ()) {
6173
6174                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6175                                     if (tr && tr->rec_enable_control()->get_value()) {
6176                         break;
6177                 }
6178
6179                 ++i;
6180         }
6181
6182         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6183
6184         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6185
6186         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6187                 RecordStateChanged (); /* EMIT SIGNAL */
6188         }
6189
6190         for (i = rl->begin(); i != rl->end (); ++i) {
6191                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6192                 if (tr && !tr->rec_enable_control()->get_value()) {
6193                         break;
6194                 }
6195         }
6196
6197         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6198
6199         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6200
6201         if (record_status() == Recording && record_arm_state_changed ) {
6202                 RecordArmStateChanged ();
6203         }
6204
6205 }
6206
6207 void
6208 Session::listen_position_changed ()
6209 {
6210         ProcessorChangeBlocker pcb (this);
6211         boost::shared_ptr<RouteList> r = routes.reader ();
6212         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6213                 (*i)->listen_position_changed ();
6214         }
6215 }
6216
6217 void
6218 Session::solo_control_mode_changed ()
6219 {
6220         if (soloing() || listening()) {
6221                 if (loading()) {
6222                         /* We can't use ::clear_all_solo_state() here because during
6223                            session loading at program startup, that will queue a call
6224                            to rt_clear_all_solo_state() that will not execute until
6225                            AFTER solo states have been established (thus throwing away
6226                            the session's saved solo state). So just explicitly turn
6227                            them all off.
6228                         */
6229                         set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6230                 } else {
6231                         clear_all_solo_state (get_routes());
6232                 }
6233         }
6234 }
6235
6236 /** Called when a property of one of our route groups changes */
6237 void
6238 Session::route_group_property_changed (RouteGroup* rg)
6239 {
6240         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6241 }
6242
6243 /** Called when a route is added to one of our route groups */
6244 void
6245 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6246 {
6247         RouteAddedToRouteGroup (rg, r);
6248 }
6249
6250 /** Called when a route is removed from one of our route groups */
6251 void
6252 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6253 {
6254         update_route_record_state ();
6255         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6256
6257         if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6258                 remove_route_group (*rg);
6259         }
6260 }
6261
6262 boost::shared_ptr<RouteList>
6263 Session::get_tracks () const
6264 {
6265         boost::shared_ptr<RouteList> rl = routes.reader ();
6266         boost::shared_ptr<RouteList> tl (new RouteList);
6267
6268         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6269                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6270                         if (!(*r)->is_auditioner()) {
6271                                 tl->push_back (*r);
6272                         }
6273                 }
6274         }
6275         return tl;
6276 }
6277
6278 boost::shared_ptr<RouteList>
6279 Session::get_routes_with_regions_at (framepos_t const p) const
6280 {
6281         boost::shared_ptr<RouteList> r = routes.reader ();
6282         boost::shared_ptr<RouteList> rl (new RouteList);
6283
6284         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6285                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6286                 if (!tr) {
6287                         continue;
6288                 }
6289
6290                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6291                 if (!pl) {
6292                         continue;
6293                 }
6294
6295                 if (pl->has_region_at (p)) {
6296                         rl->push_back (*i);
6297                 }
6298         }
6299
6300         return rl;
6301 }
6302
6303 void
6304 Session::goto_end ()
6305 {
6306         if (_session_range_location) {
6307                 request_locate (_session_range_location->end(), false);
6308         } else {
6309                 request_locate (0, false);
6310         }
6311 }
6312
6313 void
6314 Session::goto_start (bool and_roll)
6315 {
6316         if (_session_range_location) {
6317                 request_locate (_session_range_location->start(), and_roll);
6318         } else {
6319                 request_locate (0, and_roll);
6320         }
6321 }
6322
6323 framepos_t
6324 Session::current_start_frame () const
6325 {
6326         return _session_range_location ? _session_range_location->start() : 0;
6327 }
6328
6329 framepos_t
6330 Session::current_end_frame () const
6331 {
6332         return _session_range_location ? _session_range_location->end() : 0;
6333 }
6334
6335 void
6336 Session::set_session_range_location (framepos_t start, framepos_t end)
6337 {
6338         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
6339         _locations->add (_session_range_location);
6340 }
6341
6342 void
6343 Session::step_edit_status_change (bool yn)
6344 {
6345         bool send = false;
6346
6347         bool val = false;
6348         if (yn) {
6349                 send = (_step_editors == 0);
6350                 val = true;
6351
6352                 _step_editors++;
6353         } else {
6354                 send = (_step_editors == 1);
6355                 val = false;
6356
6357                 if (_step_editors > 0) {
6358                         _step_editors--;
6359                 }
6360         }
6361
6362         if (send) {
6363                 StepEditStatusChange (val);
6364         }
6365 }
6366
6367
6368 void
6369 Session::start_time_changed (framepos_t old)
6370 {
6371         /* Update the auto loop range to match the session range
6372            (unless the auto loop range has been changed by the user)
6373         */
6374
6375         Location* s = _locations->session_range_location ();
6376         if (s == 0) {
6377                 return;
6378         }
6379
6380         Location* l = _locations->auto_loop_location ();
6381
6382         if (l && l->start() == old) {
6383                 l->set_start (s->start(), true);
6384         }
6385         set_dirty ();
6386 }
6387
6388 void
6389 Session::end_time_changed (framepos_t old)
6390 {
6391         /* Update the auto loop range to match the session range
6392            (unless the auto loop range has been changed by the user)
6393         */
6394
6395         Location* s = _locations->session_range_location ();
6396         if (s == 0) {
6397                 return;
6398         }
6399
6400         Location* l = _locations->auto_loop_location ();
6401
6402         if (l && l->end() == old) {
6403                 l->set_end (s->end(), true);
6404         }
6405         set_dirty ();
6406 }
6407
6408 std::vector<std::string>
6409 Session::source_search_path (DataType type) const
6410 {
6411         Searchpath sp;
6412
6413         if (session_dirs.size() == 1) {
6414                 switch (type) {
6415                 case DataType::AUDIO:
6416                         sp.push_back (_session_dir->sound_path());
6417                         break;
6418                 case DataType::MIDI:
6419                         sp.push_back (_session_dir->midi_path());
6420                         break;
6421                 }
6422         } else {
6423                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6424                         SessionDirectory sdir (i->path);
6425                         switch (type) {
6426                         case DataType::AUDIO:
6427                                 sp.push_back (sdir.sound_path());
6428                                 break;
6429                         case DataType::MIDI:
6430                                 sp.push_back (sdir.midi_path());
6431                                 break;
6432                         }
6433                 }
6434         }
6435
6436         if (type == DataType::AUDIO) {
6437                 const string sound_path_2X = _session_dir->sound_path_2X();
6438                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6439                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6440                                 sp.push_back (sound_path_2X);
6441                         }
6442                 }
6443         }
6444
6445         // now check the explicit (possibly user-specified) search path
6446
6447         switch (type) {
6448         case DataType::AUDIO:
6449                 sp += Searchpath(config.get_audio_search_path ());
6450                 break;
6451         case DataType::MIDI:
6452                 sp += Searchpath(config.get_midi_search_path ());
6453                 break;
6454         }
6455
6456         return sp;
6457 }
6458
6459 void
6460 Session::ensure_search_path_includes (const string& path, DataType type)
6461 {
6462         Searchpath sp;
6463
6464         if (path == ".") {
6465                 return;
6466         }
6467
6468         switch (type) {
6469         case DataType::AUDIO:
6470                 sp += Searchpath(config.get_audio_search_path ());
6471                 break;
6472         case DataType::MIDI:
6473                 sp += Searchpath (config.get_midi_search_path ());
6474                 break;
6475         }
6476
6477         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6478                 /* No need to add this new directory if it has the same inode as
6479                    an existing one; checking inode rather than name prevents duplicated
6480                    directories when we are using symlinks.
6481
6482                    On Windows, I think we could just do if (*i == path) here.
6483                 */
6484                 if (PBD::equivalent_paths (*i, path)) {
6485                         return;
6486                 }
6487         }
6488
6489         sp += path;
6490
6491         switch (type) {
6492         case DataType::AUDIO:
6493                 config.set_audio_search_path (sp.to_string());
6494                 break;
6495         case DataType::MIDI:
6496                 config.set_midi_search_path (sp.to_string());
6497                 break;
6498         }
6499 }
6500
6501 void
6502 Session::remove_dir_from_search_path (const string& dir, DataType type)
6503 {
6504         Searchpath sp;
6505
6506         switch (type) {
6507         case DataType::AUDIO:
6508                 sp = Searchpath(config.get_audio_search_path ());
6509                 break;
6510         case DataType::MIDI:
6511                 sp = Searchpath (config.get_midi_search_path ());
6512                 break;
6513         }
6514
6515         sp -= dir;
6516
6517         switch (type) {
6518         case DataType::AUDIO:
6519                 config.set_audio_search_path (sp.to_string());
6520                 break;
6521         case DataType::MIDI:
6522                 config.set_midi_search_path (sp.to_string());
6523                 break;
6524         }
6525
6526 }
6527
6528 boost::shared_ptr<Speakers>
6529 Session::get_speakers()
6530 {
6531         return _speakers;
6532 }
6533
6534 list<string>
6535 Session::unknown_processors () const
6536 {
6537         list<string> p;
6538
6539         boost::shared_ptr<RouteList> r = routes.reader ();
6540         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6541                 list<string> t = (*i)->unknown_processors ();
6542                 copy (t.begin(), t.end(), back_inserter (p));
6543         }
6544
6545         p.sort ();
6546         p.unique ();
6547
6548         return p;
6549 }
6550
6551 void
6552 Session::update_latency (bool playback)
6553 {
6554
6555         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6556
6557         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6558                 return;
6559         }
6560
6561         boost::shared_ptr<RouteList> r = routes.reader ();
6562         framecnt_t max_latency = 0;
6563
6564         if (playback) {
6565                 /* reverse the list so that we work backwards from the last route to run to the first */
6566                 RouteList* rl = routes.reader().get();
6567                 r.reset (new RouteList (*rl));
6568                 reverse (r->begin(), r->end());
6569         }
6570
6571         /* compute actual latency values for the given direction and store them all in per-port
6572            structures. this will also publish the same values (to JACK) so that computation of latency
6573            for routes can consistently use public latency values.
6574         */
6575
6576         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6577                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6578         }
6579
6580         /* because we latency compensate playback, our published playback latencies should
6581            be the same for all output ports - all material played back by ardour has
6582            the same latency, whether its caused by plugins or by latency compensation. since
6583            these may differ from the values computed above, reset all playback port latencies
6584            to the same value.
6585         */
6586
6587         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6588
6589         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6590                 (*i)->set_public_port_latencies (max_latency, playback);
6591         }
6592
6593         if (playback) {
6594
6595                 post_playback_latency ();
6596
6597         } else {
6598
6599                 post_capture_latency ();
6600         }
6601
6602         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6603 }
6604
6605 void
6606 Session::post_playback_latency ()
6607 {
6608         set_worst_playback_latency ();
6609
6610         boost::shared_ptr<RouteList> r = routes.reader ();
6611
6612         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6613                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6614                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6615                 }
6616         }
6617
6618         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6619                 (*i)->set_latency_compensation (_worst_track_latency);
6620         }
6621 }
6622
6623 void
6624 Session::post_capture_latency ()
6625 {
6626         set_worst_capture_latency ();
6627
6628         /* reflect any changes in capture latencies into capture offsets
6629          */
6630
6631         boost::shared_ptr<RouteList> rl = routes.reader();
6632         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6633                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6634                 if (tr) {
6635                         tr->set_capture_offset ();
6636                 }
6637         }
6638 }
6639
6640 void
6641 Session::initialize_latencies ()
6642 {
6643         {
6644                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6645                 update_latency (false);
6646                 update_latency (true);
6647         }
6648
6649         set_worst_io_latencies ();
6650 }
6651
6652 void
6653 Session::set_worst_io_latencies ()
6654 {
6655         set_worst_playback_latency ();
6656         set_worst_capture_latency ();
6657 }
6658
6659 void
6660 Session::set_worst_playback_latency ()
6661 {
6662         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6663                 return;
6664         }
6665
6666         _worst_output_latency = 0;
6667
6668         if (!_engine.connected()) {
6669                 return;
6670         }
6671
6672         boost::shared_ptr<RouteList> r = routes.reader ();
6673
6674         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6675                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6676         }
6677
6678         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6679 }
6680
6681 void
6682 Session::set_worst_capture_latency ()
6683 {
6684         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6685                 return;
6686         }
6687
6688         _worst_input_latency = 0;
6689
6690         if (!_engine.connected()) {
6691                 return;
6692         }
6693
6694         boost::shared_ptr<RouteList> r = routes.reader ();
6695
6696         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6697                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6698         }
6699
6700         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6701 }
6702
6703 void
6704 Session::update_latency_compensation (bool force_whole_graph)
6705 {
6706         bool some_track_latency_changed = false;
6707
6708         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6709                 return;
6710         }
6711
6712         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6713
6714         _worst_track_latency = 0;
6715
6716         boost::shared_ptr<RouteList> r = routes.reader ();
6717
6718         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6719                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6720                         framecnt_t tl;
6721                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6722                                 some_track_latency_changed = true;
6723                         }
6724                         _worst_track_latency = max (tl, _worst_track_latency);
6725                 }
6726         }
6727
6728         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6729                                                      (some_track_latency_changed ? "yes" : "no")));
6730
6731         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6732
6733         if (some_track_latency_changed || force_whole_graph)  {
6734                 _engine.update_latencies ();
6735         }
6736
6737
6738         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6739                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6740                 if (!tr) {
6741                         continue;
6742                 }
6743                 tr->set_capture_offset ();
6744         }
6745 }
6746
6747 char
6748 Session::session_name_is_legal (const string& path)
6749 {
6750         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6751
6752         for (int i = 0; illegal_chars[i]; ++i) {
6753                 if (path.find (illegal_chars[i]) != string::npos) {
6754                         return illegal_chars[i];
6755                 }
6756         }
6757
6758         return 0;
6759 }
6760
6761 void
6762 Session::notify_presentation_info_change ()
6763 {
6764         if (deletion_in_progress()) {
6765                 return;
6766         }
6767
6768         PresentationInfo::Change (); /* EMIT SIGNAL */
6769         reassign_track_numbers();
6770
6771 #ifdef USE_TRACKS_CODE_FEATURES
6772         /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6773          * if track order has been changed by user
6774          */
6775         reconnect_existing_routes(true, true);
6776 #endif
6777
6778 }
6779
6780 bool
6781 Session::operation_in_progress (GQuark op) const
6782 {
6783         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6784 }
6785
6786 boost::shared_ptr<Port>
6787 Session::ltc_input_port () const
6788 {
6789         return _ltc_input->nth (0);
6790 }
6791
6792 boost::shared_ptr<Port>
6793 Session::ltc_output_port () const
6794 {
6795         return _ltc_output->nth (0);
6796 }
6797
6798 void
6799 Session::reconnect_ltc_input ()
6800 {
6801         if (_ltc_input) {
6802
6803                 string src = Config->get_ltc_source_port();
6804
6805                 _ltc_input->disconnect (this);
6806
6807                 if (src != _("None") && !src.empty())  {
6808                         _ltc_input->nth (0)->connect (src);
6809                 }
6810
6811                 if ( ARDOUR::Profile->get_trx () ) {
6812                         // Tracks need this signal to update timecode_source_dropdown
6813                         MtcOrLtcInputPortChanged (); //emit signal
6814                 }
6815         }
6816 }
6817
6818 void
6819 Session::reconnect_ltc_output ()
6820 {
6821         if (_ltc_output) {
6822
6823                 string src = Config->get_ltc_output_port();
6824
6825                 _ltc_output->disconnect (this);
6826
6827                 if (src != _("None") && !src.empty())  {
6828                         _ltc_output->nth (0)->connect (src);
6829                 }
6830         }
6831 }
6832
6833 void
6834 Session::set_range_selection (framepos_t start, framepos_t end)
6835 {
6836         _range_selection = Evoral::Range<framepos_t> (start, end);
6837 #ifdef USE_TRACKS_CODE_FEATURES
6838         follow_playhead_priority ();
6839 #endif
6840 }
6841
6842 void
6843 Session::set_object_selection (framepos_t start, framepos_t end)
6844 {
6845         _object_selection = Evoral::Range<framepos_t> (start, end);
6846 #ifdef USE_TRACKS_CODE_FEATURES
6847         follow_playhead_priority ();
6848 #endif
6849 }
6850
6851 void
6852 Session::clear_range_selection ()
6853 {
6854         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6855 #ifdef USE_TRACKS_CODE_FEATURES
6856         follow_playhead_priority ();
6857 #endif
6858 }
6859
6860 void
6861 Session::clear_object_selection ()
6862 {
6863         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6864 #ifdef USE_TRACKS_CODE_FEATURES
6865         follow_playhead_priority ();
6866 #endif
6867 }
6868
6869 void
6870 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
6871                 const ChanCount& input_start,
6872                 const ChanCount& output_start,
6873                 const ChanCount& input_offset,
6874                 const ChanCount& output_offset)
6875 {
6876         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6877         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
6878                                 input_start, output_start,
6879                                 input_offset, output_offset));
6880
6881         auto_connect_thread_wakeup ();
6882 }
6883
6884 void
6885 Session::auto_connect_thread_wakeup ()
6886 {
6887         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
6888                 pthread_cond_signal (&_auto_connect_cond);
6889                 pthread_mutex_unlock (&_auto_connect_mutex);
6890         }
6891 }
6892
6893 void
6894 Session::queue_latency_recompute ()
6895 {
6896         g_atomic_int_inc (&_latency_recompute_pending);
6897         auto_connect_thread_wakeup ();
6898 }
6899
6900 void
6901 Session::auto_connect (const AutoConnectRequest& ar)
6902 {
6903         boost::shared_ptr<Route> route = ar.route.lock();
6904
6905         if (!route) { return; }
6906
6907         if (!IO::connecting_legal) {
6908                 return;
6909         }
6910
6911         /* If both inputs and outputs are auto-connected to physical ports,
6912          * use the max of input and output offsets to ensure auto-connected
6913          * port numbers always match up (e.g. the first audio input and the
6914          * first audio output of the route will have the same physical
6915          * port number).  Otherwise just use the lowest input or output
6916          * offset possible.
6917          */
6918
6919         const bool in_out_physical =
6920                 (Config->get_input_auto_connect() & AutoConnectPhysical)
6921                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
6922                 && ar.connect_inputs;
6923
6924         const ChanCount in_offset = in_out_physical
6925                 ? ChanCount::max(ar.input_offset, ar.output_offset)
6926                 : ar.input_offset;
6927
6928         const ChanCount out_offset = in_out_physical
6929                 ? ChanCount::max(ar.input_offset, ar.output_offset)
6930                 : ar.output_offset;
6931
6932         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6933                 vector<string> physinputs;
6934                 vector<string> physoutputs;
6935
6936
6937                 /* for connecting track inputs we only want MIDI ports marked
6938                  * for "music".
6939                  */
6940
6941                 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
6942
6943                 if (!physinputs.empty() && ar.connect_inputs) {
6944                         uint32_t nphysical_in = physinputs.size();
6945
6946                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
6947                                 string port;
6948
6949                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
6950                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
6951                                 }
6952
6953                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
6954                                         break;
6955                                 }
6956                         }
6957                 }
6958
6959                 if (!physoutputs.empty()) {
6960                         uint32_t nphysical_out = physoutputs.size();
6961                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
6962                                 string port;
6963
6964                                 /* Waves Tracks:
6965                                  * do not create new connections if we reached the limit of physical outputs
6966                                  * in Multi Out mode
6967                                  */
6968                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
6969                                                 ARDOUR::Profile->get_trx () &&
6970                                                 ar.output_offset.get(*t) == nphysical_out ) {
6971                                         break;
6972                                 }
6973
6974                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
6975                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
6976                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
6977                                         /* master bus is audio only */
6978                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
6979                                                 port = _master_out->input()->ports().port(*t,
6980                                                                 i % _master_out->input()->n_ports().get(*t))->name();
6981                                         }
6982                                 }
6983
6984                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
6985                                         break;
6986                                 }
6987                         }
6988                 }
6989         }
6990 }
6991
6992 void
6993 Session::auto_connect_thread_start ()
6994 {
6995         if (_ac_thread_active) {
6996                 return;
6997         }
6998
6999         while (!_auto_connect_queue.empty ()) {
7000                 _auto_connect_queue.pop ();
7001         }
7002
7003         _ac_thread_active = true;
7004         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7005                 _ac_thread_active = false;
7006         }
7007 }
7008
7009 void
7010 Session::auto_connect_thread_terminate ()
7011 {
7012         if (!_ac_thread_active) {
7013                 return;
7014         }
7015         _ac_thread_active = false;
7016
7017         {
7018                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7019                 while (!_auto_connect_queue.empty ()) {
7020                         _auto_connect_queue.pop ();
7021                 }
7022         }
7023
7024         auto_connect_thread_wakeup ();
7025
7026         void *status;
7027         pthread_join (_auto_connect_thread, &status);
7028 }
7029
7030 void *
7031 Session::auto_connect_thread (void *arg)
7032 {
7033         Session *s = static_cast<Session *>(arg);
7034         s->auto_connect_thread_run ();
7035         pthread_exit (0);
7036         return 0;
7037 }
7038
7039 void
7040 Session::auto_connect_thread_run ()
7041 {
7042         pthread_set_name (X_("autoconnect"));
7043         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7044         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7045         pthread_mutex_lock (&_auto_connect_mutex);
7046         while (_ac_thread_active) {
7047
7048                 if (!_auto_connect_queue.empty ()) {
7049                         // Why would we need the process lock ??
7050                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7051                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7052                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
7053                         //   We have control over those, but what does jack do?
7054                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7055
7056                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7057                         while (!_auto_connect_queue.empty ()) {
7058                                 const AutoConnectRequest ar (_auto_connect_queue.front());
7059                                 _auto_connect_queue.pop ();
7060                                 lx.release ();
7061                                 auto_connect (ar);
7062                                 lx.acquire ();
7063                         }
7064                 }
7065
7066                 if (!actively_recording ()) { // might not be needed,
7067                         /* this is only used for updating plugin latencies, the
7068                          * graph does not change. so it's safe in general.
7069                          * BUT..
7070                          * .. update_latency_compensation () entails set_capture_offset()
7071                          * which calls Diskstream::set_capture_offset () which
7072                          * modifies the capture offset... which can be a proplem
7073                          * in "prepare_to_stop"
7074                          */
7075                         while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7076                                 update_latency_compensation ();
7077                         }
7078                 }
7079
7080                 AudioEngine::instance()->clear_pending_port_deletions ();
7081
7082                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7083         }
7084         pthread_mutex_unlock (&_auto_connect_mutex);
7085 }
7086
7087 void
7088 Session::cancel_all_solo ()
7089 {
7090         StripableList sl;
7091
7092         get_stripables (sl);
7093
7094         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7095         clear_all_solo_state (routes.reader());
7096 }