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