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