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