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 {
3261                         add_routes (ret, false, true, true, order); // autoconnect // outputs only
3262                 }
3263         }
3264
3265         return ret;
3266
3267 }
3268
3269 RouteList
3270 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3271                                   PlaylistDisposition pd)
3272 {
3273         XMLTree tree;
3274
3275         if (!tree.read (template_path.c_str())) {
3276                 return RouteList();
3277         }
3278
3279         return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3280 }
3281
3282 RouteList
3283 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3284 {
3285         RouteList ret;
3286         uint32_t number = 0;
3287         const uint32_t being_added = how_many;
3288         /* This will prevent the use of any existing XML-provided PBD::ID
3289            values by Stateful.
3290         */
3291         Stateful::ForceIDRegeneration force_ids;
3292         IO::disable_connecting ();
3293
3294         while (how_many) {
3295
3296                 /* We're going to modify the node contents a bit so take a
3297                  * copy. The node may be re-used when duplicating more than once.
3298                  */
3299
3300                 XMLNode node_copy (node);
3301
3302                 try {
3303                         string name;
3304
3305                         if (!name_base.empty()) {
3306
3307                                 /* if we're adding more than one routes, force
3308                                  * all the names of the new routes to be
3309                                  * numbered, via the final parameter.
3310                                  */
3311
3312                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3313                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3314                                         /*NOTREACHDE*/
3315                                 }
3316
3317                         } else {
3318
3319                                 string const route_name  = node_copy.property(X_("name"))->value ();
3320
3321                                 /* generate a new name by adding a number to the end of the template name */
3322                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3323                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3324                                         abort(); /*NOTREACHED*/
3325                                 }
3326                         }
3327
3328                         /* set this name in the XML description that we are about to use */
3329 #warning fixme -- no more Diskstream
3330                         if (pd == CopyPlaylist) {
3331                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3332                                 if (ds_node) {
3333                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3334                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3335                                         // Use same name as Route::set_name_in_state so playlist copy
3336                                         // is picked up when creating the Route in XMLRouteFactory below
3337                                         playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3338                                         playlist->reset_shares ();
3339                                 }
3340                         } else if (pd == SharePlaylist) {
3341                                 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3342                                 if (ds_node) {
3343                                         const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3344                                         boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3345                                         playlist->share_with ((node_copy.property (X_("id")))->value());
3346                                 }
3347                         }
3348
3349                         bool rename_playlist = (pd == CopyPlaylist || pd == NewPlaylist);
3350
3351                         Route::set_name_in_state (node_copy, name, rename_playlist);
3352
3353                         /* trim bitslots from listen sends so that new ones are used */
3354                         XMLNodeList children = node_copy.children ();
3355                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3356                                 if ((*i)->name() == X_("Processor")) {
3357                                         /* ForceIDRegeneration does not catch the following */
3358                                         XMLProperty const * role = (*i)->property (X_("role"));
3359                                         XMLProperty const * type = (*i)->property (X_("type"));
3360                                         if (role && role->value() == X_("Aux")) {
3361                                                 /* check if the target bus exists.
3362                                                  * we should not save aux-sends in templates.
3363                                                  */
3364                                                 XMLProperty const * target = (*i)->property (X_("target"));
3365                                                 if (!target) {
3366                                                         (*i)->set_property ("type", "dangling-aux-send");
3367                                                         continue;
3368                                                 }
3369                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3370                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3371                                                         (*i)->set_property ("type", "dangling-aux-send");
3372                                                         continue;
3373                                                 }
3374                                         }
3375                                         if (role && role->value() == X_("Listen")) {
3376                                                 (*i)->remove_property (X_("bitslot"));
3377                                         }
3378                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3379                                                 Delivery::Role xrole;
3380                                                 uint32_t bitslot = 0;
3381                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3382                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3383                                                 (*i)->remove_property (X_("bitslot"));
3384                                                 (*i)->remove_property (X_("name"));
3385                                                 (*i)->set_property ("bitslot", bitslot);
3386                                                 (*i)->set_property ("name", name);
3387                                         }
3388                                         else if (type && type->value() == X_("intreturn")) {
3389                                                 (*i)->remove_property (X_("bitslot"));
3390                                                 (*i)->set_property ("ignore-bitslot", "1");
3391                                         }
3392                                         else if (type && type->value() == X_("return")) {
3393                                                 // Return::set_state() generates a new one
3394                                                 (*i)->remove_property (X_("bitslot"));
3395                                         }
3396                                         else if (type && type->value() == X_("port")) {
3397                                                 IOProcessor::prepare_for_reset (**i, name);
3398                                         }
3399                                 }
3400                         }
3401
3402                         /* new routes start off unsoloed to avoid issues related to
3403                            upstream / downstream buses. */
3404                         node_copy.remove_node_and_delete (X_("Controllable"), X_("name"), X_("solo"));
3405
3406                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3407
3408                         if (route == 0) {
3409                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3410                                 goto out;
3411                         }
3412
3413                         if (boost::dynamic_pointer_cast<Track>(route)) {
3414                                 /* force input/output change signals so that the new diskstream
3415                                    picks up the configuration of the route. During session
3416                                    loading this normally happens in a different way.
3417                                 */
3418
3419                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3420
3421                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3422                                 change.after = route->input()->n_ports();
3423                                 route->input()->changed (change, this);
3424                                 change.after = route->output()->n_ports();
3425                                 route->output()->changed (change, this);
3426                         }
3427
3428                         ret.push_back (route);
3429                 }
3430
3431                 catch (failed_constructor &err) {
3432                         error << _("Session: could not create new route from template") << endmsg;
3433                         goto out;
3434                 }
3435
3436                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3437                         error << pfe.what() << endmsg;
3438                         goto out;
3439                 }
3440
3441                 --how_many;
3442         }
3443
3444   out:
3445         if (!ret.empty()) {
3446                 StateProtector sp (this);
3447                 if (Profile->get_trx()) {
3448                         add_routes (ret, false, false, false, insert_at);
3449                 } else {
3450                         add_routes (ret, true, true, false, insert_at);
3451                 }
3452                 IO::enable_connecting ();
3453         }
3454
3455         return ret;
3456 }
3457
3458 void
3459 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3460 {
3461         try {
3462                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3463                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3464
3465         } catch (...) {
3466                 error << _("Adding new tracks/busses failed") << endmsg;
3467         }
3468
3469         graph_reordered ();
3470
3471         update_latency (false);
3472         update_latency (true);
3473
3474         set_dirty();
3475
3476         if (save) {
3477                 save_state (_current_snapshot_name);
3478         }
3479
3480         update_route_record_state ();
3481
3482         RouteAdded (new_routes); /* EMIT SIGNAL */
3483 }
3484
3485 void
3486 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3487 {
3488         ChanCount existing_inputs;
3489         ChanCount existing_outputs;
3490         uint32_t n_routes;
3491         uint32_t added = 0;
3492
3493         count_existing_track_channels (existing_inputs, existing_outputs);
3494
3495         {
3496                 RCUWriter<RouteList> writer (routes);
3497                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3498                 n_routes = r->size();
3499                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3500
3501                 /* if there is no control out and we're not in the middle of loading,
3502                  * resort the graph here. if there is a control out, we will resort
3503                  * toward the end of this method. if we are in the middle of loading,
3504                  * we will resort when done.
3505                  */
3506
3507                 if (!_monitor_out && IO::connecting_legal) {
3508                         resort_routes_using (r);
3509                 }
3510         }
3511
3512         /* monitor is not part of the order */
3513         if (_monitor_out) {
3514                 assert (n_routes > 0);
3515                 --n_routes;
3516         }
3517
3518         {
3519                 PresentationInfo::ChangeSuspender cs;
3520                 ensure_route_presentation_info_gap (order, new_routes.size());
3521
3522                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3523
3524                         boost::weak_ptr<Route> wpr (*x);
3525                         boost::shared_ptr<Route> r (*x);
3526
3527                         r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3528                         r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3529                         r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3530
3531                         r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3532                         r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3533                         r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3534
3535                         if (r->is_master()) {
3536                                 _master_out = r;
3537                         }
3538
3539                         if (r->is_monitor()) {
3540                                 _monitor_out = r;
3541                         }
3542
3543                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3544                         if (tr) {
3545                                 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3546                                 track_playlist_changed (boost::weak_ptr<Track> (tr));
3547                                 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3548
3549                                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3550                                 if (mt) {
3551                                         mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3552                                         mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3553                                         mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3554                                 }
3555                         }
3556
3557                         if (!r->presentation_info().special (false)) {
3558
3559                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3560
3561                                 /* presentation info order may already have been set from XML */
3562
3563                                 if (!r->presentation_info().order_set()) {
3564                                         if (order == PresentationInfo::max_order) {
3565                                                 /* just add to the end */
3566                                                 r->set_presentation_order (n_routes + added);
3567                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3568                                         } else {
3569                                                 r->set_presentation_order (order + added);
3570                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3571                                         }
3572                                 } else {
3573                                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3574                                 }
3575                         }
3576
3577 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3578                         /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3579                          * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3580                          */
3581                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3582                                                                        r->name(),
3583                                                                        r->presentation_info().order(),
3584                                                                        enum_2_string (r->presentation_info().flags()),
3585                                                                        r->presentation_info()));
3586 #endif
3587
3588
3589                         if (input_auto_connect || output_auto_connect) {
3590                                 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3591                                 existing_inputs += r->n_inputs();
3592                                 existing_outputs += r->n_outputs();
3593                         }
3594
3595                         ARDOUR::GUIIdle ();
3596                 }
3597                 ensure_stripable_sort_order ();
3598         }
3599
3600         if (_monitor_out && IO::connecting_legal) {
3601                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3602
3603                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3604                         if ((*x)->is_monitor()) {
3605                                 /* relax */
3606                         } else if ((*x)->is_master()) {
3607                                 /* relax */
3608                         } else {
3609                                 (*x)->enable_monitor_send ();
3610                         }
3611                 }
3612         }
3613
3614         reassign_track_numbers ();
3615 }
3616
3617 void
3618 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3619 {
3620         boost::shared_ptr<RouteList> r = routes.reader ();
3621         boost::shared_ptr<Send> s;
3622
3623         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3624                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3625                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3626                 }
3627         }
3628 }
3629
3630 void
3631 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3632 {
3633         boost::shared_ptr<RouteList> r = routes.reader ();
3634         boost::shared_ptr<Send> s;
3635
3636         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3637                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3638                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3639                 }
3640         }
3641 }
3642
3643 void
3644 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3645 {
3646         boost::shared_ptr<RouteList> r = routes.reader ();
3647         boost::shared_ptr<Send> s;
3648
3649         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3650                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3651                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3652                 }
3653         }
3654 }
3655
3656 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3657 void
3658 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3659 {
3660         boost::shared_ptr<RouteList> r = routes.reader ();
3661         boost::shared_ptr<RouteList> t (new RouteList);
3662
3663         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3664                 /* no MIDI sends because there are no MIDI busses yet */
3665                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3666                         t->push_back (*i);
3667                 }
3668         }
3669
3670         add_internal_sends (dest, p, t);
3671 }
3672
3673 void
3674 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3675 {
3676         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3677                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3678         }
3679 }
3680
3681 void
3682 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3683 {
3684         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3685 }
3686
3687 void
3688 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3689 {
3690         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3691                 return;
3692         }
3693
3694         if (!dest->internal_return()) {
3695                 dest->add_internal_return ();
3696         }
3697
3698         sender->add_aux_send (dest, before);
3699
3700         graph_reordered ();
3701 }
3702
3703 void
3704 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3705 {
3706         bool mute_changed = false;
3707         bool send_selected = false;
3708
3709         { // RCU Writer scope
3710                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3711                 RCUWriter<RouteList> writer (routes);
3712                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3713
3714                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3715
3716                         if (_selection->selected (*iter)) {
3717                                 send_selected = true;
3718                         }
3719
3720                         if (*iter == _master_out) {
3721                                 continue;
3722                         }
3723
3724                         /* speed up session deletion, don't do the solo dance */
3725                         if (0 == (_state_of_the_state & Deletion)) {
3726                                 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3727                         }
3728
3729                         if ((*iter)->mute_control()->muted ()) {
3730                                 mute_changed = true;
3731                         }
3732
3733                         rs->remove (*iter);
3734
3735                         /* deleting the master out seems like a dumb
3736                            idea, but its more of a UI policy issue
3737                            than our concern.
3738                         */
3739
3740                         if (*iter == _master_out) {
3741                                 _master_out = boost::shared_ptr<Route> ();
3742                         }
3743
3744                         if (*iter == _monitor_out) {
3745                                 _monitor_out.reset ();
3746                         }
3747
3748                         // We need to disconnect the route's inputs and outputs
3749
3750                         (*iter)->input()->disconnect (0);
3751                         (*iter)->output()->disconnect (0);
3752
3753                         /* if the route had internal sends sending to it, remove them */
3754                         if ((*iter)->internal_return()) {
3755
3756                                 boost::shared_ptr<RouteList> r = routes.reader ();
3757                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3758                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3759                                         if (s) {
3760                                                 (*i)->remove_processor (s);
3761                                         }
3762                                 }
3763                         }
3764
3765                         /* if the monitoring section had a pointer to this route, remove it */
3766                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3767                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3768                                 ProcessorChangeBlocker pcb (this, false);
3769                                 (*iter)->remove_aux_or_listen (_monitor_out);
3770                         }
3771
3772                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3773                         if (mt && mt->step_editing()) {
3774                                 if (_step_editors > 0) {
3775                                         _step_editors--;
3776                                 }
3777                         }
3778                 }
3779
3780                 /* writer goes out of scope, forces route list update */
3781
3782         } // end of RCU Writer scope
3783
3784         if (mute_changed) {
3785                 MuteChanged (); /* EMIT SIGNAL */
3786         }
3787
3788         update_route_solo_state ();
3789         update_latency_compensation ();
3790         set_dirty();
3791
3792         /* Re-sort routes to remove the graph's current references to the one that is
3793          * going away, then flush old references out of the graph.
3794          * Wave Tracks: reconnect routes
3795          */
3796
3797 #ifdef USE_TRACKS_CODE_FEATURES
3798                 reconnect_existing_routes(true, false);
3799 #else
3800                 routes.flush (); // maybe unsafe, see below.
3801                 resort_routes ();
3802 #endif
3803
3804         if (_process_graph && !(_state_of_the_state & Deletion)) {
3805                 _process_graph->clear_other_chain ();
3806         }
3807
3808         /* get rid of it from the dead wood collection in the route list manager */
3809         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3810
3811         routes.flush ();
3812
3813         /* remove these routes from the selection if appropriate, and signal
3814          * the change *before* we call DropReferences for them.
3815          */
3816
3817         if (send_selected && !deletion_in_progress()) {
3818                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3819                         _selection->remove_stripable_by_id ((*iter)->id());
3820                 }
3821                 PropertyChange pc;
3822                 pc.add (Properties::selected);
3823                 PresentationInfo::Change (pc);
3824         }
3825
3826         /* try to cause everyone to drop their references
3827          * and unregister ports from the backend
3828          */
3829
3830         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3831                 (*iter)->drop_references ();
3832         }
3833
3834         if (deletion_in_progress()) {
3835                 return;
3836         }
3837
3838         PropertyChange pc;
3839         pc.add (Properties::order);
3840         PresentationInfo::Change (pc);
3841
3842         /* save the new state of the world */
3843
3844         if (save_state (_current_snapshot_name)) {
3845                 save_history (_current_snapshot_name);
3846         }
3847
3848         update_route_record_state ();
3849 }
3850
3851 void
3852 Session::remove_route (boost::shared_ptr<Route> route)
3853 {
3854         boost::shared_ptr<RouteList> rl (new RouteList);
3855         rl->push_back (route);
3856         remove_routes (rl);
3857 }
3858
3859 void
3860 Session::route_mute_changed ()
3861 {
3862         MuteChanged (); /* EMIT SIGNAL */
3863         set_dirty ();
3864 }
3865
3866 void
3867 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3868 {
3869         boost::shared_ptr<Route> route (wpr.lock());
3870
3871         if (!route) {
3872                 return;
3873         }
3874
3875         assert (Config->get_solo_control_is_listen_control());
3876
3877         if (route->solo_control()->soloed_by_self_or_masters()) {
3878
3879                 if (Config->get_exclusive_solo()) {
3880
3881                         RouteGroup* rg = route->route_group ();
3882                         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3883
3884                         boost::shared_ptr<RouteList> r = routes.reader ();
3885
3886                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3887                                 if ((*i) == route) {
3888                                         /* already changed */
3889                                         continue;
3890                                 }
3891
3892                                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3893                                         /* route does not get solo propagated to it */
3894                                         continue;
3895                                 }
3896
3897                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3898                                         /* this route is a part of the same solo group as the route
3899                                          * that was changed. Changing that route did change or will
3900                                          * change all group members appropriately, so we can ignore it
3901                                          * here
3902                                          */
3903                                         continue;
3904                                 }
3905                                 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3906                         }
3907                 }
3908
3909                 _listen_cnt++;
3910
3911         } else if (_listen_cnt > 0) {
3912
3913                 _listen_cnt--;
3914         }
3915 }
3916
3917 void
3918 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3919 {
3920         boost::shared_ptr<Route> route (wpr.lock());
3921
3922         if (!route) {
3923                 return;
3924         }
3925
3926         bool send_changed = false;
3927
3928         if (route->solo_isolate_control()->solo_isolated()) {
3929                 if (_solo_isolated_cnt == 0) {
3930                         send_changed = true;
3931                 }
3932                 _solo_isolated_cnt++;
3933         } else if (_solo_isolated_cnt > 0) {
3934                 _solo_isolated_cnt--;
3935                 if (_solo_isolated_cnt == 0) {
3936                         send_changed = true;
3937                 }
3938         }
3939
3940         if (send_changed) {
3941                 IsolatedChanged (); /* EMIT SIGNAL */
3942         }
3943 }
3944
3945 void
3946 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
3947 {
3948         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
3949
3950         boost::shared_ptr<Route> route (wpr.lock());
3951
3952         if (!route) {
3953                 return;
3954         }
3955
3956         if (Config->get_solo_control_is_listen_control()) {
3957                 route_listen_changed (group_override, wpr);
3958                 return;
3959         }
3960
3961         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()));
3962
3963         if (route->solo_control()->transitioned_into_solo() == 0) {
3964                 /* route solo changed by upstream/downstream or clear all solo state; not interesting
3965                    to Session.
3966                 */
3967                 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()));
3968                 return;
3969         }
3970
3971         boost::shared_ptr<RouteList> r = routes.reader ();
3972         int32_t delta = route->solo_control()->transitioned_into_solo ();
3973
3974         /* the route may be a member of a group that has shared-solo
3975          * semantics. If so, then all members of that group should follow the
3976          * solo of the changed route. But ... this is optional, controlled by a
3977          * Controllable::GroupControlDisposition.
3978          *
3979          * The first argument to the signal that this method is connected to is the
3980          * GroupControlDisposition value that was used to change solo.
3981          *
3982          * If the solo change was done with group semantics (either InverseGroup
3983          * (force the entire group to change even if the group shared solo is
3984          * disabled) or UseGroup (use the group, which may or may not have the
3985          * shared solo property enabled)) then as we propagate the change to
3986          * the entire session we should IGNORE THE GROUP that the changed route
3987          * belongs to.
3988          */
3989
3990         RouteGroup* rg = route->route_group ();
3991         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3992
3993         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
3994
3995         if (delta == 1 && Config->get_exclusive_solo()) {
3996
3997                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3998
3999                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4000
4001                         if ((*i) == route) {
4002                                 /* already changed */
4003                                 continue;
4004                         }
4005
4006                         if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4007                                 /* route does not get solo propagated to it */
4008                                 continue;
4009                         }
4010
4011                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4012                                 /* this route is a part of the same solo group as the route
4013                                  * that was changed. Changing that route did change or will
4014                                  * change all group members appropriately, so we can ignore it
4015                                  * here
4016                                  */
4017                                 continue;
4018                         }
4019
4020                         (*i)->solo_control()->set_value (0.0, group_override);
4021                 }
4022         }
4023
4024         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4025
4026         RouteList uninvolved;
4027
4028         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4029
4030         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4031                 bool via_sends_only;
4032                 bool in_signal_flow;
4033
4034                 if ((*i) == route) {
4035                         /* already changed */
4036                         continue;
4037                 }
4038
4039                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4040                         /* route does not get solo propagated to it */
4041                         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(),
4042                                                                   (*i)->can_solo()));
4043                         continue;
4044                 }
4045
4046                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4047                         /* this route is a part of the same solo group as the route
4048                          * that was changed. Changing that route did change or will
4049                          * change all group members appropriately, so we can ignore it
4050                          * here
4051                          */
4052                         continue;
4053                 }
4054
4055                 in_signal_flow = false;
4056
4057                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4058
4059                 if ((*i)->feeds (route, &via_sends_only)) {
4060                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4061                         if (!via_sends_only) {
4062                                 if (!route->soloed_by_others_upstream()) {
4063                                         (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4064                                 } else {
4065                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4066                                 }
4067                         } else {
4068                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4069                         }
4070                         in_signal_flow = true;
4071                 } else {
4072                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4073                 }
4074
4075                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4076
4077                 if (route->feeds (*i, &via_sends_only)) {
4078                         /* propagate solo upstream only if routing other than
4079                            sends is involved, but do consider the other route
4080                            (*i) to be part of the signal flow even if only
4081                            sends are involved.
4082                         */
4083                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4084                                                                   route->name(),
4085                                                                   (*i)->name(),
4086                                                                   via_sends_only,
4087                                                                   route->soloed_by_others_downstream(),
4088                                                                   route->soloed_by_others_upstream()));
4089                         if (!via_sends_only) {
4090                                 //NB. Triggers Invert Push, which handles soloed by downstream
4091                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4092                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4093                         } else {
4094                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4095                         }
4096                         in_signal_flow = true;
4097                 } else {
4098                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
4099                 }
4100
4101                 if (!in_signal_flow) {
4102                         uninvolved.push_back (*i);
4103                 }
4104         }
4105
4106         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4107
4108         /* now notify that the mute state of the routes not involved in the signal
4109            pathway of the just-solo-changed route may have altered.
4110         */
4111
4112         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4113                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4114                 (*i)->act_on_mute ();
4115                 /* Session will emit SoloChanged() after all solo changes are
4116                  * complete, which should be used by UIs to update mute status
4117                  */
4118         }
4119 }
4120
4121 void
4122 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4123 {
4124         /* now figure out if anything that matters is soloed (or is "listening")*/
4125
4126         bool something_soloed = false;
4127         bool something_listening = false;
4128         uint32_t listeners = 0;
4129         uint32_t isolated = 0;
4130
4131         if (!r) {
4132                 r = routes.reader();
4133         }
4134
4135         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4136                 if ((*i)->can_solo()) {
4137                         if (Config->get_solo_control_is_listen_control()) {
4138                                 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4139                                         listeners++;
4140                                         something_listening = true;
4141                                 }
4142                         } else {
4143                                 (*i)->set_listen (false);
4144                                 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4145                                         something_soloed = true;
4146                                 }
4147                         }
4148                 }
4149
4150                 if ((*i)->solo_isolate_control()->solo_isolated()) {
4151                         isolated++;
4152                 }
4153         }
4154
4155         if (something_soloed != _non_soloed_outs_muted) {
4156                 _non_soloed_outs_muted = something_soloed;
4157                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4158         }
4159
4160         if (something_listening != _listening) {
4161                 _listening = something_listening;
4162                 SoloActive (_listening);
4163         }
4164
4165         _listen_cnt = listeners;
4166
4167         if (isolated != _solo_isolated_cnt) {
4168                 _solo_isolated_cnt = isolated;
4169                 IsolatedChanged (); /* EMIT SIGNAL */
4170         }
4171
4172         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4173                                                   something_soloed, listeners, isolated));
4174
4175
4176         SoloChanged (); /* EMIT SIGNAL */
4177         set_dirty();
4178 }
4179
4180 bool
4181 Session::muted () const
4182 {
4183         // TODO consider caching the value on every MuteChanged signal,
4184         // Note that API users may also subscribe to MuteChanged and hence
4185         // this method needs to be called first.
4186         bool muted = false;
4187         StripableList all;
4188         get_stripables (all);
4189         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4190                 assert (!(*i)->is_auditioner()); // XXX remove me
4191                 if ((*i)->is_monitor()) {
4192                         continue;
4193                 }
4194                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route>(*i);
4195                 if (r && !r->active()) {
4196                         continue;
4197                 }
4198                 boost::shared_ptr<MuteControl> mc = (*i)->mute_control();
4199                 if (mc && mc->muted ()) {
4200                         muted = true;
4201                         break;
4202                 }
4203         }
4204         return muted;
4205 }
4206
4207 std::vector<boost::weak_ptr<AutomationControl> >
4208 Session::cancel_all_mute ()
4209 {
4210         StripableList all;
4211         get_stripables (all);
4212         std::vector<boost::weak_ptr<AutomationControl> > muted;
4213         boost::shared_ptr<ControlList> cl (new ControlList);
4214         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4215                 assert (!(*i)->is_auditioner());
4216                 if ((*i)->is_monitor()) {
4217                         continue;
4218                 }
4219                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (*i);
4220                 if (r && !r->active()) {
4221                         continue;
4222                 }
4223                 boost::shared_ptr<AutomationControl> ac = (*i)->mute_control();
4224                 if (ac && ac->get_value () > 0) {
4225                         cl->push_back (ac);
4226                         muted.push_back (boost::weak_ptr<AutomationControl>(ac));
4227                 }
4228         }
4229         if (!cl->empty ()) {
4230                 set_controls (cl, 0.0, PBD::Controllable::UseGroup);
4231         }
4232         return muted;
4233 }
4234
4235 void
4236 Session::get_stripables (StripableList& sl) const
4237 {
4238         boost::shared_ptr<RouteList> r = routes.reader ();
4239         sl.insert (sl.end(), r->begin(), r->end());
4240
4241         VCAList v = _vca_manager->vcas ();
4242         sl.insert (sl.end(), v.begin(), v.end());
4243 }
4244
4245 StripableList
4246 Session::get_stripables () const
4247 {
4248         StripableList rv;
4249         Session::get_stripables (rv);
4250         rv.sort (Stripable::Sorter ());
4251         return rv;
4252 }
4253
4254 RouteList
4255 Session::get_routelist (bool mixer_order) const
4256 {
4257         boost::shared_ptr<RouteList> r = routes.reader ();
4258         RouteList rv;
4259         rv.insert (rv.end(), r->begin(), r->end());
4260         rv.sort (Stripable::Sorter (mixer_order));
4261         return rv;
4262 }
4263
4264 boost::shared_ptr<RouteList>
4265 Session::get_routes_with_internal_returns() const
4266 {
4267         boost::shared_ptr<RouteList> r = routes.reader ();
4268         boost::shared_ptr<RouteList> rl (new RouteList);
4269
4270         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4271                 if ((*i)->internal_return ()) {
4272                         rl->push_back (*i);
4273                 }
4274         }
4275         return rl;
4276 }
4277
4278 bool
4279 Session::io_name_is_legal (const std::string& name) const
4280 {
4281         boost::shared_ptr<RouteList> r = routes.reader ();
4282
4283         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4284                 if (name == reserved->first) {
4285                         if (!route_by_name (reserved->first)) {
4286                                 /* first instance of a reserved name is allowed for some */
4287                                 return reserved->second;
4288                         }
4289                         /* all other instances of a reserved name are not allowed */
4290                         return false;
4291                 }
4292         }
4293
4294         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4295                 if ((*i)->name() == name) {
4296                         return false;
4297                 }
4298
4299                 if ((*i)->has_io_processor_named (name)) {
4300                         return false;
4301                 }
4302         }
4303
4304         return true;
4305 }
4306
4307 void
4308 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4309 {
4310         RouteList rl2;
4311         vector<string> connections;
4312
4313         /* if we are passed only a single route and we're not told to turn
4314          * others off, then just do the simple thing.
4315          */
4316
4317         if (flip_others == false && rl->size() == 1) {
4318                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4319                 if (mt) {
4320                         mt->set_input_active (onoff);
4321                         return;
4322                 }
4323         }
4324
4325         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4326
4327                 PortSet& ps ((*rt)->input()->ports());
4328
4329                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4330                         p->get_connections (connections);
4331                 }
4332
4333                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4334                         routes_using_input_from (*s, rl2);
4335                 }
4336
4337                 /* scan all relevant routes to see if others are on or off */
4338
4339                 bool others_are_already_on = false;
4340
4341                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4342
4343                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4344
4345                         if (!mt) {
4346                                 continue;
4347                         }
4348
4349                         if ((*r) != (*rt)) {
4350                                 if (mt->input_active()) {
4351                                         others_are_already_on = true;
4352                                 }
4353                         } else {
4354                                 /* this one needs changing */
4355                                 mt->set_input_active (onoff);
4356                         }
4357                 }
4358
4359                 if (flip_others) {
4360
4361                         /* globally reverse other routes */
4362
4363                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4364                                 if ((*r) != (*rt)) {
4365                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4366                                         if (mt) {
4367                                                 mt->set_input_active (!others_are_already_on);
4368                                         }
4369                                 }
4370                         }
4371                 }
4372         }
4373 }
4374
4375 void
4376 Session::routes_using_input_from (const string& str, RouteList& rl)
4377 {
4378         boost::shared_ptr<RouteList> r = routes.reader();
4379
4380         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4381                 if ((*i)->input()->connected_to (str)) {
4382                         rl.push_back (*i);
4383                 }
4384         }
4385 }
4386
4387 boost::shared_ptr<Route>
4388 Session::route_by_name (string name) const
4389 {
4390         boost::shared_ptr<RouteList> r = routes.reader ();
4391
4392         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4393                 if ((*i)->name() == name) {
4394                         return *i;
4395                 }
4396         }
4397
4398         return boost::shared_ptr<Route> ((Route*) 0);
4399 }
4400
4401 boost::shared_ptr<Route>
4402 Session::route_by_id (PBD::ID id) const
4403 {
4404         boost::shared_ptr<RouteList> r = routes.reader ();
4405
4406         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4407                 if ((*i)->id() == id) {
4408                         return *i;
4409                 }
4410         }
4411
4412         return boost::shared_ptr<Route> ((Route*) 0);
4413 }
4414
4415
4416 boost::shared_ptr<Stripable>
4417 Session::stripable_by_id (PBD::ID id) const
4418 {
4419         StripableList sl;
4420         get_stripables (sl);
4421
4422         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4423                 if ((*s)->id() == id) {
4424                         return *s;
4425                 }
4426         }
4427
4428         return boost::shared_ptr<Stripable>();
4429 }
4430
4431 boost::shared_ptr<Processor>
4432 Session::processor_by_id (PBD::ID id) const
4433 {
4434         boost::shared_ptr<RouteList> r = routes.reader ();
4435
4436         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4437                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4438                 if (p) {
4439                         return p;
4440                 }
4441         }
4442
4443         return boost::shared_ptr<Processor> ();
4444 }
4445
4446 boost::shared_ptr<Route>
4447 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4448 {
4449         return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4450 }
4451
4452 boost::shared_ptr<Stripable>
4453 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4454 {
4455         StripableList sl;
4456         PresentationInfo::order_t match_cnt = 0;
4457
4458         get_stripables (sl);
4459         sl.sort (Stripable::Sorter());
4460
4461         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4462
4463                 if ((*s)->presentation_info().hidden()) {
4464                         /* if the caller didn't explicitly ask for hidden
4465                            stripables, ignore hidden ones. This matches
4466                            the semantics of the pre-PresentationOrder
4467                            "get by RID" logic of Ardour 4.x and earlier.
4468
4469                            XXX at some point we should likely reverse
4470                            the logic of the flags, because asking for "the
4471                            hidden stripables" is not going to be common,
4472                            whereas asking for visible ones is normal.
4473                         */
4474
4475                         if (! (flags & PresentationInfo::Hidden)) {
4476                                 continue;
4477                         }
4478                 }
4479
4480                 if ((*s)->presentation_info().flag_match (flags)) {
4481                         if (match_cnt++ == n) {
4482                                 return *s;
4483                         }
4484                 }
4485         }
4486
4487         /* there is no nth stripable that matches the given flags */
4488         return boost::shared_ptr<Stripable>();
4489 }
4490
4491 boost::shared_ptr<Route>
4492 Session::route_by_selected_count (uint32_t id) const
4493 {
4494         RouteList r (*(routes.reader ()));
4495         r.sort (Stripable::Sorter());
4496
4497         RouteList::iterator i;
4498
4499         for (i = r.begin(); i != r.end(); ++i) {
4500                 if ((*i)->is_selected()) {
4501                         if (id == 0) {
4502                                 return *i;
4503                         }
4504                         --id;
4505                 }
4506         }
4507
4508         return boost::shared_ptr<Route> ();
4509 }
4510
4511 void
4512 Session::reassign_track_numbers ()
4513 {
4514         int64_t tn = 0;
4515         int64_t bn = 0;
4516         RouteList r (*(routes.reader ()));
4517         r.sort (Stripable::Sorter());
4518
4519         StateProtector sp (this);
4520
4521         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4522                 assert (!(*i)->is_auditioner());
4523                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4524                         (*i)->set_track_number(++tn);
4525                 }
4526                 else if (!(*i)->is_master() && !(*i)->is_monitor()) {
4527                         (*i)->set_track_number(--bn);
4528                 }
4529         }
4530         const uint32_t decimals = ceilf (log10f (tn + 1));
4531         const bool decimals_changed = _track_number_decimals != decimals;
4532         _track_number_decimals = decimals;
4533
4534         if (decimals_changed && config.get_track_name_number ()) {
4535                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4536                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4537                         if (t) {
4538                                 t->resync_track_name();
4539                         }
4540                 }
4541                 // trigger GUI re-layout
4542                 config.ParameterChanged("track-name-number");
4543         }
4544
4545 #ifndef NDEBUG
4546         if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4547                 boost::shared_ptr<RouteList> rl = routes.reader ();
4548                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4549                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4550                 }
4551         }
4552 #endif /* NDEBUG */
4553
4554 }
4555
4556 void
4557 Session::playlist_region_added (boost::weak_ptr<Region> w)
4558 {
4559         boost::shared_ptr<Region> r = w.lock ();
4560         if (!r) {
4561                 return;
4562         }
4563
4564         /* These are the operations that are currently in progress... */
4565         list<GQuark> curr = _current_trans_quarks;
4566         curr.sort ();
4567
4568         /* ...and these are the operations during which we want to update
4569            the session range location markers.
4570         */
4571         list<GQuark> ops;
4572         ops.push_back (Operations::capture);
4573         ops.push_back (Operations::paste);
4574         ops.push_back (Operations::duplicate_region);
4575         ops.push_back (Operations::insert_file);
4576         ops.push_back (Operations::insert_region);
4577         ops.push_back (Operations::drag_region_brush);
4578         ops.push_back (Operations::region_drag);
4579         ops.push_back (Operations::selection_grab);
4580         ops.push_back (Operations::region_fill);
4581         ops.push_back (Operations::fill_selection);
4582         ops.push_back (Operations::create_region);
4583         ops.push_back (Operations::region_copy);
4584         ops.push_back (Operations::fixed_time_region_copy);
4585         ops.sort ();
4586
4587         /* See if any of the current operations match the ones that we want */
4588         list<GQuark> in;
4589         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4590
4591         /* If so, update the session range markers */
4592         if (!in.empty ()) {
4593                 maybe_update_session_range (r->position (), r->last_sample ());
4594         }
4595 }
4596
4597 /** Update the session range markers if a is before the current start or
4598  *  b is after the current end.
4599  */
4600 void
4601 Session::maybe_update_session_range (samplepos_t a, samplepos_t b)
4602 {
4603         if (_state_of_the_state & Loading) {
4604                 return;
4605         }
4606
4607         samplepos_t session_end_marker_shift_samples = session_end_shift * _nominal_sample_rate;
4608
4609         if (_session_range_location == 0) {
4610
4611                 set_session_range_location (a, b + session_end_marker_shift_samples);
4612
4613         } else {
4614
4615                 if (a < _session_range_location->start()) {
4616                         _session_range_location->set_start (a);
4617                 }
4618
4619                 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4620                         _session_range_location->set_end (b);
4621                 }
4622         }
4623 }
4624
4625 void
4626 Session::set_end_is_free (bool yn)
4627 {
4628         _session_range_end_is_free = yn;
4629 }
4630
4631 void
4632 Session::playlist_ranges_moved (list<Evoral::RangeMove<samplepos_t> > const & ranges)
4633 {
4634         for (list<Evoral::RangeMove<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4635                 maybe_update_session_range (i->to, i->to + i->length);
4636         }
4637 }
4638
4639 void
4640 Session::playlist_regions_extended (list<Evoral::Range<samplepos_t> > const & ranges)
4641 {
4642         for (list<Evoral::Range<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4643                 maybe_update_session_range (i->from, i->to);
4644         }
4645 }
4646
4647 /* Region management */
4648
4649 boost::shared_ptr<Region>
4650 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4651 {
4652         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4653         RegionFactory::RegionMap::const_iterator i;
4654         boost::shared_ptr<Region> region;
4655
4656         Glib::Threads::Mutex::Lock lm (region_lock);
4657
4658         for (i = regions.begin(); i != regions.end(); ++i) {
4659
4660                 region = i->second;
4661
4662                 if (region->whole_file()) {
4663
4664                         if (child->source_equivalent (region)) {
4665                                 return region;
4666                         }
4667                 }
4668         }
4669
4670         return boost::shared_ptr<Region> ();
4671 }
4672
4673 int
4674 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4675 {
4676         set<boost::shared_ptr<Region> > relevant_regions;
4677
4678         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4679                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4680         }
4681
4682         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4683                 set<boost::shared_ptr<Region> >::iterator tmp;
4684
4685                 tmp = r;
4686                 ++tmp;
4687
4688                 playlists->destroy_region (*r);
4689                 RegionFactory::map_remove (*r);
4690
4691                 (*r)->drop_sources ();
4692                 (*r)->drop_references ();
4693
4694                 relevant_regions.erase (r);
4695
4696                 r = tmp;
4697         }
4698
4699         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4700
4701                 {
4702                         Glib::Threads::Mutex::Lock ls (source_lock);
4703                         /* remove from the main source list */
4704                         sources.erase ((*s)->id());
4705                 }
4706
4707                 (*s)->mark_for_remove ();
4708                 (*s)->drop_references ();
4709
4710                 s = srcs.erase (s);
4711         }
4712
4713         return 0;
4714 }
4715
4716 int
4717 Session::remove_last_capture ()
4718 {
4719         list<boost::shared_ptr<Source> > srcs;
4720
4721         boost::shared_ptr<RouteList> rl = routes.reader ();
4722         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4723                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4724                 if (!tr) {
4725                         continue;
4726                 }
4727
4728                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4729
4730                 if (!l.empty()) {
4731                         srcs.insert (srcs.end(), l.begin(), l.end());
4732                         l.clear ();
4733                 }
4734         }
4735
4736         destroy_sources (srcs);
4737
4738         save_state (_current_snapshot_name);
4739
4740         return 0;
4741 }
4742
4743 /* Source Management */
4744
4745 void
4746 Session::add_source (boost::shared_ptr<Source> source)
4747 {
4748         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4749         pair<SourceMap::iterator,bool> result;
4750
4751         entry.first = source->id();
4752         entry.second = source;
4753
4754         {
4755                 Glib::Threads::Mutex::Lock lm (source_lock);
4756                 result = sources.insert (entry);
4757         }
4758
4759         if (result.second) {
4760
4761                 /* yay, new source */
4762
4763                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4764
4765                 if (fs) {
4766                         if (!fs->within_session()) {
4767                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4768                         }
4769                 }
4770
4771                 set_dirty();
4772
4773                 boost::shared_ptr<AudioFileSource> afs;
4774
4775                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4776                         if (Config->get_auto_analyse_audio()) {
4777                                 Analyser::queue_source_for_analysis (source, false);
4778                         }
4779                 }
4780
4781                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4782         }
4783 }
4784
4785 void
4786 Session::remove_source (boost::weak_ptr<Source> src)
4787 {
4788         if (_state_of_the_state & Deletion) {
4789                 return;
4790         }
4791
4792         SourceMap::iterator i;
4793         boost::shared_ptr<Source> source = src.lock();
4794
4795         if (!source) {
4796                 return;
4797         }
4798
4799         {
4800                 Glib::Threads::Mutex::Lock lm (source_lock);
4801
4802                 if ((i = sources.find (source->id())) != sources.end()) {
4803                         sources.erase (i);
4804                 }
4805         }
4806
4807         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4808
4809                 /* save state so we don't end up with a session file
4810                    referring to non-existent sources.
4811                 */
4812
4813                 save_state (_current_snapshot_name);
4814         }
4815 }
4816
4817 boost::shared_ptr<Source>
4818 Session::source_by_id (const PBD::ID& id)
4819 {
4820         Glib::Threads::Mutex::Lock lm (source_lock);
4821         SourceMap::iterator i;
4822         boost::shared_ptr<Source> source;
4823
4824         if ((i = sources.find (id)) != sources.end()) {
4825                 source = i->second;
4826         }
4827
4828         return source;
4829 }
4830
4831 boost::shared_ptr<AudioFileSource>
4832 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4833 {
4834         /* Restricted to audio files because only audio sources have channel
4835            as a property.
4836         */
4837
4838         Glib::Threads::Mutex::Lock lm (source_lock);
4839
4840         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4841                 boost::shared_ptr<AudioFileSource> afs
4842                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4843
4844                 if (afs && afs->path() == path && chn == afs->channel()) {
4845                         return afs;
4846                 }
4847         }
4848
4849         return boost::shared_ptr<AudioFileSource>();
4850 }
4851
4852 boost::shared_ptr<MidiSource>
4853 Session::midi_source_by_path (const std::string& path, bool need_source_lock) const
4854 {
4855         /* Restricted to MIDI files because audio sources require a channel
4856            for unique identification, in addition to a path.
4857         */
4858
4859         Glib::Threads::Mutex::Lock lm (source_lock, Glib::Threads::NOT_LOCK);
4860         if (need_source_lock) {
4861                 lm.acquire ();
4862         }
4863
4864         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4865                 boost::shared_ptr<MidiSource> ms
4866                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4867                 boost::shared_ptr<FileSource> fs
4868                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4869
4870                 if (ms && fs && fs->path() == path) {
4871                         return ms;
4872                 }
4873         }
4874
4875         return boost::shared_ptr<MidiSource>();
4876 }
4877
4878 uint32_t
4879 Session::count_sources_by_origin (const string& path)
4880 {
4881         uint32_t cnt = 0;
4882         Glib::Threads::Mutex::Lock lm (source_lock);
4883
4884         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4885                 boost::shared_ptr<FileSource> fs
4886                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4887
4888                 if (fs && fs->origin() == path) {
4889                         ++cnt;
4890                 }
4891         }
4892
4893         return cnt;
4894 }
4895
4896 static string
4897 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4898         if (hash) {
4899                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4900                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4901         } else {
4902                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4903         }
4904 }
4905
4906 string
4907 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4908 {
4909         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4910
4911         if (Glib::path_is_absolute (filepath)) {
4912
4913                 /* rip the session dir from the audiofile source */
4914
4915                 string session_path;
4916                 bool in_another_session = true;
4917
4918                 if (filepath.find (interchange_dir_string) != string::npos) {
4919
4920                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4921                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4922                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4923                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4924
4925                         /* see if it is within our session */
4926
4927                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4928                                 if (i->path == session_path) {
4929                                         in_another_session = false;
4930                                         break;
4931                                 }
4932                         }
4933                 } else {
4934                         in_another_session = false;
4935                 }
4936
4937
4938                 if (in_another_session) {
4939                         SessionDirectory sd (session_path);
4940                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4941                 }
4942         }
4943
4944         /* 1) if file belongs to this session
4945          * it may be a relative path (interchange/...)
4946          * or just basename (session_state, remove source)
4947          * -> just use the basename
4948          */
4949         std::string filename = Glib::path_get_basename (filepath);
4950         std::string path;
4951
4952         /* 2) if the file is outside our session dir:
4953          * (imported but not copied) add the path for check-summming */
4954         if (!in_session) {
4955                 path = Glib::path_get_dirname (filepath);
4956         }
4957
4958         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4959 }
4960
4961 string
4962 Session::new_audio_source_path_for_embedded (const std::string& path)
4963 {
4964         /* embedded source:
4965          *
4966          * we know that the filename is already unique because it exists
4967          * out in the filesystem.
4968          *
4969          * However, when we bring it into the session, we could get a
4970          * collision.
4971          *
4972          * Eg. two embedded files:
4973          *
4974          *          /foo/bar/baz.wav
4975          *          /frob/nic/baz.wav
4976          *
4977          * When merged into session, these collide.
4978          *
4979          * There will not be a conflict with in-memory sources
4980          * because when the source was created we already picked
4981          * a unique name for it.
4982          *
4983          * This collision is not likely to be common, but we have to guard
4984          * against it.  So, if there is a collision, take the md5 hash of the
4985          * the path, and use that as the filename instead.
4986          */
4987
4988         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4989         string base = Glib::path_get_basename (path);
4990         string newpath = Glib::build_filename (sdir.sound_path(), base);
4991
4992         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4993
4994                 MD5 md5;
4995
4996                 md5.digestString (path.c_str());
4997                 md5.writeToString ();
4998                 base = md5.digestChars;
4999
5000                 string ext = get_suffix (path);
5001
5002                 if (!ext.empty()) {
5003                         base += '.';
5004                         base += ext;
5005                 }
5006
5007                 newpath = Glib::build_filename (sdir.sound_path(), base);
5008
5009                 /* if this collides, we're screwed */
5010
5011                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5012                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5013                         return string();
5014                 }
5015
5016         }
5017
5018         return newpath;
5019 }
5020
5021 /** Return true if there are no audio file sources that use @param name as
5022  * the filename component of their path.
5023  *
5024  * Return false otherwise.
5025  *
5026  * This method MUST ONLY be used to check in-session, mono files since it
5027  * hard-codes the channel of the audio file source we are looking for as zero.
5028  *
5029  * If/when Ardour supports native files in non-mono formats, the logic here
5030  * will need to be revisited.
5031  */
5032 bool
5033 Session::audio_source_name_is_unique (const string& name)
5034 {
5035         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5036         vector<space_and_path>::iterator i;
5037         uint32_t existing = 0;
5038
5039         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5040
5041                 /* note that we search *without* the extension so that
5042                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5043                    in the event that this new name is required for
5044                    a file format change.
5045                 */
5046
5047                 const string spath = *i;
5048
5049                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5050                         existing++;
5051                         break;
5052                 }
5053
5054                 /* it is possible that we have the path already
5055                  * assigned to a source that has not yet been written
5056                  * (ie. the write source for a diskstream). we have to
5057                  * check this in order to make sure that our candidate
5058                  * path isn't used again, because that can lead to
5059                  * two Sources point to the same file with different
5060                  * notions of their removability.
5061                  */
5062
5063
5064                 string possible_path = Glib::build_filename (spath, name);
5065
5066                 if (audio_source_by_path_and_channel (possible_path, 0)) {
5067                         existing++;
5068                         break;
5069                 }
5070         }
5071
5072         return (existing == 0);
5073 }
5074
5075 string
5076 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)
5077 {
5078         ostringstream sstr;
5079         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5080
5081         if (Profile->get_trx() && destructive) {
5082                 sstr << 'T';
5083                 sstr << setfill ('0') << setw (4) << cnt;
5084                 sstr << legalized_base;
5085         } else {
5086                 sstr << legalized_base;
5087
5088                 if (take_required || related_exists) {
5089                         sstr << '-';
5090                         sstr << cnt;
5091                 }
5092         }
5093
5094         if (nchan == 2) {
5095                 if (chan == 0) {
5096                         sstr << "%L";
5097                 } else {
5098                         sstr << "%R";
5099                 }
5100         } else if (nchan > 2) {
5101                 if (nchan < 26) {
5102                         sstr << '%';
5103                         sstr << 'a' + chan;
5104                 } else {
5105                         /* XXX what? more than 26 channels! */
5106                         sstr << '%';
5107                         sstr << chan+1;
5108                 }
5109         }
5110
5111         sstr << ext;
5112
5113         return sstr.str();
5114 }
5115
5116 /** Return a unique name based on \a base for a new internal audio source */
5117 string
5118 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5119 {
5120         uint32_t cnt;
5121         string possible_name;
5122         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5123         string legalized;
5124         bool some_related_source_name_exists = false;
5125
5126         legalized = legalize_for_path (base);
5127
5128         // Find a "version" of the base name that doesn't exist in any of the possible directories.
5129
5130         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5131
5132                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5133
5134                 if (audio_source_name_is_unique (possible_name)) {
5135                         break;
5136                 }
5137
5138                 some_related_source_name_exists = true;
5139
5140                 if (cnt > limit) {
5141                         error << string_compose(
5142                                         _("There are already %1 recordings for %2, which I consider too many."),
5143                                         limit, base) << endmsg;
5144                         destroy ();
5145                         throw failed_constructor();
5146                 }
5147         }
5148
5149         /* We've established that the new name does not exist in any session
5150          * directory, so now find out which one we should use for this new
5151          * audio source.
5152          */
5153
5154         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5155
5156         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5157
5158         return s;
5159 }
5160
5161 /** Return a unique name based on `base` for a new internal MIDI source */
5162 string
5163 Session::new_midi_source_path (const string& base, bool need_lock)
5164 {
5165         string possible_path;
5166         string possible_name;
5167
5168         possible_name = legalize_for_path (base);
5169
5170         // Find a "version" of the file name that doesn't exist in any of the possible directories.
5171         std::vector<string> sdirs = source_search_path(DataType::MIDI);
5172
5173         /* - the main session folder is the first in the vector.
5174          * - after checking all locations for file-name uniqueness,
5175          *   we keep the one from the last iteration as new file name
5176          * - midi files are small and should just be kept in the main session-folder
5177          *
5178          * -> reverse the array, check main session folder last and use that as location
5179          *    for MIDI files.
5180          */
5181         std::reverse(sdirs.begin(), sdirs.end());
5182
5183         while (true) {
5184                 possible_name = bump_name_once (possible_name, '-');
5185
5186                 vector<space_and_path>::iterator i;
5187                 uint32_t existing = 0;
5188
5189                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5190
5191                         possible_path = Glib::build_filename (*i, possible_name + ".mid");
5192
5193                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5194                                 existing++;
5195                         }
5196
5197                         if (midi_source_by_path (possible_path, need_lock)) {
5198                                 existing++;
5199                         }
5200                 }
5201
5202                 if (possible_path.size () >= PATH_MAX) {
5203                         error << string_compose(
5204                                         _("There are already many recordings for %1, resulting in a too long file-path %2."),
5205                                         base, possible_path) << endmsg;
5206                         destroy ();
5207                         return 0;
5208                 }
5209
5210                 if (existing == 0) {
5211                         break;
5212                 }
5213         }
5214
5215         /* No need to "find best location" for software/app-based RAID, because
5216            MIDI is so small that we always put it in the same place.
5217         */
5218
5219         return possible_path;
5220 }
5221
5222
5223 /** Create a new within-session audio source */
5224 boost::shared_ptr<AudioFileSource>
5225 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5226 {
5227         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5228
5229         if (!path.empty()) {
5230                 return boost::dynamic_pointer_cast<AudioFileSource> (
5231                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, sample_rate(), true, true));
5232         } else {
5233                 throw failed_constructor ();
5234         }
5235 }
5236
5237 /** Create a new within-session MIDI source */
5238 boost::shared_ptr<MidiSource>
5239 Session::create_midi_source_for_session (string const & basic_name)
5240 {
5241         const string path = new_midi_source_path (basic_name);
5242
5243         if (!path.empty()) {
5244                 return boost::dynamic_pointer_cast<SMFSource> (
5245                         SourceFactory::createWritable (
5246                                 DataType::MIDI, *this, path, false, sample_rate()));
5247         } else {
5248                 throw failed_constructor ();
5249         }
5250 }
5251
5252 /** Create a new within-session MIDI source */
5253 boost::shared_ptr<MidiSource>
5254 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5255 {
5256         /* the caller passes in the track the source will be used in,
5257            so that we can keep the numbering sane.
5258
5259            Rationale: a track with the name "Foo" that has had N
5260            captures carried out so far will ALREADY have a write source
5261            named "Foo-N+1.mid" waiting to be used for the next capture.
5262
5263            If we call new_midi_source_name() we will get "Foo-N+2". But
5264            there is no region corresponding to "Foo-N+1", so when
5265            "Foo-N+2" appears in the track, the gap presents the user
5266            with odd behaviour - why did it skip past Foo-N+1?
5267
5268            We could explain this to the user in some odd way, but
5269            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5270            use "Foo-N+1" here.
5271
5272            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5273         */
5274
5275         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5276         assert (mt);
5277         std::string name = track->steal_write_source_name ();
5278
5279         if (name.empty()) {
5280                 return boost::shared_ptr<MidiSource>();
5281         }
5282
5283         /* MIDI files are small, just put them in the first location of the
5284            session source search path.
5285         */
5286
5287         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5288
5289         return boost::dynamic_pointer_cast<SMFSource> (
5290                 SourceFactory::createWritable (
5291                         DataType::MIDI, *this, path, false, sample_rate()));
5292 }
5293
5294
5295 void
5296 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5297 {
5298         if (playlist->hidden()) {
5299                 return;
5300         }
5301
5302         playlists->add (playlist);
5303
5304         if (unused) {
5305                 playlist->release();
5306         }
5307
5308         set_dirty();
5309 }
5310
5311 void
5312 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5313 {
5314         if (_state_of_the_state & Deletion) {
5315                 return;
5316         }
5317
5318         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5319
5320         if (!playlist) {
5321                 return;
5322         }
5323
5324         playlists->remove (playlist);
5325
5326         set_dirty();
5327 }
5328
5329 void
5330 Session::set_audition (boost::shared_ptr<Region> r)
5331 {
5332         pending_audition_region = r;
5333         add_post_transport_work (PostTransportAudition);
5334         _butler->schedule_transport_work ();
5335 }
5336
5337 void
5338 Session::audition_playlist ()
5339 {
5340         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5341         ev->region.reset ();
5342         queue_event (ev);
5343 }
5344
5345
5346 void
5347 Session::register_lua_function (
5348                 const std::string& name,
5349                 const std::string& script,
5350                 const LuaScriptParamList& args
5351                 )
5352 {
5353         Glib::Threads::Mutex::Lock lm (lua_lock);
5354
5355         lua_State* L = lua.getState();
5356
5357         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5358         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5359         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5360                 if ((*i)->optional && !(*i)->is_set) { continue; }
5361                 tbl_arg[(*i)->name] = (*i)->value;
5362         }
5363         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5364         lm.release();
5365
5366         LuaScriptsChanged (); /* EMIT SIGNAL */
5367         set_dirty();
5368 }
5369
5370 void
5371 Session::unregister_lua_function (const std::string& name)
5372 {
5373         Glib::Threads::Mutex::Lock lm (lua_lock);
5374         (*_lua_del)(name); // throws luabridge::LuaException
5375         lua.collect_garbage ();
5376         lm.release();
5377
5378         LuaScriptsChanged (); /* EMIT SIGNAL */
5379         set_dirty();
5380 }
5381
5382 std::vector<std::string>
5383 Session::registered_lua_functions ()
5384 {
5385         Glib::Threads::Mutex::Lock lm (lua_lock);
5386         std::vector<std::string> rv;
5387
5388         try {
5389                 luabridge::LuaRef list ((*_lua_list)());
5390                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5391                         if (!i.key ().isString ()) { assert(0); continue; }
5392                         rv.push_back (i.key ().cast<std::string> ());
5393                 }
5394         } catch (...) { }
5395         return rv;
5396 }
5397
5398 #ifndef NDEBUG
5399 static void _lua_print (std::string s) {
5400         std::cout << "SessionLua: " << s << "\n";
5401 }
5402 #endif
5403
5404 void
5405 Session::try_run_lua (pframes_t nframes)
5406 {
5407         if (_n_lua_scripts == 0) return;
5408         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5409         if (tm.locked ()) {
5410                 try { (*_lua_run)(nframes); } catch (...) { }
5411                 lua.collect_garbage_step ();
5412         }
5413 }
5414
5415 void
5416 Session::setup_lua ()
5417 {
5418 #ifndef NDEBUG
5419         lua.Print.connect (&_lua_print);
5420 #endif
5421         lua.sandbox (true);
5422         lua.do_command (
5423                         "function ArdourSession ()"
5424                         "  local self = { scripts = {}, instances = {} }"
5425                         ""
5426                         "  local remove = function (n)"
5427                         "   self.scripts[n] = nil"
5428                         "   self.instances[n] = nil"
5429                         "   Session:scripts_changed()" // call back
5430                         "  end"
5431                         ""
5432                         "  local addinternal = function (n, f, a)"
5433                         "   assert(type(n) == 'string', 'function-name must be string')"
5434                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5435                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5436                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5437                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5438                         "   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 }"
5439                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5440                         "   Session:scripts_changed()" // call back
5441                         "  end"
5442                         ""
5443                         "  local add = function (n, b, a)"
5444                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5445                         "   load (b)()" // assigns f
5446                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5447                         "   addinternal (n, load(f), a)"
5448                         "  end"
5449                         ""
5450                         "  local run = function (...)"
5451                         "   for n, s in pairs (self.instances) do"
5452                         "     local status, err = pcall (s, ...)"
5453                         "     if not status then"
5454                         "       print ('fn \"'.. n .. '\": ', err)"
5455                         "       remove (n)"
5456                         "      end"
5457                         "   end"
5458                         "   collectgarbage()"
5459                         "  end"
5460                         ""
5461                         "  local cleanup = function ()"
5462                         "   self.scripts = nil"
5463                         "   self.instances = nil"
5464                         "  end"
5465                         ""
5466                         "  local list = function ()"
5467                         "   local rv = {}"
5468                         "   for n, _ in pairs (self.scripts) do"
5469                         "     rv[n] = true"
5470                         "   end"
5471                         "   return rv"
5472                         "  end"
5473                         ""
5474                         "  local function basic_serialize (o)"
5475                         "    if type(o) == \"number\" then"
5476                         "     return tostring(o)"
5477                         "    else"
5478                         "     return string.format(\"%q\", o)"
5479                         "    end"
5480                         "  end"
5481                         ""
5482                         "  local function serialize (name, value)"
5483                         "   local rv = name .. ' = '"
5484                         "   collectgarbage()"
5485                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5486                         "    return rv .. basic_serialize(value) .. ' '"
5487                         "   elseif type(value) == \"table\" then"
5488                         "    rv = rv .. '{} '"
5489                         "    for k,v in pairs(value) do"
5490                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5491                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5492                         "     collectgarbage()" // string concatenation allocates a new string :(
5493                         "    end"
5494                         "    return rv;"
5495                         "   elseif type(value) == \"function\" then"
5496                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5497                         "   else"
5498                         "    error('cannot save a ' .. type(value))"
5499                         "   end"
5500                         "  end"
5501                         ""
5502                         ""
5503                         "  local save = function ()"
5504                         "   return (serialize('scripts', self.scripts))"
5505                         "  end"
5506                         ""
5507                         "  local restore = function (state)"
5508                         "   self.scripts = {}"
5509                         "   load (state)()"
5510                         "   for n, s in pairs (scripts) do"
5511                         "    addinternal (n, load(s['f']), s['a'])"
5512                         "   end"
5513                         "  end"
5514                         ""
5515                         " return { run = run, add = add, remove = remove,"
5516                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5517                         " end"
5518                         " "
5519                         " sess = ArdourSession ()"
5520                         " ArdourSession = nil"
5521                         " "
5522                         "function ardour () end"
5523                         );
5524
5525         lua_State* L = lua.getState();
5526
5527         try {
5528                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5529                 lua.do_command ("sess = nil"); // hide it.
5530                 lua.do_command ("collectgarbage()");
5531
5532                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5533                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5534                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5535                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5536                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5537                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5538                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5539         } catch (luabridge::LuaException const& e) {
5540                 fatal << string_compose (_("programming error: %1"),
5541                                 std::string ("Failed to setup session Lua interpreter") + e.what ())
5542                         << endmsg;
5543                 abort(); /*NOTREACHED*/
5544         } catch (...) {
5545                 fatal << string_compose (_("programming error: %1"),
5546                                 X_("Failed to setup session Lua interpreter"))
5547                         << endmsg;
5548                 abort(); /*NOTREACHED*/
5549         }
5550
5551         lua_mlock (L, 1);
5552         LuaBindings::stddef (L);
5553         LuaBindings::common (L);
5554         LuaBindings::dsp (L);
5555         lua_mlock (L, 0);
5556         luabridge::push <Session *> (L, this);
5557         lua_setglobal (L, "Session");
5558 }
5559
5560 void
5561 Session::scripts_changed ()
5562 {
5563         assert (!lua_lock.trylock()); // must hold lua_lock
5564
5565         try {
5566                 luabridge::LuaRef list ((*_lua_list)());
5567                 int cnt = 0;
5568                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5569                         if (!i.key ().isString ()) { assert(0); continue; }
5570                         ++cnt;
5571                 }
5572                 _n_lua_scripts = cnt;
5573         } catch (luabridge::LuaException const& e) {
5574                 fatal << string_compose (_("programming error: %1"),
5575                                 std::string ("Indexing Lua Session Scripts failed.") + e.what ())
5576                         << endmsg;
5577                 abort(); /*NOTREACHED*/
5578         } catch (...) {
5579                 fatal << string_compose (_("programming error: %1"),
5580                                 X_("Indexing Lua Session Scripts failed."))
5581                         << endmsg;
5582                 abort(); /*NOTREACHED*/
5583         }
5584 }
5585
5586 void
5587 Session::non_realtime_set_audition ()
5588 {
5589         assert (pending_audition_region);
5590         auditioner->audition_region (pending_audition_region);
5591         pending_audition_region.reset ();
5592         AuditionActive (true); /* EMIT SIGNAL */
5593 }
5594
5595 void
5596 Session::audition_region (boost::shared_ptr<Region> r)
5597 {
5598         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5599         ev->region = r;
5600         queue_event (ev);
5601 }
5602
5603 void
5604 Session::cancel_audition ()
5605 {
5606         if (!auditioner) {
5607                 return;
5608         }
5609         if (auditioner->auditioning()) {
5610                 auditioner->cancel_audition ();
5611                 AuditionActive (false); /* EMIT SIGNAL */
5612         }
5613 }
5614
5615 bool
5616 Session::is_auditioning () const
5617 {
5618         /* can be called before we have an auditioner object */
5619         if (auditioner) {
5620                 return auditioner->auditioning();
5621         } else {
5622                 return false;
5623         }
5624 }
5625
5626 void
5627 Session::graph_reordered ()
5628 {
5629         /* don't do this stuff if we are setting up connections
5630            from a set_state() call or creating new tracks. Ditto for deletion.
5631         */
5632
5633         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5634                 return;
5635         }
5636
5637         resort_routes ();
5638
5639         /* force all diskstreams to update their capture offset values to
5640          * reflect any changes in latencies within the graph.
5641          */
5642         update_route_latency (false, true);
5643 }
5644
5645 /** @return Number of samples that there is disk space available to write,
5646  *  if known.
5647  */
5648 boost::optional<samplecnt_t>
5649 Session::available_capture_duration ()
5650 {
5651         Glib::Threads::Mutex::Lock lm (space_lock);
5652
5653         if (_total_free_4k_blocks_uncertain) {
5654                 return boost::optional<samplecnt_t> ();
5655         }
5656
5657         float sample_bytes_on_disk = 4.0; // keep gcc happy
5658
5659         switch (config.get_native_file_data_format()) {
5660         case FormatFloat:
5661                 sample_bytes_on_disk = 4.0;
5662                 break;
5663
5664         case FormatInt24:
5665                 sample_bytes_on_disk = 3.0;
5666                 break;
5667
5668         case FormatInt16:
5669                 sample_bytes_on_disk = 2.0;
5670                 break;
5671
5672         default:
5673                 /* impossible, but keep some gcc versions happy */
5674                 fatal << string_compose (_("programming error: %1"),
5675                                          X_("illegal native file data format"))
5676                       << endmsg;
5677                 abort(); /*NOTREACHED*/
5678         }
5679
5680         double scale = 4096.0 / sample_bytes_on_disk;
5681
5682         if (_total_free_4k_blocks * scale > (double) max_samplecnt) {
5683                 return max_samplecnt;
5684         }
5685
5686         return (samplecnt_t) floor (_total_free_4k_blocks * scale);
5687 }
5688
5689 void
5690 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5691 {
5692         {
5693                 RCUWriter<BundleList> writer (_bundles);
5694                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5695                 b->push_back (bundle);
5696         }
5697
5698         if (emit_signal) {
5699                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5700         }
5701
5702         set_dirty();
5703 }
5704
5705 void
5706 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5707 {
5708         bool removed = false;
5709
5710         {
5711                 RCUWriter<BundleList> writer (_bundles);
5712                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5713                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5714
5715                 if (i != b->end()) {
5716                         b->erase (i);
5717                         removed = true;
5718                 }
5719         }
5720
5721         if (removed) {
5722                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5723         }
5724
5725         set_dirty();
5726 }
5727
5728 boost::shared_ptr<Bundle>
5729 Session::bundle_by_name (string name) const
5730 {
5731         boost::shared_ptr<BundleList> b = _bundles.reader ();
5732
5733         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5734                 if ((*i)->name() == name) {
5735                         return* i;
5736                 }
5737         }
5738
5739         return boost::shared_ptr<Bundle> ();
5740 }
5741
5742 void
5743 Session::tempo_map_changed (const PropertyChange&)
5744 {
5745         clear_clicks ();
5746
5747         playlists->update_after_tempo_map_change ();
5748
5749         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5750
5751         set_dirty ();
5752 }
5753
5754 void
5755 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5756 {
5757         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5758                 (*i)->recompute_samples_from_beat ();
5759         }
5760 }
5761
5762 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5763  * the given count with the current block size.
5764  */
5765 void
5766 Session::ensure_buffers (ChanCount howmany)
5767 {
5768         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5769 }
5770
5771 void
5772 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5773 {
5774         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5775                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5776         }
5777 }
5778
5779 uint32_t
5780 Session::next_insert_id ()
5781 {
5782         /* this doesn't really loop forever. just think about it */
5783
5784         while (true) {
5785                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5786                         if (!insert_bitset[n]) {
5787                                 insert_bitset[n] = true;
5788                                 return n;
5789
5790                         }
5791                 }
5792
5793                 /* none available, so resize and try again */
5794
5795                 insert_bitset.resize (insert_bitset.size() + 16, false);
5796         }
5797 }
5798
5799 uint32_t
5800 Session::next_send_id ()
5801 {
5802         /* this doesn't really loop forever. just think about it */
5803
5804         while (true) {
5805                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5806                         if (!send_bitset[n]) {
5807                                 send_bitset[n] = true;
5808                                 return n;
5809
5810                         }
5811                 }
5812
5813                 /* none available, so resize and try again */
5814
5815                 send_bitset.resize (send_bitset.size() + 16, false);
5816         }
5817 }
5818
5819 uint32_t
5820 Session::next_aux_send_id ()
5821 {
5822         /* this doesn't really loop forever. just think about it */
5823
5824         while (true) {
5825                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5826                         if (!aux_send_bitset[n]) {
5827                                 aux_send_bitset[n] = true;
5828                                 return n;
5829
5830                         }
5831                 }
5832
5833                 /* none available, so resize and try again */
5834
5835                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5836         }
5837 }
5838
5839 uint32_t
5840 Session::next_return_id ()
5841 {
5842         /* this doesn't really loop forever. just think about it */
5843
5844         while (true) {
5845                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5846                         if (!return_bitset[n]) {
5847                                 return_bitset[n] = true;
5848                                 return n;
5849
5850                         }
5851                 }
5852
5853                 /* none available, so resize and try again */
5854
5855                 return_bitset.resize (return_bitset.size() + 16, false);
5856         }
5857 }
5858
5859 void
5860 Session::mark_send_id (uint32_t id)
5861 {
5862         if (id >= send_bitset.size()) {
5863                 send_bitset.resize (id+16, false);
5864         }
5865         if (send_bitset[id]) {
5866                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5867         }
5868         send_bitset[id] = true;
5869 }
5870
5871 void
5872 Session::mark_aux_send_id (uint32_t id)
5873 {
5874         if (id >= aux_send_bitset.size()) {
5875                 aux_send_bitset.resize (id+16, false);
5876         }
5877         if (aux_send_bitset[id]) {
5878                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5879         }
5880         aux_send_bitset[id] = true;
5881 }
5882
5883 void
5884 Session::mark_return_id (uint32_t id)
5885 {
5886         if (id >= return_bitset.size()) {
5887                 return_bitset.resize (id+16, false);
5888         }
5889         if (return_bitset[id]) {
5890                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5891         }
5892         return_bitset[id] = true;
5893 }
5894
5895 void
5896 Session::mark_insert_id (uint32_t id)
5897 {
5898         if (id >= insert_bitset.size()) {
5899                 insert_bitset.resize (id+16, false);
5900         }
5901         if (insert_bitset[id]) {
5902                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5903         }
5904         insert_bitset[id] = true;
5905 }
5906
5907 void
5908 Session::unmark_send_id (uint32_t id)
5909 {
5910         if (id < send_bitset.size()) {
5911                 send_bitset[id] = false;
5912         }
5913 }
5914
5915 void
5916 Session::unmark_aux_send_id (uint32_t id)
5917 {
5918         if (id < aux_send_bitset.size()) {
5919                 aux_send_bitset[id] = false;
5920         }
5921 }
5922
5923 void
5924 Session::unmark_return_id (uint32_t id)
5925 {
5926         if (_state_of_the_state & Deletion) { return; }
5927         if (id < return_bitset.size()) {
5928                 return_bitset[id] = false;
5929         }
5930 }
5931
5932 void
5933 Session::unmark_insert_id (uint32_t id)
5934 {
5935         if (id < insert_bitset.size()) {
5936                 insert_bitset[id] = false;
5937         }
5938 }
5939
5940 void
5941 Session::reset_native_file_format ()
5942 {
5943         boost::shared_ptr<RouteList> rl = routes.reader ();
5944
5945         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5946                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5947                 if (tr) {
5948                         /* don't save state as we do this, there's no point
5949                          */
5950                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5951                         tr->reset_write_sources (false);
5952                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5953                 }
5954         }
5955 }
5956
5957 bool
5958 Session::route_name_unique (string n) const
5959 {
5960         boost::shared_ptr<RouteList> r = routes.reader ();
5961
5962         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5963                 if ((*i)->name() == n) {
5964                         return false;
5965                 }
5966         }
5967
5968         return true;
5969 }
5970
5971 bool
5972 Session::route_name_internal (string n) const
5973 {
5974         if (auditioner && auditioner->name() == n) {
5975                 return true;
5976         }
5977
5978         if (_click_io && _click_io->name() == n) {
5979                 return true;
5980         }
5981
5982         return false;
5983 }
5984
5985 int
5986 Session::freeze_all (InterThreadInfo& itt)
5987 {
5988         boost::shared_ptr<RouteList> r = routes.reader ();
5989
5990         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5991
5992                 boost::shared_ptr<Track> t;
5993
5994                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5995                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5996                            of every track.
5997                         */
5998                         t->freeze_me (itt);
5999                 }
6000         }
6001
6002         return 0;
6003 }
6004
6005 boost::shared_ptr<Region>
6006 Session::write_one_track (Track& track, samplepos_t start, samplepos_t end,
6007                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
6008                           InterThreadInfo& itt,
6009                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
6010                           bool for_export, bool for_freeze)
6011 {
6012         boost::shared_ptr<Region> result;
6013         boost::shared_ptr<Playlist> playlist;
6014         boost::shared_ptr<Source> source;
6015         ChanCount diskstream_channels (track.n_channels());
6016         samplepos_t position;
6017         samplecnt_t this_chunk;
6018         samplepos_t to_do;
6019         samplepos_t latency_skip;
6020         BufferSet buffers;
6021         samplepos_t len = end - start;
6022         bool need_block_size_reset = false;
6023         ChanCount const max_proc = track.max_processor_streams ();
6024         string legal_playlist_name;
6025         string possible_path;
6026
6027         if (end <= start) {
6028                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
6029                                          end, start) << endmsg;
6030                 return result;
6031         }
6032
6033         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
6034                         include_endpoint, for_export, for_freeze);
6035
6036         if (diskstream_channels.n(track.data_type()) < 1) {
6037                 error << _("Cannot write a range with no data.") << endmsg;
6038                 return result;
6039         }
6040
6041         // block all process callback handling
6042
6043         block_processing ();
6044
6045         {
6046                 // synchronize with AudioEngine::process_callback()
6047                 // make sure processing is not currently running
6048                 // and processing_blocked() is honored before
6049                 // acquiring thread buffers
6050                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6051         }
6052
6053         _bounce_processing_active = true;
6054
6055         /* call tree *MUST* hold route_lock */
6056
6057         if ((playlist = track.playlist()) == 0) {
6058                 goto out;
6059         }
6060
6061         legal_playlist_name = legalize_for_path (playlist->name());
6062
6063         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
6064
6065                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6066                 string path = ((track.data_type() == DataType::AUDIO)
6067                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6068                                : new_midi_source_path (legal_playlist_name));
6069
6070                 if (path.empty()) {
6071                         goto out;
6072                 }
6073
6074                 try {
6075                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, sample_rate());
6076                 }
6077
6078                 catch (failed_constructor& err) {
6079                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6080                         goto out;
6081                 }
6082
6083                 srcs.push_back (source);
6084         }
6085
6086         /* tell redirects that care that we are about to use a much larger
6087          * blocksize. this will flush all plugins too, so that they are ready
6088          * to be used for this process.
6089          */
6090
6091         need_block_size_reset = true;
6092         track.set_block_size (bounce_chunk_size);
6093         _engine.main_thread()->get_buffers ();
6094
6095         position = start;
6096         to_do = len;
6097         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6098
6099         /* create a set of reasonably-sized buffers */
6100         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6101                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6102         }
6103         buffers.set_count (max_proc);
6104
6105         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6106                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6107                 boost::shared_ptr<MidiSource> ms;
6108                 if (afs) {
6109                         afs->prepare_for_peakfile_writes ();
6110                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6111                         Source::Lock lock(ms->mutex());
6112                         ms->mark_streaming_write_started(lock);
6113                 }
6114         }
6115
6116         while (to_do && !itt.cancel) {
6117
6118                 this_chunk = min (to_do, bounce_chunk_size);
6119
6120                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6121                         goto out;
6122                 }
6123
6124                 start += this_chunk;
6125                 to_do -= this_chunk;
6126                 itt.progress = (float) (1.0 - ((double) to_do / len));
6127
6128                 if (latency_skip >= bounce_chunk_size) {
6129                         latency_skip -= bounce_chunk_size;
6130                         continue;
6131                 }
6132
6133                 const samplecnt_t current_chunk = this_chunk - latency_skip;
6134
6135                 uint32_t n = 0;
6136                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6137                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6138                         boost::shared_ptr<MidiSource> ms;
6139
6140                         if (afs) {
6141                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6142                                         goto out;
6143                                 }
6144                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6145                                 Source::Lock lock(ms->mutex());
6146
6147                                 const MidiBuffer& buf = buffers.get_midi(0);
6148                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6149                                         Evoral::Event<samplepos_t> ev = *i;
6150                                         ev.set_time(ev.time() - position);
6151                                         ms->append_event_samples(lock, ev, ms->timeline_position());
6152                                 }
6153                         }
6154                 }
6155                 latency_skip = 0;
6156         }
6157
6158         /* post-roll, pick up delayed processor output */
6159         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6160
6161         while (latency_skip && !itt.cancel) {
6162                 this_chunk = min (latency_skip, bounce_chunk_size);
6163                 latency_skip -= this_chunk;
6164
6165                 buffers.silence (this_chunk, 0);
6166                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6167
6168                 uint32_t n = 0;
6169                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6170                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6171
6172                         if (afs) {
6173                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6174                                         goto out;
6175                                 }
6176                         }
6177                 }
6178         }
6179
6180         if (!itt.cancel) {
6181
6182                 time_t now;
6183                 struct tm* xnow;
6184                 time (&now);
6185                 xnow = localtime (&now);
6186
6187                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6188                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6189                         boost::shared_ptr<MidiSource> ms;
6190
6191                         if (afs) {
6192                                 afs->update_header (position, *xnow, now);
6193                                 afs->flush_header ();
6194                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6195                                 Source::Lock lock(ms->mutex());
6196                                 ms->mark_streaming_write_completed(lock);
6197                         }
6198                 }
6199
6200                 /* construct a region to represent the bounced material */
6201
6202                 PropertyList plist;
6203
6204                 plist.add (Properties::start, 0);
6205                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6206                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6207
6208                 result = RegionFactory::create (srcs, plist);
6209
6210         }
6211
6212   out:
6213         if (!result) {
6214                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6215                         (*src)->mark_for_remove ();
6216                         (*src)->drop_references ();
6217                 }
6218
6219         } else {
6220                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6221                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6222
6223                         if (afs)
6224                                 afs->done_with_peakfile_writes ();
6225                 }
6226         }
6227
6228         _bounce_processing_active = false;
6229
6230         if (need_block_size_reset) {
6231                 _engine.main_thread()->drop_buffers ();
6232                 track.set_block_size (get_block_size());
6233         }
6234
6235         unblock_processing ();
6236
6237         return result;
6238 }
6239
6240 gain_t*
6241 Session::gain_automation_buffer() const
6242 {
6243         return ProcessThread::gain_automation_buffer ();
6244 }
6245
6246 gain_t*
6247 Session::trim_automation_buffer() const
6248 {
6249         return ProcessThread::trim_automation_buffer ();
6250 }
6251
6252 gain_t*
6253 Session::send_gain_automation_buffer() const
6254 {
6255         return ProcessThread::send_gain_automation_buffer ();
6256 }
6257
6258 gain_t*
6259 Session::scratch_automation_buffer() const
6260 {
6261         return ProcessThread::scratch_automation_buffer ();
6262 }
6263
6264 pan_t**
6265 Session::pan_automation_buffer() const
6266 {
6267         return ProcessThread::pan_automation_buffer ();
6268 }
6269
6270 BufferSet&
6271 Session::get_silent_buffers (ChanCount count)
6272 {
6273         return ProcessThread::get_silent_buffers (count);
6274 }
6275
6276 BufferSet&
6277 Session::get_scratch_buffers (ChanCount count, bool silence)
6278 {
6279         return ProcessThread::get_scratch_buffers (count, silence);
6280 }
6281
6282 BufferSet&
6283 Session::get_noinplace_buffers (ChanCount count)
6284 {
6285         return ProcessThread::get_noinplace_buffers (count);
6286 }
6287
6288 BufferSet&
6289 Session::get_route_buffers (ChanCount count, bool silence)
6290 {
6291         return ProcessThread::get_route_buffers (count, silence);
6292 }
6293
6294
6295 BufferSet&
6296 Session::get_mix_buffers (ChanCount count)
6297 {
6298         return ProcessThread::get_mix_buffers (count);
6299 }
6300
6301 uint32_t
6302 Session::ntracks () const
6303 {
6304         uint32_t n = 0;
6305         boost::shared_ptr<RouteList> r = routes.reader ();
6306
6307         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6308                 if (boost::dynamic_pointer_cast<Track> (*i)) {
6309                         ++n;
6310                 }
6311         }
6312
6313         return n;
6314 }
6315
6316 uint32_t
6317 Session::nbusses () const
6318 {
6319         uint32_t n = 0;
6320         boost::shared_ptr<RouteList> r = routes.reader ();
6321
6322         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6323                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6324                         ++n;
6325                 }
6326         }
6327
6328         return n;
6329 }
6330
6331 uint32_t
6332 Session::nstripables (bool with_monitor) const
6333 {
6334         uint32_t rv = routes.reader()->size ();
6335         rv += _vca_manager->vcas ().size ();
6336
6337         if (with_monitor) {
6338                 return rv;
6339         }
6340
6341         if (_monitor_out) {
6342                 assert (rv > 0);
6343                 --rv;
6344         }
6345         return rv;
6346 }
6347
6348 void
6349 Session::add_automation_list(AutomationList *al)
6350 {
6351         automation_lists[al->id()] = al;
6352 }
6353
6354 /** @return true if there is at least one record-enabled track, otherwise false */
6355 bool
6356 Session::have_rec_enabled_track () const
6357 {
6358         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6359 }
6360
6361 bool
6362 Session::have_rec_disabled_track () const
6363 {
6364     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6365 }
6366
6367 /** Update the state of our rec-enabled tracks flag */
6368 void
6369 Session::update_route_record_state ()
6370 {
6371         boost::shared_ptr<RouteList> rl = routes.reader ();
6372         RouteList::iterator i = rl->begin();
6373         while (i != rl->end ()) {
6374
6375                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6376                                     if (tr && tr->rec_enable_control()->get_value()) {
6377                         break;
6378                 }
6379
6380                 ++i;
6381         }
6382
6383         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6384
6385         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6386
6387         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6388                 RecordStateChanged (); /* EMIT SIGNAL */
6389         }
6390
6391         for (i = rl->begin(); i != rl->end (); ++i) {
6392                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6393                 if (tr && !tr->rec_enable_control()->get_value()) {
6394                         break;
6395                 }
6396         }
6397
6398         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6399
6400         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6401
6402         if (record_status() == Recording && record_arm_state_changed ) {
6403                 RecordArmStateChanged ();
6404         }
6405
6406 }
6407
6408 void
6409 Session::listen_position_changed ()
6410 {
6411         ProcessorChangeBlocker pcb (this);
6412         boost::shared_ptr<RouteList> r = routes.reader ();
6413         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6414                 (*i)->listen_position_changed ();
6415         }
6416 }
6417
6418 void
6419 Session::solo_control_mode_changed ()
6420 {
6421         if (soloing() || listening()) {
6422                 if (loading()) {
6423                         /* We can't use ::clear_all_solo_state() here because during
6424                            session loading at program startup, that will queue a call
6425                            to rt_clear_all_solo_state() that will not execute until
6426                            AFTER solo states have been established (thus throwing away
6427                            the session's saved solo state). So just explicitly turn
6428                            them all off.
6429                         */
6430                         set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6431                 } else {
6432                         clear_all_solo_state (get_routes());
6433                 }
6434         }
6435 }
6436
6437 /** Called when a property of one of our route groups changes */
6438 void
6439 Session::route_group_property_changed (RouteGroup* rg)
6440 {
6441         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6442 }
6443
6444 /** Called when a route is added to one of our route groups */
6445 void
6446 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6447 {
6448         RouteAddedToRouteGroup (rg, r);
6449 }
6450
6451 /** Called when a route is removed from one of our route groups */
6452 void
6453 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6454 {
6455         update_route_record_state ();
6456         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6457
6458         if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6459                 remove_route_group (*rg);
6460         }
6461 }
6462
6463 boost::shared_ptr<RouteList>
6464 Session::get_tracks () const
6465 {
6466         boost::shared_ptr<RouteList> rl = routes.reader ();
6467         boost::shared_ptr<RouteList> tl (new RouteList);
6468
6469         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6470                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6471                         assert (!(*r)->is_auditioner()); // XXX remove me
6472                         tl->push_back (*r);
6473                 }
6474         }
6475         return tl;
6476 }
6477
6478 boost::shared_ptr<RouteList>
6479 Session::get_routes_with_regions_at (samplepos_t const p) const
6480 {
6481         boost::shared_ptr<RouteList> r = routes.reader ();
6482         boost::shared_ptr<RouteList> rl (new RouteList);
6483
6484         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6485                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6486                 if (!tr) {
6487                         continue;
6488                 }
6489
6490                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6491                 if (!pl) {
6492                         continue;
6493                 }
6494
6495                 if (pl->has_region_at (p)) {
6496                         rl->push_back (*i);
6497                 }
6498         }
6499
6500         return rl;
6501 }
6502
6503 void
6504 Session::goto_end ()
6505 {
6506         if (_session_range_location) {
6507                 request_locate (_session_range_location->end(), false);
6508         } else {
6509                 request_locate (0, false);
6510         }
6511 }
6512
6513 void
6514 Session::goto_start (bool and_roll)
6515 {
6516         if (_session_range_location) {
6517                 request_locate (_session_range_location->start(), and_roll);
6518         } else {
6519                 request_locate (0, and_roll);
6520         }
6521 }
6522
6523 samplepos_t
6524 Session::current_start_sample () const
6525 {
6526         return _session_range_location ? _session_range_location->start() : 0;
6527 }
6528
6529 samplepos_t
6530 Session::current_end_sample () const
6531 {
6532         return _session_range_location ? _session_range_location->end() : 0;
6533 }
6534
6535 void
6536 Session::set_session_range_location (samplepos_t start, samplepos_t end)
6537 {
6538         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6539         _locations->add (_session_range_location);
6540 }
6541
6542 void
6543 Session::step_edit_status_change (bool yn)
6544 {
6545         bool send = false;
6546
6547         bool val = false;
6548         if (yn) {
6549                 send = (_step_editors == 0);
6550                 val = true;
6551
6552                 _step_editors++;
6553         } else {
6554                 send = (_step_editors == 1);
6555                 val = false;
6556
6557                 if (_step_editors > 0) {
6558                         _step_editors--;
6559                 }
6560         }
6561
6562         if (send) {
6563                 StepEditStatusChange (val);
6564         }
6565 }
6566
6567
6568 void
6569 Session::start_time_changed (samplepos_t old)
6570 {
6571         /* Update the auto loop range to match the session range
6572            (unless the auto loop range has been changed by the user)
6573         */
6574
6575         Location* s = _locations->session_range_location ();
6576         if (s == 0) {
6577                 return;
6578         }
6579
6580         Location* l = _locations->auto_loop_location ();
6581
6582         if (l && l->start() == old) {
6583                 l->set_start (s->start(), true);
6584         }
6585         set_dirty ();
6586 }
6587
6588 void
6589 Session::end_time_changed (samplepos_t old)
6590 {
6591         /* Update the auto loop range to match the session range
6592            (unless the auto loop range has been changed by the user)
6593         */
6594
6595         Location* s = _locations->session_range_location ();
6596         if (s == 0) {
6597                 return;
6598         }
6599
6600         Location* l = _locations->auto_loop_location ();
6601
6602         if (l && l->end() == old) {
6603                 l->set_end (s->end(), true);
6604         }
6605         set_dirty ();
6606 }
6607
6608 std::vector<std::string>
6609 Session::source_search_path (DataType type) const
6610 {
6611         Searchpath sp;
6612
6613         if (session_dirs.size() == 1) {
6614                 switch (type) {
6615                 case DataType::AUDIO:
6616                         sp.push_back (_session_dir->sound_path());
6617                         break;
6618                 case DataType::MIDI:
6619                         sp.push_back (_session_dir->midi_path());
6620                         break;
6621                 }
6622         } else {
6623                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6624                         SessionDirectory sdir (i->path);
6625                         switch (type) {
6626                         case DataType::AUDIO:
6627                                 sp.push_back (sdir.sound_path());
6628                                 break;
6629                         case DataType::MIDI:
6630                                 sp.push_back (sdir.midi_path());
6631                                 break;
6632                         }
6633                 }
6634         }
6635
6636         if (type == DataType::AUDIO) {
6637                 const string sound_path_2X = _session_dir->sound_path_2X();
6638                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6639                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6640                                 sp.push_back (sound_path_2X);
6641                         }
6642                 }
6643         }
6644
6645         // now check the explicit (possibly user-specified) search path
6646
6647         switch (type) {
6648         case DataType::AUDIO:
6649                 sp += Searchpath(config.get_audio_search_path ());
6650                 break;
6651         case DataType::MIDI:
6652                 sp += Searchpath(config.get_midi_search_path ());
6653                 break;
6654         }
6655
6656         return sp;
6657 }
6658
6659 void
6660 Session::ensure_search_path_includes (const string& path, DataType type)
6661 {
6662         Searchpath sp;
6663
6664         if (path == ".") {
6665                 return;
6666         }
6667
6668         switch (type) {
6669         case DataType::AUDIO:
6670                 sp += Searchpath(config.get_audio_search_path ());
6671                 break;
6672         case DataType::MIDI:
6673                 sp += Searchpath (config.get_midi_search_path ());
6674                 break;
6675         }
6676
6677         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6678                 /* No need to add this new directory if it has the same inode as
6679                    an existing one; checking inode rather than name prevents duplicated
6680                    directories when we are using symlinks.
6681
6682                    On Windows, I think we could just do if (*i == path) here.
6683                 */
6684                 if (PBD::equivalent_paths (*i, path)) {
6685                         return;
6686                 }
6687         }
6688
6689         sp += path;
6690
6691         switch (type) {
6692         case DataType::AUDIO:
6693                 config.set_audio_search_path (sp.to_string());
6694                 break;
6695         case DataType::MIDI:
6696                 config.set_midi_search_path (sp.to_string());
6697                 break;
6698         }
6699 }
6700
6701 void
6702 Session::remove_dir_from_search_path (const string& dir, DataType type)
6703 {
6704         Searchpath sp;
6705
6706         switch (type) {
6707         case DataType::AUDIO:
6708                 sp = Searchpath(config.get_audio_search_path ());
6709                 break;
6710         case DataType::MIDI:
6711                 sp = Searchpath (config.get_midi_search_path ());
6712                 break;
6713         }
6714
6715         sp -= dir;
6716
6717         switch (type) {
6718         case DataType::AUDIO:
6719                 config.set_audio_search_path (sp.to_string());
6720                 break;
6721         case DataType::MIDI:
6722                 config.set_midi_search_path (sp.to_string());
6723                 break;
6724         }
6725
6726 }
6727
6728 boost::shared_ptr<Speakers>
6729 Session::get_speakers()
6730 {
6731         return _speakers;
6732 }
6733
6734 list<string>
6735 Session::unknown_processors () const
6736 {
6737         list<string> p;
6738
6739         boost::shared_ptr<RouteList> r = routes.reader ();
6740         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6741                 list<string> t = (*i)->unknown_processors ();
6742                 copy (t.begin(), t.end(), back_inserter (p));
6743         }
6744
6745         p.sort ();
6746         p.unique ();
6747
6748         return p;
6749 }
6750
6751 void
6752 Session::set_worst_io_latencies_x (IOChange, void *)
6753 {
6754                 set_worst_io_latencies ();
6755 }
6756
6757 void
6758 Session::send_latency_compensation_change ()
6759 {
6760         /* As a result of Send::set_output_latency()
6761          * or InternalReturn::set_playback_offset ()
6762          * the send's own latency can change (source track
6763          * is aligned with target bus).
6764          *
6765          * This can only happen be triggered by
6766          * Route::update_signal_latency ()
6767          * when updating the processor latency.
6768          *
6769          * We need to walk the graph again to take those changes into account
6770          * (we should probably recurse or process the graph in a 2 step process).
6771          */
6772         ++_send_latency_changes;
6773 }
6774
6775 bool
6776 Session::update_route_latency (bool playback, bool apply_to_delayline)
6777 {
6778         /* Note: RouteList is process-graph sorted */
6779         boost::shared_ptr<RouteList> r = routes.reader ();
6780
6781         if (playback) {
6782                 /* reverse the list so that we work backwards from the last route to run to the first,
6783                  * this is not needed, but can help to reduce the iterations for aux-sends.
6784                  */
6785                 RouteList* rl = routes.reader().get();
6786                 r.reset (new RouteList (*rl));
6787                 reverse (r->begin(), r->end());
6788         }
6789
6790         bool changed = false;
6791         int bailout = 0;
6792 restart:
6793         _send_latency_changes = 0;
6794         _worst_route_latency = 0;
6795
6796         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6797                 // if (!(*i)->active()) { continue ; } // TODO
6798                 samplecnt_t l;
6799                 if ((*i)->signal_latency () != (l = (*i)->update_signal_latency (apply_to_delayline))) {
6800                         changed = true;
6801                 }
6802                 _worst_route_latency = std::max (l, _worst_route_latency);
6803         }
6804
6805         if (_send_latency_changes > 0) {
6806                 // only 1 extra iteration is needed (we allow only 1 level of aux-sends)
6807                 // BUT..  jack'n'sends'n'bugs
6808                 if (++bailout < 5) {
6809                         cerr << "restarting Session::update_latency. # of send changes: " << _send_latency_changes << " iteration: " << bailout << endl;
6810                         goto restart;
6811                 }
6812         }
6813
6814         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_route_latency, (changed ? "yes" : "no")));
6815
6816         return changed;
6817 }
6818
6819 void
6820 Session::update_latency (bool playback)
6821 {
6822         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6823
6824         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6825                 return;
6826         }
6827         if (!_engine.running()) {
6828                 return;
6829         }
6830
6831         /* Note; RouteList is sorted as process-graph */
6832         boost::shared_ptr<RouteList> r = routes.reader ();
6833
6834         if (playback) {
6835                 /* reverse the list so that we work backwards from the last route to run to the first */
6836                 RouteList* rl = routes.reader().get();
6837                 r.reset (new RouteList (*rl));
6838                 reverse (r->begin(), r->end());
6839         }
6840
6841         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6842                 samplecnt_t latency = (*i)->set_private_port_latencies (playback);
6843                 (*i)->set_public_port_latencies (latency, playback);
6844         }
6845
6846         if (playback) {
6847                 set_worst_output_latency ();
6848                 update_route_latency (true, true);
6849         } else {
6850                 set_worst_input_latency ();
6851                 update_route_latency (false, false);
6852         }
6853
6854         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6855 }
6856
6857 void
6858 Session::initialize_latencies ()
6859 {
6860         {
6861                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6862                 update_latency (false);
6863                 update_latency (true);
6864         }
6865
6866         set_worst_io_latencies ();
6867 }
6868
6869 void
6870 Session::set_worst_io_latencies ()
6871 {
6872         set_worst_output_latency ();
6873         set_worst_input_latency ();
6874 }
6875
6876 void
6877 Session::set_worst_output_latency ()
6878 {
6879         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6880                 return;
6881         }
6882
6883         _worst_output_latency = 0;
6884
6885         if (!_engine.connected()) {
6886                 return;
6887         }
6888
6889         boost::shared_ptr<RouteList> r = routes.reader ();
6890
6891         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6892                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6893         }
6894
6895         _worst_output_latency = max (_worst_output_latency, _click_io->latency());
6896
6897         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6898 }
6899
6900 void
6901 Session::set_worst_input_latency ()
6902 {
6903         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6904                 return;
6905         }
6906
6907         _worst_input_latency = 0;
6908
6909         if (!_engine.connected()) {
6910                 return;
6911         }
6912
6913         boost::shared_ptr<RouteList> r = routes.reader ();
6914
6915         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6916                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6917         }
6918
6919         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6920 }
6921
6922 void
6923 Session::update_latency_compensation (bool force_whole_graph)
6924 {
6925         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6926                 return;
6927         }
6928
6929         bool some_track_latency_changed = update_route_latency (false, false);
6930
6931         if (some_track_latency_changed || force_whole_graph)  {
6932                 _engine.update_latencies ();
6933                 /* above call will ask the backend up update its latencies, which
6934                  * eventually will trigger  AudioEngine::latency_callback () and
6935                  * call Session::update_latency ()
6936                  */
6937         } else {
6938                 boost::shared_ptr<RouteList> r = routes.reader ();
6939                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6940                         (*i)->apply_latency_compensation ();
6941                 }
6942         }
6943 }
6944
6945 char
6946 Session::session_name_is_legal (const string& path)
6947 {
6948         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6949
6950         for (int i = 0; illegal_chars[i]; ++i) {
6951                 if (path.find (illegal_chars[i]) != string::npos) {
6952                         return illegal_chars[i];
6953                 }
6954         }
6955
6956         return 0;
6957 }
6958
6959 void
6960 Session::notify_presentation_info_change ()
6961 {
6962         if (deletion_in_progress()) {
6963                 return;
6964         }
6965
6966         reassign_track_numbers();
6967
6968 #ifdef USE_TRACKS_CODE_FEATURES
6969         /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6970          * if track order has been changed by user
6971          */
6972         reconnect_existing_routes(true, true);
6973 #endif
6974
6975 }
6976
6977 bool
6978 Session::operation_in_progress (GQuark op) const
6979 {
6980         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6981 }
6982
6983 boost::shared_ptr<Port>
6984 Session::ltc_output_port () const
6985 {
6986         return _ltc_output ? _ltc_output->nth (0) : boost::shared_ptr<Port> ();
6987 }
6988
6989 void
6990 Session::reconnect_ltc_output ()
6991 {
6992         if (_ltc_output) {
6993
6994                 string src = Config->get_ltc_output_port();
6995
6996                 _ltc_output->disconnect (this);
6997
6998                 if (src != _("None") && !src.empty())  {
6999                         _ltc_output->nth (0)->connect (src);
7000                 }
7001         }
7002 }
7003
7004 void
7005 Session::set_range_selection (samplepos_t start, samplepos_t end)
7006 {
7007         _range_selection = Evoral::Range<samplepos_t> (start, end);
7008 #ifdef USE_TRACKS_CODE_FEATURES
7009         follow_playhead_priority ();
7010 #endif
7011 }
7012
7013 void
7014 Session::set_object_selection (samplepos_t start, samplepos_t end)
7015 {
7016         _object_selection = Evoral::Range<samplepos_t> (start, end);
7017 #ifdef USE_TRACKS_CODE_FEATURES
7018         follow_playhead_priority ();
7019 #endif
7020 }
7021
7022 void
7023 Session::clear_range_selection ()
7024 {
7025         _range_selection = Evoral::Range<samplepos_t> (-1,-1);
7026 #ifdef USE_TRACKS_CODE_FEATURES
7027         follow_playhead_priority ();
7028 #endif
7029 }
7030
7031 void
7032 Session::clear_object_selection ()
7033 {
7034         _object_selection = Evoral::Range<samplepos_t> (-1,-1);
7035 #ifdef USE_TRACKS_CODE_FEATURES
7036         follow_playhead_priority ();
7037 #endif
7038 }
7039
7040 void
7041 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
7042                 const ChanCount& input_start,
7043                 const ChanCount& output_start,
7044                 const ChanCount& input_offset,
7045                 const ChanCount& output_offset)
7046 {
7047         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7048         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7049                                 input_start, output_start,
7050                                 input_offset, output_offset));
7051
7052         auto_connect_thread_wakeup ();
7053 }
7054
7055 void
7056 Session::auto_connect_thread_wakeup ()
7057 {
7058         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7059                 pthread_cond_signal (&_auto_connect_cond);
7060                 pthread_mutex_unlock (&_auto_connect_mutex);
7061         }
7062 }
7063
7064 void
7065 Session::queue_latency_recompute ()
7066 {
7067         g_atomic_int_inc (&_latency_recompute_pending);
7068         auto_connect_thread_wakeup ();
7069 }
7070
7071 void
7072 Session::auto_connect (const AutoConnectRequest& ar)
7073 {
7074         boost::shared_ptr<Route> route = ar.route.lock();
7075
7076         if (!route) { return; }
7077
7078         if (!IO::connecting_legal) {
7079                 return;
7080         }
7081
7082         /* If both inputs and outputs are auto-connected to physical ports,
7083          * use the max of input and output offsets to ensure auto-connected
7084          * port numbers always match up (e.g. the first audio input and the
7085          * first audio output of the route will have the same physical
7086          * port number).  Otherwise just use the lowest input or output
7087          * offset possible.
7088          */
7089
7090         const bool in_out_physical =
7091                 (Config->get_input_auto_connect() & AutoConnectPhysical)
7092                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7093                 && ar.connect_inputs;
7094
7095         const ChanCount in_offset = in_out_physical
7096                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7097                 : ar.input_offset;
7098
7099         const ChanCount out_offset = in_out_physical
7100                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7101                 : ar.output_offset;
7102
7103         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7104                 vector<string> physinputs;
7105                 vector<string> physoutputs;
7106
7107
7108                 /* for connecting track inputs we only want MIDI ports marked
7109                  * for "music".
7110                  */
7111
7112                 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7113
7114                 if (!physinputs.empty() && ar.connect_inputs) {
7115                         uint32_t nphysical_in = physinputs.size();
7116
7117                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7118                                 string port;
7119
7120                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7121                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7122                                 }
7123
7124                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7125                                         break;
7126                                 }
7127                         }
7128                 }
7129
7130                 if (!physoutputs.empty()) {
7131                         uint32_t nphysical_out = physoutputs.size();
7132                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7133                                 string port;
7134
7135                                 /* Waves Tracks:
7136                                  * do not create new connections if we reached the limit of physical outputs
7137                                  * in Multi Out mode
7138                                  */
7139                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7140                                                 ARDOUR::Profile->get_trx () &&
7141                                                 ar.output_offset.get(*t) == nphysical_out ) {
7142                                         break;
7143                                 }
7144
7145                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7146                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7147                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7148                                         /* master bus is audio only */
7149                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7150                                                 port = _master_out->input()->ports().port(*t,
7151                                                                 i % _master_out->input()->n_ports().get(*t))->name();
7152                                         }
7153                                 }
7154
7155                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7156                                         break;
7157                                 }
7158                         }
7159                 }
7160         }
7161 }
7162
7163 void
7164 Session::auto_connect_thread_start ()
7165 {
7166         if (g_atomic_int_get (&_ac_thread_active)) {
7167                 return;
7168         }
7169
7170         while (!_auto_connect_queue.empty ()) {
7171                 _auto_connect_queue.pop ();
7172         }
7173
7174         g_atomic_int_set (&_ac_thread_active, 1);
7175         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7176                 g_atomic_int_set (&_ac_thread_active, 0);
7177         }
7178 }
7179
7180 void
7181 Session::auto_connect_thread_terminate ()
7182 {
7183         if (!g_atomic_int_get (&_ac_thread_active)) {
7184                 return;
7185         }
7186
7187         {
7188                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7189                 while (!_auto_connect_queue.empty ()) {
7190                         _auto_connect_queue.pop ();
7191                 }
7192         }
7193
7194         /* cannot use auto_connect_thread_wakeup() because that is allowed to
7195          * fail to wakeup the thread.
7196          */
7197
7198         pthread_mutex_lock (&_auto_connect_mutex);
7199         g_atomic_int_set (&_ac_thread_active, 0);
7200         pthread_cond_signal (&_auto_connect_cond);
7201         pthread_mutex_unlock (&_auto_connect_mutex);
7202
7203         void *status;
7204         pthread_join (_auto_connect_thread, &status);
7205 }
7206
7207 void *
7208 Session::auto_connect_thread (void *arg)
7209 {
7210         Session *s = static_cast<Session *>(arg);
7211         s->auto_connect_thread_run ();
7212         pthread_exit (0);
7213         return 0;
7214 }
7215
7216 void
7217 Session::auto_connect_thread_run ()
7218 {
7219         pthread_set_name (X_("autoconnect"));
7220         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7221         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7222         pthread_mutex_lock (&_auto_connect_mutex);
7223         while (g_atomic_int_get (&_ac_thread_active)) {
7224
7225                 if (!_auto_connect_queue.empty ()) {
7226                         // Why would we need the process lock ??
7227                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7228                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7229                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
7230                         //   We have control over those, but what does jack do?
7231                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7232
7233                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7234                         while (!_auto_connect_queue.empty ()) {
7235                                 const AutoConnectRequest ar (_auto_connect_queue.front());
7236                                 _auto_connect_queue.pop ();
7237                                 lx.release ();
7238                                 auto_connect (ar);
7239                                 lx.acquire ();
7240                         }
7241                 }
7242
7243                 if (!actively_recording ()) { // might not be needed,
7244                         /* this is only used for updating plugin latencies, the
7245                          * graph does not change. so it's safe in general.
7246                          * BUT..
7247                          * update_latency_compensation ()
7248                          * calls DiskWriter::set_capture_offset () which
7249                          * modifies the capture-offset, which can be a problem.
7250                          */
7251                         while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7252                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7253                                 update_latency_compensation ();
7254                         }
7255                 }
7256
7257                 {
7258                         // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7259                         // jack1 cannot cope with removing ports while processing
7260                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7261                         AudioEngine::instance()->clear_pending_port_deletions ();
7262                 }
7263
7264                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7265         }
7266         pthread_mutex_unlock (&_auto_connect_mutex);
7267 }
7268
7269 void
7270 Session::cancel_all_solo ()
7271 {
7272         StripableList sl;
7273
7274         get_stripables (sl);
7275
7276         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7277         clear_all_solo_state (routes.reader());
7278 }
7279
7280 void
7281 Session::maybe_update_tempo_from_midiclock_tempo (float bpm)
7282 {
7283         if (_tempo_map->n_tempos() == 1) {
7284                 TempoSection& ts (_tempo_map->tempo_section_at_sample (0));
7285                 if (fabs (ts.note_types_per_minute() - bpm) > (0.01 * ts.note_types_per_minute())) {
7286                         const Tempo tempo (bpm, 4.0, bpm);
7287                         std::cerr << "new tempo " << bpm << " old " << ts.note_types_per_minute() << std::endl;
7288                         _tempo_map->replace_tempo (ts, tempo, 0.0, 0.0, AudioTime);
7289                 }
7290         }
7291 }