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