libs/ardour/session.cc

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