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