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