libs/ardour/session.cc

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