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<AutomationControl> 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, this);
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 WholeGroup
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<Track>
4020 Session::track_by_diskstream_id (PBD::ID id)
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<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4026                 if (t && t->using_diskstream_id (id)) {
4027                         return t;
4028                 }
4029         }
4030
4031         return boost::shared_ptr<Track> ();
4032 }
4033
4034 boost::shared_ptr<Route>
4035 Session::route_by_remote_id (uint32_t id)
4036 {
4037         boost::shared_ptr<RouteList> r = routes.reader ();
4038
4039         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4040                 if ((*i)->remote_control_id() == id) {
4041                         return *i;
4042                 }
4043         }
4044
4045         return boost::shared_ptr<Route> ((Route*) 0);
4046 }
4047
4048
4049 void
4050 Session::reassign_track_numbers ()
4051 {
4052         int64_t tn = 0;
4053         int64_t bn = 0;
4054         RouteList r (*(routes.reader ()));
4055         SignalOrderRouteSorter sorter;
4056         r.sort (sorter);
4057
4058         StateProtector sp (this);
4059
4060         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4061                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4062                         (*i)->set_track_number(++tn);
4063                 }
4064                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4065                         (*i)->set_track_number(--bn);
4066                 }
4067         }
4068         const uint32_t decimals = ceilf (log10f (tn + 1));
4069         const bool decimals_changed = _track_number_decimals != decimals;
4070         _track_number_decimals = decimals;
4071
4072         if (decimals_changed && config.get_track_name_number ()) {
4073                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4074                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4075                         if (t) {
4076                                 t->resync_track_name();
4077                         }
4078                 }
4079                 // trigger GUI re-layout
4080                 config.ParameterChanged("track-name-number");
4081         }
4082 }
4083
4084 void
4085 Session::playlist_region_added (boost::weak_ptr<Region> w)
4086 {
4087         boost::shared_ptr<Region> r = w.lock ();
4088         if (!r) {
4089                 return;
4090         }
4091
4092         /* These are the operations that are currently in progress... */
4093         list<GQuark> curr = _current_trans_quarks;
4094         curr.sort ();
4095
4096         /* ...and these are the operations during which we want to update
4097            the session range location markers.
4098         */
4099         list<GQuark> ops;
4100         ops.push_back (Operations::capture);
4101         ops.push_back (Operations::paste);
4102         ops.push_back (Operations::duplicate_region);
4103         ops.push_back (Operations::insert_file);
4104         ops.push_back (Operations::insert_region);
4105         ops.push_back (Operations::drag_region_brush);
4106         ops.push_back (Operations::region_drag);
4107         ops.push_back (Operations::selection_grab);
4108         ops.push_back (Operations::region_fill);
4109         ops.push_back (Operations::fill_selection);
4110         ops.push_back (Operations::create_region);
4111         ops.push_back (Operations::region_copy);
4112         ops.push_back (Operations::fixed_time_region_copy);
4113         ops.sort ();
4114
4115         /* See if any of the current operations match the ones that we want */
4116         list<GQuark> in;
4117         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4118
4119         /* If so, update the session range markers */
4120         if (!in.empty ()) {
4121                 maybe_update_session_range (r->position (), r->last_frame ());
4122         }
4123 }
4124
4125 /** Update the session range markers if a is before the current start or
4126  *  b is after the current end.
4127  */
4128 void
4129 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4130 {
4131         if (_state_of_the_state & Loading) {
4132                 return;
4133         }
4134
4135         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4136
4137         if (_session_range_location == 0) {
4138
4139                 set_session_range_location (a, b + session_end_marker_shift_samples);
4140
4141         } else {
4142
4143                 if (a < _session_range_location->start()) {
4144                         _session_range_location->set_start (a);
4145                 }
4146
4147                 if (b > _session_range_location->end()) {
4148                         _session_range_location->set_end (b);
4149                 }
4150         }
4151 }
4152
4153 void
4154 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4155 {
4156         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4157                 maybe_update_session_range (i->to, i->to + i->length);
4158         }
4159 }
4160
4161 void
4162 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4163 {
4164         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4165                 maybe_update_session_range (i->from, i->to);
4166         }
4167 }
4168
4169 /* Region management */
4170
4171 boost::shared_ptr<Region>
4172 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4173 {
4174         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4175         RegionFactory::RegionMap::const_iterator i;
4176         boost::shared_ptr<Region> region;
4177
4178         Glib::Threads::Mutex::Lock lm (region_lock);
4179
4180         for (i = regions.begin(); i != regions.end(); ++i) {
4181
4182                 region = i->second;
4183
4184                 if (region->whole_file()) {
4185
4186                         if (child->source_equivalent (region)) {
4187                                 return region;
4188                         }
4189                 }
4190         }
4191
4192         return boost::shared_ptr<Region> ();
4193 }
4194
4195 int
4196 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4197 {
4198         set<boost::shared_ptr<Region> > relevant_regions;
4199
4200         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4201                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4202         }
4203
4204         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4205                 set<boost::shared_ptr<Region> >::iterator tmp;
4206
4207                 tmp = r;
4208                 ++tmp;
4209
4210                 playlists->destroy_region (*r);
4211                 RegionFactory::map_remove (*r);
4212
4213                 (*r)->drop_sources ();
4214                 (*r)->drop_references ();
4215
4216                 relevant_regions.erase (r);
4217
4218                 r = tmp;
4219         }
4220
4221         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4222
4223                 {
4224                         Glib::Threads::Mutex::Lock ls (source_lock);
4225                         /* remove from the main source list */
4226                         sources.erase ((*s)->id());
4227                 }
4228
4229                 (*s)->mark_for_remove ();
4230                 (*s)->drop_references ();
4231
4232                 s = srcs.erase (s);
4233         }
4234
4235         return 0;
4236 }
4237
4238 int
4239 Session::remove_last_capture ()
4240 {
4241         list<boost::shared_ptr<Source> > srcs;
4242
4243         boost::shared_ptr<RouteList> rl = routes.reader ();
4244         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4245                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4246                 if (!tr) {
4247                         continue;
4248                 }
4249
4250                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4251
4252                 if (!l.empty()) {
4253                         srcs.insert (srcs.end(), l.begin(), l.end());
4254                         l.clear ();
4255                 }
4256         }
4257
4258         destroy_sources (srcs);
4259
4260         save_state (_current_snapshot_name);
4261
4262         return 0;
4263 }
4264
4265 /* Source Management */
4266
4267 void
4268 Session::add_source (boost::shared_ptr<Source> source)
4269 {
4270         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4271         pair<SourceMap::iterator,bool> result;
4272
4273         entry.first = source->id();
4274         entry.second = source;
4275
4276         {
4277                 Glib::Threads::Mutex::Lock lm (source_lock);
4278                 result = sources.insert (entry);
4279         }
4280
4281         if (result.second) {
4282
4283                 /* yay, new source */
4284
4285                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4286
4287                 if (fs) {
4288                         if (!fs->within_session()) {
4289                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4290                         }
4291                 }
4292
4293                 set_dirty();
4294
4295                 boost::shared_ptr<AudioFileSource> afs;
4296
4297                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4298                         if (Config->get_auto_analyse_audio()) {
4299                                 Analyser::queue_source_for_analysis (source, false);
4300                         }
4301                 }
4302
4303                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4304         }
4305 }
4306
4307 void
4308 Session::remove_source (boost::weak_ptr<Source> src)
4309 {
4310         if (_state_of_the_state & Deletion) {
4311                 return;
4312         }
4313
4314         SourceMap::iterator i;
4315         boost::shared_ptr<Source> source = src.lock();
4316
4317         if (!source) {
4318                 return;
4319         }
4320
4321         {
4322                 Glib::Threads::Mutex::Lock lm (source_lock);
4323
4324                 if ((i = sources.find (source->id())) != sources.end()) {
4325                         sources.erase (i);
4326                 }
4327         }
4328
4329         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4330
4331                 /* save state so we don't end up with a session file
4332                    referring to non-existent sources.
4333                 */
4334
4335                 save_state (_current_snapshot_name);
4336         }
4337 }
4338
4339 boost::shared_ptr<Source>
4340 Session::source_by_id (const PBD::ID& id)
4341 {
4342         Glib::Threads::Mutex::Lock lm (source_lock);
4343         SourceMap::iterator i;
4344         boost::shared_ptr<Source> source;
4345
4346         if ((i = sources.find (id)) != sources.end()) {
4347                 source = i->second;
4348         }
4349
4350         return source;
4351 }
4352
4353 boost::shared_ptr<AudioFileSource>
4354 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4355 {
4356         /* Restricted to audio files because only audio sources have channel
4357            as a property.
4358         */
4359
4360         Glib::Threads::Mutex::Lock lm (source_lock);
4361
4362         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4363                 boost::shared_ptr<AudioFileSource> afs
4364                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4365
4366                 if (afs && afs->path() == path && chn == afs->channel()) {
4367                         return afs;
4368                 }
4369         }
4370
4371         return boost::shared_ptr<AudioFileSource>();
4372 }
4373
4374 boost::shared_ptr<MidiSource>
4375 Session::midi_source_by_path (const std::string& path) const
4376 {
4377         /* Restricted to MIDI files because audio sources require a channel
4378            for unique identification, in addition to a path.
4379         */
4380
4381         Glib::Threads::Mutex::Lock lm (source_lock);
4382
4383         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4384                 boost::shared_ptr<MidiSource> ms
4385                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4386                 boost::shared_ptr<FileSource> fs
4387                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4388
4389                 if (ms && fs && fs->path() == path) {
4390                         return ms;
4391                 }
4392         }
4393
4394         return boost::shared_ptr<MidiSource>();
4395 }
4396
4397 uint32_t
4398 Session::count_sources_by_origin (const string& path)
4399 {
4400         uint32_t cnt = 0;
4401         Glib::Threads::Mutex::Lock lm (source_lock);
4402
4403         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4404                 boost::shared_ptr<FileSource> fs
4405                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4406
4407                 if (fs && fs->origin() == path) {
4408                         ++cnt;
4409                 }
4410         }
4411
4412         return cnt;
4413 }
4414
4415 static string
4416 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4417         if (hash) {
4418                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4419                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4420         } else {
4421                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4422         }
4423 }
4424
4425 string
4426 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4427 {
4428         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4429
4430         if (Glib::path_is_absolute (filepath)) {
4431
4432                 /* rip the session dir from the audiofile source */
4433
4434                 string session_path;
4435                 bool in_another_session = true;
4436
4437                 if (filepath.find (interchange_dir_string) != string::npos) {
4438
4439                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4440                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4441                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4442                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4443
4444                         /* see if it is within our session */
4445
4446                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4447                                 if (i->path == session_path) {
4448                                         in_another_session = false;
4449                                         break;
4450                                 }
4451                         }
4452                 } else {
4453                         in_another_session = false;
4454                 }
4455
4456
4457                 if (in_another_session) {
4458                         SessionDirectory sd (session_path);
4459                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4460                 }
4461         }
4462
4463         /* 1) if file belongs to this session
4464          * it may be a relative path (interchange/...)
4465          * or just basename (session_state, remove source)
4466          * -> just use the basename
4467          */
4468         std::string filename = Glib::path_get_basename (filepath);
4469         std::string path;
4470
4471         /* 2) if the file is outside our session dir:
4472          * (imported but not copied) add the path for check-summming */
4473         if (!in_session) {
4474                 path = Glib::path_get_dirname (filepath);
4475         }
4476
4477         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4478 }
4479
4480 string
4481 Session::new_audio_source_path_for_embedded (const std::string& path)
4482 {
4483         /* embedded source:
4484          *
4485          * we know that the filename is already unique because it exists
4486          * out in the filesystem.
4487          *
4488          * However, when we bring it into the session, we could get a
4489          * collision.
4490          *
4491          * Eg. two embedded files:
4492          *
4493          *          /foo/bar/baz.wav
4494          *          /frob/nic/baz.wav
4495          *
4496          * When merged into session, these collide.
4497          *
4498          * There will not be a conflict with in-memory sources
4499          * because when the source was created we already picked
4500          * a unique name for it.
4501          *
4502          * This collision is not likely to be common, but we have to guard
4503          * against it.  So, if there is a collision, take the md5 hash of the
4504          * the path, and use that as the filename instead.
4505          */
4506
4507         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4508         string base = Glib::path_get_basename (path);
4509         string newpath = Glib::build_filename (sdir.sound_path(), base);
4510
4511         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4512
4513                 MD5 md5;
4514
4515                 md5.digestString (path.c_str());
4516                 md5.writeToString ();
4517                 base = md5.digestChars;
4518
4519                 string ext = get_suffix (path);
4520
4521                 if (!ext.empty()) {
4522                         base += '.';
4523                         base += ext;
4524                 }
4525
4526                 newpath = Glib::build_filename (sdir.sound_path(), base);
4527
4528                 /* if this collides, we're screwed */
4529
4530                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4531                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4532                         return string();
4533                 }
4534
4535         }
4536
4537         return newpath;
4538 }
4539
4540 /** Return true if there are no audio file sources that use @param name as
4541  * the filename component of their path.
4542  *
4543  * Return false otherwise.
4544  *
4545  * This method MUST ONLY be used to check in-session, mono files since it
4546  * hard-codes the channel of the audio file source we are looking for as zero.
4547  *
4548  * If/when Ardour supports native files in non-mono formats, the logic here
4549  * will need to be revisited.
4550  */
4551 bool
4552 Session::audio_source_name_is_unique (const string& name)
4553 {
4554         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4555         vector<space_and_path>::iterator i;
4556         uint32_t existing = 0;
4557
4558         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4559
4560                 /* note that we search *without* the extension so that
4561                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4562                    in the event that this new name is required for
4563                    a file format change.
4564                 */
4565
4566                 const string spath = *i;
4567
4568                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4569                         existing++;
4570                         break;
4571                 }
4572
4573                 /* it is possible that we have the path already
4574                  * assigned to a source that has not yet been written
4575                  * (ie. the write source for a diskstream). we have to
4576                  * check this in order to make sure that our candidate
4577                  * path isn't used again, because that can lead to
4578                  * two Sources point to the same file with different
4579                  * notions of their removability.
4580                  */
4581
4582
4583                 string possible_path = Glib::build_filename (spath, name);
4584
4585                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4586                         existing++;
4587                         break;
4588                 }
4589         }
4590
4591         return (existing == 0);
4592 }
4593
4594 string
4595 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)
4596 {
4597         ostringstream sstr;
4598         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4599
4600         if (Profile->get_trx() && destructive) {
4601                 sstr << 'T';
4602                 sstr << setfill ('0') << setw (4) << cnt;
4603                 sstr << legalized_base;
4604         } else {
4605                 sstr << legalized_base;
4606
4607                 if (take_required || related_exists) {
4608                         sstr << '-';
4609                         sstr << cnt;
4610                 }
4611         }
4612
4613         if (nchan == 2) {
4614                 if (chan == 0) {
4615                         sstr << "%L";
4616                 } else {
4617                         sstr << "%R";
4618                 }
4619         } else if (nchan > 2) {
4620                 if (nchan < 26) {
4621                         sstr << '%';
4622                         sstr << 'a' + chan;
4623                 } else {
4624                         /* XXX what? more than 26 channels! */
4625                         sstr << '%';
4626                         sstr << chan+1;
4627                 }
4628         }
4629
4630         sstr << ext;
4631
4632         return sstr.str();
4633 }
4634
4635 /** Return a unique name based on \a base for a new internal audio source */
4636 string
4637 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4638 {
4639         uint32_t cnt;
4640         string possible_name;
4641         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4642         string legalized;
4643         bool some_related_source_name_exists = false;
4644
4645         legalized = legalize_for_path (base);
4646
4647         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4648
4649         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4650
4651                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4652
4653                 if (audio_source_name_is_unique (possible_name)) {
4654                         break;
4655                 }
4656
4657                 some_related_source_name_exists = true;
4658
4659                 if (cnt > limit) {
4660                         error << string_compose(
4661                                         _("There are already %1 recordings for %2, which I consider too many."),
4662                                         limit, base) << endmsg;
4663                         destroy ();
4664                         throw failed_constructor();
4665                 }
4666         }
4667
4668         /* We've established that the new name does not exist in any session
4669          * directory, so now find out which one we should use for this new
4670          * audio source.
4671          */
4672
4673         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4674
4675         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4676
4677         return s;
4678 }
4679
4680 /** Return a unique name based on `base` for a new internal MIDI source */
4681 string
4682 Session::new_midi_source_path (const string& base)
4683 {
4684         uint32_t cnt;
4685         char buf[PATH_MAX+1];
4686         const uint32_t limit = 10000;
4687         string legalized;
4688         string possible_path;
4689         string possible_name;
4690
4691         buf[0] = '\0';
4692         legalized = legalize_for_path (base);
4693
4694         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4695         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4696
4697         /* - the main session folder is the first in the vector.
4698          * - after checking all locations for file-name uniqueness,
4699          *   we keep the one from the last iteration as new file name
4700          * - midi files are small and should just be kept in the main session-folder
4701          *
4702          * -> reverse the array, check main session folder last and use that as location
4703          *    for MIDI files.
4704          */
4705         std::reverse(sdirs.begin(), sdirs.end());
4706
4707         for (cnt = 1; cnt <= limit; ++cnt) {
4708
4709                 vector<space_and_path>::iterator i;
4710                 uint32_t existing = 0;
4711
4712                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4713
4714                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4715                         possible_name = buf;
4716
4717                         possible_path = Glib::build_filename (*i, possible_name);
4718
4719                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4720                                 existing++;
4721                         }
4722
4723                         if (midi_source_by_path (possible_path)) {
4724                                 existing++;
4725                         }
4726                 }
4727
4728                 if (existing == 0) {
4729                         break;
4730                 }
4731
4732                 if (cnt > limit) {
4733                         error << string_compose(
4734                                         _("There are already %1 recordings for %2, which I consider too many."),
4735                                         limit, base) << endmsg;
4736                         destroy ();
4737                         return 0;
4738                 }
4739         }
4740
4741         /* No need to "find best location" for software/app-based RAID, because
4742            MIDI is so small that we always put it in the same place.
4743         */
4744
4745         return possible_path;
4746 }
4747
4748
4749 /** Create a new within-session audio source */
4750 boost::shared_ptr<AudioFileSource>
4751 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4752 {
4753         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4754
4755         if (!path.empty()) {
4756                 return boost::dynamic_pointer_cast<AudioFileSource> (
4757                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
4758         } else {
4759                 throw failed_constructor ();
4760         }
4761 }
4762
4763 /** Create a new within-session MIDI source */
4764 boost::shared_ptr<MidiSource>
4765 Session::create_midi_source_for_session (string const & basic_name)
4766 {
4767         const string path = new_midi_source_path (basic_name);
4768
4769         if (!path.empty()) {
4770                 return boost::dynamic_pointer_cast<SMFSource> (
4771                         SourceFactory::createWritable (
4772                                 DataType::MIDI, *this, path, false, frame_rate()));
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_by_stealing_name (boost::shared_ptr<Track> track)
4781 {
4782         /* the caller passes in the track the source will be used in,
4783            so that we can keep the numbering sane.
4784
4785            Rationale: a track with the name "Foo" that has had N
4786            captures carried out so far will ALREADY have a write source
4787            named "Foo-N+1.mid" waiting to be used for the next capture.
4788
4789            If we call new_midi_source_name() we will get "Foo-N+2". But
4790            there is no region corresponding to "Foo-N+1", so when
4791            "Foo-N+2" appears in the track, the gap presents the user
4792            with odd behaviour - why did it skip past Foo-N+1?
4793
4794            We could explain this to the user in some odd way, but
4795            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4796            use "Foo-N+1" here.
4797
4798            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4799         */
4800
4801         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4802         assert (mt);
4803         std::string name = track->steal_write_source_name ();
4804
4805         if (name.empty()) {
4806                 return boost::shared_ptr<MidiSource>();
4807         }
4808
4809         /* MIDI files are small, just put them in the first location of the
4810            session source search path.
4811         */
4812
4813         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4814
4815         return boost::dynamic_pointer_cast<SMFSource> (
4816                 SourceFactory::createWritable (
4817                         DataType::MIDI, *this, path, false, frame_rate()));
4818 }
4819
4820
4821 void
4822 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4823 {
4824         if (playlist->hidden()) {
4825                 return;
4826         }
4827
4828         playlists->add (playlist);
4829
4830         if (unused) {
4831                 playlist->release();
4832         }
4833
4834         set_dirty();
4835 }
4836
4837 void
4838 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4839 {
4840         if (_state_of_the_state & Deletion) {
4841                 return;
4842         }
4843
4844         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4845
4846         if (!playlist) {
4847                 return;
4848         }
4849
4850         playlists->remove (playlist);
4851
4852         set_dirty();
4853 }
4854
4855 void
4856 Session::set_audition (boost::shared_ptr<Region> r)
4857 {
4858         pending_audition_region = r;
4859         add_post_transport_work (PostTransportAudition);
4860         _butler->schedule_transport_work ();
4861 }
4862
4863 void
4864 Session::audition_playlist ()
4865 {
4866         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4867         ev->region.reset ();
4868         queue_event (ev);
4869 }
4870
4871 void
4872 Session::non_realtime_set_audition ()
4873 {
4874         assert (pending_audition_region);
4875         auditioner->audition_region (pending_audition_region);
4876         pending_audition_region.reset ();
4877         AuditionActive (true); /* EMIT SIGNAL */
4878 }
4879
4880 void
4881 Session::audition_region (boost::shared_ptr<Region> r)
4882 {
4883         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4884         ev->region = r;
4885         queue_event (ev);
4886 }
4887
4888 void
4889 Session::cancel_audition ()
4890 {
4891         if (!auditioner) {
4892                 return;
4893         }
4894         if (auditioner->auditioning()) {
4895                 auditioner->cancel_audition ();
4896                 AuditionActive (false); /* EMIT SIGNAL */
4897         }
4898 }
4899
4900 bool
4901 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4902 {
4903         if (a->is_monitor()) {
4904                 return true;
4905         }
4906         if (b->is_monitor()) {
4907                 return false;
4908         }
4909         return a->order_key () < b->order_key ();
4910 }
4911
4912 bool
4913 Session::is_auditioning () const
4914 {
4915         /* can be called before we have an auditioner object */
4916         if (auditioner) {
4917                 return auditioner->auditioning();
4918         } else {
4919                 return false;
4920         }
4921 }
4922
4923 void
4924 Session::graph_reordered ()
4925 {
4926         /* don't do this stuff if we are setting up connections
4927            from a set_state() call or creating new tracks. Ditto for deletion.
4928         */
4929
4930         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
4931                 return;
4932         }
4933
4934         /* every track/bus asked for this to be handled but it was deferred because
4935            we were connecting. do it now.
4936         */
4937
4938         request_input_change_handling ();
4939
4940         resort_routes ();
4941
4942         /* force all diskstreams to update their capture offset values to
4943            reflect any changes in latencies within the graph.
4944         */
4945
4946         boost::shared_ptr<RouteList> rl = routes.reader ();
4947         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4948                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4949                 if (tr) {
4950                         tr->set_capture_offset ();
4951                 }
4952         }
4953 }
4954
4955 /** @return Number of frames that there is disk space available to write,
4956  *  if known.
4957  */
4958 boost::optional<framecnt_t>
4959 Session::available_capture_duration ()
4960 {
4961         Glib::Threads::Mutex::Lock lm (space_lock);
4962
4963         if (_total_free_4k_blocks_uncertain) {
4964                 return boost::optional<framecnt_t> ();
4965         }
4966
4967         float sample_bytes_on_disk = 4.0; // keep gcc happy
4968
4969         switch (config.get_native_file_data_format()) {
4970         case FormatFloat:
4971                 sample_bytes_on_disk = 4.0;
4972                 break;
4973
4974         case FormatInt24:
4975                 sample_bytes_on_disk = 3.0;
4976                 break;
4977
4978         case FormatInt16:
4979                 sample_bytes_on_disk = 2.0;
4980                 break;
4981
4982         default:
4983                 /* impossible, but keep some gcc versions happy */
4984                 fatal << string_compose (_("programming error: %1"),
4985                                          X_("illegal native file data format"))
4986                       << endmsg;
4987                 abort(); /*NOTREACHED*/
4988         }
4989
4990         double scale = 4096.0 / sample_bytes_on_disk;
4991
4992         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4993                 return max_framecnt;
4994         }
4995
4996         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4997 }
4998
4999 void
5000 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5001 {
5002         {
5003                 RCUWriter<BundleList> writer (_bundles);
5004                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5005                 b->push_back (bundle);
5006         }
5007
5008         if (emit_signal) {
5009                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5010         }
5011
5012         set_dirty();
5013 }
5014
5015 void
5016 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5017 {
5018         bool removed = false;
5019
5020         {
5021                 RCUWriter<BundleList> writer (_bundles);
5022                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5023                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5024
5025                 if (i != b->end()) {
5026                         b->erase (i);
5027                         removed = true;
5028                 }
5029         }
5030
5031         if (removed) {
5032                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5033         }
5034
5035         set_dirty();
5036 }
5037
5038 boost::shared_ptr<Bundle>
5039 Session::bundle_by_name (string name) const
5040 {
5041         boost::shared_ptr<BundleList> b = _bundles.reader ();
5042
5043         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5044                 if ((*i)->name() == name) {
5045                         return* i;
5046                 }
5047         }
5048
5049         return boost::shared_ptr<Bundle> ();
5050 }
5051
5052 void
5053 Session::tempo_map_changed (const PropertyChange&)
5054 {
5055         clear_clicks ();
5056
5057         playlists->update_after_tempo_map_change ();
5058
5059         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5060
5061         set_dirty ();
5062 }
5063
5064 void
5065 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5066 {
5067         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5068                 (*i)->recompute_frames_from_bbt ();
5069         }
5070 }
5071
5072 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5073  * the given count with the current block size.
5074  */
5075 void
5076 Session::ensure_buffers (ChanCount howmany)
5077 {
5078         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5079 }
5080
5081 void
5082 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5083 {
5084         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5085                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5086         }
5087 }
5088
5089 uint32_t
5090 Session::next_insert_id ()
5091 {
5092         /* this doesn't really loop forever. just think about it */
5093
5094         while (true) {
5095                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
5096                         if (!insert_bitset[n]) {
5097                                 insert_bitset[n] = true;
5098                                 return n;
5099
5100                         }
5101                 }
5102
5103                 /* none available, so resize and try again */
5104
5105                 insert_bitset.resize (insert_bitset.size() + 16, false);
5106         }
5107 }
5108
5109 uint32_t
5110 Session::next_send_id ()
5111 {
5112         /* this doesn't really loop forever. just think about it */
5113
5114         while (true) {
5115                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
5116                         if (!send_bitset[n]) {
5117                                 send_bitset[n] = true;
5118                                 return n;
5119
5120                         }
5121                 }
5122
5123                 /* none available, so resize and try again */
5124
5125                 send_bitset.resize (send_bitset.size() + 16, false);
5126         }
5127 }
5128
5129 uint32_t
5130 Session::next_aux_send_id ()
5131 {
5132         /* this doesn't really loop forever. just think about it */
5133
5134         while (true) {
5135                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
5136                         if (!aux_send_bitset[n]) {
5137                                 aux_send_bitset[n] = true;
5138                                 return n;
5139
5140                         }
5141                 }
5142
5143                 /* none available, so resize and try again */
5144
5145                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5146         }
5147 }
5148
5149 uint32_t
5150 Session::next_return_id ()
5151 {
5152         /* this doesn't really loop forever. just think about it */
5153
5154         while (true) {
5155                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
5156                         if (!return_bitset[n]) {
5157                                 return_bitset[n] = true;
5158                                 return n;
5159
5160                         }
5161                 }
5162
5163                 /* none available, so resize and try again */
5164
5165                 return_bitset.resize (return_bitset.size() + 16, false);
5166         }
5167 }
5168
5169 void
5170 Session::mark_send_id (uint32_t id)
5171 {
5172         if (id >= send_bitset.size()) {
5173                 send_bitset.resize (id+16, false);
5174         }
5175         if (send_bitset[id]) {
5176                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5177         }
5178         send_bitset[id] = true;
5179 }
5180
5181 void
5182 Session::mark_aux_send_id (uint32_t id)
5183 {
5184         if (id >= aux_send_bitset.size()) {
5185                 aux_send_bitset.resize (id+16, false);
5186         }
5187         if (aux_send_bitset[id]) {
5188                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5189         }
5190         aux_send_bitset[id] = true;
5191 }
5192
5193 void
5194 Session::mark_return_id (uint32_t id)
5195 {
5196         if (id >= return_bitset.size()) {
5197                 return_bitset.resize (id+16, false);
5198         }
5199         if (return_bitset[id]) {
5200                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5201         }
5202         return_bitset[id] = true;
5203 }
5204
5205 void
5206 Session::mark_insert_id (uint32_t id)
5207 {
5208         if (id >= insert_bitset.size()) {
5209                 insert_bitset.resize (id+16, false);
5210         }
5211         if (insert_bitset[id]) {
5212                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5213         }
5214         insert_bitset[id] = true;
5215 }
5216
5217 void
5218 Session::unmark_send_id (uint32_t id)
5219 {
5220         if (id < send_bitset.size()) {
5221                 send_bitset[id] = false;
5222         }
5223 }
5224
5225 void
5226 Session::unmark_aux_send_id (uint32_t id)
5227 {
5228         if (id < aux_send_bitset.size()) {
5229                 aux_send_bitset[id] = false;
5230         }
5231 }
5232
5233 void
5234 Session::unmark_return_id (uint32_t id)
5235 {
5236         if (id < return_bitset.size()) {
5237                 return_bitset[id] = false;
5238         }
5239 }
5240
5241 void
5242 Session::unmark_insert_id (uint32_t id)
5243 {
5244         if (id < insert_bitset.size()) {
5245                 insert_bitset[id] = false;
5246         }
5247 }
5248
5249 void
5250 Session::reset_native_file_format ()
5251 {
5252         boost::shared_ptr<RouteList> rl = routes.reader ();
5253
5254         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5255                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5256                 if (tr) {
5257                         /* don't save state as we do this, there's no point
5258                          */
5259                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5260                         tr->reset_write_sources (false);
5261                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5262                 }
5263         }
5264 }
5265
5266 bool
5267 Session::route_name_unique (string n) const
5268 {
5269         boost::shared_ptr<RouteList> r = routes.reader ();
5270
5271         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5272                 if ((*i)->name() == n) {
5273                         return false;
5274                 }
5275         }
5276
5277         return true;
5278 }
5279
5280 bool
5281 Session::route_name_internal (string n) const
5282 {
5283         if (auditioner && auditioner->name() == n) {
5284                 return true;
5285         }
5286
5287         if (_click_io && _click_io->name() == n) {
5288                 return true;
5289         }
5290
5291         return false;
5292 }
5293
5294 int
5295 Session::freeze_all (InterThreadInfo& itt)
5296 {
5297         boost::shared_ptr<RouteList> r = routes.reader ();
5298
5299         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5300
5301                 boost::shared_ptr<Track> t;
5302
5303                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5304                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5305                            of every track.
5306                         */
5307                         t->freeze_me (itt);
5308                 }
5309         }
5310
5311         return 0;
5312 }
5313
5314 boost::shared_ptr<Region>
5315 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5316                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5317                           InterThreadInfo& itt,
5318                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5319                           bool for_export, bool for_freeze)
5320 {
5321         boost::shared_ptr<Region> result;
5322         boost::shared_ptr<Playlist> playlist;
5323         boost::shared_ptr<Source> source;
5324         ChanCount diskstream_channels (track.n_channels());
5325         framepos_t position;
5326         framecnt_t this_chunk;
5327         framepos_t to_do;
5328         framepos_t latency_skip;
5329         BufferSet buffers;
5330         framepos_t len = end - start;
5331         bool need_block_size_reset = false;
5332         ChanCount const max_proc = track.max_processor_streams ();
5333         string legal_playlist_name;
5334         string possible_path;
5335
5336         if (end <= start) {
5337                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5338                                          end, start) << endmsg;
5339                 return result;
5340         }
5341
5342         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5343                         include_endpoint, for_export, for_freeze);
5344
5345         if (diskstream_channels.n(track.data_type()) < 1) {
5346                 error << _("Cannot write a range with no data.") << endmsg;
5347                 return result;
5348         }
5349
5350         // block all process callback handling
5351
5352         block_processing ();
5353
5354         {
5355                 // synchronize with AudioEngine::process_callback()
5356                 // make sure processing is not currently running
5357                 // and processing_blocked() is honored before
5358                 // acquiring thread buffers
5359                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5360         }
5361
5362         _bounce_processing_active = true;
5363
5364         /* call tree *MUST* hold route_lock */
5365
5366         if ((playlist = track.playlist()) == 0) {
5367                 goto out;
5368         }
5369
5370         legal_playlist_name = legalize_for_path (playlist->name());
5371
5372         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5373
5374                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5375                 string path = ((track.data_type() == DataType::AUDIO)
5376                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5377                                : new_midi_source_path (legal_playlist_name));
5378
5379                 if (path.empty()) {
5380                         goto out;
5381                 }
5382
5383                 try {
5384                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5385                 }
5386
5387                 catch (failed_constructor& err) {
5388                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5389                         goto out;
5390                 }
5391
5392                 srcs.push_back (source);
5393         }
5394
5395         /* tell redirects that care that we are about to use a much larger
5396          * blocksize. this will flush all plugins too, so that they are ready
5397          * to be used for this process.
5398          */
5399
5400         need_block_size_reset = true;
5401         track.set_block_size (bounce_chunk_size);
5402         _engine.main_thread()->get_buffers ();
5403
5404         position = start;
5405         to_do = len;
5406         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5407
5408         /* create a set of reasonably-sized buffers */
5409         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5410                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5411         }
5412         buffers.set_count (max_proc);
5413
5414         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5415                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5416                 boost::shared_ptr<MidiSource> ms;
5417                 if (afs) {
5418                         afs->prepare_for_peakfile_writes ();
5419                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5420                         Source::Lock lock(ms->mutex());
5421                         ms->mark_streaming_write_started(lock);
5422                 }
5423         }
5424
5425         while (to_do && !itt.cancel) {
5426
5427                 this_chunk = min (to_do, bounce_chunk_size);
5428
5429                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5430                         goto out;
5431                 }
5432
5433                 start += this_chunk;
5434                 to_do -= this_chunk;
5435                 itt.progress = (float) (1.0 - ((double) to_do / len));
5436
5437                 if (latency_skip >= bounce_chunk_size) {
5438                         latency_skip -= bounce_chunk_size;
5439                         continue;
5440                 }
5441
5442                 const framecnt_t current_chunk = this_chunk - latency_skip;
5443
5444                 uint32_t n = 0;
5445                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5446                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5447                         boost::shared_ptr<MidiSource> ms;
5448
5449                         if (afs) {
5450                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5451                                         goto out;
5452                                 }
5453                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5454                                 Source::Lock lock(ms->mutex());
5455
5456                                 const MidiBuffer& buf = buffers.get_midi(0);
5457                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5458                                         Evoral::Event<framepos_t> ev = *i;
5459                                         ev.set_time(ev.time() - position);
5460                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5461                                 }
5462                         }
5463                 }
5464                 latency_skip = 0;
5465         }
5466
5467         /* post-roll, pick up delayed processor output */
5468         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5469
5470         while (latency_skip && !itt.cancel) {
5471                 this_chunk = min (latency_skip, bounce_chunk_size);
5472                 latency_skip -= this_chunk;
5473
5474                 buffers.silence (this_chunk, 0);
5475                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5476
5477                 uint32_t n = 0;
5478                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5479                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5480
5481                         if (afs) {
5482                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5483                                         goto out;
5484                                 }
5485                         }
5486                 }
5487         }
5488
5489         if (!itt.cancel) {
5490
5491                 time_t now;
5492                 struct tm* xnow;
5493                 time (&now);
5494                 xnow = localtime (&now);
5495
5496                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5497                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5498                         boost::shared_ptr<MidiSource> ms;
5499
5500                         if (afs) {
5501                                 afs->update_header (position, *xnow, now);
5502                                 afs->flush_header ();
5503                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5504                                 Source::Lock lock(ms->mutex());
5505                                 ms->mark_streaming_write_completed(lock);
5506                         }
5507                 }
5508
5509                 /* construct a region to represent the bounced material */
5510
5511                 PropertyList plist;
5512
5513                 plist.add (Properties::start, 0);
5514                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5515                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5516
5517                 result = RegionFactory::create (srcs, plist);
5518
5519         }
5520
5521   out:
5522         if (!result) {
5523                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5524                         (*src)->mark_for_remove ();
5525                         (*src)->drop_references ();
5526                 }
5527
5528         } else {
5529                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5530                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5531
5532                         if (afs)
5533                                 afs->done_with_peakfile_writes ();
5534                 }
5535         }
5536
5537         _bounce_processing_active = false;
5538
5539         if (need_block_size_reset) {
5540                 _engine.main_thread()->drop_buffers ();
5541                 track.set_block_size (get_block_size());
5542         }
5543
5544         unblock_processing ();
5545
5546         return result;
5547 }
5548
5549 gain_t*
5550 Session::gain_automation_buffer() const
5551 {
5552         return ProcessThread::gain_automation_buffer ();
5553 }
5554
5555 gain_t*
5556 Session::trim_automation_buffer() const
5557 {
5558         return ProcessThread::trim_automation_buffer ();
5559 }
5560
5561 gain_t*
5562 Session::send_gain_automation_buffer() const
5563 {
5564         return ProcessThread::send_gain_automation_buffer ();
5565 }
5566
5567 pan_t**
5568 Session::pan_automation_buffer() const
5569 {
5570         return ProcessThread::pan_automation_buffer ();
5571 }
5572
5573 BufferSet&
5574 Session::get_silent_buffers (ChanCount count)
5575 {
5576         return ProcessThread::get_silent_buffers (count);
5577 }
5578
5579 BufferSet&
5580 Session::get_scratch_buffers (ChanCount count, bool silence)
5581 {
5582         return ProcessThread::get_scratch_buffers (count, silence);
5583 }
5584
5585 BufferSet&
5586 Session::get_route_buffers (ChanCount count, bool silence)
5587 {
5588         return ProcessThread::get_route_buffers (count, silence);
5589 }
5590
5591
5592 BufferSet&
5593 Session::get_mix_buffers (ChanCount count)
5594 {
5595         return ProcessThread::get_mix_buffers (count);
5596 }
5597
5598 uint32_t
5599 Session::ntracks () const
5600 {
5601         uint32_t n = 0;
5602         boost::shared_ptr<RouteList> r = routes.reader ();
5603
5604         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5605                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5606                         ++n;
5607                 }
5608         }
5609
5610         return n;
5611 }
5612
5613 uint32_t
5614 Session::nbusses () 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) == 0) {
5621                         ++n;
5622                 }
5623         }
5624
5625         return n;
5626 }
5627
5628 void
5629 Session::add_automation_list(AutomationList *al)
5630 {
5631         automation_lists[al->id()] = al;
5632 }
5633
5634 /** @return true if there is at least one record-enabled track, otherwise false */
5635 bool
5636 Session::have_rec_enabled_track () const
5637 {
5638         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5639 }
5640
5641 bool
5642 Session::have_rec_disabled_track () const
5643 {
5644     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5645 }
5646
5647 /** Update the state of our rec-enabled tracks flag */
5648 void
5649 Session::update_route_record_state ()
5650 {
5651         boost::shared_ptr<RouteList> rl = routes.reader ();
5652         RouteList::iterator i = rl->begin();
5653         while (i != rl->end ()) {
5654
5655                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5656                 if (tr && tr->record_enabled ()) {
5657                         break;
5658                 }
5659
5660                 ++i;
5661         }
5662
5663         int const old = g_atomic_int_get (&_have_rec_enabled_track);
5664
5665         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5666
5667         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5668                 RecordStateChanged (); /* EMIT SIGNAL */
5669         }
5670
5671         for (i = rl->begin(); i != rl->end (); ++i) {
5672                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5673                 if (tr && !tr->record_enabled ()) {
5674                         break;
5675                 }
5676         }
5677
5678         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5679
5680         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
5681
5682         if (record_status() == Recording && record_arm_state_changed ) {
5683                 RecordArmStateChanged ();
5684         }
5685
5686 }
5687
5688 void
5689 Session::listen_position_changed ()
5690 {
5691         boost::shared_ptr<RouteList> r = routes.reader ();
5692
5693         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5694                 (*i)->listen_position_changed ();
5695         }
5696 }
5697
5698 void
5699 Session::solo_control_mode_changed ()
5700 {
5701         /* cancel all solo or all listen when solo control mode changes */
5702
5703         if (soloing()) {
5704                 set_solo (get_routes(), false);
5705         } else if (listening()) {
5706                 set_listen (get_routes(), false);
5707         }
5708 }
5709
5710 /** Called when a property of one of our route groups changes */
5711 void
5712 Session::route_group_property_changed (RouteGroup* rg)
5713 {
5714         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5715 }
5716
5717 /** Called when a route is added to one of our route groups */
5718 void
5719 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5720 {
5721         RouteAddedToRouteGroup (rg, r);
5722 }
5723
5724 /** Called when a route is removed from one of our route groups */
5725 void
5726 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5727 {
5728         update_route_record_state ();
5729         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5730 }
5731
5732 boost::shared_ptr<RouteList>
5733 Session::get_tracks () const
5734 {
5735         boost::shared_ptr<RouteList> rl = routes.reader ();
5736         boost::shared_ptr<RouteList> tl (new RouteList);
5737
5738         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5739                 if (boost::dynamic_pointer_cast<Track> (*r)) {
5740                         if (!(*r)->is_auditioner()) {
5741                                 tl->push_back (*r);
5742                         }
5743                 }
5744         }
5745         return tl;
5746 }
5747
5748 boost::shared_ptr<RouteList>
5749 Session::get_routes_with_regions_at (framepos_t const p) const
5750 {
5751         boost::shared_ptr<RouteList> r = routes.reader ();
5752         boost::shared_ptr<RouteList> rl (new RouteList);
5753
5754         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5755                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5756                 if (!tr) {
5757                         continue;
5758                 }
5759
5760                 boost::shared_ptr<Playlist> pl = tr->playlist ();
5761                 if (!pl) {
5762                         continue;
5763                 }
5764
5765                 if (pl->has_region_at (p)) {
5766                         rl->push_back (*i);
5767                 }
5768         }
5769
5770         return rl;
5771 }
5772
5773 void
5774 Session::goto_end ()
5775 {
5776         if (_session_range_location) {
5777                 request_locate (_session_range_location->end(), false);
5778         } else {
5779                 request_locate (0, false);
5780         }
5781 }
5782
5783 void
5784 Session::goto_start ()
5785 {
5786         if (_session_range_location) {
5787                 request_locate (_session_range_location->start(), false);
5788         } else {
5789                 request_locate (0, false);
5790         }
5791 }
5792
5793 framepos_t
5794 Session::current_start_frame () const
5795 {
5796         return _session_range_location ? _session_range_location->start() : 0;
5797 }
5798
5799 framepos_t
5800 Session::current_end_frame () const
5801 {
5802         return _session_range_location ? _session_range_location->end() : 0;
5803 }
5804
5805 void
5806 Session::set_session_range_location (framepos_t start, framepos_t end)
5807 {
5808         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5809         _locations->add (_session_range_location);
5810 }
5811
5812 void
5813 Session::step_edit_status_change (bool yn)
5814 {
5815         bool send = false;
5816
5817         bool val = false;
5818         if (yn) {
5819                 send = (_step_editors == 0);
5820                 val = true;
5821
5822                 _step_editors++;
5823         } else {
5824                 send = (_step_editors == 1);
5825                 val = false;
5826
5827                 if (_step_editors > 0) {
5828                         _step_editors--;
5829                 }
5830         }
5831
5832         if (send) {
5833                 StepEditStatusChange (val);
5834         }
5835 }
5836
5837
5838 void
5839 Session::start_time_changed (framepos_t old)
5840 {
5841         /* Update the auto loop range to match the session range
5842            (unless the auto loop range has been changed by the user)
5843         */
5844
5845         Location* s = _locations->session_range_location ();
5846         if (s == 0) {
5847                 return;
5848         }
5849
5850         Location* l = _locations->auto_loop_location ();
5851
5852         if (l && l->start() == old) {
5853                 l->set_start (s->start(), true);
5854         }
5855 }
5856
5857 void
5858 Session::end_time_changed (framepos_t old)
5859 {
5860         /* Update the auto loop range to match the session range
5861            (unless the auto loop range has been changed by the user)
5862         */
5863
5864         Location* s = _locations->session_range_location ();
5865         if (s == 0) {
5866                 return;
5867         }
5868
5869         Location* l = _locations->auto_loop_location ();
5870
5871         if (l && l->end() == old) {
5872                 l->set_end (s->end(), true);
5873         }
5874 }
5875
5876 std::vector<std::string>
5877 Session::source_search_path (DataType type) const
5878 {
5879         Searchpath sp;
5880
5881         if (session_dirs.size() == 1) {
5882                 switch (type) {
5883                 case DataType::AUDIO:
5884                         sp.push_back (_session_dir->sound_path());
5885                         break;
5886                 case DataType::MIDI:
5887                         sp.push_back (_session_dir->midi_path());
5888                         break;
5889                 }
5890         } else {
5891                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5892                         SessionDirectory sdir (i->path);
5893                         switch (type) {
5894                         case DataType::AUDIO:
5895                                 sp.push_back (sdir.sound_path());
5896                                 break;
5897                         case DataType::MIDI:
5898                                 sp.push_back (sdir.midi_path());
5899                                 break;
5900                         }
5901                 }
5902         }
5903
5904         if (type == DataType::AUDIO) {
5905                 const string sound_path_2X = _session_dir->sound_path_2X();
5906                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5907                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5908                                 sp.push_back (sound_path_2X);
5909                         }
5910                 }
5911         }
5912
5913         // now check the explicit (possibly user-specified) search path
5914
5915         switch (type) {
5916         case DataType::AUDIO:
5917                 sp += Searchpath(config.get_audio_search_path ());
5918                 break;
5919         case DataType::MIDI:
5920                 sp += Searchpath(config.get_midi_search_path ());
5921                 break;
5922         }
5923
5924         return sp;
5925 }
5926
5927 void
5928 Session::ensure_search_path_includes (const string& path, DataType type)
5929 {
5930         Searchpath sp;
5931
5932         if (path == ".") {
5933                 return;
5934         }
5935
5936         switch (type) {
5937         case DataType::AUDIO:
5938                 sp += Searchpath(config.get_audio_search_path ());
5939                 break;
5940         case DataType::MIDI:
5941                 sp += Searchpath (config.get_midi_search_path ());
5942                 break;
5943         }
5944
5945         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5946                 /* No need to add this new directory if it has the same inode as
5947                    an existing one; checking inode rather than name prevents duplicated
5948                    directories when we are using symlinks.
5949
5950                    On Windows, I think we could just do if (*i == path) here.
5951                 */
5952                 if (PBD::equivalent_paths (*i, path)) {
5953                         return;
5954                 }
5955         }
5956
5957         sp += path;
5958
5959         switch (type) {
5960         case DataType::AUDIO:
5961                 config.set_audio_search_path (sp.to_string());
5962                 break;
5963         case DataType::MIDI:
5964                 config.set_midi_search_path (sp.to_string());
5965                 break;
5966         }
5967 }
5968
5969 void
5970 Session::remove_dir_from_search_path (const string& dir, DataType type)
5971 {
5972         Searchpath sp;
5973
5974         switch (type) {
5975         case DataType::AUDIO:
5976                 sp = Searchpath(config.get_audio_search_path ());
5977                 break;
5978         case DataType::MIDI:
5979                 sp = Searchpath (config.get_midi_search_path ());
5980                 break;
5981         }
5982
5983         sp -= dir;
5984
5985         switch (type) {
5986         case DataType::AUDIO:
5987                 config.set_audio_search_path (sp.to_string());
5988                 break;
5989         case DataType::MIDI:
5990                 config.set_midi_search_path (sp.to_string());
5991                 break;
5992         }
5993
5994 }
5995
5996 boost::shared_ptr<Speakers>
5997 Session::get_speakers()
5998 {
5999         return _speakers;
6000 }
6001
6002 list<string>
6003 Session::unknown_processors () const
6004 {
6005         list<string> p;
6006
6007         boost::shared_ptr<RouteList> r = routes.reader ();
6008         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6009                 list<string> t = (*i)->unknown_processors ();
6010                 copy (t.begin(), t.end(), back_inserter (p));
6011         }
6012
6013         p.sort ();
6014         p.unique ();
6015
6016         return p;
6017 }
6018
6019 void
6020 Session::update_latency (bool playback)
6021 {
6022         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6023
6024         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
6025                 return;
6026         }
6027
6028         boost::shared_ptr<RouteList> r = routes.reader ();
6029         framecnt_t max_latency = 0;
6030
6031         if (playback) {
6032                 /* reverse the list so that we work backwards from the last route to run to the first */
6033                 RouteList* rl = routes.reader().get();
6034                 r.reset (new RouteList (*rl));
6035                 reverse (r->begin(), r->end());
6036         }
6037
6038         /* compute actual latency values for the given direction and store them all in per-port
6039            structures. this will also publish the same values (to JACK) so that computation of latency
6040            for routes can consistently use public latency values.
6041         */
6042
6043         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6044                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6045         }
6046
6047         /* because we latency compensate playback, our published playback latencies should
6048            be the same for all output ports - all material played back by ardour has
6049            the same latency, whether its caused by plugins or by latency compensation. since
6050            these may differ from the values computed above, reset all playback port latencies
6051            to the same value.
6052         */
6053
6054         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6055
6056         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6057                 (*i)->set_public_port_latencies (max_latency, playback);
6058         }
6059
6060         if (playback) {
6061
6062                 post_playback_latency ();
6063
6064         } else {
6065
6066                 post_capture_latency ();
6067         }
6068
6069         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6070 }
6071
6072 void
6073 Session::post_playback_latency ()
6074 {
6075         set_worst_playback_latency ();
6076
6077         boost::shared_ptr<RouteList> r = routes.reader ();
6078
6079         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6080                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6081                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6082                 }
6083         }
6084
6085         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6086                 (*i)->set_latency_compensation (_worst_track_latency);
6087         }
6088 }
6089
6090 void
6091 Session::post_capture_latency ()
6092 {
6093         set_worst_capture_latency ();
6094
6095         /* reflect any changes in capture latencies into capture offsets
6096          */
6097
6098         boost::shared_ptr<RouteList> rl = routes.reader();
6099         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6100                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6101                 if (tr) {
6102                         tr->set_capture_offset ();
6103                 }
6104         }
6105 }
6106
6107 void
6108 Session::initialize_latencies ()
6109 {
6110         {
6111                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6112                 update_latency (false);
6113                 update_latency (true);
6114         }
6115
6116         set_worst_io_latencies ();
6117 }
6118
6119 void
6120 Session::set_worst_io_latencies ()
6121 {
6122         set_worst_playback_latency ();
6123         set_worst_capture_latency ();
6124 }
6125
6126 void
6127 Session::set_worst_playback_latency ()
6128 {
6129         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6130                 return;
6131         }
6132
6133         _worst_output_latency = 0;
6134
6135         if (!_engine.connected()) {
6136                 return;
6137         }
6138
6139         boost::shared_ptr<RouteList> r = routes.reader ();
6140
6141         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6142                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6143         }
6144
6145         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6146 }
6147
6148 void
6149 Session::set_worst_capture_latency ()
6150 {
6151         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6152                 return;
6153         }
6154
6155         _worst_input_latency = 0;
6156
6157         if (!_engine.connected()) {
6158                 return;
6159         }
6160
6161         boost::shared_ptr<RouteList> r = routes.reader ();
6162
6163         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6164                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6165         }
6166
6167         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6168 }
6169
6170 void
6171 Session::update_latency_compensation (bool force_whole_graph)
6172 {
6173         bool some_track_latency_changed = false;
6174
6175         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6176                 return;
6177         }
6178
6179         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6180
6181         _worst_track_latency = 0;
6182
6183         boost::shared_ptr<RouteList> r = routes.reader ();
6184
6185         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6186                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6187                         framecnt_t tl;
6188                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6189                                 some_track_latency_changed = true;
6190                         }
6191                         _worst_track_latency = max (tl, _worst_track_latency);
6192                 }
6193         }
6194
6195         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6196                                                      (some_track_latency_changed ? "yes" : "no")));
6197
6198         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6199
6200         if (some_track_latency_changed || force_whole_graph)  {
6201                 _engine.update_latencies ();
6202         }
6203
6204
6205         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6206                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6207                 if (!tr) {
6208                         continue;
6209                 }
6210                 tr->set_capture_offset ();
6211         }
6212 }
6213
6214 char
6215 Session::session_name_is_legal (const string& path)
6216 {
6217         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6218
6219         for (int i = 0; illegal_chars[i]; ++i) {
6220                 if (path.find (illegal_chars[i]) != string::npos) {
6221                         return illegal_chars[i];
6222                 }
6223         }
6224
6225         return 0;
6226 }
6227
6228 uint32_t
6229 Session::next_control_id () const
6230 {
6231         int subtract = 0;
6232
6233         /* the monitor bus remote ID is in a different
6234          * "namespace" than regular routes. its existence doesn't
6235          * affect normal (low) numbered routes.
6236          */
6237
6238         if (_monitor_out) {
6239                 subtract++;
6240         }
6241
6242         /* the same about masterbus in Waves Tracks */
6243
6244         if (Profile->get_trx() && _master_out) {
6245                 subtract++;
6246         }
6247
6248         return nroutes() - subtract;
6249 }
6250
6251 void
6252 Session::notify_remote_id_change ()
6253 {
6254         if (deletion_in_progress()) {
6255                 return;
6256         }
6257
6258         switch (Config->get_remote_model()) {
6259         case MixerOrdered:
6260                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6261                 break;
6262         default:
6263                 break;
6264         }
6265
6266 #ifdef USE_TRACKS_CODE_FEATURES
6267                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6268                  * if track order has been changed by user
6269                  */
6270                 reconnect_existing_routes(true, true);
6271 #endif
6272
6273 }
6274
6275 void
6276 Session::sync_order_keys ()
6277 {
6278         if (deletion_in_progress()) {
6279                 return;
6280         }
6281
6282         /* tell everyone that something has happened to the sort keys
6283            and let them sync up with the change(s)
6284            this will give objects that manage the sort order keys the
6285            opportunity to keep them in sync if they wish to.
6286         */
6287
6288         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6289
6290         reassign_track_numbers();
6291
6292         Route::SyncOrderKeys (); /* EMIT SIGNAL */
6293
6294         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6295 }
6296
6297 bool
6298 Session::operation_in_progress (GQuark op) const
6299 {
6300         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6301 }
6302
6303 boost::shared_ptr<Port>
6304 Session::ltc_input_port () const
6305 {
6306         return _ltc_input->nth (0);
6307 }
6308
6309 boost::shared_ptr<Port>
6310 Session::ltc_output_port () const
6311 {
6312         return _ltc_output->nth (0);
6313 }
6314
6315 void
6316 Session::reconnect_ltc_input ()
6317 {
6318         if (_ltc_input) {
6319
6320                 string src = Config->get_ltc_source_port();
6321
6322                 _ltc_input->disconnect (this);
6323
6324                 if (src != _("None") && !src.empty())  {
6325                         _ltc_input->nth (0)->connect (src);
6326                 }
6327
6328                 if ( ARDOUR::Profile->get_trx () ) {
6329                         // Tracks need this signal to update timecode_source_dropdown
6330                         MtcOrLtcInputPortChanged (); //emit signal
6331                 }
6332         }
6333 }
6334
6335 void
6336 Session::reconnect_ltc_output ()
6337 {
6338         if (_ltc_output) {
6339
6340                 string src = Config->get_ltc_output_port();
6341
6342                 _ltc_output->disconnect (this);
6343
6344                 if (src != _("None") && !src.empty())  {
6345                         _ltc_output->nth (0)->connect (src);
6346                 }
6347         }
6348 }
6349
6350 void
6351 Session::set_range_selection (framepos_t start, framepos_t end)
6352 {
6353         _range_selection = Evoral::Range<framepos_t> (start, end);
6354 #ifdef USE_TRACKS_CODE_FEATURES
6355         follow_playhead_priority ();
6356 #endif
6357 }
6358
6359 void
6360 Session::set_object_selection (framepos_t start, framepos_t end)
6361 {
6362         _object_selection = Evoral::Range<framepos_t> (start, end);
6363 #ifdef USE_TRACKS_CODE_FEATURES
6364         follow_playhead_priority ();
6365 #endif
6366 }
6367
6368 void
6369 Session::clear_range_selection ()
6370 {
6371         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6372 #ifdef USE_TRACKS_CODE_FEATURES
6373         follow_playhead_priority ();
6374 #endif
6375 }
6376
6377 void
6378 Session::clear_object_selection ()
6379 {
6380         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6381 #ifdef USE_TRACKS_CODE_FEATURES
6382         follow_playhead_priority ();
6383 #endif
6384 }