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