libs/ardour/session.cc

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