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 (_transport_speed) {
1872                 if (!config.get_punch_in()) {
1873                         enable_record ();
1874                 }
1875         } else {
1876                 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1877                 RecordStateChanged (); /* EMIT SIGNAL */
1878         }
1879
1880         set_dirty();
1881 }
1882
1883 framepos_t
1884 Session::audible_frame () const
1885 {
1886         framepos_t ret;
1887         framepos_t tf;
1888         framecnt_t offset;
1889
1890         offset = worst_playback_latency ();
1891
1892         if (synced_to_engine()) {
1893                 /* Note: this is basically just sync-to-JACK */
1894                 tf = _engine.transport_frame();
1895         } else {
1896                 tf = _transport_frame;
1897         }
1898
1899         ret = tf;
1900
1901         if (!non_realtime_work_pending()) {
1902
1903                 /* MOVING */
1904
1905                 /* Check to see if we have passed the first guaranteed
1906                    audible frame past our last start position. if not,
1907                    return that last start point because in terms
1908                    of audible frames, we have not moved yet.
1909
1910                    `Start position' in this context means the time we last
1911                    either started, located, or changed transport direction.
1912                 */
1913
1914                 if (_transport_speed > 0.0f) {
1915
1916                         if (!play_loop || !have_looped) {
1917                                 if (tf < _last_roll_or_reversal_location + offset) {
1918                                         return _last_roll_or_reversal_location;
1919                                 }
1920                         }
1921
1922
1923                         /* forwards */
1924                         ret -= offset;
1925
1926                 } else if (_transport_speed < 0.0f) {
1927
1928                         /* XXX wot? no backward looping? */
1929
1930                         if (tf > _last_roll_or_reversal_location - offset) {
1931                                 return _last_roll_or_reversal_location;
1932                         } else {
1933                                 /* backwards */
1934                                 ret += offset;
1935                         }
1936                 }
1937         }
1938
1939         return ret;
1940 }
1941
1942 void
1943 Session::set_frame_rate (framecnt_t frames_per_second)
1944 {
1945         /** \fn void Session::set_frame_size(framecnt_t)
1946                 the AudioEngine object that calls this guarantees
1947                 that it will not be called while we are also in
1948                 ::process(). Its fine to do things that block
1949                 here.
1950         */
1951
1952         _base_frame_rate = frames_per_second;
1953         _nominal_frame_rate = frames_per_second;
1954
1955         sync_time_vars();
1956
1957         clear_clicks ();
1958         reset_write_sources (false);
1959
1960         // XXX we need some equivalent to this, somehow
1961         // SndFileSource::setup_standard_crossfades (frames_per_second);
1962
1963         set_dirty();
1964
1965         /* XXX need to reset/reinstantiate all LADSPA plugins */
1966 }
1967
1968 void
1969 Session::set_block_size (pframes_t nframes)
1970 {
1971         /* the AudioEngine guarantees
1972            that it will not be called while we are also in
1973            ::process(). It is therefore fine to do things that block
1974            here.
1975         */
1976
1977         {
1978                 current_block_size = nframes;
1979
1980                 ensure_buffers ();
1981
1982                 boost::shared_ptr<RouteList> r = routes.reader ();
1983
1984                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1985                         (*i)->set_block_size (nframes);
1986                 }
1987
1988                 boost::shared_ptr<RouteList> rl = routes.reader ();
1989                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1990                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1991                         if (tr) {
1992                                 tr->set_block_size (nframes);
1993                         }
1994                 }
1995
1996                 set_worst_io_latencies ();
1997         }
1998 }
1999
2000
2001 static void
2002 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2003 {
2004         boost::shared_ptr<Route> r2;
2005
2006         if (r1->feeds (rbase) && rbase->feeds (r1)) {
2007                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2008                 return;
2009         }
2010
2011         /* make a copy of the existing list of routes that feed r1 */
2012
2013         Route::FedBy existing (r1->fed_by());
2014
2015         /* for each route that feeds r1, recurse, marking it as feeding
2016            rbase as well.
2017         */
2018
2019         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2020                 if (!(r2 = i->r.lock ())) {
2021                         /* (*i) went away, ignore it */
2022                         continue;
2023                 }
2024
2025                 /* r2 is a route that feeds r1 which somehow feeds base. mark
2026                    base as being fed by r2
2027                 */
2028
2029                 rbase->add_fed_by (r2, i->sends_only);
2030
2031                 if (r2 != rbase) {
2032
2033                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2034                            stop here.
2035                         */
2036
2037                         if (r1->feeds (r2) && r2->feeds (r1)) {
2038                                 continue;
2039                         }
2040
2041                         /* now recurse, so that we can mark base as being fed by
2042                            all routes that feed r2
2043                         */
2044
2045                         trace_terminal (r2, rbase);
2046                 }
2047
2048         }
2049 }
2050
2051 void
2052 Session::resort_routes ()
2053 {
2054         /* don't do anything here with signals emitted
2055            by Routes during initial setup or while we
2056            are being destroyed.
2057         */
2058
2059         if (_state_of_the_state & (InitialConnecting | Deletion)) {
2060                 return;
2061         }
2062
2063         {
2064                 RCUWriter<RouteList> writer (routes);
2065                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2066                 resort_routes_using (r);
2067                 /* writer goes out of scope and forces update */
2068         }
2069
2070 #ifndef NDEBUG
2071         boost::shared_ptr<RouteList> rl = routes.reader ();
2072         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2073                 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2074
2075                 const Route::FedBy& fb ((*i)->fed_by());
2076
2077                 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2078                         boost::shared_ptr<Route> sf = f->r.lock();
2079                         if (sf) {
2080                                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2081                         }
2082                 }
2083         }
2084 #endif
2085
2086 }
2087
2088 /** This is called whenever we need to rebuild the graph of how we will process
2089  *  routes.
2090  *  @param r List of routes, in any order.
2091  */
2092
2093 void
2094 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2095 {
2096         /* We are going to build a directed graph of our routes;
2097            this is where the edges of that graph are put.
2098         */
2099
2100         GraphEdges edges;
2101
2102         /* Go through all routes doing two things:
2103          *
2104          * 1. Collect the edges of the route graph.  Each of these edges
2105          *    is a pair of routes, one of which directly feeds the other
2106          *    either by a JACK connection or by an internal send.
2107          *
2108          * 2. Begin the process of making routes aware of which other
2109          *    routes directly or indirectly feed them.  This information
2110          *    is used by the solo code.
2111          */
2112
2113         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2114
2115                 /* Clear out the route's list of direct or indirect feeds */
2116                 (*i)->clear_fed_by ();
2117
2118                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2119
2120                         bool via_sends_only;
2121
2122                         /* See if this *j feeds *i according to the current state of the JACK
2123                            connections and internal sends.
2124                         */
2125                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2126                                 /* add the edge to the graph (part #1) */
2127                                 edges.add (*j, *i, via_sends_only);
2128                                 /* tell the route (for part #2) */
2129                                 (*i)->add_fed_by (*j, via_sends_only);
2130                         }
2131                 }
2132         }
2133
2134         /* Attempt a topological sort of the route graph */
2135         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2136
2137         if (sorted_routes) {
2138                 /* We got a satisfactory topological sort, so there is no feedback;
2139                    use this new graph.
2140
2141                    Note: the process graph rechain does not require a
2142                    topologically-sorted list, but hey ho.
2143                 */
2144                 if (_process_graph) {
2145                         _process_graph->rechain (sorted_routes, edges);
2146                 }
2147
2148                 _current_route_graph = edges;
2149
2150                 /* Complete the building of the routes' lists of what directly
2151                    or indirectly feeds them.
2152                 */
2153                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2154                         trace_terminal (*i, *i);
2155                 }
2156
2157                 *r = *sorted_routes;
2158
2159 #ifndef NDEBUG
2160                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2161                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2162                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
2163                                                                    (*i)->name(), (*i)->order_key ()));
2164                 }
2165 #endif
2166
2167                 SuccessfulGraphSort (); /* EMIT SIGNAL */
2168
2169         } else {
2170                 /* The topological sort failed, so we have a problem.  Tell everyone
2171                    and stick to the old graph; this will continue to be processed, so
2172                    until the feedback is fixed, what is played back will not quite
2173                    reflect what is actually connected.  Note also that we do not
2174                    do trace_terminal here, as it would fail due to an endless recursion,
2175                    so the solo code will think that everything is still connected
2176                    as it was before.
2177                 */
2178
2179                 FeedbackDetected (); /* EMIT SIGNAL */
2180         }
2181
2182 }
2183
2184 /** Find a route name starting with \a base, maybe followed by the
2185  *  lowest \a id.  \a id will always be added if \a definitely_add_number
2186  *  is true on entry; otherwise it will only be added if required
2187  *  to make the name unique.
2188  *
2189  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2190  *  The available route name with the lowest ID will be used, and \a id
2191  *  will be set to the ID.
2192  *
2193  *  \return false if a route name could not be found, and \a track_name
2194  *  and \a id do not reflect a free route name.
2195  */
2196 bool
2197 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2198 {
2199         /* it is unfortunate that we need to include reserved names here that
2200            refer to control surfaces. But there's no way to ensure a complete
2201            lack of collisions without doing this, since the control surface
2202            support may not even be active. Without adding an API to control
2203            surface support that would list their port names, we do have to
2204            list them here.
2205         */
2206
2207         char const * const reserved[] = {
2208                 _("Monitor"),
2209                 _("Master"),
2210                 _("Control"),
2211                 _("Click"),
2212                 _("Mackie"),
2213                 0
2214         };
2215
2216         /* the base may conflict with ports that do not belong to existing
2217            routes, but hidden objects like the click track. So check port names
2218            before anything else.
2219         */
2220
2221         for (int n = 0; reserved[n]; ++n) {
2222                 if (base == reserved[n]) {
2223                         definitely_add_number = true;
2224                         if (id < 1) {
2225                                 id = 1;
2226                         }
2227                         break;
2228                 }
2229         }
2230
2231         if (!definitely_add_number && route_by_name (base) == 0) {
2232                 /* juse use the base */
2233                 name = base;
2234                 return true;
2235         }
2236
2237         do {
2238                 name = string_compose ("%1 %2", base, id);
2239
2240                 if (route_by_name (name) == 0) {
2241                         return true;
2242                 }
2243
2244                 ++id;
2245
2246         } while (id < (UINT_MAX-1));
2247
2248         return false;
2249 }
2250
2251 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2252 void
2253 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2254 {
2255         in  = ChanCount::ZERO;
2256         out = ChanCount::ZERO;
2257
2258         boost::shared_ptr<RouteList> r = routes.reader ();
2259
2260         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2261                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2262                 if (tr && !tr->is_auditioner()) {
2263                         in  += tr->n_inputs();
2264                         out += tr->n_outputs();
2265                 }
2266         }
2267 }
2268
2269 string
2270 Session::default_track_name_pattern (DataType t)
2271 {
2272         switch (t) {
2273         case DataType::AUDIO:
2274                 if (Profile->get_trx()) {
2275                         return _("Track ");
2276                 } else {
2277                         return _("Audio ");
2278                 }
2279                 break;
2280
2281         case DataType::MIDI:
2282                 return _("MIDI ");
2283         }
2284
2285         return "";
2286 }
2287
2288 /** Caller must not hold process lock
2289  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
2290  *  @param instrument plugin info for the instrument to insert pre-fader, if any
2291  */
2292 list<boost::shared_ptr<MidiTrack> >
2293 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
2294                          TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
2295 {
2296         string track_name;
2297         uint32_t track_id = 0;
2298         string port;
2299         RouteList new_routes;
2300         list<boost::shared_ptr<MidiTrack> > ret;
2301
2302         const string name_pattern = default_track_name_pattern (DataType::MIDI);
2303         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2304
2305         while (how_many) {
2306                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2307                         error << "cannot find name for new midi track" << endmsg;
2308                         goto failed;
2309                 }
2310
2311                 boost::shared_ptr<MidiTrack> track;
2312
2313                 try {
2314                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
2315
2316                         if (track->init ()) {
2317                                 goto failed;
2318                         }
2319
2320                         track->use_new_diskstream();
2321
2322 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2323                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2324 #endif
2325                         {
2326                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2327                                 if (track->input()->ensure_io (input, false, this)) {
2328                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2329                                         goto failed;
2330                                 }
2331
2332                                 if (track->output()->ensure_io (output, false, this)) {
2333                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2334                                         goto failed;
2335                                 }
2336                         }
2337
2338                         track->non_realtime_input_change();
2339
2340                         if (route_group) {
2341                                 route_group->add (track);
2342                         }
2343
2344                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2345
2346                         if (Config->get_remote_model() == UserOrdered) {
2347                                 track->set_remote_control_id (next_control_id());
2348                         }
2349
2350                         new_routes.push_back (track);
2351                         ret.push_back (track);
2352
2353                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2354                 }
2355
2356                 catch (failed_constructor &err) {
2357                         error << _("Session: could not create new midi track.") << endmsg;
2358                         goto failed;
2359                 }
2360
2361                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2362
2363                         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;
2364                         goto failed;
2365                 }
2366
2367                 --how_many;
2368         }
2369
2370   failed:
2371         if (!new_routes.empty()) {
2372                 StateProtector sp (this);
2373                 if (Profile->get_trx()) {
2374                         add_routes (new_routes, false, false, false);
2375                 } else {
2376                         add_routes (new_routes, true, true, false);
2377                 }
2378
2379                 if (instrument) {
2380                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2381                                 PluginPtr plugin = instrument->load (*this);
2382                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2383                                 (*r)->add_processor (p, PreFader);
2384
2385                         }
2386                 }
2387         }
2388
2389         return ret;
2390 }
2391
2392 void
2393 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2394 {
2395         boost::shared_ptr<Route> midi_track (wmt.lock());
2396
2397         if (!midi_track) {
2398                 return;
2399         }
2400
2401         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2402
2403                 if (change.after.n_audio() <= change.before.n_audio()) {
2404                         return;
2405                 }
2406
2407                 /* new audio ports: make sure the audio goes somewhere useful,
2408                    unless the user has no-auto-connect selected.
2409
2410                    The existing ChanCounts don't matter for this call as they are only
2411                    to do with matching input and output indices, and we are only changing
2412                    outputs here.
2413                 */
2414
2415                 ChanCount dummy;
2416
2417                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
2418         }
2419 }
2420
2421 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
2422  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
2423  *  @param output_start As \a input_start, but for outputs.
2424  */
2425 void
2426 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
2427                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
2428 {
2429         if (!IO::connecting_legal) {
2430                 return;
2431         }
2432
2433         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2434
2435         if (with_lock) {
2436                 lm.acquire ();
2437         }
2438
2439         /* If both inputs and outputs are auto-connected to physical ports,
2440            use the max of input and output offsets to ensure auto-connected
2441            port numbers always match up (e.g. the first audio input and the
2442            first audio output of the route will have the same physical
2443            port number).  Otherwise just use the lowest input or output
2444            offset possible.
2445         */
2446
2447         DEBUG_TRACE (DEBUG::Graph,
2448                      string_compose("Auto-connect: existing in = %1 out = %2\n",
2449                                     existing_inputs, existing_outputs));
2450
2451         const bool in_out_physical =
2452                 (Config->get_input_auto_connect() & AutoConnectPhysical)
2453                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
2454                 && connect_inputs;
2455
2456         const ChanCount in_offset = in_out_physical
2457                 ? ChanCount::max(existing_inputs, existing_outputs)
2458                 : existing_inputs;
2459
2460         const ChanCount out_offset = in_out_physical
2461                 ? ChanCount::max(existing_inputs, existing_outputs)
2462                 : existing_outputs;
2463
2464         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2465                 vector<string> physinputs;
2466                 vector<string> physoutputs;
2467
2468                 _engine.get_physical_outputs (*t, physoutputs);
2469                 _engine.get_physical_inputs (*t, physinputs);
2470
2471                 if (!physinputs.empty() && connect_inputs) {
2472                         uint32_t nphysical_in = physinputs.size();
2473
2474                         DEBUG_TRACE (DEBUG::Graph,
2475                                      string_compose("There are %1 physical inputs of type %2\n",
2476                                                     nphysical_in, *t));
2477
2478                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
2479                                 string port;
2480
2481                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
2482                                         DEBUG_TRACE (DEBUG::Graph,
2483                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
2484                                                                     in_offset.get(*t), i, nphysical_in,
2485                                                                     (in_offset.get(*t) + i) % nphysical_in));
2486                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
2487                                 }
2488
2489                                 DEBUG_TRACE (DEBUG::Graph,
2490                                              string_compose("Connect route %1 IN to %2\n",
2491                                                             route->name(), port));
2492
2493                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
2494                                         break;
2495                                 }
2496
2497                                 ChanCount one_added (*t, 1);
2498                                 existing_inputs += one_added;
2499                         }
2500                 }
2501
2502                 if (!physoutputs.empty()) {
2503                         uint32_t nphysical_out = physoutputs.size();
2504                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2505                                 string port;
2506
2507                                 /* Waves Tracks:
2508                                  * do not create new connections if we reached the limit of physical outputs
2509                                  * in Multi Out mode
2510                                  */
2511
2512                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
2513                                     ARDOUR::Profile->get_trx () &&
2514                                     existing_outputs.get(*t) == nphysical_out ) {
2515                                         break;
2516                                 }
2517
2518                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2519                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2520                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2521                                         /* master bus is audio only */
2522                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2523                                                 port = _master_out->input()->ports().port(*t,
2524                                                                 i % _master_out->input()->n_ports().get(*t))->name();
2525                                         }
2526                                 }
2527
2528                                 DEBUG_TRACE (DEBUG::Graph,
2529                                              string_compose("Connect route %1 OUT to %2\n",
2530                                                             route->name(), port));
2531
2532                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2533                                         break;
2534                                 }
2535
2536                                 ChanCount one_added (*t, 1);
2537                                 existing_outputs += one_added;
2538                         }
2539                 }
2540         }
2541 }
2542
2543 #ifdef USE_TRACKS_CODE_FEATURES
2544
2545 static bool
2546 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2547 {
2548         return route1->remote_control_id() < route2->remote_control_id();
2549 }
2550
2551 void
2552 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2553 {
2554         // it is not allowed to perform connection
2555         if (!IO::connecting_legal) {
2556                 return;
2557         }
2558
2559         // if we are deleting routes we will call this once at the end
2560         if (_route_deletion_in_progress) {
2561                 return;
2562         }
2563
2564         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2565
2566         if (withLock) {
2567                 lm.acquire ();
2568         }
2569
2570         // We need to disconnect the route's inputs and outputs first
2571         // basing on autoconnect configuration
2572         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2573         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2574
2575         ChanCount existing_inputs;
2576         ChanCount existing_outputs;
2577         count_existing_track_channels (existing_inputs, existing_outputs);
2578
2579         //ChanCount inputs = ChanCount::ZERO;
2580         //ChanCount outputs = ChanCount::ZERO;
2581
2582         RouteList existing_routes = *routes.reader ();
2583         existing_routes.sort (compare_routes_by_remote_id);
2584
2585         {
2586                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2587
2588                 vector<string> physinputs;
2589                 vector<string> physoutputs;
2590
2591                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2592                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2593
2594                 uint32_t input_n = 0;
2595                 uint32_t output_n = 0;
2596                 RouteList::iterator rIter = existing_routes.begin();
2597                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2598                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2599                 for (; rIter != existing_routes.end(); ++rIter) {
2600                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2601                                 continue;
2602                         }
2603
2604                         if (current_output_auto_connection == AutoConnectPhysical) {
2605                                 (*rIter)->amp()->deactivate();
2606                         } else if (current_output_auto_connection == AutoConnectMaster) {
2607                                 (*rIter)->amp()->activate();
2608                         }
2609
2610                         if (reconnectIputs) {
2611                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2612
2613                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2614
2615                                         if (current_input_auto_connection & AutoConnectPhysical) {
2616
2617                                                 if ( input_n == physinputs.size() ) {
2618                                                         break;
2619                                                 }
2620
2621                                                 string port = physinputs[input_n];
2622
2623                                                 if (port.empty() ) {
2624                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2625                                                 }
2626
2627                                                 //GZ: check this; could be heavy
2628                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2629                                                 ++input_n;
2630                                         }
2631                                 }
2632                         }
2633
2634                         if (reconnectOutputs) {
2635
2636                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2637                                 if (current_output_auto_connection & AutoConnectPhysical) {
2638
2639                                         //GZ: check this; could be heavy
2640                                         (*rIter)->output()->disconnect (this);
2641                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2642
2643                                         //GZ: check this; could be heavy
2644                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2645
2646                                 } else if (current_output_auto_connection & AutoConnectMaster){
2647
2648                                         if (!reconnect_master) {
2649                                                 continue;
2650                                         }
2651
2652                                         //GZ: check this; could be heavy
2653                                         (*rIter)->output()->disconnect (this);
2654
2655                                         if (_master_out) {
2656                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2657                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2658                                         } else {
2659                                                 error << error << "Master bus is not available" << endmsg;
2660                                                 break;
2661                                         }
2662                                 }
2663
2664                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2665                                         if (current_output_auto_connection & AutoConnectPhysical) {
2666
2667                                                 if ( output_n == physoutputs.size() ) {
2668                                                         break;
2669                                                 }
2670
2671                                                 string port = physoutputs[output_n];
2672
2673                                                 if (port.empty() ) {
2674                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2675                                                 }
2676
2677                                                 //GZ: check this; could be heavy
2678                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2679                                                 ++output_n;
2680
2681                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2682
2683                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2684                                                         break;
2685                                                 }
2686
2687                                                 // connect to master bus
2688                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2689
2690                                                 if (port.empty() ) {
2691                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2692                                                 }
2693
2694
2695                                                 //GZ: check this; could be heavy
2696                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2697
2698                                         }
2699                                 }
2700                         }
2701
2702                         //auto_connect_route (*rIter, inputs, outputs, false, reconnectIputs);
2703                 }
2704
2705                 _master_out->output()->disconnect (this);
2706                 auto_connect_master_bus ();
2707         }
2708
2709         graph_reordered ();
2710
2711         session_routes_reconnected (); /* EMIT SIGNAL */
2712 }
2713
2714 void
2715 Session::reconnect_midi_scene_ports(bool inputs)
2716 {
2717     if (inputs ) {
2718
2719         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2720         if (scene_in_ptr) {
2721             scene_in_ptr->disconnect_all ();
2722
2723             std::vector<EngineStateController::MidiPortState> midi_port_states;
2724             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2725
2726             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2727
2728             for (; state_iter != midi_port_states.end(); ++state_iter) {
2729                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2730                     scene_in_ptr->connect (state_iter->name);
2731                 }
2732             }
2733         }
2734
2735     } else {
2736
2737         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2738
2739         if (scene_out_ptr ) {
2740             scene_out_ptr->disconnect_all ();
2741
2742             std::vector<EngineStateController::MidiPortState> midi_port_states;
2743             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2744
2745             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2746
2747             for (; state_iter != midi_port_states.end(); ++state_iter) {
2748                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2749                     scene_out_ptr->connect (state_iter->name);
2750                 }
2751             }
2752         }
2753     }
2754 }
2755
2756 void
2757 Session::reconnect_mtc_ports ()
2758 {
2759         boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2760
2761         if (!mtc_in_ptr) {
2762                 return;
2763         }
2764
2765         mtc_in_ptr->disconnect_all ();
2766
2767         std::vector<EngineStateController::MidiPortState> midi_port_states;
2768         EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2769
2770         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2771
2772         for (; state_iter != midi_port_states.end(); ++state_iter) {
2773                 if (state_iter->available && state_iter->mtc_in) {
2774                         mtc_in_ptr->connect (state_iter->name);
2775                 }
2776         }
2777
2778         if (!_midi_ports->mtc_input_port ()->connected () &&
2779             config.get_external_sync () &&
2780             (Config->get_sync_source () == MTC) ) {
2781                 config.set_external_sync (false);
2782         }
2783
2784         if ( ARDOUR::Profile->get_trx () ) {
2785                 // Tracks need this signal to update timecode_source_dropdown
2786                 MtcOrLtcInputPortChanged (); //emit signal
2787         }
2788 }
2789
2790 void
2791 Session::reconnect_mmc_ports(bool inputs)
2792 {
2793         if (inputs ) { // get all enabled midi input ports
2794
2795                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
2796                 if (mmc_in_ptr) {
2797                         mmc_in_ptr->disconnect_all ();
2798                         std::vector<std::string> enabled_midi_inputs;
2799                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
2800
2801                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
2802
2803                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
2804                                 mmc_in_ptr->connect (*port_iter);
2805                         }
2806
2807                 }
2808         } else { // get all enabled midi output ports
2809
2810                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
2811                 if (mmc_out_ptr ) {
2812                         mmc_out_ptr->disconnect_all ();
2813                         std::vector<std::string> enabled_midi_outputs;
2814                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
2815
2816                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
2817
2818                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
2819                                 mmc_out_ptr->connect (*port_iter);
2820                         }
2821                 }
2822         }
2823 }
2824
2825 #endif
2826
2827 /** Caller must not hold process lock
2828  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2829  */
2830 list< boost::shared_ptr<AudioTrack> >
2831 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2832                           uint32_t how_many, string name_template)
2833 {
2834         string track_name;
2835         uint32_t track_id = 0;
2836         string port;
2837         RouteList new_routes;
2838         list<boost::shared_ptr<AudioTrack> > ret;
2839
2840         const string name_pattern = default_track_name_pattern (DataType::AUDIO);
2841         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2842
2843         while (how_many) {
2844
2845                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
2846                         error << "cannot find name for new audio track" << endmsg;
2847                         goto failed;
2848                 }
2849
2850                 boost::shared_ptr<AudioTrack> track;
2851
2852                 try {
2853                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2854
2855                         if (track->init ()) {
2856                                 goto failed;
2857                         }
2858
2859                         if (ARDOUR::Profile->get_trx ()) {
2860                                 // TRACKS considers it's not a USE CASE, it's
2861                                 // a piece of behavior of the session model:
2862                                 //
2863                                 // Gain for a newly created route depends on
2864                                 // the current output_auto_connect mode:
2865                                 //
2866                                 //  0 for Stereo Out mode
2867                                 //  0 Multi Out mode
2868                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
2869                                         track->set_gain (dB_to_coefficient (0), 0);
2870                                 }
2871                         }
2872
2873                         track->use_new_diskstream();
2874
2875 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2876                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2877 #endif
2878                         {
2879                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2880
2881                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2882                                         error << string_compose (
2883                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2884                                                 input_channels, output_channels)
2885                                               << endmsg;
2886                                         goto failed;
2887                                 }
2888
2889                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2890                                         error << string_compose (
2891                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2892                                                 input_channels, output_channels)
2893                                               << endmsg;
2894                                         goto failed;
2895                                 }
2896                         }
2897
2898                         if (route_group) {
2899                                 route_group->add (track);
2900                         }
2901
2902                         track->non_realtime_input_change();
2903
2904                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2905                         if (Config->get_remote_model() == UserOrdered) {
2906                                 track->set_remote_control_id (next_control_id());
2907                         }
2908
2909                         new_routes.push_back (track);
2910                         ret.push_back (track);
2911
2912                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2913                 }
2914
2915                 catch (failed_constructor &err) {
2916                         error << _("Session: could not create new audio track.") << endmsg;
2917                         goto failed;
2918                 }
2919
2920                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2921
2922                         error << pfe.what() << endmsg;
2923                         goto failed;
2924                 }
2925
2926                 --how_many;
2927         }
2928
2929   failed:
2930         if (!new_routes.empty()) {
2931                 StateProtector sp (this);
2932                 if (Profile->get_trx()) {
2933                         add_routes (new_routes, false, false, false);
2934                 } else {
2935                         add_routes (new_routes, true, true, false);
2936                 }
2937         }
2938
2939         return ret;
2940 }
2941
2942 /** Caller must not hold process lock.
2943  *  @param name_template string to use for the start of the name, or "" to use "Bus".
2944  */
2945 RouteList
2946 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2947 {
2948         string bus_name;
2949         uint32_t bus_id = 0;
2950         string port;
2951         RouteList ret;
2952
2953         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2954
2955         while (how_many) {
2956                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
2957                         error << "cannot find name for new audio bus" << endmsg;
2958                         goto failure;
2959                 }
2960
2961                 try {
2962                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2963
2964                         if (bus->init ()) {
2965                                 goto failure;
2966                         }
2967
2968 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2969                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2970 #endif
2971                         {
2972                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2973
2974                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2975                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2976                                                                  input_channels, output_channels)
2977                                               << endmsg;
2978                                         goto failure;
2979                                 }
2980
2981
2982                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2983                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2984                                                                  input_channels, output_channels)
2985                                               << endmsg;
2986                                         goto failure;
2987                                 }
2988                         }
2989
2990                         if (route_group) {
2991                                 route_group->add (bus);
2992                         }
2993                         if (Config->get_remote_model() == UserOrdered) {
2994                                 bus->set_remote_control_id (next_control_id());
2995                         }
2996
2997                         bus->add_internal_return ();
2998
2999                         ret.push_back (bus);
3000
3001                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3002
3003                         ARDOUR::GUIIdle ();
3004                 }
3005
3006
3007                 catch (failed_constructor &err) {
3008                         error << _("Session: could not create new audio route.") << endmsg;
3009                         goto failure;
3010                 }
3011
3012                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3013                         error << pfe.what() << endmsg;
3014                         goto failure;
3015                 }
3016
3017
3018                 --how_many;
3019         }
3020
3021   failure:
3022         if (!ret.empty()) {
3023                 StateProtector sp (this);
3024                 if (Profile->get_trx()) {
3025                         add_routes (ret, false, false, false);
3026                 } else {
3027                         add_routes (ret, false, true, true); // autoconnect // outputs only
3028                 }
3029         }
3030
3031         return ret;
3032
3033 }
3034
3035 RouteList
3036 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
3037 {
3038         RouteList ret;
3039         uint32_t control_id;
3040         XMLTree tree;
3041         uint32_t number = 0;
3042         const uint32_t being_added = how_many;
3043
3044         if (!tree.read (template_path.c_str())) {
3045                 return ret;
3046         }
3047
3048         XMLNode* node = tree.root();
3049
3050         IO::disable_connecting ();
3051
3052         control_id = next_control_id ();
3053
3054         while (how_many) {
3055
3056                 XMLNode node_copy (*node);
3057
3058                 /* Remove IDs of everything so that new ones are used */
3059                 node_copy.remove_property_recursively (X_("id"));
3060
3061                 try {
3062                         string name;
3063
3064                         if (!name_base.empty()) {
3065
3066                                 /* if we're adding more than one routes, force
3067                                  * all the names of the new routes to be
3068                                  * numbered, via the final parameter.
3069                                  */
3070
3071                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3072                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3073                                         /*NOTREACHDE*/
3074                                 }
3075
3076                         } else {
3077
3078                                 string const route_name  = node_copy.property(X_("name"))->value ();
3079
3080                                 /* generate a new name by adding a number to the end of the template name */
3081                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3082                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3083                                         abort(); /*NOTREACHED*/
3084                                 }
3085                         }
3086
3087                         /* set this name in the XML description that we are about to use */
3088                         Route::set_name_in_state (node_copy, name);
3089
3090                         /* trim bitslots from listen sends so that new ones are used */
3091                         XMLNodeList children = node_copy.children ();
3092                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3093                                 if ((*i)->name() == X_("Processor")) {
3094                                         XMLProperty* role = (*i)->property (X_("role"));
3095                                         if (role && role->value() == X_("Listen")) {
3096                                                 (*i)->remove_property (X_("bitslot"));
3097                                         }
3098                                 }
3099                         }
3100
3101                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3102
3103                         if (route == 0) {
3104                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3105                                 goto out;
3106                         }
3107
3108                         if (boost::dynamic_pointer_cast<Track>(route)) {
3109                                 /* force input/output change signals so that the new diskstream
3110                                    picks up the configuration of the route. During session
3111                                    loading this normally happens in a different way.
3112                                 */
3113
3114                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3115
3116                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3117                                 change.after = route->input()->n_ports();
3118                                 route->input()->changed (change, this);
3119                                 change.after = route->output()->n_ports();
3120                                 route->output()->changed (change, this);
3121                         }
3122
3123                         route->set_remote_control_id (control_id);
3124                         ++control_id;
3125
3126                         ret.push_back (route);
3127
3128                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3129                 }
3130
3131                 catch (failed_constructor &err) {
3132                         error << _("Session: could not create new route from template") << endmsg;
3133                         goto out;
3134                 }
3135
3136                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3137                         error << pfe.what() << endmsg;
3138                         goto out;
3139                 }
3140
3141                 --how_many;
3142         }
3143
3144   out:
3145         if (!ret.empty()) {
3146                 StateProtector sp (this);
3147                 if (Profile->get_trx()) {
3148                         add_routes (ret, false, false, false);
3149                 } else {
3150                         add_routes (ret, true, true, false);
3151                 }
3152                 IO::enable_connecting ();
3153         }
3154
3155         return ret;
3156 }
3157
3158 void
3159 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
3160 {
3161         try {
3162                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3163                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
3164
3165         } catch (...) {
3166                 error << _("Adding new tracks/busses failed") << endmsg;
3167         }
3168
3169         graph_reordered ();
3170
3171         update_latency (true);
3172         update_latency (false);
3173
3174         set_dirty();
3175
3176         if (save) {
3177                 save_state (_current_snapshot_name);
3178         }
3179
3180         reassign_track_numbers();
3181
3182         update_route_record_state ();
3183
3184         RouteAdded (new_routes); /* EMIT SIGNAL */
3185 }
3186
3187 void
3188 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3189 {
3190         ChanCount existing_inputs;
3191         ChanCount existing_outputs;
3192         uint32_t order = next_control_id();
3193
3194         if (_order_hint > -1) {
3195                 order = _order_hint;
3196                 _order_hint = -1;
3197         }
3198
3199         count_existing_track_channels (existing_inputs, existing_outputs);
3200
3201         {
3202                 RCUWriter<RouteList> writer (routes);
3203                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3204                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3205
3206                 /* if there is no control out and we're not in the middle of loading,
3207                    resort the graph here. if there is a control out, we will resort
3208                    toward the end of this method. if we are in the middle of loading,
3209                    we will resort when done.
3210                 */
3211
3212                 if (!_monitor_out && IO::connecting_legal) {
3213                         resort_routes_using (r);
3214                 }
3215         }
3216
3217         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3218
3219                 boost::weak_ptr<Route> wpr (*x);
3220                 boost::shared_ptr<Route> r (*x);
3221
3222                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3223                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3224                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
3225                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
3226                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3227                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3228
3229                 if (r->is_master()) {
3230                         _master_out = r;
3231                 }
3232
3233                 if (r->is_monitor()) {
3234                         _monitor_out = r;
3235                 }
3236
3237                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3238                 if (tr) {
3239                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3240                         track_playlist_changed (boost::weak_ptr<Track> (tr));
3241                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3242
3243                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3244                         if (mt) {
3245                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3246                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3247                         }
3248                 }
3249
3250
3251                 if (input_auto_connect || output_auto_connect) {
3252                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
3253                 }
3254
3255                 /* order keys are a GUI responsibility but we need to set up
3256                    reasonable defaults because they also affect the remote control
3257                    ID in most situations.
3258                 */
3259
3260                 if (!r->has_order_key ()) {
3261                         if (r->is_auditioner()) {
3262                                 /* use an arbitrarily high value */
3263                                 r->set_order_key (UINT_MAX);
3264                         } else {
3265                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3266                                 r->set_order_key (order);
3267                                 order++;
3268                         }
3269                 }
3270
3271                 ARDOUR::GUIIdle ();
3272         }
3273
3274         if (_monitor_out && IO::connecting_legal) {
3275                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3276
3277                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3278                         if ((*x)->is_monitor()) {
3279                                 /* relax */
3280                         } else if ((*x)->is_master()) {
3281                                         /* relax */
3282                         } else {
3283                                 (*x)->enable_monitor_send ();
3284                         }
3285                 }
3286         }
3287 }
3288
3289 void
3290 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3291 {
3292         boost::shared_ptr<RouteList> r = routes.reader ();
3293         boost::shared_ptr<Send> s;
3294
3295         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3296                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3297                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO);
3298                 }
3299         }
3300 }
3301
3302 void
3303 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3304 {
3305         boost::shared_ptr<RouteList> r = routes.reader ();
3306         boost::shared_ptr<Send> s;
3307
3308         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3309                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3310                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY);
3311                 }
3312         }
3313 }
3314
3315 void
3316 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3317 {
3318         boost::shared_ptr<RouteList> r = routes.reader ();
3319         boost::shared_ptr<Send> s;
3320
3321         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3322                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3323                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
3324                 }
3325         }
3326 }
3327
3328 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3329 void
3330 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3331 {
3332         boost::shared_ptr<RouteList> r = routes.reader ();
3333         boost::shared_ptr<RouteList> t (new RouteList);
3334
3335         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3336                 /* no MIDI sends because there are no MIDI busses yet */
3337                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3338                         t->push_back (*i);
3339                 }
3340         }
3341
3342         add_internal_sends (dest, p, t);
3343 }
3344
3345 void
3346 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3347 {
3348         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3349                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3350         }
3351 }
3352
3353 void
3354 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3355 {
3356         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3357 }
3358
3359 void
3360 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3361 {
3362         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3363                 return;
3364         }
3365
3366         if (!dest->internal_return()) {
3367                 dest->add_internal_return ();
3368         }
3369
3370         sender->add_aux_send (dest, before);
3371
3372         graph_reordered ();
3373 }
3374
3375
3376 void
3377 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3378 {
3379         PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3380
3381         { // RCU Writer scope
3382                 RCUWriter<RouteList> writer (routes);
3383                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3384
3385
3386                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3387
3388                         if (*iter == _master_out) {
3389                                 continue;
3390                         }
3391
3392                         (*iter)->set_solo (false, this);
3393
3394                         rs->remove (*iter);
3395
3396                         /* deleting the master out seems like a dumb
3397                            idea, but its more of a UI policy issue
3398                            than our concern.
3399                         */
3400
3401                         if (*iter == _master_out) {
3402                                 _master_out = boost::shared_ptr<Route> ();
3403                         }
3404
3405                         if (*iter == _monitor_out) {
3406                                 _monitor_out.reset ();
3407                         }
3408
3409                         // We need to disconnect the route's inputs and outputs
3410
3411                         (*iter)->input()->disconnect (0);
3412                         (*iter)->output()->disconnect (0);
3413
3414                         /* if the route had internal sends sending to it, remove them */
3415                         if ((*iter)->internal_return()) {
3416
3417                                 boost::shared_ptr<RouteList> r = routes.reader ();
3418                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3419                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3420                                         if (s) {
3421                                                 (*i)->remove_processor (s);
3422                                         }
3423                                 }
3424                         }
3425
3426                         /* if the monitoring section had a pointer to this route, remove it */
3427                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3428                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3429                                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3430                                 (*iter)->remove_aux_or_listen (_monitor_out);
3431                         }
3432
3433                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3434                         if (mt && mt->step_editing()) {
3435                                 if (_step_editors > 0) {
3436                                         _step_editors--;
3437                                 }
3438                         }
3439                 }
3440
3441                 /* writer goes out of scope, forces route list update */
3442
3443         } // end of RCU Writer scope
3444
3445         update_route_solo_state ();
3446         RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3447         update_latency_compensation ();
3448         set_dirty();
3449
3450         /* Re-sort routes to remove the graph's current references to the one that is
3451          * going away, then flush old references out of the graph.
3452          * Wave Tracks: reconnect routes
3453          */
3454
3455 #ifdef USE_TRACKS_CODE_FEATURES
3456                 reconnect_existing_routes(true, false);
3457 #else
3458                 routes.flush (); // maybe unsafe, see below.
3459                 resort_routes ();
3460 #endif
3461
3462         if (_process_graph) {
3463                 _process_graph->clear_other_chain ();
3464         }
3465
3466         /* get rid of it from the dead wood collection in the route list manager */
3467         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3468
3469         routes.flush ();
3470
3471         /* try to cause everyone to drop their references
3472          * and unregister ports from the backend
3473          */
3474
3475         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3476                 (*iter)->drop_references ();
3477         }
3478
3479         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3480
3481         /* save the new state of the world */
3482
3483         if (save_state (_current_snapshot_name)) {
3484                 save_history (_current_snapshot_name);
3485         }
3486
3487         reassign_track_numbers();
3488         update_route_record_state ();
3489 }
3490
3491 void
3492 Session::remove_route (boost::shared_ptr<Route> route)
3493 {
3494         boost::shared_ptr<RouteList> rl (new RouteList);
3495         rl->push_back (route);
3496         remove_routes (rl);
3497 }
3498
3499 void
3500 Session::route_mute_changed (void* /*src*/)
3501 {
3502         set_dirty ();
3503 }
3504
3505 void
3506 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3507 {
3508         boost::shared_ptr<Route> route = wpr.lock();
3509         if (!route) {
3510                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3511                 return;
3512         }
3513
3514         if (route->listening_via_monitor ()) {
3515
3516                 if (Config->get_exclusive_solo()) {
3517                         /* new listen: disable all other listen */
3518                         boost::shared_ptr<RouteList> r = routes.reader ();
3519                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3520                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3521                                         continue;
3522                                 }
3523                                 (*i)->set_listen (false, this);
3524                         }
3525                 }
3526
3527                 _listen_cnt++;
3528
3529         } else if (_listen_cnt > 0) {
3530
3531                 _listen_cnt--;
3532         }
3533
3534         update_route_solo_state ();
3535 }
3536 void
3537 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3538 {
3539         boost::shared_ptr<Route> route = wpr.lock ();
3540
3541         if (!route) {
3542                 /* should not happen */
3543                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3544                 return;
3545         }
3546
3547         bool send_changed = false;
3548
3549         if (route->solo_isolated()) {
3550                 if (_solo_isolated_cnt == 0) {
3551                         send_changed = true;
3552                 }
3553                 _solo_isolated_cnt++;
3554         } else if (_solo_isolated_cnt > 0) {
3555                 _solo_isolated_cnt--;
3556                 if (_solo_isolated_cnt == 0) {
3557                         send_changed = true;
3558                 }
3559         }
3560
3561         if (send_changed) {
3562                 IsolatedChanged (); /* EMIT SIGNAL */
3563         }
3564 }
3565
3566 void
3567 Session::routes_solo_changed (boost::shared_ptr<RouteList> solo_change_routes)
3568 {
3569         if (solo_update_disabled) {
3570                 // We know already
3571                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
3572                 return;
3573         }
3574
3575         if (solo_change_routes->empty() ) {
3576                 return;
3577         }
3578
3579         boost::shared_ptr<RouteList> non_solo_change_routes (new RouteList);
3580         boost::shared_ptr<RouteList> r = routes.reader ();
3581         int32_t delta;
3582
3583         std::set_difference (r->begin(), r->end(),
3584                              solo_change_routes->begin(), solo_change_routes->end(),
3585                              std::back_inserter(*non_solo_change_routes) );
3586
3587         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3588
3589         solo_update_disabled = true;
3590         RouteList uninvolved;
3591
3592         for (RouteList::iterator route = solo_change_routes->begin(); route != solo_change_routes->end(); ++route) {
3593
3594                 if ((*route)->self_soloed() ) {
3595                         delta = 1;
3596                 } else {
3597                         delta = -1;
3598                 }
3599
3600                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", (*route)->name()));
3601
3602                 for (RouteList::iterator i = non_solo_change_routes->begin(); i != non_solo_change_routes->end(); ++i) {
3603                         bool via_sends_only;
3604                         bool in_signal_flow;
3605
3606                         if ((*i) == *route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ) {
3607                                 continue;
3608                         }
3609
3610                         in_signal_flow = false;
3611
3612                         DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3613
3614                         if ((*i)->feeds (*route, &via_sends_only)) {
3615                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3616                                 if (!via_sends_only) {
3617                                         if (!(*route)->soloed_by_others_upstream()) {
3618                                                 (*i)->mod_solo_by_others_downstream (delta);
3619                                         }
3620                                 } else {
3621                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3622                                 }
3623                                 in_signal_flow = true;
3624                         } else {
3625                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3626                         }
3627
3628                         DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3629
3630                         if ((*route)->feeds (*i, &via_sends_only)) {
3631                                 /* propagate solo upstream only if routing other than
3632                                    sends is involved, but do consider the other route
3633                                    (*i) to be part of the signal flow even if only
3634                                    sends are involved.
3635                                 */
3636                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3637                                                                           (*route)->name(),
3638                                                                           (*i)->name(),
3639                                                                           via_sends_only,
3640                                                                           (*route)->soloed_by_others_downstream(),
3641                                                                           (*route)->soloed_by_others_upstream()));
3642                                 if (!via_sends_only) {
3643                                         if (!(*route)->soloed_by_others_downstream()) {
3644                                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3645                                                 (*i)->mod_solo_by_others_upstream (delta);
3646                                         } else {
3647                                                 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3648                                         }
3649                                 } else {
3650                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3651                                 }
3652                                 in_signal_flow = true;
3653                         } else {
3654                                 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3655                         }
3656
3657                         if (!in_signal_flow) {
3658                                 uninvolved.push_back (*i);
3659                         }
3660                 }
3661         }
3662         solo_update_disabled = false;
3663         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3664
3665         update_route_solo_state ();
3666
3667         /* now notify that the mute state of the routes not involved in the signal
3668            pathway of the just-solo-changed route may have altered.
3669         */
3670
3671         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3672                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1\n", (*i)->name() ));
3673                 (*i)->mute_changed (this);
3674         }
3675
3676         SoloChanged (); /* EMIT SIGNAL */
3677         set_dirty();
3678 }
3679
3680 void
3681 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
3682 {
3683         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3684
3685         if (!self_solo_change) {
3686                 // session doesn't care about changes to soloed-by-others
3687                 return;
3688         }
3689
3690         if (solo_update_disabled) {
3691                 // We know already
3692                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
3693                 return;
3694         }
3695
3696         boost::shared_ptr<Route> route = wpr.lock ();
3697         assert (route);
3698
3699         boost::shared_ptr<RouteList> r = routes.reader ();
3700         int32_t delta;
3701
3702         if (route->self_soloed()) {
3703                 delta = 1;
3704         } else {
3705                 delta = -1;
3706         }
3707
3708         RouteGroup* rg = route->route_group ();
3709         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
3710
3711         if (delta == 1 && Config->get_exclusive_solo()) {
3712
3713                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3714
3715                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3716                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3717                             (leave_group_alone && ((*i)->route_group() == rg))) {
3718                                 continue;
3719                         }
3720                         (*i)->set_solo (false, this);
3721                 }
3722         }
3723
3724         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3725
3726         solo_update_disabled = true;
3727
3728         RouteList uninvolved;
3729
3730         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3731
3732         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3733                 bool via_sends_only;
3734                 bool in_signal_flow;
3735
3736                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3737                     (leave_group_alone && ((*i)->route_group() == rg))) {
3738                         continue;
3739                 }
3740
3741                 in_signal_flow = false;
3742
3743                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3744
3745                 if ((*i)->feeds (route, &via_sends_only)) {
3746                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3747                         if (!via_sends_only) {
3748                                 if (!route->soloed_by_others_upstream()) {
3749                                         (*i)->mod_solo_by_others_downstream (delta);
3750                                 }
3751                         } else {
3752                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3753                         }
3754                         in_signal_flow = true;
3755                 } else {
3756                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3757                 }
3758
3759                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3760
3761                 if (route->feeds (*i, &via_sends_only)) {
3762                         /* propagate solo upstream only if routing other than
3763                            sends is involved, but do consider the other route
3764                            (*i) to be part of the signal flow even if only
3765                            sends are involved.
3766                         */
3767                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3768                                                                   route->name(),
3769                                                                   (*i)->name(),
3770                                                                   via_sends_only,
3771                                                                   route->soloed_by_others_downstream(),
3772                                                                   route->soloed_by_others_upstream()));
3773                         if (!via_sends_only) {
3774                                 if (!route->soloed_by_others_downstream()) {
3775                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3776                                         (*i)->mod_solo_by_others_upstream (delta);
3777                                 } else {
3778                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3779                                 }
3780                         } else {
3781                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3782                         }
3783                         in_signal_flow = true;
3784                 } else {
3785                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3786                 }
3787
3788                 if (!in_signal_flow) {
3789                         uninvolved.push_back (*i);
3790                 }
3791         }
3792
3793         solo_update_disabled = false;
3794         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3795
3796         update_route_solo_state (r);
3797
3798         /* now notify that the mute state of the routes not involved in the signal
3799            pathway of the just-solo-changed route may have altered.
3800         */
3801
3802         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3803                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3804                 (*i)->act_on_mute ();
3805                 (*i)->mute_changed (this);
3806         }
3807
3808         SoloChanged (); /* EMIT SIGNAL */
3809         set_dirty();
3810 }
3811
3812 void
3813 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3814 {
3815         /* now figure out if anything that matters is soloed (or is "listening")*/
3816
3817         bool something_soloed = false;
3818         uint32_t listeners = 0;
3819         uint32_t isolated = 0;
3820
3821         if (!r) {
3822                 r = routes.reader();
3823         }
3824
3825         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3826                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3827                         something_soloed = true;
3828                 }
3829
3830                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3831                         if (Config->get_solo_control_is_listen_control()) {
3832                                 listeners++;
3833                         } else {
3834                                 (*i)->set_listen (false, this);
3835                         }
3836                 }
3837
3838                 if ((*i)->solo_isolated()) {
3839                         isolated++;
3840                 }
3841         }
3842
3843         if (something_soloed != _non_soloed_outs_muted) {
3844                 _non_soloed_outs_muted = something_soloed;
3845                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3846         }
3847
3848         _listen_cnt = listeners;
3849
3850         if (isolated != _solo_isolated_cnt) {
3851                 _solo_isolated_cnt = isolated;
3852                 IsolatedChanged (); /* EMIT SIGNAL */
3853         }
3854
3855         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3856                                                   something_soloed, listeners, isolated));
3857 }
3858
3859 boost::shared_ptr<RouteList>
3860 Session::get_routes_with_internal_returns() const
3861 {
3862         boost::shared_ptr<RouteList> r = routes.reader ();
3863         boost::shared_ptr<RouteList> rl (new RouteList);
3864
3865         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3866                 if ((*i)->internal_return ()) {
3867                         rl->push_back (*i);
3868                 }
3869         }
3870         return rl;
3871 }
3872
3873 bool
3874 Session::io_name_is_legal (const std::string& name)
3875 {
3876         boost::shared_ptr<RouteList> r = routes.reader ();
3877
3878         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3879                 if ((*i)->name() == name) {
3880                         return false;
3881                 }
3882
3883                 if ((*i)->has_io_processor_named (name)) {
3884                         return false;
3885                 }
3886         }
3887
3888         return true;
3889 }
3890
3891 void
3892 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3893 {
3894         RouteList rl2;
3895         vector<string> connections;
3896
3897         /* if we are passed only a single route and we're not told to turn
3898          * others off, then just do the simple thing.
3899          */
3900
3901         if (flip_others == false && rl->size() == 1) {
3902                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3903                 if (mt) {
3904                         mt->set_input_active (onoff);
3905                         return;
3906                 }
3907         }
3908
3909         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3910
3911                 PortSet& ps ((*rt)->input()->ports());
3912
3913                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3914                         p->get_connections (connections);
3915                 }
3916
3917                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3918                         routes_using_input_from (*s, rl2);
3919                 }
3920
3921                 /* scan all relevant routes to see if others are on or off */
3922
3923                 bool others_are_already_on = false;
3924
3925                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3926
3927                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3928
3929                         if (!mt) {
3930                                 continue;
3931                         }
3932
3933                         if ((*r) != (*rt)) {
3934                                 if (mt->input_active()) {
3935                                         others_are_already_on = true;
3936                                 }
3937                         } else {
3938                                 /* this one needs changing */
3939                                 mt->set_input_active (onoff);
3940                         }
3941                 }
3942
3943                 if (flip_others) {
3944
3945                         /* globally reverse other routes */
3946
3947                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3948                                 if ((*r) != (*rt)) {
3949                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3950                                         if (mt) {
3951                                                 mt->set_input_active (!others_are_already_on);
3952                                         }
3953                                 }
3954                         }
3955                 }
3956         }
3957 }
3958
3959 void
3960 Session::routes_using_input_from (const string& str, RouteList& rl)
3961 {
3962         boost::shared_ptr<RouteList> r = routes.reader();
3963
3964         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3965                 if ((*i)->input()->connected_to (str)) {
3966                         rl.push_back (*i);
3967                 }
3968         }
3969 }
3970
3971 boost::shared_ptr<Route>
3972 Session::route_by_name (string name)
3973 {
3974         boost::shared_ptr<RouteList> r = routes.reader ();
3975
3976         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3977                 if ((*i)->name() == name) {
3978                         return *i;
3979                 }
3980         }
3981
3982         return boost::shared_ptr<Route> ((Route*) 0);
3983 }
3984
3985 boost::shared_ptr<Route>
3986 Session::route_by_id (PBD::ID id)
3987 {
3988         boost::shared_ptr<RouteList> r = routes.reader ();
3989
3990         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3991                 if ((*i)->id() == id) {
3992                         return *i;
3993                 }
3994         }
3995
3996         return boost::shared_ptr<Route> ((Route*) 0);
3997 }
3998
3999 boost::shared_ptr<Track>
4000 Session::track_by_diskstream_id (PBD::ID id)
4001 {
4002         boost::shared_ptr<RouteList> r = routes.reader ();
4003
4004         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4005                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4006                 if (t && t->using_diskstream_id (id)) {
4007                         return t;
4008                 }
4009         }
4010
4011         return boost::shared_ptr<Track> ();
4012 }
4013
4014 boost::shared_ptr<Route>
4015 Session::route_by_remote_id (uint32_t id)
4016 {
4017         boost::shared_ptr<RouteList> r = routes.reader ();
4018
4019         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4020                 if ((*i)->remote_control_id() == id) {
4021                         return *i;
4022                 }
4023         }
4024
4025         return boost::shared_ptr<Route> ((Route*) 0);
4026 }
4027
4028
4029 void
4030 Session::reassign_track_numbers ()
4031 {
4032         int64_t tn = 0;
4033         int64_t bn = 0;
4034         RouteList r (*(routes.reader ()));
4035         SignalOrderRouteSorter sorter;
4036         r.sort (sorter);
4037
4038         StateProtector sp (this);
4039
4040         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4041                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4042                         (*i)->set_track_number(++tn);
4043                 }
4044                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4045                         (*i)->set_track_number(--bn);
4046                 }
4047         }
4048         const uint32_t decimals = ceilf (log10f (tn + 1));
4049         const bool decimals_changed = _track_number_decimals != decimals;
4050         _track_number_decimals = decimals;
4051
4052         if (decimals_changed && config.get_track_name_number ()) {
4053                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4054                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4055                         if (t) {
4056                                 t->resync_track_name();
4057                         }
4058                 }
4059                 // trigger GUI re-layout
4060                 config.ParameterChanged("track-name-number");
4061         }
4062 }
4063
4064 void
4065 Session::playlist_region_added (boost::weak_ptr<Region> w)
4066 {
4067         boost::shared_ptr<Region> r = w.lock ();
4068         if (!r) {
4069                 return;
4070         }
4071
4072         /* These are the operations that are currently in progress... */
4073         list<GQuark> curr = _current_trans_quarks;
4074         curr.sort ();
4075
4076         /* ...and these are the operations during which we want to update
4077            the session range location markers.
4078         */
4079         list<GQuark> ops;
4080         ops.push_back (Operations::capture);
4081         ops.push_back (Operations::paste);
4082         ops.push_back (Operations::duplicate_region);
4083         ops.push_back (Operations::insert_file);
4084         ops.push_back (Operations::insert_region);
4085         ops.push_back (Operations::drag_region_brush);
4086         ops.push_back (Operations::region_drag);
4087         ops.push_back (Operations::selection_grab);
4088         ops.push_back (Operations::region_fill);
4089         ops.push_back (Operations::fill_selection);
4090         ops.push_back (Operations::create_region);
4091         ops.push_back (Operations::region_copy);
4092         ops.push_back (Operations::fixed_time_region_copy);
4093         ops.sort ();
4094
4095         /* See if any of the current operations match the ones that we want */
4096         list<GQuark> in;
4097         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4098
4099         /* If so, update the session range markers */
4100         if (!in.empty ()) {
4101                 maybe_update_session_range (r->position (), r->last_frame ());
4102         }
4103 }
4104
4105 /** Update the session range markers if a is before the current start or
4106  *  b is after the current end.
4107  */
4108 void
4109 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4110 {
4111         if (_state_of_the_state & Loading) {
4112                 return;
4113         }
4114
4115         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4116
4117         if (_session_range_location == 0) {
4118
4119                 set_session_range_location (a, b + session_end_marker_shift_samples);
4120
4121         } else {
4122
4123                 if (a < _session_range_location->start()) {
4124                         _session_range_location->set_start (a);
4125                 }
4126
4127                 if (b > _session_range_location->end()) {
4128                         _session_range_location->set_end (b);
4129                 }
4130         }
4131 }
4132
4133 void
4134 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4135 {
4136         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4137                 maybe_update_session_range (i->to, i->to + i->length);
4138         }
4139 }
4140
4141 void
4142 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4143 {
4144         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4145                 maybe_update_session_range (i->from, i->to);
4146         }
4147 }
4148
4149 /* Region management */
4150
4151 boost::shared_ptr<Region>
4152 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4153 {
4154         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4155         RegionFactory::RegionMap::const_iterator i;
4156         boost::shared_ptr<Region> region;
4157
4158         Glib::Threads::Mutex::Lock lm (region_lock);
4159
4160         for (i = regions.begin(); i != regions.end(); ++i) {
4161
4162                 region = i->second;
4163
4164                 if (region->whole_file()) {
4165
4166                         if (child->source_equivalent (region)) {
4167                                 return region;
4168                         }
4169                 }
4170         }
4171
4172         return boost::shared_ptr<Region> ();
4173 }
4174
4175 int
4176 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4177 {
4178         set<boost::shared_ptr<Region> > relevant_regions;
4179
4180         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4181                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4182         }
4183
4184         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4185                 set<boost::shared_ptr<Region> >::iterator tmp;
4186
4187                 tmp = r;
4188                 ++tmp;
4189
4190                 playlists->destroy_region (*r);
4191                 RegionFactory::map_remove (*r);
4192
4193                 (*r)->drop_sources ();
4194                 (*r)->drop_references ();
4195
4196                 relevant_regions.erase (r);
4197
4198                 r = tmp;
4199         }
4200
4201         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4202
4203                 {
4204                         Glib::Threads::Mutex::Lock ls (source_lock);
4205                         /* remove from the main source list */
4206                         sources.erase ((*s)->id());
4207                 }
4208
4209                 (*s)->mark_for_remove ();
4210                 (*s)->drop_references ();
4211
4212                 s = srcs.erase (s);
4213         }
4214
4215         return 0;
4216 }
4217
4218 int
4219 Session::remove_last_capture ()
4220 {
4221         list<boost::shared_ptr<Source> > srcs;
4222
4223         boost::shared_ptr<RouteList> rl = routes.reader ();
4224         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4225                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4226                 if (!tr) {
4227                         continue;
4228                 }
4229
4230                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4231
4232                 if (!l.empty()) {
4233                         srcs.insert (srcs.end(), l.begin(), l.end());
4234                         l.clear ();
4235                 }
4236         }
4237
4238         destroy_sources (srcs);
4239
4240         save_state (_current_snapshot_name);
4241
4242         return 0;
4243 }
4244
4245 /* Source Management */
4246
4247 void
4248 Session::add_source (boost::shared_ptr<Source> source)
4249 {
4250         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4251         pair<SourceMap::iterator,bool> result;
4252
4253         entry.first = source->id();
4254         entry.second = source;
4255
4256         {
4257                 Glib::Threads::Mutex::Lock lm (source_lock);
4258                 result = sources.insert (entry);
4259         }
4260
4261         if (result.second) {
4262
4263                 /* yay, new source */
4264
4265                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4266
4267                 if (fs) {
4268                         if (!fs->within_session()) {
4269                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4270                         }
4271                 }
4272
4273                 set_dirty();
4274
4275                 boost::shared_ptr<AudioFileSource> afs;
4276
4277                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4278                         if (Config->get_auto_analyse_audio()) {
4279                                 Analyser::queue_source_for_analysis (source, false);
4280                         }
4281                 }
4282
4283                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4284         }
4285 }
4286
4287 void
4288 Session::remove_source (boost::weak_ptr<Source> src)
4289 {
4290         if (_state_of_the_state & Deletion) {
4291                 return;
4292         }
4293
4294         SourceMap::iterator i;
4295         boost::shared_ptr<Source> source = src.lock();
4296
4297         if (!source) {
4298                 return;
4299         }
4300
4301         {
4302                 Glib::Threads::Mutex::Lock lm (source_lock);
4303
4304                 if ((i = sources.find (source->id())) != sources.end()) {
4305                         sources.erase (i);
4306                 }
4307         }
4308
4309         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4310
4311                 /* save state so we don't end up with a session file
4312                    referring to non-existent sources.
4313                 */
4314
4315                 save_state (_current_snapshot_name);
4316         }
4317 }
4318
4319 boost::shared_ptr<Source>
4320 Session::source_by_id (const PBD::ID& id)
4321 {
4322         Glib::Threads::Mutex::Lock lm (source_lock);
4323         SourceMap::iterator i;
4324         boost::shared_ptr<Source> source;
4325
4326         if ((i = sources.find (id)) != sources.end()) {
4327                 source = i->second;
4328         }
4329
4330         return source;
4331 }
4332
4333 boost::shared_ptr<AudioFileSource>
4334 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4335 {
4336         /* Restricted to audio files because only audio sources have channel
4337            as a property.
4338         */
4339
4340         Glib::Threads::Mutex::Lock lm (source_lock);
4341
4342         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4343                 boost::shared_ptr<AudioFileSource> afs
4344                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4345
4346                 if (afs && afs->path() == path && chn == afs->channel()) {
4347                         return afs;
4348                 }
4349         }
4350
4351         return boost::shared_ptr<AudioFileSource>();
4352 }
4353
4354 boost::shared_ptr<MidiSource>
4355 Session::midi_source_by_path (const std::string& path) const
4356 {
4357         /* Restricted to MIDI files because audio sources require a channel
4358            for unique identification, in addition to a path.
4359         */
4360
4361         Glib::Threads::Mutex::Lock lm (source_lock);
4362
4363         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4364                 boost::shared_ptr<MidiSource> ms
4365                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4366                 boost::shared_ptr<FileSource> fs
4367                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4368
4369                 if (ms && fs && fs->path() == path) {
4370                         return ms;
4371                 }
4372         }
4373
4374         return boost::shared_ptr<MidiSource>();
4375 }
4376
4377 uint32_t
4378 Session::count_sources_by_origin (const string& path)
4379 {
4380         uint32_t cnt = 0;
4381         Glib::Threads::Mutex::Lock lm (source_lock);
4382
4383         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4384                 boost::shared_ptr<FileSource> fs
4385                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4386
4387                 if (fs && fs->origin() == path) {
4388                         ++cnt;
4389                 }
4390         }
4391
4392         return cnt;
4393 }
4394
4395 static string
4396 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4397         if (hash) {
4398                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4399                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4400         } else {
4401                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4402         }
4403 }
4404
4405 string
4406 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4407 {
4408         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4409
4410         if (Glib::path_is_absolute (filepath)) {
4411
4412                 /* rip the session dir from the audiofile source */
4413
4414                 string session_path;
4415                 bool in_another_session = true;
4416
4417                 if (filepath.find (interchange_dir_string) != string::npos) {
4418
4419                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4420                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4421                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4422                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4423
4424                         /* see if it is within our session */
4425
4426                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4427                                 if (i->path == session_path) {
4428                                         in_another_session = false;
4429                                         break;
4430                                 }
4431                         }
4432                 } else {
4433                         in_another_session = false;
4434                 }
4435
4436
4437                 if (in_another_session) {
4438                         SessionDirectory sd (session_path);
4439                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4440                 }
4441         }
4442
4443         /* 1) if file belongs to this session
4444          * it may be a relative path (interchange/...)
4445          * or just basename (session_state, remove source)
4446          * -> just use the basename
4447          */
4448         std::string filename = Glib::path_get_basename (filepath);
4449         std::string path;
4450
4451         /* 2) if the file is outside our session dir:
4452          * (imported but not copied) add the path for check-summming */
4453         if (!in_session) {
4454                 path = Glib::path_get_dirname (filepath);
4455         }
4456
4457         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4458 }
4459
4460 string
4461 Session::new_audio_source_path_for_embedded (const std::string& path)
4462 {
4463         /* embedded source:
4464          *
4465          * we know that the filename is already unique because it exists
4466          * out in the filesystem.
4467          *
4468          * However, when we bring it into the session, we could get a
4469          * collision.
4470          *
4471          * Eg. two embedded files:
4472          *
4473          *          /foo/bar/baz.wav
4474          *          /frob/nic/baz.wav
4475          *
4476          * When merged into session, these collide.
4477          *
4478          * There will not be a conflict with in-memory sources
4479          * because when the source was created we already picked
4480          * a unique name for it.
4481          *
4482          * This collision is not likely to be common, but we have to guard
4483          * against it.  So, if there is a collision, take the md5 hash of the
4484          * the path, and use that as the filename instead.
4485          */
4486
4487         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4488         string base = Glib::path_get_basename (path);
4489         string newpath = Glib::build_filename (sdir.sound_path(), base);
4490
4491         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4492
4493                 MD5 md5;
4494
4495                 md5.digestString (path.c_str());
4496                 md5.writeToString ();
4497                 base = md5.digestChars;
4498
4499                 string ext = get_suffix (path);
4500
4501                 if (!ext.empty()) {
4502                         base += '.';
4503                         base += ext;
4504                 }
4505
4506                 newpath = Glib::build_filename (sdir.sound_path(), base);
4507
4508                 /* if this collides, we're screwed */
4509
4510                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4511                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4512                         return string();
4513                 }
4514
4515         }
4516
4517         return newpath;
4518 }
4519
4520 /** Return true if there are no audio file sources that use @param name as
4521  * the filename component of their path.
4522  *
4523  * Return false otherwise.
4524  *
4525  * This method MUST ONLY be used to check in-session, mono files since it
4526  * hard-codes the channel of the audio file source we are looking for as zero.
4527  *
4528  * If/when Ardour supports native files in non-mono formats, the logic here
4529  * will need to be revisited.
4530  */
4531 bool
4532 Session::audio_source_name_is_unique (const string& name)
4533 {
4534         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4535         vector<space_and_path>::iterator i;
4536         uint32_t existing = 0;
4537
4538         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4539
4540                 /* note that we search *without* the extension so that
4541                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4542                    in the event that this new name is required for
4543                    a file format change.
4544                 */
4545
4546                 const string spath = *i;
4547
4548                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4549                         existing++;
4550                         break;
4551                 }
4552
4553                 /* it is possible that we have the path already
4554                  * assigned to a source that has not yet been written
4555                  * (ie. the write source for a diskstream). we have to
4556                  * check this in order to make sure that our candidate
4557                  * path isn't used again, because that can lead to
4558                  * two Sources point to the same file with different
4559                  * notions of their removability.
4560                  */
4561
4562
4563                 string possible_path = Glib::build_filename (spath, name);
4564
4565                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4566                         existing++;
4567                         break;
4568                 }
4569         }
4570
4571         return (existing == 0);
4572 }
4573
4574 string
4575 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)
4576 {
4577         ostringstream sstr;
4578         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4579
4580         if (Profile->get_trx() && destructive) {
4581                 sstr << 'T';
4582                 sstr << setfill ('0') << setw (4) << cnt;
4583                 sstr << legalized_base;
4584         } else {
4585                 sstr << legalized_base;
4586
4587                 if (take_required || related_exists) {
4588                         sstr << '-';
4589                         sstr << cnt;
4590                 }
4591         }
4592
4593         if (nchan == 2) {
4594                 if (chan == 0) {
4595                         sstr << "%L";
4596                 } else {
4597                         sstr << "%R";
4598                 }
4599         } else if (nchan > 2) {
4600                 if (nchan < 26) {
4601                         sstr << '%';
4602                         sstr << 'a' + chan;
4603                 } else {
4604                         /* XXX what? more than 26 channels! */
4605                         sstr << '%';
4606                         sstr << chan+1;
4607                 }
4608         }
4609
4610         sstr << ext;
4611
4612         return sstr.str();
4613 }
4614
4615 /** Return a unique name based on \a base for a new internal audio source */
4616 string
4617 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4618 {
4619         uint32_t cnt;
4620         string possible_name;
4621         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4622         string legalized;
4623         bool some_related_source_name_exists = false;
4624
4625         legalized = legalize_for_path (base);
4626
4627         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4628
4629         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4630
4631                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4632
4633                 if (audio_source_name_is_unique (possible_name)) {
4634                         break;
4635                 }
4636
4637                 some_related_source_name_exists = true;
4638
4639                 if (cnt > limit) {
4640                         error << string_compose(
4641                                         _("There are already %1 recordings for %2, which I consider too many."),
4642                                         limit, base) << endmsg;
4643                         destroy ();
4644                         throw failed_constructor();
4645                 }
4646         }
4647
4648         /* We've established that the new name does not exist in any session
4649          * directory, so now find out which one we should use for this new
4650          * audio source.
4651          */
4652
4653         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4654
4655         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4656
4657         return s;
4658 }
4659
4660 /** Return a unique name based on `base` for a new internal MIDI source */
4661 string
4662 Session::new_midi_source_path (const string& base)
4663 {
4664         uint32_t cnt;
4665         char buf[PATH_MAX+1];
4666         const uint32_t limit = 10000;
4667         string legalized;
4668         string possible_path;
4669         string possible_name;
4670
4671         buf[0] = '\0';
4672         legalized = legalize_for_path (base);
4673
4674         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4675         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4676
4677         /* - the main session folder is the first in the vector.
4678          * - after checking all locations for file-name uniqueness,
4679          *   we keep the one from the last iteration as new file name
4680          * - midi files are small and should just be kept in the main session-folder
4681          *
4682          * -> reverse the array, check main session folder last and use that as location
4683          *    for MIDI files.
4684          */
4685         std::reverse(sdirs.begin(), sdirs.end());
4686
4687         for (cnt = 1; cnt <= limit; ++cnt) {
4688
4689                 vector<space_and_path>::iterator i;
4690                 uint32_t existing = 0;
4691
4692                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4693
4694                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4695                         possible_name = buf;
4696
4697                         possible_path = Glib::build_filename (*i, possible_name);
4698
4699                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4700                                 existing++;
4701                         }
4702
4703                         if (midi_source_by_path (possible_path)) {
4704                                 existing++;
4705                         }
4706                 }
4707
4708                 if (existing == 0) {
4709                         break;
4710                 }
4711
4712                 if (cnt > limit) {
4713                         error << string_compose(
4714                                         _("There are already %1 recordings for %2, which I consider too many."),
4715                                         limit, base) << endmsg;
4716                         destroy ();
4717                         return 0;
4718                 }
4719         }
4720
4721         /* No need to "find best location" for software/app-based RAID, because
4722            MIDI is so small that we always put it in the same place.
4723         */
4724
4725         return possible_path;
4726 }
4727
4728
4729 /** Create a new within-session audio source */
4730 boost::shared_ptr<AudioFileSource>
4731 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4732 {
4733         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4734
4735         if (!path.empty()) {
4736                 return boost::dynamic_pointer_cast<AudioFileSource> (
4737                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
4738         } else {
4739                 throw failed_constructor ();
4740         }
4741 }
4742
4743 /** Create a new within-session MIDI source */
4744 boost::shared_ptr<MidiSource>
4745 Session::create_midi_source_for_session (string const & basic_name)
4746 {
4747         const string path = new_midi_source_path (basic_name);
4748
4749         if (!path.empty()) {
4750                 return boost::dynamic_pointer_cast<SMFSource> (
4751                         SourceFactory::createWritable (
4752                                 DataType::MIDI, *this, path, false, frame_rate()));
4753         } else {
4754                 throw failed_constructor ();
4755         }
4756 }
4757
4758 /** Create a new within-session MIDI source */
4759 boost::shared_ptr<MidiSource>
4760 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4761 {
4762         /* the caller passes in the track the source will be used in,
4763            so that we can keep the numbering sane.
4764
4765            Rationale: a track with the name "Foo" that has had N
4766            captures carried out so far will ALREADY have a write source
4767            named "Foo-N+1.mid" waiting to be used for the next capture.
4768
4769            If we call new_midi_source_name() we will get "Foo-N+2". But
4770            there is no region corresponding to "Foo-N+1", so when
4771            "Foo-N+2" appears in the track, the gap presents the user
4772            with odd behaviour - why did it skip past Foo-N+1?
4773
4774            We could explain this to the user in some odd way, but
4775            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4776            use "Foo-N+1" here.
4777
4778            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4779         */
4780
4781         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4782         assert (mt);
4783         std::string name = track->steal_write_source_name ();
4784
4785         if (name.empty()) {
4786                 return boost::shared_ptr<MidiSource>();
4787         }
4788
4789         /* MIDI files are small, just put them in the first location of the
4790            session source search path.
4791         */
4792
4793         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4794
4795         return boost::dynamic_pointer_cast<SMFSource> (
4796                 SourceFactory::createWritable (
4797                         DataType::MIDI, *this, path, false, frame_rate()));
4798 }
4799
4800
4801 void
4802 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4803 {
4804         if (playlist->hidden()) {
4805                 return;
4806         }
4807
4808         playlists->add (playlist);
4809
4810         if (unused) {
4811                 playlist->release();
4812         }
4813
4814         set_dirty();
4815 }
4816
4817 void
4818 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4819 {
4820         if (_state_of_the_state & Deletion) {
4821                 return;
4822         }
4823
4824         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4825
4826         if (!playlist) {
4827                 return;
4828         }
4829
4830         playlists->remove (playlist);
4831
4832         set_dirty();
4833 }
4834
4835 void
4836 Session::set_audition (boost::shared_ptr<Region> r)
4837 {
4838         pending_audition_region = r;
4839         add_post_transport_work (PostTransportAudition);
4840         _butler->schedule_transport_work ();
4841 }
4842
4843 void
4844 Session::audition_playlist ()
4845 {
4846         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4847         ev->region.reset ();
4848         queue_event (ev);
4849 }
4850
4851 void
4852 Session::non_realtime_set_audition ()
4853 {
4854         assert (pending_audition_region);
4855         auditioner->audition_region (pending_audition_region);
4856         pending_audition_region.reset ();
4857         AuditionActive (true); /* EMIT SIGNAL */
4858 }
4859
4860 void
4861 Session::audition_region (boost::shared_ptr<Region> r)
4862 {
4863         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4864         ev->region = r;
4865         queue_event (ev);
4866 }
4867
4868 void
4869 Session::cancel_audition ()
4870 {
4871         if (!auditioner) {
4872                 return;
4873         }
4874         if (auditioner->auditioning()) {
4875                 auditioner->cancel_audition ();
4876                 AuditionActive (false); /* EMIT SIGNAL */
4877         }
4878 }
4879
4880 bool
4881 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4882 {
4883         if (a->is_monitor()) {
4884                 return true;
4885         }
4886         if (b->is_monitor()) {
4887                 return false;
4888         }
4889         return a->order_key () < b->order_key ();
4890 }
4891
4892 bool
4893 Session::is_auditioning () const
4894 {
4895         /* can be called before we have an auditioner object */
4896         if (auditioner) {
4897                 return auditioner->auditioning();
4898         } else {
4899                 return false;
4900         }
4901 }
4902
4903 void
4904 Session::graph_reordered ()
4905 {
4906         /* don't do this stuff if we are setting up connections
4907            from a set_state() call or creating new tracks. Ditto for deletion.
4908         */
4909
4910         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
4911                 return;
4912         }
4913
4914         /* every track/bus asked for this to be handled but it was deferred because
4915            we were connecting. do it now.
4916         */
4917
4918         request_input_change_handling ();
4919
4920         resort_routes ();
4921
4922         /* force all diskstreams to update their capture offset values to
4923            reflect any changes in latencies within the graph.
4924         */
4925
4926         boost::shared_ptr<RouteList> rl = routes.reader ();
4927         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4928                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4929                 if (tr) {
4930                         tr->set_capture_offset ();
4931                 }
4932         }
4933 }
4934
4935 /** @return Number of frames that there is disk space available to write,
4936  *  if known.
4937  */
4938 boost::optional<framecnt_t>
4939 Session::available_capture_duration ()
4940 {
4941         Glib::Threads::Mutex::Lock lm (space_lock);
4942
4943         if (_total_free_4k_blocks_uncertain) {
4944                 return boost::optional<framecnt_t> ();
4945         }
4946
4947         float sample_bytes_on_disk = 4.0; // keep gcc happy
4948
4949         switch (config.get_native_file_data_format()) {
4950         case FormatFloat:
4951                 sample_bytes_on_disk = 4.0;
4952                 break;
4953
4954         case FormatInt24:
4955                 sample_bytes_on_disk = 3.0;
4956                 break;
4957
4958         case FormatInt16:
4959                 sample_bytes_on_disk = 2.0;
4960                 break;
4961
4962         default:
4963                 /* impossible, but keep some gcc versions happy */
4964                 fatal << string_compose (_("programming error: %1"),
4965                                          X_("illegal native file data format"))
4966                       << endmsg;
4967                 abort(); /*NOTREACHED*/
4968         }
4969
4970         double scale = 4096.0 / sample_bytes_on_disk;
4971
4972         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4973                 return max_framecnt;
4974         }
4975
4976         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4977 }
4978
4979 void
4980 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
4981 {
4982         {
4983                 RCUWriter<BundleList> writer (_bundles);
4984                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4985                 b->push_back (bundle);
4986         }
4987
4988         if (emit_signal) {
4989                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4990         }
4991
4992         set_dirty();
4993 }
4994
4995 void
4996 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4997 {
4998         bool removed = false;
4999
5000         {
5001                 RCUWriter<BundleList> writer (_bundles);
5002                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5003                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5004
5005                 if (i != b->end()) {
5006                         b->erase (i);
5007                         removed = true;
5008                 }
5009         }
5010
5011         if (removed) {
5012                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5013         }
5014
5015         set_dirty();
5016 }
5017
5018 boost::shared_ptr<Bundle>
5019 Session::bundle_by_name (string name) const
5020 {
5021         boost::shared_ptr<BundleList> b = _bundles.reader ();
5022
5023         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5024                 if ((*i)->name() == name) {
5025                         return* i;
5026                 }
5027         }
5028
5029         return boost::shared_ptr<Bundle> ();
5030 }
5031
5032 void
5033 Session::tempo_map_changed (const PropertyChange&)
5034 {
5035         clear_clicks ();
5036
5037         playlists->update_after_tempo_map_change ();
5038
5039         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5040
5041         set_dirty ();
5042 }
5043
5044 void
5045 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5046 {
5047         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5048                 (*i)->recompute_frames_from_bbt ();
5049         }
5050 }
5051
5052 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5053  * the given count with the current block size.
5054  */
5055 void
5056 Session::ensure_buffers (ChanCount howmany)
5057 {
5058         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5059 }
5060
5061 void
5062 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5063 {
5064         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5065                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5066         }
5067 }
5068
5069 uint32_t
5070 Session::next_insert_id ()
5071 {
5072         /* this doesn't really loop forever. just think about it */
5073
5074         while (true) {
5075                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
5076                         if (!insert_bitset[n]) {
5077                                 insert_bitset[n] = true;
5078                                 return n;
5079
5080                         }
5081                 }
5082
5083                 /* none available, so resize and try again */
5084
5085                 insert_bitset.resize (insert_bitset.size() + 16, false);
5086         }
5087 }
5088
5089 uint32_t
5090 Session::next_send_id ()
5091 {
5092         /* this doesn't really loop forever. just think about it */
5093
5094         while (true) {
5095                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
5096                         if (!send_bitset[n]) {
5097                                 send_bitset[n] = true;
5098                                 return n;
5099
5100                         }
5101                 }
5102
5103                 /* none available, so resize and try again */
5104
5105                 send_bitset.resize (send_bitset.size() + 16, false);
5106         }
5107 }
5108
5109 uint32_t
5110 Session::next_aux_send_id ()
5111 {
5112         /* this doesn't really loop forever. just think about it */
5113
5114         while (true) {
5115                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
5116                         if (!aux_send_bitset[n]) {
5117                                 aux_send_bitset[n] = true;
5118                                 return n;
5119
5120                         }
5121                 }
5122
5123                 /* none available, so resize and try again */
5124
5125                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5126         }
5127 }
5128
5129 uint32_t
5130 Session::next_return_id ()
5131 {
5132         /* this doesn't really loop forever. just think about it */
5133
5134         while (true) {
5135                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
5136                         if (!return_bitset[n]) {
5137                                 return_bitset[n] = true;
5138                                 return n;
5139
5140                         }
5141                 }
5142
5143                 /* none available, so resize and try again */
5144
5145                 return_bitset.resize (return_bitset.size() + 16, false);
5146         }
5147 }
5148
5149 void
5150 Session::mark_send_id (uint32_t id)
5151 {
5152         if (id >= send_bitset.size()) {
5153                 send_bitset.resize (id+16, false);
5154         }
5155         if (send_bitset[id]) {
5156                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5157         }
5158         send_bitset[id] = true;
5159 }
5160
5161 void
5162 Session::mark_aux_send_id (uint32_t id)
5163 {
5164         if (id >= aux_send_bitset.size()) {
5165                 aux_send_bitset.resize (id+16, false);
5166         }
5167         if (aux_send_bitset[id]) {
5168                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5169         }
5170         aux_send_bitset[id] = true;
5171 }
5172
5173 void
5174 Session::mark_return_id (uint32_t id)
5175 {
5176         if (id >= return_bitset.size()) {
5177                 return_bitset.resize (id+16, false);
5178         }
5179         if (return_bitset[id]) {
5180                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5181         }
5182         return_bitset[id] = true;
5183 }
5184
5185 void
5186 Session::mark_insert_id (uint32_t id)
5187 {
5188         if (id >= insert_bitset.size()) {
5189                 insert_bitset.resize (id+16, false);
5190         }
5191         if (insert_bitset[id]) {
5192                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5193         }
5194         insert_bitset[id] = true;
5195 }
5196
5197 void
5198 Session::unmark_send_id (uint32_t id)
5199 {
5200         if (id < send_bitset.size()) {
5201                 send_bitset[id] = false;
5202         }
5203 }
5204
5205 void
5206 Session::unmark_aux_send_id (uint32_t id)
5207 {
5208         if (id < aux_send_bitset.size()) {
5209                 aux_send_bitset[id] = false;
5210         }
5211 }
5212
5213 void
5214 Session::unmark_return_id (uint32_t id)
5215 {
5216         if (id < return_bitset.size()) {
5217                 return_bitset[id] = false;
5218         }
5219 }
5220
5221 void
5222 Session::unmark_insert_id (uint32_t id)
5223 {
5224         if (id < insert_bitset.size()) {
5225                 insert_bitset[id] = false;
5226         }
5227 }
5228
5229 void
5230 Session::reset_native_file_format ()
5231 {
5232         boost::shared_ptr<RouteList> rl = routes.reader ();
5233
5234         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5235                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5236                 if (tr) {
5237                         /* don't save state as we do this, there's no point
5238                          */
5239                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5240                         tr->reset_write_sources (false);
5241                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5242                 }
5243         }
5244 }
5245
5246 bool
5247 Session::route_name_unique (string n) const
5248 {
5249         boost::shared_ptr<RouteList> r = routes.reader ();
5250
5251         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5252                 if ((*i)->name() == n) {
5253                         return false;
5254                 }
5255         }
5256
5257         return true;
5258 }
5259
5260 bool
5261 Session::route_name_internal (string n) const
5262 {
5263         if (auditioner && auditioner->name() == n) {
5264                 return true;
5265         }
5266
5267         if (_click_io && _click_io->name() == n) {
5268                 return true;
5269         }
5270
5271         return false;
5272 }
5273
5274 int
5275 Session::freeze_all (InterThreadInfo& itt)
5276 {
5277         boost::shared_ptr<RouteList> r = routes.reader ();
5278
5279         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5280
5281                 boost::shared_ptr<Track> t;
5282
5283                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5284                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5285                            of every track.
5286                         */
5287                         t->freeze_me (itt);
5288                 }
5289         }
5290
5291         return 0;
5292 }
5293
5294 boost::shared_ptr<Region>
5295 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5296                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5297                           InterThreadInfo& itt,
5298                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5299                           bool for_export, bool for_freeze)
5300 {
5301         boost::shared_ptr<Region> result;
5302         boost::shared_ptr<Playlist> playlist;
5303         boost::shared_ptr<Source> source;
5304         ChanCount diskstream_channels (track.n_channels());
5305         framepos_t position;
5306         framecnt_t this_chunk;
5307         framepos_t to_do;
5308         framepos_t latency_skip;
5309         BufferSet buffers;
5310         framepos_t len = end - start;
5311         bool need_block_size_reset = false;
5312         ChanCount const max_proc = track.max_processor_streams ();
5313         string legal_playlist_name;
5314         string possible_path;
5315
5316         if (end <= start) {
5317                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5318                                          end, start) << endmsg;
5319                 return result;
5320         }
5321
5322         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5323                         include_endpoint, for_export, for_freeze);
5324
5325         if (diskstream_channels.n(track.data_type()) < 1) {
5326                 error << _("Cannot write a range with no data.") << endmsg;
5327                 return result;
5328         }
5329
5330         // block all process callback handling
5331
5332         block_processing ();
5333
5334         {
5335                 // synchronize with AudioEngine::process_callback()
5336                 // make sure processing is not currently running
5337                 // and processing_blocked() is honored before
5338                 // acquiring thread buffers
5339                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5340         }
5341
5342         _bounce_processing_active = true;
5343
5344         /* call tree *MUST* hold route_lock */
5345
5346         if ((playlist = track.playlist()) == 0) {
5347                 goto out;
5348         }
5349
5350         legal_playlist_name = legalize_for_path (playlist->name());
5351
5352         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5353
5354                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5355                 string path = ((track.data_type() == DataType::AUDIO)
5356                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5357                                : new_midi_source_path (legal_playlist_name));
5358
5359                 if (path.empty()) {
5360                         goto out;
5361                 }
5362
5363                 try {
5364                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5365                 }
5366
5367                 catch (failed_constructor& err) {
5368                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5369                         goto out;
5370                 }
5371
5372                 srcs.push_back (source);
5373         }
5374
5375         /* tell redirects that care that we are about to use a much larger
5376          * blocksize. this will flush all plugins too, so that they are ready
5377          * to be used for this process.
5378          */
5379
5380         need_block_size_reset = true;
5381         track.set_block_size (bounce_chunk_size);
5382         _engine.main_thread()->get_buffers ();
5383
5384         position = start;
5385         to_do = len;
5386         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5387
5388         /* create a set of reasonably-sized buffers */
5389         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5390                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5391         }
5392         buffers.set_count (max_proc);
5393
5394         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5395                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5396                 boost::shared_ptr<MidiSource> ms;
5397                 if (afs) {
5398                         afs->prepare_for_peakfile_writes ();
5399                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5400                         Source::Lock lock(ms->mutex());
5401                         ms->mark_streaming_write_started(lock);
5402                 }
5403         }
5404
5405         while (to_do && !itt.cancel) {
5406
5407                 this_chunk = min (to_do, bounce_chunk_size);
5408
5409                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5410                         goto out;
5411                 }
5412
5413                 start += this_chunk;
5414                 to_do -= this_chunk;
5415                 itt.progress = (float) (1.0 - ((double) to_do / len));
5416
5417                 if (latency_skip >= bounce_chunk_size) {
5418                         latency_skip -= bounce_chunk_size;
5419                         continue;
5420                 }
5421
5422                 const framecnt_t current_chunk = this_chunk - latency_skip;
5423
5424                 uint32_t n = 0;
5425                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5426                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5427                         boost::shared_ptr<MidiSource> ms;
5428
5429                         if (afs) {
5430                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5431                                         goto out;
5432                                 }
5433                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5434                                 Source::Lock lock(ms->mutex());
5435
5436                                 const MidiBuffer& buf = buffers.get_midi(0);
5437                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5438                                         Evoral::Event<framepos_t> ev = *i;
5439                                         ev.set_time(ev.time() - position);
5440                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5441                                 }
5442                         }
5443                 }
5444                 latency_skip = 0;
5445         }
5446
5447         /* post-roll, pick up delayed processor output */
5448         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5449
5450         while (latency_skip && !itt.cancel) {
5451                 this_chunk = min (latency_skip, bounce_chunk_size);
5452                 latency_skip -= this_chunk;
5453
5454                 buffers.silence (this_chunk, 0);
5455                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5456
5457                 uint32_t n = 0;
5458                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5459                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5460
5461                         if (afs) {
5462                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5463                                         goto out;
5464                                 }
5465                         }
5466                 }
5467         }
5468
5469         if (!itt.cancel) {
5470
5471                 time_t now;
5472                 struct tm* xnow;
5473                 time (&now);
5474                 xnow = localtime (&now);
5475
5476                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5477                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5478                         boost::shared_ptr<MidiSource> ms;
5479
5480                         if (afs) {
5481                                 afs->update_header (position, *xnow, now);
5482                                 afs->flush_header ();
5483                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5484                                 Source::Lock lock(ms->mutex());
5485                                 ms->mark_streaming_write_completed(lock);
5486                         }
5487                 }
5488
5489                 /* construct a region to represent the bounced material */
5490
5491                 PropertyList plist;
5492
5493                 plist.add (Properties::start, 0);
5494                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5495                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5496
5497                 result = RegionFactory::create (srcs, plist);
5498
5499         }
5500
5501   out:
5502         if (!result) {
5503                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5504                         (*src)->mark_for_remove ();
5505                         (*src)->drop_references ();
5506                 }
5507
5508         } else {
5509                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5510                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5511
5512                         if (afs)
5513                                 afs->done_with_peakfile_writes ();
5514                 }
5515         }
5516
5517         _bounce_processing_active = false;
5518
5519         if (need_block_size_reset) {
5520                 _engine.main_thread()->drop_buffers ();
5521                 track.set_block_size (get_block_size());
5522         }
5523
5524         unblock_processing ();
5525
5526         return result;
5527 }
5528
5529 gain_t*
5530 Session::gain_automation_buffer() const
5531 {
5532         return ProcessThread::gain_automation_buffer ();
5533 }
5534
5535 gain_t*
5536 Session::trim_automation_buffer() const
5537 {
5538         return ProcessThread::trim_automation_buffer ();
5539 }
5540
5541 gain_t*
5542 Session::send_gain_automation_buffer() const
5543 {
5544         return ProcessThread::send_gain_automation_buffer ();
5545 }
5546
5547 pan_t**
5548 Session::pan_automation_buffer() const
5549 {
5550         return ProcessThread::pan_automation_buffer ();
5551 }
5552
5553 BufferSet&
5554 Session::get_silent_buffers (ChanCount count)
5555 {
5556         return ProcessThread::get_silent_buffers (count);
5557 }
5558
5559 BufferSet&
5560 Session::get_scratch_buffers (ChanCount count, bool silence)
5561 {
5562         return ProcessThread::get_scratch_buffers (count, silence);
5563 }
5564
5565 BufferSet&
5566 Session::get_route_buffers (ChanCount count, bool silence)
5567 {
5568         return ProcessThread::get_route_buffers (count, silence);
5569 }
5570
5571
5572 BufferSet&
5573 Session::get_mix_buffers (ChanCount count)
5574 {
5575         return ProcessThread::get_mix_buffers (count);
5576 }
5577
5578 uint32_t
5579 Session::ntracks () const
5580 {
5581         uint32_t n = 0;
5582         boost::shared_ptr<RouteList> r = routes.reader ();
5583
5584         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5585                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5586                         ++n;
5587                 }
5588         }
5589
5590         return n;
5591 }
5592
5593 uint32_t
5594 Session::nbusses () const
5595 {
5596         uint32_t n = 0;
5597         boost::shared_ptr<RouteList> r = routes.reader ();
5598
5599         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5600                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5601                         ++n;
5602                 }
5603         }
5604
5605         return n;
5606 }
5607
5608 void
5609 Session::add_automation_list(AutomationList *al)
5610 {
5611         automation_lists[al->id()] = al;
5612 }
5613
5614 /** @return true if there is at least one record-enabled track, otherwise false */
5615 bool
5616 Session::have_rec_enabled_track () const
5617 {
5618         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5619 }
5620
5621 bool
5622 Session::have_rec_disabled_track () const
5623 {
5624     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5625 }
5626
5627 /** Update the state of our rec-enabled tracks flag */
5628 void
5629 Session::update_route_record_state ()
5630 {
5631         boost::shared_ptr<RouteList> rl = routes.reader ();
5632         RouteList::iterator i = rl->begin();
5633         while (i != rl->end ()) {
5634
5635                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5636                 if (tr && tr->record_enabled ()) {
5637                         break;
5638                 }
5639
5640                 ++i;
5641         }
5642
5643         int const old = g_atomic_int_get (&_have_rec_enabled_track);
5644
5645         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5646
5647         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5648                 RecordStateChanged (); /* EMIT SIGNAL */
5649         }
5650
5651         for (i = rl->begin(); i != rl->end (); ++i) {
5652                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5653                 if (tr && !tr->record_enabled ()) {
5654                         break;
5655                 }
5656         }
5657
5658         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5659
5660         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
5661
5662         if (record_status() == Recording && record_arm_state_changed ) {
5663                 RecordArmStateChanged ();
5664         }
5665
5666 }
5667
5668 void
5669 Session::listen_position_changed ()
5670 {
5671         boost::shared_ptr<RouteList> r = routes.reader ();
5672
5673         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5674                 (*i)->listen_position_changed ();
5675         }
5676 }
5677
5678 void
5679 Session::solo_control_mode_changed ()
5680 {
5681         /* cancel all solo or all listen when solo control mode changes */
5682
5683         if (soloing()) {
5684                 set_solo (get_routes(), false);
5685         } else if (listening()) {
5686                 set_listen (get_routes(), false);
5687         }
5688 }
5689
5690 /** Called when a property of one of our route groups changes */
5691 void
5692 Session::route_group_property_changed (RouteGroup* rg)
5693 {
5694         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5695 }
5696
5697 /** Called when a route is added to one of our route groups */
5698 void
5699 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5700 {
5701         RouteAddedToRouteGroup (rg, r);
5702 }
5703
5704 /** Called when a route is removed from one of our route groups */
5705 void
5706 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5707 {
5708         update_route_record_state ();
5709         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5710 }
5711
5712 boost::shared_ptr<RouteList>
5713 Session::get_tracks () const
5714 {
5715         boost::shared_ptr<RouteList> rl = routes.reader ();
5716         boost::shared_ptr<RouteList> tl (new RouteList);
5717
5718         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5719                 if (boost::dynamic_pointer_cast<Track> (*r)) {
5720                         if (!(*r)->is_auditioner()) {
5721                                 tl->push_back (*r);
5722                         }
5723                 }
5724         }
5725         return tl;
5726 }
5727
5728 boost::shared_ptr<RouteList>
5729 Session::get_routes_with_regions_at (framepos_t const p) const
5730 {
5731         boost::shared_ptr<RouteList> r = routes.reader ();
5732         boost::shared_ptr<RouteList> rl (new RouteList);
5733
5734         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5735                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5736                 if (!tr) {
5737                         continue;
5738                 }
5739
5740                 boost::shared_ptr<Playlist> pl = tr->playlist ();
5741                 if (!pl) {
5742                         continue;
5743                 }
5744
5745                 if (pl->has_region_at (p)) {
5746                         rl->push_back (*i);
5747                 }
5748         }
5749
5750         return rl;
5751 }
5752
5753 void
5754 Session::goto_end ()
5755 {
5756         if (_session_range_location) {
5757                 request_locate (_session_range_location->end(), false);
5758         } else {
5759                 request_locate (0, false);
5760         }
5761 }
5762
5763 void
5764 Session::goto_start ()
5765 {
5766         if (_session_range_location) {
5767                 request_locate (_session_range_location->start(), false);
5768         } else {
5769                 request_locate (0, false);
5770         }
5771 }
5772
5773 framepos_t
5774 Session::current_start_frame () const
5775 {
5776         return _session_range_location ? _session_range_location->start() : 0;
5777 }
5778
5779 framepos_t
5780 Session::current_end_frame () const
5781 {
5782         return _session_range_location ? _session_range_location->end() : 0;
5783 }
5784
5785 void
5786 Session::set_session_range_location (framepos_t start, framepos_t end)
5787 {
5788         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5789         _locations->add (_session_range_location);
5790 }
5791
5792 void
5793 Session::step_edit_status_change (bool yn)
5794 {
5795         bool send = false;
5796
5797         bool val = false;
5798         if (yn) {
5799                 send = (_step_editors == 0);
5800                 val = true;
5801
5802                 _step_editors++;
5803         } else {
5804                 send = (_step_editors == 1);
5805                 val = false;
5806
5807                 if (_step_editors > 0) {
5808                         _step_editors--;
5809                 }
5810         }
5811
5812         if (send) {
5813                 StepEditStatusChange (val);
5814         }
5815 }
5816
5817
5818 void
5819 Session::start_time_changed (framepos_t old)
5820 {
5821         /* Update the auto loop range to match the session range
5822            (unless the auto loop range has been changed by the user)
5823         */
5824
5825         Location* s = _locations->session_range_location ();
5826         if (s == 0) {
5827                 return;
5828         }
5829
5830         Location* l = _locations->auto_loop_location ();
5831
5832         if (l && l->start() == old) {
5833                 l->set_start (s->start(), true);
5834         }
5835 }
5836
5837 void
5838 Session::end_time_changed (framepos_t old)
5839 {
5840         /* Update the auto loop range to match the session range
5841            (unless the auto loop range has been changed by the user)
5842         */
5843
5844         Location* s = _locations->session_range_location ();
5845         if (s == 0) {
5846                 return;
5847         }
5848
5849         Location* l = _locations->auto_loop_location ();
5850
5851         if (l && l->end() == old) {
5852                 l->set_end (s->end(), true);
5853         }
5854 }
5855
5856 std::vector<std::string>
5857 Session::source_search_path (DataType type) const
5858 {
5859         Searchpath sp;
5860
5861         if (session_dirs.size() == 1) {
5862                 switch (type) {
5863                 case DataType::AUDIO:
5864                         sp.push_back (_session_dir->sound_path());
5865                         break;
5866                 case DataType::MIDI:
5867                         sp.push_back (_session_dir->midi_path());
5868                         break;
5869                 }
5870         } else {
5871                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5872                         SessionDirectory sdir (i->path);
5873                         switch (type) {
5874                         case DataType::AUDIO:
5875                                 sp.push_back (sdir.sound_path());
5876                                 break;
5877                         case DataType::MIDI:
5878                                 sp.push_back (sdir.midi_path());
5879                                 break;
5880                         }
5881                 }
5882         }
5883
5884         if (type == DataType::AUDIO) {
5885                 const string sound_path_2X = _session_dir->sound_path_2X();
5886                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5887                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5888                                 sp.push_back (sound_path_2X);
5889                         }
5890                 }
5891         }
5892
5893         // now check the explicit (possibly user-specified) search path
5894
5895         switch (type) {
5896         case DataType::AUDIO:
5897                 sp += Searchpath(config.get_audio_search_path ());
5898                 break;
5899         case DataType::MIDI:
5900                 sp += Searchpath(config.get_midi_search_path ());
5901                 break;
5902         }
5903
5904         return sp;
5905 }
5906
5907 void
5908 Session::ensure_search_path_includes (const string& path, DataType type)
5909 {
5910         Searchpath sp;
5911
5912         if (path == ".") {
5913                 return;
5914         }
5915
5916         switch (type) {
5917         case DataType::AUDIO:
5918                 sp += Searchpath(config.get_audio_search_path ());
5919                 break;
5920         case DataType::MIDI:
5921                 sp += Searchpath (config.get_midi_search_path ());
5922                 break;
5923         }
5924
5925         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5926                 /* No need to add this new directory if it has the same inode as
5927                    an existing one; checking inode rather than name prevents duplicated
5928                    directories when we are using symlinks.
5929
5930                    On Windows, I think we could just do if (*i == path) here.
5931                 */
5932                 if (PBD::equivalent_paths (*i, path)) {
5933                         return;
5934                 }
5935         }
5936
5937         sp += path;
5938
5939         switch (type) {
5940         case DataType::AUDIO:
5941                 config.set_audio_search_path (sp.to_string());
5942                 break;
5943         case DataType::MIDI:
5944                 config.set_midi_search_path (sp.to_string());
5945                 break;
5946         }
5947 }
5948
5949 void
5950 Session::remove_dir_from_search_path (const string& dir, DataType type)
5951 {
5952         Searchpath sp;
5953
5954         switch (type) {
5955         case DataType::AUDIO:
5956                 sp = Searchpath(config.get_audio_search_path ());
5957                 break;
5958         case DataType::MIDI:
5959                 sp = Searchpath (config.get_midi_search_path ());
5960                 break;
5961         }
5962
5963         sp -= dir;
5964
5965         switch (type) {
5966         case DataType::AUDIO:
5967                 config.set_audio_search_path (sp.to_string());
5968                 break;
5969         case DataType::MIDI:
5970                 config.set_midi_search_path (sp.to_string());
5971                 break;
5972         }
5973
5974 }
5975
5976 boost::shared_ptr<Speakers>
5977 Session::get_speakers()
5978 {
5979         return _speakers;
5980 }
5981
5982 list<string>
5983 Session::unknown_processors () const
5984 {
5985         list<string> p;
5986
5987         boost::shared_ptr<RouteList> r = routes.reader ();
5988         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5989                 list<string> t = (*i)->unknown_processors ();
5990                 copy (t.begin(), t.end(), back_inserter (p));
5991         }
5992
5993         p.sort ();
5994         p.unique ();
5995
5996         return p;
5997 }
5998
5999 void
6000 Session::update_latency (bool playback)
6001 {
6002         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6003
6004         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
6005                 return;
6006         }
6007
6008         boost::shared_ptr<RouteList> r = routes.reader ();
6009         framecnt_t max_latency = 0;
6010
6011         if (playback) {
6012                 /* reverse the list so that we work backwards from the last route to run to the first */
6013                 RouteList* rl = routes.reader().get();
6014                 r.reset (new RouteList (*rl));
6015                 reverse (r->begin(), r->end());
6016         }
6017
6018         /* compute actual latency values for the given direction and store them all in per-port
6019            structures. this will also publish the same values (to JACK) so that computation of latency
6020            for routes can consistently use public latency values.
6021         */
6022
6023         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6024                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6025         }
6026
6027         /* because we latency compensate playback, our published playback latencies should
6028            be the same for all output ports - all material played back by ardour has
6029            the same latency, whether its caused by plugins or by latency compensation. since
6030            these may differ from the values computed above, reset all playback port latencies
6031            to the same value.
6032         */
6033
6034         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6035
6036         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6037                 (*i)->set_public_port_latencies (max_latency, playback);
6038         }
6039
6040         if (playback) {
6041
6042                 post_playback_latency ();
6043
6044         } else {
6045
6046                 post_capture_latency ();
6047         }
6048
6049         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6050 }
6051
6052 void
6053 Session::post_playback_latency ()
6054 {
6055         set_worst_playback_latency ();
6056
6057         boost::shared_ptr<RouteList> r = routes.reader ();
6058
6059         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6060                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6061                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6062                 }
6063         }
6064
6065         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6066                 (*i)->set_latency_compensation (_worst_track_latency);
6067         }
6068 }
6069
6070 void
6071 Session::post_capture_latency ()
6072 {
6073         set_worst_capture_latency ();
6074
6075         /* reflect any changes in capture latencies into capture offsets
6076          */
6077
6078         boost::shared_ptr<RouteList> rl = routes.reader();
6079         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6080                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6081                 if (tr) {
6082                         tr->set_capture_offset ();
6083                 }
6084         }
6085 }
6086
6087 void
6088 Session::initialize_latencies ()
6089 {
6090         {
6091                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6092                 update_latency (false);
6093                 update_latency (true);
6094         }
6095
6096         set_worst_io_latencies ();
6097 }
6098
6099 void
6100 Session::set_worst_io_latencies ()
6101 {
6102         set_worst_playback_latency ();
6103         set_worst_capture_latency ();
6104 }
6105
6106 void
6107 Session::set_worst_playback_latency ()
6108 {
6109         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6110                 return;
6111         }
6112
6113         _worst_output_latency = 0;
6114
6115         if (!_engine.connected()) {
6116                 return;
6117         }
6118
6119         boost::shared_ptr<RouteList> r = routes.reader ();
6120
6121         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6122                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6123         }
6124
6125         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6126 }
6127
6128 void
6129 Session::set_worst_capture_latency ()
6130 {
6131         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6132                 return;
6133         }
6134
6135         _worst_input_latency = 0;
6136
6137         if (!_engine.connected()) {
6138                 return;
6139         }
6140
6141         boost::shared_ptr<RouteList> r = routes.reader ();
6142
6143         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6144                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6145         }
6146
6147         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6148 }
6149
6150 void
6151 Session::update_latency_compensation (bool force_whole_graph)
6152 {
6153         bool some_track_latency_changed = false;
6154
6155         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6156                 return;
6157         }
6158
6159         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6160
6161         _worst_track_latency = 0;
6162
6163         boost::shared_ptr<RouteList> r = routes.reader ();
6164
6165         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6166                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6167                         framecnt_t tl;
6168                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6169                                 some_track_latency_changed = true;
6170                         }
6171                         _worst_track_latency = max (tl, _worst_track_latency);
6172                 }
6173         }
6174
6175         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6176                                                      (some_track_latency_changed ? "yes" : "no")));
6177
6178         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6179
6180         if (some_track_latency_changed || force_whole_graph)  {
6181                 _engine.update_latencies ();
6182         }
6183
6184
6185         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6186                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6187                 if (!tr) {
6188                         continue;
6189                 }
6190                 tr->set_capture_offset ();
6191         }
6192 }
6193
6194 char
6195 Session::session_name_is_legal (const string& path)
6196 {
6197         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6198
6199         for (int i = 0; illegal_chars[i]; ++i) {
6200                 if (path.find (illegal_chars[i]) != string::npos) {
6201                         return illegal_chars[i];
6202                 }
6203         }
6204
6205         return 0;
6206 }
6207
6208 uint32_t
6209 Session::next_control_id () const
6210 {
6211         int subtract = 0;
6212
6213         /* the monitor bus remote ID is in a different
6214          * "namespace" than regular routes. its existence doesn't
6215          * affect normal (low) numbered routes.
6216          */
6217
6218         if (_monitor_out) {
6219                 subtract++;
6220         }
6221
6222         /* the same about masterbus in Waves Tracks */
6223
6224         if (Profile->get_trx() && _master_out) {
6225                 subtract++;
6226         }
6227
6228         return nroutes() - subtract;
6229 }
6230
6231 void
6232 Session::notify_remote_id_change ()
6233 {
6234         if (deletion_in_progress()) {
6235                 return;
6236         }
6237
6238         switch (Config->get_remote_model()) {
6239         case MixerOrdered:
6240                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6241                 break;
6242         default:
6243                 break;
6244         }
6245
6246 #ifdef USE_TRACKS_CODE_FEATURES
6247                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6248                  * if track order has been changed by user
6249                  */
6250                 reconnect_existing_routes(true, true);
6251 #endif
6252
6253 }
6254
6255 void
6256 Session::sync_order_keys ()
6257 {
6258         if (deletion_in_progress()) {
6259                 return;
6260         }
6261
6262         /* tell everyone that something has happened to the sort keys
6263            and let them sync up with the change(s)
6264            this will give objects that manage the sort order keys the
6265            opportunity to keep them in sync if they wish to.
6266         */
6267
6268         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6269
6270         reassign_track_numbers();
6271
6272         Route::SyncOrderKeys (); /* EMIT SIGNAL */
6273
6274         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6275 }
6276
6277 bool
6278 Session::operation_in_progress (GQuark op) const
6279 {
6280         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6281 }
6282
6283 boost::shared_ptr<Port>
6284 Session::ltc_input_port () const
6285 {
6286         return _ltc_input->nth (0);
6287 }
6288
6289 boost::shared_ptr<Port>
6290 Session::ltc_output_port () const
6291 {
6292         return _ltc_output->nth (0);
6293 }
6294
6295 void
6296 Session::reconnect_ltc_input ()
6297 {
6298         if (_ltc_input) {
6299
6300                 string src = Config->get_ltc_source_port();
6301
6302                 _ltc_input->disconnect (this);
6303
6304                 if (src != _("None") && !src.empty())  {
6305                         _ltc_input->nth (0)->connect (src);
6306                 }
6307
6308                 if ( ARDOUR::Profile->get_trx () ) {
6309                         // Tracks need this signal to update timecode_source_dropdown
6310                         MtcOrLtcInputPortChanged (); //emit signal
6311                 }
6312         }
6313 }
6314
6315 void
6316 Session::reconnect_ltc_output ()
6317 {
6318         if (_ltc_output) {
6319
6320                 string src = Config->get_ltc_output_port();
6321
6322                 _ltc_output->disconnect (this);
6323
6324                 if (src != _("None") && !src.empty())  {
6325                         _ltc_output->nth (0)->connect (src);
6326                 }
6327         }
6328 }
6329
6330 void
6331 Session::set_range_selection (framepos_t start, framepos_t end)
6332 {
6333         _range_selection = Evoral::Range<framepos_t> (start, end);
6334 #ifdef USE_TRACKS_CODE_FEATURES
6335         follow_playhead_priority ();
6336 #endif
6337 }
6338
6339 void
6340 Session::set_object_selection (framepos_t start, framepos_t end)
6341 {
6342         _object_selection = Evoral::Range<framepos_t> (start, end);
6343 #ifdef USE_TRACKS_CODE_FEATURES
6344         follow_playhead_priority ();
6345 #endif
6346 }
6347
6348 void
6349 Session::clear_range_selection ()
6350 {
6351         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6352 #ifdef USE_TRACKS_CODE_FEATURES
6353         follow_playhead_priority ();
6354 #endif
6355 }
6356
6357 void
6358 Session::clear_object_selection ()
6359 {
6360         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6361 #ifdef USE_TRACKS_CODE_FEATURES
6362         follow_playhead_priority ();
6363 #endif
6364 }