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