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