libs/ardour/session.cc

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