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