libs/ardour/session.cc

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