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