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