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