libs/ardour/session.cc

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