libs/ardour/session.cc

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