libs/ardour/session.cc

   1 /*
   2     Copyright (C) 1999-2010 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <stdint.h>
  21
  22 #include <algorithm>
  23 #include <string>
  24 #include <vector>
  25 #include <sstream>
  26 #include <cstdio> /* sprintf(3) ... grrr */
  27 #include <cmath>
  28 #include <cerrno>
  29 #include <unistd.h>
  30 #include <limits.h>
  31
  32 #include <glibmm/threads.h>
  33 #include <glibmm/miscutils.h>
  34 #include <glibmm/fileutils.h>
  35
  36 #include <boost/algorithm/string/erase.hpp>
  37
  38 #include "pbd/basename.h"
  39 #include "pbd/convert.h"
  40 #include "pbd/error.h"
  41 #include "pbd/file_utils.h"
  42 #include "pbd/md5.h"
  43 #include "pbd/pthread_utils.h"
  44 #include "pbd/search_path.h"
  45 #include "pbd/stacktrace.h"
  46 #include "pbd/stl_delete.h"
  47 #include "pbd/replace_all.h"
  48 #include "pbd/unwind.h"
  49
  50 #include "ardour/amp.h"
  51 #include "ardour/analyser.h"
  52 #include "ardour/async_midi_port.h"
  53 #include "ardour/audio_buffer.h"
  54 #include "ardour/audio_port.h"
  55 #include "ardour/audio_track.h"
  56 #include "ardour/audioengine.h"
  57 #include "ardour/audiofilesource.h"
  58 #include "ardour/auditioner.h"
  59 #include "ardour/boost_debug.h"
  60 #include "ardour/buffer_manager.h"
  61 #include "ardour/buffer_set.h"
  62 #include "ardour/bundle.h"
  63 #include "ardour/butler.h"
  64 #include "ardour/click.h"
  65 #include "ardour/control_protocol_manager.h"
  66 #include "ardour/data_type.h"
  67 #include "ardour/debug.h"
  68 #include "ardour/disk_reader.h"
  69 #include "ardour/directory_names.h"
  70 #ifdef USE_TRACKS_CODE_FEATURES
  71 #include "ardour/engine_state_controller.h"
  72 #endif
  73 #include "ardour/filename_extensions.h"
  74 #include "ardour/gain_control.h"
  75 #include "ardour/graph.h"
  76 #include "ardour/luabindings.h"
  77 #include "ardour/midiport_manager.h"
  78 #include "ardour/scene_changer.h"
  79 #include "ardour/midi_patch_manager.h"
  80 #include "ardour/midi_track.h"
  81 #include "ardour/midi_ui.h"
  82 #include "ardour/operations.h"
  83 #include "ardour/playlist.h"
  84 #include "ardour/playlist_factory.h"
  85 #include "ardour/plugin.h"
  86 #include "ardour/plugin_insert.h"
  87 #include "ardour/process_thread.h"
  88 #include "ardour/profile.h"
  89 #include "ardour/rc_configuration.h"
  90 #include "ardour/recent_sessions.h"
  91 #include "ardour/region.h"
  92 #include "ardour/region_factory.h"
  93 #include "ardour/revision.h"
  94 #include "ardour/route_graph.h"
  95 #include "ardour/route_group.h"
  96 #include "ardour/send.h"
  97 #include "ardour/selection.h"
  98 #include "ardour/session.h"
  99 #include "ardour/session_directory.h"
 100 #include "ardour/session_playlists.h"
 101 #include "ardour/slave.h"
 102 #include "ardour/smf_source.h"
 103 #include "ardour/slave.h"
 104 #include "ardour/solo_isolate_control.h"
 105 #include "ardour/source_factory.h"
 106 #include "ardour/speakers.h"
 107 #include "ardour/tempo.h"
 108 #include "ardour/ticker.h"
 109 #include "ardour/track.h"
 110 #include "ardour/types_convert.h"
 111 #include "ardour/user_bundle.h"
 112 #include "ardour/utils.h"
 113 #include "ardour/vca_manager.h"
 114 #include "ardour/vca.h"
 115
 116 #include "midi++/port.h"
 117 #include "midi++/mmc.h"
 118
 119 #include "LuaBridge/LuaBridge.h"
 120
 121 #include "pbd/i18n.h"
 122
 123 #include <glibmm/checksum.h>
 124
 125 namespace ARDOUR {
 126 class MidiSource;
 127 class Processor;
 128 class Speakers;
 129 }
 130
 131 using namespace std;
 132 using namespace ARDOUR;
 133 using namespace PBD;
 134
 135 bool Session::_disable_all_loaded_plugins = false;
 136 bool Session::_bypass_all_loaded_plugins = false;
 137 guint Session::_name_id_counter = 0;
 138
 139 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
 140 PBD::Signal1<void,std::string> Session::Dialog;
 141 PBD::Signal0<int> Session::AskAboutPendingState;
 142 PBD::Signal2<int, samplecnt_t, samplecnt_t> Session::AskAboutSampleRateMismatch;
 143 PBD::Signal2<void, samplecnt_t, samplecnt_t> Session::NotifyAboutSampleRateMismatch;
 144 PBD::Signal0<void> Session::SendFeedback;
 145 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
 146
 147 PBD::Signal1<void, samplepos_t> Session::StartTimeChanged;
 148 PBD::Signal1<void, samplepos_t> Session::EndTimeChanged;
 149 PBD::Signal2<void,std::string, std::string> Session::Exported;
 150 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
 151 PBD::Signal0<void> Session::Quit;
 152 PBD::Signal0<void> Session::FeedbackDetected;
 153 PBD::Signal0<void> Session::SuccessfulGraphSort;
 154 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
 155
 156 const samplecnt_t Session::bounce_chunk_size = 8192;
 157 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
 158 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
 159
 160 // seconds should be added after the region exceeds end marker
 161 #ifdef USE_TRACKS_CODE_FEATURES
 162 const uint32_t Session::session_end_shift = 5;
 163 #else
 164 const uint32_t Session::session_end_shift = 0;
 165 #endif
 166
 167 /** @param snapshot_name Snapshot name, without .ardour suffix */
 168 Session::Session (AudioEngine &eng,
 169                   const string& fullpath,
 170                   const string& snapshot_name,
 171                   BusProfile* bus_profile,
 172                   string mix_template)
 173         : playlists (new SessionPlaylists)
 174         , _engine (eng)
 175         , process_function (&Session::process_with_events)
 176         , _bounce_processing_active (false)
 177         , waiting_for_sync_offset (false)
 178         , _base_sample_rate (0)
 179         , _nominal_sample_rate (0)
 180         , _current_sample_rate (0)
 181         , transport_sub_state (0)
 182         , _record_status (Disabled)
 183         , _transport_sample (0)
 184         , _seek_counter (0)
 185         , _session_range_location (0)
 186         , _session_range_end_is_free (true)
 187         , _slave (0)
 188         , _silent (false)
 189         , _remaining_latency_preroll (0)
 190         , _transport_speed (0)
 191         , _default_transport_speed (1.0)
 192         , _last_transport_speed (0)
 193         , _signalled_varispeed (0)
 194         , _target_transport_speed (0.0)
 195         , auto_play_legal (false)
 196         , _last_slave_transport_sample (0)
 197         , maximum_output_latency (0)
 198         , _requested_return_sample (-1)
 199         , current_block_size (0)
 200         , _worst_output_latency (0)
 201         , _worst_input_latency (0)
 202         , _worst_track_latency (0)
 203         , _worst_track_out_latency (0)
 204         , _have_captured (false)
 205         , _non_soloed_outs_muted (false)
 206         , _listening (false)
 207         , _listen_cnt (0)
 208         , _solo_isolated_cnt (0)
 209         , _writable (false)
 210         , _was_seamless (Config->get_seamless_loop ())
 211         , _under_nsm_control (false)
 212         , _xrun_count (0)
 213         , delta_accumulator_cnt (0)
 214         , average_slave_delta (1800) // !!! why 1800 ???
 215         , average_dir (0)
 216         , have_first_delta_accumulator (false)
 217         , _slave_state (Stopped)
 218         , _mtc_active (false)
 219         , _ltc_active (false)
 220         , post_export_sync (false)
 221         , post_export_position (0)
 222         , _exporting (false)
 223         , _export_rolling (false)
 224         , _realtime_export (false)
 225         , _region_export (false)
 226         , _export_preroll (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         if (latent_locate) {
2175                 *latent_locate = false;
2176         }
2177
2178         samplepos_t ret;
2179
2180         if (synced_to_engine()) {
2181                 /* Note: this is basically just sync-to-JACK */
2182                 ret = _engine.transport_sample();
2183         } else {
2184                 ret = _transport_sample;
2185         }
2186
2187         assert (ret >= 0);
2188
2189         if (!transport_rolling()) {
2190                 return ret;
2191         }
2192
2193 #if 0 // TODO looping
2194         if (_transport_speed > 0.0f) {
2195                 if (play_loop && have_looped) {
2196                         /* the play-position wrapped at the loop-point
2197                          * ardour is already playing the beginning of the loop,
2198                          * but due to playback latency, the "audible frame"
2199                          * is still at the end of the loop.
2200                          */
2201                         Location *location = _locations->auto_loop_location();
2202                         sampleoffset_t lo = location->start() - ret;
2203                         if (lo > 0) {
2204                                 ret = location->end () - lo;
2205                                 if (latent_locate) {
2206                                         *latent_locate = true;
2207                                 }
2208                         }
2209                 }
2210         } else if (_transport_speed < 0.0f) {
2211                 /* XXX wot? no backward looping? */
2212         }
2213 #endif
2214
2215         return std::max ((samplepos_t)0, ret);
2216 }
2217
2218 samplecnt_t
2219 Session::preroll_samples (samplepos_t pos) const
2220 {
2221         const float pr = Config->get_preroll_seconds();
2222         if (pos >= 0 && pr < 0) {
2223                 const Tempo& tempo = _tempo_map->tempo_at_sample (pos);
2224                 const Meter& meter = _tempo_map->meter_at_sample (pos);
2225                 return meter.samples_per_bar (tempo, sample_rate()) * -pr;
2226         }
2227         if (pr < 0) {
2228                 return 0;
2229         }
2230         return pr * sample_rate();
2231 }
2232
2233 void
2234 Session::set_sample_rate (samplecnt_t frames_per_second)
2235 {
2236         /** \fn void Session::set_sample_size(samplecnt_t)
2237                 the AudioEngine object that calls this guarantees
2238                 that it will not be called while we are also in
2239                 ::process(). Its fine to do things that block
2240                 here.
2241         */
2242
2243         if (_base_sample_rate == 0) {
2244                 _base_sample_rate = frames_per_second;
2245         }
2246         else if (_base_sample_rate != frames_per_second && frames_per_second != _nominal_sample_rate) {
2247                 NotifyAboutSampleRateMismatch (_base_sample_rate, frames_per_second);
2248         }
2249         _nominal_sample_rate = frames_per_second;
2250
2251         sync_time_vars();
2252
2253         clear_clicks ();
2254         reset_write_sources (false);
2255
2256         // XXX we need some equivalent to this, somehow
2257         // SndFileSource::setup_standard_crossfades (frames_per_second);
2258
2259         set_dirty();
2260
2261         /* XXX need to reset/reinstantiate all LADSPA plugins */
2262 }
2263
2264 void
2265 Session::set_block_size (pframes_t nframes)
2266 {
2267         /* the AudioEngine guarantees
2268            that it will not be called while we are also in
2269            ::process(). It is therefore fine to do things that block
2270            here.
2271         */
2272
2273         {
2274                 current_block_size = nframes;
2275
2276                 ensure_buffers ();
2277
2278                 boost::shared_ptr<RouteList> r = routes.reader ();
2279
2280                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2281                         (*i)->set_block_size (nframes);
2282                 }
2283
2284                 boost::shared_ptr<RouteList> rl = routes.reader ();
2285                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2286                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2287                         if (tr) {
2288                                 tr->set_block_size (nframes);
2289                         }
2290                 }
2291
2292                 set_worst_io_latencies ();
2293         }
2294 }
2295
2296
2297 static void
2298 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2299 {
2300         boost::shared_ptr<Route> r2;
2301
2302         if (r1->feeds (rbase) && rbase->feeds (r1)) {
2303                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2304                 return;
2305         }
2306
2307         /* make a copy of the existing list of routes that feed r1 */
2308
2309         Route::FedBy existing (r1->fed_by());
2310
2311         /* for each route that feeds r1, recurse, marking it as feeding
2312            rbase as well.
2313         */
2314
2315         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2316                 if (!(r2 = i->r.lock ())) {
2317                         /* (*i) went away, ignore it */
2318                         continue;
2319                 }
2320
2321                 /* r2 is a route that feeds r1 which somehow feeds base. mark
2322                    base as being fed by r2
2323                 */
2324
2325                 rbase->add_fed_by (r2, i->sends_only);
2326
2327                 if (r2 != rbase) {
2328
2329                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2330                            stop here.
2331                         */
2332
2333                         if (r1->feeds (r2) && r2->feeds (r1)) {
2334                                 continue;
2335                         }
2336
2337                         /* now recurse, so that we can mark base as being fed by
2338                            all routes that feed r2
2339                         */
2340
2341                         trace_terminal (r2, rbase);
2342                 }
2343
2344         }
2345 }
2346
2347 void
2348 Session::resort_routes ()
2349 {
2350         /* don't do anything here with signals emitted
2351            by Routes during initial setup or while we
2352            are being destroyed.
2353         */
2354
2355         if (_state_of_the_state & (InitialConnecting | Deletion)) {
2356                 return;
2357         }
2358
2359         if (_route_deletion_in_progress) {
2360                 return;
2361         }
2362
2363         {
2364                 RCUWriter<RouteList> writer (routes);
2365                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2366                 resort_routes_using (r);
2367                 /* writer goes out of scope and forces update */
2368         }
2369
2370 #ifndef NDEBUG
2371         if (DEBUG_ENABLED(DEBUG::Graph)) {
2372                 boost::shared_ptr<RouteList> rl = routes.reader ();
2373                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2374                         DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2375
2376                         const Route::FedBy& fb ((*i)->fed_by());
2377
2378                         for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2379                                 boost::shared_ptr<Route> sf = f->r.lock();
2380                                 if (sf) {
2381                                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2382                                 }
2383                         }
2384                 }
2385         }
2386 #endif
2387
2388 }
2389
2390 /** This is called whenever we need to rebuild the graph of how we will process
2391  *  routes.
2392  *  @param r List of routes, in any order.
2393  */
2394
2395 void
2396 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2397 {
2398         /* We are going to build a directed graph of our routes;
2399            this is where the edges of that graph are put.
2400         */
2401
2402         GraphEdges edges;
2403
2404         /* Go through all routes doing two things:
2405          *
2406          * 1. Collect the edges of the route graph.  Each of these edges
2407          *    is a pair of routes, one of which directly feeds the other
2408          *    either by a JACK connection or by an internal send.
2409          *
2410          * 2. Begin the process of making routes aware of which other
2411          *    routes directly or indirectly feed them.  This information
2412          *    is used by the solo code.
2413          */
2414
2415         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2416
2417                 /* Clear out the route's list of direct or indirect feeds */
2418                 (*i)->clear_fed_by ();
2419
2420                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2421
2422                         bool via_sends_only;
2423
2424                         /* See if this *j feeds *i according to the current state of the JACK
2425                            connections and internal sends.
2426                         */
2427                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2428                                 /* add the edge to the graph (part #1) */
2429                                 edges.add (*j, *i, via_sends_only);
2430                                 /* tell the route (for part #2) */
2431                                 (*i)->add_fed_by (*j, via_sends_only);
2432                         }
2433                 }
2434         }
2435
2436         /* Attempt a topological sort of the route graph */
2437         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2438
2439         if (sorted_routes) {
2440                 /* We got a satisfactory topological sort, so there is no feedback;
2441                    use this new graph.
2442
2443                    Note: the process graph rechain does not require a
2444                    topologically-sorted list, but hey ho.
2445                 */
2446                 if (_process_graph) {
2447                         _process_graph->rechain (sorted_routes, edges);
2448                 }
2449
2450                 _current_route_graph = edges;
2451
2452                 /* Complete the building of the routes' lists of what directly
2453                    or indirectly feeds them.
2454                 */
2455                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2456                         trace_terminal (*i, *i);
2457                 }
2458
2459                 *r = *sorted_routes;
2460
2461 #ifndef NDEBUG
2462                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2463                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2464                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2465                 }
2466 #endif
2467
2468                 SuccessfulGraphSort (); /* EMIT SIGNAL */
2469
2470         } else {
2471                 /* The topological sort failed, so we have a problem.  Tell everyone
2472                    and stick to the old graph; this will continue to be processed, so
2473                    until the feedback is fixed, what is played back will not quite
2474                    reflect what is actually connected.  Note also that we do not
2475                    do trace_terminal here, as it would fail due to an endless recursion,
2476                    so the solo code will think that everything is still connected
2477                    as it was before.
2478                 */
2479
2480                 FeedbackDetected (); /* EMIT SIGNAL */
2481         }
2482
2483 }
2484
2485 /** Find a route name starting with \a base, maybe followed by the
2486  *  lowest \a id.  \a id will always be added if \a definitely_add_number
2487  *  is true on entry; otherwise it will only be added if required
2488  *  to make the name unique.
2489  *
2490  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2491  *  The available route name with the lowest ID will be used, and \a id
2492  *  will be set to the ID.
2493  *
2494  *  \return false if a route name could not be found, and \a track_name
2495  *  and \a id do not reflect a free route name.
2496  */
2497 bool
2498 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2499 {
2500         /* the base may conflict with ports that do not belong to existing
2501            routes, but hidden objects like the click track. So check port names
2502            before anything else.
2503         */
2504
2505         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2506                 if (base == reserved->first) {
2507                         /* Check if this reserved name already exists, and if
2508                            so, disallow it without a numeric suffix.
2509                         */
2510                         if (!reserved->second || route_by_name (reserved->first)) {
2511                                 definitely_add_number = true;
2512                                 if (id < 1) {
2513                                         id = 1;
2514                                 }
2515                         }
2516                         break;
2517                 }
2518         }
2519
2520         /* if we have "base 1" already, it doesn't make sense to add "base"
2521          * if "base 1" has been deleted, adding "base" is no worse than "base 1"
2522          */
2523         if (!definitely_add_number && route_by_name (base) == 0 && (route_by_name (string_compose("%1 1", base)) == 0)) {
2524                 /* just use the base */
2525                 name = base;
2526                 return true;
2527         }
2528
2529         do {
2530                 name = string_compose ("%1 %2", base, id);
2531
2532                 if (route_by_name (name) == 0) {
2533                         return true;
2534                 }
2535
2536                 ++id;
2537
2538         } while (id < (UINT_MAX-1));
2539
2540         return false;
2541 }
2542
2543 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2544 void
2545 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2546 {
2547         in  = ChanCount::ZERO;
2548         out = ChanCount::ZERO;
2549
2550         boost::shared_ptr<RouteList> r = routes.reader ();
2551
2552         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2553                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2554                 if (!tr) {
2555                         continue;
2556                 }
2557                 assert (!tr->is_auditioner()); // XXX remove me
2558                 in  += tr->n_inputs();
2559                 out += tr->n_outputs();
2560         }
2561 }
2562
2563 string
2564 Session::default_track_name_pattern (DataType t)
2565 {
2566         switch (t) {
2567         case DataType::AUDIO:
2568                 if (Profile->get_trx()) {
2569                         return _("Track ");
2570                 } else {
2571                         return _("Audio ");
2572                 }
2573                 break;
2574
2575         case DataType::MIDI:
2576                 return _("MIDI ");
2577         }
2578
2579         return "";
2580 }
2581
2582 /** Caller must not hold process lock
2583  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
2584  *  @param instrument plugin info for the instrument to insert pre-fader, if any
2585  */
2586 list<boost::shared_ptr<MidiTrack> >
2587 Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool strict_io,
2588                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2589                          RouteGroup* route_group, uint32_t how_many,
2590                          string name_template, PresentationInfo::order_t order,
2591                          TrackMode mode)
2592 {
2593         string track_name;
2594         uint32_t track_id = 0;
2595         string port;
2596         RouteList new_routes;
2597         list<boost::shared_ptr<MidiTrack> > ret;
2598
2599         const string name_pattern = default_track_name_pattern (DataType::MIDI);
2600         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2601
2602         while (how_many) {
2603                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2604                         error << "cannot find name for new midi track" << endmsg;
2605                         goto failed;
2606                 }
2607
2608                 boost::shared_ptr<MidiTrack> track;
2609
2610                 try {
2611                         track.reset (new MidiTrack (*this, track_name, mode));
2612
2613                         if (track->init ()) {
2614                                 goto failed;
2615                         }
2616
2617                         if (strict_io) {
2618                                 track->set_strict_io (true);
2619                         }
2620
2621                         BOOST_MARK_TRACK (track);
2622
2623                         {
2624                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2625                                 if (track->input()->ensure_io (input, false, this)) {
2626                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2627                                         goto failed;
2628                                 }
2629
2630                                 if (track->output()->ensure_io (output, false, this)) {
2631                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2632                                         goto failed;
2633                                 }
2634                         }
2635
2636                         if (route_group) {
2637                                 route_group->add (track);
2638                         }
2639
2640                         new_routes.push_back (track);
2641                         ret.push_back (track);
2642                 }
2643
2644                 catch (failed_constructor &err) {
2645                         error << _("Session: could not create new midi track.") << endmsg;
2646                         goto failed;
2647                 }
2648
2649                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2650
2651                         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;
2652                         goto failed;
2653                 }
2654
2655                 --how_many;
2656         }
2657
2658   failed:
2659         if (!new_routes.empty()) {
2660                 StateProtector sp (this);
2661                 if (Profile->get_trx()) {
2662                         add_routes (new_routes, false, false, false, order);
2663                 } else {
2664                         add_routes (new_routes, true, true, false, order);
2665                 }
2666
2667                 if (instrument) {
2668                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2669                                 PluginPtr plugin = instrument->load (*this);
2670                                 if (!plugin) {
2671                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2672                                         continue;
2673                                 }
2674                                 if (pset) {
2675                                         plugin->load_preset (*pset);
2676                                 }
2677                                 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2678                                 if (strict_io) {
2679                                         pi->set_strict_io (true);
2680                                 }
2681
2682                                 (*r)->add_processor (pi, PreFader);
2683
2684                                 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2685                                         (*r)->move_instrument_down (false);
2686                                 }
2687                         }
2688                 }
2689         }
2690
2691         return ret;
2692 }
2693
2694 RouteList
2695 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, bool strict_io,
2696                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2697                          PresentationInfo::Flag flag, PresentationInfo::order_t order)
2698 {
2699         string bus_name;
2700         uint32_t bus_id = 0;
2701         string port;
2702         RouteList ret;
2703
2704         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2705
2706         while (how_many) {
2707                 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2708                         error << "cannot find name for new midi bus" << endmsg;
2709                         goto failure;
2710                 }
2711
2712                 try {
2713                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2714
2715                         if (bus->init ()) {
2716                                 goto failure;
2717                         }
2718
2719                         if (strict_io) {
2720                                 bus->set_strict_io (true);
2721                         }
2722
2723                         BOOST_MARK_ROUTE(bus);
2724
2725                         {
2726                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2727
2728                                 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2729                                         error << _("cannot configure new midi bus input") << endmsg;
2730                                         goto failure;
2731                                 }
2732
2733
2734                                 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2735                                         error << _("cannot configure new midi bus output") << endmsg;
2736                                         goto failure;
2737                                 }
2738                         }
2739
2740                         if (route_group) {
2741                                 route_group->add (bus);
2742                         }
2743
2744                         bus->add_internal_return ();
2745                         ret.push_back (bus);
2746                 }
2747
2748                 catch (failed_constructor &err) {
2749                         error << _("Session: could not create new audio route.") << endmsg;
2750                         goto failure;
2751                 }
2752
2753                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2754                         error << pfe.what() << endmsg;
2755                         goto failure;
2756                 }
2757
2758
2759                 --how_many;
2760         }
2761
2762   failure:
2763         if (!ret.empty()) {
2764                 StateProtector sp (this);
2765                 add_routes (ret, false, false, false, order);
2766
2767                 if (instrument) {
2768                         for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2769                                 PluginPtr plugin = instrument->load (*this);
2770                                 if (!plugin) {
2771                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2772                                         continue;
2773                                 }
2774                                 if (pset) {
2775                                         plugin->load_preset (*pset);
2776                                 }
2777                                 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2778                                 if (strict_io) {
2779                                         pi->set_strict_io (true);
2780                                 }
2781
2782                                 (*r)->add_processor (pi, PreFader);
2783
2784                                 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2785                                         (*r)->move_instrument_down (false);
2786                                 }
2787                         }
2788                 }
2789         }
2790
2791         return ret;
2792
2793 }
2794
2795
2796 void
2797 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2798 {
2799         boost::shared_ptr<Route> midi_track (wmt.lock());
2800
2801         if (!midi_track) {
2802                 return;
2803         }
2804
2805         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2806
2807                 if (change.after.n_audio() <= change.before.n_audio()) {
2808                         return;
2809                 }
2810
2811                 /* new audio ports: make sure the audio goes somewhere useful,
2812                  * unless the user has no-auto-connect selected.
2813                  *
2814                  * The existing ChanCounts don't matter for this call as they are only
2815                  * to do with matching input and output indices, and we are only changing
2816                  * outputs here.
2817                  */
2818                 auto_connect_route (midi_track, false, ChanCount(), change.before);
2819         }
2820 }
2821
2822 #ifdef USE_TRACKS_CODE_FEATURES
2823
2824 static bool
2825 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2826 {
2827         return route1->remote_control_id() < route2->remote_control_id();
2828 }
2829
2830 void
2831 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2832 {
2833         // it is not allowed to perform connection
2834         if (!IO::connecting_legal) {
2835                 return;
2836         }
2837
2838         // if we are deleting routes we will call this once at the end
2839         if (_route_deletion_in_progress) {
2840                 return;
2841         }
2842
2843         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2844
2845         if (withLock) {
2846                 lm.acquire ();
2847         }
2848
2849         // We need to disconnect the route's inputs and outputs first
2850         // basing on autoconnect configuration
2851         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2852         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2853
2854         ChanCount existing_inputs;
2855         ChanCount existing_outputs;
2856         count_existing_track_channels (existing_inputs, existing_outputs);
2857
2858         //ChanCount inputs = ChanCount::ZERO;
2859         //ChanCount outputs = ChanCount::ZERO;
2860
2861         RouteList existing_routes = *routes.reader ();
2862         existing_routes.sort (compare_routes_by_remote_id);
2863
2864         {
2865                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2866
2867                 vector<string> physinputs;
2868                 vector<string> physoutputs;
2869
2870                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2871                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2872
2873                 uint32_t input_n = 0;
2874                 uint32_t output_n = 0;
2875                 RouteList::iterator rIter = existing_routes.begin();
2876                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2877                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2878                 for (; rIter != existing_routes.end(); ++rIter) {
2879                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2880                                 continue;
2881                         }
2882
2883                         if (current_output_auto_connection == AutoConnectPhysical) {
2884                                 (*rIter)->amp()->deactivate();
2885                         } else if (current_output_auto_connection == AutoConnectMaster) {
2886                                 (*rIter)->amp()->activate();
2887                         }
2888
2889                         if (reconnectIputs) {
2890                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2891
2892                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2893
2894                                         if (current_input_auto_connection & AutoConnectPhysical) {
2895
2896                                                 if ( input_n == physinputs.size() ) {
2897                                                         break;
2898                                                 }
2899
2900                                                 string port = physinputs[input_n];
2901
2902                                                 if (port.empty() ) {
2903                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2904                                                 }
2905
2906                                                 //GZ: check this; could be heavy
2907                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2908                                                 ++input_n;
2909                                         }
2910                                 }
2911                         }
2912
2913                         if (reconnectOutputs) {
2914
2915                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2916                                 if (current_output_auto_connection & AutoConnectPhysical) {
2917
2918                                         //GZ: check this; could be heavy
2919                                         (*rIter)->output()->disconnect (this);
2920                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2921
2922                                         //GZ: check this; could be heavy
2923                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2924
2925                                 } else if (current_output_auto_connection & AutoConnectMaster){
2926
2927                                         if (!reconnect_master) {
2928                                                 continue;
2929                                         }
2930
2931                                         //GZ: check this; could be heavy
2932                                         (*rIter)->output()->disconnect (this);
2933
2934                                         if (_master_out) {
2935                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2936                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2937                                         } else {
2938                                                 error << error << "Master bus is not available" << endmsg;
2939                                                 break;
2940                                         }
2941                                 }
2942
2943                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2944                                         if (current_output_auto_connection & AutoConnectPhysical) {
2945
2946                                                 if ( output_n == physoutputs.size() ) {
2947                                                         break;
2948                                                 }
2949
2950                                                 string port = physoutputs[output_n];
2951
2952                                                 if (port.empty() ) {
2953                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2954                                                 }
2955
2956                                                 //GZ: check this; could be heavy
2957                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2958                                                 ++output_n;
2959
2960                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2961
2962                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2963                                                         break;
2964                                                 }
2965
2966                                                 // connect to master bus
2967                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2968
2969                                                 if (port.empty() ) {
2970                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2971                                                 }
2972
2973
2974                                                 //GZ: check this; could be heavy
2975                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2976
2977                                         }
2978                                 }
2979                         }
2980                 }
2981
2982                 _master_out->output()->disconnect (this);
2983                 auto_connect_master_bus ();
2984         }
2985
2986         graph_reordered ();
2987
2988         session_routes_reconnected (); /* EMIT SIGNAL */
2989 }
2990
2991 void
2992 Session::reconnect_midi_scene_ports(bool inputs)
2993 {
2994     if (inputs ) {
2995
2996         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2997         if (scene_in_ptr) {
2998             scene_in_ptr->disconnect_all ();
2999
3000             std::vector<EngineStateController::MidiPortState> midi_port_states;
3001             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3002
3003             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3004
3005             for (; state_iter != midi_port_states.end(); ++state_iter) {
3006                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
3007                     scene_in_ptr->connect (state_iter->name);
3008                 }
3009             }
3010         }
3011
3012     } else {
3013
3014         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
3015
3016         if (scene_out_ptr ) {
3017             scene_out_ptr->disconnect_all ();
3018
3019             std::vector<EngineStateController::MidiPortState> midi_port_states;
3020             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
3021
3022             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3023
3024             for (; state_iter != midi_port_states.end(); ++state_iter) {
3025                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
3026                     scene_out_ptr->connect (state_iter->name);
3027                 }
3028             }
3029         }
3030     }
3031 }
3032
3033 void
3034 Session::reconnect_mtc_ports ()
3035 {
3036         boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
3037
3038         if (!mtc_in_ptr) {
3039                 return;
3040         }
3041
3042         mtc_in_ptr->disconnect_all ();
3043
3044         std::vector<EngineStateController::MidiPortState> midi_port_states;
3045         EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3046
3047         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3048
3049         for (; state_iter != midi_port_states.end(); ++state_iter) {
3050                 if (state_iter->available && state_iter->mtc_in) {
3051                         mtc_in_ptr->connect (state_iter->name);
3052                 }
3053         }
3054
3055         if (!_midi_ports->mtc_input_port ()->connected () &&
3056             config.get_external_sync () &&
3057             (Config->get_sync_source () == MTC) ) {
3058                 config.set_external_sync (false);
3059         }
3060
3061         if ( ARDOUR::Profile->get_trx () ) {
3062                 // Tracks need this signal to update timecode_source_dropdown
3063                 MtcOrLtcInputPortChanged (); //emit signal
3064         }
3065 }
3066
3067 void
3068 Session::reconnect_mmc_ports(bool inputs)
3069 {
3070         if (inputs ) { // get all enabled midi input ports
3071
3072                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
3073                 if (mmc_in_ptr) {
3074                         mmc_in_ptr->disconnect_all ();
3075                         std::vector<std::string> enabled_midi_inputs;
3076                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
3077
3078                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
3079
3080                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
3081                                 mmc_in_ptr->connect (*port_iter);
3082                         }
3083
3084                 }
3085         } else { // get all enabled midi output ports
3086
3087                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
3088                 if (mmc_out_ptr ) {
3089                         mmc_out_ptr->disconnect_all ();
3090                         std::vector<std::string> enabled_midi_outputs;
3091                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
3092
3093                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
3094
3095                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
3096                                 mmc_out_ptr->connect (*port_iter);
3097                         }
3098                 }
3099         }
3100 }
3101
3102 #endif
3103
3104 bool
3105 Session::ensure_stripable_sort_order ()
3106 {
3107         StripableList sl;
3108         get_stripables (sl);
3109         sl.sort (Stripable::Sorter ());
3110
3111         bool change = false;
3112         PresentationInfo::order_t order = 0;
3113
3114         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3115                 boost::shared_ptr<Stripable> s (*si);
3116                 assert (!s->is_auditioner ()); // XXX remove me
3117                 if (s->is_monitor ()) {
3118                         continue;
3119                 }
3120                 if (order != s->presentation_info().order()) {
3121                         s->set_presentation_order (order);
3122                         change = true;
3123                 }
3124                 ++order;
3125         }
3126         return change;
3127 }
3128
3129 void
3130 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
3131 {
3132         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", first_new_order, how_many));
3133
3134         if (first_new_order == PresentationInfo::max_order) {
3135                 /* adding at end, no worries */
3136                 return;
3137         }
3138
3139         /* create a gap in the presentation info to accomodate @param how_many
3140          * new objects.
3141          */
3142         StripableList sl;
3143         get_stripables (sl);
3144
3145         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3146                 boost::shared_ptr<Stripable> s (*si);
3147
3148                 if (s->presentation_info().special (false)) {
3149                         continue;
3150                 }
3151
3152                 if (!s->presentation_info().order_set()) {
3153                         continue;
3154                 }
3155
3156                 if (s->presentation_info().order () >= first_new_order) {
3157                         s->set_presentation_order (s->presentation_info().order () + how_many);
3158                 }
3159         }
3160 }
3161
3162 /** Caller must not hold process lock
3163  *  @param name_template string to use for the start of the name, or "" to use "Audio".
3164  */
3165 list< boost::shared_ptr<AudioTrack> >
3166 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
3167                           uint32_t how_many, string name_template, PresentationInfo::order_t order,
3168                           TrackMode mode)
3169 {
3170         string track_name;
3171         uint32_t track_id = 0;
3172         string port;
3173         RouteList new_routes;
3174         list<boost::shared_ptr<AudioTrack> > ret;
3175
3176         const string name_pattern = default_track_name_pattern (DataType::AUDIO);
3177         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
3178
3179         while (how_many) {
3180
3181                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
3182                         error << "cannot find name for new audio track" << endmsg;
3183                         goto failed;
3184                 }
3185
3186                 boost::shared_ptr<AudioTrack> track;
3187
3188                 try {
3189                         track.reset (new AudioTrack (*this, track_name, mode));
3190
3191                         if (track->init ()) {
3192                                 goto failed;
3193                         }
3194
3195                         if (Profile->get_mixbus ()) {
3196                                 track->set_strict_io (true);
3197                         }
3198
3199                         if (ARDOUR::Profile->get_trx ()) {
3200                                 // TRACKS considers it's not a USE CASE, it's
3201                                 // a piece of behavior of the session model:
3202                                 //
3203                                 // Gain for a newly created route depends on
3204                                 // the current output_auto_connect mode:
3205                                 //
3206                                 //  0 for Stereo Out mode
3207                                 //  0 Multi Out mode
3208                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3209                                         track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3210                                 }
3211                         }
3212
3213                         BOOST_MARK_TRACK (track);
3214
3215                         {
3216                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3217
3218                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3219                                         error << string_compose (
3220                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3221                                                 input_channels, output_channels)
3222                                               << endmsg;
3223                                         goto failed;
3224                                 }
3225
3226                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3227                                         error << string_compose (
3228                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3229                                                 input_channels, output_channels)
3230                                               << endmsg;
3231                                         goto failed;
3232                                 }
3233                         }
3234
3235                         if (route_group) {
3236                                 route_group->add (track);
3237                         }
3238
3239                         new_routes.push_back (track);
3240                         ret.push_back (track);
3241                 }
3242
3243                 catch (failed_constructor &err) {
3244                         error << _("Session: could not create new audio track.") << endmsg;
3245                         goto failed;
3246                 }
3247
3248                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3249
3250                         error << pfe.what() << endmsg;
3251                         goto failed;
3252                 }
3253
3254                 --how_many;
3255         }
3256
3257   failed:
3258         if (!new_routes.empty()) {
3259                 StateProtector sp (this);
3260                 if (Profile->get_trx()) {
3261                         add_routes (new_routes, false, false, false, order);
3262                 } else {
3263                         add_routes (new_routes, true, true, false, order);
3264                 }
3265         }
3266
3267         return ret;
3268 }
3269
3270 /** Caller must not hold process lock.
3271  *  @param name_template string to use for the start of the name, or "" to use "Bus".
3272  */
3273 RouteList
3274 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3275                           PresentationInfo::Flag flags, PresentationInfo::order_t order)
3276 {
3277         string bus_name;
3278         uint32_t bus_id = 0;
3279         string port;
3280         RouteList ret;
3281
3282         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3283
3284         while (how_many) {
3285                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3286                         error << "cannot find name for new audio bus" << endmsg;
3287                         goto failure;
3288                 }
3289
3290                 try {
3291                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3292
3293                         if (bus->init ()) {
3294                                 goto failure;
3295                         }
3296
3297                         if (Profile->get_mixbus ()) {
3298                                 bus->set_strict_io (true);
3299                         }
3300
3301                         BOOST_MARK_ROUTE(bus);
3302
3303                         {
3304                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3305
3306                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3307                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3308                                                                  input_channels, output_channels)
3309                                               << endmsg;
3310                                         goto failure;
3311                                 }
3312
3313
3314                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3315                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3316                                                                  input_channels, output_channels)
3317                                               << endmsg;
3318                                         goto failure;
3319                                 }
3320                         }
3321
3322                         if (route_group) {
3323                                 route_group->add (bus);
3324                         }
3325
3326                         bus->add_internal_return ();
3327                         ret.push_back (bus);
3328                 }
3329
3330                 catch (failed_constructor &err) {
3331                         error << _("Session: could not create new audio route.") << endmsg;
3332                         goto failure;
3333                 }
3334
3335                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3336                         error << pfe.what() << endmsg;
3337                         goto failure;
3338                 }
3339
3340
3341                 --how_many;
3342         }
3343
3344   failure:
3345         if (!ret.empty()) {
3346                 StateProtector sp (this);
3347                 if (Profile->get_trx()) {
3348                         add_routes (ret, false, false, false, order);
3349                 } else {
3350                         add_routes (ret, false, true, true, order); // autoconnect // outputs only
3351                 }
3352         }
3353
3354         return ret;
3355
3356 }
3357
3358 RouteList
3359 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3360                                   PlaylistDisposition pd)
3361 {
3362         XMLTree tree;
3363
3364         if (!tree.read (template_path.c_str())) {
3365                 return RouteList();
3366         }
3367
3368         return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3369 }
3370
3371 RouteList
3372 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3373 {
3374         RouteList ret;
3375         uint32_t number = 0;
3376         const uint32_t being_added = how_many;
3377         /* This will prevent the use of any existing XML-provided PBD::ID
3378            values by Stateful.
3379         */
3380         Stateful::ForceIDRegeneration force_ids;
3381         IO::disable_connecting ();
3382
3383         while (how_many) {
3384
3385                 /* We're going to modify the node contents a bit so take a
3386                  * copy. The node may be re-used when duplicating more than once.
3387                  */
3388
3389                 XMLNode node_copy (node);
3390
3391                 try {
3392                         string name;
3393
3394                         if (!name_base.empty()) {
3395
3396                                 /* if we're adding more than one routes, force
3397                                  * all the names of the new routes to be
3398                                  * numbered, via the final parameter.
3399                                  */
3400
3401                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3402                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3403                                         /*NOTREACHDE*/
3404                                 }
3405
3406                         } else {
3407
3408                                 string const route_name  = node_copy.property(X_("name"))->value ();
3409
3410                                 /* generate a new name by adding a number to the end of the template name */
3411                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3412                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3413                                         abort(); /*NOTREACHED*/
3414                                 }
3415                         }
3416
3417                         /* set this name in the XML description that we are about to use */
3418
3419                         if (pd == CopyPlaylist) {
3420                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3421                                 if (ds_node) {
3422                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3423                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3424                                         // Use same name as Route::set_name_in_state so playlist copy
3425                                         // is picked up when creating the Route in XMLRouteFactory below
3426                                         playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3427                                         playlist->reset_shares ();
3428                                 }
3429                         } else if (pd == SharePlaylist) {
3430                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3431                                 if (ds_node) {
3432                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3433                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3434                                         playlist->share_with ((node_copy.property (X_("id")))->value());
3435                                 }
3436                         }
3437
3438                         bool rename_playlist = (pd == CopyPlaylist || pd == NewPlaylist);
3439
3440                         Route::set_name_in_state (node_copy, name, rename_playlist);
3441
3442                         /* trim bitslots from listen sends so that new ones are used */
3443                         XMLNodeList children = node_copy.children ();
3444                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3445                                 if ((*i)->name() == X_("Processor")) {
3446                                         /* ForceIDRegeneration does not catch the following */
3447                                         XMLProperty const * role = (*i)->property (X_("role"));
3448                                         XMLProperty const * type = (*i)->property (X_("type"));
3449                                         if (role && role->value() == X_("Aux")) {
3450                                                 /* check if the target bus exists.
3451                                                  * we should not save aux-sends in templates.
3452                                                  */
3453                                                 XMLProperty const * target = (*i)->property (X_("target"));
3454                                                 if (!target) {
3455                                                         (*i)->set_property ("type", "dangling-aux-send");
3456                                                         continue;
3457                                                 }
3458                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3459                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3460                                                         (*i)->set_property ("type", "dangling-aux-send");
3461                                                         continue;
3462                                                 }
3463                                         }
3464                                         if (role && role->value() == X_("Listen")) {
3465                                                 (*i)->remove_property (X_("bitslot"));
3466                                         }
3467                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3468                                                 Delivery::Role xrole;
3469                                                 uint32_t bitslot = 0;
3470                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3471                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3472                                                 (*i)->remove_property (X_("bitslot"));
3473                                                 (*i)->remove_property (X_("name"));
3474                                                 (*i)->set_property ("bitslot", bitslot);
3475                                                 (*i)->set_property ("name", name);
3476                                         }
3477                                         else if (type && type->value() == X_("intreturn")) {
3478                                                 (*i)->remove_property (X_("bitslot"));
3479                                                 (*i)->set_property ("ignore-bitslot", "1");
3480                                         }
3481                                         else if (type && type->value() == X_("return")) {
3482                                                 // Return::set_state() generates a new one
3483                                                 (*i)->remove_property (X_("bitslot"));
3484                                         }
3485                                         else if (type && type->value() == X_("port")) {
3486                                                 // PortInsert::set_state() handles the bitslot
3487                                                 (*i)->remove_property (X_("bitslot"));
3488                                                 (*i)->set_property ("ignore-name", "1");
3489                                         }
3490                                 }
3491                         }
3492
3493                         /* new routes start off unsoloed to avoid issues related to
3494                            upstream / downstream buses. */
3495                         node_copy.remove_node_and_delete (X_("Controllable"), X_("name"), X_("solo"));
3496
3497                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3498
3499                         if (route == 0) {
3500                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3501                                 goto out;
3502                         }
3503
3504                         if (boost::dynamic_pointer_cast<Track>(route)) {
3505                                 /* force input/output change signals so that the new diskstream
3506                                    picks up the configuration of the route. During session
3507                                    loading this normally happens in a different way.
3508                                 */
3509
3510                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3511
3512                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3513                                 change.after = route->input()->n_ports();
3514                                 route->input()->changed (change, this);
3515                                 change.after = route->output()->n_ports();
3516                                 route->output()->changed (change, this);
3517                         }
3518
3519                         ret.push_back (route);
3520                 }
3521
3522                 catch (failed_constructor &err) {
3523                         error << _("Session: could not create new route from template") << endmsg;
3524                         goto out;
3525                 }
3526
3527                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3528                         error << pfe.what() << endmsg;
3529                         goto out;
3530                 }
3531
3532                 --how_many;
3533         }
3534
3535   out:
3536         if (!ret.empty()) {
3537                 StateProtector sp (this);
3538                 if (Profile->get_trx()) {
3539                         add_routes (ret, false, false, false, insert_at);
3540                 } else {
3541                         add_routes (ret, true, true, false, insert_at);
3542                 }
3543                 IO::enable_connecting ();
3544         }
3545
3546         return ret;
3547 }
3548
3549 void
3550 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3551 {
3552         try {
3553                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3554                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3555
3556         } catch (...) {
3557                 error << _("Adding new tracks/busses failed") << endmsg;
3558         }
3559
3560         graph_reordered ();
3561
3562         update_latency (false);
3563         update_latency (true);
3564
3565         set_dirty();
3566
3567         if (save) {
3568                 save_state (_current_snapshot_name);
3569         }
3570
3571         update_route_record_state ();
3572
3573         RouteAdded (new_routes); /* EMIT SIGNAL */
3574 }
3575
3576 void
3577 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3578 {
3579         ChanCount existing_inputs;
3580         ChanCount existing_outputs;
3581         uint32_t n_routes;
3582         uint32_t added = 0;
3583
3584         count_existing_track_channels (existing_inputs, existing_outputs);
3585
3586         {
3587                 RCUWriter<RouteList> writer (routes);
3588                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3589                 n_routes = r->size();
3590                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3591
3592                 /* if there is no control out and we're not in the middle of loading,
3593                  * resort the graph here. if there is a control out, we will resort
3594                  * toward the end of this method. if we are in the middle of loading,
3595                  * we will resort when done.
3596                  */
3597
3598                 if (!_monitor_out && IO::connecting_legal) {
3599                         resort_routes_using (r);
3600                 }
3601         }
3602
3603         /* monitor is not part of the order */
3604         if (_monitor_out) {
3605                 assert (n_routes > 0);
3606                 --n_routes;
3607         }
3608
3609         {
3610                 PresentationInfo::ChangeSuspender cs;
3611                 ensure_route_presentation_info_gap (order, new_routes.size());
3612
3613                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3614
3615                         boost::weak_ptr<Route> wpr (*x);
3616                         boost::shared_ptr<Route> r (*x);
3617
3618                         r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3619                         r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3620                         r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3621
3622                         r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3623                         r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3624                         r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3625
3626                         if (r->is_master()) {
3627                                 _master_out = r;
3628                         }
3629
3630                         if (r->is_monitor()) {
3631                                 _monitor_out = r;
3632                         }
3633
3634                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3635                         if (tr) {
3636                                 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3637                                 track_playlist_changed (boost::weak_ptr<Track> (tr));
3638                                 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3639
3640                                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3641                                 if (mt) {
3642                                         mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3643                                         mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3644                                         mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3645                                 }
3646                         }
3647
3648                         if (!r->presentation_info().special (false)) {
3649
3650                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3651
3652                                 /* presentation info order may already have been set from XML */
3653
3654                                 if (!r->presentation_info().order_set()) {
3655                                         if (order == PresentationInfo::max_order) {
3656                                                 /* just add to the end */
3657                                                 r->set_presentation_order (n_routes + added);
3658                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3659                                         } else {
3660                                                 r->set_presentation_order (order + added);
3661                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3662                                         }
3663                                 } else {
3664                                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3665                                 }
3666                         }
3667
3668 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3669                         /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3670                          * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3671                          */
3672                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3673                                                                        r->name(),
3674                                                                        r->presentation_info().order(),
3675                                                                        enum_2_string (r->presentation_info().flags()),
3676                                                                        r->presentation_info()));
3677 #endif
3678
3679
3680                         if (input_auto_connect || output_auto_connect) {
3681                                 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3682                                 existing_inputs += r->n_inputs();
3683                                 existing_outputs += r->n_outputs();
3684                         }
3685
3686                         ARDOUR::GUIIdle ();
3687                 }
3688                 ensure_stripable_sort_order ();
3689         }
3690
3691         if (_monitor_out && IO::connecting_legal) {
3692                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3693
3694                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3695                         if ((*x)->is_monitor()) {
3696                                 /* relax */
3697                         } else if ((*x)->is_master()) {
3698                                 /* relax */
3699                         } else {
3700                                 (*x)->enable_monitor_send ();
3701                         }
3702                 }
3703         }
3704
3705         reassign_track_numbers ();
3706 }
3707
3708 void
3709 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3710 {
3711         boost::shared_ptr<RouteList> r = routes.reader ();
3712         boost::shared_ptr<Send> s;
3713
3714         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3715                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3716                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3717                 }
3718         }
3719 }
3720
3721 void
3722 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3723 {
3724         boost::shared_ptr<RouteList> r = routes.reader ();
3725         boost::shared_ptr<Send> s;
3726
3727         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3728                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3729                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3730                 }
3731         }
3732 }
3733
3734 void
3735 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3736 {
3737         boost::shared_ptr<RouteList> r = routes.reader ();
3738         boost::shared_ptr<Send> s;
3739
3740         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3741                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3742                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3743                 }
3744         }
3745 }
3746
3747 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3748 void
3749 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3750 {
3751         boost::shared_ptr<RouteList> r = routes.reader ();
3752         boost::shared_ptr<RouteList> t (new RouteList);
3753
3754         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3755                 /* no MIDI sends because there are no MIDI busses yet */
3756                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3757                         t->push_back (*i);
3758                 }
3759         }
3760
3761         add_internal_sends (dest, p, t);
3762 }
3763
3764 void
3765 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3766 {
3767         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3768                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3769         }
3770 }
3771
3772 void
3773 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3774 {
3775         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3776 }
3777
3778 void
3779 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3780 {
3781         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3782                 return;
3783         }
3784
3785         if (!dest->internal_return()) {
3786                 dest->add_internal_return ();
3787         }
3788
3789         sender->add_aux_send (dest, before);
3790
3791         graph_reordered ();
3792 }
3793
3794 void
3795 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3796 {
3797         bool mute_changed = false;
3798         bool send_selected = false;
3799
3800         { // RCU Writer scope
3801                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3802                 RCUWriter<RouteList> writer (routes);
3803                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3804
3805                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3806
3807                         if (_selection->selected (*iter)) {
3808                                 send_selected = true;
3809                         }
3810
3811                         if (*iter == _master_out) {
3812                                 continue;
3813                         }
3814
3815                         /* speed up session deletion, don't do the solo dance */
3816                         if (0 == (_state_of_the_state & Deletion)) {
3817                                 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3818                         }
3819
3820                         if ((*iter)->mute_control()->muted ()) {
3821                                 mute_changed = true;
3822                         }
3823
3824                         rs->remove (*iter);
3825
3826                         /* deleting the master out seems like a dumb
3827                            idea, but its more of a UI policy issue
3828                            than our concern.
3829                         */
3830
3831                         if (*iter == _master_out) {
3832                                 _master_out = boost::shared_ptr<Route> ();
3833                         }
3834
3835                         if (*iter == _monitor_out) {
3836                                 _monitor_out.reset ();
3837                         }
3838
3839                         // We need to disconnect the route's inputs and outputs
3840
3841                         (*iter)->input()->disconnect (0);
3842                         (*iter)->output()->disconnect (0);
3843
3844                         /* if the route had internal sends sending to it, remove them */
3845                         if ((*iter)->internal_return()) {
3846
3847                                 boost::shared_ptr<RouteList> r = routes.reader ();
3848                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3849                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3850                                         if (s) {
3851                                                 (*i)->remove_processor (s);
3852                                         }
3853                                 }
3854                         }
3855
3856                         /* if the monitoring section had a pointer to this route, remove it */
3857                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3858                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3859                                 ProcessorChangeBlocker pcb (this, false);
3860                                 (*iter)->remove_aux_or_listen (_monitor_out);
3861                         }
3862
3863                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3864                         if (mt && mt->step_editing()) {
3865                                 if (_step_editors > 0) {
3866                                         _step_editors--;
3867                                 }
3868                         }
3869                 }
3870
3871                 /* writer goes out of scope, forces route list update */
3872
3873         } // end of RCU Writer scope
3874
3875         if (mute_changed) {
3876                 MuteChanged (); /* EMIT SIGNAL */
3877         }
3878
3879         update_route_solo_state ();
3880         update_latency_compensation ();
3881         set_dirty();
3882
3883         /* Re-sort routes to remove the graph's current references to the one that is
3884          * going away, then flush old references out of the graph.
3885          * Wave Tracks: reconnect routes
3886          */
3887
3888 #ifdef USE_TRACKS_CODE_FEATURES
3889                 reconnect_existing_routes(true, false);
3890 #else
3891                 routes.flush (); // maybe unsafe, see below.
3892                 resort_routes ();
3893 #endif
3894
3895         if (_process_graph && !(_state_of_the_state & Deletion)) {
3896                 _process_graph->clear_other_chain ();
3897         }
3898
3899         /* get rid of it from the dead wood collection in the route list manager */
3900         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3901
3902         routes.flush ();
3903
3904         /* remove these routes from the selection if appropriate, and signal
3905          * the change *before* we call DropReferences for them.
3906          */
3907
3908         if (send_selected && !deletion_in_progress()) {
3909                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3910                         _selection->remove_stripable_by_id ((*iter)->id());
3911                 }
3912                 PropertyChange pc;
3913                 pc.add (Properties::selected);
3914                 PresentationInfo::Change (pc);
3915         }
3916
3917         /* try to cause everyone to drop their references
3918          * and unregister ports from the backend
3919          */
3920
3921         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3922                 (*iter)->drop_references ();
3923         }
3924
3925         if (deletion_in_progress()) {
3926                 return;
3927         }
3928
3929         PropertyChange pc;
3930         pc.add (Properties::order);
3931         PresentationInfo::Change (pc);
3932
3933         /* save the new state of the world */
3934
3935         if (save_state (_current_snapshot_name)) {
3936                 save_history (_current_snapshot_name);
3937         }
3938
3939         update_route_record_state ();
3940 }
3941
3942 void
3943 Session::remove_route (boost::shared_ptr<Route> route)
3944 {
3945         boost::shared_ptr<RouteList> rl (new RouteList);
3946         rl->push_back (route);
3947         remove_routes (rl);
3948 }
3949
3950 void
3951 Session::route_mute_changed ()
3952 {
3953         MuteChanged (); /* EMIT SIGNAL */
3954         set_dirty ();
3955 }
3956
3957 void
3958 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3959 {
3960         boost::shared_ptr<Route> route (wpr.lock());
3961
3962         if (!route) {
3963                 return;
3964         }
3965
3966         assert (Config->get_solo_control_is_listen_control());
3967
3968         if (route->solo_control()->soloed_by_self_or_masters()) {
3969
3970                 if (Config->get_exclusive_solo()) {
3971
3972                         RouteGroup* rg = route->route_group ();
3973                         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3974
3975                         boost::shared_ptr<RouteList> r = routes.reader ();
3976
3977                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3978                                 if ((*i) == route) {
3979                                         /* already changed */
3980                                         continue;
3981                                 }
3982
3983                                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3984                                         /* route does not get solo propagated to it */
3985                                         continue;
3986                                 }
3987
3988                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3989                                         /* this route is a part of the same solo group as the route
3990                                          * that was changed. Changing that route did change or will
3991                                          * change all group members appropriately, so we can ignore it
3992                                          * here
3993                                          */
3994                                         continue;
3995                                 }
3996                                 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3997                         }
3998                 }
3999
4000                 _listen_cnt++;
4001
4002         } else if (_listen_cnt > 0) {
4003
4004                 _listen_cnt--;
4005         }
4006 }
4007
4008 void
4009 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
4010 {
4011         boost::shared_ptr<Route> route (wpr.lock());
4012
4013         if (!route) {
4014                 return;
4015         }
4016
4017         bool send_changed = false;
4018
4019         if (route->solo_isolate_control()->solo_isolated()) {
4020                 if (_solo_isolated_cnt == 0) {
4021                         send_changed = true;
4022                 }
4023                 _solo_isolated_cnt++;
4024         } else if (_solo_isolated_cnt > 0) {
4025                 _solo_isolated_cnt--;
4026                 if (_solo_isolated_cnt == 0) {
4027                         send_changed = true;
4028                 }
4029         }
4030
4031         if (send_changed) {
4032                 IsolatedChanged (); /* EMIT SIGNAL */
4033         }
4034 }
4035
4036 void
4037 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
4038 {
4039         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
4040
4041         boost::shared_ptr<Route> route (wpr.lock());
4042
4043         if (!route) {
4044                 return;
4045         }
4046
4047         if (Config->get_solo_control_is_listen_control()) {
4048                 route_listen_changed (group_override, wpr);
4049                 return;
4050         }
4051
4052         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()));
4053
4054         if (route->solo_control()->transitioned_into_solo() == 0) {
4055                 /* route solo changed by upstream/downstream or clear all solo state; not interesting
4056                    to Session.
4057                 */
4058                 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()));
4059                 return;
4060         }
4061
4062         boost::shared_ptr<RouteList> r = routes.reader ();
4063         int32_t delta = route->solo_control()->transitioned_into_solo ();
4064
4065         /* the route may be a member of a group that has shared-solo
4066          * semantics. If so, then all members of that group should follow the
4067          * solo of the changed route. But ... this is optional, controlled by a
4068          * Controllable::GroupControlDisposition.
4069          *
4070          * The first argument to the signal that this method is connected to is the
4071          * GroupControlDisposition value that was used to change solo.
4072          *
4073          * If the solo change was done with group semantics (either InverseGroup
4074          * (force the entire group to change even if the group shared solo is
4075          * disabled) or UseGroup (use the group, which may or may not have the
4076          * shared solo property enabled)) then as we propagate the change to
4077          * the entire session we should IGNORE THE GROUP that the changed route
4078          * belongs to.
4079          */
4080
4081         RouteGroup* rg = route->route_group ();
4082         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
4083
4084         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
4085
4086         if (delta == 1 && Config->get_exclusive_solo()) {
4087
4088                 /* new solo: disable all other solos, but not the group if its solo-enabled */
4089
4090                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4091
4092                         if ((*i) == route) {
4093                                 /* already changed */
4094                                 continue;
4095                         }
4096
4097                         if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4098                                 /* route does not get solo propagated to it */
4099                                 continue;
4100                         }
4101
4102                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4103                                 /* this route is a part of the same solo group as the route
4104                                  * that was changed. Changing that route did change or will
4105                                  * change all group members appropriately, so we can ignore it
4106                                  * here
4107                                  */
4108                                 continue;
4109                         }
4110
4111                         (*i)->solo_control()->set_value (0.0, group_override);
4112                 }
4113         }
4114
4115         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4116
4117         RouteList uninvolved;
4118
4119         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4120
4121         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4122                 bool via_sends_only;
4123                 bool in_signal_flow;
4124
4125                 if ((*i) == route) {
4126                         /* already changed */
4127                         continue;
4128                 }
4129
4130                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4131                         /* route does not get solo propagated to it */
4132                         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(),
4133                                                                   (*i)->can_solo()));
4134                         continue;
4135                 }
4136
4137                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4138                         /* this route is a part of the same solo group as the route
4139                          * that was changed. Changing that route did change or will
4140                          * change all group members appropriately, so we can ignore it
4141                          * here
4142                          */
4143                         continue;
4144                 }
4145
4146                 in_signal_flow = false;
4147
4148                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4149
4150                 if ((*i)->feeds (route, &via_sends_only)) {
4151                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4152                         if (!via_sends_only) {
4153                                 if (!route->soloed_by_others_upstream()) {
4154                                         (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4155                                 } else {
4156                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4157                                 }
4158                         } else {
4159                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4160                         }
4161                         in_signal_flow = true;
4162                 } else {
4163                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4164                 }
4165
4166                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4167
4168                 if (route->feeds (*i, &via_sends_only)) {
4169                         /* propagate solo upstream only if routing other than
4170                            sends is involved, but do consider the other route
4171                            (*i) to be part of the signal flow even if only
4172                            sends are involved.
4173                         */
4174                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4175                                                                   route->name(),
4176                                                                   (*i)->name(),
4177                                                                   via_sends_only,
4178                                                                   route->soloed_by_others_downstream(),
4179                                                                   route->soloed_by_others_upstream()));
4180                         if (!via_sends_only) {
4181                                 //NB. Triggers Invert Push, which handles soloed by downstream
4182                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4183                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4184                         } else {
4185                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4186                         }
4187                         in_signal_flow = true;
4188                 } else {
4189                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
4190                 }
4191
4192                 if (!in_signal_flow) {
4193                         uninvolved.push_back (*i);
4194                 }
4195         }
4196
4197         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4198
4199         /* now notify that the mute state of the routes not involved in the signal
4200            pathway of the just-solo-changed route may have altered.
4201         */
4202
4203         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4204                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4205                 (*i)->act_on_mute ();
4206                 /* Session will emit SoloChanged() after all solo changes are
4207                  * complete, which should be used by UIs to update mute status
4208                  */
4209         }
4210 }
4211
4212 void
4213 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4214 {
4215         /* now figure out if anything that matters is soloed (or is "listening")*/
4216
4217         bool something_soloed = false;
4218         bool something_listening = false;
4219         uint32_t listeners = 0;
4220         uint32_t isolated = 0;
4221
4222         if (!r) {
4223                 r = routes.reader();
4224         }
4225
4226         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4227                 if ((*i)->can_solo()) {
4228                         if (Config->get_solo_control_is_listen_control()) {
4229                                 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4230                                         listeners++;
4231                                         something_listening = true;
4232                                 }
4233                         } else {
4234                                 (*i)->set_listen (false);
4235                                 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4236                                         something_soloed = true;
4237                                 }
4238                         }
4239                 }
4240
4241                 if ((*i)->solo_isolate_control()->solo_isolated()) {
4242                         isolated++;
4243                 }
4244         }
4245
4246         if (something_soloed != _non_soloed_outs_muted) {
4247                 _non_soloed_outs_muted = something_soloed;
4248                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4249         }
4250
4251         if (something_listening != _listening) {
4252                 _listening = something_listening;
4253                 SoloActive (_listening);
4254         }
4255
4256         _listen_cnt = listeners;
4257
4258         if (isolated != _solo_isolated_cnt) {
4259                 _solo_isolated_cnt = isolated;
4260                 IsolatedChanged (); /* EMIT SIGNAL */
4261         }
4262
4263         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4264                                                   something_soloed, listeners, isolated));
4265
4266
4267         SoloChanged (); /* EMIT SIGNAL */
4268         set_dirty();
4269 }
4270
4271 bool
4272 Session::muted () const
4273 {
4274         // TODO consider caching the value on every MuteChanged signal,
4275         // Note that API users may also subscribe to MuteChanged and hence
4276         // this method needs to be called first.
4277         bool muted = false;
4278         StripableList all;
4279         get_stripables (all);
4280         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4281                 assert (!(*i)->is_auditioner()); // XXX remove me
4282                 if ((*i)->is_monitor()) {
4283                         continue;
4284                 }
4285                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route>(*i);
4286                 if (r && !r->active()) {
4287                         continue;
4288                 }
4289                 boost::shared_ptr<MuteControl> mc = (*i)->mute_control();
4290                 if (mc && mc->muted ()) {
4291                         muted = true;
4292                         break;
4293                 }
4294         }
4295         return muted;
4296 }
4297
4298 std::vector<boost::weak_ptr<AutomationControl> >
4299 Session::cancel_all_mute ()
4300 {
4301         StripableList all;
4302         get_stripables (all);
4303         std::vector<boost::weak_ptr<AutomationControl> > muted;
4304         boost::shared_ptr<ControlList> cl (new ControlList);
4305         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4306                 assert (!(*i)->is_auditioner());
4307                 if ((*i)->is_monitor()) {
4308                         continue;
4309                 }
4310                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (*i);
4311                 if (r && !r->active()) {
4312                         continue;
4313                 }
4314                 boost::shared_ptr<AutomationControl> ac = (*i)->mute_control();
4315                 if (ac && ac->get_value () > 0) {
4316                         cl->push_back (ac);
4317                         muted.push_back (boost::weak_ptr<AutomationControl>(ac));
4318                 }
4319         }
4320         if (!cl->empty ()) {
4321                 set_controls (cl, 0.0, PBD::Controllable::UseGroup);
4322         }
4323         return muted;
4324 }
4325
4326 void
4327 Session::get_stripables (StripableList& sl) const
4328 {
4329         boost::shared_ptr<RouteList> r = routes.reader ();
4330         sl.insert (sl.end(), r->begin(), r->end());
4331
4332         VCAList v = _vca_manager->vcas ();
4333         sl.insert (sl.end(), v.begin(), v.end());
4334 }
4335
4336 StripableList
4337 Session::get_stripables () const
4338 {
4339         StripableList rv;
4340         Session::get_stripables (rv);
4341         rv.sort (Stripable::Sorter ());
4342         return rv;
4343 }
4344
4345 boost::shared_ptr<RouteList>
4346 Session::get_routes_with_internal_returns() const
4347 {
4348         boost::shared_ptr<RouteList> r = routes.reader ();
4349         boost::shared_ptr<RouteList> rl (new RouteList);
4350
4351         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4352                 if ((*i)->internal_return ()) {
4353                         rl->push_back (*i);
4354                 }
4355         }
4356         return rl;
4357 }
4358
4359 bool
4360 Session::io_name_is_legal (const std::string& name) const
4361 {
4362         boost::shared_ptr<RouteList> r = routes.reader ();
4363
4364         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4365                 if (name == reserved->first) {
4366                         if (!route_by_name (reserved->first)) {
4367                                 /* first instance of a reserved name is allowed for some */
4368                                 return reserved->second;
4369                         }
4370                         /* all other instances of a reserved name are not allowed */
4371                         return false;
4372                 }
4373         }
4374
4375         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4376                 if ((*i)->name() == name) {
4377                         return false;
4378                 }
4379
4380                 if ((*i)->has_io_processor_named (name)) {
4381                         return false;
4382                 }
4383         }
4384
4385         return true;
4386 }
4387
4388 void
4389 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4390 {
4391         RouteList rl2;
4392         vector<string> connections;
4393
4394         /* if we are passed only a single route and we're not told to turn
4395          * others off, then just do the simple thing.
4396          */
4397
4398         if (flip_others == false && rl->size() == 1) {
4399                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4400                 if (mt) {
4401                         mt->set_input_active (onoff);
4402                         return;
4403                 }
4404         }
4405
4406         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4407
4408                 PortSet& ps ((*rt)->input()->ports());
4409
4410                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4411                         p->get_connections (connections);
4412                 }
4413
4414                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4415                         routes_using_input_from (*s, rl2);
4416                 }
4417
4418                 /* scan all relevant routes to see if others are on or off */
4419
4420                 bool others_are_already_on = false;
4421
4422                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4423
4424                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4425
4426                         if (!mt) {
4427                                 continue;
4428                         }
4429
4430                         if ((*r) != (*rt)) {
4431                                 if (mt->input_active()) {
4432                                         others_are_already_on = true;
4433                                 }
4434                         } else {
4435                                 /* this one needs changing */
4436                                 mt->set_input_active (onoff);
4437                         }
4438                 }
4439
4440                 if (flip_others) {
4441
4442                         /* globally reverse other routes */
4443
4444                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4445                                 if ((*r) != (*rt)) {
4446                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4447                                         if (mt) {
4448                                                 mt->set_input_active (!others_are_already_on);
4449                                         }
4450                                 }
4451                         }
4452                 }
4453         }
4454 }
4455
4456 void
4457 Session::routes_using_input_from (const string& str, RouteList& rl)
4458 {
4459         boost::shared_ptr<RouteList> r = routes.reader();
4460
4461         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4462                 if ((*i)->input()->connected_to (str)) {
4463                         rl.push_back (*i);
4464                 }
4465         }
4466 }
4467
4468 boost::shared_ptr<Route>
4469 Session::route_by_name (string name) const
4470 {
4471         boost::shared_ptr<RouteList> r = routes.reader ();
4472
4473         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4474                 if ((*i)->name() == name) {
4475                         return *i;
4476                 }
4477         }
4478
4479         return boost::shared_ptr<Route> ((Route*) 0);
4480 }
4481
4482 boost::shared_ptr<Route>
4483 Session::route_by_id (PBD::ID id) const
4484 {
4485         boost::shared_ptr<RouteList> r = routes.reader ();
4486
4487         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4488                 if ((*i)->id() == id) {
4489                         return *i;
4490                 }
4491         }
4492
4493         return boost::shared_ptr<Route> ((Route*) 0);
4494 }
4495
4496
4497 boost::shared_ptr<Stripable>
4498 Session::stripable_by_id (PBD::ID id) const
4499 {
4500         StripableList sl;
4501         get_stripables (sl);
4502
4503         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4504                 if ((*s)->id() == id) {
4505                         return *s;
4506                 }
4507         }
4508
4509         return boost::shared_ptr<Stripable>();
4510 }
4511
4512 boost::shared_ptr<Processor>
4513 Session::processor_by_id (PBD::ID id) const
4514 {
4515         boost::shared_ptr<RouteList> r = routes.reader ();
4516
4517         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4518                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4519                 if (p) {
4520                         return p;
4521                 }
4522         }
4523
4524         return boost::shared_ptr<Processor> ();
4525 }
4526
4527 boost::shared_ptr<Route>
4528 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4529 {
4530         return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4531 }
4532
4533 boost::shared_ptr<Stripable>
4534 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4535 {
4536         StripableList sl;
4537         PresentationInfo::order_t match_cnt = 0;
4538
4539         get_stripables (sl);
4540         sl.sort (Stripable::Sorter());
4541
4542         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4543
4544                 if ((*s)->presentation_info().hidden()) {
4545                         /* if the caller didn't explicitly ask for hidden
4546                            stripables, ignore hidden ones. This matches
4547                            the semantics of the pre-PresentationOrder
4548                            "get by RID" logic of Ardour 4.x and earlier.
4549
4550                            XXX at some point we should likely reverse
4551                            the logic of the flags, because asking for "the
4552                            hidden stripables" is not going to be common,
4553                            whereas asking for visible ones is normal.
4554                         */
4555
4556                         if (! (flags & PresentationInfo::Hidden)) {
4557                                 continue;
4558                         }
4559                 }
4560
4561                 if ((*s)->presentation_info().flag_match (flags)) {
4562                         if (match_cnt++ == n) {
4563                                 return *s;
4564                         }
4565                 }
4566         }
4567
4568         /* there is no nth stripable that matches the given flags */
4569         return boost::shared_ptr<Stripable>();
4570 }
4571
4572 boost::shared_ptr<Route>
4573 Session::route_by_selected_count (uint32_t id) const
4574 {
4575         RouteList r (*(routes.reader ()));
4576         r.sort (Stripable::Sorter());
4577
4578         RouteList::iterator i;
4579
4580         for (i = r.begin(); i != r.end(); ++i) {
4581                 if ((*i)->is_selected()) {
4582                         if (id == 0) {
4583                                 return *i;
4584                         }
4585                         --id;
4586                 }
4587         }
4588
4589         return boost::shared_ptr<Route> ();
4590 }
4591
4592 void
4593 Session::reassign_track_numbers ()
4594 {
4595         int64_t tn = 0;
4596         int64_t bn = 0;
4597         RouteList r (*(routes.reader ()));
4598         r.sort (Stripable::Sorter());
4599
4600         StateProtector sp (this);
4601
4602         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4603                 assert (!(*i)->is_auditioner());
4604                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4605                         (*i)->set_track_number(++tn);
4606                 }
4607                 else if (!(*i)->is_master() && !(*i)->is_monitor()) {
4608                         (*i)->set_track_number(--bn);
4609                 }
4610         }
4611         const uint32_t decimals = ceilf (log10f (tn + 1));
4612         const bool decimals_changed = _track_number_decimals != decimals;
4613         _track_number_decimals = decimals;
4614
4615         if (decimals_changed && config.get_track_name_number ()) {
4616                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4617                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4618                         if (t) {
4619                                 t->resync_track_name();
4620                         }
4621                 }
4622                 // trigger GUI re-layout
4623                 config.ParameterChanged("track-name-number");
4624         }
4625
4626 #ifndef NDEBUG
4627         if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4628                 boost::shared_ptr<RouteList> rl = routes.reader ();
4629                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4630                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4631                 }
4632         }
4633 #endif /* NDEBUG */
4634
4635 }
4636
4637 void
4638 Session::playlist_region_added (boost::weak_ptr<Region> w)
4639 {
4640         boost::shared_ptr<Region> r = w.lock ();
4641         if (!r) {
4642                 return;
4643         }
4644
4645         /* These are the operations that are currently in progress... */
4646         list<GQuark> curr = _current_trans_quarks;
4647         curr.sort ();
4648
4649         /* ...and these are the operations during which we want to update
4650            the session range location markers.
4651         */
4652         list<GQuark> ops;
4653         ops.push_back (Operations::capture);
4654         ops.push_back (Operations::paste);
4655         ops.push_back (Operations::duplicate_region);
4656         ops.push_back (Operations::insert_file);
4657         ops.push_back (Operations::insert_region);
4658         ops.push_back (Operations::drag_region_brush);
4659         ops.push_back (Operations::region_drag);
4660         ops.push_back (Operations::selection_grab);
4661         ops.push_back (Operations::region_fill);
4662         ops.push_back (Operations::fill_selection);
4663         ops.push_back (Operations::create_region);
4664         ops.push_back (Operations::region_copy);
4665         ops.push_back (Operations::fixed_time_region_copy);
4666         ops.sort ();
4667
4668         /* See if any of the current operations match the ones that we want */
4669         list<GQuark> in;
4670         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4671
4672         /* If so, update the session range markers */
4673         if (!in.empty ()) {
4674                 maybe_update_session_range (r->position (), r->last_sample ());
4675         }
4676 }
4677
4678 /** Update the session range markers if a is before the current start or
4679  *  b is after the current end.
4680  */
4681 void
4682 Session::maybe_update_session_range (samplepos_t a, samplepos_t b)
4683 {
4684         if (_state_of_the_state & Loading) {
4685                 return;
4686         }
4687
4688         samplepos_t session_end_marker_shift_samples = session_end_shift * _nominal_sample_rate;
4689
4690         if (_session_range_location == 0) {
4691
4692                 set_session_range_location (a, b + session_end_marker_shift_samples);
4693
4694         } else {
4695
4696                 if (a < _session_range_location->start()) {
4697                         _session_range_location->set_start (a);
4698                 }
4699
4700                 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4701                         _session_range_location->set_end (b);
4702                 }
4703         }
4704 }
4705
4706 void
4707 Session::set_end_is_free (bool yn)
4708 {
4709         _session_range_end_is_free = yn;
4710 }
4711
4712 void
4713 Session::playlist_ranges_moved (list<Evoral::RangeMove<samplepos_t> > const & ranges)
4714 {
4715         for (list<Evoral::RangeMove<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4716                 maybe_update_session_range (i->to, i->to + i->length);
4717         }
4718 }
4719
4720 void
4721 Session::playlist_regions_extended (list<Evoral::Range<samplepos_t> > const & ranges)
4722 {
4723         for (list<Evoral::Range<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4724                 maybe_update_session_range (i->from, i->to);
4725         }
4726 }
4727
4728 /* Region management */
4729
4730 boost::shared_ptr<Region>
4731 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4732 {
4733         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4734         RegionFactory::RegionMap::const_iterator i;
4735         boost::shared_ptr<Region> region;
4736
4737         Glib::Threads::Mutex::Lock lm (region_lock);
4738
4739         for (i = regions.begin(); i != regions.end(); ++i) {
4740
4741                 region = i->second;
4742
4743                 if (region->whole_file()) {
4744
4745                         if (child->source_equivalent (region)) {
4746                                 return region;
4747                         }
4748                 }
4749         }
4750
4751         return boost::shared_ptr<Region> ();
4752 }
4753
4754 int
4755 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4756 {
4757         set<boost::shared_ptr<Region> > relevant_regions;
4758
4759         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4760                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4761         }
4762
4763         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4764                 set<boost::shared_ptr<Region> >::iterator tmp;
4765
4766                 tmp = r;
4767                 ++tmp;
4768
4769                 playlists->destroy_region (*r);
4770                 RegionFactory::map_remove (*r);
4771
4772                 (*r)->drop_sources ();
4773                 (*r)->drop_references ();
4774
4775                 relevant_regions.erase (r);
4776
4777                 r = tmp;
4778         }
4779
4780         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4781
4782                 {
4783                         Glib::Threads::Mutex::Lock ls (source_lock);
4784                         /* remove from the main source list */
4785                         sources.erase ((*s)->id());
4786                 }
4787
4788                 (*s)->mark_for_remove ();
4789                 (*s)->drop_references ();
4790
4791                 s = srcs.erase (s);
4792         }
4793
4794         return 0;
4795 }
4796
4797 int
4798 Session::remove_last_capture ()
4799 {
4800         list<boost::shared_ptr<Source> > srcs;
4801
4802         boost::shared_ptr<RouteList> rl = routes.reader ();
4803         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4804                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4805                 if (!tr) {
4806                         continue;
4807                 }
4808
4809                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4810
4811                 if (!l.empty()) {
4812                         srcs.insert (srcs.end(), l.begin(), l.end());
4813                         l.clear ();
4814                 }
4815         }
4816
4817         destroy_sources (srcs);
4818
4819         save_state (_current_snapshot_name);
4820
4821         return 0;
4822 }
4823
4824 /* Source Management */
4825
4826 void
4827 Session::add_source (boost::shared_ptr<Source> source)
4828 {
4829         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4830         pair<SourceMap::iterator,bool> result;
4831
4832         entry.first = source->id();
4833         entry.second = source;
4834
4835         {
4836                 Glib::Threads::Mutex::Lock lm (source_lock);
4837                 result = sources.insert (entry);
4838         }
4839
4840         if (result.second) {
4841
4842                 /* yay, new source */
4843
4844                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4845
4846                 if (fs) {
4847                         if (!fs->within_session()) {
4848                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4849                         }
4850                 }
4851
4852                 set_dirty();
4853
4854                 boost::shared_ptr<AudioFileSource> afs;
4855
4856                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4857                         if (Config->get_auto_analyse_audio()) {
4858                                 Analyser::queue_source_for_analysis (source, false);
4859                         }
4860                 }
4861
4862                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4863         }
4864 }
4865
4866 void
4867 Session::remove_source (boost::weak_ptr<Source> src)
4868 {
4869         if (_state_of_the_state & Deletion) {
4870                 return;
4871         }
4872
4873         SourceMap::iterator i;
4874         boost::shared_ptr<Source> source = src.lock();
4875
4876         if (!source) {
4877                 return;
4878         }
4879
4880         {
4881                 Glib::Threads::Mutex::Lock lm (source_lock);
4882
4883                 if ((i = sources.find (source->id())) != sources.end()) {
4884                         sources.erase (i);
4885                 }
4886         }
4887
4888         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4889
4890                 /* save state so we don't end up with a session file
4891                    referring to non-existent sources.
4892                 */
4893
4894                 save_state (_current_snapshot_name);
4895         }
4896 }
4897
4898 boost::shared_ptr<Source>
4899 Session::source_by_id (const PBD::ID& id)
4900 {
4901         Glib::Threads::Mutex::Lock lm (source_lock);
4902         SourceMap::iterator i;
4903         boost::shared_ptr<Source> source;
4904
4905         if ((i = sources.find (id)) != sources.end()) {
4906                 source = i->second;
4907         }
4908
4909         return source;
4910 }
4911
4912 boost::shared_ptr<AudioFileSource>
4913 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4914 {
4915         /* Restricted to audio files because only audio sources have channel
4916            as a property.
4917         */
4918
4919         Glib::Threads::Mutex::Lock lm (source_lock);
4920
4921         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4922                 boost::shared_ptr<AudioFileSource> afs
4923                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4924
4925                 if (afs && afs->path() == path && chn == afs->channel()) {
4926                         return afs;
4927                 }
4928         }
4929
4930         return boost::shared_ptr<AudioFileSource>();
4931 }
4932
4933 boost::shared_ptr<MidiSource>
4934 Session::midi_source_by_path (const std::string& path, bool need_source_lock) const
4935 {
4936         /* Restricted to MIDI files because audio sources require a channel
4937            for unique identification, in addition to a path.
4938         */
4939
4940         Glib::Threads::Mutex::Lock lm (source_lock, Glib::Threads::NOT_LOCK);
4941         if (need_source_lock) {
4942                 lm.acquire ();
4943         }
4944
4945         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4946                 boost::shared_ptr<MidiSource> ms
4947                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4948                 boost::shared_ptr<FileSource> fs
4949                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4950
4951                 if (ms && fs && fs->path() == path) {
4952                         return ms;
4953                 }
4954         }
4955
4956         return boost::shared_ptr<MidiSource>();
4957 }
4958
4959 uint32_t
4960 Session::count_sources_by_origin (const string& path)
4961 {
4962         uint32_t cnt = 0;
4963         Glib::Threads::Mutex::Lock lm (source_lock);
4964
4965         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4966                 boost::shared_ptr<FileSource> fs
4967                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4968
4969                 if (fs && fs->origin() == path) {
4970                         ++cnt;
4971                 }
4972         }
4973
4974         return cnt;
4975 }
4976
4977 static string
4978 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4979         if (hash) {
4980                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4981                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4982         } else {
4983                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4984         }
4985 }
4986
4987 string
4988 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4989 {
4990         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4991
4992         if (Glib::path_is_absolute (filepath)) {
4993
4994                 /* rip the session dir from the audiofile source */
4995
4996                 string session_path;
4997                 bool in_another_session = true;
4998
4999                 if (filepath.find (interchange_dir_string) != string::npos) {
5000
5001                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
5002                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
5003                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
5004                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
5005
5006                         /* see if it is within our session */
5007
5008                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5009                                 if (i->path == session_path) {
5010                                         in_another_session = false;
5011                                         break;
5012                                 }
5013                         }
5014                 } else {
5015                         in_another_session = false;
5016                 }
5017
5018
5019                 if (in_another_session) {
5020                         SessionDirectory sd (session_path);
5021                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
5022                 }
5023         }
5024
5025         /* 1) if file belongs to this session
5026          * it may be a relative path (interchange/...)
5027          * or just basename (session_state, remove source)
5028          * -> just use the basename
5029          */
5030         std::string filename = Glib::path_get_basename (filepath);
5031         std::string path;
5032
5033         /* 2) if the file is outside our session dir:
5034          * (imported but not copied) add the path for check-summming */
5035         if (!in_session) {
5036                 path = Glib::path_get_dirname (filepath);
5037         }
5038
5039         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
5040 }
5041
5042 string
5043 Session::new_audio_source_path_for_embedded (const std::string& path)
5044 {
5045         /* embedded source:
5046          *
5047          * we know that the filename is already unique because it exists
5048          * out in the filesystem.
5049          *
5050          * However, when we bring it into the session, we could get a
5051          * collision.
5052          *
5053          * Eg. two embedded files:
5054          *
5055          *          /foo/bar/baz.wav
5056          *          /frob/nic/baz.wav
5057          *
5058          * When merged into session, these collide.
5059          *
5060          * There will not be a conflict with in-memory sources
5061          * because when the source was created we already picked
5062          * a unique name for it.
5063          *
5064          * This collision is not likely to be common, but we have to guard
5065          * against it.  So, if there is a collision, take the md5 hash of the
5066          * the path, and use that as the filename instead.
5067          */
5068
5069         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5070         string base = Glib::path_get_basename (path);
5071         string newpath = Glib::build_filename (sdir.sound_path(), base);
5072
5073         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5074
5075                 MD5 md5;
5076
5077                 md5.digestString (path.c_str());
5078                 md5.writeToString ();
5079                 base = md5.digestChars;
5080
5081                 string ext = get_suffix (path);
5082
5083                 if (!ext.empty()) {
5084                         base += '.';
5085                         base += ext;
5086                 }
5087
5088                 newpath = Glib::build_filename (sdir.sound_path(), base);
5089
5090                 /* if this collides, we're screwed */
5091
5092                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5093                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5094                         return string();
5095                 }
5096
5097         }
5098
5099         return newpath;
5100 }
5101
5102 /** Return true if there are no audio file sources that use @param name as
5103  * the filename component of their path.
5104  *
5105  * Return false otherwise.
5106  *
5107  * This method MUST ONLY be used to check in-session, mono files since it
5108  * hard-codes the channel of the audio file source we are looking for as zero.
5109  *
5110  * If/when Ardour supports native files in non-mono formats, the logic here
5111  * will need to be revisited.
5112  */
5113 bool
5114 Session::audio_source_name_is_unique (const string& name)
5115 {
5116         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5117         vector<space_and_path>::iterator i;
5118         uint32_t existing = 0;
5119
5120         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5121
5122                 /* note that we search *without* the extension so that
5123                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5124                    in the event that this new name is required for
5125                    a file format change.
5126                 */
5127
5128                 const string spath = *i;
5129
5130                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5131                         existing++;
5132                         break;
5133                 }
5134
5135                 /* it is possible that we have the path already
5136                  * assigned to a source that has not yet been written
5137                  * (ie. the write source for a diskstream). we have to
5138                  * check this in order to make sure that our candidate
5139                  * path isn't used again, because that can lead to
5140                  * two Sources point to the same file with different
5141                  * notions of their removability.
5142                  */
5143
5144
5145                 string possible_path = Glib::build_filename (spath, name);
5146
5147                 if (audio_source_by_path_and_channel (possible_path, 0)) {
5148                         existing++;
5149                         break;
5150                 }
5151         }
5152
5153         return (existing == 0);
5154 }
5155
5156 string
5157 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)
5158 {
5159         ostringstream sstr;
5160         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5161
5162         if (Profile->get_trx() && destructive) {
5163                 sstr << 'T';
5164                 sstr << setfill ('0') << setw (4) << cnt;
5165                 sstr << legalized_base;
5166         } else {
5167                 sstr << legalized_base;
5168
5169                 if (take_required || related_exists) {
5170                         sstr << '-';
5171                         sstr << cnt;
5172                 }
5173         }
5174
5175         if (nchan == 2) {
5176                 if (chan == 0) {
5177                         sstr << "%L";
5178                 } else {
5179                         sstr << "%R";
5180                 }
5181         } else if (nchan > 2) {
5182                 if (nchan < 26) {
5183                         sstr << '%';
5184                         sstr << 'a' + chan;
5185                 } else {
5186                         /* XXX what? more than 26 channels! */
5187                         sstr << '%';
5188                         sstr << chan+1;
5189                 }
5190         }
5191
5192         sstr << ext;
5193
5194         return sstr.str();
5195 }
5196
5197 /** Return a unique name based on \a base for a new internal audio source */
5198 string
5199 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5200 {
5201         uint32_t cnt;
5202         string possible_name;
5203         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5204         string legalized;
5205         bool some_related_source_name_exists = false;
5206
5207         legalized = legalize_for_path (base);
5208
5209         // Find a "version" of the base name that doesn't exist in any of the possible directories.
5210
5211         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5212
5213                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5214
5215                 if (audio_source_name_is_unique (possible_name)) {
5216                         break;
5217                 }
5218
5219                 some_related_source_name_exists = true;
5220
5221                 if (cnt > limit) {
5222                         error << string_compose(
5223                                         _("There are already %1 recordings for %2, which I consider too many."),
5224                                         limit, base) << endmsg;
5225                         destroy ();
5226                         throw failed_constructor();
5227                 }
5228         }
5229
5230         /* We've established that the new name does not exist in any session
5231          * directory, so now find out which one we should use for this new
5232          * audio source.
5233          */
5234
5235         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5236
5237         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5238
5239         return s;
5240 }
5241
5242 /** Return a unique name based on `base` for a new internal MIDI source */
5243 string
5244 Session::new_midi_source_path (const string& base, bool need_lock)
5245 {
5246         string possible_path;
5247         string possible_name;
5248
5249         possible_name = legalize_for_path (base);
5250
5251         // Find a "version" of the file name that doesn't exist in any of the possible directories.
5252         std::vector<string> sdirs = source_search_path(DataType::MIDI);
5253
5254         /* - the main session folder is the first in the vector.
5255          * - after checking all locations for file-name uniqueness,
5256          *   we keep the one from the last iteration as new file name
5257          * - midi files are small and should just be kept in the main session-folder
5258          *
5259          * -> reverse the array, check main session folder last and use that as location
5260          *    for MIDI files.
5261          */
5262         std::reverse(sdirs.begin(), sdirs.end());
5263
5264         while (true) {
5265                 possible_name = bump_name_once (possible_name, '-');
5266
5267                 vector<space_and_path>::iterator i;
5268                 uint32_t existing = 0;
5269
5270                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5271
5272                         possible_path = Glib::build_filename (*i, possible_name + ".mid");
5273
5274                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5275                                 existing++;
5276                         }
5277
5278                         if (midi_source_by_path (possible_path, need_lock)) {
5279                                 existing++;
5280                         }
5281                 }
5282
5283                 if (possible_path.size () >= PATH_MAX) {
5284                         error << string_compose(
5285                                         _("There are already many recordings for %1, resulting in a too long file-path %2."),
5286                                         base, possible_path) << endmsg;
5287                         destroy ();
5288                         return 0;
5289                 }
5290
5291                 if (existing == 0) {
5292                         break;
5293                 }
5294         }
5295
5296         /* No need to "find best location" for software/app-based RAID, because
5297            MIDI is so small that we always put it in the same place.
5298         */
5299
5300         return possible_path;
5301 }
5302
5303
5304 /** Create a new within-session audio source */
5305 boost::shared_ptr<AudioFileSource>
5306 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5307 {
5308         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5309
5310         if (!path.empty()) {
5311                 return boost::dynamic_pointer_cast<AudioFileSource> (
5312                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, sample_rate(), true, true));
5313         } else {
5314                 throw failed_constructor ();
5315         }
5316 }
5317
5318 /** Create a new within-session MIDI source */
5319 boost::shared_ptr<MidiSource>
5320 Session::create_midi_source_for_session (string const & basic_name)
5321 {
5322         const string path = new_midi_source_path (basic_name);
5323
5324         if (!path.empty()) {
5325                 return boost::dynamic_pointer_cast<SMFSource> (
5326                         SourceFactory::createWritable (
5327                                 DataType::MIDI, *this, path, false, sample_rate()));
5328         } else {
5329                 throw failed_constructor ();
5330         }
5331 }
5332
5333 /** Create a new within-session MIDI source */
5334 boost::shared_ptr<MidiSource>
5335 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5336 {
5337         /* the caller passes in the track the source will be used in,
5338            so that we can keep the numbering sane.
5339
5340            Rationale: a track with the name "Foo" that has had N
5341            captures carried out so far will ALREADY have a write source
5342            named "Foo-N+1.mid" waiting to be used for the next capture.
5343
5344            If we call new_midi_source_name() we will get "Foo-N+2". But
5345            there is no region corresponding to "Foo-N+1", so when
5346            "Foo-N+2" appears in the track, the gap presents the user
5347            with odd behaviour - why did it skip past Foo-N+1?
5348
5349            We could explain this to the user in some odd way, but
5350            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5351            use "Foo-N+1" here.
5352
5353            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5354         */
5355
5356         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5357         assert (mt);
5358         std::string name = track->steal_write_source_name ();
5359
5360         if (name.empty()) {
5361                 return boost::shared_ptr<MidiSource>();
5362         }
5363
5364         /* MIDI files are small, just put them in the first location of the
5365            session source search path.
5366         */
5367
5368         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5369
5370         return boost::dynamic_pointer_cast<SMFSource> (
5371                 SourceFactory::createWritable (
5372                         DataType::MIDI, *this, path, false, sample_rate()));
5373 }
5374
5375
5376 void
5377 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5378 {
5379         if (playlist->hidden()) {
5380                 return;
5381         }
5382
5383         playlists->add (playlist);
5384
5385         if (unused) {
5386                 playlist->release();
5387         }
5388
5389         set_dirty();
5390 }
5391
5392 void
5393 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5394 {
5395         if (_state_of_the_state & Deletion) {
5396                 return;
5397         }
5398
5399         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5400
5401         if (!playlist) {
5402                 return;
5403         }
5404
5405         playlists->remove (playlist);
5406
5407         set_dirty();
5408 }
5409
5410 void
5411 Session::set_audition (boost::shared_ptr<Region> r)
5412 {
5413         pending_audition_region = r;
5414         add_post_transport_work (PostTransportAudition);
5415         _butler->schedule_transport_work ();
5416 }
5417
5418 void
5419 Session::audition_playlist ()
5420 {
5421         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5422         ev->region.reset ();
5423         queue_event (ev);
5424 }
5425
5426
5427 void
5428 Session::register_lua_function (
5429                 const std::string& name,
5430                 const std::string& script,
5431                 const LuaScriptParamList& args
5432                 )
5433 {
5434         Glib::Threads::Mutex::Lock lm (lua_lock);
5435
5436         lua_State* L = lua.getState();
5437
5438         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5439         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5440         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5441                 if ((*i)->optional && !(*i)->is_set) { continue; }
5442                 tbl_arg[(*i)->name] = (*i)->value;
5443         }
5444         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5445         lm.release();
5446
5447         LuaScriptsChanged (); /* EMIT SIGNAL */
5448         set_dirty();
5449 }
5450
5451 void
5452 Session::unregister_lua_function (const std::string& name)
5453 {
5454         Glib::Threads::Mutex::Lock lm (lua_lock);
5455         (*_lua_del)(name); // throws luabridge::LuaException
5456         lua.collect_garbage ();
5457         lm.release();
5458
5459         LuaScriptsChanged (); /* EMIT SIGNAL */
5460         set_dirty();
5461 }
5462
5463 std::vector<std::string>
5464 Session::registered_lua_functions ()
5465 {
5466         Glib::Threads::Mutex::Lock lm (lua_lock);
5467         std::vector<std::string> rv;
5468
5469         try {
5470                 luabridge::LuaRef list ((*_lua_list)());
5471                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5472                         if (!i.key ().isString ()) { assert(0); continue; }
5473                         rv.push_back (i.key ().cast<std::string> ());
5474                 }
5475         } catch (...) { }
5476         return rv;
5477 }
5478
5479 #ifndef NDEBUG
5480 static void _lua_print (std::string s) {
5481         std::cout << "SessionLua: " << s << "\n";
5482 }
5483 #endif
5484
5485 void
5486 Session::try_run_lua (pframes_t nframes)
5487 {
5488         if (_n_lua_scripts == 0) return;
5489         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5490         if (tm.locked ()) {
5491                 try { (*_lua_run)(nframes); } catch (...) { }
5492                 lua.collect_garbage_step ();
5493         }
5494 }
5495
5496 void
5497 Session::setup_lua ()
5498 {
5499 #ifndef NDEBUG
5500         lua.Print.connect (&_lua_print);
5501 #endif
5502         lua.tweak_rt_gc ();
5503         lua.sandbox (true);
5504         lua.do_command (
5505                         "function ArdourSession ()"
5506                         "  local self = { scripts = {}, instances = {} }"
5507                         ""
5508                         "  local remove = function (n)"
5509                         "   self.scripts[n] = nil"
5510                         "   self.instances[n] = nil"
5511                         "   Session:scripts_changed()" // call back
5512                         "  end"
5513                         ""
5514                         "  local addinternal = function (n, f, a)"
5515                         "   assert(type(n) == 'string', 'function-name must be string')"
5516                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5517                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5518                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5519                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5520                         "   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 }"
5521                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5522                         "   Session:scripts_changed()" // call back
5523                         "  end"
5524                         ""
5525                         "  local add = function (n, b, a)"
5526                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5527                         "   load (b)()" // assigns f
5528                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5529                         "   addinternal (n, load(f), a)"
5530                         "  end"
5531                         ""
5532                         "  local run = function (...)"
5533                         "   for n, s in pairs (self.instances) do"
5534                         "     local status, err = pcall (s, ...)"
5535                         "     if not status then"
5536                         "       print ('fn \"'.. n .. '\": ', err)"
5537                         "       remove (n)"
5538                         "      end"
5539                         "   end"
5540                         "   collectgarbage()"
5541                         "  end"
5542                         ""
5543                         "  local cleanup = function ()"
5544                         "   self.scripts = nil"
5545                         "   self.instances = nil"
5546                         "  end"
5547                         ""
5548                         "  local list = function ()"
5549                         "   local rv = {}"
5550                         "   for n, _ in pairs (self.scripts) do"
5551                         "     rv[n] = true"
5552                         "   end"
5553                         "   return rv"
5554                         "  end"
5555                         ""
5556                         "  local function basic_serialize (o)"
5557                         "    if type(o) == \"number\" then"
5558                         "     return tostring(o)"
5559                         "    else"
5560                         "     return string.format(\"%q\", o)"
5561                         "    end"
5562                         "  end"
5563                         ""
5564                         "  local function serialize (name, value)"
5565                         "   local rv = name .. ' = '"
5566                         "   collectgarbage()"
5567                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5568                         "    return rv .. basic_serialize(value) .. ' '"
5569                         "   elseif type(value) == \"table\" then"
5570                         "    rv = rv .. '{} '"
5571                         "    for k,v in pairs(value) do"
5572                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5573                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5574                         "     collectgarbage()" // string concatenation allocates a new string :(
5575                         "    end"
5576                         "    return rv;"
5577                         "   elseif type(value) == \"function\" then"
5578                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5579                         "   else"
5580                         "    error('cannot save a ' .. type(value))"
5581                         "   end"
5582                         "  end"
5583                         ""
5584                         ""
5585                         "  local save = function ()"
5586                         "   return (serialize('scripts', self.scripts))"
5587                         "  end"
5588                         ""
5589                         "  local restore = function (state)"
5590                         "   self.scripts = {}"
5591                         "   load (state)()"
5592                         "   for n, s in pairs (scripts) do"
5593                         "    addinternal (n, load(s['f']), s['a'])"
5594                         "   end"
5595                         "  end"
5596                         ""
5597                         " return { run = run, add = add, remove = remove,"
5598                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5599                         " end"
5600                         " "
5601                         " sess = ArdourSession ()"
5602                         " ArdourSession = nil"
5603                         " "
5604                         "function ardour () end"
5605                         );
5606
5607         lua_State* L = lua.getState();
5608
5609         try {
5610                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5611                 lua.do_command ("sess = nil"); // hide it.
5612                 lua.do_command ("collectgarbage()");
5613
5614                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5615                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5616                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5617                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5618                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5619                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5620                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5621         } catch (luabridge::LuaException const& e) {
5622                 fatal << string_compose (_("programming error: %1"),
5623                                 std::string ("Failed to setup session Lua interpreter") + e.what ())
5624                         << endmsg;
5625                 abort(); /*NOTREACHED*/
5626         } catch (...) {
5627                 fatal << string_compose (_("programming error: %1"),
5628                                 X_("Failed to setup session Lua interpreter"))
5629                         << endmsg;
5630                 abort(); /*NOTREACHED*/
5631         }
5632
5633         LuaBindings::stddef (L);
5634         LuaBindings::common (L);
5635         LuaBindings::dsp (L);
5636         luabridge::push <Session *> (L, this);
5637         lua_setglobal (L, "Session");
5638 }
5639
5640 void
5641 Session::scripts_changed ()
5642 {
5643         assert (!lua_lock.trylock()); // must hold lua_lock
5644
5645         try {
5646                 luabridge::LuaRef list ((*_lua_list)());
5647                 int cnt = 0;
5648                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5649                         if (!i.key ().isString ()) { assert(0); continue; }
5650                         ++cnt;
5651                 }
5652                 _n_lua_scripts = cnt;
5653         } catch (luabridge::LuaException const& e) {
5654                 fatal << string_compose (_("programming error: %1"),
5655                                 std::string ("Indexing Lua Session Scripts failed.") + e.what ())
5656                         << endmsg;
5657                 abort(); /*NOTREACHED*/
5658         } catch (...) {
5659                 fatal << string_compose (_("programming error: %1"),
5660                                 X_("Indexing Lua Session Scripts failed."))
5661                         << endmsg;
5662                 abort(); /*NOTREACHED*/
5663         }
5664 }
5665
5666 void
5667 Session::non_realtime_set_audition ()
5668 {
5669         assert (pending_audition_region);
5670         auditioner->audition_region (pending_audition_region);
5671         pending_audition_region.reset ();
5672         AuditionActive (true); /* EMIT SIGNAL */
5673 }
5674
5675 void
5676 Session::audition_region (boost::shared_ptr<Region> r)
5677 {
5678         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5679         ev->region = r;
5680         queue_event (ev);
5681 }
5682
5683 void
5684 Session::cancel_audition ()
5685 {
5686         if (!auditioner) {
5687                 return;
5688         }
5689         if (auditioner->auditioning()) {
5690                 auditioner->cancel_audition ();
5691                 AuditionActive (false); /* EMIT SIGNAL */
5692         }
5693 }
5694
5695 bool
5696 Session::is_auditioning () const
5697 {
5698         /* can be called before we have an auditioner object */
5699         if (auditioner) {
5700                 return auditioner->auditioning();
5701         } else {
5702                 return false;
5703         }
5704 }
5705
5706 void
5707 Session::graph_reordered ()
5708 {
5709         /* don't do this stuff if we are setting up connections
5710            from a set_state() call or creating new tracks. Ditto for deletion.
5711         */
5712
5713         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5714                 return;
5715         }
5716
5717         resort_routes ();
5718
5719         /* force all diskstreams to update their capture offset values to
5720            reflect any changes in latencies within the graph.
5721         */
5722
5723         boost::shared_ptr<RouteList> rl = routes.reader ();
5724         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5725                 (*i)->update_signal_latency (true); // XXX
5726         }
5727 }
5728
5729 /** @return Number of samples that there is disk space available to write,
5730  *  if known.
5731  */
5732 boost::optional<samplecnt_t>
5733 Session::available_capture_duration ()
5734 {
5735         Glib::Threads::Mutex::Lock lm (space_lock);
5736
5737         if (_total_free_4k_blocks_uncertain) {
5738                 return boost::optional<samplecnt_t> ();
5739         }
5740
5741         float sample_bytes_on_disk = 4.0; // keep gcc happy
5742
5743         switch (config.get_native_file_data_format()) {
5744         case FormatFloat:
5745                 sample_bytes_on_disk = 4.0;
5746                 break;
5747
5748         case FormatInt24:
5749                 sample_bytes_on_disk = 3.0;
5750                 break;
5751
5752         case FormatInt16:
5753                 sample_bytes_on_disk = 2.0;
5754                 break;
5755
5756         default:
5757                 /* impossible, but keep some gcc versions happy */
5758                 fatal << string_compose (_("programming error: %1"),
5759                                          X_("illegal native file data format"))
5760                       << endmsg;
5761                 abort(); /*NOTREACHED*/
5762         }
5763
5764         double scale = 4096.0 / sample_bytes_on_disk;
5765
5766         if (_total_free_4k_blocks * scale > (double) max_samplecnt) {
5767                 return max_samplecnt;
5768         }
5769
5770         return (samplecnt_t) floor (_total_free_4k_blocks * scale);
5771 }
5772
5773 void
5774 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5775 {
5776         {
5777                 RCUWriter<BundleList> writer (_bundles);
5778                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5779                 b->push_back (bundle);
5780         }
5781
5782         if (emit_signal) {
5783                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5784         }
5785
5786         set_dirty();
5787 }
5788
5789 void
5790 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5791 {
5792         bool removed = false;
5793
5794         {
5795                 RCUWriter<BundleList> writer (_bundles);
5796                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5797                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5798
5799                 if (i != b->end()) {
5800                         b->erase (i);
5801                         removed = true;
5802                 }
5803         }
5804
5805         if (removed) {
5806                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5807         }
5808
5809         set_dirty();
5810 }
5811
5812 boost::shared_ptr<Bundle>
5813 Session::bundle_by_name (string name) const
5814 {
5815         boost::shared_ptr<BundleList> b = _bundles.reader ();
5816
5817         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5818                 if ((*i)->name() == name) {
5819                         return* i;
5820                 }
5821         }
5822
5823         return boost::shared_ptr<Bundle> ();
5824 }
5825
5826 void
5827 Session::tempo_map_changed (const PropertyChange&)
5828 {
5829         clear_clicks ();
5830
5831         playlists->update_after_tempo_map_change ();
5832
5833         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5834
5835         set_dirty ();
5836 }
5837
5838 void
5839 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5840 {
5841         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5842                 (*i)->recompute_samples_from_beat ();
5843         }
5844 }
5845
5846 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5847  * the given count with the current block size.
5848  */
5849 void
5850 Session::ensure_buffers (ChanCount howmany)
5851 {
5852         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5853 }
5854
5855 void
5856 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5857 {
5858         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5859                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5860         }
5861 }
5862
5863 uint32_t
5864 Session::next_insert_id ()
5865 {
5866         /* this doesn't really loop forever. just think about it */
5867
5868         while (true) {
5869                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5870                         if (!insert_bitset[n]) {
5871                                 insert_bitset[n] = true;
5872                                 return n;
5873
5874                         }
5875                 }
5876
5877                 /* none available, so resize and try again */
5878
5879                 insert_bitset.resize (insert_bitset.size() + 16, false);
5880         }
5881 }
5882
5883 uint32_t
5884 Session::next_send_id ()
5885 {
5886         /* this doesn't really loop forever. just think about it */
5887
5888         while (true) {
5889                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5890                         if (!send_bitset[n]) {
5891                                 send_bitset[n] = true;
5892                                 return n;
5893
5894                         }
5895                 }
5896
5897                 /* none available, so resize and try again */
5898
5899                 send_bitset.resize (send_bitset.size() + 16, false);
5900         }
5901 }
5902
5903 uint32_t
5904 Session::next_aux_send_id ()
5905 {
5906         /* this doesn't really loop forever. just think about it */
5907
5908         while (true) {
5909                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5910                         if (!aux_send_bitset[n]) {
5911                                 aux_send_bitset[n] = true;
5912                                 return n;
5913
5914                         }
5915                 }
5916
5917                 /* none available, so resize and try again */
5918
5919                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5920         }
5921 }
5922
5923 uint32_t
5924 Session::next_return_id ()
5925 {
5926         /* this doesn't really loop forever. just think about it */
5927
5928         while (true) {
5929                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5930                         if (!return_bitset[n]) {
5931                                 return_bitset[n] = true;
5932                                 return n;
5933
5934                         }
5935                 }
5936
5937                 /* none available, so resize and try again */
5938
5939                 return_bitset.resize (return_bitset.size() + 16, false);
5940         }
5941 }
5942
5943 void
5944 Session::mark_send_id (uint32_t id)
5945 {
5946         if (id >= send_bitset.size()) {
5947                 send_bitset.resize (id+16, false);
5948         }
5949         if (send_bitset[id]) {
5950                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5951         }
5952         send_bitset[id] = true;
5953 }
5954
5955 void
5956 Session::mark_aux_send_id (uint32_t id)
5957 {
5958         if (id >= aux_send_bitset.size()) {
5959                 aux_send_bitset.resize (id+16, false);
5960         }
5961         if (aux_send_bitset[id]) {
5962                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5963         }
5964         aux_send_bitset[id] = true;
5965 }
5966
5967 void
5968 Session::mark_return_id (uint32_t id)
5969 {
5970         if (id >= return_bitset.size()) {
5971                 return_bitset.resize (id+16, false);
5972         }
5973         if (return_bitset[id]) {
5974                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5975         }
5976         return_bitset[id] = true;
5977 }
5978
5979 void
5980 Session::mark_insert_id (uint32_t id)
5981 {
5982         if (id >= insert_bitset.size()) {
5983                 insert_bitset.resize (id+16, false);
5984         }
5985         if (insert_bitset[id]) {
5986                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5987         }
5988         insert_bitset[id] = true;
5989 }
5990
5991 void
5992 Session::unmark_send_id (uint32_t id)
5993 {
5994         if (id < send_bitset.size()) {
5995                 send_bitset[id] = false;
5996         }
5997 }
5998
5999 void
6000 Session::unmark_aux_send_id (uint32_t id)
6001 {
6002         if (id < aux_send_bitset.size()) {
6003                 aux_send_bitset[id] = false;
6004         }
6005 }
6006
6007 void
6008 Session::unmark_return_id (uint32_t id)
6009 {
6010         if (_state_of_the_state & Deletion) { return; }
6011         if (id < return_bitset.size()) {
6012                 return_bitset[id] = false;
6013         }
6014 }
6015
6016 void
6017 Session::unmark_insert_id (uint32_t id)
6018 {
6019         if (id < insert_bitset.size()) {
6020                 insert_bitset[id] = false;
6021         }
6022 }
6023
6024 void
6025 Session::reset_native_file_format ()
6026 {
6027         boost::shared_ptr<RouteList> rl = routes.reader ();
6028
6029         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6030                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6031                 if (tr) {
6032                         /* don't save state as we do this, there's no point
6033                          */
6034                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
6035                         tr->reset_write_sources (false);
6036                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
6037                 }
6038         }
6039 }
6040
6041 bool
6042 Session::route_name_unique (string n) const
6043 {
6044         boost::shared_ptr<RouteList> r = routes.reader ();
6045
6046         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6047                 if ((*i)->name() == n) {
6048                         return false;
6049                 }
6050         }
6051
6052         return true;
6053 }
6054
6055 bool
6056 Session::route_name_internal (string n) const
6057 {
6058         if (auditioner && auditioner->name() == n) {
6059                 return true;
6060         }
6061
6062         if (_click_io && _click_io->name() == n) {
6063                 return true;
6064         }
6065
6066         return false;
6067 }
6068
6069 int
6070 Session::freeze_all (InterThreadInfo& itt)
6071 {
6072         boost::shared_ptr<RouteList> r = routes.reader ();
6073
6074         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6075
6076                 boost::shared_ptr<Track> t;
6077
6078                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
6079                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
6080                            of every track.
6081                         */
6082                         t->freeze_me (itt);
6083                 }
6084         }
6085
6086         return 0;
6087 }
6088
6089 boost::shared_ptr<Region>
6090 Session::write_one_track (Track& track, samplepos_t start, samplepos_t end,
6091                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
6092                           InterThreadInfo& itt,
6093                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
6094                           bool for_export, bool for_freeze)
6095 {
6096         boost::shared_ptr<Region> result;
6097         boost::shared_ptr<Playlist> playlist;
6098         boost::shared_ptr<Source> source;
6099         ChanCount diskstream_channels (track.n_channels());
6100         samplepos_t position;
6101         samplecnt_t this_chunk;
6102         samplepos_t to_do;
6103         samplepos_t latency_skip;
6104         BufferSet buffers;
6105         samplepos_t len = end - start;
6106         bool need_block_size_reset = false;
6107         ChanCount const max_proc = track.max_processor_streams ();
6108         string legal_playlist_name;
6109         string possible_path;
6110
6111         if (end <= start) {
6112                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
6113                                          end, start) << endmsg;
6114                 return result;
6115         }
6116
6117         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
6118                         include_endpoint, for_export, for_freeze);
6119
6120         if (diskstream_channels.n(track.data_type()) < 1) {
6121                 error << _("Cannot write a range with no data.") << endmsg;
6122                 return result;
6123         }
6124
6125         // block all process callback handling
6126
6127         block_processing ();
6128
6129         {
6130                 // synchronize with AudioEngine::process_callback()
6131                 // make sure processing is not currently running
6132                 // and processing_blocked() is honored before
6133                 // acquiring thread buffers
6134                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6135         }
6136
6137         _bounce_processing_active = true;
6138
6139         /* call tree *MUST* hold route_lock */
6140
6141         if ((playlist = track.playlist()) == 0) {
6142                 goto out;
6143         }
6144
6145         legal_playlist_name = legalize_for_path (playlist->name());
6146
6147         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
6148
6149                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6150                 string path = ((track.data_type() == DataType::AUDIO)
6151                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6152                                : new_midi_source_path (legal_playlist_name));
6153
6154                 if (path.empty()) {
6155                         goto out;
6156                 }
6157
6158                 try {
6159                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, sample_rate());
6160                 }
6161
6162                 catch (failed_constructor& err) {
6163                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6164                         goto out;
6165                 }
6166
6167                 srcs.push_back (source);
6168         }
6169
6170         /* tell redirects that care that we are about to use a much larger
6171          * blocksize. this will flush all plugins too, so that they are ready
6172          * to be used for this process.
6173          */
6174
6175         need_block_size_reset = true;
6176         track.set_block_size (bounce_chunk_size);
6177         _engine.main_thread()->get_buffers ();
6178
6179         position = start;
6180         to_do = len;
6181         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6182
6183         /* create a set of reasonably-sized buffers */
6184         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6185                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6186         }
6187         buffers.set_count (max_proc);
6188
6189         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6190                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6191                 boost::shared_ptr<MidiSource> ms;
6192                 if (afs) {
6193                         afs->prepare_for_peakfile_writes ();
6194                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6195                         Source::Lock lock(ms->mutex());
6196                         ms->mark_streaming_write_started(lock);
6197                 }
6198         }
6199
6200         while (to_do && !itt.cancel) {
6201
6202                 this_chunk = min (to_do, bounce_chunk_size);
6203
6204                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6205                         goto out;
6206                 }
6207
6208                 start += this_chunk;
6209                 to_do -= this_chunk;
6210                 itt.progress = (float) (1.0 - ((double) to_do / len));
6211
6212                 if (latency_skip >= bounce_chunk_size) {
6213                         latency_skip -= bounce_chunk_size;
6214                         continue;
6215                 }
6216
6217                 const samplecnt_t current_chunk = this_chunk - latency_skip;
6218
6219                 uint32_t n = 0;
6220                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6221                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6222                         boost::shared_ptr<MidiSource> ms;
6223
6224                         if (afs) {
6225                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6226                                         goto out;
6227                                 }
6228                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6229                                 Source::Lock lock(ms->mutex());
6230
6231                                 const MidiBuffer& buf = buffers.get_midi(0);
6232                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6233                                         Evoral::Event<samplepos_t> ev = *i;
6234                                         ev.set_time(ev.time() - position);
6235                                         ms->append_event_samples(lock, ev, ms->timeline_position());
6236                                 }
6237                         }
6238                 }
6239                 latency_skip = 0;
6240         }
6241
6242         /* post-roll, pick up delayed processor output */
6243         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6244
6245         while (latency_skip && !itt.cancel) {
6246                 this_chunk = min (latency_skip, bounce_chunk_size);
6247                 latency_skip -= this_chunk;
6248
6249                 buffers.silence (this_chunk, 0);
6250                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6251
6252                 uint32_t n = 0;
6253                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6254                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6255
6256                         if (afs) {
6257                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6258                                         goto out;
6259                                 }
6260                         }
6261                 }
6262         }
6263
6264         if (!itt.cancel) {
6265
6266                 time_t now;
6267                 struct tm* xnow;
6268                 time (&now);
6269                 xnow = localtime (&now);
6270
6271                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6272                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6273                         boost::shared_ptr<MidiSource> ms;
6274
6275                         if (afs) {
6276                                 afs->update_header (position, *xnow, now);
6277                                 afs->flush_header ();
6278                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6279                                 Source::Lock lock(ms->mutex());
6280                                 ms->mark_streaming_write_completed(lock);
6281                         }
6282                 }
6283
6284                 /* construct a region to represent the bounced material */
6285
6286                 PropertyList plist;
6287
6288                 plist.add (Properties::start, 0);
6289                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6290                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6291
6292                 result = RegionFactory::create (srcs, plist);
6293
6294         }
6295
6296   out:
6297         if (!result) {
6298                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6299                         (*src)->mark_for_remove ();
6300                         (*src)->drop_references ();
6301                 }
6302
6303         } else {
6304                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6305                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6306
6307                         if (afs)
6308                                 afs->done_with_peakfile_writes ();
6309                 }
6310         }
6311
6312         _bounce_processing_active = false;
6313
6314         if (need_block_size_reset) {
6315                 _engine.main_thread()->drop_buffers ();
6316                 track.set_block_size (get_block_size());
6317         }
6318
6319         unblock_processing ();
6320
6321         return result;
6322 }
6323
6324 gain_t*
6325 Session::gain_automation_buffer() const
6326 {
6327         return ProcessThread::gain_automation_buffer ();
6328 }
6329
6330 gain_t*
6331 Session::trim_automation_buffer() const
6332 {
6333         return ProcessThread::trim_automation_buffer ();
6334 }
6335
6336 gain_t*
6337 Session::send_gain_automation_buffer() const
6338 {
6339         return ProcessThread::send_gain_automation_buffer ();
6340 }
6341
6342 gain_t*
6343 Session::scratch_automation_buffer() const
6344 {
6345         return ProcessThread::scratch_automation_buffer ();
6346 }
6347
6348 pan_t**
6349 Session::pan_automation_buffer() const
6350 {
6351         return ProcessThread::pan_automation_buffer ();
6352 }
6353
6354 BufferSet&
6355 Session::get_silent_buffers (ChanCount count)
6356 {
6357         return ProcessThread::get_silent_buffers (count);
6358 }
6359
6360 BufferSet&
6361 Session::get_scratch_buffers (ChanCount count, bool silence)
6362 {
6363         return ProcessThread::get_scratch_buffers (count, silence);
6364 }
6365
6366 BufferSet&
6367 Session::get_noinplace_buffers (ChanCount count)
6368 {
6369         return ProcessThread::get_noinplace_buffers (count);
6370 }
6371
6372 BufferSet&
6373 Session::get_route_buffers (ChanCount count, bool silence)
6374 {
6375         return ProcessThread::get_route_buffers (count, silence);
6376 }
6377
6378
6379 BufferSet&
6380 Session::get_mix_buffers (ChanCount count)
6381 {
6382         return ProcessThread::get_mix_buffers (count);
6383 }
6384
6385 uint32_t
6386 Session::ntracks () const
6387 {
6388         uint32_t n = 0;
6389         boost::shared_ptr<RouteList> r = routes.reader ();
6390
6391         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6392                 if (boost::dynamic_pointer_cast<Track> (*i)) {
6393                         ++n;
6394                 }
6395         }
6396
6397         return n;
6398 }
6399
6400 uint32_t
6401 Session::nbusses () const
6402 {
6403         uint32_t n = 0;
6404         boost::shared_ptr<RouteList> r = routes.reader ();
6405
6406         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6407                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6408                         ++n;
6409                 }
6410         }
6411
6412         return n;
6413 }
6414
6415 uint32_t
6416 Session::nstripables (bool with_monitor) const
6417 {
6418         uint32_t rv = routes.reader()->size ();
6419         rv += _vca_manager->vcas ().size ();
6420
6421         if (with_monitor) {
6422                 return rv;
6423         }
6424
6425         if (_monitor_out) {
6426                 assert (rv > 0);
6427                 --rv;
6428         }
6429         return rv;
6430 }
6431
6432 void
6433 Session::add_automation_list(AutomationList *al)
6434 {
6435         automation_lists[al->id()] = al;
6436 }
6437
6438 /** @return true if there is at least one record-enabled track, otherwise false */
6439 bool
6440 Session::have_rec_enabled_track () const
6441 {
6442         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6443 }
6444
6445 bool
6446 Session::have_rec_disabled_track () const
6447 {
6448     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6449 }
6450
6451 /** Update the state of our rec-enabled tracks flag */
6452 void
6453 Session::update_route_record_state ()
6454 {
6455         boost::shared_ptr<RouteList> rl = routes.reader ();
6456         RouteList::iterator i = rl->begin();
6457         while (i != rl->end ()) {
6458
6459                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6460                                     if (tr && tr->rec_enable_control()->get_value()) {
6461                         break;
6462                 }
6463
6464                 ++i;
6465         }
6466
6467         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6468
6469         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6470
6471         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6472                 RecordStateChanged (); /* EMIT SIGNAL */
6473         }
6474
6475         for (i = rl->begin(); i != rl->end (); ++i) {
6476                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6477                 if (tr && !tr->rec_enable_control()->get_value()) {
6478                         break;
6479                 }
6480         }
6481
6482         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6483
6484         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6485
6486         if (record_status() == Recording && record_arm_state_changed ) {
6487                 RecordArmStateChanged ();
6488         }
6489
6490 }
6491
6492 void
6493 Session::listen_position_changed ()
6494 {
6495         ProcessorChangeBlocker pcb (this);
6496         boost::shared_ptr<RouteList> r = routes.reader ();
6497         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6498                 (*i)->listen_position_changed ();
6499         }
6500 }
6501
6502 void
6503 Session::solo_control_mode_changed ()
6504 {
6505         if (soloing() || listening()) {
6506                 if (loading()) {
6507                         /* We can't use ::clear_all_solo_state() here because during
6508                            session loading at program startup, that will queue a call
6509                            to rt_clear_all_solo_state() that will not execute until
6510                            AFTER solo states have been established (thus throwing away
6511                            the session's saved solo state). So just explicitly turn
6512                            them all off.
6513                         */
6514                         set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6515                 } else {
6516                         clear_all_solo_state (get_routes());
6517                 }
6518         }
6519 }
6520
6521 /** Called when a property of one of our route groups changes */
6522 void
6523 Session::route_group_property_changed (RouteGroup* rg)
6524 {
6525         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6526 }
6527
6528 /** Called when a route is added to one of our route groups */
6529 void
6530 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6531 {
6532         RouteAddedToRouteGroup (rg, r);
6533 }
6534
6535 /** Called when a route is removed from one of our route groups */
6536 void
6537 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6538 {
6539         update_route_record_state ();
6540         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6541
6542         if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6543                 remove_route_group (*rg);
6544         }
6545 }
6546
6547 boost::shared_ptr<RouteList>
6548 Session::get_tracks () const
6549 {
6550         boost::shared_ptr<RouteList> rl = routes.reader ();
6551         boost::shared_ptr<RouteList> tl (new RouteList);
6552
6553         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6554                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6555                         assert (!(*r)->is_auditioner()); // XXX remove me
6556                         tl->push_back (*r);
6557                 }
6558         }
6559         return tl;
6560 }
6561
6562 boost::shared_ptr<RouteList>
6563 Session::get_routes_with_regions_at (samplepos_t const p) const
6564 {
6565         boost::shared_ptr<RouteList> r = routes.reader ();
6566         boost::shared_ptr<RouteList> rl (new RouteList);
6567
6568         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6569                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6570                 if (!tr) {
6571                         continue;
6572                 }
6573
6574                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6575                 if (!pl) {
6576                         continue;
6577                 }
6578
6579                 if (pl->has_region_at (p)) {
6580                         rl->push_back (*i);
6581                 }
6582         }
6583
6584         return rl;
6585 }
6586
6587 void
6588 Session::goto_end ()
6589 {
6590         if (_session_range_location) {
6591                 request_locate (_session_range_location->end(), false);
6592         } else {
6593                 request_locate (0, false);
6594         }
6595 }
6596
6597 void
6598 Session::goto_start (bool and_roll)
6599 {
6600         if (_session_range_location) {
6601                 request_locate (_session_range_location->start(), and_roll);
6602         } else {
6603                 request_locate (0, and_roll);
6604         }
6605 }
6606
6607 samplepos_t
6608 Session::current_start_sample () const
6609 {
6610         return _session_range_location ? _session_range_location->start() : 0;
6611 }
6612
6613 samplepos_t
6614 Session::current_end_sample () const
6615 {
6616         return _session_range_location ? _session_range_location->end() : 0;
6617 }
6618
6619 void
6620 Session::set_session_range_location (samplepos_t start, samplepos_t end)
6621 {
6622         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6623         _locations->add (_session_range_location);
6624 }
6625
6626 void
6627 Session::step_edit_status_change (bool yn)
6628 {
6629         bool send = false;
6630
6631         bool val = false;
6632         if (yn) {
6633                 send = (_step_editors == 0);
6634                 val = true;
6635
6636                 _step_editors++;
6637         } else {
6638                 send = (_step_editors == 1);
6639                 val = false;
6640
6641                 if (_step_editors > 0) {
6642                         _step_editors--;
6643                 }
6644         }
6645
6646         if (send) {
6647                 StepEditStatusChange (val);
6648         }
6649 }
6650
6651
6652 void
6653 Session::start_time_changed (samplepos_t old)
6654 {
6655         /* Update the auto loop range to match the session range
6656            (unless the auto loop range has been changed by the user)
6657         */
6658
6659         Location* s = _locations->session_range_location ();
6660         if (s == 0) {
6661                 return;
6662         }
6663
6664         Location* l = _locations->auto_loop_location ();
6665
6666         if (l && l->start() == old) {
6667                 l->set_start (s->start(), true);
6668         }
6669         set_dirty ();
6670 }
6671
6672 void
6673 Session::end_time_changed (samplepos_t old)
6674 {
6675         /* Update the auto loop range to match the session range
6676            (unless the auto loop range has been changed by the user)
6677         */
6678
6679         Location* s = _locations->session_range_location ();
6680         if (s == 0) {
6681                 return;
6682         }
6683
6684         Location* l = _locations->auto_loop_location ();
6685
6686         if (l && l->end() == old) {
6687                 l->set_end (s->end(), true);
6688         }
6689         set_dirty ();
6690 }
6691
6692 std::vector<std::string>
6693 Session::source_search_path (DataType type) const
6694 {
6695         Searchpath sp;
6696
6697         if (session_dirs.size() == 1) {
6698                 switch (type) {
6699                 case DataType::AUDIO:
6700                         sp.push_back (_session_dir->sound_path());
6701                         break;
6702                 case DataType::MIDI:
6703                         sp.push_back (_session_dir->midi_path());
6704                         break;
6705                 }
6706         } else {
6707                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6708                         SessionDirectory sdir (i->path);
6709                         switch (type) {
6710                         case DataType::AUDIO:
6711                                 sp.push_back (sdir.sound_path());
6712                                 break;
6713                         case DataType::MIDI:
6714                                 sp.push_back (sdir.midi_path());
6715                                 break;
6716                         }
6717                 }
6718         }
6719
6720         if (type == DataType::AUDIO) {
6721                 const string sound_path_2X = _session_dir->sound_path_2X();
6722                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6723                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6724                                 sp.push_back (sound_path_2X);
6725                         }
6726                 }
6727         }
6728
6729         // now check the explicit (possibly user-specified) search path
6730
6731         switch (type) {
6732         case DataType::AUDIO:
6733                 sp += Searchpath(config.get_audio_search_path ());
6734                 break;
6735         case DataType::MIDI:
6736                 sp += Searchpath(config.get_midi_search_path ());
6737                 break;
6738         }
6739
6740         return sp;
6741 }
6742
6743 void
6744 Session::ensure_search_path_includes (const string& path, DataType type)
6745 {
6746         Searchpath sp;
6747
6748         if (path == ".") {
6749                 return;
6750         }
6751
6752         switch (type) {
6753         case DataType::AUDIO:
6754                 sp += Searchpath(config.get_audio_search_path ());
6755                 break;
6756         case DataType::MIDI:
6757                 sp += Searchpath (config.get_midi_search_path ());
6758                 break;
6759         }
6760
6761         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6762                 /* No need to add this new directory if it has the same inode as
6763                    an existing one; checking inode rather than name prevents duplicated
6764                    directories when we are using symlinks.
6765
6766                    On Windows, I think we could just do if (*i == path) here.
6767                 */
6768                 if (PBD::equivalent_paths (*i, path)) {
6769                         return;
6770                 }
6771         }
6772
6773         sp += path;
6774
6775         switch (type) {
6776         case DataType::AUDIO:
6777                 config.set_audio_search_path (sp.to_string());
6778                 break;
6779         case DataType::MIDI:
6780                 config.set_midi_search_path (sp.to_string());
6781                 break;
6782         }
6783 }
6784
6785 void
6786 Session::remove_dir_from_search_path (const string& dir, DataType type)
6787 {
6788         Searchpath sp;
6789
6790         switch (type) {
6791         case DataType::AUDIO:
6792                 sp = Searchpath(config.get_audio_search_path ());
6793                 break;
6794         case DataType::MIDI:
6795                 sp = Searchpath (config.get_midi_search_path ());
6796                 break;
6797         }
6798
6799         sp -= dir;
6800
6801         switch (type) {
6802         case DataType::AUDIO:
6803                 config.set_audio_search_path (sp.to_string());
6804                 break;
6805         case DataType::MIDI:
6806                 config.set_midi_search_path (sp.to_string());
6807                 break;
6808         }
6809
6810 }
6811
6812 boost::shared_ptr<Speakers>
6813 Session::get_speakers()
6814 {
6815         return _speakers;
6816 }
6817
6818 list<string>
6819 Session::unknown_processors () const
6820 {
6821         list<string> p;
6822
6823         boost::shared_ptr<RouteList> r = routes.reader ();
6824         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6825                 list<string> t = (*i)->unknown_processors ();
6826                 copy (t.begin(), t.end(), back_inserter (p));
6827         }
6828
6829         p.sort ();
6830         p.unique ();
6831
6832         return p;
6833 }
6834
6835 void
6836 Session::update_latency (bool playback)
6837 {
6838
6839         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6840
6841         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6842                 return;
6843         }
6844         if (!_engine.running()) {
6845                 return;
6846         }
6847
6848         /* Note; RouteList is sorted as process-graph */
6849         boost::shared_ptr<RouteList> r = routes.reader ();
6850
6851         if (playback) {
6852                 /* reverse the list so that we work backwards from the last route to run to the first */
6853                 RouteList* rl = routes.reader().get();
6854                 r.reset (new RouteList (*rl));
6855                 reverse (r->begin(), r->end());
6856         }
6857
6858         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6859                 samplecnt_t latency = (*i)->set_private_port_latencies (playback);
6860                 (*i)->set_public_port_latencies (latency, playback);
6861         }
6862
6863         if (playback) {
6864                 post_playback_latency ();
6865         } else {
6866                 post_capture_latency ();
6867         }
6868
6869         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6870 }
6871
6872 void
6873 Session::post_playback_latency ()
6874 {
6875         set_worst_playback_latency ();
6876
6877         boost::shared_ptr<RouteList> r = routes.reader ();
6878
6879         _worst_track_out_latency = 0; // XXX remove me
6880
6881         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6882                 assert (!(*i)->is_auditioner()); // XXX remove me
6883                 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6884         }
6885
6886         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6887                 if (!(*i)->active()) { continue ; }
6888                 (*i)->apply_latency_compensation ();
6889         }
6890 }
6891
6892 void
6893 Session::post_capture_latency ()
6894 {
6895         set_worst_capture_latency ();
6896
6897         /* reflect any changes in capture latencies into capture offsets */
6898
6899         boost::shared_ptr<RouteList> rl = routes.reader();
6900         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6901                 (*i)->update_signal_latency ();
6902         }
6903 }
6904
6905 void
6906 Session::initialize_latencies ()
6907 {
6908         {
6909                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6910                 update_latency (false);
6911                 update_latency (true);
6912         }
6913
6914         set_worst_io_latencies ();
6915 }
6916
6917 void
6918 Session::set_worst_io_latencies ()
6919 {
6920         set_worst_playback_latency ();
6921         set_worst_capture_latency ();
6922 }
6923
6924 void
6925 Session::set_worst_playback_latency ()
6926 {
6927         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6928                 return;
6929         }
6930
6931         _worst_output_latency = 0;
6932
6933         if (!_engine.connected()) {
6934                 return;
6935         }
6936
6937         boost::shared_ptr<RouteList> r = routes.reader ();
6938
6939         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6940                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6941         }
6942
6943         _worst_output_latency = max (_worst_output_latency, _click_io->latency());
6944
6945         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6946 }
6947
6948 void
6949 Session::set_worst_capture_latency ()
6950 {
6951         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6952                 return;
6953         }
6954
6955         _worst_input_latency = 0;
6956
6957         if (!_engine.connected()) {
6958                 return;
6959         }
6960
6961         boost::shared_ptr<RouteList> r = routes.reader ();
6962
6963         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6964                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6965                 if (!tr) {
6966                         continue;
6967                 }
6968                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6969         }
6970
6971         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6972 }
6973
6974 void
6975 Session::update_latency_compensation (bool force_whole_graph)
6976 {
6977         // TODO: consolidate
6978         bool some_track_latency_changed = false;
6979
6980         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6981                 return;
6982         }
6983
6984         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6985
6986         _worst_track_latency = 0;
6987
6988         boost::shared_ptr<RouteList> r = routes.reader ();
6989
6990         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6991                 assert (!(*i)->is_auditioner()); // XXX remove me
6992                 if ((*i)->active()) {
6993                         samplecnt_t tl;
6994                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency () /* - (*i)->output()->user_latency()*/)) {
6995                                 some_track_latency_changed = true;
6996                         }
6997                         _worst_track_latency = max (tl, _worst_track_latency);
6998                 }
6999         }
7000
7001         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
7002                                                      (some_track_latency_changed ? "yes" : "no")));
7003
7004         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
7005
7006         if (some_track_latency_changed || force_whole_graph)  {
7007                 _engine.update_latencies ();
7008         }
7009
7010         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7011                 (*i)->update_signal_latency (true);
7012         }
7013 }
7014
7015 char
7016 Session::session_name_is_legal (const string& path)
7017 {
7018         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
7019
7020         for (int i = 0; illegal_chars[i]; ++i) {
7021                 if (path.find (illegal_chars[i]) != string::npos) {
7022                         return illegal_chars[i];
7023                 }
7024         }
7025
7026         return 0;
7027 }
7028
7029 void
7030 Session::notify_presentation_info_change ()
7031 {
7032         if (deletion_in_progress()) {
7033                 return;
7034         }
7035
7036         reassign_track_numbers();
7037
7038 #ifdef USE_TRACKS_CODE_FEATURES
7039         /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
7040          * if track order has been changed by user
7041          */
7042         reconnect_existing_routes(true, true);
7043 #endif
7044
7045 }
7046
7047 bool
7048 Session::operation_in_progress (GQuark op) const
7049 {
7050         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
7051 }
7052
7053 boost::shared_ptr<Port>
7054 Session::ltc_input_port () const
7055 {
7056         assert (_ltc_input);
7057         return _ltc_input->nth (0);
7058 }
7059
7060 boost::shared_ptr<Port>
7061 Session::ltc_output_port () const
7062 {
7063         return _ltc_output ? _ltc_output->nth (0) : boost::shared_ptr<Port> ();
7064 }
7065
7066 void
7067 Session::reconnect_ltc_input ()
7068 {
7069         if (_ltc_input) {
7070
7071                 string src = Config->get_ltc_source_port();
7072
7073                 _ltc_input->disconnect (this);
7074
7075                 if (src != _("None") && !src.empty())  {
7076                         _ltc_input->nth (0)->connect (src);
7077                 }
7078
7079                 if ( ARDOUR::Profile->get_trx () ) {
7080                         // Tracks need this signal to update timecode_source_dropdown
7081                         MtcOrLtcInputPortChanged (); //emit signal
7082                 }
7083         }
7084 }
7085
7086 void
7087 Session::reconnect_ltc_output ()
7088 {
7089         if (_ltc_output) {
7090
7091                 string src = Config->get_ltc_output_port();
7092
7093                 _ltc_output->disconnect (this);
7094
7095                 if (src != _("None") && !src.empty())  {
7096                         _ltc_output->nth (0)->connect (src);
7097                 }
7098         }
7099 }
7100
7101 void
7102 Session::set_range_selection (samplepos_t start, samplepos_t end)
7103 {
7104         _range_selection = Evoral::Range<samplepos_t> (start, end);
7105 #ifdef USE_TRACKS_CODE_FEATURES
7106         follow_playhead_priority ();
7107 #endif
7108 }
7109
7110 void
7111 Session::set_object_selection (samplepos_t start, samplepos_t end)
7112 {
7113         _object_selection = Evoral::Range<samplepos_t> (start, end);
7114 #ifdef USE_TRACKS_CODE_FEATURES
7115         follow_playhead_priority ();
7116 #endif
7117 }
7118
7119 void
7120 Session::clear_range_selection ()
7121 {
7122         _range_selection = Evoral::Range<samplepos_t> (-1,-1);
7123 #ifdef USE_TRACKS_CODE_FEATURES
7124         follow_playhead_priority ();
7125 #endif
7126 }
7127
7128 void
7129 Session::clear_object_selection ()
7130 {
7131         _object_selection = Evoral::Range<samplepos_t> (-1,-1);
7132 #ifdef USE_TRACKS_CODE_FEATURES
7133         follow_playhead_priority ();
7134 #endif
7135 }
7136
7137 void
7138 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
7139                 const ChanCount& input_start,
7140                 const ChanCount& output_start,
7141                 const ChanCount& input_offset,
7142                 const ChanCount& output_offset)
7143 {
7144         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7145         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7146                                 input_start, output_start,
7147                                 input_offset, output_offset));
7148
7149         auto_connect_thread_wakeup ();
7150 }
7151
7152 void
7153 Session::auto_connect_thread_wakeup ()
7154 {
7155         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7156                 pthread_cond_signal (&_auto_connect_cond);
7157                 pthread_mutex_unlock (&_auto_connect_mutex);
7158         }
7159 }
7160
7161 void
7162 Session::queue_latency_recompute ()
7163 {
7164         g_atomic_int_inc (&_latency_recompute_pending);
7165         auto_connect_thread_wakeup ();
7166 }
7167
7168 void
7169 Session::auto_connect (const AutoConnectRequest& ar)
7170 {
7171         boost::shared_ptr<Route> route = ar.route.lock();
7172
7173         if (!route) { return; }
7174
7175         if (!IO::connecting_legal) {
7176                 return;
7177         }
7178
7179         /* If both inputs and outputs are auto-connected to physical ports,
7180          * use the max of input and output offsets to ensure auto-connected
7181          * port numbers always match up (e.g. the first audio input and the
7182          * first audio output of the route will have the same physical
7183          * port number).  Otherwise just use the lowest input or output
7184          * offset possible.
7185          */
7186
7187         const bool in_out_physical =
7188                 (Config->get_input_auto_connect() & AutoConnectPhysical)
7189                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7190                 && ar.connect_inputs;
7191
7192         const ChanCount in_offset = in_out_physical
7193                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7194                 : ar.input_offset;
7195
7196         const ChanCount out_offset = in_out_physical
7197                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7198                 : ar.output_offset;
7199
7200         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7201                 vector<string> physinputs;
7202                 vector<string> physoutputs;
7203
7204
7205                 /* for connecting track inputs we only want MIDI ports marked
7206                  * for "music".
7207                  */
7208
7209                 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7210
7211                 if (!physinputs.empty() && ar.connect_inputs) {
7212                         uint32_t nphysical_in = physinputs.size();
7213
7214                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7215                                 string port;
7216
7217                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7218                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7219                                 }
7220
7221                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7222                                         break;
7223                                 }
7224                         }
7225                 }
7226
7227                 if (!physoutputs.empty()) {
7228                         uint32_t nphysical_out = physoutputs.size();
7229                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7230                                 string port;
7231
7232                                 /* Waves Tracks:
7233                                  * do not create new connections if we reached the limit of physical outputs
7234                                  * in Multi Out mode
7235                                  */
7236                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7237                                                 ARDOUR::Profile->get_trx () &&
7238                                                 ar.output_offset.get(*t) == nphysical_out ) {
7239                                         break;
7240                                 }
7241
7242                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7243                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7244                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7245                                         /* master bus is audio only */
7246                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7247                                                 port = _master_out->input()->ports().port(*t,
7248                                                                 i % _master_out->input()->n_ports().get(*t))->name();
7249                                         }
7250                                 }
7251
7252                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7253                                         break;
7254                                 }
7255                         }
7256                 }
7257         }
7258 }
7259
7260 void
7261 Session::auto_connect_thread_start ()
7262 {
7263         if (g_atomic_int_get (&_ac_thread_active)) {
7264                 return;
7265         }
7266
7267         while (!_auto_connect_queue.empty ()) {
7268                 _auto_connect_queue.pop ();
7269         }
7270
7271         g_atomic_int_set (&_ac_thread_active, 1);
7272         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7273                 g_atomic_int_set (&_ac_thread_active, 0);
7274         }
7275 }
7276
7277 void
7278 Session::auto_connect_thread_terminate ()
7279 {
7280         if (!g_atomic_int_get (&_ac_thread_active)) {
7281                 return;
7282         }
7283
7284         {
7285                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7286                 while (!_auto_connect_queue.empty ()) {
7287                         _auto_connect_queue.pop ();
7288                 }
7289         }
7290
7291         /* cannot use auto_connect_thread_wakeup() because that is allowed to
7292          * fail to wakeup the thread.
7293          */
7294
7295         pthread_mutex_lock (&_auto_connect_mutex);
7296         g_atomic_int_set (&_ac_thread_active, 0);
7297         pthread_cond_signal (&_auto_connect_cond);
7298         pthread_mutex_unlock (&_auto_connect_mutex);
7299
7300         void *status;
7301         pthread_join (_auto_connect_thread, &status);
7302 }
7303
7304 void *
7305 Session::auto_connect_thread (void *arg)
7306 {
7307         Session *s = static_cast<Session *>(arg);
7308         s->auto_connect_thread_run ();
7309         pthread_exit (0);
7310         return 0;
7311 }
7312
7313 void
7314 Session::auto_connect_thread_run ()
7315 {
7316         pthread_set_name (X_("autoconnect"));
7317         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7318         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7319         pthread_mutex_lock (&_auto_connect_mutex);
7320         while (g_atomic_int_get (&_ac_thread_active)) {
7321
7322                 if (!_auto_connect_queue.empty ()) {
7323                         // Why would we need the process lock ??
7324                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7325                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7326                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
7327                         //   We have control over those, but what does jack do?
7328                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7329
7330                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7331                         while (!_auto_connect_queue.empty ()) {
7332                                 const AutoConnectRequest ar (_auto_connect_queue.front());
7333                                 _auto_connect_queue.pop ();
7334                                 lx.release ();
7335                                 auto_connect (ar);
7336                                 lx.acquire ();
7337                         }
7338                 }
7339
7340                 if (!actively_recording ()) { // might not be needed,
7341                         /* this is only used for updating plugin latencies, the
7342                          * graph does not change. so it's safe in general.
7343                          * BUT..
7344                          * update_latency_compensation ()
7345                          * calls DiskWriter::set_capture_offset () which
7346                          * modifies the capture-offset, which can be a problem.
7347                          */
7348                         while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7349                                 update_latency_compensation ();
7350                         }
7351                 }
7352
7353                 {
7354                         // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7355                         // jack1 cannot cope with removing ports while processing
7356                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7357                         AudioEngine::instance()->clear_pending_port_deletions ();
7358                 }
7359
7360                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7361         }
7362         pthread_mutex_unlock (&_auto_connect_mutex);
7363 }
7364
7365 void
7366 Session::cancel_all_solo ()
7367 {
7368         StripableList sl;
7369
7370         get_stripables (sl);
7371
7372         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7373         clear_all_solo_state (routes.reader());
7374 }