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