libs/ardour/session.cc

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