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