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         { // RCU Writer scope
3721                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3722                 RCUWriter<RouteList> writer (routes);
3723                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3724
3725
3726                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3727
3728                         if (*iter == _master_out) {
3729                                 continue;
3730                         }
3731
3732                         /* speed up session deletion, don't do the solo dance */
3733                         if (0 == (_state_of_the_state & Deletion)) {
3734                                 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3735                         }
3736
3737                         rs->remove (*iter);
3738
3739                         /* deleting the master out seems like a dumb
3740                            idea, but its more of a UI policy issue
3741                            than our concern.
3742                         */
3743
3744                         if (*iter == _master_out) {
3745                                 _master_out = boost::shared_ptr<Route> ();
3746                         }
3747
3748                         if (*iter == _monitor_out) {
3749                                 _monitor_out.reset ();
3750                         }
3751
3752                         // We need to disconnect the route's inputs and outputs
3753
3754                         (*iter)->input()->disconnect (0);
3755                         (*iter)->output()->disconnect (0);
3756
3757                         /* if the route had internal sends sending to it, remove them */
3758                         if ((*iter)->internal_return()) {
3759
3760                                 boost::shared_ptr<RouteList> r = routes.reader ();
3761                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3762                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3763                                         if (s) {
3764                                                 (*i)->remove_processor (s);
3765                                         }
3766                                 }
3767                         }
3768
3769                         /* if the monitoring section had a pointer to this route, remove it */
3770                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3771                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3772                                 ProcessorChangeBlocker pcb (this, false);
3773                                 (*iter)->remove_aux_or_listen (_monitor_out);
3774                         }
3775
3776                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3777                         if (mt && mt->step_editing()) {
3778                                 if (_step_editors > 0) {
3779                                         _step_editors--;
3780                                 }
3781                         }
3782                 }
3783
3784                 /* writer goes out of scope, forces route list update */
3785
3786         } // end of RCU Writer scope
3787
3788         update_route_solo_state ();
3789         update_latency_compensation ();
3790         set_dirty();
3791
3792         /* Re-sort routes to remove the graph's current references to the one that is
3793          * going away, then flush old references out of the graph.
3794          * Wave Tracks: reconnect routes
3795          */
3796
3797 #ifdef USE_TRACKS_CODE_FEATURES
3798                 reconnect_existing_routes(true, false);
3799 #else
3800                 routes.flush (); // maybe unsafe, see below.
3801                 resort_routes ();
3802 #endif
3803
3804         if (_process_graph && !(_state_of_the_state & Deletion)) {
3805                 _process_graph->clear_other_chain ();
3806         }
3807
3808         /* get rid of it from the dead wood collection in the route list manager */
3809         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3810
3811         routes.flush ();
3812
3813         /* try to cause everyone to drop their references
3814          * and unregister ports from the backend
3815          */
3816
3817         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3818                 cerr << "Drop references to " << (*iter)->name() << endl;
3819                 (*iter)->drop_references ();
3820         }
3821
3822         if (_state_of_the_state & Deletion) {
3823                 return;
3824         }
3825
3826         PropertyChange so;
3827         so.add (Properties::selected);
3828         so.add (Properties::order);
3829         PresentationInfo::Change (PropertyChange (so));
3830
3831         /* save the new state of the world */
3832
3833         if (save_state (_current_snapshot_name)) {
3834                 save_history (_current_snapshot_name);
3835         }
3836
3837         update_route_record_state ();
3838 }
3839
3840 void
3841 Session::remove_route (boost::shared_ptr<Route> route)
3842 {
3843         boost::shared_ptr<RouteList> rl (new RouteList);
3844         rl->push_back (route);
3845         remove_routes (rl);
3846 }
3847
3848 void
3849 Session::route_mute_changed ()
3850 {
3851         set_dirty ();
3852 }
3853
3854 void
3855 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3856 {
3857         boost::shared_ptr<Route> route (wpr.lock());
3858
3859         if (!route) {
3860                 return;
3861         }
3862
3863         assert (Config->get_solo_control_is_listen_control());
3864
3865         if (route->solo_control()->soloed_by_self_or_masters()) {
3866
3867                 if (Config->get_exclusive_solo()) {
3868
3869                         RouteGroup* rg = route->route_group ();
3870                         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3871
3872                         boost::shared_ptr<RouteList> r = routes.reader ();
3873
3874                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3875                                 if ((*i) == route) {
3876                                         /* already changed */
3877                                         continue;
3878                                 }
3879
3880                                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3881                                         /* route does not get solo propagated to it */
3882                                         continue;
3883                                 }
3884
3885                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3886                                         /* this route is a part of the same solo group as the route
3887                                          * that was changed. Changing that route did change or will
3888                                          * change all group members appropriately, so we can ignore it
3889                                          * here
3890                                          */
3891                                         continue;
3892                                 }
3893                                 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3894                         }
3895                 }
3896
3897                 _listen_cnt++;
3898
3899         } else if (_listen_cnt > 0) {
3900
3901                 _listen_cnt--;
3902         }
3903 }
3904
3905 void
3906 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3907 {
3908         boost::shared_ptr<Route> route (wpr.lock());
3909
3910         if (!route) {
3911                 return;
3912         }
3913
3914         bool send_changed = false;
3915
3916         if (route->solo_isolate_control()->solo_isolated()) {
3917                 if (_solo_isolated_cnt == 0) {
3918                         send_changed = true;
3919                 }
3920                 _solo_isolated_cnt++;
3921         } else if (_solo_isolated_cnt > 0) {
3922                 _solo_isolated_cnt--;
3923                 if (_solo_isolated_cnt == 0) {
3924                         send_changed = true;
3925                 }
3926         }
3927
3928         if (send_changed) {
3929                 IsolatedChanged (); /* EMIT SIGNAL */
3930         }
3931 }
3932
3933 void
3934 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
3935 {
3936         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
3937
3938         boost::shared_ptr<Route> route (wpr.lock());
3939
3940         if (!route) {
3941                 return;
3942         }
3943
3944         if (Config->get_solo_control_is_listen_control()) {
3945                 route_listen_changed (group_override, wpr);
3946                 return;
3947         }
3948
3949         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()));
3950
3951         if (route->solo_control()->transitioned_into_solo() == 0) {
3952                 /* route solo changed by upstream/downstream or clear all solo state; not interesting
3953                    to Session.
3954                 */
3955                 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()));
3956                 return;
3957         }
3958
3959         boost::shared_ptr<RouteList> r = routes.reader ();
3960         int32_t delta = route->solo_control()->transitioned_into_solo ();
3961
3962         /* the route may be a member of a group that has shared-solo
3963          * semantics. If so, then all members of that group should follow the
3964          * solo of the changed route. But ... this is optional, controlled by a
3965          * Controllable::GroupControlDisposition.
3966          *
3967          * The first argument to the signal that this method is connected to is the
3968          * GroupControlDisposition value that was used to change solo.
3969          *
3970          * If the solo change was done with group semantics (either InverseGroup
3971          * (force the entire group to change even if the group shared solo is
3972          * disabled) or UseGroup (use the group, which may or may not have the
3973          * shared solo property enabled)) then as we propagate the change to
3974          * the entire session we should IGNORE THE GROUP that the changed route
3975          * belongs to.
3976          */
3977
3978         RouteGroup* rg = route->route_group ();
3979         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3980
3981         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
3982
3983         if (delta == 1 && Config->get_exclusive_solo()) {
3984
3985                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3986
3987                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3988
3989                         if ((*i) == route) {
3990                                 /* already changed */
3991                                 continue;
3992                         }
3993
3994                         if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3995                                 /* route does not get solo propagated to it */
3996                                 continue;
3997                         }
3998
3999                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4000                                 /* this route is a part of the same solo group as the route
4001                                  * that was changed. Changing that route did change or will
4002                                  * change all group members appropriately, so we can ignore it
4003                                  * here
4004                                  */
4005                                 continue;
4006                         }
4007
4008                         (*i)->solo_control()->set_value (0.0, group_override);
4009                 }
4010         }
4011
4012         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4013
4014         RouteList uninvolved;
4015
4016         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4017
4018         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4019                 bool via_sends_only;
4020                 bool in_signal_flow;
4021
4022                 if ((*i) == route) {
4023                         /* already changed */
4024                         continue;
4025                 }
4026
4027                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4028                         /* route does not get solo propagated to it */
4029                         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(),
4030                                                                   (*i)->can_solo()));
4031                         continue;
4032                 }
4033
4034                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4035                         /* this route is a part of the same solo group as the route
4036                          * that was changed. Changing that route did change or will
4037                          * change all group members appropriately, so we can ignore it
4038                          * here
4039                          */
4040                         continue;
4041                 }
4042
4043                 in_signal_flow = false;
4044
4045                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4046
4047                 if ((*i)->feeds (route, &via_sends_only)) {
4048                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4049                         if (!via_sends_only) {
4050                                 if (!route->soloed_by_others_upstream()) {
4051                                         (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4052                                 } else {
4053                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4054                                 }
4055                         } else {
4056                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4057                         }
4058                         in_signal_flow = true;
4059                 } else {
4060                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4061                 }
4062
4063                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4064
4065                 if (route->feeds (*i, &via_sends_only)) {
4066                         /* propagate solo upstream only if routing other than
4067                            sends is involved, but do consider the other route
4068                            (*i) to be part of the signal flow even if only
4069                            sends are involved.
4070                         */
4071                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4072                                                                   route->name(),
4073                                                                   (*i)->name(),
4074                                                                   via_sends_only,
4075                                                                   route->soloed_by_others_downstream(),
4076                                                                   route->soloed_by_others_upstream()));
4077                         if (!via_sends_only) {
4078                                 //NB. Triggers Invert Push, which handles soloed by downstream
4079                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4080                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4081                         } else {
4082                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4083                         }
4084                         in_signal_flow = true;
4085                 } else {
4086                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
4087                 }
4088
4089                 if (!in_signal_flow) {
4090                         uninvolved.push_back (*i);
4091                 }
4092         }
4093
4094         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4095
4096         /* now notify that the mute state of the routes not involved in the signal
4097            pathway of the just-solo-changed route may have altered.
4098         */
4099
4100         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4101                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4102                 (*i)->act_on_mute ();
4103                 /* Session will emit SoloChanged() after all solo changes are
4104                  * complete, which should be used by UIs to update mute status
4105                  */
4106         }
4107 }
4108
4109 void
4110 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4111 {
4112         /* now figure out if anything that matters is soloed (or is "listening")*/
4113
4114         bool something_soloed = false;
4115         bool something_listening = false;
4116         uint32_t listeners = 0;
4117         uint32_t isolated = 0;
4118
4119         if (!r) {
4120                 r = routes.reader();
4121         }
4122
4123         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4124                 if ((*i)->can_solo()) {
4125                         if (Config->get_solo_control_is_listen_control()) {
4126                                 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4127                                         listeners++;
4128                                         something_listening = true;
4129                                 }
4130                         } else {
4131                                 (*i)->set_listen (false);
4132                                 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4133                                         something_soloed = true;
4134                                 }
4135                         }
4136                 }
4137
4138                 if ((*i)->solo_isolate_control()->solo_isolated()) {
4139                         isolated++;
4140                 }
4141         }
4142
4143         if (something_soloed != _non_soloed_outs_muted) {
4144                 _non_soloed_outs_muted = something_soloed;
4145                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4146         }
4147
4148         if (something_listening != _listening) {
4149                 _listening = something_listening;
4150                 SoloActive (_listening);
4151         }
4152
4153         _listen_cnt = listeners;
4154
4155         if (isolated != _solo_isolated_cnt) {
4156                 _solo_isolated_cnt = isolated;
4157                 IsolatedChanged (); /* EMIT SIGNAL */
4158         }
4159
4160         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4161                                                   something_soloed, listeners, isolated));
4162
4163
4164         SoloChanged (); /* EMIT SIGNAL */
4165         set_dirty();
4166 }
4167
4168 void
4169 Session::get_stripables (StripableList& sl) const
4170 {
4171         boost::shared_ptr<RouteList> r = routes.reader ();
4172         sl.insert (sl.end(), r->begin(), r->end());
4173
4174         VCAList v = _vca_manager->vcas ();
4175         sl.insert (sl.end(), v.begin(), v.end());
4176 }
4177
4178 boost::shared_ptr<RouteList>
4179 Session::get_routes_with_internal_returns() const
4180 {
4181         boost::shared_ptr<RouteList> r = routes.reader ();
4182         boost::shared_ptr<RouteList> rl (new RouteList);
4183
4184         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4185                 if ((*i)->internal_return ()) {
4186                         rl->push_back (*i);
4187                 }
4188         }
4189         return rl;
4190 }
4191
4192 bool
4193 Session::io_name_is_legal (const std::string& name) const
4194 {
4195         boost::shared_ptr<RouteList> r = routes.reader ();
4196
4197         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4198                 if (name == reserved->first) {
4199                         if (!route_by_name (reserved->first)) {
4200                                 /* first instance of a reserved name is allowed */
4201                                 return true;
4202                         }
4203                         /* all other instances of a reserved name are not allowed */
4204                         return false;
4205                 }
4206         }
4207
4208         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4209                 if ((*i)->name() == name) {
4210                         return false;
4211                 }
4212
4213                 if ((*i)->has_io_processor_named (name)) {
4214                         return false;
4215                 }
4216         }
4217
4218         return true;
4219 }
4220
4221 void
4222 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4223 {
4224         RouteList rl2;
4225         vector<string> connections;
4226
4227         /* if we are passed only a single route and we're not told to turn
4228          * others off, then just do the simple thing.
4229          */
4230
4231         if (flip_others == false && rl->size() == 1) {
4232                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4233                 if (mt) {
4234                         mt->set_input_active (onoff);
4235                         return;
4236                 }
4237         }
4238
4239         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4240
4241                 PortSet& ps ((*rt)->input()->ports());
4242
4243                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4244                         p->get_connections (connections);
4245                 }
4246
4247                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4248                         routes_using_input_from (*s, rl2);
4249                 }
4250
4251                 /* scan all relevant routes to see if others are on or off */
4252
4253                 bool others_are_already_on = false;
4254
4255                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4256
4257                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4258
4259                         if (!mt) {
4260                                 continue;
4261                         }
4262
4263                         if ((*r) != (*rt)) {
4264                                 if (mt->input_active()) {
4265                                         others_are_already_on = true;
4266                                 }
4267                         } else {
4268                                 /* this one needs changing */
4269                                 mt->set_input_active (onoff);
4270                         }
4271                 }
4272
4273                 if (flip_others) {
4274
4275                         /* globally reverse other routes */
4276
4277                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4278                                 if ((*r) != (*rt)) {
4279                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4280                                         if (mt) {
4281                                                 mt->set_input_active (!others_are_already_on);
4282                                         }
4283                                 }
4284                         }
4285                 }
4286         }
4287 }
4288
4289 void
4290 Session::routes_using_input_from (const string& str, RouteList& rl)
4291 {
4292         boost::shared_ptr<RouteList> r = routes.reader();
4293
4294         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4295                 if ((*i)->input()->connected_to (str)) {
4296                         rl.push_back (*i);
4297                 }
4298         }
4299 }
4300
4301 boost::shared_ptr<Route>
4302 Session::route_by_name (string name) const
4303 {
4304         boost::shared_ptr<RouteList> r = routes.reader ();
4305
4306         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4307                 if ((*i)->name() == name) {
4308                         return *i;
4309                 }
4310         }
4311
4312         return boost::shared_ptr<Route> ((Route*) 0);
4313 }
4314
4315 boost::shared_ptr<Route>
4316 Session::route_by_id (PBD::ID id) const
4317 {
4318         boost::shared_ptr<RouteList> r = routes.reader ();
4319
4320         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4321                 if ((*i)->id() == id) {
4322                         return *i;
4323                 }
4324         }
4325
4326         return boost::shared_ptr<Route> ((Route*) 0);
4327 }
4328
4329 boost::shared_ptr<Processor>
4330 Session::processor_by_id (PBD::ID id) const
4331 {
4332         boost::shared_ptr<RouteList> r = routes.reader ();
4333
4334         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4335                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4336                 if (p) {
4337                         return p;
4338                 }
4339         }
4340
4341         return boost::shared_ptr<Processor> ();
4342 }
4343
4344 boost::shared_ptr<Track>
4345 Session::track_by_diskstream_id (PBD::ID id) const
4346 {
4347         boost::shared_ptr<RouteList> r = routes.reader ();
4348
4349         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4350                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4351                 if (t && t->using_diskstream_id (id)) {
4352                         return t;
4353                 }
4354         }
4355
4356         return boost::shared_ptr<Track> ();
4357 }
4358
4359 boost::shared_ptr<Route>
4360 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4361 {
4362         return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4363 }
4364
4365 boost::shared_ptr<Stripable>
4366 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4367 {
4368         StripableList sl;
4369         PresentationInfo::order_t match_cnt = 0;
4370
4371         get_stripables (sl);
4372         sl.sort (Stripable::PresentationOrderSorter());
4373
4374         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4375
4376                 if ((*s)->presentation_info().hidden()) {
4377                         /* if the caller didn't explicitly ask for hidden
4378                            stripables, ignore hidden ones. This matches
4379                            the semantics of the pre-PresentationOrder
4380                            "get by RID" logic of Ardour 4.x and earlier.
4381
4382                            XXX at some point we should likely reverse
4383                            the logic of the flags, because asking for "the
4384                            hidden stripables" is not going to be common,
4385                            whereas asking for visible ones is normal.
4386                         */
4387
4388                         if (! (flags & PresentationInfo::Hidden)) {
4389                                 continue;
4390                         }
4391                 }
4392
4393                 if ((*s)->presentation_info().flag_match (flags)) {
4394                         if (match_cnt++ == n) {
4395                                 return *s;
4396                         }
4397                 }
4398         }
4399
4400         /* there is no nth stripable that matches the given flags */
4401         return boost::shared_ptr<Stripable>();
4402 }
4403
4404 struct PresentationOrderSorter {
4405         bool operator() (boost::shared_ptr<Stripable> a, boost::shared_ptr<Stripable> b) {
4406                 if (a->presentation_info().special() && !b->presentation_info().special()) {
4407                         /* a is not ordered, b is; b comes before a */
4408                         return false;
4409                 } else if (!b->presentation_info().order_set() && a->presentation_info().order_set()) {
4410                         /* b is not ordered, a is; a comes before b */
4411                         return true;
4412                 } else {
4413                         return a->presentation_info().order() < b->presentation_info().order();
4414                 }
4415         }
4416 };
4417
4418 boost::shared_ptr<Route>
4419 Session::route_by_selected_count (uint32_t id) const
4420 {
4421         RouteList r (*(routes.reader ()));
4422         PresentationOrderSorter sorter;
4423         r.sort (sorter);
4424
4425         RouteList::iterator i;
4426
4427         for (i = r.begin(); i != r.end(); ++i) {
4428                 if ((*i)->presentation_info().selected()) {
4429                         if (id == 0) {
4430                                 return *i;
4431                         }
4432                         --id;
4433                 }
4434         }
4435
4436         return boost::shared_ptr<Route> ();
4437 }
4438
4439 void
4440 Session::reassign_track_numbers ()
4441 {
4442         int64_t tn = 0;
4443         int64_t bn = 0;
4444         RouteList r (*(routes.reader ()));
4445         PresentationOrderSorter sorter;
4446         r.sort (sorter);
4447
4448         StateProtector sp (this);
4449
4450         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4451                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4452                         (*i)->set_track_number(++tn);
4453                 }
4454                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4455                         (*i)->set_track_number(--bn);
4456                 }
4457         }
4458         const uint32_t decimals = ceilf (log10f (tn + 1));
4459         const bool decimals_changed = _track_number_decimals != decimals;
4460         _track_number_decimals = decimals;
4461
4462         if (decimals_changed && config.get_track_name_number ()) {
4463                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4464                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4465                         if (t) {
4466                                 t->resync_track_name();
4467                         }
4468                 }
4469                 // trigger GUI re-layout
4470                 config.ParameterChanged("track-name-number");
4471         }
4472
4473 #ifndef NDEBUG
4474         if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4475                 boost::shared_ptr<RouteList> rl = routes.reader ();
4476                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4477                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4478                 }
4479         }
4480 #endif /* NDEBUG */
4481
4482 }
4483
4484 void
4485 Session::playlist_region_added (boost::weak_ptr<Region> w)
4486 {
4487         boost::shared_ptr<Region> r = w.lock ();
4488         if (!r) {
4489                 return;
4490         }
4491
4492         /* These are the operations that are currently in progress... */
4493         list<GQuark> curr = _current_trans_quarks;
4494         curr.sort ();
4495
4496         /* ...and these are the operations during which we want to update
4497            the session range location markers.
4498         */
4499         list<GQuark> ops;
4500         ops.push_back (Operations::capture);
4501         ops.push_back (Operations::paste);
4502         ops.push_back (Operations::duplicate_region);
4503         ops.push_back (Operations::insert_file);
4504         ops.push_back (Operations::insert_region);
4505         ops.push_back (Operations::drag_region_brush);
4506         ops.push_back (Operations::region_drag);
4507         ops.push_back (Operations::selection_grab);
4508         ops.push_back (Operations::region_fill);
4509         ops.push_back (Operations::fill_selection);
4510         ops.push_back (Operations::create_region);
4511         ops.push_back (Operations::region_copy);
4512         ops.push_back (Operations::fixed_time_region_copy);
4513         ops.sort ();
4514
4515         /* See if any of the current operations match the ones that we want */
4516         list<GQuark> in;
4517         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4518
4519         /* If so, update the session range markers */
4520         if (!in.empty ()) {
4521                 maybe_update_session_range (r->position (), r->last_frame ());
4522         }
4523 }
4524
4525 /** Update the session range markers if a is before the current start or
4526  *  b is after the current end.
4527  */
4528 void
4529 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4530 {
4531         if (_state_of_the_state & Loading) {
4532                 return;
4533         }
4534
4535         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4536
4537         if (_session_range_location == 0) {
4538
4539                 set_session_range_location (a, b + session_end_marker_shift_samples);
4540
4541         } else {
4542
4543                 if (a < _session_range_location->start()) {
4544                         _session_range_location->set_start (a);
4545                 }
4546
4547                 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4548                         _session_range_location->set_end (b);
4549                 }
4550         }
4551 }
4552
4553 void
4554 Session::set_end_is_free (bool yn)
4555 {
4556         _session_range_end_is_free = yn;
4557 }
4558
4559 void
4560 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4561 {
4562         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4563                 maybe_update_session_range (i->to, i->to + i->length);
4564         }
4565 }
4566
4567 void
4568 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4569 {
4570         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4571                 maybe_update_session_range (i->from, i->to);
4572         }
4573 }
4574
4575 /* Region management */
4576
4577 boost::shared_ptr<Region>
4578 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4579 {
4580         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4581         RegionFactory::RegionMap::const_iterator i;
4582         boost::shared_ptr<Region> region;
4583
4584         Glib::Threads::Mutex::Lock lm (region_lock);
4585
4586         for (i = regions.begin(); i != regions.end(); ++i) {
4587
4588                 region = i->second;
4589
4590                 if (region->whole_file()) {
4591
4592                         if (child->source_equivalent (region)) {
4593                                 return region;
4594                         }
4595                 }
4596         }
4597
4598         return boost::shared_ptr<Region> ();
4599 }
4600
4601 int
4602 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4603 {
4604         set<boost::shared_ptr<Region> > relevant_regions;
4605
4606         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4607                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4608         }
4609
4610         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4611                 set<boost::shared_ptr<Region> >::iterator tmp;
4612
4613                 tmp = r;
4614                 ++tmp;
4615
4616                 playlists->destroy_region (*r);
4617                 RegionFactory::map_remove (*r);
4618
4619                 (*r)->drop_sources ();
4620                 (*r)->drop_references ();
4621
4622                 relevant_regions.erase (r);
4623
4624                 r = tmp;
4625         }
4626
4627         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4628
4629                 {
4630                         Glib::Threads::Mutex::Lock ls (source_lock);
4631                         /* remove from the main source list */
4632                         sources.erase ((*s)->id());
4633                 }
4634
4635                 (*s)->mark_for_remove ();
4636                 (*s)->drop_references ();
4637
4638                 s = srcs.erase (s);
4639         }
4640
4641         return 0;
4642 }
4643
4644 int
4645 Session::remove_last_capture ()
4646 {
4647         list<boost::shared_ptr<Source> > srcs;
4648
4649         boost::shared_ptr<RouteList> rl = routes.reader ();
4650         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4651                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4652                 if (!tr) {
4653                         continue;
4654                 }
4655
4656                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4657
4658                 if (!l.empty()) {
4659                         srcs.insert (srcs.end(), l.begin(), l.end());
4660                         l.clear ();
4661                 }
4662         }
4663
4664         destroy_sources (srcs);
4665
4666         save_state (_current_snapshot_name);
4667
4668         return 0;
4669 }
4670
4671 /* Source Management */
4672
4673 void
4674 Session::add_source (boost::shared_ptr<Source> source)
4675 {
4676         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4677         pair<SourceMap::iterator,bool> result;
4678
4679         entry.first = source->id();
4680         entry.second = source;
4681
4682         {
4683                 Glib::Threads::Mutex::Lock lm (source_lock);
4684                 result = sources.insert (entry);
4685         }
4686
4687         if (result.second) {
4688
4689                 /* yay, new source */
4690
4691                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4692
4693                 if (fs) {
4694                         if (!fs->within_session()) {
4695                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4696                         }
4697                 }
4698
4699                 set_dirty();
4700
4701                 boost::shared_ptr<AudioFileSource> afs;
4702
4703                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4704                         if (Config->get_auto_analyse_audio()) {
4705                                 Analyser::queue_source_for_analysis (source, false);
4706                         }
4707                 }
4708
4709                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4710         }
4711 }
4712
4713 void
4714 Session::remove_source (boost::weak_ptr<Source> src)
4715 {
4716         if (_state_of_the_state & Deletion) {
4717                 return;
4718         }
4719
4720         SourceMap::iterator i;
4721         boost::shared_ptr<Source> source = src.lock();
4722
4723         if (!source) {
4724                 return;
4725         }
4726
4727         {
4728                 Glib::Threads::Mutex::Lock lm (source_lock);
4729
4730                 if ((i = sources.find (source->id())) != sources.end()) {
4731                         sources.erase (i);
4732                 }
4733         }
4734
4735         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4736
4737                 /* save state so we don't end up with a session file
4738                    referring to non-existent sources.
4739                 */
4740
4741                 save_state (_current_snapshot_name);
4742         }
4743 }
4744
4745 boost::shared_ptr<Source>
4746 Session::source_by_id (const PBD::ID& id)
4747 {
4748         Glib::Threads::Mutex::Lock lm (source_lock);
4749         SourceMap::iterator i;
4750         boost::shared_ptr<Source> source;
4751
4752         if ((i = sources.find (id)) != sources.end()) {
4753                 source = i->second;
4754         }
4755
4756         return source;
4757 }
4758
4759 boost::shared_ptr<AudioFileSource>
4760 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4761 {
4762         /* Restricted to audio files because only audio sources have channel
4763            as a property.
4764         */
4765
4766         Glib::Threads::Mutex::Lock lm (source_lock);
4767
4768         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4769                 boost::shared_ptr<AudioFileSource> afs
4770                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4771
4772                 if (afs && afs->path() == path && chn == afs->channel()) {
4773                         return afs;
4774                 }
4775         }
4776
4777         return boost::shared_ptr<AudioFileSource>();
4778 }
4779
4780 boost::shared_ptr<MidiSource>
4781 Session::midi_source_by_path (const std::string& path) const
4782 {
4783         /* Restricted to MIDI files because audio sources require a channel
4784            for unique identification, in addition to a path.
4785         */
4786
4787         Glib::Threads::Mutex::Lock lm (source_lock);
4788
4789         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4790                 boost::shared_ptr<MidiSource> ms
4791                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4792                 boost::shared_ptr<FileSource> fs
4793                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4794
4795                 if (ms && fs && fs->path() == path) {
4796                         return ms;
4797                 }
4798         }
4799
4800         return boost::shared_ptr<MidiSource>();
4801 }
4802
4803 uint32_t
4804 Session::count_sources_by_origin (const string& path)
4805 {
4806         uint32_t cnt = 0;
4807         Glib::Threads::Mutex::Lock lm (source_lock);
4808
4809         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4810                 boost::shared_ptr<FileSource> fs
4811                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4812
4813                 if (fs && fs->origin() == path) {
4814                         ++cnt;
4815                 }
4816         }
4817
4818         return cnt;
4819 }
4820
4821 static string
4822 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4823         if (hash) {
4824                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4825                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4826         } else {
4827                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4828         }
4829 }
4830
4831 string
4832 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4833 {
4834         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4835
4836         if (Glib::path_is_absolute (filepath)) {
4837
4838                 /* rip the session dir from the audiofile source */
4839
4840                 string session_path;
4841                 bool in_another_session = true;
4842
4843                 if (filepath.find (interchange_dir_string) != string::npos) {
4844
4845                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4846                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4847                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4848                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4849
4850                         /* see if it is within our session */
4851
4852                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4853                                 if (i->path == session_path) {
4854                                         in_another_session = false;
4855                                         break;
4856                                 }
4857                         }
4858                 } else {
4859                         in_another_session = false;
4860                 }
4861
4862
4863                 if (in_another_session) {
4864                         SessionDirectory sd (session_path);
4865                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4866                 }
4867         }
4868
4869         /* 1) if file belongs to this session
4870          * it may be a relative path (interchange/...)
4871          * or just basename (session_state, remove source)
4872          * -> just use the basename
4873          */
4874         std::string filename = Glib::path_get_basename (filepath);
4875         std::string path;
4876
4877         /* 2) if the file is outside our session dir:
4878          * (imported but not copied) add the path for check-summming */
4879         if (!in_session) {
4880                 path = Glib::path_get_dirname (filepath);
4881         }
4882
4883         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4884 }
4885
4886 string
4887 Session::new_audio_source_path_for_embedded (const std::string& path)
4888 {
4889         /* embedded source:
4890          *
4891          * we know that the filename is already unique because it exists
4892          * out in the filesystem.
4893          *
4894          * However, when we bring it into the session, we could get a
4895          * collision.
4896          *
4897          * Eg. two embedded files:
4898          *
4899          *          /foo/bar/baz.wav
4900          *          /frob/nic/baz.wav
4901          *
4902          * When merged into session, these collide.
4903          *
4904          * There will not be a conflict with in-memory sources
4905          * because when the source was created we already picked
4906          * a unique name for it.
4907          *
4908          * This collision is not likely to be common, but we have to guard
4909          * against it.  So, if there is a collision, take the md5 hash of the
4910          * the path, and use that as the filename instead.
4911          */
4912
4913         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4914         string base = Glib::path_get_basename (path);
4915         string newpath = Glib::build_filename (sdir.sound_path(), base);
4916
4917         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4918
4919                 MD5 md5;
4920
4921                 md5.digestString (path.c_str());
4922                 md5.writeToString ();
4923                 base = md5.digestChars;
4924
4925                 string ext = get_suffix (path);
4926
4927                 if (!ext.empty()) {
4928                         base += '.';
4929                         base += ext;
4930                 }
4931
4932                 newpath = Glib::build_filename (sdir.sound_path(), base);
4933
4934                 /* if this collides, we're screwed */
4935
4936                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4937                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4938                         return string();
4939                 }
4940
4941         }
4942
4943         return newpath;
4944 }
4945
4946 /** Return true if there are no audio file sources that use @param name as
4947  * the filename component of their path.
4948  *
4949  * Return false otherwise.
4950  *
4951  * This method MUST ONLY be used to check in-session, mono files since it
4952  * hard-codes the channel of the audio file source we are looking for as zero.
4953  *
4954  * If/when Ardour supports native files in non-mono formats, the logic here
4955  * will need to be revisited.
4956  */
4957 bool
4958 Session::audio_source_name_is_unique (const string& name)
4959 {
4960         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4961         vector<space_and_path>::iterator i;
4962         uint32_t existing = 0;
4963
4964         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4965
4966                 /* note that we search *without* the extension so that
4967                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4968                    in the event that this new name is required for
4969                    a file format change.
4970                 */
4971
4972                 const string spath = *i;
4973
4974                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4975                         existing++;
4976                         break;
4977                 }
4978
4979                 /* it is possible that we have the path already
4980                  * assigned to a source that has not yet been written
4981                  * (ie. the write source for a diskstream). we have to
4982                  * check this in order to make sure that our candidate
4983                  * path isn't used again, because that can lead to
4984                  * two Sources point to the same file with different
4985                  * notions of their removability.
4986                  */
4987
4988
4989                 string possible_path = Glib::build_filename (spath, name);
4990
4991                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4992                         existing++;
4993                         break;
4994                 }
4995         }
4996
4997         return (existing == 0);
4998 }
4999
5000 string
5001 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)
5002 {
5003         ostringstream sstr;
5004         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5005
5006         if (Profile->get_trx() && destructive) {
5007                 sstr << 'T';
5008                 sstr << setfill ('0') << setw (4) << cnt;
5009                 sstr << legalized_base;
5010         } else {
5011                 sstr << legalized_base;
5012
5013                 if (take_required || related_exists) {
5014                         sstr << '-';
5015                         sstr << cnt;
5016                 }
5017         }
5018
5019         if (nchan == 2) {
5020                 if (chan == 0) {
5021                         sstr << "%L";
5022                 } else {
5023                         sstr << "%R";
5024                 }
5025         } else if (nchan > 2) {
5026                 if (nchan < 26) {
5027                         sstr << '%';
5028                         sstr << 'a' + chan;
5029                 } else {
5030                         /* XXX what? more than 26 channels! */
5031                         sstr << '%';
5032                         sstr << chan+1;
5033                 }
5034         }
5035
5036         sstr << ext;
5037
5038         return sstr.str();
5039 }
5040
5041 /** Return a unique name based on \a base for a new internal audio source */
5042 string
5043 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5044 {
5045         uint32_t cnt;
5046         string possible_name;
5047         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5048         string legalized;
5049         bool some_related_source_name_exists = false;
5050
5051         legalized = legalize_for_path (base);
5052
5053         // Find a "version" of the base name that doesn't exist in any of the possible directories.
5054
5055         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5056
5057                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5058
5059                 if (audio_source_name_is_unique (possible_name)) {
5060                         break;
5061                 }
5062
5063                 some_related_source_name_exists = true;
5064
5065                 if (cnt > limit) {
5066                         error << string_compose(
5067                                         _("There are already %1 recordings for %2, which I consider too many."),
5068                                         limit, base) << endmsg;
5069                         destroy ();
5070                         throw failed_constructor();
5071                 }
5072         }
5073
5074         /* We've established that the new name does not exist in any session
5075          * directory, so now find out which one we should use for this new
5076          * audio source.
5077          */
5078
5079         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5080
5081         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5082
5083         return s;
5084 }
5085
5086 /** Return a unique name based on `base` for a new internal MIDI source */
5087 string
5088 Session::new_midi_source_path (const string& base)
5089 {
5090         uint32_t cnt;
5091         char buf[PATH_MAX+1];
5092         const uint32_t limit = 10000;
5093         string legalized;
5094         string possible_path;
5095         string possible_name;
5096
5097         buf[0] = '\0';
5098         legalized = legalize_for_path (base);
5099
5100         // Find a "version" of the file name that doesn't exist in any of the possible directories.
5101         std::vector<string> sdirs = source_search_path(DataType::MIDI);
5102
5103         /* - the main session folder is the first in the vector.
5104          * - after checking all locations for file-name uniqueness,
5105          *   we keep the one from the last iteration as new file name
5106          * - midi files are small and should just be kept in the main session-folder
5107          *
5108          * -> reverse the array, check main session folder last and use that as location
5109          *    for MIDI files.
5110          */
5111         std::reverse(sdirs.begin(), sdirs.end());
5112
5113         for (cnt = 1; cnt <= limit; ++cnt) {
5114
5115                 vector<space_and_path>::iterator i;
5116                 uint32_t existing = 0;
5117
5118                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5119
5120                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
5121                         possible_name = buf;
5122
5123                         possible_path = Glib::build_filename (*i, possible_name);
5124
5125                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5126                                 existing++;
5127                         }
5128
5129                         if (midi_source_by_path (possible_path)) {
5130                                 existing++;
5131                         }
5132                 }
5133
5134                 if (existing == 0) {
5135                         break;
5136                 }
5137
5138                 if (cnt > limit) {
5139                         error << string_compose(
5140                                         _("There are already %1 recordings for %2, which I consider too many."),
5141                                         limit, base) << endmsg;
5142                         destroy ();
5143                         return 0;
5144                 }
5145         }
5146
5147         /* No need to "find best location" for software/app-based RAID, because
5148            MIDI is so small that we always put it in the same place.
5149         */
5150
5151         return possible_path;
5152 }
5153
5154
5155 /** Create a new within-session audio source */
5156 boost::shared_ptr<AudioFileSource>
5157 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5158 {
5159         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5160
5161         if (!path.empty()) {
5162                 return boost::dynamic_pointer_cast<AudioFileSource> (
5163                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
5164         } else {
5165                 throw failed_constructor ();
5166         }
5167 }
5168
5169 /** Create a new within-session MIDI source */
5170 boost::shared_ptr<MidiSource>
5171 Session::create_midi_source_for_session (string const & basic_name)
5172 {
5173         const string path = new_midi_source_path (basic_name);
5174
5175         if (!path.empty()) {
5176                 return boost::dynamic_pointer_cast<SMFSource> (
5177                         SourceFactory::createWritable (
5178                                 DataType::MIDI, *this, path, false, frame_rate()));
5179         } else {
5180                 throw failed_constructor ();
5181         }
5182 }
5183
5184 /** Create a new within-session MIDI source */
5185 boost::shared_ptr<MidiSource>
5186 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5187 {
5188         /* the caller passes in the track the source will be used in,
5189            so that we can keep the numbering sane.
5190
5191            Rationale: a track with the name "Foo" that has had N
5192            captures carried out so far will ALREADY have a write source
5193            named "Foo-N+1.mid" waiting to be used for the next capture.
5194
5195            If we call new_midi_source_name() we will get "Foo-N+2". But
5196            there is no region corresponding to "Foo-N+1", so when
5197            "Foo-N+2" appears in the track, the gap presents the user
5198            with odd behaviour - why did it skip past Foo-N+1?
5199
5200            We could explain this to the user in some odd way, but
5201            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5202            use "Foo-N+1" here.
5203
5204            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5205         */
5206
5207         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5208         assert (mt);
5209         std::string name = track->steal_write_source_name ();
5210
5211         if (name.empty()) {
5212                 return boost::shared_ptr<MidiSource>();
5213         }
5214
5215         /* MIDI files are small, just put them in the first location of the
5216            session source search path.
5217         */
5218
5219         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5220
5221         return boost::dynamic_pointer_cast<SMFSource> (
5222                 SourceFactory::createWritable (
5223                         DataType::MIDI, *this, path, false, frame_rate()));
5224 }
5225
5226
5227 void
5228 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5229 {
5230         if (playlist->hidden()) {
5231                 return;
5232         }
5233
5234         playlists->add (playlist);
5235
5236         if (unused) {
5237                 playlist->release();
5238         }
5239
5240         set_dirty();
5241 }
5242
5243 void
5244 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5245 {
5246         if (_state_of_the_state & Deletion) {
5247                 return;
5248         }
5249
5250         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5251
5252         if (!playlist) {
5253                 return;
5254         }
5255
5256         playlists->remove (playlist);
5257
5258         set_dirty();
5259 }
5260
5261 void
5262 Session::set_audition (boost::shared_ptr<Region> r)
5263 {
5264         pending_audition_region = r;
5265         add_post_transport_work (PostTransportAudition);
5266         _butler->schedule_transport_work ();
5267 }
5268
5269 void
5270 Session::audition_playlist ()
5271 {
5272         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5273         ev->region.reset ();
5274         queue_event (ev);
5275 }
5276
5277
5278 void
5279 Session::register_lua_function (
5280                 const std::string& name,
5281                 const std::string& script,
5282                 const LuaScriptParamList& args
5283                 )
5284 {
5285         Glib::Threads::Mutex::Lock lm (lua_lock);
5286
5287         lua_State* L = lua.getState();
5288
5289         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5290         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5291         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5292                 if ((*i)->optional && !(*i)->is_set) { continue; }
5293                 tbl_arg[(*i)->name] = (*i)->value;
5294         }
5295         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5296         lm.release();
5297
5298         LuaScriptsChanged (); /* EMIT SIGNAL */
5299         set_dirty();
5300 }
5301
5302 void
5303 Session::unregister_lua_function (const std::string& name)
5304 {
5305         Glib::Threads::Mutex::Lock lm (lua_lock);
5306         (*_lua_del)(name); // throws luabridge::LuaException
5307         lua.collect_garbage ();
5308         lm.release();
5309
5310         LuaScriptsChanged (); /* EMIT SIGNAL */
5311         set_dirty();
5312 }
5313
5314 std::vector<std::string>
5315 Session::registered_lua_functions ()
5316 {
5317         Glib::Threads::Mutex::Lock lm (lua_lock);
5318         std::vector<std::string> rv;
5319
5320         try {
5321                 luabridge::LuaRef list ((*_lua_list)());
5322                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5323                         if (!i.key ().isString ()) { assert(0); continue; }
5324                         rv.push_back (i.key ().cast<std::string> ());
5325                 }
5326         } catch (luabridge::LuaException const& e) { }
5327         return rv;
5328 }
5329
5330 #ifndef NDEBUG
5331 static void _lua_print (std::string s) {
5332         std::cout << "SessionLua: " << s << "\n";
5333 }
5334 #endif
5335
5336 void
5337 Session::try_run_lua (pframes_t nframes)
5338 {
5339         if (_n_lua_scripts == 0) return;
5340         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5341         if (tm.locked ()) {
5342                 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5343                 lua.collect_garbage_step ();
5344         }
5345 }
5346
5347 void
5348 Session::setup_lua ()
5349 {
5350 #ifndef NDEBUG
5351         lua.Print.connect (&_lua_print);
5352 #endif
5353         lua.tweak_rt_gc ();
5354         lua.do_command (
5355                         "function ArdourSession ()"
5356                         "  local self = { scripts = {}, instances = {} }"
5357                         ""
5358                         "  local remove = function (n)"
5359                         "   self.scripts[n] = nil"
5360                         "   self.instances[n] = nil"
5361                         "   Session:scripts_changed()" // call back
5362                         "  end"
5363                         ""
5364                         "  local addinternal = function (n, f, a)"
5365                         "   assert(type(n) == 'string', 'function-name must be string')"
5366                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5367                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5368                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5369                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5370                         "   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"
5371                         "   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 }"
5372                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5373                         "   Session:scripts_changed()" // call back
5374                         "  end"
5375                         ""
5376                         "  local add = function (n, b, a)"
5377                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5378                         "   load (b)()" // assigns f
5379                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5380                         "   addinternal (n, load(f), a)"
5381                         "  end"
5382                         ""
5383                         "  local run = function (...)"
5384                         "   for n, s in pairs (self.instances) do"
5385                         "     local status, err = pcall (s, ...)"
5386                         "     if not status then"
5387                         "       print ('fn \"'.. n .. '\": ', err)"
5388                         "       remove (n)"
5389                         "      end"
5390                         "   end"
5391                         "   collectgarbage()"
5392                         "  end"
5393                         ""
5394                         "  local cleanup = function ()"
5395                         "   self.scripts = nil"
5396                         "   self.instances = nil"
5397                         "  end"
5398                         ""
5399                         "  local list = function ()"
5400                         "   local rv = {}"
5401                         "   for n, _ in pairs (self.scripts) do"
5402                         "     rv[n] = true"
5403                         "   end"
5404                         "   return rv"
5405                         "  end"
5406                         ""
5407                         "  local function basic_serialize (o)"
5408                         "    if type(o) == \"number\" then"
5409                         "     return tostring(o)"
5410                         "    else"
5411                         "     return string.format(\"%q\", o)"
5412                         "    end"
5413                         "  end"
5414                         ""
5415                         "  local function serialize (name, value)"
5416                         "   local rv = name .. ' = '"
5417                         "   collectgarbage()"
5418                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5419                         "    return rv .. basic_serialize(value) .. ' '"
5420                         "   elseif type(value) == \"table\" then"
5421                         "    rv = rv .. '{} '"
5422                         "    for k,v in pairs(value) do"
5423                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5424                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5425                         "     collectgarbage()" // string concatenation allocates a new string :(
5426                         "    end"
5427                         "    return rv;"
5428                         "   elseif type(value) == \"function\" then"
5429                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5430                         "   else"
5431                         "    error('cannot save a ' .. type(value))"
5432                         "   end"
5433                         "  end"
5434                         ""
5435                         ""
5436                         "  local save = function ()"
5437                         "   return (serialize('scripts', self.scripts))"
5438                         "  end"
5439                         ""
5440                         "  local restore = function (state)"
5441                         "   self.scripts = {}"
5442                         "   load (state)()"
5443                         "   for n, s in pairs (scripts) do"
5444                         "    addinternal (n, load(s['f']), s['a'])"
5445                         "   end"
5446                         "  end"
5447                         ""
5448                         " return { run = run, add = add, remove = remove,"
5449                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5450                         " end"
5451                         " "
5452                         " sess = ArdourSession ()"
5453                         " ArdourSession = nil"
5454                         " "
5455                         "function ardour () end"
5456                         );
5457
5458         lua_State* L = lua.getState();
5459
5460         try {
5461                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5462                 lua.do_command ("sess = nil"); // hide it.
5463                 lua.do_command ("collectgarbage()");
5464
5465                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5466                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5467                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5468                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5469                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5470                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5471                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5472         } catch (luabridge::LuaException const& e) {
5473                 fatal << string_compose (_("programming error: %1"),
5474                                 X_("Failed to setup Lua interpreter"))
5475                         << endmsg;
5476                 abort(); /*NOTREACHED*/
5477         }
5478
5479         LuaBindings::stddef (L);
5480         LuaBindings::common (L);
5481         LuaBindings::dsp (L);
5482         luabridge::push <Session *> (L, this);
5483         lua_setglobal (L, "Session");
5484 }
5485
5486 void
5487 Session::scripts_changed ()
5488 {
5489         assert (!lua_lock.trylock()); // must hold lua_lock
5490
5491         try {
5492                 luabridge::LuaRef list ((*_lua_list)());
5493                 int cnt = 0;
5494                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5495                         if (!i.key ().isString ()) { assert(0); continue; }
5496                         ++cnt;
5497                 }
5498                 _n_lua_scripts = cnt;
5499         } catch (luabridge::LuaException const& e) {
5500                 fatal << string_compose (_("programming error: %1"),
5501                                 X_("Indexing Lua Session Scripts failed."))
5502                         << endmsg;
5503                 abort(); /*NOTREACHED*/
5504         }
5505 }
5506
5507 void
5508 Session::non_realtime_set_audition ()
5509 {
5510         assert (pending_audition_region);
5511         auditioner->audition_region (pending_audition_region);
5512         pending_audition_region.reset ();
5513         AuditionActive (true); /* EMIT SIGNAL */
5514 }
5515
5516 void
5517 Session::audition_region (boost::shared_ptr<Region> r)
5518 {
5519         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5520         ev->region = r;
5521         queue_event (ev);
5522 }
5523
5524 void
5525 Session::cancel_audition ()
5526 {
5527         if (!auditioner) {
5528                 return;
5529         }
5530         if (auditioner->auditioning()) {
5531                 auditioner->cancel_audition ();
5532                 AuditionActive (false); /* EMIT SIGNAL */
5533         }
5534 }
5535
5536 bool
5537 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
5538 {
5539         if (a->is_monitor()) {
5540                 return true;
5541         }
5542         if (b->is_monitor()) {
5543                 return false;
5544         }
5545         return a->presentation_info().order() < b->presentation_info().order();
5546 }
5547
5548 bool
5549 Session::is_auditioning () const
5550 {
5551         /* can be called before we have an auditioner object */
5552         if (auditioner) {
5553                 return auditioner->auditioning();
5554         } else {
5555                 return false;
5556         }
5557 }
5558
5559 void
5560 Session::graph_reordered ()
5561 {
5562         /* don't do this stuff if we are setting up connections
5563            from a set_state() call or creating new tracks. Ditto for deletion.
5564         */
5565
5566         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5567                 return;
5568         }
5569
5570         /* every track/bus asked for this to be handled but it was deferred because
5571            we were connecting. do it now.
5572         */
5573
5574         request_input_change_handling ();
5575
5576         resort_routes ();
5577
5578         /* force all diskstreams to update their capture offset values to
5579            reflect any changes in latencies within the graph.
5580         */
5581
5582         boost::shared_ptr<RouteList> rl = routes.reader ();
5583         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5584                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5585                 if (tr) {
5586                         tr->set_capture_offset ();
5587                 }
5588         }
5589 }
5590
5591 /** @return Number of frames that there is disk space available to write,
5592  *  if known.
5593  */
5594 boost::optional<framecnt_t>
5595 Session::available_capture_duration ()
5596 {
5597         Glib::Threads::Mutex::Lock lm (space_lock);
5598
5599         if (_total_free_4k_blocks_uncertain) {
5600                 return boost::optional<framecnt_t> ();
5601         }
5602
5603         float sample_bytes_on_disk = 4.0; // keep gcc happy
5604
5605         switch (config.get_native_file_data_format()) {
5606         case FormatFloat:
5607                 sample_bytes_on_disk = 4.0;
5608                 break;
5609
5610         case FormatInt24:
5611                 sample_bytes_on_disk = 3.0;
5612                 break;
5613
5614         case FormatInt16:
5615                 sample_bytes_on_disk = 2.0;
5616                 break;
5617
5618         default:
5619                 /* impossible, but keep some gcc versions happy */
5620                 fatal << string_compose (_("programming error: %1"),
5621                                          X_("illegal native file data format"))
5622                       << endmsg;
5623                 abort(); /*NOTREACHED*/
5624         }
5625
5626         double scale = 4096.0 / sample_bytes_on_disk;
5627
5628         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5629                 return max_framecnt;
5630         }
5631
5632         return (framecnt_t) floor (_total_free_4k_blocks * scale);
5633 }
5634
5635 void
5636 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5637 {
5638         {
5639                 RCUWriter<BundleList> writer (_bundles);
5640                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5641                 b->push_back (bundle);
5642         }
5643
5644         if (emit_signal) {
5645                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5646         }
5647
5648         set_dirty();
5649 }
5650
5651 void
5652 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5653 {
5654         bool removed = false;
5655
5656         {
5657                 RCUWriter<BundleList> writer (_bundles);
5658                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5659                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5660
5661                 if (i != b->end()) {
5662                         b->erase (i);
5663                         removed = true;
5664                 }
5665         }
5666
5667         if (removed) {
5668                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5669         }
5670
5671         set_dirty();
5672 }
5673
5674 boost::shared_ptr<Bundle>
5675 Session::bundle_by_name (string name) const
5676 {
5677         boost::shared_ptr<BundleList> b = _bundles.reader ();
5678
5679         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5680                 if ((*i)->name() == name) {
5681                         return* i;
5682                 }
5683         }
5684
5685         return boost::shared_ptr<Bundle> ();
5686 }
5687
5688 void
5689 Session::tempo_map_changed (const PropertyChange&)
5690 {
5691         clear_clicks ();
5692
5693         playlists->update_after_tempo_map_change ();
5694
5695         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5696
5697         set_dirty ();
5698 }
5699
5700 void
5701 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5702 {
5703         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5704                 (*i)->recompute_frames_from_beat ();
5705         }
5706 }
5707
5708 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5709  * the given count with the current block size.
5710  */
5711 void
5712 Session::ensure_buffers (ChanCount howmany)
5713 {
5714         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5715 }
5716
5717 void
5718 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5719 {
5720         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5721                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5722         }
5723 }
5724
5725 uint32_t
5726 Session::next_insert_id ()
5727 {
5728         /* this doesn't really loop forever. just think about it */
5729
5730         while (true) {
5731                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5732                         if (!insert_bitset[n]) {
5733                                 insert_bitset[n] = true;
5734                                 return n;
5735
5736                         }
5737                 }
5738
5739                 /* none available, so resize and try again */
5740
5741                 insert_bitset.resize (insert_bitset.size() + 16, false);
5742         }
5743 }
5744
5745 uint32_t
5746 Session::next_send_id ()
5747 {
5748         /* this doesn't really loop forever. just think about it */
5749
5750         while (true) {
5751                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5752                         if (!send_bitset[n]) {
5753                                 send_bitset[n] = true;
5754                                 return n;
5755
5756                         }
5757                 }
5758
5759                 /* none available, so resize and try again */
5760
5761                 send_bitset.resize (send_bitset.size() + 16, false);
5762         }
5763 }
5764
5765 uint32_t
5766 Session::next_aux_send_id ()
5767 {
5768         /* this doesn't really loop forever. just think about it */
5769
5770         while (true) {
5771                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5772                         if (!aux_send_bitset[n]) {
5773                                 aux_send_bitset[n] = true;
5774                                 return n;
5775
5776                         }
5777                 }
5778
5779                 /* none available, so resize and try again */
5780
5781                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5782         }
5783 }
5784
5785 uint32_t
5786 Session::next_return_id ()
5787 {
5788         /* this doesn't really loop forever. just think about it */
5789
5790         while (true) {
5791                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5792                         if (!return_bitset[n]) {
5793                                 return_bitset[n] = true;
5794                                 return n;
5795
5796                         }
5797                 }
5798
5799                 /* none available, so resize and try again */
5800
5801                 return_bitset.resize (return_bitset.size() + 16, false);
5802         }
5803 }
5804
5805 void
5806 Session::mark_send_id (uint32_t id)
5807 {
5808         if (id >= send_bitset.size()) {
5809                 send_bitset.resize (id+16, false);
5810         }
5811         if (send_bitset[id]) {
5812                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5813         }
5814         send_bitset[id] = true;
5815 }
5816
5817 void
5818 Session::mark_aux_send_id (uint32_t id)
5819 {
5820         if (id >= aux_send_bitset.size()) {
5821                 aux_send_bitset.resize (id+16, false);
5822         }
5823         if (aux_send_bitset[id]) {
5824                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5825         }
5826         aux_send_bitset[id] = true;
5827 }
5828
5829 void
5830 Session::mark_return_id (uint32_t id)
5831 {
5832         if (id >= return_bitset.size()) {
5833                 return_bitset.resize (id+16, false);
5834         }
5835         if (return_bitset[id]) {
5836                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5837         }
5838         return_bitset[id] = true;
5839 }
5840
5841 void
5842 Session::mark_insert_id (uint32_t id)
5843 {
5844         if (id >= insert_bitset.size()) {
5845                 insert_bitset.resize (id+16, false);
5846         }
5847         if (insert_bitset[id]) {
5848                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5849         }
5850         insert_bitset[id] = true;
5851 }
5852
5853 void
5854 Session::unmark_send_id (uint32_t id)
5855 {
5856         if (id < send_bitset.size()) {
5857                 send_bitset[id] = false;
5858         }
5859 }
5860
5861 void
5862 Session::unmark_aux_send_id (uint32_t id)
5863 {
5864         if (id < aux_send_bitset.size()) {
5865                 aux_send_bitset[id] = false;
5866         }
5867 }
5868
5869 void
5870 Session::unmark_return_id (uint32_t id)
5871 {
5872         if (_state_of_the_state & Deletion) { return; }
5873         if (id < return_bitset.size()) {
5874                 return_bitset[id] = false;
5875         }
5876 }
5877
5878 void
5879 Session::unmark_insert_id (uint32_t id)
5880 {
5881         if (id < insert_bitset.size()) {
5882                 insert_bitset[id] = false;
5883         }
5884 }
5885
5886 void
5887 Session::reset_native_file_format ()
5888 {
5889         boost::shared_ptr<RouteList> rl = routes.reader ();
5890
5891         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5892                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5893                 if (tr) {
5894                         /* don't save state as we do this, there's no point
5895                          */
5896                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5897                         tr->reset_write_sources (false);
5898                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5899                 }
5900         }
5901 }
5902
5903 bool
5904 Session::route_name_unique (string n) const
5905 {
5906         boost::shared_ptr<RouteList> r = routes.reader ();
5907
5908         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5909                 if ((*i)->name() == n) {
5910                         return false;
5911                 }
5912         }
5913
5914         return true;
5915 }
5916
5917 bool
5918 Session::route_name_internal (string n) const
5919 {
5920         if (auditioner && auditioner->name() == n) {
5921                 return true;
5922         }
5923
5924         if (_click_io && _click_io->name() == n) {
5925                 return true;
5926         }
5927
5928         return false;
5929 }
5930
5931 int
5932 Session::freeze_all (InterThreadInfo& itt)
5933 {
5934         boost::shared_ptr<RouteList> r = routes.reader ();
5935
5936         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5937
5938                 boost::shared_ptr<Track> t;
5939
5940                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5941                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5942                            of every track.
5943                         */
5944                         t->freeze_me (itt);
5945                 }
5946         }
5947
5948         return 0;
5949 }
5950
5951 boost::shared_ptr<Region>
5952 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5953                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5954                           InterThreadInfo& itt,
5955                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5956                           bool for_export, bool for_freeze)
5957 {
5958         boost::shared_ptr<Region> result;
5959         boost::shared_ptr<Playlist> playlist;
5960         boost::shared_ptr<Source> source;
5961         ChanCount diskstream_channels (track.n_channels());
5962         framepos_t position;
5963         framecnt_t this_chunk;
5964         framepos_t to_do;
5965         framepos_t latency_skip;
5966         BufferSet buffers;
5967         framepos_t len = end - start;
5968         bool need_block_size_reset = false;
5969         ChanCount const max_proc = track.max_processor_streams ();
5970         string legal_playlist_name;
5971         string possible_path;
5972
5973         if (end <= start) {
5974                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5975                                          end, start) << endmsg;
5976                 return result;
5977         }
5978
5979         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5980                         include_endpoint, for_export, for_freeze);
5981
5982         if (diskstream_channels.n(track.data_type()) < 1) {
5983                 error << _("Cannot write a range with no data.") << endmsg;
5984                 return result;
5985         }
5986
5987         // block all process callback handling
5988
5989         block_processing ();
5990
5991         {
5992                 // synchronize with AudioEngine::process_callback()
5993                 // make sure processing is not currently running
5994                 // and processing_blocked() is honored before
5995                 // acquiring thread buffers
5996                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5997         }
5998
5999         _bounce_processing_active = true;
6000
6001         /* call tree *MUST* hold route_lock */
6002
6003         if ((playlist = track.playlist()) == 0) {
6004                 goto out;
6005         }
6006
6007         legal_playlist_name = legalize_for_path (playlist->name());
6008
6009         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
6010
6011                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6012                 string path = ((track.data_type() == DataType::AUDIO)
6013                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6014                                : new_midi_source_path (legal_playlist_name));
6015
6016                 if (path.empty()) {
6017                         goto out;
6018                 }
6019
6020                 try {
6021                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
6022                 }
6023
6024                 catch (failed_constructor& err) {
6025                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6026                         goto out;
6027                 }
6028
6029                 srcs.push_back (source);
6030         }
6031
6032         /* tell redirects that care that we are about to use a much larger
6033          * blocksize. this will flush all plugins too, so that they are ready
6034          * to be used for this process.
6035          */
6036
6037         need_block_size_reset = true;
6038         track.set_block_size (bounce_chunk_size);
6039         _engine.main_thread()->get_buffers ();
6040
6041         position = start;
6042         to_do = len;
6043         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6044
6045         /* create a set of reasonably-sized buffers */
6046         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6047                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6048         }
6049         buffers.set_count (max_proc);
6050
6051         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6052                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6053                 boost::shared_ptr<MidiSource> ms;
6054                 if (afs) {
6055                         afs->prepare_for_peakfile_writes ();
6056                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6057                         Source::Lock lock(ms->mutex());
6058                         ms->mark_streaming_write_started(lock);
6059                 }
6060         }
6061
6062         while (to_do && !itt.cancel) {
6063
6064                 this_chunk = min (to_do, bounce_chunk_size);
6065
6066                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6067                         goto out;
6068                 }
6069
6070                 start += this_chunk;
6071                 to_do -= this_chunk;
6072                 itt.progress = (float) (1.0 - ((double) to_do / len));
6073
6074                 if (latency_skip >= bounce_chunk_size) {
6075                         latency_skip -= bounce_chunk_size;
6076                         continue;
6077                 }
6078
6079                 const framecnt_t current_chunk = this_chunk - latency_skip;
6080
6081                 uint32_t n = 0;
6082                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6083                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6084                         boost::shared_ptr<MidiSource> ms;
6085
6086                         if (afs) {
6087                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6088                                         goto out;
6089                                 }
6090                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6091                                 Source::Lock lock(ms->mutex());
6092
6093                                 const MidiBuffer& buf = buffers.get_midi(0);
6094                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6095                                         Evoral::Event<framepos_t> ev = *i;
6096                                         ev.set_time(ev.time() - position);
6097                                         ms->append_event_frames(lock, ev, ms->timeline_position());
6098                                 }
6099                         }
6100                 }
6101                 latency_skip = 0;
6102         }
6103
6104         /* post-roll, pick up delayed processor output */
6105         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6106
6107         while (latency_skip && !itt.cancel) {
6108                 this_chunk = min (latency_skip, bounce_chunk_size);
6109                 latency_skip -= this_chunk;
6110
6111                 buffers.silence (this_chunk, 0);
6112                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6113
6114                 uint32_t n = 0;
6115                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6116                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6117
6118                         if (afs) {
6119                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6120                                         goto out;
6121                                 }
6122                         }
6123                 }
6124         }
6125
6126         if (!itt.cancel) {
6127
6128                 time_t now;
6129                 struct tm* xnow;
6130                 time (&now);
6131                 xnow = localtime (&now);
6132
6133                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6134                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6135                         boost::shared_ptr<MidiSource> ms;
6136
6137                         if (afs) {
6138                                 afs->update_header (position, *xnow, now);
6139                                 afs->flush_header ();
6140                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6141                                 Source::Lock lock(ms->mutex());
6142                                 ms->mark_streaming_write_completed(lock);
6143                         }
6144                 }
6145
6146                 /* construct a region to represent the bounced material */
6147
6148                 PropertyList plist;
6149
6150                 plist.add (Properties::start, 0);
6151                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6152                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6153
6154                 result = RegionFactory::create (srcs, plist);
6155
6156         }
6157
6158   out:
6159         if (!result) {
6160                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6161                         (*src)->mark_for_remove ();
6162                         (*src)->drop_references ();
6163                 }
6164
6165         } else {
6166                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6167                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6168
6169                         if (afs)
6170                                 afs->done_with_peakfile_writes ();
6171                 }
6172         }
6173
6174         _bounce_processing_active = false;
6175
6176         if (need_block_size_reset) {
6177                 _engine.main_thread()->drop_buffers ();
6178                 track.set_block_size (get_block_size());
6179         }
6180
6181         unblock_processing ();
6182
6183         return result;
6184 }
6185
6186 gain_t*
6187 Session::gain_automation_buffer() const
6188 {
6189         return ProcessThread::gain_automation_buffer ();
6190 }
6191
6192 gain_t*
6193 Session::trim_automation_buffer() const
6194 {
6195         return ProcessThread::trim_automation_buffer ();
6196 }
6197
6198 gain_t*
6199 Session::send_gain_automation_buffer() const
6200 {
6201         return ProcessThread::send_gain_automation_buffer ();
6202 }
6203
6204 pan_t**
6205 Session::pan_automation_buffer() const
6206 {
6207         return ProcessThread::pan_automation_buffer ();
6208 }
6209
6210 BufferSet&
6211 Session::get_silent_buffers (ChanCount count)
6212 {
6213         return ProcessThread::get_silent_buffers (count);
6214 }
6215
6216 BufferSet&
6217 Session::get_scratch_buffers (ChanCount count, bool silence)
6218 {
6219         return ProcessThread::get_scratch_buffers (count, silence);
6220 }
6221
6222 BufferSet&
6223 Session::get_noinplace_buffers (ChanCount count)
6224 {
6225         return ProcessThread::get_noinplace_buffers (count);
6226 }
6227
6228 BufferSet&
6229 Session::get_route_buffers (ChanCount count, bool silence)
6230 {
6231         return ProcessThread::get_route_buffers (count, silence);
6232 }
6233
6234
6235 BufferSet&
6236 Session::get_mix_buffers (ChanCount count)
6237 {
6238         return ProcessThread::get_mix_buffers (count);
6239 }
6240
6241 uint32_t
6242 Session::ntracks () const
6243 {
6244         uint32_t n = 0;
6245         boost::shared_ptr<RouteList> r = routes.reader ();
6246
6247         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6248                 if (boost::dynamic_pointer_cast<Track> (*i)) {
6249                         ++n;
6250                 }
6251         }
6252
6253         return n;
6254 }
6255
6256 uint32_t
6257 Session::nbusses () const
6258 {
6259         uint32_t n = 0;
6260         boost::shared_ptr<RouteList> r = routes.reader ();
6261
6262         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6263                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6264                         ++n;
6265                 }
6266         }
6267
6268         return n;
6269 }
6270
6271 void
6272 Session::add_automation_list(AutomationList *al)
6273 {
6274         automation_lists[al->id()] = al;
6275 }
6276
6277 /** @return true if there is at least one record-enabled track, otherwise false */
6278 bool
6279 Session::have_rec_enabled_track () const
6280 {
6281         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6282 }
6283
6284 bool
6285 Session::have_rec_disabled_track () const
6286 {
6287     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6288 }
6289
6290 /** Update the state of our rec-enabled tracks flag */
6291 void
6292 Session::update_route_record_state ()
6293 {
6294         boost::shared_ptr<RouteList> rl = routes.reader ();
6295         RouteList::iterator i = rl->begin();
6296         while (i != rl->end ()) {
6297
6298                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6299                                     if (tr && tr->rec_enable_control()->get_value()) {
6300                         break;
6301                 }
6302
6303                 ++i;
6304         }
6305
6306         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6307
6308         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6309
6310         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6311                 RecordStateChanged (); /* EMIT SIGNAL */
6312         }
6313
6314         for (i = rl->begin(); i != rl->end (); ++i) {
6315                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6316                 if (tr && !tr->rec_enable_control()->get_value()) {
6317                         break;
6318                 }
6319         }
6320
6321         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6322
6323         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6324
6325         if (record_status() == Recording && record_arm_state_changed ) {
6326                 RecordArmStateChanged ();
6327         }
6328
6329 }
6330
6331 void
6332 Session::listen_position_changed ()
6333 {
6334         ProcessorChangeBlocker pcb (this);
6335         boost::shared_ptr<RouteList> r = routes.reader ();
6336         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6337                 (*i)->listen_position_changed ();
6338         }
6339 }
6340
6341 void
6342 Session::solo_control_mode_changed ()
6343 {
6344         if (soloing() || listening()) {
6345                 if (loading()) {
6346                         /* We can't use ::clear_all_solo_state() here because during
6347                            session loading at program startup, that will queue a call
6348                            to rt_clear_all_solo_state() that will not execute until
6349                            AFTER solo states have been established (thus throwing away
6350                            the session's saved solo state). So just explicitly turn
6351                            them all off.
6352                         */
6353                         set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6354                 } else {
6355                         clear_all_solo_state (get_routes());
6356                 }
6357         }
6358 }
6359
6360 /** Called when a property of one of our route groups changes */
6361 void
6362 Session::route_group_property_changed (RouteGroup* rg)
6363 {
6364         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6365 }
6366
6367 /** Called when a route is added to one of our route groups */
6368 void
6369 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6370 {
6371         RouteAddedToRouteGroup (rg, r);
6372 }
6373
6374 /** Called when a route is removed from one of our route groups */
6375 void
6376 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6377 {
6378         update_route_record_state ();
6379         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6380
6381         if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6382                 remove_route_group (*rg);
6383         }
6384 }
6385
6386 boost::shared_ptr<RouteList>
6387 Session::get_tracks () const
6388 {
6389         boost::shared_ptr<RouteList> rl = routes.reader ();
6390         boost::shared_ptr<RouteList> tl (new RouteList);
6391
6392         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6393                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6394                         if (!(*r)->is_auditioner()) {
6395                                 tl->push_back (*r);
6396                         }
6397                 }
6398         }
6399         return tl;
6400 }
6401
6402 boost::shared_ptr<RouteList>
6403 Session::get_routes_with_regions_at (framepos_t const p) const
6404 {
6405         boost::shared_ptr<RouteList> r = routes.reader ();
6406         boost::shared_ptr<RouteList> rl (new RouteList);
6407
6408         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6409                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6410                 if (!tr) {
6411                         continue;
6412                 }
6413
6414                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6415                 if (!pl) {
6416                         continue;
6417                 }
6418
6419                 if (pl->has_region_at (p)) {
6420                         rl->push_back (*i);
6421                 }
6422         }
6423
6424         return rl;
6425 }
6426
6427 void
6428 Session::goto_end ()
6429 {
6430         if (_session_range_location) {
6431                 request_locate (_session_range_location->end(), false);
6432         } else {
6433                 request_locate (0, false);
6434         }
6435 }
6436
6437 void
6438 Session::goto_start (bool and_roll)
6439 {
6440         if (_session_range_location) {
6441                 request_locate (_session_range_location->start(), and_roll);
6442         } else {
6443                 request_locate (0, and_roll);
6444         }
6445 }
6446
6447 framepos_t
6448 Session::current_start_frame () const
6449 {
6450         return _session_range_location ? _session_range_location->start() : 0;
6451 }
6452
6453 framepos_t
6454 Session::current_end_frame () const
6455 {
6456         return _session_range_location ? _session_range_location->end() : 0;
6457 }
6458
6459 void
6460 Session::set_session_range_location (framepos_t start, framepos_t end)
6461 {
6462         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6463         _locations->add (_session_range_location);
6464 }
6465
6466 void
6467 Session::step_edit_status_change (bool yn)
6468 {
6469         bool send = false;
6470
6471         bool val = false;
6472         if (yn) {
6473                 send = (_step_editors == 0);
6474                 val = true;
6475
6476                 _step_editors++;
6477         } else {
6478                 send = (_step_editors == 1);
6479                 val = false;
6480
6481                 if (_step_editors > 0) {
6482                         _step_editors--;
6483                 }
6484         }
6485
6486         if (send) {
6487                 StepEditStatusChange (val);
6488         }
6489 }
6490
6491
6492 void
6493 Session::start_time_changed (framepos_t old)
6494 {
6495         /* Update the auto loop range to match the session range
6496            (unless the auto loop range has been changed by the user)
6497         */
6498
6499         Location* s = _locations->session_range_location ();
6500         if (s == 0) {
6501                 return;
6502         }
6503
6504         Location* l = _locations->auto_loop_location ();
6505
6506         if (l && l->start() == old) {
6507                 l->set_start (s->start(), true);
6508         }
6509         set_dirty ();
6510 }
6511
6512 void
6513 Session::end_time_changed (framepos_t old)
6514 {
6515         /* Update the auto loop range to match the session range
6516            (unless the auto loop range has been changed by the user)
6517         */
6518
6519         Location* s = _locations->session_range_location ();
6520         if (s == 0) {
6521                 return;
6522         }
6523
6524         Location* l = _locations->auto_loop_location ();
6525
6526         if (l && l->end() == old) {
6527                 l->set_end (s->end(), true);
6528         }
6529         set_dirty ();
6530 }
6531
6532 std::vector<std::string>
6533 Session::source_search_path (DataType type) const
6534 {
6535         Searchpath sp;
6536
6537         if (session_dirs.size() == 1) {
6538                 switch (type) {
6539                 case DataType::AUDIO:
6540                         sp.push_back (_session_dir->sound_path());
6541                         break;
6542                 case DataType::MIDI:
6543                         sp.push_back (_session_dir->midi_path());
6544                         break;
6545                 }
6546         } else {
6547                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6548                         SessionDirectory sdir (i->path);
6549                         switch (type) {
6550                         case DataType::AUDIO:
6551                                 sp.push_back (sdir.sound_path());
6552                                 break;
6553                         case DataType::MIDI:
6554                                 sp.push_back (sdir.midi_path());
6555                                 break;
6556                         }
6557                 }
6558         }
6559
6560         if (type == DataType::AUDIO) {
6561                 const string sound_path_2X = _session_dir->sound_path_2X();
6562                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6563                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6564                                 sp.push_back (sound_path_2X);
6565                         }
6566                 }
6567         }
6568
6569         // now check the explicit (possibly user-specified) search path
6570
6571         switch (type) {
6572         case DataType::AUDIO:
6573                 sp += Searchpath(config.get_audio_search_path ());
6574                 break;
6575         case DataType::MIDI:
6576                 sp += Searchpath(config.get_midi_search_path ());
6577                 break;
6578         }
6579
6580         return sp;
6581 }
6582
6583 void
6584 Session::ensure_search_path_includes (const string& path, DataType type)
6585 {
6586         Searchpath sp;
6587
6588         if (path == ".") {
6589                 return;
6590         }
6591
6592         switch (type) {
6593         case DataType::AUDIO:
6594                 sp += Searchpath(config.get_audio_search_path ());
6595                 break;
6596         case DataType::MIDI:
6597                 sp += Searchpath (config.get_midi_search_path ());
6598                 break;
6599         }
6600
6601         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6602                 /* No need to add this new directory if it has the same inode as
6603                    an existing one; checking inode rather than name prevents duplicated
6604                    directories when we are using symlinks.
6605
6606                    On Windows, I think we could just do if (*i == path) here.
6607                 */
6608                 if (PBD::equivalent_paths (*i, path)) {
6609                         return;
6610                 }
6611         }
6612
6613         sp += path;
6614
6615         switch (type) {
6616         case DataType::AUDIO:
6617                 config.set_audio_search_path (sp.to_string());
6618                 break;
6619         case DataType::MIDI:
6620                 config.set_midi_search_path (sp.to_string());
6621                 break;
6622         }
6623 }
6624
6625 void
6626 Session::remove_dir_from_search_path (const string& dir, DataType type)
6627 {
6628         Searchpath sp;
6629
6630         switch (type) {
6631         case DataType::AUDIO:
6632                 sp = Searchpath(config.get_audio_search_path ());
6633                 break;
6634         case DataType::MIDI:
6635                 sp = Searchpath (config.get_midi_search_path ());
6636                 break;
6637         }
6638
6639         sp -= dir;
6640
6641         switch (type) {
6642         case DataType::AUDIO:
6643                 config.set_audio_search_path (sp.to_string());
6644                 break;
6645         case DataType::MIDI:
6646                 config.set_midi_search_path (sp.to_string());
6647                 break;
6648         }
6649
6650 }
6651
6652 boost::shared_ptr<Speakers>
6653 Session::get_speakers()
6654 {
6655         return _speakers;
6656 }
6657
6658 list<string>
6659 Session::unknown_processors () const
6660 {
6661         list<string> p;
6662
6663         boost::shared_ptr<RouteList> r = routes.reader ();
6664         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6665                 list<string> t = (*i)->unknown_processors ();
6666                 copy (t.begin(), t.end(), back_inserter (p));
6667         }
6668
6669         p.sort ();
6670         p.unique ();
6671
6672         return p;
6673 }
6674
6675 void
6676 Session::update_latency (bool playback)
6677 {
6678
6679         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6680
6681         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6682                 return;
6683         }
6684
6685         boost::shared_ptr<RouteList> r = routes.reader ();
6686         framecnt_t max_latency = 0;
6687
6688         if (playback) {
6689                 /* reverse the list so that we work backwards from the last route to run to the first */
6690                 RouteList* rl = routes.reader().get();
6691                 r.reset (new RouteList (*rl));
6692                 reverse (r->begin(), r->end());
6693         }
6694
6695         /* compute actual latency values for the given direction and store them all in per-port
6696            structures. this will also publish the same values (to JACK) so that computation of latency
6697            for routes can consistently use public latency values.
6698         */
6699
6700         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6701                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6702         }
6703
6704         /* because we latency compensate playback, our published playback latencies should
6705            be the same for all output ports - all material played back by ardour has
6706            the same latency, whether its caused by plugins or by latency compensation. since
6707            these may differ from the values computed above, reset all playback port latencies
6708            to the same value.
6709         */
6710
6711         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6712
6713         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6714                 (*i)->set_public_port_latencies (max_latency, playback);
6715         }
6716
6717         if (playback) {
6718
6719                 post_playback_latency ();
6720
6721         } else {
6722
6723                 post_capture_latency ();
6724         }
6725
6726         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6727 }
6728
6729 void
6730 Session::post_playback_latency ()
6731 {
6732         set_worst_playback_latency ();
6733
6734         boost::shared_ptr<RouteList> r = routes.reader ();
6735
6736         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6737                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6738                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6739                 }
6740         }
6741
6742         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6743                 (*i)->set_latency_compensation (_worst_track_latency);
6744         }
6745 }
6746
6747 void
6748 Session::post_capture_latency ()
6749 {
6750         set_worst_capture_latency ();
6751
6752         /* reflect any changes in capture latencies into capture offsets
6753          */
6754
6755         boost::shared_ptr<RouteList> rl = routes.reader();
6756         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6757                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6758                 if (tr) {
6759                         tr->set_capture_offset ();
6760                 }
6761         }
6762 }
6763
6764 void
6765 Session::initialize_latencies ()
6766 {
6767         {
6768                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6769                 update_latency (false);
6770                 update_latency (true);
6771         }
6772
6773         set_worst_io_latencies ();
6774 }
6775
6776 void
6777 Session::set_worst_io_latencies ()
6778 {
6779         set_worst_playback_latency ();
6780         set_worst_capture_latency ();
6781 }
6782
6783 void
6784 Session::set_worst_playback_latency ()
6785 {
6786         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6787                 return;
6788         }
6789
6790         _worst_output_latency = 0;
6791
6792         if (!_engine.connected()) {
6793                 return;
6794         }
6795
6796         boost::shared_ptr<RouteList> r = routes.reader ();
6797
6798         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6799                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6800         }
6801
6802         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6803 }
6804
6805 void
6806 Session::set_worst_capture_latency ()
6807 {
6808         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6809                 return;
6810         }
6811
6812         _worst_input_latency = 0;
6813
6814         if (!_engine.connected()) {
6815                 return;
6816         }
6817
6818         boost::shared_ptr<RouteList> r = routes.reader ();
6819
6820         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6821                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6822         }
6823
6824         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6825 }
6826
6827 void
6828 Session::update_latency_compensation (bool force_whole_graph)
6829 {
6830         bool some_track_latency_changed = false;
6831
6832         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6833                 return;
6834         }
6835
6836         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6837
6838         _worst_track_latency = 0;
6839
6840         boost::shared_ptr<RouteList> r = routes.reader ();
6841
6842         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6843                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6844                         framecnt_t tl;
6845                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6846                                 some_track_latency_changed = true;
6847                         }
6848                         _worst_track_latency = max (tl, _worst_track_latency);
6849                 }
6850         }
6851
6852         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6853                                                      (some_track_latency_changed ? "yes" : "no")));
6854
6855         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6856
6857         if (some_track_latency_changed || force_whole_graph)  {
6858                 _engine.update_latencies ();
6859         }
6860
6861
6862         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6863                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6864                 if (!tr) {
6865                         continue;
6866                 }
6867                 tr->set_capture_offset ();
6868         }
6869 }
6870
6871 char
6872 Session::session_name_is_legal (const string& path)
6873 {
6874         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6875
6876         for (int i = 0; illegal_chars[i]; ++i) {
6877                 if (path.find (illegal_chars[i]) != string::npos) {
6878                         return illegal_chars[i];
6879                 }
6880         }
6881
6882         return 0;
6883 }
6884
6885 void
6886 Session::notify_presentation_info_change ()
6887 {
6888         if (deletion_in_progress()) {
6889                 return;
6890         }
6891
6892         reassign_track_numbers();
6893
6894 #ifdef USE_TRACKS_CODE_FEATURES
6895         /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6896          * if track order has been changed by user
6897          */
6898         reconnect_existing_routes(true, true);
6899 #endif
6900
6901 }
6902
6903 bool
6904 Session::operation_in_progress (GQuark op) const
6905 {
6906         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6907 }
6908
6909 boost::shared_ptr<Port>
6910 Session::ltc_input_port () const
6911 {
6912         return _ltc_input->nth (0);
6913 }
6914
6915 boost::shared_ptr<Port>
6916 Session::ltc_output_port () const
6917 {
6918         return _ltc_output->nth (0);
6919 }
6920
6921 void
6922 Session::reconnect_ltc_input ()
6923 {
6924         if (_ltc_input) {
6925
6926                 string src = Config->get_ltc_source_port();
6927
6928                 _ltc_input->disconnect (this);
6929
6930                 if (src != _("None") && !src.empty())  {
6931                         _ltc_input->nth (0)->connect (src);
6932                 }
6933
6934                 if ( ARDOUR::Profile->get_trx () ) {
6935                         // Tracks need this signal to update timecode_source_dropdown
6936                         MtcOrLtcInputPortChanged (); //emit signal
6937                 }
6938         }
6939 }
6940
6941 void
6942 Session::reconnect_ltc_output ()
6943 {
6944         if (_ltc_output) {
6945
6946                 string src = Config->get_ltc_output_port();
6947
6948                 _ltc_output->disconnect (this);
6949
6950                 if (src != _("None") && !src.empty())  {
6951                         _ltc_output->nth (0)->connect (src);
6952                 }
6953         }
6954 }
6955
6956 void
6957 Session::set_range_selection (framepos_t start, framepos_t end)
6958 {
6959         _range_selection = Evoral::Range<framepos_t> (start, end);
6960 #ifdef USE_TRACKS_CODE_FEATURES
6961         follow_playhead_priority ();
6962 #endif
6963 }
6964
6965 void
6966 Session::set_object_selection (framepos_t start, framepos_t end)
6967 {
6968         _object_selection = Evoral::Range<framepos_t> (start, end);
6969 #ifdef USE_TRACKS_CODE_FEATURES
6970         follow_playhead_priority ();
6971 #endif
6972 }
6973
6974 void
6975 Session::clear_range_selection ()
6976 {
6977         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6978 #ifdef USE_TRACKS_CODE_FEATURES
6979         follow_playhead_priority ();
6980 #endif
6981 }
6982
6983 void
6984 Session::clear_object_selection ()
6985 {
6986         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6987 #ifdef USE_TRACKS_CODE_FEATURES
6988         follow_playhead_priority ();
6989 #endif
6990 }
6991
6992 void
6993 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
6994                 const ChanCount& input_start,
6995                 const ChanCount& output_start,
6996                 const ChanCount& input_offset,
6997                 const ChanCount& output_offset)
6998 {
6999         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7000         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7001                                 input_start, output_start,
7002                                 input_offset, output_offset));
7003
7004         auto_connect_thread_wakeup ();
7005 }
7006
7007 void
7008 Session::auto_connect_thread_wakeup ()
7009 {
7010         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7011                 pthread_cond_signal (&_auto_connect_cond);
7012                 pthread_mutex_unlock (&_auto_connect_mutex);
7013         }
7014 }
7015
7016 void
7017 Session::queue_latency_recompute ()
7018 {
7019         g_atomic_int_inc (&_latency_recompute_pending);
7020         auto_connect_thread_wakeup ();
7021 }
7022
7023 void
7024 Session::auto_connect (const AutoConnectRequest& ar)
7025 {
7026         boost::shared_ptr<Route> route = ar.route.lock();
7027
7028         if (!route) { return; }
7029
7030         if (!IO::connecting_legal) {
7031                 return;
7032         }
7033
7034         /* If both inputs and outputs are auto-connected to physical ports,
7035          * use the max of input and output offsets to ensure auto-connected
7036          * port numbers always match up (e.g. the first audio input and the
7037          * first audio output of the route will have the same physical
7038          * port number).  Otherwise just use the lowest input or output
7039          * offset possible.
7040          */
7041
7042         const bool in_out_physical =
7043                 (Config->get_input_auto_connect() & AutoConnectPhysical)
7044                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7045                 && ar.connect_inputs;
7046
7047         const ChanCount in_offset = in_out_physical
7048                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7049                 : ar.input_offset;
7050
7051         const ChanCount out_offset = in_out_physical
7052                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7053                 : ar.output_offset;
7054
7055         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7056                 vector<string> physinputs;
7057                 vector<string> physoutputs;
7058
7059
7060                 /* for connecting track inputs we only want MIDI ports marked
7061                  * for "music".
7062                  */
7063
7064                 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7065
7066                 if (!physinputs.empty() && ar.connect_inputs) {
7067                         uint32_t nphysical_in = physinputs.size();
7068
7069                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7070                                 string port;
7071
7072                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7073                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7074                                 }
7075
7076                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7077                                         break;
7078                                 }
7079                         }
7080                 }
7081
7082                 if (!physoutputs.empty()) {
7083                         uint32_t nphysical_out = physoutputs.size();
7084                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7085                                 string port;
7086
7087                                 /* Waves Tracks:
7088                                  * do not create new connections if we reached the limit of physical outputs
7089                                  * in Multi Out mode
7090                                  */
7091                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7092                                                 ARDOUR::Profile->get_trx () &&
7093                                                 ar.output_offset.get(*t) == nphysical_out ) {
7094                                         break;
7095                                 }
7096
7097                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7098                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7099                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7100                                         /* master bus is audio only */
7101                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7102                                                 port = _master_out->input()->ports().port(*t,
7103                                                                 i % _master_out->input()->n_ports().get(*t))->name();
7104                                         }
7105                                 }
7106
7107                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7108                                         break;
7109                                 }
7110                         }
7111                 }
7112         }
7113 }
7114
7115 void
7116 Session::auto_connect_thread_start ()
7117 {
7118         if (g_atomic_int_get (&_ac_thread_active)) {
7119                 return;
7120         }
7121
7122         while (!_auto_connect_queue.empty ()) {
7123                 _auto_connect_queue.pop ();
7124         }
7125
7126         g_atomic_int_set (&_ac_thread_active, 1);
7127         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7128                 g_atomic_int_set (&_ac_thread_active, 0);
7129         }
7130 }
7131
7132 void
7133 Session::auto_connect_thread_terminate ()
7134 {
7135         if (!g_atomic_int_get (&_ac_thread_active)) {
7136                 return;
7137         }
7138
7139         {
7140                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7141                 while (!_auto_connect_queue.empty ()) {
7142                         _auto_connect_queue.pop ();
7143                 }
7144         }
7145
7146         /* cannot use auto_connect_thread_wakeup() because that is allowed to
7147          * fail to wakeup the thread.
7148          */
7149
7150         pthread_mutex_lock (&_auto_connect_mutex);
7151         g_atomic_int_set (&_ac_thread_active, 0);
7152         pthread_cond_signal (&_auto_connect_cond);
7153         pthread_mutex_unlock (&_auto_connect_mutex);
7154
7155         void *status;
7156         pthread_join (_auto_connect_thread, &status);
7157 }
7158
7159 void *
7160 Session::auto_connect_thread (void *arg)
7161 {
7162         Session *s = static_cast<Session *>(arg);
7163         s->auto_connect_thread_run ();
7164         pthread_exit (0);
7165         return 0;
7166 }
7167
7168 void
7169 Session::auto_connect_thread_run ()
7170 {
7171         pthread_set_name (X_("autoconnect"));
7172         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7173         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7174         pthread_mutex_lock (&_auto_connect_mutex);
7175         while (g_atomic_int_get (&_ac_thread_active)) {
7176
7177                 if (!_auto_connect_queue.empty ()) {
7178                         // Why would we need the process lock ??
7179                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7180                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7181                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
7182                         //   We have control over those, but what does jack do?
7183                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7184
7185                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7186                         while (!_auto_connect_queue.empty ()) {
7187                                 const AutoConnectRequest ar (_auto_connect_queue.front());
7188                                 _auto_connect_queue.pop ();
7189                                 lx.release ();
7190                                 auto_connect (ar);
7191                                 lx.acquire ();
7192                         }
7193                 }
7194
7195                 if (!actively_recording ()) { // might not be needed,
7196                         /* this is only used for updating plugin latencies, the
7197                          * graph does not change. so it's safe in general.
7198                          * BUT..
7199                          * .. update_latency_compensation () entails set_capture_offset()
7200                          * which calls Diskstream::set_capture_offset () which
7201                          * modifies the capture offset... which can be a proplem
7202                          * in "prepare_to_stop"
7203                          */
7204                         while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7205                                 update_latency_compensation ();
7206                         }
7207                 }
7208
7209                 {
7210                         // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7211                         // jack1 cannot cope with removing ports while processing
7212                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7213                         AudioEngine::instance()->clear_pending_port_deletions ();
7214                 }
7215
7216                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7217         }
7218         pthread_mutex_unlock (&_auto_connect_mutex);
7219 }
7220
7221 void
7222 Session::cancel_all_solo ()
7223 {
7224         StripableList sl;
7225
7226         get_stripables (sl);
7227
7228         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7229         clear_all_solo_state (routes.reader());
7230 }