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