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