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