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) 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);
4897
4898         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4899                 boost::shared_ptr<MidiSource> ms
4900                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4901                 boost::shared_ptr<FileSource> fs
4902                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4903
4904                 if (ms && fs && fs->path() == path) {
4905                         return ms;
4906                 }
4907         }
4908
4909         return boost::shared_ptr<MidiSource>();
4910 }
4911
4912 uint32_t
4913 Session::count_sources_by_origin (const string& path)
4914 {
4915         uint32_t cnt = 0;
4916         Glib::Threads::Mutex::Lock lm (source_lock);
4917
4918         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4919                 boost::shared_ptr<FileSource> fs
4920                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4921
4922                 if (fs && fs->origin() == path) {
4923                         ++cnt;
4924                 }
4925         }
4926
4927         return cnt;
4928 }
4929
4930 static string
4931 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4932         if (hash) {
4933                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4934                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4935         } else {
4936                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4937         }
4938 }
4939
4940 string
4941 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4942 {
4943         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4944
4945         if (Glib::path_is_absolute (filepath)) {
4946
4947                 /* rip the session dir from the audiofile source */
4948
4949                 string session_path;
4950                 bool in_another_session = true;
4951
4952                 if (filepath.find (interchange_dir_string) != string::npos) {
4953
4954                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4955                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4956                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4957                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4958
4959                         /* see if it is within our session */
4960
4961                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4962                                 if (i->path == session_path) {
4963                                         in_another_session = false;
4964                                         break;
4965                                 }
4966                         }
4967                 } else {
4968                         in_another_session = false;
4969                 }
4970
4971
4972                 if (in_another_session) {
4973                         SessionDirectory sd (session_path);
4974                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4975                 }
4976         }
4977
4978         /* 1) if file belongs to this session
4979          * it may be a relative path (interchange/...)
4980          * or just basename (session_state, remove source)
4981          * -> just use the basename
4982          */
4983         std::string filename = Glib::path_get_basename (filepath);
4984         std::string path;
4985
4986         /* 2) if the file is outside our session dir:
4987          * (imported but not copied) add the path for check-summming */
4988         if (!in_session) {
4989                 path = Glib::path_get_dirname (filepath);
4990         }
4991
4992         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4993 }
4994
4995 string
4996 Session::new_audio_source_path_for_embedded (const std::string& path)
4997 {
4998         /* embedded source:
4999          *
5000          * we know that the filename is already unique because it exists
5001          * out in the filesystem.
5002          *
5003          * However, when we bring it into the session, we could get a
5004          * collision.
5005          *
5006          * Eg. two embedded files:
5007          *
5008          *          /foo/bar/baz.wav
5009          *          /frob/nic/baz.wav
5010          *
5011          * When merged into session, these collide.
5012          *
5013          * There will not be a conflict with in-memory sources
5014          * because when the source was created we already picked
5015          * a unique name for it.
5016          *
5017          * This collision is not likely to be common, but we have to guard
5018          * against it.  So, if there is a collision, take the md5 hash of the
5019          * the path, and use that as the filename instead.
5020          */
5021
5022         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5023         string base = Glib::path_get_basename (path);
5024         string newpath = Glib::build_filename (sdir.sound_path(), base);
5025
5026         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5027
5028                 MD5 md5;
5029
5030                 md5.digestString (path.c_str());
5031                 md5.writeToString ();
5032                 base = md5.digestChars;
5033
5034                 string ext = get_suffix (path);
5035
5036                 if (!ext.empty()) {
5037                         base += '.';
5038                         base += ext;
5039                 }
5040
5041                 newpath = Glib::build_filename (sdir.sound_path(), base);
5042
5043                 /* if this collides, we're screwed */
5044
5045                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5046                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5047                         return string();
5048                 }
5049
5050         }
5051
5052         return newpath;
5053 }
5054
5055 /** Return true if there are no audio file sources that use @param name as
5056  * the filename component of their path.
5057  *
5058  * Return false otherwise.
5059  *
5060  * This method MUST ONLY be used to check in-session, mono files since it
5061  * hard-codes the channel of the audio file source we are looking for as zero.
5062  *
5063  * If/when Ardour supports native files in non-mono formats, the logic here
5064  * will need to be revisited.
5065  */
5066 bool
5067 Session::audio_source_name_is_unique (const string& name)
5068 {
5069         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5070         vector<space_and_path>::iterator i;
5071         uint32_t existing = 0;
5072
5073         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5074
5075                 /* note that we search *without* the extension so that
5076                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5077                    in the event that this new name is required for
5078                    a file format change.
5079                 */
5080
5081                 const string spath = *i;
5082
5083                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5084                         existing++;
5085                         break;
5086                 }
5087
5088                 /* it is possible that we have the path already
5089                  * assigned to a source that has not yet been written
5090                  * (ie. the write source for a diskstream). we have to
5091                  * check this in order to make sure that our candidate
5092                  * path isn't used again, because that can lead to
5093                  * two Sources point to the same file with different
5094                  * notions of their removability.
5095                  */
5096
5097
5098                 string possible_path = Glib::build_filename (spath, name);
5099
5100                 if (audio_source_by_path_and_channel (possible_path, 0)) {
5101                         existing++;
5102                         break;
5103                 }
5104         }
5105
5106         return (existing == 0);
5107 }
5108
5109 string
5110 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)
5111 {
5112         ostringstream sstr;
5113         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5114
5115         if (Profile->get_trx() && destructive) {
5116                 sstr << 'T';
5117                 sstr << setfill ('0') << setw (4) << cnt;
5118                 sstr << legalized_base;
5119         } else {
5120                 sstr << legalized_base;
5121
5122                 if (take_required || related_exists) {
5123                         sstr << '-';
5124                         sstr << cnt;
5125                 }
5126         }
5127
5128         if (nchan == 2) {
5129                 if (chan == 0) {
5130                         sstr << "%L";
5131                 } else {
5132                         sstr << "%R";
5133                 }
5134         } else if (nchan > 2) {
5135                 if (nchan < 26) {
5136                         sstr << '%';
5137                         sstr << 'a' + chan;
5138                 } else {
5139                         /* XXX what? more than 26 channels! */
5140                         sstr << '%';
5141                         sstr << chan+1;
5142                 }
5143         }
5144
5145         sstr << ext;
5146
5147         return sstr.str();
5148 }
5149
5150 /** Return a unique name based on \a base for a new internal audio source */
5151 string
5152 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5153 {
5154         uint32_t cnt;
5155         string possible_name;
5156         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5157         string legalized;
5158         bool some_related_source_name_exists = false;
5159
5160         legalized = legalize_for_path (base);
5161
5162         // Find a "version" of the base name that doesn't exist in any of the possible directories.
5163
5164         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5165
5166                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5167
5168                 if (audio_source_name_is_unique (possible_name)) {
5169                         break;
5170                 }
5171
5172                 some_related_source_name_exists = true;
5173
5174                 if (cnt > limit) {
5175                         error << string_compose(
5176                                         _("There are already %1 recordings for %2, which I consider too many."),
5177                                         limit, base) << endmsg;
5178                         destroy ();
5179                         throw failed_constructor();
5180                 }
5181         }
5182
5183         /* We've established that the new name does not exist in any session
5184          * directory, so now find out which one we should use for this new
5185          * audio source.
5186          */
5187
5188         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5189
5190         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5191
5192         return s;
5193 }
5194
5195 /** Return a unique name based on `base` for a new internal MIDI source */
5196 string
5197 Session::new_midi_source_path (const string& base)
5198 {
5199         uint32_t cnt;
5200         char buf[PATH_MAX+1];
5201         const uint32_t limit = 10000;
5202         string legalized;
5203         string possible_path;
5204         string possible_name;
5205
5206         buf[0] = '\0';
5207         legalized = legalize_for_path (base);
5208
5209         // Find a "version" of the file name that doesn't exist in any of the possible directories.
5210         std::vector<string> sdirs = source_search_path(DataType::MIDI);
5211
5212         /* - the main session folder is the first in the vector.
5213          * - after checking all locations for file-name uniqueness,
5214          *   we keep the one from the last iteration as new file name
5215          * - midi files are small and should just be kept in the main session-folder
5216          *
5217          * -> reverse the array, check main session folder last and use that as location
5218          *    for MIDI files.
5219          */
5220         std::reverse(sdirs.begin(), sdirs.end());
5221
5222         for (cnt = 1; cnt <= limit; ++cnt) {
5223
5224                 vector<space_and_path>::iterator i;
5225                 uint32_t existing = 0;
5226
5227                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5228
5229                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
5230                         possible_name = buf;
5231
5232                         possible_path = Glib::build_filename (*i, possible_name);
5233
5234                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5235                                 existing++;
5236                         }
5237
5238                         if (midi_source_by_path (possible_path)) {
5239                                 existing++;
5240                         }
5241                 }
5242
5243                 if (existing == 0) {
5244                         break;
5245                 }
5246
5247                 if (cnt > limit) {
5248                         error << string_compose(
5249                                         _("There are already %1 recordings for %2, which I consider too many."),
5250                                         limit, base) << endmsg;
5251                         destroy ();
5252                         return 0;
5253                 }
5254         }
5255
5256         /* No need to "find best location" for software/app-based RAID, because
5257            MIDI is so small that we always put it in the same place.
5258         */
5259
5260         return possible_path;
5261 }
5262
5263
5264 /** Create a new within-session audio source */
5265 boost::shared_ptr<AudioFileSource>
5266 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5267 {
5268         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5269
5270         if (!path.empty()) {
5271                 return boost::dynamic_pointer_cast<AudioFileSource> (
5272                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
5273         } else {
5274                 throw failed_constructor ();
5275         }
5276 }
5277
5278 /** Create a new within-session MIDI source */
5279 boost::shared_ptr<MidiSource>
5280 Session::create_midi_source_for_session (string const & basic_name)
5281 {
5282         const string path = new_midi_source_path (basic_name);
5283
5284         if (!path.empty()) {
5285                 return boost::dynamic_pointer_cast<SMFSource> (
5286                         SourceFactory::createWritable (
5287                                 DataType::MIDI, *this, path, false, frame_rate()));
5288         } else {
5289                 throw failed_constructor ();
5290         }
5291 }
5292
5293 /** Create a new within-session MIDI source */
5294 boost::shared_ptr<MidiSource>
5295 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5296 {
5297         /* the caller passes in the track the source will be used in,
5298            so that we can keep the numbering sane.
5299
5300            Rationale: a track with the name "Foo" that has had N
5301            captures carried out so far will ALREADY have a write source
5302            named "Foo-N+1.mid" waiting to be used for the next capture.
5303
5304            If we call new_midi_source_name() we will get "Foo-N+2". But
5305            there is no region corresponding to "Foo-N+1", so when
5306            "Foo-N+2" appears in the track, the gap presents the user
5307            with odd behaviour - why did it skip past Foo-N+1?
5308
5309            We could explain this to the user in some odd way, but
5310            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5311            use "Foo-N+1" here.
5312
5313            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5314         */
5315
5316         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5317         assert (mt);
5318         std::string name = track->steal_write_source_name ();
5319
5320         if (name.empty()) {
5321                 return boost::shared_ptr<MidiSource>();
5322         }
5323
5324         /* MIDI files are small, just put them in the first location of the
5325            session source search path.
5326         */
5327
5328         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5329
5330         return boost::dynamic_pointer_cast<SMFSource> (
5331                 SourceFactory::createWritable (
5332                         DataType::MIDI, *this, path, false, frame_rate()));
5333 }
5334
5335
5336 void
5337 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5338 {
5339         if (playlist->hidden()) {
5340                 return;
5341         }
5342
5343         playlists->add (playlist);
5344
5345         if (unused) {
5346                 playlist->release();
5347         }
5348
5349         set_dirty();
5350 }
5351
5352 void
5353 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5354 {
5355         if (_state_of_the_state & Deletion) {
5356                 return;
5357         }
5358
5359         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5360
5361         if (!playlist) {
5362                 return;
5363         }
5364
5365         playlists->remove (playlist);
5366
5367         set_dirty();
5368 }
5369
5370 void
5371 Session::set_audition (boost::shared_ptr<Region> r)
5372 {
5373         pending_audition_region = r;
5374         add_post_transport_work (PostTransportAudition);
5375         _butler->schedule_transport_work ();
5376 }
5377
5378 void
5379 Session::audition_playlist ()
5380 {
5381         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5382         ev->region.reset ();
5383         queue_event (ev);
5384 }
5385
5386
5387 void
5388 Session::register_lua_function (
5389                 const std::string& name,
5390                 const std::string& script,
5391                 const LuaScriptParamList& args
5392                 )
5393 {
5394         Glib::Threads::Mutex::Lock lm (lua_lock);
5395
5396         lua_State* L = lua.getState();
5397
5398         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5399         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5400         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5401                 if ((*i)->optional && !(*i)->is_set) { continue; }
5402                 tbl_arg[(*i)->name] = (*i)->value;
5403         }
5404         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5405         lm.release();
5406
5407         LuaScriptsChanged (); /* EMIT SIGNAL */
5408         set_dirty();
5409 }
5410
5411 void
5412 Session::unregister_lua_function (const std::string& name)
5413 {
5414         Glib::Threads::Mutex::Lock lm (lua_lock);
5415         (*_lua_del)(name); // throws luabridge::LuaException
5416         lua.collect_garbage ();
5417         lm.release();
5418
5419         LuaScriptsChanged (); /* EMIT SIGNAL */
5420         set_dirty();
5421 }
5422
5423 std::vector<std::string>
5424 Session::registered_lua_functions ()
5425 {
5426         Glib::Threads::Mutex::Lock lm (lua_lock);
5427         std::vector<std::string> rv;
5428
5429         try {
5430                 luabridge::LuaRef list ((*_lua_list)());
5431                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5432                         if (!i.key ().isString ()) { assert(0); continue; }
5433                         rv.push_back (i.key ().cast<std::string> ());
5434                 }
5435         } catch (luabridge::LuaException const& e) { }
5436         return rv;
5437 }
5438
5439 #ifndef NDEBUG
5440 static void _lua_print (std::string s) {
5441         std::cout << "SessionLua: " << s << "\n";
5442 }
5443 #endif
5444
5445 void
5446 Session::try_run_lua (pframes_t nframes)
5447 {
5448         if (_n_lua_scripts == 0) return;
5449         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5450         if (tm.locked ()) {
5451                 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5452                 lua.collect_garbage_step ();
5453         }
5454 }
5455
5456 void
5457 Session::setup_lua ()
5458 {
5459 #ifndef NDEBUG
5460         lua.Print.connect (&_lua_print);
5461 #endif
5462         lua.tweak_rt_gc ();
5463         lua.do_command (
5464                         "function ArdourSession ()"
5465                         "  local self = { scripts = {}, instances = {} }"
5466                         ""
5467                         "  local remove = function (n)"
5468                         "   self.scripts[n] = nil"
5469                         "   self.instances[n] = nil"
5470                         "   Session:scripts_changed()" // call back
5471                         "  end"
5472                         ""
5473                         "  local addinternal = function (n, f, a)"
5474                         "   assert(type(n) == 'string', 'function-name must be string')"
5475                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5476                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5477                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5478                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5479                         "   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"
5480                         "   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 }"
5481                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5482                         "   Session:scripts_changed()" // call back
5483                         "  end"
5484                         ""
5485                         "  local add = function (n, b, a)"
5486                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5487                         "   load (b)()" // assigns f
5488                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5489                         "   addinternal (n, load(f), a)"
5490                         "  end"
5491                         ""
5492                         "  local run = function (...)"
5493                         "   for n, s in pairs (self.instances) do"
5494                         "     local status, err = pcall (s, ...)"
5495                         "     if not status then"
5496                         "       print ('fn \"'.. n .. '\": ', err)"
5497                         "       remove (n)"
5498                         "      end"
5499                         "   end"
5500                         "   collectgarbage()"
5501                         "  end"
5502                         ""
5503                         "  local cleanup = function ()"
5504                         "   self.scripts = nil"
5505                         "   self.instances = nil"
5506                         "  end"
5507                         ""
5508                         "  local list = function ()"
5509                         "   local rv = {}"
5510                         "   for n, _ in pairs (self.scripts) do"
5511                         "     rv[n] = true"
5512                         "   end"
5513                         "   return rv"
5514                         "  end"
5515                         ""
5516                         "  local function basic_serialize (o)"
5517                         "    if type(o) == \"number\" then"
5518                         "     return tostring(o)"
5519                         "    else"
5520                         "     return string.format(\"%q\", o)"
5521                         "    end"
5522                         "  end"
5523                         ""
5524                         "  local function serialize (name, value)"
5525                         "   local rv = name .. ' = '"
5526                         "   collectgarbage()"
5527                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5528                         "    return rv .. basic_serialize(value) .. ' '"
5529                         "   elseif type(value) == \"table\" then"
5530                         "    rv = rv .. '{} '"
5531                         "    for k,v in pairs(value) do"
5532                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5533                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5534                         "     collectgarbage()" // string concatenation allocates a new string :(
5535                         "    end"
5536                         "    return rv;"
5537                         "   elseif type(value) == \"function\" then"
5538                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5539                         "   else"
5540                         "    error('cannot save a ' .. type(value))"
5541                         "   end"
5542                         "  end"
5543                         ""
5544                         ""
5545                         "  local save = function ()"
5546                         "   return (serialize('scripts', self.scripts))"
5547                         "  end"
5548                         ""
5549                         "  local restore = function (state)"
5550                         "   self.scripts = {}"
5551                         "   load (state)()"
5552                         "   for n, s in pairs (scripts) do"
5553                         "    addinternal (n, load(s['f']), s['a'])"
5554                         "   end"
5555                         "  end"
5556                         ""
5557                         " return { run = run, add = add, remove = remove,"
5558                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5559                         " end"
5560                         " "
5561                         " sess = ArdourSession ()"
5562                         " ArdourSession = nil"
5563                         " "
5564                         "function ardour () end"
5565                         );
5566
5567         lua_State* L = lua.getState();
5568
5569         try {
5570                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5571                 lua.do_command ("sess = nil"); // hide it.
5572                 lua.do_command ("collectgarbage()");
5573
5574                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5575                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5576                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5577                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5578                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5579                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5580                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5581         } catch (luabridge::LuaException const& e) {
5582                 fatal << string_compose (_("programming error: %1"),
5583                                 X_("Failed to setup Lua interpreter"))
5584                         << endmsg;
5585                 abort(); /*NOTREACHED*/
5586         }
5587
5588         LuaBindings::stddef (L);
5589         LuaBindings::common (L);
5590         LuaBindings::dsp (L);
5591         luabridge::push <Session *> (L, this);
5592         lua_setglobal (L, "Session");
5593 }
5594
5595 void
5596 Session::scripts_changed ()
5597 {
5598         assert (!lua_lock.trylock()); // must hold lua_lock
5599
5600         try {
5601                 luabridge::LuaRef list ((*_lua_list)());
5602                 int cnt = 0;
5603                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5604                         if (!i.key ().isString ()) { assert(0); continue; }
5605                         ++cnt;
5606                 }
5607                 _n_lua_scripts = cnt;
5608         } catch (luabridge::LuaException const& e) {
5609                 fatal << string_compose (_("programming error: %1"),
5610                                 X_("Indexing Lua Session Scripts failed."))
5611                         << endmsg;
5612                 abort(); /*NOTREACHED*/
5613         }
5614 }
5615
5616 void
5617 Session::non_realtime_set_audition ()
5618 {
5619         assert (pending_audition_region);
5620         auditioner->audition_region (pending_audition_region);
5621         pending_audition_region.reset ();
5622         AuditionActive (true); /* EMIT SIGNAL */
5623 }
5624
5625 void
5626 Session::audition_region (boost::shared_ptr<Region> r)
5627 {
5628         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5629         ev->region = r;
5630         queue_event (ev);
5631 }
5632
5633 void
5634 Session::cancel_audition ()
5635 {
5636         if (!auditioner) {
5637                 return;
5638         }
5639         if (auditioner->auditioning()) {
5640                 auditioner->cancel_audition ();
5641                 AuditionActive (false); /* EMIT SIGNAL */
5642         }
5643 }
5644
5645 bool
5646 Session::is_auditioning () const
5647 {
5648         /* can be called before we have an auditioner object */
5649         if (auditioner) {
5650                 return auditioner->auditioning();
5651         } else {
5652                 return false;
5653         }
5654 }
5655
5656 void
5657 Session::graph_reordered ()
5658 {
5659         /* don't do this stuff if we are setting up connections
5660            from a set_state() call or creating new tracks. Ditto for deletion.
5661         */
5662
5663         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5664                 return;
5665         }
5666
5667         /* every track/bus asked for this to be handled but it was deferred because
5668            we were connecting. do it now.
5669         */
5670
5671         request_input_change_handling ();
5672
5673         resort_routes ();
5674
5675         /* force all diskstreams to update their capture offset values to
5676            reflect any changes in latencies within the graph.
5677         */
5678
5679         boost::shared_ptr<RouteList> rl = routes.reader ();
5680         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5681                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5682                 if (tr) {
5683                         tr->set_capture_offset ();
5684                 }
5685         }
5686 }
5687
5688 /** @return Number of frames that there is disk space available to write,
5689  *  if known.
5690  */
5691 boost::optional<framecnt_t>
5692 Session::available_capture_duration ()
5693 {
5694         Glib::Threads::Mutex::Lock lm (space_lock);
5695
5696         if (_total_free_4k_blocks_uncertain) {
5697                 return boost::optional<framecnt_t> ();
5698         }
5699
5700         float sample_bytes_on_disk = 4.0; // keep gcc happy
5701
5702         switch (config.get_native_file_data_format()) {
5703         case FormatFloat:
5704                 sample_bytes_on_disk = 4.0;
5705                 break;
5706
5707         case FormatInt24:
5708                 sample_bytes_on_disk = 3.0;
5709                 break;
5710
5711         case FormatInt16:
5712                 sample_bytes_on_disk = 2.0;
5713                 break;
5714
5715         default:
5716                 /* impossible, but keep some gcc versions happy */
5717                 fatal << string_compose (_("programming error: %1"),
5718                                          X_("illegal native file data format"))
5719                       << endmsg;
5720                 abort(); /*NOTREACHED*/
5721         }
5722
5723         double scale = 4096.0 / sample_bytes_on_disk;
5724
5725         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5726                 return max_framecnt;
5727         }
5728
5729         return (framecnt_t) floor (_total_free_4k_blocks * scale);
5730 }
5731
5732 void
5733 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5734 {
5735         {
5736                 RCUWriter<BundleList> writer (_bundles);
5737                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5738                 b->push_back (bundle);
5739         }
5740
5741         if (emit_signal) {
5742                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5743         }
5744
5745         set_dirty();
5746 }
5747
5748 void
5749 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5750 {
5751         bool removed = false;
5752
5753         {
5754                 RCUWriter<BundleList> writer (_bundles);
5755                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5756                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5757
5758                 if (i != b->end()) {
5759                         b->erase (i);
5760                         removed = true;
5761                 }
5762         }
5763
5764         if (removed) {
5765                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5766         }
5767
5768         set_dirty();
5769 }
5770
5771 boost::shared_ptr<Bundle>
5772 Session::bundle_by_name (string name) const
5773 {
5774         boost::shared_ptr<BundleList> b = _bundles.reader ();
5775
5776         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5777                 if ((*i)->name() == name) {
5778                         return* i;
5779                 }
5780         }
5781
5782         return boost::shared_ptr<Bundle> ();
5783 }
5784
5785 void
5786 Session::tempo_map_changed (const PropertyChange&)
5787 {
5788         clear_clicks ();
5789
5790         playlists->update_after_tempo_map_change ();
5791
5792         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5793
5794         set_dirty ();
5795 }
5796
5797 void
5798 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5799 {
5800         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5801                 (*i)->recompute_frames_from_beat ();
5802         }
5803 }
5804
5805 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5806  * the given count with the current block size.
5807  */
5808 void
5809 Session::ensure_buffers (ChanCount howmany)
5810 {
5811         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5812 }
5813
5814 void
5815 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5816 {
5817         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5818                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5819         }
5820 }
5821
5822 uint32_t
5823 Session::next_insert_id ()
5824 {
5825         /* this doesn't really loop forever. just think about it */
5826
5827         while (true) {
5828                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5829                         if (!insert_bitset[n]) {
5830                                 insert_bitset[n] = true;
5831                                 return n;
5832
5833                         }
5834                 }
5835
5836                 /* none available, so resize and try again */
5837
5838                 insert_bitset.resize (insert_bitset.size() + 16, false);
5839         }
5840 }
5841
5842 uint32_t
5843 Session::next_send_id ()
5844 {
5845         /* this doesn't really loop forever. just think about it */
5846
5847         while (true) {
5848                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5849                         if (!send_bitset[n]) {
5850                                 send_bitset[n] = true;
5851                                 return n;
5852
5853                         }
5854                 }
5855
5856                 /* none available, so resize and try again */
5857
5858                 send_bitset.resize (send_bitset.size() + 16, false);
5859         }
5860 }
5861
5862 uint32_t
5863 Session::next_aux_send_id ()
5864 {
5865         /* this doesn't really loop forever. just think about it */
5866
5867         while (true) {
5868                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5869                         if (!aux_send_bitset[n]) {
5870                                 aux_send_bitset[n] = true;
5871                                 return n;
5872
5873                         }
5874                 }
5875
5876                 /* none available, so resize and try again */
5877
5878                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5879         }
5880 }
5881
5882 uint32_t
5883 Session::next_return_id ()
5884 {
5885         /* this doesn't really loop forever. just think about it */
5886
5887         while (true) {
5888                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5889                         if (!return_bitset[n]) {
5890                                 return_bitset[n] = true;
5891                                 return n;
5892
5893                         }
5894                 }
5895
5896                 /* none available, so resize and try again */
5897
5898                 return_bitset.resize (return_bitset.size() + 16, false);
5899         }
5900 }
5901
5902 void
5903 Session::mark_send_id (uint32_t id)
5904 {
5905         if (id >= send_bitset.size()) {
5906                 send_bitset.resize (id+16, false);
5907         }
5908         if (send_bitset[id]) {
5909                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5910         }
5911         send_bitset[id] = true;
5912 }
5913
5914 void
5915 Session::mark_aux_send_id (uint32_t id)
5916 {
5917         if (id >= aux_send_bitset.size()) {
5918                 aux_send_bitset.resize (id+16, false);
5919         }
5920         if (aux_send_bitset[id]) {
5921                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5922         }
5923         aux_send_bitset[id] = true;
5924 }
5925
5926 void
5927 Session::mark_return_id (uint32_t id)
5928 {
5929         if (id >= return_bitset.size()) {
5930                 return_bitset.resize (id+16, false);
5931         }
5932         if (return_bitset[id]) {
5933                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5934         }
5935         return_bitset[id] = true;
5936 }
5937
5938 void
5939 Session::mark_insert_id (uint32_t id)
5940 {
5941         if (id >= insert_bitset.size()) {
5942                 insert_bitset.resize (id+16, false);
5943         }
5944         if (insert_bitset[id]) {
5945                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5946         }
5947         insert_bitset[id] = true;
5948 }
5949
5950 void
5951 Session::unmark_send_id (uint32_t id)
5952 {
5953         if (id < send_bitset.size()) {
5954                 send_bitset[id] = false;
5955         }
5956 }
5957
5958 void
5959 Session::unmark_aux_send_id (uint32_t id)
5960 {
5961         if (id < aux_send_bitset.size()) {
5962                 aux_send_bitset[id] = false;
5963         }
5964 }
5965
5966 void
5967 Session::unmark_return_id (uint32_t id)
5968 {
5969         if (_state_of_the_state & Deletion) { return; }
5970         if (id < return_bitset.size()) {
5971                 return_bitset[id] = false;
5972         }
5973 }
5974
5975 void
5976 Session::unmark_insert_id (uint32_t id)
5977 {
5978         if (id < insert_bitset.size()) {
5979                 insert_bitset[id] = false;
5980         }
5981 }
5982
5983 void
5984 Session::reset_native_file_format ()
5985 {
5986         boost::shared_ptr<RouteList> rl = routes.reader ();
5987
5988         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5989                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5990                 if (tr) {
5991                         /* don't save state as we do this, there's no point
5992                          */
5993                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5994                         tr->reset_write_sources (false);
5995                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5996                 }
5997         }
5998 }
5999
6000 bool
6001 Session::route_name_unique (string n) const
6002 {
6003         boost::shared_ptr<RouteList> r = routes.reader ();
6004
6005         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6006                 if ((*i)->name() == n) {
6007                         return false;
6008                 }
6009         }
6010
6011         return true;
6012 }
6013
6014 bool
6015 Session::route_name_internal (string n) const
6016 {
6017         if (auditioner && auditioner->name() == n) {
6018                 return true;
6019         }
6020
6021         if (_click_io && _click_io->name() == n) {
6022                 return true;
6023         }
6024
6025         return false;
6026 }
6027
6028 int
6029 Session::freeze_all (InterThreadInfo& itt)
6030 {
6031         boost::shared_ptr<RouteList> r = routes.reader ();
6032
6033         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6034
6035                 boost::shared_ptr<Track> t;
6036
6037                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
6038                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
6039                            of every track.
6040                         */
6041                         t->freeze_me (itt);
6042                 }
6043         }
6044
6045         return 0;
6046 }
6047
6048 boost::shared_ptr<Region>
6049 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
6050                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
6051                           InterThreadInfo& itt,
6052                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
6053                           bool for_export, bool for_freeze)
6054 {
6055         boost::shared_ptr<Region> result;
6056         boost::shared_ptr<Playlist> playlist;
6057         boost::shared_ptr<Source> source;
6058         ChanCount diskstream_channels (track.n_channels());
6059         framepos_t position;
6060         framecnt_t this_chunk;
6061         framepos_t to_do;
6062         framepos_t latency_skip;
6063         BufferSet buffers;
6064         framepos_t len = end - start;
6065         bool need_block_size_reset = false;
6066         ChanCount const max_proc = track.max_processor_streams ();
6067         string legal_playlist_name;
6068         string possible_path;
6069
6070         if (end <= start) {
6071                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
6072                                          end, start) << endmsg;
6073                 return result;
6074         }
6075
6076         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
6077                         include_endpoint, for_export, for_freeze);
6078
6079         if (diskstream_channels.n(track.data_type()) < 1) {
6080                 error << _("Cannot write a range with no data.") << endmsg;
6081                 return result;
6082         }
6083
6084         // block all process callback handling
6085
6086         block_processing ();
6087
6088         {
6089                 // synchronize with AudioEngine::process_callback()
6090                 // make sure processing is not currently running
6091                 // and processing_blocked() is honored before
6092                 // acquiring thread buffers
6093                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6094         }
6095
6096         _bounce_processing_active = true;
6097
6098         /* call tree *MUST* hold route_lock */
6099
6100         if ((playlist = track.playlist()) == 0) {
6101                 goto out;
6102         }
6103
6104         legal_playlist_name = legalize_for_path (playlist->name());
6105
6106         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
6107
6108                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6109                 string path = ((track.data_type() == DataType::AUDIO)
6110                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6111                                : new_midi_source_path (legal_playlist_name));
6112
6113                 if (path.empty()) {
6114                         goto out;
6115                 }
6116
6117                 try {
6118                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
6119                 }
6120
6121                 catch (failed_constructor& err) {
6122                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6123                         goto out;
6124                 }
6125
6126                 srcs.push_back (source);
6127         }
6128
6129         /* tell redirects that care that we are about to use a much larger
6130          * blocksize. this will flush all plugins too, so that they are ready
6131          * to be used for this process.
6132          */
6133
6134         need_block_size_reset = true;
6135         track.set_block_size (bounce_chunk_size);
6136         _engine.main_thread()->get_buffers ();
6137
6138         position = start;
6139         to_do = len;
6140         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6141
6142         /* create a set of reasonably-sized buffers */
6143         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6144                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6145         }
6146         buffers.set_count (max_proc);
6147
6148         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6149                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6150                 boost::shared_ptr<MidiSource> ms;
6151                 if (afs) {
6152                         afs->prepare_for_peakfile_writes ();
6153                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6154                         Source::Lock lock(ms->mutex());
6155                         ms->mark_streaming_write_started(lock);
6156                 }
6157         }
6158
6159         while (to_do && !itt.cancel) {
6160
6161                 this_chunk = min (to_do, bounce_chunk_size);
6162
6163                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6164                         goto out;
6165                 }
6166
6167                 start += this_chunk;
6168                 to_do -= this_chunk;
6169                 itt.progress = (float) (1.0 - ((double) to_do / len));
6170
6171                 if (latency_skip >= bounce_chunk_size) {
6172                         latency_skip -= bounce_chunk_size;
6173                         continue;
6174                 }
6175
6176                 const framecnt_t current_chunk = this_chunk - latency_skip;
6177
6178                 uint32_t n = 0;
6179                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6180                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6181                         boost::shared_ptr<MidiSource> ms;
6182
6183                         if (afs) {
6184                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6185                                         goto out;
6186                                 }
6187                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6188                                 Source::Lock lock(ms->mutex());
6189
6190                                 const MidiBuffer& buf = buffers.get_midi(0);
6191                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6192                                         Evoral::Event<framepos_t> ev = *i;
6193                                         ev.set_time(ev.time() - position);
6194                                         ms->append_event_frames(lock, ev, ms->timeline_position());
6195                                 }
6196                         }
6197                 }
6198                 latency_skip = 0;
6199         }
6200
6201         /* post-roll, pick up delayed processor output */
6202         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6203
6204         while (latency_skip && !itt.cancel) {
6205                 this_chunk = min (latency_skip, bounce_chunk_size);
6206                 latency_skip -= this_chunk;
6207
6208                 buffers.silence (this_chunk, 0);
6209                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6210
6211                 uint32_t n = 0;
6212                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6213                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6214
6215                         if (afs) {
6216                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6217                                         goto out;
6218                                 }
6219                         }
6220                 }
6221         }
6222
6223         if (!itt.cancel) {
6224
6225                 time_t now;
6226                 struct tm* xnow;
6227                 time (&now);
6228                 xnow = localtime (&now);
6229
6230                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6231                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6232                         boost::shared_ptr<MidiSource> ms;
6233
6234                         if (afs) {
6235                                 afs->update_header (position, *xnow, now);
6236                                 afs->flush_header ();
6237                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6238                                 Source::Lock lock(ms->mutex());
6239                                 ms->mark_streaming_write_completed(lock);
6240                         }
6241                 }
6242
6243                 /* construct a region to represent the bounced material */
6244
6245                 PropertyList plist;
6246
6247                 plist.add (Properties::start, 0);
6248                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6249                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6250
6251                 result = RegionFactory::create (srcs, plist);
6252
6253         }
6254
6255   out:
6256         if (!result) {
6257                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6258                         (*src)->mark_for_remove ();
6259                         (*src)->drop_references ();
6260                 }
6261
6262         } else {
6263                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6264                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6265
6266                         if (afs)
6267                                 afs->done_with_peakfile_writes ();
6268                 }
6269         }
6270
6271         _bounce_processing_active = false;
6272
6273         if (need_block_size_reset) {
6274                 _engine.main_thread()->drop_buffers ();
6275                 track.set_block_size (get_block_size());
6276         }
6277
6278         unblock_processing ();
6279
6280         return result;
6281 }
6282
6283 gain_t*
6284 Session::gain_automation_buffer() const
6285 {
6286         return ProcessThread::gain_automation_buffer ();
6287 }
6288
6289 gain_t*
6290 Session::trim_automation_buffer() const
6291 {
6292         return ProcessThread::trim_automation_buffer ();
6293 }
6294
6295 gain_t*
6296 Session::send_gain_automation_buffer() const
6297 {
6298         return ProcessThread::send_gain_automation_buffer ();
6299 }
6300
6301 gain_t*
6302 Session::scratch_automation_buffer() const
6303 {
6304         return ProcessThread::scratch_automation_buffer ();
6305 }
6306
6307 pan_t**
6308 Session::pan_automation_buffer() const
6309 {
6310         return ProcessThread::pan_automation_buffer ();
6311 }
6312
6313 BufferSet&
6314 Session::get_silent_buffers (ChanCount count)
6315 {
6316         return ProcessThread::get_silent_buffers (count);
6317 }
6318
6319 BufferSet&
6320 Session::get_scratch_buffers (ChanCount count, bool silence)
6321 {
6322         return ProcessThread::get_scratch_buffers (count, silence);
6323 }
6324
6325 BufferSet&
6326 Session::get_noinplace_buffers (ChanCount count)
6327 {
6328         return ProcessThread::get_noinplace_buffers (count);
6329 }
6330
6331 BufferSet&
6332 Session::get_route_buffers (ChanCount count, bool silence)
6333 {
6334         return ProcessThread::get_route_buffers (count, silence);
6335 }
6336
6337
6338 BufferSet&
6339 Session::get_mix_buffers (ChanCount count)
6340 {
6341         return ProcessThread::get_mix_buffers (count);
6342 }
6343
6344 uint32_t
6345 Session::ntracks () const
6346 {
6347         uint32_t n = 0;
6348         boost::shared_ptr<RouteList> r = routes.reader ();
6349
6350         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6351                 if (boost::dynamic_pointer_cast<Track> (*i)) {
6352                         ++n;
6353                 }
6354         }
6355
6356         return n;
6357 }
6358
6359 uint32_t
6360 Session::nbusses () const
6361 {
6362         uint32_t n = 0;
6363         boost::shared_ptr<RouteList> r = routes.reader ();
6364
6365         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6366                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6367                         ++n;
6368                 }
6369         }
6370
6371         return n;
6372 }
6373
6374 uint32_t
6375 Session::nstripables (bool with_auditioner_and_monitor) const
6376 {
6377         uint32_t rv = routes.reader()->size ();
6378         rv += _vca_manager->vcas ().size ();
6379
6380         if (with_auditioner_and_monitor) {
6381                 return rv;
6382         }
6383
6384         if (auditioner) {
6385                 assert (rv > 0);
6386                 --rv;
6387         }
6388         if (_monitor_out) {
6389                 assert (rv > 0);
6390                 --rv;
6391         }
6392         return rv;
6393 }
6394
6395 void
6396 Session::add_automation_list(AutomationList *al)
6397 {
6398         automation_lists[al->id()] = al;
6399 }
6400
6401 /** @return true if there is at least one record-enabled track, otherwise false */
6402 bool
6403 Session::have_rec_enabled_track () const
6404 {
6405         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6406 }
6407
6408 bool
6409 Session::have_rec_disabled_track () const
6410 {
6411     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6412 }
6413
6414 /** Update the state of our rec-enabled tracks flag */
6415 void
6416 Session::update_route_record_state ()
6417 {
6418         boost::shared_ptr<RouteList> rl = routes.reader ();
6419         RouteList::iterator i = rl->begin();
6420         while (i != rl->end ()) {
6421
6422                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6423                                     if (tr && tr->rec_enable_control()->get_value()) {
6424                         break;
6425                 }
6426
6427                 ++i;
6428         }
6429
6430         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6431
6432         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6433
6434         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6435                 RecordStateChanged (); /* EMIT SIGNAL */
6436         }
6437
6438         for (i = rl->begin(); i != rl->end (); ++i) {
6439                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6440                 if (tr && !tr->rec_enable_control()->get_value()) {
6441                         break;
6442                 }
6443         }
6444
6445         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6446
6447         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6448
6449         if (record_status() == Recording && record_arm_state_changed ) {
6450                 RecordArmStateChanged ();
6451         }
6452
6453 }
6454
6455 void
6456 Session::listen_position_changed ()
6457 {
6458         ProcessorChangeBlocker pcb (this);
6459         boost::shared_ptr<RouteList> r = routes.reader ();
6460         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6461                 (*i)->listen_position_changed ();
6462         }
6463 }
6464
6465 void
6466 Session::solo_control_mode_changed ()
6467 {
6468         if (soloing() || listening()) {
6469                 if (loading()) {
6470                         /* We can't use ::clear_all_solo_state() here because during
6471                            session loading at program startup, that will queue a call
6472                            to rt_clear_all_solo_state() that will not execute until
6473                            AFTER solo states have been established (thus throwing away
6474                            the session's saved solo state). So just explicitly turn
6475                            them all off.
6476                         */
6477                         set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6478                 } else {
6479                         clear_all_solo_state (get_routes());
6480                 }
6481         }
6482 }
6483
6484 /** Called when a property of one of our route groups changes */
6485 void
6486 Session::route_group_property_changed (RouteGroup* rg)
6487 {
6488         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6489 }
6490
6491 /** Called when a route is added to one of our route groups */
6492 void
6493 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6494 {
6495         RouteAddedToRouteGroup (rg, r);
6496 }
6497
6498 /** Called when a route is removed from one of our route groups */
6499 void
6500 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6501 {
6502         update_route_record_state ();
6503         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6504
6505         if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6506                 remove_route_group (*rg);
6507         }
6508 }
6509
6510 boost::shared_ptr<RouteList>
6511 Session::get_tracks () const
6512 {
6513         boost::shared_ptr<RouteList> rl = routes.reader ();
6514         boost::shared_ptr<RouteList> tl (new RouteList);
6515
6516         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6517                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6518                         if (!(*r)->is_auditioner()) {
6519                                 tl->push_back (*r);
6520                         }
6521                 }
6522         }
6523         return tl;
6524 }
6525
6526 boost::shared_ptr<RouteList>
6527 Session::get_routes_with_regions_at (framepos_t const p) const
6528 {
6529         boost::shared_ptr<RouteList> r = routes.reader ();
6530         boost::shared_ptr<RouteList> rl (new RouteList);
6531
6532         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6533                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6534                 if (!tr) {
6535                         continue;
6536                 }
6537
6538                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6539                 if (!pl) {
6540                         continue;
6541                 }
6542
6543                 if (pl->has_region_at (p)) {
6544                         rl->push_back (*i);
6545                 }
6546         }
6547
6548         return rl;
6549 }
6550
6551 void
6552 Session::goto_end ()
6553 {
6554         if (_session_range_location) {
6555                 request_locate (_session_range_location->end(), false);
6556         } else {
6557                 request_locate (0, false);
6558         }
6559 }
6560
6561 void
6562 Session::goto_start (bool and_roll)
6563 {
6564         if (_session_range_location) {
6565                 request_locate (_session_range_location->start(), and_roll);
6566         } else {
6567                 request_locate (0, and_roll);
6568         }
6569 }
6570
6571 framepos_t
6572 Session::current_start_frame () const
6573 {
6574         return _session_range_location ? _session_range_location->start() : 0;
6575 }
6576
6577 framepos_t
6578 Session::current_end_frame () const
6579 {
6580         return _session_range_location ? _session_range_location->end() : 0;
6581 }
6582
6583 void
6584 Session::set_session_range_location (framepos_t start, framepos_t end)
6585 {
6586         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6587         _locations->add (_session_range_location);
6588 }
6589
6590 void
6591 Session::step_edit_status_change (bool yn)
6592 {
6593         bool send = false;
6594
6595         bool val = false;
6596         if (yn) {
6597                 send = (_step_editors == 0);
6598                 val = true;
6599
6600                 _step_editors++;
6601         } else {
6602                 send = (_step_editors == 1);
6603                 val = false;
6604
6605                 if (_step_editors > 0) {
6606                         _step_editors--;
6607                 }
6608         }
6609
6610         if (send) {
6611                 StepEditStatusChange (val);
6612         }
6613 }
6614
6615
6616 void
6617 Session::start_time_changed (framepos_t old)
6618 {
6619         /* Update the auto loop range to match the session range
6620            (unless the auto loop range has been changed by the user)
6621         */
6622
6623         Location* s = _locations->session_range_location ();
6624         if (s == 0) {
6625                 return;
6626         }
6627
6628         Location* l = _locations->auto_loop_location ();
6629
6630         if (l && l->start() == old) {
6631                 l->set_start (s->start(), true);
6632         }
6633         set_dirty ();
6634 }
6635
6636 void
6637 Session::end_time_changed (framepos_t old)
6638 {
6639         /* Update the auto loop range to match the session range
6640            (unless the auto loop range has been changed by the user)
6641         */
6642
6643         Location* s = _locations->session_range_location ();
6644         if (s == 0) {
6645                 return;
6646         }
6647
6648         Location* l = _locations->auto_loop_location ();
6649
6650         if (l && l->end() == old) {
6651                 l->set_end (s->end(), true);
6652         }
6653         set_dirty ();
6654 }
6655
6656 std::vector<std::string>
6657 Session::source_search_path (DataType type) const
6658 {
6659         Searchpath sp;
6660
6661         if (session_dirs.size() == 1) {
6662                 switch (type) {
6663                 case DataType::AUDIO:
6664                         sp.push_back (_session_dir->sound_path());
6665                         break;
6666                 case DataType::MIDI:
6667                         sp.push_back (_session_dir->midi_path());
6668                         break;
6669                 }
6670         } else {
6671                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6672                         SessionDirectory sdir (i->path);
6673                         switch (type) {
6674                         case DataType::AUDIO:
6675                                 sp.push_back (sdir.sound_path());
6676                                 break;
6677                         case DataType::MIDI:
6678                                 sp.push_back (sdir.midi_path());
6679                                 break;
6680                         }
6681                 }
6682         }
6683
6684         if (type == DataType::AUDIO) {
6685                 const string sound_path_2X = _session_dir->sound_path_2X();
6686                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6687                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6688                                 sp.push_back (sound_path_2X);
6689                         }
6690                 }
6691         }
6692
6693         // now check the explicit (possibly user-specified) search path
6694
6695         switch (type) {
6696         case DataType::AUDIO:
6697                 sp += Searchpath(config.get_audio_search_path ());
6698                 break;
6699         case DataType::MIDI:
6700                 sp += Searchpath(config.get_midi_search_path ());
6701                 break;
6702         }
6703
6704         return sp;
6705 }
6706
6707 void
6708 Session::ensure_search_path_includes (const string& path, DataType type)
6709 {
6710         Searchpath sp;
6711
6712         if (path == ".") {
6713                 return;
6714         }
6715
6716         switch (type) {
6717         case DataType::AUDIO:
6718                 sp += Searchpath(config.get_audio_search_path ());
6719                 break;
6720         case DataType::MIDI:
6721                 sp += Searchpath (config.get_midi_search_path ());
6722                 break;
6723         }
6724
6725         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6726                 /* No need to add this new directory if it has the same inode as
6727                    an existing one; checking inode rather than name prevents duplicated
6728                    directories when we are using symlinks.
6729
6730                    On Windows, I think we could just do if (*i == path) here.
6731                 */
6732                 if (PBD::equivalent_paths (*i, path)) {
6733                         return;
6734                 }
6735         }
6736
6737         sp += path;
6738
6739         switch (type) {
6740         case DataType::AUDIO:
6741                 config.set_audio_search_path (sp.to_string());
6742                 break;
6743         case DataType::MIDI:
6744                 config.set_midi_search_path (sp.to_string());
6745                 break;
6746         }
6747 }
6748
6749 void
6750 Session::remove_dir_from_search_path (const string& dir, DataType type)
6751 {
6752         Searchpath sp;
6753
6754         switch (type) {
6755         case DataType::AUDIO:
6756                 sp = Searchpath(config.get_audio_search_path ());
6757                 break;
6758         case DataType::MIDI:
6759                 sp = Searchpath (config.get_midi_search_path ());
6760                 break;
6761         }
6762
6763         sp -= dir;
6764
6765         switch (type) {
6766         case DataType::AUDIO:
6767                 config.set_audio_search_path (sp.to_string());
6768                 break;
6769         case DataType::MIDI:
6770                 config.set_midi_search_path (sp.to_string());
6771                 break;
6772         }
6773
6774 }
6775
6776 boost::shared_ptr<Speakers>
6777 Session::get_speakers()
6778 {
6779         return _speakers;
6780 }
6781
6782 list<string>
6783 Session::unknown_processors () const
6784 {
6785         list<string> p;
6786
6787         boost::shared_ptr<RouteList> r = routes.reader ();
6788         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6789                 list<string> t = (*i)->unknown_processors ();
6790                 copy (t.begin(), t.end(), back_inserter (p));
6791         }
6792
6793         p.sort ();
6794         p.unique ();
6795
6796         return p;
6797 }
6798
6799 void
6800 Session::update_latency (bool playback)
6801 {
6802
6803         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6804
6805         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6806                 return;
6807         }
6808
6809         boost::shared_ptr<RouteList> r = routes.reader ();
6810         framecnt_t max_latency = 0;
6811
6812         if (playback) {
6813                 /* reverse the list so that we work backwards from the last route to run to the first */
6814                 RouteList* rl = routes.reader().get();
6815                 r.reset (new RouteList (*rl));
6816                 reverse (r->begin(), r->end());
6817         }
6818
6819         /* compute actual latency values for the given direction and store them all in per-port
6820            structures. this will also publish the same values (to JACK) so that computation of latency
6821            for routes can consistently use public latency values.
6822         */
6823
6824         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6825                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6826         }
6827
6828         /* because we latency compensate playback, our published playback latencies should
6829            be the same for all output ports - all material played back by ardour has
6830            the same latency, whether its caused by plugins or by latency compensation. since
6831            these may differ from the values computed above, reset all playback port latencies
6832            to the same value.
6833         */
6834
6835         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6836
6837         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6838                 (*i)->set_public_port_latencies (max_latency, playback);
6839         }
6840
6841         if (playback) {
6842
6843                 post_playback_latency ();
6844
6845         } else {
6846
6847                 post_capture_latency ();
6848         }
6849
6850         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6851 }
6852
6853 void
6854 Session::post_playback_latency ()
6855 {
6856         set_worst_playback_latency ();
6857
6858         boost::shared_ptr<RouteList> r = routes.reader ();
6859
6860         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6861                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6862                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6863                 }
6864         }
6865
6866         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6867                 (*i)->set_latency_compensation (_worst_track_latency);
6868         }
6869 }
6870
6871 void
6872 Session::post_capture_latency ()
6873 {
6874         set_worst_capture_latency ();
6875
6876         /* reflect any changes in capture latencies into capture offsets
6877          */
6878
6879         boost::shared_ptr<RouteList> rl = routes.reader();
6880         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6881                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6882                 if (tr) {
6883                         tr->set_capture_offset ();
6884                 }
6885         }
6886 }
6887
6888 void
6889 Session::initialize_latencies ()
6890 {
6891         {
6892                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6893                 update_latency (false);
6894                 update_latency (true);
6895         }
6896
6897         set_worst_io_latencies ();
6898 }
6899
6900 void
6901 Session::set_worst_io_latencies ()
6902 {
6903         set_worst_playback_latency ();
6904         set_worst_capture_latency ();
6905 }
6906
6907 void
6908 Session::set_worst_playback_latency ()
6909 {
6910         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6911                 return;
6912         }
6913
6914         _worst_output_latency = 0;
6915
6916         if (!_engine.connected()) {
6917                 return;
6918         }
6919
6920         boost::shared_ptr<RouteList> r = routes.reader ();
6921
6922         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6923                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6924         }
6925
6926         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6927 }
6928
6929 void
6930 Session::set_worst_capture_latency ()
6931 {
6932         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6933                 return;
6934         }
6935
6936         _worst_input_latency = 0;
6937
6938         if (!_engine.connected()) {
6939                 return;
6940         }
6941
6942         boost::shared_ptr<RouteList> r = routes.reader ();
6943
6944         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6945                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6946         }
6947
6948         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6949 }
6950
6951 void
6952 Session::update_latency_compensation (bool force_whole_graph)
6953 {
6954         bool some_track_latency_changed = false;
6955
6956         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6957                 return;
6958         }
6959
6960         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6961
6962         _worst_track_latency = 0;
6963
6964         boost::shared_ptr<RouteList> r = routes.reader ();
6965
6966         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6967                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6968                         framecnt_t tl;
6969                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6970                                 some_track_latency_changed = true;
6971                         }
6972                         _worst_track_latency = max (tl, _worst_track_latency);
6973                 }
6974         }
6975
6976         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6977                                                      (some_track_latency_changed ? "yes" : "no")));
6978
6979         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6980
6981         if (some_track_latency_changed || force_whole_graph)  {
6982                 _engine.update_latencies ();
6983         }
6984
6985
6986         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6987                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6988                 if (!tr) {
6989                         continue;
6990                 }
6991                 tr->set_capture_offset ();
6992         }
6993 }
6994
6995 char
6996 Session::session_name_is_legal (const string& path)
6997 {
6998         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6999
7000         for (int i = 0; illegal_chars[i]; ++i) {
7001                 if (path.find (illegal_chars[i]) != string::npos) {
7002                         return illegal_chars[i];
7003                 }
7004         }
7005
7006         return 0;
7007 }
7008
7009 void
7010 Session::notify_presentation_info_change ()
7011 {
7012         if (deletion_in_progress()) {
7013                 return;
7014         }
7015
7016         reassign_track_numbers();
7017
7018 #ifdef USE_TRACKS_CODE_FEATURES
7019         /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
7020          * if track order has been changed by user
7021          */
7022         reconnect_existing_routes(true, true);
7023 #endif
7024
7025 }
7026
7027 bool
7028 Session::operation_in_progress (GQuark op) const
7029 {
7030         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
7031 }
7032
7033 boost::shared_ptr<Port>
7034 Session::ltc_input_port () const
7035 {
7036         return _ltc_input->nth (0);
7037 }
7038
7039 boost::shared_ptr<Port>
7040 Session::ltc_output_port () const
7041 {
7042         return _ltc_output->nth (0);
7043 }
7044
7045 void
7046 Session::reconnect_ltc_input ()
7047 {
7048         if (_ltc_input) {
7049
7050                 string src = Config->get_ltc_source_port();
7051
7052                 _ltc_input->disconnect (this);
7053
7054                 if (src != _("None") && !src.empty())  {
7055                         _ltc_input->nth (0)->connect (src);
7056                 }
7057
7058                 if ( ARDOUR::Profile->get_trx () ) {
7059                         // Tracks need this signal to update timecode_source_dropdown
7060                         MtcOrLtcInputPortChanged (); //emit signal
7061                 }
7062         }
7063 }
7064
7065 void
7066 Session::reconnect_ltc_output ()
7067 {
7068         if (_ltc_output) {
7069
7070                 string src = Config->get_ltc_output_port();
7071
7072                 _ltc_output->disconnect (this);
7073
7074                 if (src != _("None") && !src.empty())  {
7075                         _ltc_output->nth (0)->connect (src);
7076                 }
7077         }
7078 }
7079
7080 void
7081 Session::set_range_selection (framepos_t start, framepos_t end)
7082 {
7083         _range_selection = Evoral::Range<framepos_t> (start, end);
7084 #ifdef USE_TRACKS_CODE_FEATURES
7085         follow_playhead_priority ();
7086 #endif
7087 }
7088
7089 void
7090 Session::set_object_selection (framepos_t start, framepos_t end)
7091 {
7092         _object_selection = Evoral::Range<framepos_t> (start, end);
7093 #ifdef USE_TRACKS_CODE_FEATURES
7094         follow_playhead_priority ();
7095 #endif
7096 }
7097
7098 void
7099 Session::clear_range_selection ()
7100 {
7101         _range_selection = Evoral::Range<framepos_t> (-1,-1);
7102 #ifdef USE_TRACKS_CODE_FEATURES
7103         follow_playhead_priority ();
7104 #endif
7105 }
7106
7107 void
7108 Session::clear_object_selection ()
7109 {
7110         _object_selection = Evoral::Range<framepos_t> (-1,-1);
7111 #ifdef USE_TRACKS_CODE_FEATURES
7112         follow_playhead_priority ();
7113 #endif
7114 }
7115
7116 void
7117 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
7118                 const ChanCount& input_start,
7119                 const ChanCount& output_start,
7120                 const ChanCount& input_offset,
7121                 const ChanCount& output_offset)
7122 {
7123         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7124         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7125                                 input_start, output_start,
7126                                 input_offset, output_offset));
7127
7128         auto_connect_thread_wakeup ();
7129 }
7130
7131 void
7132 Session::auto_connect_thread_wakeup ()
7133 {
7134         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7135                 pthread_cond_signal (&_auto_connect_cond);
7136                 pthread_mutex_unlock (&_auto_connect_mutex);
7137         }
7138 }
7139
7140 void
7141 Session::queue_latency_recompute ()
7142 {
7143         g_atomic_int_inc (&_latency_recompute_pending);
7144         auto_connect_thread_wakeup ();
7145 }
7146
7147 void
7148 Session::auto_connect (const AutoConnectRequest& ar)
7149 {
7150         boost::shared_ptr<Route> route = ar.route.lock();
7151
7152         if (!route) { return; }
7153
7154         if (!IO::connecting_legal) {
7155                 return;
7156         }
7157
7158         /* If both inputs and outputs are auto-connected to physical ports,
7159          * use the max of input and output offsets to ensure auto-connected
7160          * port numbers always match up (e.g. the first audio input and the
7161          * first audio output of the route will have the same physical
7162          * port number).  Otherwise just use the lowest input or output
7163          * offset possible.
7164          */
7165
7166         const bool in_out_physical =
7167                 (Config->get_input_auto_connect() & AutoConnectPhysical)
7168                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7169                 && ar.connect_inputs;
7170
7171         const ChanCount in_offset = in_out_physical
7172                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7173                 : ar.input_offset;
7174
7175         const ChanCount out_offset = in_out_physical
7176                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7177                 : ar.output_offset;
7178
7179         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7180                 vector<string> physinputs;
7181                 vector<string> physoutputs;
7182
7183
7184                 /* for connecting track inputs we only want MIDI ports marked
7185                  * for "music".
7186                  */
7187
7188                 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7189
7190                 if (!physinputs.empty() && ar.connect_inputs) {
7191                         uint32_t nphysical_in = physinputs.size();
7192
7193                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7194                                 string port;
7195
7196                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7197                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7198                                 }
7199
7200                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7201                                         break;
7202                                 }
7203                         }
7204                 }
7205
7206                 if (!physoutputs.empty()) {
7207                         uint32_t nphysical_out = physoutputs.size();
7208                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7209                                 string port;
7210
7211                                 /* Waves Tracks:
7212                                  * do not create new connections if we reached the limit of physical outputs
7213                                  * in Multi Out mode
7214                                  */
7215                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7216                                                 ARDOUR::Profile->get_trx () &&
7217                                                 ar.output_offset.get(*t) == nphysical_out ) {
7218                                         break;
7219                                 }
7220
7221                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7222                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7223                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7224                                         /* master bus is audio only */
7225                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7226                                                 port = _master_out->input()->ports().port(*t,
7227                                                                 i % _master_out->input()->n_ports().get(*t))->name();
7228                                         }
7229                                 }
7230
7231                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7232                                         break;
7233                                 }
7234                         }
7235                 }
7236         }
7237 }
7238
7239 void
7240 Session::auto_connect_thread_start ()
7241 {
7242         if (g_atomic_int_get (&_ac_thread_active)) {
7243                 return;
7244         }
7245
7246         while (!_auto_connect_queue.empty ()) {
7247                 _auto_connect_queue.pop ();
7248         }
7249
7250         g_atomic_int_set (&_ac_thread_active, 1);
7251         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7252                 g_atomic_int_set (&_ac_thread_active, 0);
7253         }
7254 }
7255
7256 void
7257 Session::auto_connect_thread_terminate ()
7258 {
7259         if (!g_atomic_int_get (&_ac_thread_active)) {
7260                 return;
7261         }
7262
7263         {
7264                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7265                 while (!_auto_connect_queue.empty ()) {
7266                         _auto_connect_queue.pop ();
7267                 }
7268         }
7269
7270         /* cannot use auto_connect_thread_wakeup() because that is allowed to
7271          * fail to wakeup the thread.
7272          */
7273
7274         pthread_mutex_lock (&_auto_connect_mutex);
7275         g_atomic_int_set (&_ac_thread_active, 0);
7276         pthread_cond_signal (&_auto_connect_cond);
7277         pthread_mutex_unlock (&_auto_connect_mutex);
7278
7279         void *status;
7280         pthread_join (_auto_connect_thread, &status);
7281 }
7282
7283 void *
7284 Session::auto_connect_thread (void *arg)
7285 {
7286         Session *s = static_cast<Session *>(arg);
7287         s->auto_connect_thread_run ();
7288         pthread_exit (0);
7289         return 0;
7290 }
7291
7292 void
7293 Session::auto_connect_thread_run ()
7294 {
7295         pthread_set_name (X_("autoconnect"));
7296         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7297         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7298         pthread_mutex_lock (&_auto_connect_mutex);
7299         while (g_atomic_int_get (&_ac_thread_active)) {
7300
7301                 if (!_auto_connect_queue.empty ()) {
7302                         // Why would we need the process lock ??
7303                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7304                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7305                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
7306                         //   We have control over those, but what does jack do?
7307                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7308
7309                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7310                         while (!_auto_connect_queue.empty ()) {
7311                                 const AutoConnectRequest ar (_auto_connect_queue.front());
7312                                 _auto_connect_queue.pop ();
7313                                 lx.release ();
7314                                 auto_connect (ar);
7315                                 lx.acquire ();
7316                         }
7317                 }
7318
7319                 if (!actively_recording ()) { // might not be needed,
7320                         /* this is only used for updating plugin latencies, the
7321                          * graph does not change. so it's safe in general.
7322                          * BUT..
7323                          * .. update_latency_compensation () entails set_capture_offset()
7324                          * which calls Diskstream::set_capture_offset () which
7325                          * modifies the capture offset... which can be a proplem
7326                          * in "prepare_to_stop"
7327                          */
7328                         while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7329                                 update_latency_compensation ();
7330                         }
7331                 }
7332
7333                 {
7334                         // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7335                         // jack1 cannot cope with removing ports while processing
7336                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7337                         AudioEngine::instance()->clear_pending_port_deletions ();
7338                 }
7339
7340                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7341         }
7342         pthread_mutex_unlock (&_auto_connect_mutex);
7343 }
7344
7345 void
7346 Session::cancel_all_solo ()
7347 {
7348         StripableList sl;
7349
7350         get_stripables (sl);
7351
7352         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7353         clear_all_solo_state (routes.reader());
7354 }