libs/ardour/session.cc

   1 /*
   2     Copyright (C) 1999-2010 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <stdint.h>
  21
  22 #include <algorithm>
  23 #include <string>
  24 #include <vector>
  25 #include <sstream>
  26 #include <cstdio> /* sprintf(3) ... grrr */
  27 #include <cmath>
  28 #include <cerrno>
  29 #include <unistd.h>
  30 #include <limits.h>
  31
  32 #include <glibmm/threads.h>
  33 #include <glibmm/miscutils.h>
  34 #include <glibmm/fileutils.h>
  35
  36 #include <boost/algorithm/string/erase.hpp>
  37
  38 #include "pbd/basename.h"
  39 #include "pbd/convert.h"
  40 #include "pbd/error.h"
  41 #include "pbd/file_utils.h"
  42 #include "pbd/md5.h"
  43 #include "pbd/pthread_utils.h"
  44 #include "pbd/search_path.h"
  45 #include "pbd/stacktrace.h"
  46 #include "pbd/stl_delete.h"
  47 #include "pbd/replace_all.h"
  48 #include "pbd/unwind.h"
  49
  50 #include "ardour/amp.h"
  51 #include "ardour/analyser.h"
  52 #include "ardour/async_midi_port.h"
  53 #include "ardour/audio_buffer.h"
  54 #include "ardour/audio_port.h"
  55 #include "ardour/audio_track.h"
  56 #include "ardour/audioengine.h"
  57 #include "ardour/audiofilesource.h"
  58 #include "ardour/auditioner.h"
  59 #include "ardour/boost_debug.h"
  60 #include "ardour/buffer_manager.h"
  61 #include "ardour/buffer_set.h"
  62 #include "ardour/bundle.h"
  63 #include "ardour/butler.h"
  64 #include "ardour/click.h"
  65 #include "ardour/control_protocol_manager.h"
  66 #include "ardour/data_type.h"
  67 #include "ardour/debug.h"
  68 #include "ardour/disk_reader.h"
  69 #include "ardour/directory_names.h"
  70 #ifdef USE_TRACKS_CODE_FEATURES
  71 #include "ardour/engine_state_controller.h"
  72 #endif
  73 #include "ardour/filename_extensions.h"
  74 #include "ardour/gain_control.h"
  75 #include "ardour/graph.h"
  76 #include "ardour/luabindings.h"
  77 #include "ardour/midiport_manager.h"
  78 #include "ardour/scene_changer.h"
  79 #include "ardour/midi_patch_manager.h"
  80 #include "ardour/midi_track.h"
  81 #include "ardour/midi_ui.h"
  82 #include "ardour/operations.h"
  83 #include "ardour/playlist.h"
  84 #include "ardour/playlist_factory.h"
  85 #include "ardour/plugin.h"
  86 #include "ardour/plugin_insert.h"
  87 #include "ardour/process_thread.h"
  88 #include "ardour/profile.h"
  89 #include "ardour/rc_configuration.h"
  90 #include "ardour/recent_sessions.h"
  91 #include "ardour/region.h"
  92 #include "ardour/region_factory.h"
  93 #include "ardour/revision.h"
  94 #include "ardour/route_graph.h"
  95 #include "ardour/route_group.h"
  96 #include "ardour/send.h"
  97 #include "ardour/selection.h"
  98 #include "ardour/session.h"
  99 #include "ardour/session_directory.h"
 100 #include "ardour/session_playlists.h"
 101 #include "ardour/slave.h"
 102 #include "ardour/smf_source.h"
 103 #include "ardour/slave.h"
 104 #include "ardour/solo_isolate_control.h"
 105 #include "ardour/source_factory.h"
 106 #include "ardour/speakers.h"
 107 #include "ardour/tempo.h"
 108 #include "ardour/ticker.h"
 109 #include "ardour/track.h"
 110 #include "ardour/types_convert.h"
 111 #include "ardour/user_bundle.h"
 112 #include "ardour/utils.h"
 113 #include "ardour/vca_manager.h"
 114 #include "ardour/vca.h"
 115
 116 #include "midi++/port.h"
 117 #include "midi++/mmc.h"
 118
 119 #include "LuaBridge/LuaBridge.h"
 120
 121 #include "pbd/i18n.h"
 122
 123 #include <glibmm/checksum.h>
 124
 125 namespace ARDOUR {
 126 class MidiSource;
 127 class Processor;
 128 class Speakers;
 129 }
 130
 131 using namespace std;
 132 using namespace ARDOUR;
 133 using namespace PBD;
 134
 135 bool Session::_disable_all_loaded_plugins = false;
 136 bool Session::_bypass_all_loaded_plugins = false;
 137 guint Session::_name_id_counter = 0;
 138
 139 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
 140 PBD::Signal1<void,std::string> Session::Dialog;
 141 PBD::Signal0<int> Session::AskAboutPendingState;
 142 PBD::Signal2<int, samplecnt_t, samplecnt_t> Session::AskAboutSampleRateMismatch;
 143 PBD::Signal2<void, samplecnt_t, samplecnt_t> Session::NotifyAboutSampleRateMismatch;
 144 PBD::Signal0<void> Session::SendFeedback;
 145 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
 146
 147 PBD::Signal1<void, samplepos_t> Session::StartTimeChanged;
 148 PBD::Signal1<void, samplepos_t> Session::EndTimeChanged;
 149 PBD::Signal2<void,std::string, std::string> Session::Exported;
 150 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
 151 PBD::Signal0<void> Session::Quit;
 152 PBD::Signal0<void> Session::FeedbackDetected;
 153 PBD::Signal0<void> Session::SuccessfulGraphSort;
 154 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
 155
 156 const samplecnt_t Session::bounce_chunk_size = 8192;
 157 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
 158 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
 159
 160 // seconds should be added after the region exceeds end marker
 161 #ifdef USE_TRACKS_CODE_FEATURES
 162 const uint32_t Session::session_end_shift = 5;
 163 #else
 164 const uint32_t Session::session_end_shift = 0;
 165 #endif
 166
 167 /** @param snapshot_name Snapshot name, without .ardour suffix */
 168 Session::Session (AudioEngine &eng,
 169                   const string& fullpath,
 170                   const string& snapshot_name,
 171                   BusProfile* bus_profile,
 172                   string mix_template)
 173         : playlists (new SessionPlaylists)
 174         , _engine (eng)
 175         , process_function (&Session::process_with_events)
 176         , _bounce_processing_active (false)
 177         , waiting_for_sync_offset (false)
 178         , _base_sample_rate (0)
 179         , _nominal_sample_rate (0)
 180         , _current_sample_rate (0)
 181         , transport_sub_state (0)
 182         , _record_status (Disabled)
 183         , _transport_sample (0)
 184         , _seek_counter (0)
 185         , _session_range_location (0)
 186         , _session_range_end_is_free (true)
 187         , _slave (0)
 188         , _silent (false)
 189         , _remaining_latency_preroll (0)
 190         , _transport_speed (0)
 191         , _default_transport_speed (1.0)
 192         , _last_transport_speed (0)
 193         , _signalled_varispeed (0)
 194         , _target_transport_speed (0.0)
 195         , auto_play_legal (false)
 196         , _last_slave_transport_sample (0)
 197         , _requested_return_sample (-1)
 198         , current_block_size (0)
 199         , _worst_output_latency (0)
 200         , _worst_input_latency (0)
 201         , _worst_route_latency (0)
 202         , _send_latency_changes (0)
 203         , _have_captured (false)
 204         , _non_soloed_outs_muted (false)
 205         , _listening (false)
 206         , _listen_cnt (0)
 207         , _solo_isolated_cnt (0)
 208         , _writable (false)
 209         , _was_seamless (Config->get_seamless_loop ())
 210         , _under_nsm_control (false)
 211         , _xrun_count (0)
 212         , delta_accumulator_cnt (0)
 213         , average_slave_delta (1800) // !!! why 1800 ???
 214         , average_dir (0)
 215         , have_first_delta_accumulator (false)
 216         , _slave_state (Stopped)
 217         , _mtc_active (false)
 218         , _ltc_active (false)
 219         , post_export_sync (false)
 220         , post_export_position (0)
 221         , _exporting (false)
 222         , _export_rolling (false)
 223         , _realtime_export (false)
 224         , _region_export (false)
 225         , _export_preroll (0)
 226         , _pre_export_mmc_enabled (false)
 227         , _name (snapshot_name)
 228         , _is_new (true)
 229         , _send_qf_mtc (false)
 230         , _pframes_since_last_mtc (0)
 231         , play_loop (false)
 232         , loop_changing (false)
 233         , last_loopend (0)
 234         , _session_dir (new SessionDirectory (fullpath))
 235         , _current_snapshot_name (snapshot_name)
 236         , state_tree (0)
 237         , state_was_pending (false)
 238         , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
 239         , _suspend_save (0)
 240         , _save_queued (false)
 241         , _last_roll_location (0)
 242         , _last_roll_or_reversal_location (0)
 243         , _last_record_location (0)
 244         , pending_locate_roll (false)
 245         , pending_locate_sample (0)
 246         , pending_locate_flush (false)
 247         , pending_abort (false)
 248         , pending_auto_loop (false)
 249         , _mempool ("Session", 3145728)
 250         , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
 251         , _n_lua_scripts (0)
 252         , _butler (new Butler (*this))
 253         , _post_transport_work (0)
 254         ,  cumulative_rf_motion (0)
 255         , rf_scale (1.0)
 256         , _locations (new Locations (*this))
 257         , _ignore_skips_updates (false)
 258         , _rt_thread_active (false)
 259         , _rt_emit_pending (false)
 260         , _ac_thread_active (0)
 261         , _latency_recompute_pending (0)
 262         , step_speed (0)
 263         , outbound_mtc_timecode_frame (0)
 264         , next_quarter_frame_to_send (-1)
 265         , _samples_per_timecode_frame (0)
 266         , _frames_per_hour (0)
 267         , _timecode_frames_per_hour (0)
 268         , last_timecode_valid (false)
 269         , last_timecode_when (0)
 270         , _send_timecode_update (false)
 271         , ltc_encoder (0)
 272         , ltc_enc_buf(0)
 273         , ltc_buf_off (0)
 274         , ltc_buf_len (0)
 275         , ltc_speed (0)
 276         , ltc_enc_byte (0)
 277         , ltc_enc_pos (0)
 278         , ltc_enc_cnt (0)
 279         , ltc_enc_off (0)
 280         , restarting (false)
 281         , ltc_prev_cycle (0)
 282         , ltc_timecode_offset (0)
 283         , ltc_timecode_negative_offset (false)
 284         , midi_control_ui (0)
 285         , _tempo_map (0)
 286         , _all_route_group (new RouteGroup (*this, "all"))
 287         , routes (new RouteList)
 288         , _adding_routes_in_progress (false)
 289         , _reconnecting_routes_in_progress (false)
 290         , _route_deletion_in_progress (false)
 291         , destructive_index (0)
 292         , _track_number_decimals(1)
 293         , default_fade_steepness (0)
 294         , default_fade_msecs (0)
 295         , _total_free_4k_blocks (0)
 296         , _total_free_4k_blocks_uncertain (false)
 297         , no_questions_about_missing_files (false)
 298         , _playback_load (0)
 299         , _capture_load (0)
 300         , _bundles (new BundleList)
 301         , _bundle_xml_node (0)
 302         , _current_trans (0)
 303         , _clicking (false)
 304         , _click_rec_only (false)
 305         , click_data (0)
 306         , click_emphasis_data (0)
 307         , click_length (0)
 308         , click_emphasis_length (0)
 309         , _clicks_cleared (0)
 310         , _count_in_samples (0)
 311         , _play_range (false)
 312         , _range_selection (-1,-1)
 313         , _object_selection (-1,-1)
 314         , _preroll_record_trim_len (0)
 315         , _count_in_once (false)
 316         , main_outs (0)
 317         , first_file_data_format_reset (true)
 318         , first_file_header_format_reset (true)
 319         , have_looped (false)
 320         , _have_rec_enabled_track (false)
 321         , _have_rec_disabled_track (true)
 322         , _step_editors (0)
 323         , _suspend_timecode_transmission (0)
 324         ,  _speakers (new Speakers)
 325         , _ignore_route_processor_changes (0)
 326         , midi_clock (0)
 327         , _scene_changer (0)
 328         , _midi_ports (0)
 329         , _mmc (0)
 330         , _vca_manager (new VCAManager (*this))
 331         , _selection (new CoreSelection (*this))
 332         , _global_locate_pending (false)
 333 {
 334         uint32_t sr = 0;
 335
 336         created_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
 337
 338         pthread_mutex_init (&_rt_emit_mutex, 0);
 339         pthread_cond_init (&_rt_emit_cond, 0);
 340
 341         pthread_mutex_init (&_auto_connect_mutex, 0);
 342         pthread_cond_init (&_auto_connect_cond, 0);
 343
 344         init_name_id_counter (1); // reset for new sessions, start at 1
 345         VCA::set_next_vca_number (1); // reset for new sessions, start at 1
 346
 347         pre_engine_init (fullpath); // sets _is_new
 348
 349         setup_lua ();
 350
 351         if (_is_new) {
 352
 353                 Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
 354
 355 #ifdef USE_TRACKS_CODE_FEATURES
 356                 sr = EngineStateController::instance()->get_current_sample_rate();
 357 #endif
 358                 if (ensure_engine (sr, true)) {
 359                         destroy ();
 360                         throw SessionException (_("Cannot connect to audio/midi engine"));
 361                 }
 362
 363                 // set samplerate for plugins added early
 364                 // e.g from templates or MB channelstrip
 365                 set_block_size (_engine.samples_per_cycle());
 366                 set_sample_rate (_engine.sample_rate());
 367
 368                 if (create (mix_template, bus_profile)) {
 369                         destroy ();
 370                         throw SessionException (_("Session initialization failed"));
 371                 }
 372
 373                 /* if a mix template was provided, then ::create() will
 374                  * have copied it into the session and we need to load it
 375                  * so that we have the state ready for ::set_state()
 376                  * after the engine is started.
 377                  *
 378                  * Note that we do NOT try to get the sample rate from
 379                  * the template at this time, though doing so would
 380                  * be easy if we decided this was an appropriate part
 381                  * of a template.
 382                  */
 383
 384                 if (!mix_template.empty()) {
 385                         try {
 386                                 if (load_state (_current_snapshot_name)) {
 387                                         throw SessionException (_("Failed to load template/snapshot state"));
 388                                 }
 389                         } catch (PBD::unknown_enumeration& e) {
 390                                 throw SessionException (_("Failed to parse template/snapshot state"));
 391                         }
 392                         store_recent_templates (mix_template);
 393                 }
 394
 395                 /* load default session properties - if any */
 396                 config.load_state();
 397
 398         } else {
 399
 400                 if (load_state (_current_snapshot_name)) {
 401                         throw SessionException (_("Failed to load state"));
 402                 }
 403
 404                 /* try to get sample rate from XML state so that we
 405                  * can influence the SR if we set up the audio
 406                  * engine.
 407                  */
 408
 409                 if (state_tree) {
 410                         XMLProperty const * prop;
 411                         XMLNode const * root (state_tree->root());
 412                         if ((prop = root->property (X_("sample-rate"))) != 0) {
 413                                 sr = atoi (prop->value());
 414                         }
 415                 }
 416
 417                 if (ensure_engine (sr, false)) {
 418                         destroy ();
 419                         throw SessionException (_("Cannot connect to audio/midi engine"));
 420                 }
 421         }
 422
 423         int err = post_engine_init ();
 424         if (err) {
 425                 destroy ();
 426                 switch (err) {
 427                         case -1:
 428                                 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Failed to create background threads.")));
 429                                 break;
 430                         case -2:
 431                         case -3:
 432                                 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Invalid TempoMap in session-file.")));
 433                                 break;
 434                         case -4:
 435                                 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Invalid or corrupt session state.")));
 436                                 break;
 437                         case -5:
 438                                 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Port registration failed.")));
 439                                 break;
 440                         default:
 441                                 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Unexpected exception during session setup, possibly invalid audio/midi engine parameters. Please see stdout/stderr for details")));
 442                                 break;
 443                 }
 444         }
 445
 446         store_recent_sessions (_name, _path);
 447
 448         bool was_dirty = dirty();
 449
 450         _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 451
 452         PresentationInfo::Change.connect_same_thread (*this, boost::bind (&Session::notify_presentation_info_change, this));
 453
 454         Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
 455         config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
 456
 457         if (was_dirty) {
 458                 DirtyChanged (); /* EMIT SIGNAL */
 459         }
 460
 461         StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
 462         EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
 463
 464         Send::ChangedLatency.connect_same_thread (*this, boost::bind (&Session::send_latency_compensation_change, this));
 465
 466         emit_thread_start ();
 467         auto_connect_thread_start ();
 468
 469         /* hook us up to the engine since we are now completely constructed */
 470
 471         BootMessage (_("Connect to engine"));
 472
 473         _engine.set_session (this);
 474         _engine.reset_timebase ();
 475
 476 #ifdef USE_TRACKS_CODE_FEATURES
 477
 478         EngineStateController::instance()->set_session(this);
 479
 480         if (_is_new ) {
 481                 if ( ARDOUR::Profile->get_trx () ) {
 482
 483                         /* Waves Tracks: fill session with tracks basing on the amount of inputs.
 484                          * each available input must have corresponding track when session starts.
 485                          */
 486
 487                         uint32_t how_many (0);
 488
 489                         std::vector<std::string> inputs;
 490                         EngineStateController::instance()->get_physical_audio_inputs(inputs);
 491
 492                         how_many = inputs.size();
 493
 494                         list<boost::shared_ptr<AudioTrack> > tracks;
 495
 496                         // Track names after driver
 497                         if (Config->get_tracks_auto_naming() == NameAfterDriver) {
 498                                 string track_name = "";
 499                                 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
 500                                         string track_name;
 501                                         track_name = inputs[i];
 502                                         replace_all (track_name, "system:capture", "");
 503
 504                                         list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
 505                                         tracks.insert(tracks.begin(), single_track.front());
 506                                 }
 507                         } else { // Default track names
 508                                 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
 509                         }
 510
 511                         if (tracks.size() != how_many) {
 512                                 destroy ();
 513                                 throw failed_constructor ();
 514                         }
 515                 }
 516         }
 517 #endif
 518
 519         ensure_subdirs (); // archived or zipped sessions may lack peaks/ analysis/ etc
 520
 521         if (!mix_template.empty ()) {
 522                 /* ::create() unsets _is_new after creating the session.
 523                  * But for templated sessions, the sample-rate is initially unset
 524                  * (not read from template), so we need to save it (again).
 525                  */
 526                 _is_new = true;
 527         }
 528
 529         session_loaded ();
 530         _is_new = false;
 531
 532         BootMessage (_("Session loading complete"));
 533 }
 534
 535 Session::~Session ()
 536 {
 537 #ifdef PT_TIMING
 538         ST.dump ("ST.dump");
 539 #endif
 540         destroy ();
 541 }
 542
 543 unsigned int
 544 Session::next_name_id ()
 545 {
 546         return g_atomic_int_add (&_name_id_counter, 1);
 547 }
 548
 549 unsigned int
 550 Session::name_id_counter ()
 551 {
 552         return g_atomic_int_get (&_name_id_counter);
 553 }
 554
 555 void
 556 Session::init_name_id_counter (guint n)
 557 {
 558         g_atomic_int_set (&_name_id_counter, n);
 559 }
 560
 561 int
 562 Session::ensure_engine (uint32_t desired_sample_rate, bool isnew)
 563 {
 564         if (_engine.current_backend() == 0) {
 565                 /* backend is unknown ... */
 566                 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
 567                 if (r.get_value_or (-1) != 0) {
 568                         return -1;
 569                 }
 570         } else if (!isnew && _engine.running() && _engine.sample_rate () == desired_sample_rate) {
 571                 /* keep engine */
 572         } else if (_engine.setup_required()) {
 573                 /* backend is known, but setup is needed */
 574                 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
 575                 if (r.get_value_or (-1) != 0) {
 576                         return -1;
 577                 }
 578         } else if (!_engine.running()) {
 579                 if (_engine.start()) {
 580                         return -1;
 581                 }
 582         }
 583
 584         /* at this point the engine should be running */
 585
 586         if (!_engine.running()) {
 587                 return -1;
 588         }
 589
 590         return immediately_post_engine ();
 591
 592 }
 593
 594 int
 595 Session::immediately_post_engine ()
 596 {
 597         /* Do various initializations that should take place directly after we
 598          * know that the engine is running, but before we either create a
 599          * session or set state for an existing one.
 600          */
 601
 602         if (how_many_dsp_threads () > 1) {
 603                 /* For now, only create the graph if we are using >1 DSP threads, as
 604                    it is a bit slower than the old code with 1 thread.
 605                 */
 606                 _process_graph.reset (new Graph (*this));
 607         }
 608
 609         /* every time we reconnect, recompute worst case output latencies */
 610
 611         _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
 612
 613         if (synced_to_engine()) {
 614                 _engine.transport_stop ();
 615         }
 616
 617         if (config.get_jack_time_master()) {
 618                 _engine.transport_locate (_transport_sample);
 619         }
 620
 621         try {
 622                 BootMessage (_("Set up LTC"));
 623                 setup_ltc ();
 624                 BootMessage (_("Set up Click"));
 625                 setup_click ();
 626                 BootMessage (_("Set up standard connections"));
 627                 setup_bundles ();
 628         }
 629
 630         catch (failed_constructor& err) {
 631                 return -1;
 632         }
 633
 634         /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
 635          * can we do that? */
 636          _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
 637
 638         return 0;
 639 }
 640
 641 void
 642 Session::destroy ()
 643 {
 644         vector<void*> debug_pointers;
 645
 646         /* if we got to here, leaving pending capture state around
 647            is a mistake.
 648         */
 649
 650         remove_pending_capture_state ();
 651
 652         Analyser::flush ();
 653
 654         _state_of_the_state = StateOfTheState (CannotSave|Deletion);
 655
 656         {
 657                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 658                 ltc_tx_cleanup();
 659                 delete _slave;
 660                 _slave = 0;
 661         }
 662
 663         /* disconnect from any and all signals that we are connected to */
 664
 665         Port::PortSignalDrop (); /* EMIT SIGNAL */
 666         drop_connections ();
 667
 668         /* shutdown control surface protocols while we still have ports
 669          * and the engine to move data to any devices.
 670          */
 671
 672         /* remove I/O objects before unsetting the engine session */
 673         _click_io.reset ();
 674         _ltc_input.reset ();
 675         _ltc_output.reset ();
 676
 677         ControlProtocolManager::instance().drop_protocols ();
 678
 679         /* stop auto dis/connecting */
 680         auto_connect_thread_terminate ();
 681
 682         MIDI::Name::MidiPatchManager::instance().remove_search_path(session_directory().midi_patch_path());
 683
 684         _engine.remove_session ();
 685
 686 #ifdef USE_TRACKS_CODE_FEATURES
 687         EngineStateController::instance()->remove_session();
 688 #endif
 689
 690         /* drop slave, if any. We don't use use_sync_source (0) because
 691          * there's no reason to do all the other stuff that may happen
 692          * when calling that method.
 693          */
 694         delete _slave;
 695
 696         /* deregister all ports - there will be no process or any other
 697          * callbacks from the engine any more.
 698          */
 699
 700         Port::PortDrop (); /* EMIT SIGNAL */
 701
 702         /* clear history so that no references to objects are held any more */
 703
 704         _history.clear ();
 705
 706         /* clear state tree so that no references to objects are held any more */
 707
 708         delete state_tree;
 709         state_tree = 0;
 710
 711         {
 712                 /* unregister all lua functions, drop held references (if any) */
 713                 Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
 714                 (*_lua_cleanup)();
 715                 lua.do_command ("Session = nil");
 716                 delete _lua_run;
 717                 delete _lua_add;
 718                 delete _lua_del;
 719                 delete _lua_list;
 720                 delete _lua_save;
 721                 delete _lua_load;
 722                 delete _lua_cleanup;
 723                 lua.collect_garbage ();
 724         }
 725
 726         /* reset dynamic state version back to default */
 727         Stateful::loading_state_version = 0;
 728
 729         _butler->drop_references ();
 730         delete _butler;
 731         _butler = 0;
 732
 733         delete _all_route_group;
 734
 735         DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
 736         for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
 737                 delete *i;
 738         }
 739
 740         if (click_data != default_click) {
 741                 delete [] click_data;
 742         }
 743
 744         if (click_emphasis_data != default_click_emphasis) {
 745                 delete [] click_emphasis_data;
 746         }
 747
 748         clear_clicks ();
 749
 750         /* need to remove auditioner before monitoring section
 751          * otherwise it is re-connected.
 752          * Note: If a session was never successfully loaded, there
 753          * may not yet be an auditioner.
 754          */
 755         if (auditioner) {
 756                 auditioner->drop_references ();
 757         }
 758         auditioner.reset ();
 759
 760         /* drop references to routes held by the monitoring section
 761          * specifically _monitor_out aux/listen references */
 762         remove_monitor_section();
 763
 764         /* clear out any pending dead wood from RCU managed objects */
 765
 766         routes.flush ();
 767         _bundles.flush ();
 768
 769         DiskReader::free_working_buffers();
 770
 771         /* tell everyone who is still standing that we're about to die */
 772         drop_references ();
 773
 774         /* tell everyone to drop references and delete objects as we go */
 775
 776         DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
 777         RegionFactory::delete_all_regions ();
 778
 779         /* Do this early so that VCAs no longer hold references to routes */
 780
 781         DEBUG_TRACE (DEBUG::Destruction, "delete vcas\n");
 782         delete _vca_manager;
 783
 784         DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
 785
 786         /* reset these three references to special routes before we do the usual route delete thing */
 787
 788         _master_out.reset ();
 789         _monitor_out.reset ();
 790
 791         {
 792                 RCUWriter<RouteList> writer (routes);
 793                 boost::shared_ptr<RouteList> r = writer.get_copy ();
 794
 795                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 796                         DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
 797                         (*i)->drop_references ();
 798                 }
 799
 800                 r->clear ();
 801                 /* writer goes out of scope and updates master */
 802         }
 803         routes.flush ();
 804
 805         {
 806                 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
 807                 Glib::Threads::Mutex::Lock lm (source_lock);
 808                 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 809                         DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
 810                         i->second->drop_references ();
 811                 }
 812
 813                 sources.clear ();
 814         }
 815
 816         /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
 817         playlists.reset ();
 818
 819         emit_thread_terminate ();
 820
 821         pthread_cond_destroy (&_rt_emit_cond);
 822         pthread_mutex_destroy (&_rt_emit_mutex);
 823
 824         pthread_cond_destroy (&_auto_connect_cond);
 825         pthread_mutex_destroy (&_auto_connect_mutex);
 826
 827         delete _scene_changer; _scene_changer = 0;
 828         delete midi_control_ui; midi_control_ui = 0;
 829
 830         delete _mmc; _mmc = 0;
 831         delete _midi_ports; _midi_ports = 0;
 832         delete _locations; _locations = 0;
 833
 834         delete midi_clock;
 835         delete _tempo_map;
 836
 837         /* clear event queue, the session is gone, nobody is interested in
 838          * those anymore, but they do leak memory if not removed
 839          */
 840         while (!immediate_events.empty ()) {
 841                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 842                 SessionEvent *ev = immediate_events.front ();
 843                 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Drop event: %1\n", enum_2_string (ev->type)));
 844                 immediate_events.pop_front ();
 845                 bool remove = true;
 846                 bool del = true;
 847                 switch (ev->type) {
 848                         case SessionEvent::AutoLoop:
 849                         case SessionEvent::AutoLoopDeclick:
 850                         case SessionEvent::Skip:
 851                         case SessionEvent::PunchIn:
 852                         case SessionEvent::PunchOut:
 853                         case SessionEvent::StopOnce:
 854                         case SessionEvent::RangeStop:
 855                         case SessionEvent::RangeLocate:
 856                                 remove = false;
 857                                 del = false;
 858                                 break;
 859                         case SessionEvent::RealTimeOperation:
 860                                 process_rtop (ev);
 861                                 del = false;
 862                         default:
 863                                 break;
 864                 }
 865                 if (remove) {
 866                         del = del && !_remove_event (ev);
 867                 }
 868                 if (del) {
 869                         delete ev;
 870                 }
 871         }
 872
 873         {
 874                 /* unregister all dropped ports, process pending port deletion. */
 875                 // this may call ARDOUR::Port::drop ... jack_port_unregister ()
 876                 // jack1 cannot cope with removing ports while processing
 877                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 878                 AudioEngine::instance()->clear_pending_port_deletions ();
 879         }
 880
 881         DEBUG_TRACE (DEBUG::Destruction, "delete selection\n");
 882         delete _selection;
 883         _selection = 0;
 884
 885         DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
 886
 887         BOOST_SHOW_POINTERS ();
 888 }
 889
 890 void
 891 Session::setup_ltc ()
 892 {
 893         XMLNode* child = 0;
 894
 895         _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
 896         _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
 897
 898         if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
 899                 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
 900         } else {
 901                 {
 902                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 903                         _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
 904                         // TODO use auto-connect thread somehow (needs a route currently)
 905                         // see note in Session::auto_connect_thread_run() why process lock is needed.
 906                         reconnect_ltc_input ();
 907                 }
 908         }
 909
 910         if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
 911                 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
 912         } else {
 913                 {
 914                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 915                         _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
 916                         // TODO use auto-connect thread
 917                         reconnect_ltc_output ();
 918                 }
 919         }
 920
 921         /* fix up names of LTC ports because we don't want the normal
 922          * IO style of NAME/TYPE-{in,out}N
 923          */
 924
 925         _ltc_input->nth (0)->set_name (X_("LTC-in"));
 926         _ltc_output->nth (0)->set_name (X_("LTC-out"));
 927 }
 928
 929 void
 930 Session::setup_click ()
 931 {
 932         _clicking = false;
 933
 934         boost::shared_ptr<AutomationList> gl (new AutomationList (Evoral::Parameter (GainAutomation)));
 935         boost::shared_ptr<GainControl> gain_control = boost::shared_ptr<GainControl> (new GainControl (*this, Evoral::Parameter(GainAutomation), gl));
 936
 937         _click_io.reset (new ClickIO (*this, X_("Click")));
 938         _click_gain.reset (new Amp (*this, _("Fader"), gain_control, true));
 939         _click_gain->activate ();
 940         if (state_tree) {
 941                 setup_click_state (state_tree->root());
 942         } else {
 943                 setup_click_state (0);
 944         }
 945 }
 946
 947 void
 948 Session::setup_click_state (const XMLNode* node)
 949 {
 950         const XMLNode* child = 0;
 951
 952         if (node && (child = find_named_node (*node, "Click")) != 0) {
 953
 954                 /* existing state for Click */
 955                 int c = 0;
 956
 957                 if (Stateful::loading_state_version < 3000) {
 958                         c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
 959                 } else {
 960                         const XMLNodeList& children (child->children());
 961                         XMLNodeList::const_iterator i = children.begin();
 962                         if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
 963                                 ++i;
 964                                 if (i != children.end()) {
 965                                         c = _click_gain->set_state (**i, Stateful::loading_state_version);
 966                                 }
 967                         }
 968                 }
 969
 970                 if (c == 0) {
 971                         _clicking = Config->get_clicking ();
 972
 973                 } else {
 974
 975                         error << _("could not setup Click I/O") << endmsg;
 976                         _clicking = false;
 977                 }
 978
 979
 980         } else {
 981
 982                 /* default state for Click: dual-mono to first 2 physical outputs */
 983
 984                 vector<string> outs;
 985                 _engine.get_physical_outputs (DataType::AUDIO, outs);
 986
 987                 for (uint32_t physport = 0; physport < 2; ++physport) {
 988                         if (outs.size() > physport) {
 989                                 if (_click_io->add_port (outs[physport], this)) {
 990                                         // relax, even though its an error
 991                                 }
 992                         }
 993                 }
 994
 995                 if (_click_io->n_ports () > ChanCount::ZERO) {
 996                         _clicking = Config->get_clicking ();
 997                 }
 998         }
 999 }
1000
1001 void
1002 Session::get_physical_ports (vector<string>& inputs, vector<string>& outputs, DataType type,
1003                              MidiPortFlags include, MidiPortFlags exclude)
1004 {
1005         _engine.get_physical_inputs (type, inputs, include, exclude);
1006         _engine.get_physical_outputs (type, outputs, include, exclude);
1007 }
1008
1009 void
1010 Session::setup_bundles ()
1011 {
1012
1013         {
1014                 RCUWriter<BundleList> writer (_bundles);
1015                 boost::shared_ptr<BundleList> b = writer.get_copy ();
1016                 for (BundleList::iterator i = b->begin(); i != b->end();) {
1017                         if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
1018                                 ++i;
1019                                 continue;
1020                         }
1021                         i = b->erase(i);
1022                 }
1023         }
1024
1025         vector<string> inputs[DataType::num_types];
1026         vector<string> outputs[DataType::num_types];
1027
1028         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1029                 get_physical_ports (inputs[i], outputs[i], DataType (DataType::Symbol (i)),
1030                                     MidiPortFlags (0), /* no specific inclusions */
1031                                     MidiPortFlags (MidiPortControl|MidiPortVirtual) /* exclude control & virtual ports */
1032                         );
1033         }
1034
1035         /* Create a set of Bundle objects that map
1036            to the physical I/O currently available.  We create both
1037            mono and stereo bundles, so that the common cases of mono
1038            and stereo tracks get bundles to put in their mixer strip
1039            in / out menus.  There may be a nicer way of achieving that;
1040            it doesn't really scale that well to higher channel counts
1041         */
1042
1043         /* mono output bundles */
1044
1045         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
1046                 char buf[64];
1047                 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
1048                 if (!pn.empty()) {
1049                         snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
1050                 } else {
1051                         snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
1052                 }
1053
1054                 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
1055                 c->add_channel (_("mono"), DataType::AUDIO);
1056                 c->set_port (0, outputs[DataType::AUDIO][np]);
1057
1058                 add_bundle (c, false);
1059         }
1060
1061         /* stereo output bundles */
1062
1063         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
1064                 if (np + 1 < outputs[DataType::AUDIO].size()) {
1065                         char buf[32];
1066                         snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1067                         boost::shared_ptr<Bundle> c (new Bundle (buf, true));
1068                         c->add_channel (_("L"), DataType::AUDIO);
1069                         c->set_port (0, outputs[DataType::AUDIO][np]);
1070                         c->add_channel (_("R"), DataType::AUDIO);
1071                         c->set_port (1, outputs[DataType::AUDIO][np + 1]);
1072
1073                         add_bundle (c, false);
1074                 }
1075         }
1076
1077         /* mono input bundles */
1078
1079         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
1080                 char buf[64];
1081                 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
1082                 if (!pn.empty()) {
1083                         snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
1084                 } else {
1085                         snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
1086                 }
1087
1088                 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1089                 c->add_channel (_("mono"), DataType::AUDIO);
1090                 c->set_port (0, inputs[DataType::AUDIO][np]);
1091
1092                 add_bundle (c, false);
1093         }
1094
1095         /* stereo input bundles */
1096
1097         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
1098                 if (np + 1 < inputs[DataType::AUDIO].size()) {
1099                         char buf[32];
1100                         snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1101
1102                         boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1103                         c->add_channel (_("L"), DataType::AUDIO);
1104                         c->set_port (0, inputs[DataType::AUDIO][np]);
1105                         c->add_channel (_("R"), DataType::AUDIO);
1106                         c->set_port (1, inputs[DataType::AUDIO][np + 1]);
1107
1108                         add_bundle (c, false);
1109                 }
1110         }
1111
1112         /* MIDI input bundles */
1113
1114         for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
1115                 string n = inputs[DataType::MIDI][np];
1116
1117                 std::string pn = _engine.get_pretty_name_by_name (n);
1118                 if (!pn.empty()) {
1119                         n = pn;
1120                 } else {
1121                         boost::erase_first (n, X_("alsa_pcm:"));
1122                 }
1123                 boost::shared_ptr<Bundle> c (new Bundle (n, false));
1124                 c->add_channel ("", DataType::MIDI);
1125                 c->set_port (0, inputs[DataType::MIDI][np]);
1126                 add_bundle (c, false);
1127         }
1128
1129         /* MIDI output bundles */
1130
1131         for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
1132                 string n = outputs[DataType::MIDI][np];
1133                 std::string pn = _engine.get_pretty_name_by_name (n);
1134                 if (!pn.empty()) {
1135                         n = pn;
1136                 } else {
1137                         boost::erase_first (n, X_("alsa_pcm:"));
1138                 }
1139                 boost::shared_ptr<Bundle> c (new Bundle (n, true));
1140                 c->add_channel ("", DataType::MIDI);
1141                 c->set_port (0, outputs[DataType::MIDI][np]);
1142                 add_bundle (c, false);
1143         }
1144
1145         // we trust the backend to only calls us if there's a change
1146         BundleAddedOrRemoved (); /* EMIT SIGNAL */
1147 }
1148
1149 void
1150 Session::auto_connect_master_bus ()
1151 {
1152         if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
1153                 return;
1154         }
1155
1156         // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
1157         // In this case it means "Multi Out" output mode
1158         if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
1159                 return;
1160         }
1161
1162         /* if requested auto-connect the outputs to the first N physical ports.
1163          */
1164
1165         uint32_t limit = _master_out->n_outputs().n_total();
1166         vector<string> outputs[DataType::num_types];
1167
1168         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1169                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1170         }
1171
1172         for (uint32_t n = 0; n < limit; ++n) {
1173                 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
1174                 string connect_to;
1175                 if (outputs[p->type()].size() > n) {
1176                         connect_to = outputs[p->type()][n];
1177                 }
1178
1179                 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
1180                         if (_master_out->output()->connect (p, connect_to, this)) {
1181                                 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
1182                                       << endmsg;
1183                                 break;
1184                         }
1185                 }
1186         }
1187 }
1188
1189 void
1190 Session::remove_monitor_section ()
1191 {
1192         if (!_monitor_out || Profile->get_trx()) {
1193                 return;
1194         }
1195
1196         /* force reversion to Solo-In-Place */
1197         Config->set_solo_control_is_listen_control (false);
1198
1199         /* if we are auditioning, cancel it ... this is a workaround
1200            to a problem (auditioning does not execute the process graph,
1201            which is needed to remove routes when using >1 core for processing)
1202         */
1203         cancel_audition ();
1204
1205         {
1206                 /* Hold process lock while doing this so that we don't hear bits and
1207                  * pieces of audio as we work on each route.
1208                  */
1209
1210                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1211
1212                 /* Connect tracks to monitor section. Note that in an
1213                    existing session, the internal sends will already exist, but we want the
1214                    routes to notice that they connect to the control out specifically.
1215                 */
1216
1217
1218                 boost::shared_ptr<RouteList> r = routes.reader ();
1219                 ProcessorChangeBlocker  pcb (this, false);
1220
1221                 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
1222
1223                         if ((*x)->is_monitor()) {
1224                                 /* relax */
1225                         } else if ((*x)->is_master()) {
1226                                 /* relax */
1227                         } else {
1228                                 (*x)->remove_aux_or_listen (_monitor_out);
1229                         }
1230                 }
1231         }
1232
1233         remove_route (_monitor_out);
1234         if (_state_of_the_state & Deletion) {
1235                 return;
1236         }
1237
1238         auto_connect_master_bus ();
1239
1240         if (auditioner) {
1241                 auditioner->connect ();
1242         }
1243
1244         Config->ParameterChanged ("use-monitor-bus");
1245 }
1246
1247 void
1248 Session::add_monitor_section ()
1249 {
1250         RouteList rl;
1251
1252         if (_monitor_out || !_master_out || Profile->get_trx()) {
1253                 return;
1254         }
1255
1256         boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), PresentationInfo::MonitorOut, DataType::AUDIO));
1257
1258         if (r->init ()) {
1259                 return;
1260         }
1261
1262         BOOST_MARK_ROUTE(r);
1263
1264         try {
1265                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1266                 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1267                 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1268         } catch (...) {
1269                 error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
1270                 return;
1271         }
1272
1273         rl.push_back (r);
1274         add_routes (rl, false, false, false, 0);
1275
1276         assert (_monitor_out);
1277
1278         /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1279            are undefined, at best.
1280         */
1281
1282         uint32_t limit = _monitor_out->n_inputs().n_audio();
1283
1284         if (_master_out) {
1285
1286                 /* connect the inputs to the master bus outputs. this
1287                  * represents a separate data feed from the internal sends from
1288                  * each route. as of jan 2011, it allows the monitor section to
1289                  * conditionally ignore either the internal sends or the normal
1290                  * input feed, but we should really find a better way to do
1291                  * this, i think.
1292                  */
1293
1294                 _master_out->output()->disconnect (this);
1295
1296                 for (uint32_t n = 0; n < limit; ++n) {
1297                         boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1298                         boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1299
1300                         if (o) {
1301                                 string connect_to = o->name();
1302                                 if (_monitor_out->input()->connect (p, connect_to, this)) {
1303                                         error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1304                                               << endmsg;
1305                                         break;
1306                                 }
1307                         }
1308                 }
1309         }
1310
1311         /* if monitor section is not connected, connect it to physical outs
1312          */
1313
1314         if ((Config->get_auto_connect_standard_busses () || Profile->get_mixbus ()) && !_monitor_out->output()->connected ()) {
1315
1316                 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1317
1318                         boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1319
1320                         if (b) {
1321                                 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1322                         } else {
1323                                 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1324                                                            Config->get_monitor_bus_preferred_bundle())
1325                                         << endmsg;
1326                         }
1327
1328                 } else {
1329
1330                         /* Monitor bus is audio only */
1331
1332                         vector<string> outputs[DataType::num_types];
1333
1334                         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1335                                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1336                         }
1337
1338                         uint32_t mod = outputs[DataType::AUDIO].size();
1339                         uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1340
1341                         if (mod != 0) {
1342
1343                                 for (uint32_t n = 0; n < limit; ++n) {
1344
1345                                         boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1346                                         string connect_to;
1347                                         if (outputs[DataType::AUDIO].size() > (n % mod)) {
1348                                                 connect_to = outputs[DataType::AUDIO][n % mod];
1349                                         }
1350
1351                                         if (!connect_to.empty()) {
1352                                                 if (_monitor_out->output()->connect (p, connect_to, this)) {
1353                                                         error << string_compose (
1354                                                                 _("cannot connect control output %1 to %2"),
1355                                                                 n, connect_to)
1356                                                               << endmsg;
1357                                                         break;
1358                                                 }
1359                                         }
1360                                 }
1361                         }
1362                 }
1363         }
1364
1365         /* Hold process lock while doing this so that we don't hear bits and
1366          * pieces of audio as we work on each route.
1367          */
1368
1369         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1370
1371         /* Connect tracks to monitor section. Note that in an
1372            existing session, the internal sends will already exist, but we want the
1373            routes to notice that they connect to the control out specifically.
1374         */
1375
1376
1377         boost::shared_ptr<RouteList> rls = routes.reader ();
1378
1379         ProcessorChangeBlocker  pcb (this, false /* XXX */);
1380
1381         for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1382
1383                 if ((*x)->is_monitor()) {
1384                         /* relax */
1385                 } else if ((*x)->is_master()) {
1386                         /* relax */
1387                 } else {
1388                         (*x)->enable_monitor_send ();
1389                 }
1390         }
1391
1392         if (auditioner) {
1393                 auditioner->connect ();
1394         }
1395         Config->ParameterChanged ("use-monitor-bus");
1396 }
1397
1398 void
1399 Session::reset_monitor_section ()
1400 {
1401         /* Process lock should be held by the caller.*/
1402
1403         if (!_monitor_out || Profile->get_trx()) {
1404                 return;
1405         }
1406
1407         uint32_t limit = _master_out->n_outputs().n_audio();
1408
1409         /* connect the inputs to the master bus outputs. this
1410          * represents a separate data feed from the internal sends from
1411          * each route. as of jan 2011, it allows the monitor section to
1412          * conditionally ignore either the internal sends or the normal
1413          * input feed, but we should really find a better way to do
1414          * this, i think.
1415          */
1416
1417         _master_out->output()->disconnect (this);
1418         _monitor_out->output()->disconnect (this);
1419
1420         // monitor section follow master bus - except midi
1421         ChanCount mon_chn (_master_out->output()->n_ports());
1422         mon_chn.set_midi (0);
1423
1424         _monitor_out->input()->ensure_io (mon_chn, false, this);
1425         _monitor_out->output()->ensure_io (mon_chn, false, this);
1426
1427         for (uint32_t n = 0; n < limit; ++n) {
1428                 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1429                 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1430
1431                 if (o) {
1432                         string connect_to = o->name();
1433                         if (_monitor_out->input()->connect (p, connect_to, this)) {
1434                                 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1435                                       << endmsg;
1436                                 break;
1437                         }
1438                 }
1439         }
1440
1441         /* connect monitor section to physical outs
1442          */
1443
1444         if (Config->get_auto_connect_standard_busses()) {
1445
1446                 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1447
1448                         boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1449
1450                         if (b) {
1451                                 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1452                         } else {
1453                                 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1454                                                            Config->get_monitor_bus_preferred_bundle())
1455                                         << endmsg;
1456                         }
1457
1458                 } else {
1459
1460                         /* Monitor bus is audio only */
1461
1462                         vector<string> outputs[DataType::num_types];
1463
1464                         for (uint32_t i = 0; i < DataType::num_types; ++i) {
1465                                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1466                         }
1467
1468                         uint32_t mod = outputs[DataType::AUDIO].size();
1469                         uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1470
1471                         if (mod != 0) {
1472
1473                                 for (uint32_t n = 0; n < limit; ++n) {
1474
1475                                         boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1476                                         string connect_to;
1477                                         if (outputs[DataType::AUDIO].size() > (n % mod)) {
1478                                                 connect_to = outputs[DataType::AUDIO][n % mod];
1479                                         }
1480
1481                                         if (!connect_to.empty()) {
1482                                                 if (_monitor_out->output()->connect (p, connect_to, this)) {
1483                                                         error << string_compose (
1484                                                                 _("cannot connect control output %1 to %2"),
1485                                                                 n, connect_to)
1486                                                               << endmsg;
1487                                                         break;
1488                                                 }
1489                                         }
1490                                 }
1491                         }
1492                 }
1493         }
1494
1495         /* Connect tracks to monitor section. Note that in an
1496            existing session, the internal sends will already exist, but we want the
1497            routes to notice that they connect to the control out specifically.
1498         */
1499
1500
1501         boost::shared_ptr<RouteList> rls = routes.reader ();
1502
1503         ProcessorChangeBlocker pcb (this, false);
1504
1505         for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1506
1507                 if ((*x)->is_monitor()) {
1508                         /* relax */
1509                 } else if ((*x)->is_master()) {
1510                         /* relax */
1511                 } else {
1512                         (*x)->enable_monitor_send ();
1513                 }
1514         }
1515 }
1516
1517 int
1518 Session::add_master_bus (ChanCount const& count)
1519 {
1520         if (master_out ()) {
1521                 return -1;
1522         }
1523
1524         RouteList rl;
1525
1526         boost::shared_ptr<Route> r (new Route (*this, _("Master"), PresentationInfo::MasterOut, DataType::AUDIO));
1527         if (r->init ()) {
1528                 return -1;
1529         }
1530
1531         BOOST_MARK_ROUTE(r);
1532
1533         {
1534                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1535                 r->input()->ensure_io (count, false, this);
1536                 r->output()->ensure_io (count, false, this);
1537         }
1538
1539         rl.push_back (r);
1540         add_routes (rl, false, false, false, PresentationInfo::max_order);
1541         return 0;
1542 }
1543
1544 void
1545 Session::hookup_io ()
1546 {
1547         /* stop graph reordering notifications from
1548            causing resorts, etc.
1549         */
1550
1551         _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1552
1553         if (!auditioner) {
1554
1555                 /* we delay creating the auditioner till now because
1556                    it makes its own connections to ports.
1557                 */
1558
1559                 try {
1560                         boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1561                         if (a->init()) {
1562                                 throw failed_constructor ();
1563                         }
1564                         auditioner = a;
1565                 }
1566
1567                 catch (failed_constructor& err) {
1568                         warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1569                 }
1570         }
1571
1572         /* load bundles, which we may have postponed earlier on */
1573         if (_bundle_xml_node) {
1574                 load_bundles (*_bundle_xml_node);
1575                 delete _bundle_xml_node;
1576         }
1577
1578         /* Tell all IO objects to connect themselves together */
1579
1580         IO::enable_connecting ();
1581
1582         /* Now tell all "floating" ports to connect to whatever
1583            they should be connected to.
1584         */
1585
1586         AudioEngine::instance()->reconnect_ports ();
1587
1588         /* Anyone who cares about input state, wake up and do something */
1589
1590         IOConnectionsComplete (); /* EMIT SIGNAL */
1591
1592         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1593
1594         /* now handle the whole enchilada as if it was one
1595            graph reorder event.
1596         */
1597
1598         graph_reordered ();
1599
1600         /* update the full solo state, which can't be
1601            correctly determined on a per-route basis, but
1602            needs the global overview that only the session
1603            has.
1604         */
1605
1606         update_route_solo_state ();
1607 }
1608
1609 void
1610 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1611 {
1612         boost::shared_ptr<Track> track = wp.lock ();
1613         if (!track) {
1614                 return;
1615         }
1616
1617         boost::shared_ptr<Playlist> playlist;
1618
1619         if ((playlist = track->playlist()) != 0) {
1620                 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1621                 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1622                 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1623         }
1624 }
1625
1626 bool
1627 Session::record_enabling_legal () const
1628 {
1629         /* this used to be in here, but survey says.... we don't need to restrict it */
1630         // if (record_status() == Recording) {
1631         //      return false;
1632         // }
1633
1634         if (Config->get_all_safe()) {
1635                 return false;
1636         }
1637         return true;
1638 }
1639
1640 void
1641 Session::set_track_monitor_input_status (bool yn)
1642 {
1643         boost::shared_ptr<RouteList> rl = routes.reader ();
1644         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1645                 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1646                 if (tr && tr->rec_enable_control()->get_value()) {
1647                         //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1648                         tr->request_input_monitoring (yn);
1649                 }
1650         }
1651 }
1652
1653 void
1654 Session::auto_punch_start_changed (Location* location)
1655 {
1656         replace_event (SessionEvent::PunchIn, location->start());
1657
1658         if (get_record_enabled() && config.get_punch_in()) {
1659                 /* capture start has been changed, so save new pending state */
1660                 save_state ("", true);
1661         }
1662 }
1663
1664 void
1665 Session::auto_punch_end_changed (Location* location)
1666 {
1667         samplepos_t when_to_stop = location->end();
1668         // when_to_stop += _worst_output_latency + _worst_input_latency;
1669         replace_event (SessionEvent::PunchOut, when_to_stop);
1670 }
1671
1672 void
1673 Session::auto_punch_changed (Location* location)
1674 {
1675         samplepos_t when_to_stop = location->end();
1676
1677         replace_event (SessionEvent::PunchIn, location->start());
1678         //when_to_stop += _worst_output_latency + _worst_input_latency;
1679         replace_event (SessionEvent::PunchOut, when_to_stop);
1680 }
1681
1682 /** @param loc A loop location.
1683  *  @param pos Filled in with the start time of the required fade-out (in session samples).
1684  *  @param length Filled in with the length of the required fade-out.
1685  */
1686 void
1687 Session::auto_loop_declick_range (Location* loc, samplepos_t & pos, samplepos_t & length)
1688 {
1689         pos = max (loc->start(), loc->end() - 64);
1690         length = loc->end() - pos;
1691 }
1692
1693 void
1694 Session::auto_loop_changed (Location* location)
1695 {
1696         replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1697         samplepos_t dcp;
1698         samplecnt_t dcl;
1699         auto_loop_declick_range (location, dcp, dcl);
1700
1701         if (transport_rolling() && play_loop) {
1702
1703                 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1704
1705                 // if (_transport_sample > location->end()) {
1706
1707                 if (_transport_sample < location->start() || _transport_sample > location->end()) {
1708                         // relocate to beginning of loop
1709                         clear_events (SessionEvent::LocateRoll);
1710
1711                         request_locate (location->start(), true);
1712
1713                 }
1714                 else if (Config->get_seamless_loop() && !loop_changing) {
1715
1716                         // schedule a locate-roll to refill the disk readers at the
1717                         // previous loop end
1718                         loop_changing = true;
1719
1720                         if (location->end() > last_loopend) {
1721                                 clear_events (SessionEvent::LocateRoll);
1722                                 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1723                                 queue_event (ev);
1724                         }
1725
1726                 }
1727         } else {
1728                 clear_events (SessionEvent::AutoLoopDeclick);
1729                 clear_events (SessionEvent::AutoLoop);
1730         }
1731
1732         /* possibly move playhead if not rolling; if we are rolling we'll move
1733            to the loop start on stop if that is appropriate.
1734          */
1735
1736         samplepos_t pos;
1737
1738         if (!transport_rolling() && select_playhead_priority_target (pos)) {
1739                 if (pos == location->start()) {
1740                         request_locate (pos);
1741                 }
1742         }
1743
1744
1745         last_loopend = location->end();
1746         set_dirty ();
1747 }
1748
1749 void
1750 Session::set_auto_punch_location (Location* location)
1751 {
1752         Location* existing;
1753
1754         if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1755                 punch_connections.drop_connections();
1756                 existing->set_auto_punch (false, this);
1757                 remove_event (existing->start(), SessionEvent::PunchIn);
1758                 clear_events (SessionEvent::PunchOut);
1759                 auto_punch_location_changed (0);
1760         }
1761
1762         set_dirty();
1763
1764         if (location == 0) {
1765                 return;
1766         }
1767
1768         if (location->end() <= location->start()) {
1769                 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1770                 return;
1771         }
1772
1773         punch_connections.drop_connections ();
1774
1775         location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1776         location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1777         location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1778
1779         location->set_auto_punch (true, this);
1780
1781         auto_punch_changed (location);
1782
1783         auto_punch_location_changed (location);
1784 }
1785
1786 void
1787 Session::set_session_extents (samplepos_t start, samplepos_t end)
1788 {
1789         Location* existing;
1790         if ((existing = _locations->session_range_location()) == 0) {
1791                 //if there is no existing session, we need to make a new session location  (should never happen)
1792                 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange, 0);
1793         }
1794
1795         if (end <= start) {
1796                 error << _("Session: you can't use that location for session start/end)") << endmsg;
1797                 return;
1798         }
1799
1800         existing->set( start, end );
1801
1802         set_dirty();
1803 }
1804
1805 void
1806 Session::set_auto_loop_location (Location* location)
1807 {
1808         Location* existing;
1809
1810         if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1811                 loop_connections.drop_connections ();
1812                 existing->set_auto_loop (false, this);
1813                 remove_event (existing->end(), SessionEvent::AutoLoop);
1814                 samplepos_t dcp;
1815                 samplecnt_t dcl;
1816                 auto_loop_declick_range (existing, dcp, dcl);
1817                 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1818                 auto_loop_location_changed (0);
1819         }
1820
1821         set_dirty();
1822
1823         if (location == 0) {
1824                 return;
1825         }
1826
1827         if (location->end() <= location->start()) {
1828                 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1829                 return;
1830         }
1831
1832         last_loopend = location->end();
1833
1834         loop_connections.drop_connections ();
1835
1836         location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1837         location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1838         location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1839         location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1840
1841         location->set_auto_loop (true, this);
1842
1843         if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1844                 // set all tracks to use internal looping
1845                 boost::shared_ptr<RouteList> rl = routes.reader ();
1846                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1847                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1848                         if (tr && !tr->is_private_route()) {
1849                                 tr->set_loop (location);
1850                         }
1851                 }
1852         }
1853
1854         /* take care of our stuff first */
1855
1856         auto_loop_changed (location);
1857
1858         /* now tell everyone else */
1859
1860         auto_loop_location_changed (location);
1861 }
1862
1863 void
1864 Session::update_marks (Location*)
1865 {
1866         set_dirty ();
1867 }
1868
1869 void
1870 Session::update_skips (Location* loc, bool consolidate)
1871 {
1872         if (_ignore_skips_updates) {
1873                 return;
1874         }
1875
1876         Locations::LocationList skips;
1877
1878         if (consolidate) {
1879                 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1880                 consolidate_skips (loc);
1881         }
1882
1883         sync_locations_to_skips ();
1884
1885         set_dirty ();
1886 }
1887
1888 void
1889 Session::consolidate_skips (Location* loc)
1890 {
1891         Locations::LocationList all_locations = _locations->list ();
1892
1893         for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1894
1895                 if (!(*l)->is_skip ()) {
1896                         ++l;
1897                         continue;
1898                 }
1899
1900                 /* don't test against self */
1901
1902                 if (*l == loc) {
1903                         ++l;
1904                         continue;
1905                 }
1906
1907                 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1908                 case Evoral::OverlapInternal:
1909                 case Evoral::OverlapExternal:
1910                 case Evoral::OverlapStart:
1911                 case Evoral::OverlapEnd:
1912                         /* adjust new location to cover existing one */
1913                         loc->set_start (min (loc->start(), (*l)->start()));
1914                         loc->set_end (max (loc->end(), (*l)->end()));
1915                         /* we don't need this one any more */
1916                         _locations->remove (*l);
1917                         /* the location has been deleted, so remove reference to it in our local list */
1918                         l = all_locations.erase (l);
1919                         break;
1920
1921                 case Evoral::OverlapNone:
1922                         ++l;
1923                         break;
1924                 }
1925         }
1926 }
1927
1928 void
1929 Session::sync_locations_to_skips ()
1930 {
1931         /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1932          * Session::_sync_locations_to_skips() from the audioengine thread.
1933          */
1934         clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1935 }
1936
1937 void
1938 Session::_sync_locations_to_skips ()
1939 {
1940         /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1941
1942         Locations::LocationList const & locs (_locations->list());
1943
1944         for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1945
1946                 Location* location = *i;
1947
1948                 if (location->is_skip() && location->is_skipping()) {
1949                         SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1950                         queue_event (ev);
1951                 }
1952         }
1953 }
1954
1955
1956 void
1957 Session::location_added (Location *location)
1958 {
1959         if (location->is_auto_punch()) {
1960                 set_auto_punch_location (location);
1961         }
1962
1963         if (location->is_auto_loop()) {
1964                 set_auto_loop_location (location);
1965         }
1966
1967         if (location->is_session_range()) {
1968                 /* no need for any signal handling or event setting with the session range,
1969                    because we keep a direct reference to it and use its start/end directly.
1970                 */
1971                 _session_range_location = location;
1972         }
1973
1974         if (location->is_mark()) {
1975                 /* listen for per-location signals that require us to do any * global updates for marks */
1976
1977                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1978                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1979                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1980                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1981                 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1982         }
1983
1984         if (location->is_range_marker()) {
1985                 /* listen for per-location signals that require us to do any * global updates for marks */
1986
1987                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1988                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1989                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1990                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1991                 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1992         }
1993
1994         if (location->is_skip()) {
1995                 /* listen for per-location signals that require us to update skip-locate events */
1996
1997                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1998                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1999                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
2000                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
2001                 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
2002
2003                 update_skips (location, true);
2004         }
2005
2006         set_dirty ();
2007 }
2008
2009 void
2010 Session::location_removed (Location *location)
2011 {
2012         if (location->is_auto_loop()) {
2013                 set_auto_loop_location (0);
2014                 set_track_loop (false);
2015         }
2016
2017         if (location->is_auto_punch()) {
2018                 set_auto_punch_location (0);
2019         }
2020
2021         if (location->is_session_range()) {
2022                 /* this is never supposed to happen */
2023                 error << _("programming error: session range removed!") << endl;
2024         }
2025
2026         if (location->is_skip()) {
2027
2028                 update_skips (location, false);
2029         }
2030
2031         set_dirty ();
2032 }
2033
2034 void
2035 Session::locations_changed ()
2036 {
2037         _locations->apply (*this, &Session::_locations_changed);
2038 }
2039
2040 void
2041 Session::_locations_changed (const Locations::LocationList& locations)
2042 {
2043         /* There was some mass-change in the Locations object.
2044
2045            We might be re-adding a location here but it doesn't actually matter
2046            for all the locations that the Session takes an interest in.
2047         */
2048
2049         {
2050                 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
2051                 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
2052                         location_added (*i);
2053                 }
2054         }
2055
2056         update_skips (NULL, false);
2057 }
2058
2059 void
2060 Session::enable_record ()
2061 {
2062         if (_transport_speed != 0.0 && _transport_speed != 1.0) {
2063                 /* no recording at anything except normal speed */
2064                 return;
2065         }
2066
2067         while (1) {
2068                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
2069
2070                 if (rs == Recording) {
2071                         break;
2072                 }
2073
2074                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
2075
2076                         _last_record_location = _transport_sample;
2077                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
2078
2079                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2080                                 set_track_monitor_input_status (true);
2081                         }
2082
2083                         RecordStateChanged ();
2084                         break;
2085                 }
2086         }
2087 }
2088
2089 void
2090 Session::set_all_tracks_record_enabled (bool enable )
2091 {
2092         boost::shared_ptr<RouteList> rl = routes.reader();
2093         set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), enable, Controllable::NoGroup);
2094 }
2095
2096 void
2097 Session::disable_record (bool rt_context, bool force)
2098 {
2099         RecordState rs;
2100
2101         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
2102
2103                 if (!Config->get_latched_record_enable () || force) {
2104                         g_atomic_int_set (&_record_status, Disabled);
2105                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
2106                 } else {
2107                         if (rs == Recording) {
2108                                 g_atomic_int_set (&_record_status, Enabled);
2109                         }
2110                 }
2111
2112                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2113                         set_track_monitor_input_status (false);
2114                 }
2115
2116                 RecordStateChanged (); /* emit signal */
2117
2118                 if (!rt_context) {
2119                         remove_pending_capture_state ();
2120                 }
2121         }
2122 }
2123
2124 void
2125 Session::step_back_from_record ()
2126 {
2127         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
2128
2129                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2130                         set_track_monitor_input_status (false);
2131                 }
2132
2133                 RecordStateChanged (); /* emit signal */
2134         }
2135 }
2136
2137 void
2138 Session::maybe_enable_record (bool rt_context)
2139 {
2140         if (_step_editors > 0) {
2141                 return;
2142         }
2143
2144         g_atomic_int_set (&_record_status, Enabled);
2145
2146         /* This function is currently called from somewhere other than an RT thread.
2147          * (except maybe lua scripts, which can use rt_context = true)
2148          * This save_state() call therefore doesn't impact anything.  Doing it here
2149          * means that we save pending state of which sources the next record will use,
2150          * which gives us some chance of recovering from a crash during the record.
2151          */
2152
2153         if (!rt_context) {
2154                 save_state ("", true);
2155         }
2156
2157         if (_transport_speed) {
2158                 if (!config.get_punch_in()) {
2159                         enable_record ();
2160                 }
2161         } else {
2162                 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
2163                 RecordStateChanged (); /* EMIT SIGNAL */
2164         }
2165
2166         set_dirty();
2167 }
2168
2169 samplepos_t
2170 Session::audible_sample (bool* latent_locate) const
2171 {
2172         if (latent_locate) {
2173                 *latent_locate = false;
2174         }
2175
2176         samplepos_t ret;
2177
2178         if (synced_to_engine()) {
2179                 /* Note: this is basically just sync-to-JACK */
2180                 ret = _engine.transport_sample();
2181         } else {
2182                 ret = _transport_sample;
2183         }
2184
2185         assert (ret >= 0);
2186
2187         if (!transport_rolling()) {
2188                 return ret;
2189         }
2190
2191 #if 0 // TODO looping
2192         if (_transport_speed > 0.0f) {
2193                 if (play_loop && have_looped) {
2194                         /* the play-position wrapped at the loop-point
2195                          * ardour is already playing the beginning of the loop,
2196                          * but due to playback latency, the "audible frame"
2197                          * is still at the end of the loop.
2198                          */
2199                         Location *location = _locations->auto_loop_location();
2200                         sampleoffset_t lo = location->start() - ret;
2201                         if (lo > 0) {
2202                                 ret = location->end () - lo;
2203                                 if (latent_locate) {
2204                                         *latent_locate = true;
2205                                 }
2206                         }
2207                 }
2208         } else if (_transport_speed < 0.0f) {
2209                 /* XXX wot? no backward looping? */
2210         }
2211 #endif
2212
2213         return std::max ((samplepos_t)0, ret);
2214 }
2215
2216 samplecnt_t
2217 Session::preroll_samples (samplepos_t pos) const
2218 {
2219         const float pr = Config->get_preroll_seconds();
2220         if (pos >= 0 && pr < 0) {
2221                 const Tempo& tempo = _tempo_map->tempo_at_sample (pos);
2222                 const Meter& meter = _tempo_map->meter_at_sample (pos);
2223                 return meter.samples_per_bar (tempo, sample_rate()) * -pr;
2224         }
2225         if (pr < 0) {
2226                 return 0;
2227         }
2228         return pr * sample_rate();
2229 }
2230
2231 void
2232 Session::set_sample_rate (samplecnt_t frames_per_second)
2233 {
2234         /** \fn void Session::set_sample_size(samplecnt_t)
2235                 the AudioEngine object that calls this guarantees
2236                 that it will not be called while we are also in
2237                 ::process(). Its fine to do things that block
2238                 here.
2239         */
2240
2241         if (_base_sample_rate == 0) {
2242                 _base_sample_rate = frames_per_second;
2243         }
2244         else if (_base_sample_rate != frames_per_second && frames_per_second != _nominal_sample_rate) {
2245                 NotifyAboutSampleRateMismatch (_base_sample_rate, frames_per_second);
2246         }
2247         _nominal_sample_rate = frames_per_second;
2248
2249         sync_time_vars();
2250
2251         clear_clicks ();
2252         reset_write_sources (false);
2253
2254         // XXX we need some equivalent to this, somehow
2255         // SndFileSource::setup_standard_crossfades (frames_per_second);
2256
2257         set_dirty();
2258
2259         /* XXX need to reset/reinstantiate all LADSPA plugins */
2260 }
2261
2262 void
2263 Session::set_block_size (pframes_t nframes)
2264 {
2265         /* the AudioEngine guarantees
2266            that it will not be called while we are also in
2267            ::process(). It is therefore fine to do things that block
2268            here.
2269         */
2270
2271         {
2272                 current_block_size = nframes;
2273
2274                 ensure_buffers ();
2275
2276                 boost::shared_ptr<RouteList> r = routes.reader ();
2277
2278                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2279                         (*i)->set_block_size (nframes);
2280                 }
2281
2282                 boost::shared_ptr<RouteList> rl = routes.reader ();
2283                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2284                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2285                         if (tr) {
2286                                 tr->set_block_size (nframes);
2287                         }
2288                 }
2289
2290                 set_worst_io_latencies ();
2291         }
2292 }
2293
2294
2295 static void
2296 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2297 {
2298         boost::shared_ptr<Route> r2;
2299
2300         if (r1->feeds (rbase) && rbase->feeds (r1)) {
2301                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2302                 return;
2303         }
2304
2305         /* make a copy of the existing list of routes that feed r1 */
2306
2307         Route::FedBy existing (r1->fed_by());
2308
2309         /* for each route that feeds r1, recurse, marking it as feeding
2310            rbase as well.
2311         */
2312
2313         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2314                 if (!(r2 = i->r.lock ())) {
2315                         /* (*i) went away, ignore it */
2316                         continue;
2317                 }
2318
2319                 /* r2 is a route that feeds r1 which somehow feeds base. mark
2320                    base as being fed by r2
2321                 */
2322
2323                 rbase->add_fed_by (r2, i->sends_only);
2324
2325                 if (r2 != rbase) {
2326
2327                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2328                            stop here.
2329                         */
2330
2331                         if (r1->feeds (r2) && r2->feeds (r1)) {
2332                                 continue;
2333                         }
2334
2335                         /* now recurse, so that we can mark base as being fed by
2336                            all routes that feed r2
2337                         */
2338
2339                         trace_terminal (r2, rbase);
2340                 }
2341
2342         }
2343 }
2344
2345 void
2346 Session::resort_routes ()
2347 {
2348         /* don't do anything here with signals emitted
2349            by Routes during initial setup or while we
2350            are being destroyed.
2351         */
2352
2353         if (_state_of_the_state & (InitialConnecting | Deletion)) {
2354                 return;
2355         }
2356
2357         if (_route_deletion_in_progress) {
2358                 return;
2359         }
2360
2361         {
2362                 RCUWriter<RouteList> writer (routes);
2363                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2364                 resort_routes_using (r);
2365                 /* writer goes out of scope and forces update */
2366         }
2367
2368 #ifndef NDEBUG
2369         if (DEBUG_ENABLED(DEBUG::Graph)) {
2370                 boost::shared_ptr<RouteList> rl = routes.reader ();
2371                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2372                         DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2373
2374                         const Route::FedBy& fb ((*i)->fed_by());
2375
2376                         for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2377                                 boost::shared_ptr<Route> sf = f->r.lock();
2378                                 if (sf) {
2379                                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2380                                 }
2381                         }
2382                 }
2383         }
2384 #endif
2385
2386 }
2387
2388 /** This is called whenever we need to rebuild the graph of how we will process
2389  *  routes.
2390  *  @param r List of routes, in any order.
2391  */
2392
2393 void
2394 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2395 {
2396         /* We are going to build a directed graph of our routes;
2397            this is where the edges of that graph are put.
2398         */
2399
2400         GraphEdges edges;
2401
2402         /* Go through all routes doing two things:
2403          *
2404          * 1. Collect the edges of the route graph.  Each of these edges
2405          *    is a pair of routes, one of which directly feeds the other
2406          *    either by a JACK connection or by an internal send.
2407          *
2408          * 2. Begin the process of making routes aware of which other
2409          *    routes directly or indirectly feed them.  This information
2410          *    is used by the solo code.
2411          */
2412
2413         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2414
2415                 /* Clear out the route's list of direct or indirect feeds */
2416                 (*i)->clear_fed_by ();
2417
2418                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2419
2420                         bool via_sends_only;
2421
2422                         /* See if this *j feeds *i according to the current state of the JACK
2423                            connections and internal sends.
2424                         */
2425                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2426                                 /* add the edge to the graph (part #1) */
2427                                 edges.add (*j, *i, via_sends_only);
2428                                 /* tell the route (for part #2) */
2429                                 (*i)->add_fed_by (*j, via_sends_only);
2430                         }
2431                 }
2432         }
2433
2434         /* Attempt a topological sort of the route graph */
2435         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2436
2437         if (sorted_routes) {
2438                 /* We got a satisfactory topological sort, so there is no feedback;
2439                    use this new graph.
2440
2441                    Note: the process graph rechain does not require a
2442                    topologically-sorted list, but hey ho.
2443                 */
2444                 if (_process_graph) {
2445                         _process_graph->rechain (sorted_routes, edges);
2446                 }
2447
2448                 _current_route_graph = edges;
2449
2450                 /* Complete the building of the routes' lists of what directly
2451                    or indirectly feeds them.
2452                 */
2453                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2454                         trace_terminal (*i, *i);
2455                 }
2456
2457                 *r = *sorted_routes;
2458
2459 #ifndef NDEBUG
2460                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2461                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2462                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2463                 }
2464 #endif
2465
2466                 SuccessfulGraphSort (); /* EMIT SIGNAL */
2467
2468         } else {
2469                 /* The topological sort failed, so we have a problem.  Tell everyone
2470                    and stick to the old graph; this will continue to be processed, so
2471                    until the feedback is fixed, what is played back will not quite
2472                    reflect what is actually connected.  Note also that we do not
2473                    do trace_terminal here, as it would fail due to an endless recursion,
2474                    so the solo code will think that everything is still connected
2475                    as it was before.
2476                 */
2477
2478                 FeedbackDetected (); /* EMIT SIGNAL */
2479         }
2480
2481 }
2482
2483 /** Find a route name starting with \a base, maybe followed by the
2484  *  lowest \a id.  \a id will always be added if \a definitely_add_number
2485  *  is true on entry; otherwise it will only be added if required
2486  *  to make the name unique.
2487  *
2488  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2489  *  The available route name with the lowest ID will be used, and \a id
2490  *  will be set to the ID.
2491  *
2492  *  \return false if a route name could not be found, and \a track_name
2493  *  and \a id do not reflect a free route name.
2494  */
2495 bool
2496 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2497 {
2498         /* the base may conflict with ports that do not belong to existing
2499            routes, but hidden objects like the click track. So check port names
2500            before anything else.
2501         */
2502
2503         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2504                 if (base == reserved->first) {
2505                         /* Check if this reserved name already exists, and if
2506                            so, disallow it without a numeric suffix.
2507                         */
2508                         if (!reserved->second || route_by_name (reserved->first)) {
2509                                 definitely_add_number = true;
2510                                 if (id < 1) {
2511                                         id = 1;
2512                                 }
2513                         }
2514                         break;
2515                 }
2516         }
2517
2518         /* if we have "base 1" already, it doesn't make sense to add "base"
2519          * if "base 1" has been deleted, adding "base" is no worse than "base 1"
2520          */
2521         if (!definitely_add_number && route_by_name (base) == 0 && (route_by_name (string_compose("%1 1", base)) == 0)) {
2522                 /* just use the base */
2523                 name = base;
2524                 return true;
2525         }
2526
2527         do {
2528                 name = string_compose ("%1 %2", base, id);
2529
2530                 if (route_by_name (name) == 0) {
2531                         return true;
2532                 }
2533
2534                 ++id;
2535
2536         } while (id < (UINT_MAX-1));
2537
2538         return false;
2539 }
2540
2541 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2542 void
2543 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2544 {
2545         in  = ChanCount::ZERO;
2546         out = ChanCount::ZERO;
2547
2548         boost::shared_ptr<RouteList> r = routes.reader ();
2549
2550         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2551                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2552                 if (!tr) {
2553                         continue;
2554                 }
2555                 assert (!tr->is_auditioner()); // XXX remove me
2556                 in  += tr->n_inputs();
2557                 out += tr->n_outputs();
2558         }
2559 }
2560
2561 string
2562 Session::default_track_name_pattern (DataType t)
2563 {
2564         switch (t) {
2565         case DataType::AUDIO:
2566                 if (Profile->get_trx()) {
2567                         return _("Track ");
2568                 } else {
2569                         return _("Audio ");
2570                 }
2571                 break;
2572
2573         case DataType::MIDI:
2574                 return _("MIDI ");
2575         }
2576
2577         return "";
2578 }
2579
2580 /** Caller must not hold process lock
2581  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
2582  *  @param instrument plugin info for the instrument to insert pre-fader, if any
2583  */
2584 list<boost::shared_ptr<MidiTrack> >
2585 Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool strict_io,
2586                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2587                          RouteGroup* route_group, uint32_t how_many,
2588                          string name_template, PresentationInfo::order_t order,
2589                          TrackMode mode)
2590 {
2591         string track_name;
2592         uint32_t track_id = 0;
2593         string port;
2594         RouteList new_routes;
2595         list<boost::shared_ptr<MidiTrack> > ret;
2596
2597         const string name_pattern = default_track_name_pattern (DataType::MIDI);
2598         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2599
2600         while (how_many) {
2601                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2602                         error << "cannot find name for new midi track" << endmsg;
2603                         goto failed;
2604                 }
2605
2606                 boost::shared_ptr<MidiTrack> track;
2607
2608                 try {
2609                         track.reset (new MidiTrack (*this, track_name, mode));
2610
2611                         if (track->init ()) {
2612                                 goto failed;
2613                         }
2614
2615                         if (strict_io) {
2616                                 track->set_strict_io (true);
2617                         }
2618
2619                         BOOST_MARK_TRACK (track);
2620
2621                         {
2622                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2623                                 if (track->input()->ensure_io (input, false, this)) {
2624                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2625                                         goto failed;
2626                                 }
2627
2628                                 if (track->output()->ensure_io (output, false, this)) {
2629                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2630                                         goto failed;
2631                                 }
2632                         }
2633
2634                         if (route_group) {
2635                                 route_group->add (track);
2636                         }
2637
2638                         new_routes.push_back (track);
2639                         ret.push_back (track);
2640                 }
2641
2642                 catch (failed_constructor &err) {
2643                         error << _("Session: could not create new midi track.") << endmsg;
2644                         goto failed;
2645                 }
2646
2647                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2648
2649                         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;
2650                         goto failed;
2651                 }
2652
2653                 --how_many;
2654         }
2655
2656   failed:
2657         if (!new_routes.empty()) {
2658                 StateProtector sp (this);
2659                 if (Profile->get_trx()) {
2660                         add_routes (new_routes, false, false, false, order);
2661                 } else {
2662                         add_routes (new_routes, true, true, false, order);
2663                 }
2664
2665                 if (instrument) {
2666                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2667                                 PluginPtr plugin = instrument->load (*this);
2668                                 if (!plugin) {
2669                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2670                                         continue;
2671                                 }
2672                                 if (pset) {
2673                                         plugin->load_preset (*pset);
2674                                 }
2675                                 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2676                                 if (strict_io) {
2677                                         pi->set_strict_io (true);
2678                                 }
2679
2680                                 (*r)->add_processor (pi, PreFader);
2681
2682                                 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2683                                         (*r)->move_instrument_down (false);
2684                                 }
2685                         }
2686                 }
2687         }
2688
2689         return ret;
2690 }
2691
2692 RouteList
2693 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, bool strict_io,
2694                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2695                          PresentationInfo::Flag flag, PresentationInfo::order_t order)
2696 {
2697         string bus_name;
2698         uint32_t bus_id = 0;
2699         string port;
2700         RouteList ret;
2701
2702         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2703
2704         while (how_many) {
2705                 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2706                         error << "cannot find name for new midi bus" << endmsg;
2707                         goto failure;
2708                 }
2709
2710                 try {
2711                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2712
2713                         if (bus->init ()) {
2714                                 goto failure;
2715                         }
2716
2717                         if (strict_io) {
2718                                 bus->set_strict_io (true);
2719                         }
2720
2721                         BOOST_MARK_ROUTE(bus);
2722
2723                         {
2724                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2725
2726                                 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2727                                         error << _("cannot configure new midi bus input") << endmsg;
2728                                         goto failure;
2729                                 }
2730
2731
2732                                 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2733                                         error << _("cannot configure new midi bus output") << endmsg;
2734                                         goto failure;
2735                                 }
2736                         }
2737
2738                         if (route_group) {
2739                                 route_group->add (bus);
2740                         }
2741
2742                         bus->add_internal_return ();
2743                         ret.push_back (bus);
2744                 }
2745
2746                 catch (failed_constructor &err) {
2747                         error << _("Session: could not create new audio route.") << endmsg;
2748                         goto failure;
2749                 }
2750
2751                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2752                         error << pfe.what() << endmsg;
2753                         goto failure;
2754                 }
2755
2756
2757                 --how_many;
2758         }
2759
2760   failure:
2761         if (!ret.empty()) {
2762                 StateProtector sp (this);
2763                 add_routes (ret, false, false, false, order);
2764
2765                 if (instrument) {
2766                         for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2767                                 PluginPtr plugin = instrument->load (*this);
2768                                 if (!plugin) {
2769                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2770                                         continue;
2771                                 }
2772                                 if (pset) {
2773                                         plugin->load_preset (*pset);
2774                                 }
2775                                 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2776                                 if (strict_io) {
2777                                         pi->set_strict_io (true);
2778                                 }
2779
2780                                 (*r)->add_processor (pi, PreFader);
2781
2782                                 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2783                                         (*r)->move_instrument_down (false);
2784                                 }
2785                         }
2786                 }
2787         }
2788
2789         return ret;
2790
2791 }
2792
2793
2794 void
2795 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2796 {
2797         boost::shared_ptr<Route> midi_track (wmt.lock());
2798
2799         if (!midi_track) {
2800                 return;
2801         }
2802
2803         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2804
2805                 if (change.after.n_audio() <= change.before.n_audio()) {
2806                         return;
2807                 }
2808
2809                 /* new audio ports: make sure the audio goes somewhere useful,
2810                  * unless the user has no-auto-connect selected.
2811                  *
2812                  * The existing ChanCounts don't matter for this call as they are only
2813                  * to do with matching input and output indices, and we are only changing
2814                  * outputs here.
2815                  */
2816                 auto_connect_route (midi_track, false, ChanCount(), change.before);
2817         }
2818 }
2819
2820 #ifdef USE_TRACKS_CODE_FEATURES
2821
2822 static bool
2823 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2824 {
2825         return route1->remote_control_id() < route2->remote_control_id();
2826 }
2827
2828 void
2829 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2830 {
2831         // it is not allowed to perform connection
2832         if (!IO::connecting_legal) {
2833                 return;
2834         }
2835
2836         // if we are deleting routes we will call this once at the end
2837         if (_route_deletion_in_progress) {
2838                 return;
2839         }
2840
2841         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2842
2843         if (withLock) {
2844                 lm.acquire ();
2845         }
2846
2847         // We need to disconnect the route's inputs and outputs first
2848         // basing on autoconnect configuration
2849         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2850         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2851
2852         ChanCount existing_inputs;
2853         ChanCount existing_outputs;
2854         count_existing_track_channels (existing_inputs, existing_outputs);
2855
2856         //ChanCount inputs = ChanCount::ZERO;
2857         //ChanCount outputs = ChanCount::ZERO;
2858
2859         RouteList existing_routes = *routes.reader ();
2860         existing_routes.sort (compare_routes_by_remote_id);
2861
2862         {
2863                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2864
2865                 vector<string> physinputs;
2866                 vector<string> physoutputs;
2867
2868                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2869                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2870
2871                 uint32_t input_n = 0;
2872                 uint32_t output_n = 0;
2873                 RouteList::iterator rIter = existing_routes.begin();
2874                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2875                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2876                 for (; rIter != existing_routes.end(); ++rIter) {
2877                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2878                                 continue;
2879                         }
2880
2881                         if (current_output_auto_connection == AutoConnectPhysical) {
2882                                 (*rIter)->amp()->deactivate();
2883                         } else if (current_output_auto_connection == AutoConnectMaster) {
2884                                 (*rIter)->amp()->activate();
2885                         }
2886
2887                         if (reconnectIputs) {
2888                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2889
2890                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2891
2892                                         if (current_input_auto_connection & AutoConnectPhysical) {
2893
2894                                                 if ( input_n == physinputs.size() ) {
2895                                                         break;
2896                                                 }
2897
2898                                                 string port = physinputs[input_n];
2899
2900                                                 if (port.empty() ) {
2901                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2902                                                 }
2903
2904                                                 //GZ: check this; could be heavy
2905                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2906                                                 ++input_n;
2907                                         }
2908                                 }
2909                         }
2910
2911                         if (reconnectOutputs) {
2912
2913                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2914                                 if (current_output_auto_connection & AutoConnectPhysical) {
2915
2916                                         //GZ: check this; could be heavy
2917                                         (*rIter)->output()->disconnect (this);
2918                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2919
2920                                         //GZ: check this; could be heavy
2921                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2922
2923                                 } else if (current_output_auto_connection & AutoConnectMaster){
2924
2925                                         if (!reconnect_master) {
2926                                                 continue;
2927                                         }
2928
2929                                         //GZ: check this; could be heavy
2930                                         (*rIter)->output()->disconnect (this);
2931
2932                                         if (_master_out) {
2933                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2934                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2935                                         } else {
2936                                                 error << error << "Master bus is not available" << endmsg;
2937                                                 break;
2938                                         }
2939                                 }
2940
2941                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2942                                         if (current_output_auto_connection & AutoConnectPhysical) {
2943
2944                                                 if ( output_n == physoutputs.size() ) {
2945                                                         break;
2946                                                 }
2947
2948                                                 string port = physoutputs[output_n];
2949
2950                                                 if (port.empty() ) {
2951                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2952                                                 }
2953
2954                                                 //GZ: check this; could be heavy
2955                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2956                                                 ++output_n;
2957
2958                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2959
2960                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2961                                                         break;
2962                                                 }
2963
2964                                                 // connect to master bus
2965                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2966
2967                                                 if (port.empty() ) {
2968                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2969                                                 }
2970
2971
2972                                                 //GZ: check this; could be heavy
2973                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2974
2975                                         }
2976                                 }
2977                         }
2978                 }
2979
2980                 _master_out->output()->disconnect (this);
2981                 auto_connect_master_bus ();
2982         }
2983
2984         graph_reordered ();
2985
2986         session_routes_reconnected (); /* EMIT SIGNAL */
2987 }
2988
2989 void
2990 Session::reconnect_midi_scene_ports(bool inputs)
2991 {
2992     if (inputs ) {
2993
2994         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2995         if (scene_in_ptr) {
2996             scene_in_ptr->disconnect_all ();
2997
2998             std::vector<EngineStateController::MidiPortState> midi_port_states;
2999             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3000
3001             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3002
3003             for (; state_iter != midi_port_states.end(); ++state_iter) {
3004                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
3005                     scene_in_ptr->connect (state_iter->name);
3006                 }
3007             }
3008         }
3009
3010     } else {
3011
3012         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
3013
3014         if (scene_out_ptr ) {
3015             scene_out_ptr->disconnect_all ();
3016
3017             std::vector<EngineStateController::MidiPortState> midi_port_states;
3018             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
3019
3020             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3021
3022             for (; state_iter != midi_port_states.end(); ++state_iter) {
3023                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
3024                     scene_out_ptr->connect (state_iter->name);
3025                 }
3026             }
3027         }
3028     }
3029 }
3030
3031 void
3032 Session::reconnect_mtc_ports ()
3033 {
3034         boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
3035
3036         if (!mtc_in_ptr) {
3037                 return;
3038         }
3039
3040         mtc_in_ptr->disconnect_all ();
3041
3042         std::vector<EngineStateController::MidiPortState> midi_port_states;
3043         EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3044
3045         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3046
3047         for (; state_iter != midi_port_states.end(); ++state_iter) {
3048                 if (state_iter->available && state_iter->mtc_in) {
3049                         mtc_in_ptr->connect (state_iter->name);
3050                 }
3051         }
3052
3053         if (!_midi_ports->mtc_input_port ()->connected () &&
3054             config.get_external_sync () &&
3055             (Config->get_sync_source () == MTC) ) {
3056                 config.set_external_sync (false);
3057         }
3058
3059         if ( ARDOUR::Profile->get_trx () ) {
3060                 // Tracks need this signal to update timecode_source_dropdown
3061                 MtcOrLtcInputPortChanged (); //emit signal
3062         }
3063 }
3064
3065 void
3066 Session::reconnect_mmc_ports(bool inputs)
3067 {
3068         if (inputs ) { // get all enabled midi input ports
3069
3070                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
3071                 if (mmc_in_ptr) {
3072                         mmc_in_ptr->disconnect_all ();
3073                         std::vector<std::string> enabled_midi_inputs;
3074                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
3075
3076                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
3077
3078                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
3079                                 mmc_in_ptr->connect (*port_iter);
3080                         }
3081
3082                 }
3083         } else { // get all enabled midi output ports
3084
3085                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
3086                 if (mmc_out_ptr ) {
3087                         mmc_out_ptr->disconnect_all ();
3088                         std::vector<std::string> enabled_midi_outputs;
3089                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
3090
3091                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
3092
3093                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
3094                                 mmc_out_ptr->connect (*port_iter);
3095                         }
3096                 }
3097         }
3098 }
3099
3100 #endif
3101
3102 bool
3103 Session::ensure_stripable_sort_order ()
3104 {
3105         StripableList sl;
3106         get_stripables (sl);
3107         sl.sort (Stripable::Sorter ());
3108
3109         bool change = false;
3110         PresentationInfo::order_t order = 0;
3111
3112         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3113                 boost::shared_ptr<Stripable> s (*si);
3114                 assert (!s->is_auditioner ()); // XXX remove me
3115                 if (s->is_monitor ()) {
3116                         continue;
3117                 }
3118                 if (order != s->presentation_info().order()) {
3119                         s->set_presentation_order (order);
3120                         change = true;
3121                 }
3122                 ++order;
3123         }
3124         return change;
3125 }
3126
3127 void
3128 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
3129 {
3130         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", first_new_order, how_many));
3131
3132         if (first_new_order == PresentationInfo::max_order) {
3133                 /* adding at end, no worries */
3134                 return;
3135         }
3136
3137         /* create a gap in the presentation info to accomodate @param how_many
3138          * new objects.
3139          */
3140         StripableList sl;
3141         get_stripables (sl);
3142
3143         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3144                 boost::shared_ptr<Stripable> s (*si);
3145
3146                 if (s->presentation_info().special (false)) {
3147                         continue;
3148                 }
3149
3150                 if (!s->presentation_info().order_set()) {
3151                         continue;
3152                 }
3153
3154                 if (s->presentation_info().order () >= first_new_order) {
3155                         s->set_presentation_order (s->presentation_info().order () + how_many);
3156                 }
3157         }
3158 }
3159
3160 /** Caller must not hold process lock
3161  *  @param name_template string to use for the start of the name, or "" to use "Audio".
3162  */
3163 list< boost::shared_ptr<AudioTrack> >
3164 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
3165                           uint32_t how_many, string name_template, PresentationInfo::order_t order,
3166                           TrackMode mode)
3167 {
3168         string track_name;
3169         uint32_t track_id = 0;
3170         string port;
3171         RouteList new_routes;
3172         list<boost::shared_ptr<AudioTrack> > ret;
3173
3174         const string name_pattern = default_track_name_pattern (DataType::AUDIO);
3175         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
3176
3177         while (how_many) {
3178
3179                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
3180                         error << "cannot find name for new audio track" << endmsg;
3181                         goto failed;
3182                 }
3183
3184                 boost::shared_ptr<AudioTrack> track;
3185
3186                 try {
3187                         track.reset (new AudioTrack (*this, track_name, mode));
3188
3189                         if (track->init ()) {
3190                                 goto failed;
3191                         }
3192
3193                         if (Profile->get_mixbus ()) {
3194                                 track->set_strict_io (true);
3195                         }
3196
3197                         if (ARDOUR::Profile->get_trx ()) {
3198                                 // TRACKS considers it's not a USE CASE, it's
3199                                 // a piece of behavior of the session model:
3200                                 //
3201                                 // Gain for a newly created route depends on
3202                                 // the current output_auto_connect mode:
3203                                 //
3204                                 //  0 for Stereo Out mode
3205                                 //  0 Multi Out mode
3206                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3207                                         track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3208                                 }
3209                         }
3210
3211                         BOOST_MARK_TRACK (track);
3212
3213                         {
3214                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3215
3216                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3217                                         error << string_compose (
3218                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3219                                                 input_channels, output_channels)
3220                                               << endmsg;
3221                                         goto failed;
3222                                 }
3223
3224                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3225                                         error << string_compose (
3226                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3227                                                 input_channels, output_channels)
3228                                               << endmsg;
3229                                         goto failed;
3230                                 }
3231                         }
3232
3233                         if (route_group) {
3234                                 route_group->add (track);
3235                         }
3236
3237                         new_routes.push_back (track);
3238                         ret.push_back (track);
3239                 }
3240
3241                 catch (failed_constructor &err) {
3242                         error << _("Session: could not create new audio track.") << endmsg;
3243                         goto failed;
3244                 }
3245
3246                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3247
3248                         error << pfe.what() << endmsg;
3249                         goto failed;
3250                 }
3251
3252                 --how_many;
3253         }
3254
3255   failed:
3256         if (!new_routes.empty()) {
3257                 StateProtector sp (this);
3258                 if (Profile->get_trx()) {
3259                         add_routes (new_routes, false, false, false, order);
3260                 } else {
3261                         add_routes (new_routes, true, true, false, order);
3262                 }
3263         }
3264
3265         return ret;
3266 }
3267
3268 /** Caller must not hold process lock.
3269  *  @param name_template string to use for the start of the name, or "" to use "Bus".
3270  */
3271 RouteList
3272 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3273                           PresentationInfo::Flag flags, PresentationInfo::order_t order)
3274 {
3275         string bus_name;
3276         uint32_t bus_id = 0;
3277         string port;
3278         RouteList ret;
3279
3280         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3281
3282         while (how_many) {
3283                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3284                         error << "cannot find name for new audio bus" << endmsg;
3285                         goto failure;
3286                 }
3287
3288                 try {
3289                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3290
3291                         if (bus->init ()) {
3292                                 goto failure;
3293                         }
3294
3295                         if (Profile->get_mixbus ()) {
3296                                 bus->set_strict_io (true);
3297                         }
3298
3299                         BOOST_MARK_ROUTE(bus);
3300
3301                         {
3302                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3303
3304                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3305                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3306                                                                  input_channels, output_channels)
3307                                               << endmsg;
3308                                         goto failure;
3309                                 }
3310
3311
3312                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3313                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3314                                                                  input_channels, output_channels)
3315                                               << endmsg;
3316                                         goto failure;
3317                                 }
3318                         }
3319
3320                         if (route_group) {
3321                                 route_group->add (bus);
3322                         }
3323
3324                         bus->add_internal_return ();
3325                         ret.push_back (bus);
3326                 }
3327
3328                 catch (failed_constructor &err) {
3329                         error << _("Session: could not create new audio route.") << endmsg;
3330                         goto failure;
3331                 }
3332
3333                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3334                         error << pfe.what() << endmsg;
3335                         goto failure;
3336                 }
3337
3338
3339                 --how_many;
3340         }
3341
3342   failure:
3343         if (!ret.empty()) {
3344                 StateProtector sp (this);
3345                 if (Profile->get_trx()) {
3346                         add_routes (ret, false, false, false, order);
3347                 } else {
3348                         add_routes (ret, false, true, true, order); // autoconnect // outputs only
3349                 }
3350         }
3351
3352         return ret;
3353
3354 }
3355
3356 RouteList
3357 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3358                                   PlaylistDisposition pd)
3359 {
3360         XMLTree tree;
3361
3362         if (!tree.read (template_path.c_str())) {
3363                 return RouteList();
3364         }
3365
3366         return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3367 }
3368
3369 RouteList
3370 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3371 {
3372         RouteList ret;
3373         uint32_t number = 0;
3374         const uint32_t being_added = how_many;
3375         /* This will prevent the use of any existing XML-provided PBD::ID
3376            values by Stateful.
3377         */
3378         Stateful::ForceIDRegeneration force_ids;
3379         IO::disable_connecting ();
3380
3381         while (how_many) {
3382
3383                 /* We're going to modify the node contents a bit so take a
3384                  * copy. The node may be re-used when duplicating more than once.
3385                  */
3386
3387                 XMLNode node_copy (node);
3388
3389                 try {
3390                         string name;
3391
3392                         if (!name_base.empty()) {
3393
3394                                 /* if we're adding more than one routes, force
3395                                  * all the names of the new routes to be
3396                                  * numbered, via the final parameter.
3397                                  */
3398
3399                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3400                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3401                                         /*NOTREACHDE*/
3402                                 }
3403
3404                         } else {
3405
3406                                 string const route_name  = node_copy.property(X_("name"))->value ();
3407
3408                                 /* generate a new name by adding a number to the end of the template name */
3409                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3410                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3411                                         abort(); /*NOTREACHED*/
3412                                 }
3413                         }
3414
3415                         /* set this name in the XML description that we are about to use */
3416 #warning fixme -- no more Diskstream
3417                         if (pd == CopyPlaylist) {
3418                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3419                                 if (ds_node) {
3420                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3421                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3422                                         // Use same name as Route::set_name_in_state so playlist copy
3423                                         // is picked up when creating the Route in XMLRouteFactory below
3424                                         playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3425                                         playlist->reset_shares ();
3426                                 }
3427                         } else if (pd == SharePlaylist) {
3428                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3429                                 if (ds_node) {
3430                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3431                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3432                                         playlist->share_with ((node_copy.property (X_("id")))->value());
3433                                 }
3434                         }
3435
3436                         bool rename_playlist = (pd == CopyPlaylist || pd == NewPlaylist);
3437
3438                         Route::set_name_in_state (node_copy, name, rename_playlist);
3439
3440                         /* trim bitslots from listen sends so that new ones are used */
3441                         XMLNodeList children = node_copy.children ();
3442                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3443                                 if ((*i)->name() == X_("Processor")) {
3444                                         /* ForceIDRegeneration does not catch the following */
3445                                         XMLProperty const * role = (*i)->property (X_("role"));
3446                                         XMLProperty const * type = (*i)->property (X_("type"));
3447                                         if (role && role->value() == X_("Aux")) {
3448                                                 /* check if the target bus exists.
3449                                                  * we should not save aux-sends in templates.
3450                                                  */
3451                                                 XMLProperty const * target = (*i)->property (X_("target"));
3452                                                 if (!target) {
3453                                                         (*i)->set_property ("type", "dangling-aux-send");
3454                                                         continue;
3455                                                 }
3456                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3457                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3458                                                         (*i)->set_property ("type", "dangling-aux-send");
3459                                                         continue;
3460                                                 }
3461                                         }
3462                                         if (role && role->value() == X_("Listen")) {
3463                                                 (*i)->remove_property (X_("bitslot"));
3464                                         }
3465                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3466                                                 Delivery::Role xrole;
3467                                                 uint32_t bitslot = 0;
3468                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3469                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3470                                                 (*i)->remove_property (X_("bitslot"));
3471                                                 (*i)->remove_property (X_("name"));
3472                                                 (*i)->set_property ("bitslot", bitslot);
3473                                                 (*i)->set_property ("name", name);
3474                                         }
3475                                         else if (type && type->value() == X_("intreturn")) {
3476                                                 (*i)->remove_property (X_("bitslot"));
3477                                                 (*i)->set_property ("ignore-bitslot", "1");
3478                                         }
3479                                         else if (type && type->value() == X_("return")) {
3480                                                 // Return::set_state() generates a new one
3481                                                 (*i)->remove_property (X_("bitslot"));
3482                                         }
3483                                         else if (type && type->value() == X_("port")) {
3484                                                 // PortInsert::set_state() handles the bitslot
3485                                                 (*i)->remove_property (X_("bitslot"));
3486                                                 (*i)->set_property ("ignore-name", "1");
3487                                         }
3488                                 }
3489                         }
3490
3491                         /* new routes start off unsoloed to avoid issues related to
3492                            upstream / downstream buses. */
3493                         node_copy.remove_node_and_delete (X_("Controllable"), X_("name"), X_("solo"));
3494
3495                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3496
3497                         if (route == 0) {
3498                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3499                                 goto out;
3500                         }
3501
3502                         if (boost::dynamic_pointer_cast<Track>(route)) {
3503                                 /* force input/output change signals so that the new diskstream
3504                                    picks up the configuration of the route. During session
3505                                    loading this normally happens in a different way.
3506                                 */
3507
3508                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3509
3510                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3511                                 change.after = route->input()->n_ports();
3512                                 route->input()->changed (change, this);
3513                                 change.after = route->output()->n_ports();
3514                                 route->output()->changed (change, this);
3515                         }
3516
3517                         ret.push_back (route);
3518                 }
3519
3520                 catch (failed_constructor &err) {
3521                         error << _("Session: could not create new route from template") << endmsg;
3522                         goto out;
3523                 }
3524
3525                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3526                         error << pfe.what() << endmsg;
3527                         goto out;
3528                 }
3529
3530                 --how_many;
3531         }
3532
3533   out:
3534         if (!ret.empty()) {
3535                 StateProtector sp (this);
3536                 if (Profile->get_trx()) {
3537                         add_routes (ret, false, false, false, insert_at);
3538                 } else {
3539                         add_routes (ret, true, true, false, insert_at);
3540                 }
3541                 IO::enable_connecting ();
3542         }
3543
3544         return ret;
3545 }
3546
3547 void
3548 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3549 {
3550         try {
3551                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3552                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3553
3554         } catch (...) {
3555                 error << _("Adding new tracks/busses failed") << endmsg;
3556         }
3557
3558         graph_reordered ();
3559
3560         update_latency (false);
3561         update_latency (true);
3562
3563         set_dirty();
3564
3565         if (save) {
3566                 save_state (_current_snapshot_name);
3567         }
3568
3569         update_route_record_state ();
3570
3571         RouteAdded (new_routes); /* EMIT SIGNAL */
3572 }
3573
3574 void
3575 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3576 {
3577         ChanCount existing_inputs;
3578         ChanCount existing_outputs;
3579         uint32_t n_routes;
3580         uint32_t added = 0;
3581
3582         count_existing_track_channels (existing_inputs, existing_outputs);
3583
3584         {
3585                 RCUWriter<RouteList> writer (routes);
3586                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3587                 n_routes = r->size();
3588                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3589
3590                 /* if there is no control out and we're not in the middle of loading,
3591                  * resort the graph here. if there is a control out, we will resort
3592                  * toward the end of this method. if we are in the middle of loading,
3593                  * we will resort when done.
3594                  */
3595
3596                 if (!_monitor_out && IO::connecting_legal) {
3597                         resort_routes_using (r);
3598                 }
3599         }
3600
3601         /* monitor is not part of the order */
3602         if (_monitor_out) {
3603                 assert (n_routes > 0);
3604                 --n_routes;
3605         }
3606
3607         {
3608                 PresentationInfo::ChangeSuspender cs;
3609                 ensure_route_presentation_info_gap (order, new_routes.size());
3610
3611                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3612
3613                         boost::weak_ptr<Route> wpr (*x);
3614                         boost::shared_ptr<Route> r (*x);
3615
3616                         r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3617                         r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3618                         r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3619
3620                         r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3621                         r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3622                         r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3623
3624                         if (r->is_master()) {
3625                                 _master_out = r;
3626                         }
3627
3628                         if (r->is_monitor()) {
3629                                 _monitor_out = r;
3630                         }
3631
3632                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3633                         if (tr) {
3634                                 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3635                                 track_playlist_changed (boost::weak_ptr<Track> (tr));
3636                                 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3637
3638                                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3639                                 if (mt) {
3640                                         mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3641                                         mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3642                                         mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3643                                 }
3644                         }
3645
3646                         if (!r->presentation_info().special (false)) {
3647
3648                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3649
3650                                 /* presentation info order may already have been set from XML */
3651
3652                                 if (!r->presentation_info().order_set()) {
3653                                         if (order == PresentationInfo::max_order) {
3654                                                 /* just add to the end */
3655                                                 r->set_presentation_order (n_routes + added);
3656                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3657                                         } else {
3658                                                 r->set_presentation_order (order + added);
3659                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3660                                         }
3661                                 } else {
3662                                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3663                                 }
3664                         }
3665
3666 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3667                         /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3668                          * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3669                          */
3670                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3671                                                                        r->name(),
3672                                                                        r->presentation_info().order(),
3673                                                                        enum_2_string (r->presentation_info().flags()),
3674                                                                        r->presentation_info()));
3675 #endif
3676
3677
3678                         if (input_auto_connect || output_auto_connect) {
3679                                 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3680                                 existing_inputs += r->n_inputs();
3681                                 existing_outputs += r->n_outputs();
3682                         }
3683
3684                         ARDOUR::GUIIdle ();
3685                 }
3686                 ensure_stripable_sort_order ();
3687         }
3688
3689         if (_monitor_out && IO::connecting_legal) {
3690                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3691
3692                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3693                         if ((*x)->is_monitor()) {
3694                                 /* relax */
3695                         } else if ((*x)->is_master()) {
3696                                 /* relax */
3697                         } else {
3698                                 (*x)->enable_monitor_send ();
3699                         }
3700                 }
3701         }
3702
3703         reassign_track_numbers ();
3704 }
3705
3706 void
3707 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3708 {
3709         boost::shared_ptr<RouteList> r = routes.reader ();
3710         boost::shared_ptr<Send> s;
3711
3712         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3713                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3714                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3715                 }
3716         }
3717 }
3718
3719 void
3720 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3721 {
3722         boost::shared_ptr<RouteList> r = routes.reader ();
3723         boost::shared_ptr<Send> s;
3724
3725         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3726                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3727                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3728                 }
3729         }
3730 }
3731
3732 void
3733 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3734 {
3735         boost::shared_ptr<RouteList> r = routes.reader ();
3736         boost::shared_ptr<Send> s;
3737
3738         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3739                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3740                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3741                 }
3742         }
3743 }
3744
3745 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3746 void
3747 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3748 {
3749         boost::shared_ptr<RouteList> r = routes.reader ();
3750         boost::shared_ptr<RouteList> t (new RouteList);
3751
3752         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3753                 /* no MIDI sends because there are no MIDI busses yet */
3754                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3755                         t->push_back (*i);
3756                 }
3757         }
3758
3759         add_internal_sends (dest, p, t);
3760 }
3761
3762 void
3763 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3764 {
3765         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3766                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3767         }
3768 }
3769
3770 void
3771 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3772 {
3773         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3774 }
3775
3776 void
3777 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3778 {
3779         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3780                 return;
3781         }
3782
3783         if (!dest->internal_return()) {
3784                 dest->add_internal_return ();
3785         }
3786
3787         sender->add_aux_send (dest, before);
3788
3789         graph_reordered ();
3790 }
3791
3792 void
3793 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3794 {
3795         bool mute_changed = false;
3796         bool send_selected = false;
3797
3798         { // RCU Writer scope
3799                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3800                 RCUWriter<RouteList> writer (routes);
3801                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3802
3803                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3804
3805                         if (_selection->selected (*iter)) {
3806                                 send_selected = true;
3807                         }
3808
3809                         if (*iter == _master_out) {
3810                                 continue;
3811                         }
3812
3813                         /* speed up session deletion, don't do the solo dance */
3814                         if (0 == (_state_of_the_state & Deletion)) {
3815                                 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3816                         }
3817
3818                         if ((*iter)->mute_control()->muted ()) {
3819                                 mute_changed = true;
3820                         }
3821
3822                         rs->remove (*iter);
3823
3824                         /* deleting the master out seems like a dumb
3825                            idea, but its more of a UI policy issue
3826                            than our concern.
3827                         */
3828
3829                         if (*iter == _master_out) {
3830                                 _master_out = boost::shared_ptr<Route> ();
3831                         }
3832
3833                         if (*iter == _monitor_out) {
3834                                 _monitor_out.reset ();
3835                         }
3836
3837                         // We need to disconnect the route's inputs and outputs
3838
3839                         (*iter)->input()->disconnect (0);
3840                         (*iter)->output()->disconnect (0);
3841
3842                         /* if the route had internal sends sending to it, remove them */
3843                         if ((*iter)->internal_return()) {
3844
3845                                 boost::shared_ptr<RouteList> r = routes.reader ();
3846                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3847                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3848                                         if (s) {
3849                                                 (*i)->remove_processor (s);
3850                                         }
3851                                 }
3852                         }
3853
3854                         /* if the monitoring section had a pointer to this route, remove it */
3855                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3856                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3857                                 ProcessorChangeBlocker pcb (this, false);
3858                                 (*iter)->remove_aux_or_listen (_monitor_out);
3859                         }
3860
3861                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3862                         if (mt && mt->step_editing()) {
3863                                 if (_step_editors > 0) {
3864                                         _step_editors--;
3865                                 }
3866                         }
3867                 }
3868
3869                 /* writer goes out of scope, forces route list update */
3870
3871         } // end of RCU Writer scope
3872
3873         if (mute_changed) {
3874                 MuteChanged (); /* EMIT SIGNAL */
3875         }
3876
3877         update_route_solo_state ();
3878         update_latency_compensation ();
3879         set_dirty();
3880
3881         /* Re-sort routes to remove the graph's current references to the one that is
3882          * going away, then flush old references out of the graph.
3883          * Wave Tracks: reconnect routes
3884          */
3885
3886 #ifdef USE_TRACKS_CODE_FEATURES
3887                 reconnect_existing_routes(true, false);
3888 #else
3889                 routes.flush (); // maybe unsafe, see below.
3890                 resort_routes ();
3891 #endif
3892
3893         if (_process_graph && !(_state_of_the_state & Deletion)) {
3894                 _process_graph->clear_other_chain ();
3895         }
3896
3897         /* get rid of it from the dead wood collection in the route list manager */
3898         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3899
3900         routes.flush ();
3901
3902         /* remove these routes from the selection if appropriate, and signal
3903          * the change *before* we call DropReferences for them.
3904          */
3905
3906         if (send_selected && !deletion_in_progress()) {
3907                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3908                         _selection->remove_stripable_by_id ((*iter)->id());
3909                 }
3910                 PropertyChange pc;
3911                 pc.add (Properties::selected);
3912                 PresentationInfo::Change (pc);
3913         }
3914
3915         /* try to cause everyone to drop their references
3916          * and unregister ports from the backend
3917          */
3918
3919         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3920                 (*iter)->drop_references ();
3921         }
3922
3923         if (deletion_in_progress()) {
3924                 return;
3925         }
3926
3927         PropertyChange pc;
3928         pc.add (Properties::order);
3929         PresentationInfo::Change (pc);
3930
3931         /* save the new state of the world */
3932
3933         if (save_state (_current_snapshot_name)) {
3934                 save_history (_current_snapshot_name);
3935         }
3936
3937         update_route_record_state ();
3938 }
3939
3940 void
3941 Session::remove_route (boost::shared_ptr<Route> route)
3942 {
3943         boost::shared_ptr<RouteList> rl (new RouteList);
3944         rl->push_back (route);
3945         remove_routes (rl);
3946 }
3947
3948 void
3949 Session::route_mute_changed ()
3950 {
3951         MuteChanged (); /* EMIT SIGNAL */
3952         set_dirty ();
3953 }
3954
3955 void
3956 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3957 {
3958         boost::shared_ptr<Route> route (wpr.lock());
3959
3960         if (!route) {
3961                 return;
3962         }
3963
3964         assert (Config->get_solo_control_is_listen_control());
3965
3966         if (route->solo_control()->soloed_by_self_or_masters()) {
3967
3968                 if (Config->get_exclusive_solo()) {
3969
3970                         RouteGroup* rg = route->route_group ();
3971                         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3972
3973                         boost::shared_ptr<RouteList> r = routes.reader ();
3974
3975                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3976                                 if ((*i) == route) {
3977                                         /* already changed */
3978                                         continue;
3979                                 }
3980
3981                                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3982                                         /* route does not get solo propagated to it */
3983                                         continue;
3984                                 }
3985
3986                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3987                                         /* this route is a part of the same solo group as the route
3988                                          * that was changed. Changing that route did change or will
3989                                          * change all group members appropriately, so we can ignore it
3990                                          * here
3991                                          */
3992                                         continue;
3993                                 }
3994                                 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3995                         }
3996                 }
3997
3998                 _listen_cnt++;
3999
4000         } else if (_listen_cnt > 0) {
4001
4002                 _listen_cnt--;
4003         }
4004 }
4005
4006 void
4007 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
4008 {
4009         boost::shared_ptr<Route> route (wpr.lock());
4010
4011         if (!route) {
4012                 return;
4013         }
4014
4015         bool send_changed = false;
4016
4017         if (route->solo_isolate_control()->solo_isolated()) {
4018                 if (_solo_isolated_cnt == 0) {
4019                         send_changed = true;
4020                 }
4021                 _solo_isolated_cnt++;
4022         } else if (_solo_isolated_cnt > 0) {
4023                 _solo_isolated_cnt--;
4024                 if (_solo_isolated_cnt == 0) {
4025                         send_changed = true;
4026                 }
4027         }
4028
4029         if (send_changed) {
4030                 IsolatedChanged (); /* EMIT SIGNAL */
4031         }
4032 }
4033
4034 void
4035 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
4036 {
4037         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
4038
4039         boost::shared_ptr<Route> route (wpr.lock());
4040
4041         if (!route) {
4042                 return;
4043         }
4044
4045         if (Config->get_solo_control_is_listen_control()) {
4046                 route_listen_changed (group_override, wpr);
4047                 return;
4048         }
4049
4050         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()));
4051
4052         if (route->solo_control()->transitioned_into_solo() == 0) {
4053                 /* route solo changed by upstream/downstream or clear all solo state; not interesting
4054                    to Session.
4055                 */
4056                 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()));
4057                 return;
4058         }
4059
4060         boost::shared_ptr<RouteList> r = routes.reader ();
4061         int32_t delta = route->solo_control()->transitioned_into_solo ();
4062
4063         /* the route may be a member of a group that has shared-solo
4064          * semantics. If so, then all members of that group should follow the
4065          * solo of the changed route. But ... this is optional, controlled by a
4066          * Controllable::GroupControlDisposition.
4067          *
4068          * The first argument to the signal that this method is connected to is the
4069          * GroupControlDisposition value that was used to change solo.
4070          *
4071          * If the solo change was done with group semantics (either InverseGroup
4072          * (force the entire group to change even if the group shared solo is
4073          * disabled) or UseGroup (use the group, which may or may not have the
4074          * shared solo property enabled)) then as we propagate the change to
4075          * the entire session we should IGNORE THE GROUP that the changed route
4076          * belongs to.
4077          */
4078
4079         RouteGroup* rg = route->route_group ();
4080         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
4081
4082         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
4083
4084         if (delta == 1 && Config->get_exclusive_solo()) {
4085
4086                 /* new solo: disable all other solos, but not the group if its solo-enabled */
4087
4088                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4089
4090                         if ((*i) == route) {
4091                                 /* already changed */
4092                                 continue;
4093                         }
4094
4095                         if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4096                                 /* route does not get solo propagated to it */
4097                                 continue;
4098                         }
4099
4100                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4101                                 /* this route is a part of the same solo group as the route
4102                                  * that was changed. Changing that route did change or will
4103                                  * change all group members appropriately, so we can ignore it
4104                                  * here
4105                                  */
4106                                 continue;
4107                         }
4108
4109                         (*i)->solo_control()->set_value (0.0, group_override);
4110                 }
4111         }
4112
4113         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4114
4115         RouteList uninvolved;
4116
4117         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4118
4119         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4120                 bool via_sends_only;
4121                 bool in_signal_flow;
4122
4123                 if ((*i) == route) {
4124                         /* already changed */
4125                         continue;
4126                 }
4127
4128                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4129                         /* route does not get solo propagated to it */
4130                         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(),
4131                                                                   (*i)->can_solo()));
4132                         continue;
4133                 }
4134
4135                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4136                         /* this route is a part of the same solo group as the route
4137                          * that was changed. Changing that route did change or will
4138                          * change all group members appropriately, so we can ignore it
4139                          * here
4140                          */
4141                         continue;
4142                 }
4143
4144                 in_signal_flow = false;
4145
4146                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4147
4148                 if ((*i)->feeds (route, &via_sends_only)) {
4149                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4150                         if (!via_sends_only) {
4151                                 if (!route->soloed_by_others_upstream()) {
4152                                         (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4153                                 } else {
4154                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4155                                 }
4156                         } else {
4157                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4158                         }
4159                         in_signal_flow = true;
4160                 } else {
4161                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4162                 }
4163
4164                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4165
4166                 if (route->feeds (*i, &via_sends_only)) {
4167                         /* propagate solo upstream only if routing other than
4168                            sends is involved, but do consider the other route
4169                            (*i) to be part of the signal flow even if only
4170                            sends are involved.
4171                         */
4172                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4173                                                                   route->name(),
4174                                                                   (*i)->name(),
4175                                                                   via_sends_only,
4176                                                                   route->soloed_by_others_downstream(),
4177                                                                   route->soloed_by_others_upstream()));
4178                         if (!via_sends_only) {
4179                                 //NB. Triggers Invert Push, which handles soloed by downstream
4180                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4181                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4182                         } else {
4183                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4184                         }
4185                         in_signal_flow = true;
4186                 } else {
4187                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
4188                 }
4189
4190                 if (!in_signal_flow) {
4191                         uninvolved.push_back (*i);
4192                 }
4193         }
4194
4195         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4196
4197         /* now notify that the mute state of the routes not involved in the signal
4198            pathway of the just-solo-changed route may have altered.
4199         */
4200
4201         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4202                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4203                 (*i)->act_on_mute ();
4204                 /* Session will emit SoloChanged() after all solo changes are
4205                  * complete, which should be used by UIs to update mute status
4206                  */
4207         }
4208 }
4209
4210 void
4211 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4212 {
4213         /* now figure out if anything that matters is soloed (or is "listening")*/
4214
4215         bool something_soloed = false;
4216         bool something_listening = false;
4217         uint32_t listeners = 0;
4218         uint32_t isolated = 0;
4219
4220         if (!r) {
4221                 r = routes.reader();
4222         }
4223
4224         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4225                 if ((*i)->can_solo()) {
4226                         if (Config->get_solo_control_is_listen_control()) {
4227                                 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4228                                         listeners++;
4229                                         something_listening = true;
4230                                 }
4231                         } else {
4232                                 (*i)->set_listen (false);
4233                                 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4234                                         something_soloed = true;
4235                                 }
4236                         }
4237                 }
4238
4239                 if ((*i)->solo_isolate_control()->solo_isolated()) {
4240                         isolated++;
4241                 }
4242         }
4243
4244         if (something_soloed != _non_soloed_outs_muted) {
4245                 _non_soloed_outs_muted = something_soloed;
4246                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4247         }
4248
4249         if (something_listening != _listening) {
4250                 _listening = something_listening;
4251                 SoloActive (_listening);
4252         }
4253
4254         _listen_cnt = listeners;
4255
4256         if (isolated != _solo_isolated_cnt) {
4257                 _solo_isolated_cnt = isolated;
4258                 IsolatedChanged (); /* EMIT SIGNAL */
4259         }
4260
4261         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4262                                                   something_soloed, listeners, isolated));
4263
4264
4265         SoloChanged (); /* EMIT SIGNAL */
4266         set_dirty();
4267 }
4268
4269 bool
4270 Session::muted () const
4271 {
4272         // TODO consider caching the value on every MuteChanged signal,
4273         // Note that API users may also subscribe to MuteChanged and hence
4274         // this method needs to be called first.
4275         bool muted = false;
4276         StripableList all;
4277         get_stripables (all);
4278         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4279                 assert (!(*i)->is_auditioner()); // XXX remove me
4280                 if ((*i)->is_monitor()) {
4281                         continue;
4282                 }
4283                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route>(*i);
4284                 if (r && !r->active()) {
4285                         continue;
4286                 }
4287                 boost::shared_ptr<MuteControl> mc = (*i)->mute_control();
4288                 if (mc && mc->muted ()) {
4289                         muted = true;
4290                         break;
4291                 }
4292         }
4293         return muted;
4294 }
4295
4296 std::vector<boost::weak_ptr<AutomationControl> >
4297 Session::cancel_all_mute ()
4298 {
4299         StripableList all;
4300         get_stripables (all);
4301         std::vector<boost::weak_ptr<AutomationControl> > muted;
4302         boost::shared_ptr<ControlList> cl (new ControlList);
4303         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4304                 assert (!(*i)->is_auditioner());
4305                 if ((*i)->is_monitor()) {
4306                         continue;
4307                 }
4308                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (*i);
4309                 if (r && !r->active()) {
4310                         continue;
4311                 }
4312                 boost::shared_ptr<AutomationControl> ac = (*i)->mute_control();
4313                 if (ac && ac->get_value () > 0) {
4314                         cl->push_back (ac);
4315                         muted.push_back (boost::weak_ptr<AutomationControl>(ac));
4316                 }
4317         }
4318         if (!cl->empty ()) {
4319                 set_controls (cl, 0.0, PBD::Controllable::UseGroup);
4320         }
4321         return muted;
4322 }
4323
4324 void
4325 Session::get_stripables (StripableList& sl) const
4326 {
4327         boost::shared_ptr<RouteList> r = routes.reader ();
4328         sl.insert (sl.end(), r->begin(), r->end());
4329
4330         VCAList v = _vca_manager->vcas ();
4331         sl.insert (sl.end(), v.begin(), v.end());
4332 }
4333
4334 StripableList
4335 Session::get_stripables () const
4336 {
4337         StripableList rv;
4338         Session::get_stripables (rv);
4339         rv.sort (Stripable::Sorter ());
4340         return rv;
4341 }
4342
4343 boost::shared_ptr<RouteList>
4344 Session::get_routes_with_internal_returns() const
4345 {
4346         boost::shared_ptr<RouteList> r = routes.reader ();
4347         boost::shared_ptr<RouteList> rl (new RouteList);
4348
4349         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4350                 if ((*i)->internal_return ()) {
4351                         rl->push_back (*i);
4352                 }
4353         }
4354         return rl;
4355 }
4356
4357 bool
4358 Session::io_name_is_legal (const std::string& name) const
4359 {
4360         boost::shared_ptr<RouteList> r = routes.reader ();
4361
4362         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4363                 if (name == reserved->first) {
4364                         if (!route_by_name (reserved->first)) {
4365                                 /* first instance of a reserved name is allowed for some */
4366                                 return reserved->second;
4367                         }
4368                         /* all other instances of a reserved name are not allowed */
4369                         return false;
4370                 }
4371         }
4372
4373         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4374                 if ((*i)->name() == name) {
4375                         return false;
4376                 }
4377
4378                 if ((*i)->has_io_processor_named (name)) {
4379                         return false;
4380                 }
4381         }
4382
4383         return true;
4384 }
4385
4386 void
4387 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4388 {
4389         RouteList rl2;
4390         vector<string> connections;
4391
4392         /* if we are passed only a single route and we're not told to turn
4393          * others off, then just do the simple thing.
4394          */
4395
4396         if (flip_others == false && rl->size() == 1) {
4397                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4398                 if (mt) {
4399                         mt->set_input_active (onoff);
4400                         return;
4401                 }
4402         }
4403
4404         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4405
4406                 PortSet& ps ((*rt)->input()->ports());
4407
4408                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4409                         p->get_connections (connections);
4410                 }
4411
4412                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4413                         routes_using_input_from (*s, rl2);
4414                 }
4415
4416                 /* scan all relevant routes to see if others are on or off */
4417
4418                 bool others_are_already_on = false;
4419
4420                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4421
4422                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4423
4424                         if (!mt) {
4425                                 continue;
4426                         }
4427
4428                         if ((*r) != (*rt)) {
4429                                 if (mt->input_active()) {
4430                                         others_are_already_on = true;
4431                                 }
4432                         } else {
4433                                 /* this one needs changing */
4434                                 mt->set_input_active (onoff);
4435                         }
4436                 }
4437
4438                 if (flip_others) {
4439
4440                         /* globally reverse other routes */
4441
4442                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4443                                 if ((*r) != (*rt)) {
4444                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4445                                         if (mt) {
4446                                                 mt->set_input_active (!others_are_already_on);
4447                                         }
4448                                 }
4449                         }
4450                 }
4451         }
4452 }
4453
4454 void
4455 Session::routes_using_input_from (const string& str, RouteList& rl)
4456 {
4457         boost::shared_ptr<RouteList> r = routes.reader();
4458
4459         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4460                 if ((*i)->input()->connected_to (str)) {
4461                         rl.push_back (*i);
4462                 }
4463         }
4464 }
4465
4466 boost::shared_ptr<Route>
4467 Session::route_by_name (string name) const
4468 {
4469         boost::shared_ptr<RouteList> r = routes.reader ();
4470
4471         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4472                 if ((*i)->name() == name) {
4473                         return *i;
4474                 }
4475         }
4476
4477         return boost::shared_ptr<Route> ((Route*) 0);
4478 }
4479
4480 boost::shared_ptr<Route>
4481 Session::route_by_id (PBD::ID id) const
4482 {
4483         boost::shared_ptr<RouteList> r = routes.reader ();
4484
4485         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4486                 if ((*i)->id() == id) {
4487                         return *i;
4488                 }
4489         }
4490
4491         return boost::shared_ptr<Route> ((Route*) 0);
4492 }
4493
4494
4495 boost::shared_ptr<Stripable>
4496 Session::stripable_by_id (PBD::ID id) const
4497 {
4498         StripableList sl;
4499         get_stripables (sl);
4500
4501         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4502                 if ((*s)->id() == id) {
4503                         return *s;
4504                 }
4505         }
4506
4507         return boost::shared_ptr<Stripable>();
4508 }
4509
4510 boost::shared_ptr<Processor>
4511 Session::processor_by_id (PBD::ID id) const
4512 {
4513         boost::shared_ptr<RouteList> r = routes.reader ();
4514
4515         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4516                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4517                 if (p) {
4518                         return p;
4519                 }
4520         }
4521
4522         return boost::shared_ptr<Processor> ();
4523 }
4524
4525 boost::shared_ptr<Route>
4526 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4527 {
4528         return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4529 }
4530
4531 boost::shared_ptr<Stripable>
4532 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4533 {
4534         StripableList sl;
4535         PresentationInfo::order_t match_cnt = 0;
4536
4537         get_stripables (sl);
4538         sl.sort (Stripable::Sorter());
4539
4540         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4541
4542                 if ((*s)->presentation_info().hidden()) {
4543                         /* if the caller didn't explicitly ask for hidden
4544                            stripables, ignore hidden ones. This matches
4545                            the semantics of the pre-PresentationOrder
4546                            "get by RID" logic of Ardour 4.x and earlier.
4547
4548                            XXX at some point we should likely reverse
4549                            the logic of the flags, because asking for "the
4550                            hidden stripables" is not going to be common,
4551                            whereas asking for visible ones is normal.
4552                         */
4553
4554                         if (! (flags & PresentationInfo::Hidden)) {
4555                                 continue;
4556                         }
4557                 }
4558
4559                 if ((*s)->presentation_info().flag_match (flags)) {
4560                         if (match_cnt++ == n) {
4561                                 return *s;
4562                         }
4563                 }
4564         }
4565
4566         /* there is no nth stripable that matches the given flags */
4567         return boost::shared_ptr<Stripable>();
4568 }
4569
4570 boost::shared_ptr<Route>
4571 Session::route_by_selected_count (uint32_t id) const
4572 {
4573         RouteList r (*(routes.reader ()));
4574         r.sort (Stripable::Sorter());
4575
4576         RouteList::iterator i;
4577
4578         for (i = r.begin(); i != r.end(); ++i) {
4579                 if ((*i)->is_selected()) {
4580                         if (id == 0) {
4581                                 return *i;
4582                         }
4583                         --id;
4584                 }
4585         }
4586
4587         return boost::shared_ptr<Route> ();
4588 }
4589
4590 void
4591 Session::reassign_track_numbers ()
4592 {
4593         int64_t tn = 0;
4594         int64_t bn = 0;
4595         RouteList r (*(routes.reader ()));
4596         r.sort (Stripable::Sorter());
4597
4598         StateProtector sp (this);
4599
4600         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4601                 assert (!(*i)->is_auditioner());
4602                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4603                         (*i)->set_track_number(++tn);
4604                 }
4605                 else if (!(*i)->is_master() && !(*i)->is_monitor()) {
4606                         (*i)->set_track_number(--bn);
4607                 }
4608         }
4609         const uint32_t decimals = ceilf (log10f (tn + 1));
4610         const bool decimals_changed = _track_number_decimals != decimals;
4611         _track_number_decimals = decimals;
4612
4613         if (decimals_changed && config.get_track_name_number ()) {
4614                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4615                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4616                         if (t) {
4617                                 t->resync_track_name();
4618                         }
4619                 }
4620                 // trigger GUI re-layout
4621                 config.ParameterChanged("track-name-number");
4622         }
4623
4624 #ifndef NDEBUG
4625         if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4626                 boost::shared_ptr<RouteList> rl = routes.reader ();
4627                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4628                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4629                 }
4630         }
4631 #endif /* NDEBUG */
4632
4633 }
4634
4635 void
4636 Session::playlist_region_added (boost::weak_ptr<Region> w)
4637 {
4638         boost::shared_ptr<Region> r = w.lock ();
4639         if (!r) {
4640                 return;
4641         }
4642
4643         /* These are the operations that are currently in progress... */
4644         list<GQuark> curr = _current_trans_quarks;
4645         curr.sort ();
4646
4647         /* ...and these are the operations during which we want to update
4648            the session range location markers.
4649         */
4650         list<GQuark> ops;
4651         ops.push_back (Operations::capture);
4652         ops.push_back (Operations::paste);
4653         ops.push_back (Operations::duplicate_region);
4654         ops.push_back (Operations::insert_file);
4655         ops.push_back (Operations::insert_region);
4656         ops.push_back (Operations::drag_region_brush);
4657         ops.push_back (Operations::region_drag);
4658         ops.push_back (Operations::selection_grab);
4659         ops.push_back (Operations::region_fill);
4660         ops.push_back (Operations::fill_selection);
4661         ops.push_back (Operations::create_region);
4662         ops.push_back (Operations::region_copy);
4663         ops.push_back (Operations::fixed_time_region_copy);
4664         ops.sort ();
4665
4666         /* See if any of the current operations match the ones that we want */
4667         list<GQuark> in;
4668         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4669
4670         /* If so, update the session range markers */
4671         if (!in.empty ()) {
4672                 maybe_update_session_range (r->position (), r->last_sample ());
4673         }
4674 }
4675
4676 /** Update the session range markers if a is before the current start or
4677  *  b is after the current end.
4678  */
4679 void
4680 Session::maybe_update_session_range (samplepos_t a, samplepos_t b)
4681 {
4682         if (_state_of_the_state & Loading) {
4683                 return;
4684         }
4685
4686         samplepos_t session_end_marker_shift_samples = session_end_shift * _nominal_sample_rate;
4687
4688         if (_session_range_location == 0) {
4689
4690                 set_session_range_location (a, b + session_end_marker_shift_samples);
4691
4692         } else {
4693
4694                 if (a < _session_range_location->start()) {
4695                         _session_range_location->set_start (a);
4696                 }
4697
4698                 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4699                         _session_range_location->set_end (b);
4700                 }
4701         }
4702 }
4703
4704 void
4705 Session::set_end_is_free (bool yn)
4706 {
4707         _session_range_end_is_free = yn;
4708 }
4709
4710 void
4711 Session::playlist_ranges_moved (list<Evoral::RangeMove<samplepos_t> > const & ranges)
4712 {
4713         for (list<Evoral::RangeMove<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4714                 maybe_update_session_range (i->to, i->to + i->length);
4715         }
4716 }
4717
4718 void
4719 Session::playlist_regions_extended (list<Evoral::Range<samplepos_t> > const & ranges)
4720 {
4721         for (list<Evoral::Range<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4722                 maybe_update_session_range (i->from, i->to);
4723         }
4724 }
4725
4726 /* Region management */
4727
4728 boost::shared_ptr<Region>
4729 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4730 {
4731         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4732         RegionFactory::RegionMap::const_iterator i;
4733         boost::shared_ptr<Region> region;
4734
4735         Glib::Threads::Mutex::Lock lm (region_lock);
4736
4737         for (i = regions.begin(); i != regions.end(); ++i) {
4738
4739                 region = i->second;
4740
4741                 if (region->whole_file()) {
4742
4743                         if (child->source_equivalent (region)) {
4744                                 return region;
4745                         }
4746                 }
4747         }
4748
4749         return boost::shared_ptr<Region> ();
4750 }
4751
4752 int
4753 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4754 {
4755         set<boost::shared_ptr<Region> > relevant_regions;
4756
4757         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4758                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4759         }
4760
4761         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4762                 set<boost::shared_ptr<Region> >::iterator tmp;
4763
4764                 tmp = r;
4765                 ++tmp;
4766
4767                 playlists->destroy_region (*r);
4768                 RegionFactory::map_remove (*r);
4769
4770                 (*r)->drop_sources ();
4771                 (*r)->drop_references ();
4772
4773                 relevant_regions.erase (r);
4774
4775                 r = tmp;
4776         }
4777
4778         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4779
4780                 {
4781                         Glib::Threads::Mutex::Lock ls (source_lock);
4782                         /* remove from the main source list */
4783                         sources.erase ((*s)->id());
4784                 }
4785
4786                 (*s)->mark_for_remove ();
4787                 (*s)->drop_references ();
4788
4789                 s = srcs.erase (s);
4790         }
4791
4792         return 0;
4793 }
4794
4795 int
4796 Session::remove_last_capture ()
4797 {
4798         list<boost::shared_ptr<Source> > srcs;
4799
4800         boost::shared_ptr<RouteList> rl = routes.reader ();
4801         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4802                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4803                 if (!tr) {
4804                         continue;
4805                 }
4806
4807                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4808
4809                 if (!l.empty()) {
4810                         srcs.insert (srcs.end(), l.begin(), l.end());
4811                         l.clear ();
4812                 }
4813         }
4814
4815         destroy_sources (srcs);
4816
4817         save_state (_current_snapshot_name);
4818
4819         return 0;
4820 }
4821
4822 /* Source Management */
4823
4824 void
4825 Session::add_source (boost::shared_ptr<Source> source)
4826 {
4827         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4828         pair<SourceMap::iterator,bool> result;
4829
4830         entry.first = source->id();
4831         entry.second = source;
4832
4833         {
4834                 Glib::Threads::Mutex::Lock lm (source_lock);
4835                 result = sources.insert (entry);
4836         }
4837
4838         if (result.second) {
4839
4840                 /* yay, new source */
4841
4842                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4843
4844                 if (fs) {
4845                         if (!fs->within_session()) {
4846                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4847                         }
4848                 }
4849
4850                 set_dirty();
4851
4852                 boost::shared_ptr<AudioFileSource> afs;
4853
4854                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4855                         if (Config->get_auto_analyse_audio()) {
4856                                 Analyser::queue_source_for_analysis (source, false);
4857                         }
4858                 }
4859
4860                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4861         }
4862 }
4863
4864 void
4865 Session::remove_source (boost::weak_ptr<Source> src)
4866 {
4867         if (_state_of_the_state & Deletion) {
4868                 return;
4869         }
4870
4871         SourceMap::iterator i;
4872         boost::shared_ptr<Source> source = src.lock();
4873
4874         if (!source) {
4875                 return;
4876         }
4877
4878         {
4879                 Glib::Threads::Mutex::Lock lm (source_lock);
4880
4881                 if ((i = sources.find (source->id())) != sources.end()) {
4882                         sources.erase (i);
4883                 }
4884         }
4885
4886         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4887
4888                 /* save state so we don't end up with a session file
4889                    referring to non-existent sources.
4890                 */
4891
4892                 save_state (_current_snapshot_name);
4893         }
4894 }
4895
4896 boost::shared_ptr<Source>
4897 Session::source_by_id (const PBD::ID& id)
4898 {
4899         Glib::Threads::Mutex::Lock lm (source_lock);
4900         SourceMap::iterator i;
4901         boost::shared_ptr<Source> source;
4902
4903         if ((i = sources.find (id)) != sources.end()) {
4904                 source = i->second;
4905         }
4906
4907         return source;
4908 }
4909
4910 boost::shared_ptr<AudioFileSource>
4911 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4912 {
4913         /* Restricted to audio files because only audio sources have channel
4914            as a property.
4915         */
4916
4917         Glib::Threads::Mutex::Lock lm (source_lock);
4918
4919         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4920                 boost::shared_ptr<AudioFileSource> afs
4921                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4922
4923                 if (afs && afs->path() == path && chn == afs->channel()) {
4924                         return afs;
4925                 }
4926         }
4927
4928         return boost::shared_ptr<AudioFileSource>();
4929 }
4930
4931 boost::shared_ptr<MidiSource>
4932 Session::midi_source_by_path (const std::string& path, bool need_source_lock) const
4933 {
4934         /* Restricted to MIDI files because audio sources require a channel
4935            for unique identification, in addition to a path.
4936         */
4937
4938         Glib::Threads::Mutex::Lock lm (source_lock, Glib::Threads::NOT_LOCK);
4939         if (need_source_lock) {
4940                 lm.acquire ();
4941         }
4942
4943         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4944                 boost::shared_ptr<MidiSource> ms
4945                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4946                 boost::shared_ptr<FileSource> fs
4947                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4948
4949                 if (ms && fs && fs->path() == path) {
4950                         return ms;
4951                 }
4952         }
4953
4954         return boost::shared_ptr<MidiSource>();
4955 }
4956
4957 uint32_t
4958 Session::count_sources_by_origin (const string& path)
4959 {
4960         uint32_t cnt = 0;
4961         Glib::Threads::Mutex::Lock lm (source_lock);
4962
4963         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4964                 boost::shared_ptr<FileSource> fs
4965                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4966
4967                 if (fs && fs->origin() == path) {
4968                         ++cnt;
4969                 }
4970         }
4971
4972         return cnt;
4973 }
4974
4975 static string
4976 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4977         if (hash) {
4978                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4979                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4980         } else {
4981                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4982         }
4983 }
4984
4985 string
4986 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4987 {
4988         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4989
4990         if (Glib::path_is_absolute (filepath)) {
4991
4992                 /* rip the session dir from the audiofile source */
4993
4994                 string session_path;
4995                 bool in_another_session = true;
4996
4997                 if (filepath.find (interchange_dir_string) != string::npos) {
4998
4999                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
5000                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
5001                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
5002                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
5003
5004                         /* see if it is within our session */
5005
5006                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5007                                 if (i->path == session_path) {
5008                                         in_another_session = false;
5009                                         break;
5010                                 }
5011                         }
5012                 } else {
5013                         in_another_session = false;
5014                 }
5015
5016
5017                 if (in_another_session) {
5018                         SessionDirectory sd (session_path);
5019                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
5020                 }
5021         }
5022
5023         /* 1) if file belongs to this session
5024          * it may be a relative path (interchange/...)
5025          * or just basename (session_state, remove source)
5026          * -> just use the basename
5027          */
5028         std::string filename = Glib::path_get_basename (filepath);
5029         std::string path;
5030
5031         /* 2) if the file is outside our session dir:
5032          * (imported but not copied) add the path for check-summming */
5033         if (!in_session) {
5034                 path = Glib::path_get_dirname (filepath);
5035         }
5036
5037         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
5038 }
5039
5040 string
5041 Session::new_audio_source_path_for_embedded (const std::string& path)
5042 {
5043         /* embedded source:
5044          *
5045          * we know that the filename is already unique because it exists
5046          * out in the filesystem.
5047          *
5048          * However, when we bring it into the session, we could get a
5049          * collision.
5050          *
5051          * Eg. two embedded files:
5052          *
5053          *          /foo/bar/baz.wav
5054          *          /frob/nic/baz.wav
5055          *
5056          * When merged into session, these collide.
5057          *
5058          * There will not be a conflict with in-memory sources
5059          * because when the source was created we already picked
5060          * a unique name for it.
5061          *
5062          * This collision is not likely to be common, but we have to guard
5063          * against it.  So, if there is a collision, take the md5 hash of the
5064          * the path, and use that as the filename instead.
5065          */
5066
5067         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5068         string base = Glib::path_get_basename (path);
5069         string newpath = Glib::build_filename (sdir.sound_path(), base);
5070
5071         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5072
5073                 MD5 md5;
5074
5075                 md5.digestString (path.c_str());
5076                 md5.writeToString ();
5077                 base = md5.digestChars;
5078
5079                 string ext = get_suffix (path);
5080
5081                 if (!ext.empty()) {
5082                         base += '.';
5083                         base += ext;
5084                 }
5085
5086                 newpath = Glib::build_filename (sdir.sound_path(), base);
5087
5088                 /* if this collides, we're screwed */
5089
5090                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5091                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5092                         return string();
5093                 }
5094
5095         }
5096
5097         return newpath;
5098 }
5099
5100 /** Return true if there are no audio file sources that use @param name as
5101  * the filename component of their path.
5102  *
5103  * Return false otherwise.
5104  *
5105  * This method MUST ONLY be used to check in-session, mono files since it
5106  * hard-codes the channel of the audio file source we are looking for as zero.
5107  *
5108  * If/when Ardour supports native files in non-mono formats, the logic here
5109  * will need to be revisited.
5110  */
5111 bool
5112 Session::audio_source_name_is_unique (const string& name)
5113 {
5114         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5115         vector<space_and_path>::iterator i;
5116         uint32_t existing = 0;
5117
5118         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5119
5120                 /* note that we search *without* the extension so that
5121                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5122                    in the event that this new name is required for
5123                    a file format change.
5124                 */
5125
5126                 const string spath = *i;
5127
5128                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5129                         existing++;
5130                         break;
5131                 }
5132
5133                 /* it is possible that we have the path already
5134                  * assigned to a source that has not yet been written
5135                  * (ie. the write source for a diskstream). we have to
5136                  * check this in order to make sure that our candidate
5137                  * path isn't used again, because that can lead to
5138                  * two Sources point to the same file with different
5139                  * notions of their removability.
5140                  */
5141
5142
5143                 string possible_path = Glib::build_filename (spath, name);
5144
5145                 if (audio_source_by_path_and_channel (possible_path, 0)) {
5146                         existing++;
5147                         break;
5148                 }
5149         }
5150
5151         return (existing == 0);
5152 }
5153
5154 string
5155 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)
5156 {
5157         ostringstream sstr;
5158         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5159
5160         if (Profile->get_trx() && destructive) {
5161                 sstr << 'T';
5162                 sstr << setfill ('0') << setw (4) << cnt;
5163                 sstr << legalized_base;
5164         } else {
5165                 sstr << legalized_base;
5166
5167                 if (take_required || related_exists) {
5168                         sstr << '-';
5169                         sstr << cnt;
5170                 }
5171         }
5172
5173         if (nchan == 2) {
5174                 if (chan == 0) {
5175                         sstr << "%L";
5176                 } else {
5177                         sstr << "%R";
5178                 }
5179         } else if (nchan > 2) {
5180                 if (nchan < 26) {
5181                         sstr << '%';
5182                         sstr << 'a' + chan;
5183                 } else {
5184                         /* XXX what? more than 26 channels! */
5185                         sstr << '%';
5186                         sstr << chan+1;
5187                 }
5188         }
5189
5190         sstr << ext;
5191
5192         return sstr.str();
5193 }
5194
5195 /** Return a unique name based on \a base for a new internal audio source */
5196 string
5197 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5198 {
5199         uint32_t cnt;
5200         string possible_name;
5201         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5202         string legalized;
5203         bool some_related_source_name_exists = false;
5204
5205         legalized = legalize_for_path (base);
5206
5207         // Find a "version" of the base name that doesn't exist in any of the possible directories.
5208
5209         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5210
5211                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5212
5213                 if (audio_source_name_is_unique (possible_name)) {
5214                         break;
5215                 }
5216
5217                 some_related_source_name_exists = true;
5218
5219                 if (cnt > limit) {
5220                         error << string_compose(
5221                                         _("There are already %1 recordings for %2, which I consider too many."),
5222                                         limit, base) << endmsg;
5223                         destroy ();
5224                         throw failed_constructor();
5225                 }
5226         }
5227
5228         /* We've established that the new name does not exist in any session
5229          * directory, so now find out which one we should use for this new
5230          * audio source.
5231          */
5232
5233         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5234
5235         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5236
5237         return s;
5238 }
5239
5240 /** Return a unique name based on `base` for a new internal MIDI source */
5241 string
5242 Session::new_midi_source_path (const string& base, bool need_lock)
5243 {
5244         string possible_path;
5245         string possible_name;
5246
5247         possible_name = legalize_for_path (base);
5248
5249         // Find a "version" of the file name that doesn't exist in any of the possible directories.
5250         std::vector<string> sdirs = source_search_path(DataType::MIDI);
5251
5252         /* - the main session folder is the first in the vector.
5253          * - after checking all locations for file-name uniqueness,
5254          *   we keep the one from the last iteration as new file name
5255          * - midi files are small and should just be kept in the main session-folder
5256          *
5257          * -> reverse the array, check main session folder last and use that as location
5258          *    for MIDI files.
5259          */
5260         std::reverse(sdirs.begin(), sdirs.end());
5261
5262         while (true) {
5263                 possible_name = bump_name_once (possible_name, '-');
5264
5265                 vector<space_and_path>::iterator i;
5266                 uint32_t existing = 0;
5267
5268                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5269
5270                         possible_path = Glib::build_filename (*i, possible_name + ".mid");
5271
5272                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5273                                 existing++;
5274                         }
5275
5276                         if (midi_source_by_path (possible_path, need_lock)) {
5277                                 existing++;
5278                         }
5279                 }
5280
5281                 if (possible_path.size () >= PATH_MAX) {
5282                         error << string_compose(
5283                                         _("There are already many recordings for %1, resulting in a too long file-path %2."),
5284                                         base, possible_path) << endmsg;
5285                         destroy ();
5286                         return 0;
5287                 }
5288
5289                 if (existing == 0) {
5290                         break;
5291                 }
5292         }
5293
5294         /* No need to "find best location" for software/app-based RAID, because
5295            MIDI is so small that we always put it in the same place.
5296         */
5297
5298         return possible_path;
5299 }
5300
5301
5302 /** Create a new within-session audio source */
5303 boost::shared_ptr<AudioFileSource>
5304 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5305 {
5306         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5307
5308         if (!path.empty()) {
5309                 return boost::dynamic_pointer_cast<AudioFileSource> (
5310                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, sample_rate(), true, true));
5311         } else {
5312                 throw failed_constructor ();
5313         }
5314 }
5315
5316 /** Create a new within-session MIDI source */
5317 boost::shared_ptr<MidiSource>
5318 Session::create_midi_source_for_session (string const & basic_name)
5319 {
5320         const string path = new_midi_source_path (basic_name);
5321
5322         if (!path.empty()) {
5323                 return boost::dynamic_pointer_cast<SMFSource> (
5324                         SourceFactory::createWritable (
5325                                 DataType::MIDI, *this, path, false, sample_rate()));
5326         } else {
5327                 throw failed_constructor ();
5328         }
5329 }
5330
5331 /** Create a new within-session MIDI source */
5332 boost::shared_ptr<MidiSource>
5333 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5334 {
5335         /* the caller passes in the track the source will be used in,
5336            so that we can keep the numbering sane.
5337
5338            Rationale: a track with the name "Foo" that has had N
5339            captures carried out so far will ALREADY have a write source
5340            named "Foo-N+1.mid" waiting to be used for the next capture.
5341
5342            If we call new_midi_source_name() we will get "Foo-N+2". But
5343            there is no region corresponding to "Foo-N+1", so when
5344            "Foo-N+2" appears in the track, the gap presents the user
5345            with odd behaviour - why did it skip past Foo-N+1?
5346
5347            We could explain this to the user in some odd way, but
5348            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5349            use "Foo-N+1" here.
5350
5351            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5352         */
5353
5354         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5355         assert (mt);
5356         std::string name = track->steal_write_source_name ();
5357
5358         if (name.empty()) {
5359                 return boost::shared_ptr<MidiSource>();
5360         }
5361
5362         /* MIDI files are small, just put them in the first location of the
5363            session source search path.
5364         */
5365
5366         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5367
5368         return boost::dynamic_pointer_cast<SMFSource> (
5369                 SourceFactory::createWritable (
5370                         DataType::MIDI, *this, path, false, sample_rate()));
5371 }
5372
5373
5374 void
5375 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5376 {
5377         if (playlist->hidden()) {
5378                 return;
5379         }
5380
5381         playlists->add (playlist);
5382
5383         if (unused) {
5384                 playlist->release();
5385         }
5386
5387         set_dirty();
5388 }
5389
5390 void
5391 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5392 {
5393         if (_state_of_the_state & Deletion) {
5394                 return;
5395         }
5396
5397         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5398
5399         if (!playlist) {
5400                 return;
5401         }
5402
5403         playlists->remove (playlist);
5404
5405         set_dirty();
5406 }
5407
5408 void
5409 Session::set_audition (boost::shared_ptr<Region> r)
5410 {
5411         pending_audition_region = r;
5412         add_post_transport_work (PostTransportAudition);
5413         _butler->schedule_transport_work ();
5414 }
5415
5416 void
5417 Session::audition_playlist ()
5418 {
5419         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5420         ev->region.reset ();
5421         queue_event (ev);
5422 }
5423
5424
5425 void
5426 Session::register_lua_function (
5427                 const std::string& name,
5428                 const std::string& script,
5429                 const LuaScriptParamList& args
5430                 )
5431 {
5432         Glib::Threads::Mutex::Lock lm (lua_lock);
5433
5434         lua_State* L = lua.getState();
5435
5436         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5437         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5438         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5439                 if ((*i)->optional && !(*i)->is_set) { continue; }
5440                 tbl_arg[(*i)->name] = (*i)->value;
5441         }
5442         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5443         lm.release();
5444
5445         LuaScriptsChanged (); /* EMIT SIGNAL */
5446         set_dirty();
5447 }
5448
5449 void
5450 Session::unregister_lua_function (const std::string& name)
5451 {
5452         Glib::Threads::Mutex::Lock lm (lua_lock);
5453         (*_lua_del)(name); // throws luabridge::LuaException
5454         lua.collect_garbage ();
5455         lm.release();
5456
5457         LuaScriptsChanged (); /* EMIT SIGNAL */
5458         set_dirty();
5459 }
5460
5461 std::vector<std::string>
5462 Session::registered_lua_functions ()
5463 {
5464         Glib::Threads::Mutex::Lock lm (lua_lock);
5465         std::vector<std::string> rv;
5466
5467         try {
5468                 luabridge::LuaRef list ((*_lua_list)());
5469                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5470                         if (!i.key ().isString ()) { assert(0); continue; }
5471                         rv.push_back (i.key ().cast<std::string> ());
5472                 }
5473         } catch (...) { }
5474         return rv;
5475 }
5476
5477 #ifndef NDEBUG
5478 static void _lua_print (std::string s) {
5479         std::cout << "SessionLua: " << s << "\n";
5480 }
5481 #endif
5482
5483 void
5484 Session::try_run_lua (pframes_t nframes)
5485 {
5486         if (_n_lua_scripts == 0) return;
5487         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5488         if (tm.locked ()) {
5489                 try { (*_lua_run)(nframes); } catch (...) { }
5490                 lua.collect_garbage_step ();
5491         }
5492 }
5493
5494 void
5495 Session::setup_lua ()
5496 {
5497 #ifndef NDEBUG
5498         lua.Print.connect (&_lua_print);
5499 #endif
5500         lua.tweak_rt_gc ();
5501         lua.sandbox (true);
5502         lua.do_command (
5503                         "function ArdourSession ()"
5504                         "  local self = { scripts = {}, instances = {} }"
5505                         ""
5506                         "  local remove = function (n)"
5507                         "   self.scripts[n] = nil"
5508                         "   self.instances[n] = nil"
5509                         "   Session:scripts_changed()" // call back
5510                         "  end"
5511                         ""
5512                         "  local addinternal = function (n, f, a)"
5513                         "   assert(type(n) == 'string', 'function-name must be string')"
5514                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5515                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5516                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5517                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5518                         "   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 }"
5519                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5520                         "   Session:scripts_changed()" // call back
5521                         "  end"
5522                         ""
5523                         "  local add = function (n, b, a)"
5524                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5525                         "   load (b)()" // assigns f
5526                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5527                         "   addinternal (n, load(f), a)"
5528                         "  end"
5529                         ""
5530                         "  local run = function (...)"
5531                         "   for n, s in pairs (self.instances) do"
5532                         "     local status, err = pcall (s, ...)"
5533                         "     if not status then"
5534                         "       print ('fn \"'.. n .. '\": ', err)"
5535                         "       remove (n)"
5536                         "      end"
5537                         "   end"
5538                         "   collectgarbage()"
5539                         "  end"
5540                         ""
5541                         "  local cleanup = function ()"
5542                         "   self.scripts = nil"
5543                         "   self.instances = nil"
5544                         "  end"
5545                         ""
5546                         "  local list = function ()"
5547                         "   local rv = {}"
5548                         "   for n, _ in pairs (self.scripts) do"
5549                         "     rv[n] = true"
5550                         "   end"
5551                         "   return rv"
5552                         "  end"
5553                         ""
5554                         "  local function basic_serialize (o)"
5555                         "    if type(o) == \"number\" then"
5556                         "     return tostring(o)"
5557                         "    else"
5558                         "     return string.format(\"%q\", o)"
5559                         "    end"
5560                         "  end"
5561                         ""
5562                         "  local function serialize (name, value)"
5563                         "   local rv = name .. ' = '"
5564                         "   collectgarbage()"
5565                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5566                         "    return rv .. basic_serialize(value) .. ' '"
5567                         "   elseif type(value) == \"table\" then"
5568                         "    rv = rv .. '{} '"
5569                         "    for k,v in pairs(value) do"
5570                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5571                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5572                         "     collectgarbage()" // string concatenation allocates a new string :(
5573                         "    end"
5574                         "    return rv;"
5575                         "   elseif type(value) == \"function\" then"
5576                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5577                         "   else"
5578                         "    error('cannot save a ' .. type(value))"
5579                         "   end"
5580                         "  end"
5581                         ""
5582                         ""
5583                         "  local save = function ()"
5584                         "   return (serialize('scripts', self.scripts))"
5585                         "  end"
5586                         ""
5587                         "  local restore = function (state)"
5588                         "   self.scripts = {}"
5589                         "   load (state)()"
5590                         "   for n, s in pairs (scripts) do"
5591                         "    addinternal (n, load(s['f']), s['a'])"
5592                         "   end"
5593                         "  end"
5594                         ""
5595                         " return { run = run, add = add, remove = remove,"
5596                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5597                         " end"
5598                         " "
5599                         " sess = ArdourSession ()"
5600                         " ArdourSession = nil"
5601                         " "
5602                         "function ardour () end"
5603                         );
5604
5605         lua_State* L = lua.getState();
5606
5607         try {
5608                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5609                 lua.do_command ("sess = nil"); // hide it.
5610                 lua.do_command ("collectgarbage()");
5611
5612                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5613                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5614                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5615                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5616                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5617                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5618                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5619         } catch (luabridge::LuaException const& e) {
5620                 fatal << string_compose (_("programming error: %1"),
5621                                 std::string ("Failed to setup session Lua interpreter") + e.what ())
5622                         << endmsg;
5623                 abort(); /*NOTREACHED*/
5624         } catch (...) {
5625                 fatal << string_compose (_("programming error: %1"),
5626                                 X_("Failed to setup session Lua interpreter"))
5627                         << endmsg;
5628                 abort(); /*NOTREACHED*/
5629         }
5630
5631         LuaBindings::stddef (L);
5632         LuaBindings::common (L);
5633         LuaBindings::dsp (L);
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                                 update_latency_compensation ();
7358                         }
7359                 }
7360
7361                 {
7362                         // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7363                         // jack1 cannot cope with removing ports while processing
7364                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7365                         AudioEngine::instance()->clear_pending_port_deletions ();
7366                 }
7367
7368                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7369         }
7370         pthread_mutex_unlock (&_auto_connect_mutex);
7371 }
7372
7373 void
7374 Session::cancel_all_solo ()
7375 {
7376         StripableList sl;
7377
7378         get_stripables (sl);
7379
7380         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7381         clear_all_solo_state (routes.reader());
7382 }