libs/ardour/session.cc

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