libs/ardour/session.cc

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