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