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