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