libs/ardour/session.cc

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