libs/ardour/session.cc

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