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