libs/ardour/session.cc

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