libs/ardour/session.cc

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