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