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                 if (!rt_context) {
2093                         remove_pending_capture_state ();
2094                 }
2095         }
2096 }
2097
2098 void
2099 Session::step_back_from_record ()
2100 {
2101         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
2102
2103                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2104                         set_track_monitor_input_status (false);
2105                 }
2106
2107                 RecordStateChanged (); /* emit signal */
2108         }
2109 }
2110
2111 void
2112 Session::maybe_enable_record (bool rt_context)
2113 {
2114         if (_step_editors > 0) {
2115                 return;
2116         }
2117
2118         g_atomic_int_set (&_record_status, Enabled);
2119
2120         /* This function is currently called from somewhere other than an RT thread.
2121          * (except maybe lua scripts, which can use rt_context = true)
2122          * This save_state() call therefore doesn't impact anything.  Doing it here
2123          * means that we save pending state of which sources the next record will use,
2124          * which gives us some chance of recovering from a crash during the record.
2125          */
2126
2127         if (!rt_context) {
2128                 save_state ("", true);
2129         }
2130
2131         if (_transport_speed) {
2132                 if (!config.get_punch_in()) {
2133                         enable_record ();
2134                 }
2135         } else {
2136                 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
2137                 RecordStateChanged (); /* EMIT SIGNAL */
2138         }
2139
2140         set_dirty();
2141 }
2142
2143 samplepos_t
2144 Session::audible_sample (bool* latent_locate) const
2145 {
2146         if (latent_locate) {
2147                 *latent_locate = false;
2148         }
2149
2150         samplepos_t ret;
2151
2152         if (synced_to_engine()) {
2153                 /* Note: this is basically just sync-to-JACK */
2154                 ret = _engine.transport_sample();
2155         } else {
2156                 ret = _transport_sample;
2157         }
2158
2159         assert (ret >= 0);
2160
2161         if (!transport_rolling()) {
2162                 return ret;
2163         }
2164
2165 #if 0 // TODO looping
2166         if (_transport_speed > 0.0f) {
2167                 if (play_loop && have_looped) {
2168                         /* the play-position wrapped at the loop-point
2169                          * ardour is already playing the beginning of the loop,
2170                          * but due to playback latency, the "audible frame"
2171                          * is still at the end of the loop.
2172                          */
2173                         Location *location = _locations->auto_loop_location();
2174                         sampleoffset_t lo = location->start() - ret;
2175                         if (lo > 0) {
2176                                 ret = location->end () - lo;
2177                                 if (latent_locate) {
2178                                         *latent_locate = true;
2179                                 }
2180                         }
2181                 }
2182         } else if (_transport_speed < 0.0f) {
2183                 /* XXX wot? no backward looping? */
2184         }
2185 #endif
2186
2187         return std::max ((samplepos_t)0, ret);
2188 }
2189
2190 samplecnt_t
2191 Session::preroll_samples (samplepos_t pos) const
2192 {
2193         const float pr = Config->get_preroll_seconds();
2194         if (pos >= 0 && pr < 0) {
2195                 const Tempo& tempo = _tempo_map->tempo_at_sample (pos);
2196                 const Meter& meter = _tempo_map->meter_at_sample (pos);
2197                 return meter.samples_per_bar (tempo, sample_rate()) * -pr;
2198         }
2199         if (pr < 0) {
2200                 return 0;
2201         }
2202         return pr * sample_rate();
2203 }
2204
2205 void
2206 Session::set_sample_rate (samplecnt_t frames_per_second)
2207 {
2208         /** \fn void Session::set_sample_size(samplecnt_t)
2209                 the AudioEngine object that calls this guarantees
2210                 that it will not be called while we are also in
2211                 ::process(). Its fine to do things that block
2212                 here.
2213         */
2214
2215         if (_base_sample_rate == 0) {
2216                 _base_sample_rate = frames_per_second;
2217         }
2218         else if (_base_sample_rate != frames_per_second && frames_per_second != _nominal_sample_rate) {
2219                 NotifyAboutSampleRateMismatch (_base_sample_rate, frames_per_second);
2220         }
2221         _nominal_sample_rate = frames_per_second;
2222
2223         sync_time_vars();
2224
2225         clear_clicks ();
2226         reset_write_sources (false);
2227
2228         // XXX we need some equivalent to this, somehow
2229         // SndFileSource::setup_standard_crossfades (frames_per_second);
2230
2231         set_dirty();
2232
2233         /* XXX need to reset/reinstantiate all LADSPA plugins */
2234 }
2235
2236 void
2237 Session::set_block_size (pframes_t nframes)
2238 {
2239         /* the AudioEngine guarantees
2240            that it will not be called while we are also in
2241            ::process(). It is therefore fine to do things that block
2242            here.
2243         */
2244
2245         {
2246                 current_block_size = nframes;
2247
2248                 ensure_buffers ();
2249
2250                 boost::shared_ptr<RouteList> r = routes.reader ();
2251
2252                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2253                         (*i)->set_block_size (nframes);
2254                 }
2255
2256                 boost::shared_ptr<RouteList> rl = routes.reader ();
2257                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2258                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2259                         if (tr) {
2260                                 tr->set_block_size (nframes);
2261                         }
2262                 }
2263
2264                 set_worst_io_latencies ();
2265         }
2266 }
2267
2268
2269 static void
2270 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase, bool sends_only)
2271 {
2272         boost::shared_ptr<Route> r2;
2273
2274         if (r1->feeds (rbase) && rbase->feeds (r1)) {
2275                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2276                 return;
2277         }
2278
2279         /* make a copy of the existing list of routes that feed r1 */
2280
2281         Route::FedBy existing (r1->fed_by());
2282
2283         /* for each route that feeds r1, recurse, marking it as feeding
2284            rbase as well.
2285         */
2286
2287         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2288                 if (!(r2 = i->r.lock ())) {
2289                         /* (*i) went away, ignore it */
2290                         continue;
2291                 }
2292
2293                 /* r2 is a route that feeds r1 which somehow feeds base. mark
2294                    base as being fed by r2
2295                 */
2296
2297                 rbase->add_fed_by (r2, i->sends_only || sends_only);
2298
2299                 if (r2 != rbase) {
2300
2301                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2302                            stop here.
2303                         */
2304
2305                         if (r1->feeds (r2) && r2->feeds (r1)) {
2306                                 continue;
2307                         }
2308
2309                         /* now recurse, so that we can mark base as being fed by
2310                            all routes that feed r2
2311                         */
2312
2313                         trace_terminal (r2, rbase, i->sends_only || sends_only);
2314                 }
2315
2316         }
2317 }
2318
2319 void
2320 Session::resort_routes ()
2321 {
2322         /* don't do anything here with signals emitted
2323            by Routes during initial setup or while we
2324            are being destroyed.
2325         */
2326
2327         if (inital_connect_or_deletion_in_progress ()) {
2328                 return;
2329         }
2330
2331         if (_route_deletion_in_progress) {
2332                 return;
2333         }
2334
2335         {
2336                 RCUWriter<RouteList> writer (routes);
2337                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2338                 resort_routes_using (r);
2339                 /* writer goes out of scope and forces update */
2340         }
2341
2342 #ifndef NDEBUG
2343         if (DEBUG_ENABLED(DEBUG::Graph)) {
2344                 boost::shared_ptr<RouteList> rl = routes.reader ();
2345                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2346                         DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2347
2348                         const Route::FedBy& fb ((*i)->fed_by());
2349
2350                         for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2351                                 boost::shared_ptr<Route> sf = f->r.lock();
2352                                 if (sf) {
2353                                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2354                                 }
2355                         }
2356                 }
2357         }
2358 #endif
2359
2360 }
2361
2362 /** This is called whenever we need to rebuild the graph of how we will process
2363  *  routes.
2364  *  @param r List of routes, in any order.
2365  */
2366
2367 void
2368 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2369 {
2370         /* We are going to build a directed graph of our routes;
2371            this is where the edges of that graph are put.
2372         */
2373
2374         GraphEdges edges;
2375
2376         /* Go through all routes doing two things:
2377          *
2378          * 1. Collect the edges of the route graph.  Each of these edges
2379          *    is a pair of routes, one of which directly feeds the other
2380          *    either by a JACK connection or by an internal send.
2381          *
2382          * 2. Begin the process of making routes aware of which other
2383          *    routes directly or indirectly feed them.  This information
2384          *    is used by the solo code.
2385          */
2386
2387         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2388
2389                 /* Clear out the route's list of direct or indirect feeds */
2390                 (*i)->clear_fed_by ();
2391
2392                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2393
2394                         bool via_sends_only;
2395
2396                         /* See if this *j feeds *i according to the current state of the JACK
2397                            connections and internal sends.
2398                         */
2399                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2400                                 /* add the edge to the graph (part #1) */
2401                                 edges.add (*j, *i, via_sends_only);
2402                                 /* tell the route (for part #2) */
2403                                 (*i)->add_fed_by (*j, via_sends_only);
2404                         }
2405                 }
2406         }
2407
2408         /* Attempt a topological sort of the route graph */
2409         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2410
2411         if (sorted_routes) {
2412                 /* We got a satisfactory topological sort, so there is no feedback;
2413                    use this new graph.
2414
2415                    Note: the process graph rechain does not require a
2416                    topologically-sorted list, but hey ho.
2417                 */
2418                 if (_process_graph) {
2419                         _process_graph->rechain (sorted_routes, edges);
2420                 }
2421
2422                 _current_route_graph = edges;
2423
2424                 /* Complete the building of the routes' lists of what directly
2425                    or indirectly feeds them.
2426                 */
2427                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2428                         trace_terminal (*i, *i, false);
2429                 }
2430
2431                 *r = *sorted_routes;
2432
2433 #ifndef NDEBUG
2434                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2435                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2436                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2437                 }
2438 #endif
2439
2440                 SuccessfulGraphSort (); /* EMIT SIGNAL */
2441
2442         } else {
2443                 /* The topological sort failed, so we have a problem.  Tell everyone
2444                    and stick to the old graph; this will continue to be processed, so
2445                    until the feedback is fixed, what is played back will not quite
2446                    reflect what is actually connected.  Note also that we do not
2447                    do trace_terminal here, as it would fail due to an endless recursion,
2448                    so the solo code will think that everything is still connected
2449                    as it was before.
2450                 */
2451
2452                 FeedbackDetected (); /* EMIT SIGNAL */
2453         }
2454
2455 }
2456
2457 /** Find a route name starting with \a base, maybe followed by the
2458  *  lowest \a id.  \a id will always be added if \a definitely_add_number
2459  *  is true on entry; otherwise it will only be added if required
2460  *  to make the name unique.
2461  *
2462  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2463  *  The available route name with the lowest ID will be used, and \a id
2464  *  will be set to the ID.
2465  *
2466  *  \return false if a route name could not be found, and \a track_name
2467  *  and \a id do not reflect a free route name.
2468  */
2469 bool
2470 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2471 {
2472         /* the base may conflict with ports that do not belong to existing
2473            routes, but hidden objects like the click track. So check port names
2474            before anything else.
2475         */
2476
2477         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2478                 if (base == reserved->first) {
2479                         /* Check if this reserved name already exists, and if
2480                            so, disallow it without a numeric suffix.
2481                         */
2482                         if (!reserved->second || route_by_name (reserved->first)) {
2483                                 definitely_add_number = true;
2484                                 if (id < 1) {
2485                                         id = 1;
2486                                 }
2487                         }
2488                         break;
2489                 }
2490         }
2491
2492         /* if we have "base 1" already, it doesn't make sense to add "base"
2493          * if "base 1" has been deleted, adding "base" is no worse than "base 1"
2494          */
2495         if (!definitely_add_number && route_by_name (base) == 0 && (route_by_name (string_compose("%1 1", base)) == 0)) {
2496                 /* just use the base */
2497                 name = base;
2498                 return true;
2499         }
2500
2501         do {
2502                 name = string_compose ("%1 %2", base, id);
2503
2504                 if (route_by_name (name) == 0) {
2505                         return true;
2506                 }
2507
2508                 ++id;
2509
2510         } while (id < (UINT_MAX-1));
2511
2512         return false;
2513 }
2514
2515 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2516 void
2517 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2518 {
2519         in  = ChanCount::ZERO;
2520         out = ChanCount::ZERO;
2521
2522         boost::shared_ptr<RouteList> r = routes.reader ();
2523
2524         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2525                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2526                 if (!tr) {
2527                         continue;
2528                 }
2529                 assert (!tr->is_auditioner()); // XXX remove me
2530                 in  += tr->n_inputs();
2531                 out += tr->n_outputs();
2532         }
2533 }
2534
2535 string
2536 Session::default_track_name_pattern (DataType t)
2537 {
2538         switch (t) {
2539         case DataType::AUDIO:
2540                 if (Profile->get_trx()) {
2541                         return _("Track ");
2542                 } else {
2543                         return _("Audio ");
2544                 }
2545                 break;
2546
2547         case DataType::MIDI:
2548                 return _("MIDI ");
2549         }
2550
2551         return "";
2552 }
2553
2554 /** Caller must not hold process lock
2555  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
2556  *  @param instrument plugin info for the instrument to insert pre-fader, if any
2557  */
2558 list<boost::shared_ptr<MidiTrack> >
2559 Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool strict_io,
2560                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2561                          RouteGroup* route_group, uint32_t how_many,
2562                          string name_template, PresentationInfo::order_t order,
2563                          TrackMode mode)
2564 {
2565         string track_name;
2566         uint32_t track_id = 0;
2567         string port;
2568         RouteList new_routes;
2569         list<boost::shared_ptr<MidiTrack> > ret;
2570
2571         const string name_pattern = default_track_name_pattern (DataType::MIDI);
2572         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2573
2574         while (how_many) {
2575                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2576                         error << "cannot find name for new midi track" << endmsg;
2577                         goto failed;
2578                 }
2579
2580                 boost::shared_ptr<MidiTrack> track;
2581
2582                 try {
2583                         track.reset (new MidiTrack (*this, track_name, mode));
2584
2585                         if (track->init ()) {
2586                                 goto failed;
2587                         }
2588
2589                         if (strict_io) {
2590                                 track->set_strict_io (true);
2591                         }
2592
2593                         BOOST_MARK_TRACK (track);
2594
2595                         {
2596                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2597                                 if (track->input()->ensure_io (input, false, this)) {
2598                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2599                                         goto failed;
2600                                 }
2601
2602                                 if (track->output()->ensure_io (output, false, this)) {
2603                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2604                                         goto failed;
2605                                 }
2606                         }
2607
2608                         if (route_group) {
2609                                 route_group->add (track);
2610                         }
2611
2612                         new_routes.push_back (track);
2613                         ret.push_back (track);
2614                 }
2615
2616                 catch (failed_constructor &err) {
2617                         error << _("Session: could not create new midi track.") << endmsg;
2618                         goto failed;
2619                 }
2620
2621                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2622
2623                         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;
2624                         goto failed;
2625                 }
2626
2627                 --how_many;
2628         }
2629
2630         failed:
2631         if (!new_routes.empty()) {
2632                 StateProtector sp (this);
2633                 if (Profile->get_trx()) {
2634                         add_routes (new_routes, false, false, false, order);
2635                 } else {
2636                         add_routes (new_routes, true, true, false, order);
2637                 }
2638
2639                 if (instrument) {
2640                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2641                                 PluginPtr plugin = instrument->load (*this);
2642                                 if (!plugin) {
2643                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2644                                         continue;
2645                                 }
2646                                 if (pset) {
2647                                         plugin->load_preset (*pset);
2648                                 }
2649                                 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2650                                 if (strict_io) {
2651                                         pi->set_strict_io (true);
2652                                 }
2653
2654                                 (*r)->add_processor (pi, PreFader);
2655
2656                                 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2657                                         (*r)->move_instrument_down (false);
2658                                 }
2659                         }
2660                 }
2661         }
2662
2663         return ret;
2664 }
2665
2666 RouteList
2667 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, bool strict_io,
2668                          boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2669                          PresentationInfo::Flag flag, PresentationInfo::order_t order)
2670 {
2671         string bus_name;
2672         uint32_t bus_id = 0;
2673         string port;
2674         RouteList ret;
2675
2676         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2677
2678         while (how_many) {
2679                 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2680                         error << "cannot find name for new midi bus" << endmsg;
2681                         goto failure;
2682                 }
2683
2684                 try {
2685                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2686
2687                         if (bus->init ()) {
2688                                 goto failure;
2689                         }
2690
2691                         if (strict_io) {
2692                                 bus->set_strict_io (true);
2693                         }
2694
2695                         BOOST_MARK_ROUTE(bus);
2696
2697                         {
2698                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2699
2700                                 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2701                                         error << _("cannot configure new midi bus input") << endmsg;
2702                                         goto failure;
2703                                 }
2704
2705
2706                                 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2707                                         error << _("cannot configure new midi bus output") << endmsg;
2708                                         goto failure;
2709                                 }
2710                         }
2711
2712                         if (route_group) {
2713                                 route_group->add (bus);
2714                         }
2715
2716                         bus->add_internal_return ();
2717                         ret.push_back (bus);
2718                 }
2719
2720                 catch (failed_constructor &err) {
2721                         error << _("Session: could not create new audio route.") << endmsg;
2722                         goto failure;
2723                 }
2724
2725                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2726                         error << pfe.what() << endmsg;
2727                         goto failure;
2728                 }
2729
2730
2731                 --how_many;
2732         }
2733
2734         failure:
2735         if (!ret.empty()) {
2736                 StateProtector sp (this);
2737                 add_routes (ret, false, false, false, order);
2738
2739                 if (instrument) {
2740                         for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2741                                 PluginPtr plugin = instrument->load (*this);
2742                                 if (!plugin) {
2743                                         warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2744                                         continue;
2745                                 }
2746                                 if (pset) {
2747                                         plugin->load_preset (*pset);
2748                                 }
2749                                 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2750                                 if (strict_io) {
2751                                         pi->set_strict_io (true);
2752                                 }
2753
2754                                 (*r)->add_processor (pi, PreFader);
2755
2756                                 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2757                                         (*r)->move_instrument_down (false);
2758                                 }
2759                         }
2760                 }
2761         }
2762
2763         return ret;
2764
2765 }
2766
2767
2768 void
2769 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2770 {
2771         boost::shared_ptr<Route> midi_track (wmt.lock());
2772
2773         if (!midi_track) {
2774                 return;
2775         }
2776
2777         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2778
2779                 if (change.after.n_audio() <= change.before.n_audio()) {
2780                         return;
2781                 }
2782
2783                 /* new audio ports: make sure the audio goes somewhere useful,
2784                  * unless the user has no-auto-connect selected.
2785                  *
2786                  * The existing ChanCounts don't matter for this call as they are only
2787                  * to do with matching input and output indices, and we are only changing
2788                  * outputs here.
2789                  */
2790                 auto_connect_route (midi_track, false, ChanCount(), change.before);
2791         }
2792 }
2793
2794 #ifdef USE_TRACKS_CODE_FEATURES
2795
2796 static bool
2797 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2798 {
2799         return route1->remote_control_id() < route2->remote_control_id();
2800 }
2801
2802 void
2803 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2804 {
2805         // it is not allowed to perform connection
2806         if (!IO::connecting_legal) {
2807                 return;
2808         }
2809
2810         // if we are deleting routes we will call this once at the end
2811         if (_route_deletion_in_progress) {
2812                 return;
2813         }
2814
2815         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2816
2817         if (withLock) {
2818                 lm.acquire ();
2819         }
2820
2821         // We need to disconnect the route's inputs and outputs first
2822         // basing on autoconnect configuration
2823         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2824         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2825
2826         ChanCount existing_inputs;
2827         ChanCount existing_outputs;
2828         count_existing_track_channels (existing_inputs, existing_outputs);
2829
2830         //ChanCount inputs = ChanCount::ZERO;
2831         //ChanCount outputs = ChanCount::ZERO;
2832
2833         RouteList existing_routes = *routes.reader ();
2834         existing_routes.sort (compare_routes_by_remote_id);
2835
2836         {
2837                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2838
2839                 vector<string> physinputs;
2840                 vector<string> physoutputs;
2841
2842                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2843                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2844
2845                 uint32_t input_n = 0;
2846                 uint32_t output_n = 0;
2847                 RouteList::iterator rIter = existing_routes.begin();
2848                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2849                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2850                 for (; rIter != existing_routes.end(); ++rIter) {
2851                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2852                                 continue;
2853                         }
2854
2855                         if (current_output_auto_connection == AutoConnectPhysical) {
2856                                 (*rIter)->amp()->deactivate();
2857                         } else if (current_output_auto_connection == AutoConnectMaster) {
2858                                 (*rIter)->amp()->activate();
2859                         }
2860
2861                         if (reconnectIputs) {
2862                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2863
2864                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2865
2866                                         if (current_input_auto_connection & AutoConnectPhysical) {
2867
2868                                                 if ( input_n == physinputs.size() ) {
2869                                                         break;
2870                                                 }
2871
2872                                                 string port = physinputs[input_n];
2873
2874                                                 if (port.empty() ) {
2875                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2876                                                 }
2877
2878                                                 //GZ: check this; could be heavy
2879                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2880                                                 ++input_n;
2881                                         }
2882                                 }
2883                         }
2884
2885                         if (reconnectOutputs) {
2886
2887                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2888                                 if (current_output_auto_connection & AutoConnectPhysical) {
2889
2890                                         //GZ: check this; could be heavy
2891                                         (*rIter)->output()->disconnect (this);
2892                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2893
2894                                         //GZ: check this; could be heavy
2895                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2896
2897                                 } else if (current_output_auto_connection & AutoConnectMaster){
2898
2899                                         if (!reconnect_master) {
2900                                                 continue;
2901                                         }
2902
2903                                         //GZ: check this; could be heavy
2904                                         (*rIter)->output()->disconnect (this);
2905
2906                                         if (_master_out) {
2907                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2908                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2909                                         } else {
2910                                                 error << error << "Master bus is not available" << endmsg;
2911                                                 break;
2912                                         }
2913                                 }
2914
2915                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2916                                         if (current_output_auto_connection & AutoConnectPhysical) {
2917
2918                                                 if ( output_n == physoutputs.size() ) {
2919                                                         break;
2920                                                 }
2921
2922                                                 string port = physoutputs[output_n];
2923
2924                                                 if (port.empty() ) {
2925                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2926                                                 }
2927
2928                                                 //GZ: check this; could be heavy
2929                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2930                                                 ++output_n;
2931
2932                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2933
2934                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2935                                                         break;
2936                                                 }
2937
2938                                                 // connect to master bus
2939                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2940
2941                                                 if (port.empty() ) {
2942                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2943                                                 }
2944
2945
2946                                                 //GZ: check this; could be heavy
2947                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2948
2949                                         }
2950                                 }
2951                         }
2952                 }
2953
2954                 _master_out->output()->disconnect (this);
2955                 auto_connect_master_bus ();
2956         }
2957
2958         graph_reordered ();
2959
2960         session_routes_reconnected (); /* EMIT SIGNAL */
2961 }
2962
2963 void
2964 Session::reconnect_midi_scene_ports(bool inputs)
2965 {
2966         if (inputs ) {
2967
2968                 boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2969                 if (scene_in_ptr) {
2970                         scene_in_ptr->disconnect_all ();
2971
2972                         std::vector<EngineStateController::MidiPortState> midi_port_states;
2973                         EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2974
2975                         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2976
2977                         for (; state_iter != midi_port_states.end(); ++state_iter) {
2978                                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2979                                         scene_in_ptr->connect (state_iter->name);
2980                                 }
2981                         }
2982                 }
2983
2984         } else {
2985
2986                 boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2987
2988                 if (scene_out_ptr ) {
2989                         scene_out_ptr->disconnect_all ();
2990
2991                         std::vector<EngineStateController::MidiPortState> midi_port_states;
2992                         EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2993
2994                         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2995
2996                         for (; state_iter != midi_port_states.end(); ++state_iter) {
2997                                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2998                                         scene_out_ptr->connect (state_iter->name);
2999                                 }
3000                         }
3001                 }
3002         }
3003 }
3004
3005 void
3006 Session::reconnect_mmc_ports(bool inputs)
3007 {
3008         if (inputs ) { // get all enabled midi input ports
3009
3010                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
3011                 if (mmc_in_ptr) {
3012                         mmc_in_ptr->disconnect_all ();
3013                         std::vector<std::string> enabled_midi_inputs;
3014                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
3015
3016                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
3017
3018                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
3019                                 mmc_in_ptr->connect (*port_iter);
3020                         }
3021
3022                 }
3023         } else { // get all enabled midi output ports
3024
3025                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
3026                 if (mmc_out_ptr ) {
3027                         mmc_out_ptr->disconnect_all ();
3028                         std::vector<std::string> enabled_midi_outputs;
3029                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
3030
3031                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
3032
3033                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
3034                                 mmc_out_ptr->connect (*port_iter);
3035                         }
3036                 }
3037         }
3038 }
3039
3040 #endif
3041
3042 bool
3043 Session::ensure_stripable_sort_order ()
3044 {
3045         StripableList sl;
3046         get_stripables (sl);
3047         sl.sort (Stripable::Sorter ());
3048
3049         bool change = false;
3050         PresentationInfo::order_t order = 0;
3051
3052         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3053                 boost::shared_ptr<Stripable> s (*si);
3054                 assert (!s->is_auditioner ()); // XXX remove me
3055                 if (s->is_monitor ()) {
3056                         continue;
3057                 }
3058                 if (order != s->presentation_info().order()) {
3059                         s->set_presentation_order (order);
3060                         change = true;
3061                 }
3062                 ++order;
3063         }
3064         return change;
3065 }
3066
3067 void
3068 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
3069 {
3070         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", first_new_order, how_many));
3071
3072         if (first_new_order == PresentationInfo::max_order) {
3073                 /* adding at end, no worries */
3074                 return;
3075         }
3076
3077         /* create a gap in the presentation info to accomodate @param how_many
3078          * new objects.
3079          */
3080         StripableList sl;
3081         get_stripables (sl);
3082
3083         for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3084                 boost::shared_ptr<Stripable> s (*si);
3085
3086                 if (s->presentation_info().special (false)) {
3087                         continue;
3088                 }
3089
3090                 if (!s->presentation_info().order_set()) {
3091                         continue;
3092                 }
3093
3094                 if (s->presentation_info().order () >= first_new_order) {
3095                         s->set_presentation_order (s->presentation_info().order () + how_many);
3096                 }
3097         }
3098 }
3099
3100 /** Caller must not hold process lock
3101  *  @param name_template string to use for the start of the name, or "" to use "Audio".
3102  */
3103 list< boost::shared_ptr<AudioTrack> >
3104 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
3105                           uint32_t how_many, string name_template, PresentationInfo::order_t order,
3106                           TrackMode mode)
3107 {
3108         string track_name;
3109         uint32_t track_id = 0;
3110         string port;
3111         RouteList new_routes;
3112         list<boost::shared_ptr<AudioTrack> > ret;
3113
3114         const string name_pattern = default_track_name_pattern (DataType::AUDIO);
3115         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
3116
3117         while (how_many) {
3118
3119                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
3120                         error << "cannot find name for new audio track" << endmsg;
3121                         goto failed;
3122                 }
3123
3124                 boost::shared_ptr<AudioTrack> track;
3125
3126                 try {
3127                         track.reset (new AudioTrack (*this, track_name, mode));
3128
3129                         if (track->init ()) {
3130                                 goto failed;
3131                         }
3132
3133                         if (Profile->get_mixbus ()) {
3134                                 track->set_strict_io (true);
3135                         }
3136
3137                         if (ARDOUR::Profile->get_trx ()) {
3138                                 // TRACKS considers it's not a USE CASE, it's
3139                                 // a piece of behavior of the session model:
3140                                 //
3141                                 // Gain for a newly created route depends on
3142                                 // the current output_auto_connect mode:
3143                                 //
3144                                 //  0 for Stereo Out mode
3145                                 //  0 Multi Out mode
3146                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3147                                         track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3148                                 }
3149                         }
3150
3151                         BOOST_MARK_TRACK (track);
3152
3153                         {
3154                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3155
3156                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3157                                         error << string_compose (
3158                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3159                                                 input_channels, output_channels)
3160                                               << endmsg;
3161                                         goto failed;
3162                                 }
3163
3164                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3165                                         error << string_compose (
3166                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
3167                                                 input_channels, output_channels)
3168                                               << endmsg;
3169                                         goto failed;
3170                                 }
3171                         }
3172
3173                         if (route_group) {
3174                                 route_group->add (track);
3175                         }
3176
3177                         new_routes.push_back (track);
3178                         ret.push_back (track);
3179                 }
3180
3181                 catch (failed_constructor &err) {
3182                         error << _("Session: could not create new audio track.") << endmsg;
3183                         goto failed;
3184                 }
3185
3186                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3187
3188                         error << pfe.what() << endmsg;
3189                         goto failed;
3190                 }
3191
3192                 --how_many;
3193         }
3194
3195         failed:
3196         if (!new_routes.empty()) {
3197                 StateProtector sp (this);
3198                 if (Profile->get_trx()) {
3199                         add_routes (new_routes, false, false, false, order);
3200                 } else {
3201                         add_routes (new_routes, true, true, false, order);
3202                 }
3203         }
3204
3205         return ret;
3206 }
3207
3208 /** Caller must not hold process lock.
3209  *  @param name_template string to use for the start of the name, or "" to use "Bus".
3210  */
3211 RouteList
3212 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3213                           PresentationInfo::Flag flags, PresentationInfo::order_t order)
3214 {
3215         string bus_name;
3216         uint32_t bus_id = 0;
3217         string port;
3218         RouteList ret;
3219
3220         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3221
3222         while (how_many) {
3223                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3224                         error << "cannot find name for new audio bus" << endmsg;
3225                         goto failure;
3226                 }
3227
3228                 try {
3229                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3230
3231                         if (bus->init ()) {
3232                                 goto failure;
3233                         }
3234
3235                         if (Profile->get_mixbus ()) {
3236                                 bus->set_strict_io (true);
3237                         }
3238
3239                         BOOST_MARK_ROUTE(bus);
3240
3241                         {
3242                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3243
3244                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3245                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3246                                                                  input_channels, output_channels)
3247                                               << endmsg;
3248                                         goto failure;
3249                                 }
3250
3251
3252                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3253                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3254                                                                  input_channels, output_channels)
3255                                               << endmsg;
3256                                         goto failure;
3257                                 }
3258                         }
3259
3260                         if (route_group) {
3261                                 route_group->add (bus);
3262                         }
3263
3264                         bus->add_internal_return ();
3265                         ret.push_back (bus);
3266                 }
3267
3268                 catch (failed_constructor &err) {
3269                         error << _("Session: could not create new audio route.") << endmsg;
3270                         goto failure;
3271                 }
3272
3273                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3274                         error << pfe.what() << endmsg;
3275                         goto failure;
3276                 }
3277
3278
3279                 --how_many;
3280         }
3281
3282         failure:
3283         if (!ret.empty()) {
3284                 StateProtector sp (this);
3285                 if (Profile->get_trx()) {
3286                         add_routes (ret, false, false, false, order);
3287                 } else if (flags == PresentationInfo::FoldbackBus) {
3288                         add_routes (ret, false, false, true, order); // no autoconnect
3289                 } else {
3290                         add_routes (ret, false, true, true, order); // autoconnect // outputs only
3291                 }
3292         }
3293
3294         return ret;
3295
3296 }
3297
3298 RouteList
3299 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3300                                   PlaylistDisposition pd)
3301 {
3302         XMLTree tree;
3303
3304         if (!tree.read (template_path.c_str())) {
3305                 return RouteList();
3306         }
3307
3308         return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3309 }
3310
3311 RouteList
3312 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3313 {
3314         RouteList ret;
3315         uint32_t number = 0;
3316         const uint32_t being_added = how_many;
3317         /* This will prevent the use of any existing XML-provided PBD::ID
3318            values by Stateful.
3319         */
3320         Stateful::ForceIDRegeneration force_ids;
3321         IO::disable_connecting ();
3322
3323         while (how_many) {
3324
3325                 /* We're going to modify the node contents a bit so take a
3326                  * copy. The node may be re-used when duplicating more than once.
3327                  */
3328
3329                 XMLNode node_copy (node);
3330                 std::vector<boost::shared_ptr<Playlist> > shared_playlists;
3331
3332                 try {
3333                         string name;
3334
3335                         if (!name_base.empty()) {
3336
3337                                 /* if we're adding more than one routes, force
3338                                  * all the names of the new routes to be
3339                                  * numbered, via the final parameter.
3340                                  */
3341
3342                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3343                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3344                                         /*NOTREACHED*/
3345                                 }
3346
3347                         } else {
3348
3349                                 string const route_name  = node_copy.property(X_("name"))->value ();
3350
3351                                 /* generate a new name by adding a number to the end of the template name */
3352                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3353                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3354                                         abort(); /*NOTREACHED*/
3355                                 }
3356                         }
3357
3358                         /* figure out the appropriate playlist setup. The track
3359                          * (if the Route we're creating is a track) will find
3360                          * playlists via ID.
3361                          */
3362
3363                         if (pd == CopyPlaylist) {
3364
3365                                 PBD::ID playlist_id;
3366
3367                                 if (node_copy.get_property (X_("audio-playlist"), playlist_id)) {
3368                                         boost::shared_ptr<Playlist> playlist = _playlists->by_id (playlist_id);
3369                                         playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3370                                         playlist->reset_shares ();
3371                                         node_copy.set_property (X_("audio-playlist"), playlist->id());
3372                                 }
3373
3374                                 if (node_copy.get_property (X_("midi-playlist"), playlist_id)) {
3375                                         boost::shared_ptr<Playlist> playlist = _playlists->by_id (playlist_id);
3376                                         playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3377                                         playlist->reset_shares ();
3378                                         node_copy.set_property (X_("midi-playlist"), playlist->id());
3379                                 }
3380
3381                         } else if (pd == SharePlaylist) {
3382                                 PBD::ID playlist_id;
3383
3384                                 if (node_copy.get_property (X_("audio-playlist"), playlist_id)) {
3385                                         boost::shared_ptr<Playlist> playlist = _playlists->by_id (playlist_id);
3386                                         shared_playlists.push_back (playlist);
3387                                 }
3388
3389                                 if (node_copy.get_property (X_("midi-playlist"), playlist_id)) {
3390                                         boost::shared_ptr<Playlist> playlist = _playlists->by_id (playlist_id);
3391                                         shared_playlists.push_back (playlist);
3392                                 }
3393
3394                         } else { /* NewPlaylist */
3395
3396                                 PBD::ID pid;
3397
3398                                 if (node_copy.get_property (X_("audio-playlist"), pid)) {
3399                                         boost::shared_ptr<Playlist> playlist = PlaylistFactory::create (DataType::AUDIO, *this, name, false);
3400                                         node_copy.set_property (X_("audio-playlist"), playlist->id());
3401                                 }
3402
3403                                 if (node_copy.get_property (X_("midi-playlist"), pid)) {
3404                                         boost::shared_ptr<Playlist> playlist = PlaylistFactory::create (DataType::MIDI, *this, name, false);
3405                                         node_copy.set_property (X_("midi-playlist"), playlist->id());
3406                                 }
3407                         }
3408
3409                         /* Fix up new name in the XML node */
3410
3411                         Route::set_name_in_state (node_copy, name);
3412
3413                         /* trim bitslots from listen sends so that new ones are used */
3414                         XMLNodeList children = node_copy.children ();
3415                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3416                                 if ((*i)->name() == X_("Processor")) {
3417                                         /* ForceIDRegeneration does not catch the following */
3418                                         XMLProperty const * role = (*i)->property (X_("role"));
3419                                         XMLProperty const * type = (*i)->property (X_("type"));
3420                                         if (role && role->value() == X_("Aux")) {
3421                                                 /* check if the target bus exists.
3422                                                  * we should not save aux-sends in templates.
3423                                                  */
3424                                                 XMLProperty const * target = (*i)->property (X_("target"));
3425                                                 if (!target) {
3426                                                         (*i)->set_property ("type", "dangling-aux-send");
3427                                                         continue;
3428                                                 }
3429                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3430                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3431                                                         (*i)->set_property ("type", "dangling-aux-send");
3432                                                         continue;
3433                                                 }
3434                                         }
3435                                         if (role && role->value() == X_("Listen")) {
3436                                                 (*i)->remove_property (X_("bitslot"));
3437                                         }
3438                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3439                                                 Delivery::Role xrole;
3440                                                 uint32_t bitslot = 0;
3441                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3442                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3443                                                 (*i)->remove_property (X_("bitslot"));
3444                                                 (*i)->remove_property (X_("name"));
3445                                                 (*i)->set_property ("bitslot", bitslot);
3446                                                 (*i)->set_property ("name", name);
3447                                                 XMLNodeList io_kids = (*i)->children ();
3448                                                 for (XMLNodeList::iterator j = io_kids.begin(); j != io_kids.end(); ++j) {
3449                                                         if ((*j)->name() != X_("IO")) {
3450                                                                 continue;
3451                                                         }
3452                                                         (*j)->remove_property (X_("name"));
3453                                                         (*j)->set_property ("name", name);
3454                                                 }
3455                                         }
3456                                         else if (type && type->value() == X_("intreturn")) {
3457                                                 (*i)->remove_property (X_("bitslot"));
3458                                                 (*i)->set_property ("ignore-bitslot", "1");
3459                                         }
3460                                         else if (type && type->value() == X_("return")) {
3461                                                 // Return::set_state() generates a new one
3462                                                 (*i)->remove_property (X_("bitslot"));
3463                                         }
3464                                         else if (type && type->value() == X_("port")) {
3465                                                 IOProcessor::prepare_for_reset (**i, name);
3466                                         }
3467                                 }
3468                         }
3469
3470                         /* new routes start off unsoloed to avoid issues related to
3471                            upstream / downstream buses.
3472                         */
3473                         node_copy.remove_node_and_delete (X_("Controllable"), X_("name"), X_("solo"));
3474
3475                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3476
3477                         if (route == 0) {
3478                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3479                                 goto out;
3480                         }
3481
3482                         /* Fix up sharing of playlists with the new Route/Track */
3483
3484                         for (vector<boost::shared_ptr<Playlist> >::iterator sp = shared_playlists.begin(); sp != shared_playlists.end(); ++sp) {
3485                                 (*sp)->share_with (route->id());
3486                         }
3487
3488                         if (boost::dynamic_pointer_cast<Track>(route)) {
3489                                 /* force input/output change signals so that the new diskstream
3490                                    picks up the configuration of the route. During session
3491                                    loading this normally happens in a different way.
3492                                 */
3493
3494                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3495
3496                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3497                                 change.after = route->input()->n_ports();
3498                                 route->input()->changed (change, this);
3499                                 change.after = route->output()->n_ports();
3500                                 route->output()->changed (change, this);
3501                         }
3502
3503                         ret.push_back (route);
3504                 }
3505
3506                 catch (failed_constructor &err) {
3507                         error << _("Session: could not create new route from template") << endmsg;
3508                         goto out;
3509                 }
3510
3511                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3512                         error << pfe.what() << endmsg;
3513                         goto out;
3514                 }
3515
3516                 catch (...) {
3517                         IO::enable_connecting ();
3518                         throw;
3519                 }
3520
3521                 --how_many;
3522         }
3523
3524         out:
3525         if (!ret.empty()) {
3526                 StateProtector sp (this);
3527                 if (Profile->get_trx()) {
3528                         add_routes (ret, false, false, false, insert_at);
3529                 } else {
3530                         add_routes (ret, true, true, false, insert_at);
3531                 }
3532         }
3533
3534         IO::enable_connecting ();
3535
3536         return ret;
3537 }
3538
3539 void
3540 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3541 {
3542         try {
3543                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3544                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3545
3546         } catch (...) {
3547                 error << _("Adding new tracks/busses failed") << endmsg;
3548         }
3549
3550         graph_reordered ();
3551
3552         update_latency (false);
3553         update_latency (true);
3554
3555         set_dirty();
3556
3557         if (save) {
3558                 save_state (_current_snapshot_name);
3559         }
3560
3561         update_route_record_state ();
3562
3563         RouteAdded (new_routes); /* EMIT SIGNAL */
3564 }
3565
3566 void
3567 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3568 {
3569         ChanCount existing_inputs;
3570         ChanCount existing_outputs;
3571         uint32_t n_routes;
3572         uint32_t added = 0;
3573
3574         count_existing_track_channels (existing_inputs, existing_outputs);
3575
3576         {
3577                 RCUWriter<RouteList> writer (routes);
3578                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3579                 n_routes = r->size();
3580                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3581
3582                 /* if there is no control out and we're not in the middle of loading,
3583                  * resort the graph here. if there is a control out, we will resort
3584                  * toward the end of this method. if we are in the middle of loading,
3585                  * we will resort when done.
3586                  */
3587
3588                 if (!_monitor_out && IO::connecting_legal) {
3589                         resort_routes_using (r);
3590                 }
3591         }
3592
3593         /* monitor is not part of the order */
3594         if (_monitor_out) {
3595                 assert (n_routes > 0);
3596                 --n_routes;
3597         }
3598
3599         {
3600                 PresentationInfo::ChangeSuspender cs;
3601                 ensure_route_presentation_info_gap (order, new_routes.size());
3602
3603                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3604
3605                         boost::weak_ptr<Route> wpr (*x);
3606                         boost::shared_ptr<Route> r (*x);
3607
3608                         r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3609                         r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3610                         r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3611
3612                         r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3613                         r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3614                         r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3615
3616                         if (r->is_master()) {
3617                                 _master_out = r;
3618                         }
3619
3620                         if (r->is_monitor()) {
3621                                 _monitor_out = r;
3622                         }
3623
3624                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3625                         if (tr) {
3626                                 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3627                                 track_playlist_changed (boost::weak_ptr<Track> (tr));
3628                                 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3629
3630                                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3631                                 if (mt) {
3632                                         mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3633                                         mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3634                                         mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3635                                 }
3636                         }
3637
3638                         if (!r->presentation_info().special (false)) {
3639
3640                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3641
3642                                 /* presentation info order may already have been set from XML */
3643
3644                                 if (!r->presentation_info().order_set()) {
3645                                         if (order == PresentationInfo::max_order) {
3646                                                 /* just add to the end */
3647                                                 r->set_presentation_order (n_routes + added);
3648                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3649                                         } else {
3650                                                 r->set_presentation_order (order + added);
3651                                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3652                                         }
3653                                 } else {
3654                                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3655                                 }
3656                         }
3657
3658 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3659                         /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3660                          * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3661                          */
3662                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3663                                                                        r->name(),
3664                                                                        r->presentation_info().order(),
3665                                                                        enum_2_string (r->presentation_info().flags()),
3666                                                                        r->presentation_info()));
3667 #endif
3668
3669
3670                         if (input_auto_connect || output_auto_connect) {
3671                                 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3672                                 existing_inputs += r->n_inputs();
3673                                 existing_outputs += r->n_outputs();
3674                         }
3675
3676                         ARDOUR::GUIIdle ();
3677                 }
3678                 ensure_stripable_sort_order ();
3679         }
3680
3681         if (_monitor_out && IO::connecting_legal) {
3682                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3683
3684                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3685                         if ((*x)->is_monitor()) {
3686                                 /* relax */
3687                         } else if ((*x)->is_master()) {
3688                                 /* relax */
3689                         } else {
3690                                 (*x)->enable_monitor_send ();
3691                         }
3692                 }
3693         }
3694
3695         reassign_track_numbers ();
3696 }
3697
3698 void
3699 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3700 {
3701         boost::shared_ptr<RouteList> r = routes.reader ();
3702         boost::shared_ptr<Send> s;
3703
3704         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3705                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3706                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3707                 }
3708         }
3709 }
3710
3711 void
3712 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3713 {
3714         boost::shared_ptr<RouteList> r = routes.reader ();
3715         boost::shared_ptr<Send> s;
3716
3717         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3718                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3719                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3720                 }
3721         }
3722 }
3723
3724 void
3725 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3726 {
3727         boost::shared_ptr<RouteList> r = routes.reader ();
3728         boost::shared_ptr<Send> s;
3729
3730         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3731                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3732                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3733                 }
3734         }
3735 }
3736
3737 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3738 void
3739 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3740 {
3741         boost::shared_ptr<RouteList> r = routes.reader ();
3742         boost::shared_ptr<RouteList> t (new RouteList);
3743
3744         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3745                 /* no MIDI sends because there are no MIDI busses yet */
3746                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3747                         t->push_back (*i);
3748                 }
3749         }
3750
3751         add_internal_sends (dest, p, t);
3752 }
3753
3754 void
3755 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3756 {
3757         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3758                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3759         }
3760 }
3761
3762 void
3763 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3764 {
3765         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3766 }
3767
3768 void
3769 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3770 {
3771         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3772                 return;
3773         }
3774
3775         if (!dest->internal_return()) {
3776                 dest->add_internal_return ();
3777         }
3778
3779         sender->add_aux_send (dest, before);
3780
3781         graph_reordered ();
3782 }
3783
3784 void
3785 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3786 {
3787         bool mute_changed = false;
3788         bool send_selected = false;
3789
3790         { // RCU Writer scope
3791                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3792                 RCUWriter<RouteList> writer (routes);
3793                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3794
3795                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3796
3797                         if (_selection->selected (*iter)) {
3798                                 send_selected = true;
3799                         }
3800
3801                         if (*iter == _master_out) {
3802                                 continue;
3803                         }
3804
3805                         /* speed up session deletion, don't do the solo dance */
3806                         if (!deletion_in_progress ()) {
3807                                 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3808                         }
3809
3810                         if ((*iter)->mute_control()->muted ()) {
3811                                 mute_changed = true;
3812                         }
3813
3814                         rs->remove (*iter);
3815
3816                         /* deleting the master out seems like a dumb
3817                            idea, but its more of a UI policy issue
3818                            than our concern.
3819                         */
3820
3821                         if (*iter == _master_out) {
3822                                 _master_out = boost::shared_ptr<Route> ();
3823                         }
3824
3825                         if (*iter == _monitor_out) {
3826                                 _monitor_out.reset ();
3827                         }
3828
3829                         // We need to disconnect the route's inputs and outputs
3830
3831                         (*iter)->input()->disconnect (0);
3832                         (*iter)->output()->disconnect (0);
3833
3834                         /* if the route had internal sends sending to it, remove them */
3835
3836                         if (!deletion_in_progress () && (*iter)->internal_return()) {
3837
3838                                 boost::shared_ptr<RouteList> r = routes.reader ();
3839                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3840                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3841                                         if (s) {
3842                                                 (*i)->remove_processor (s);
3843                                         }
3844                                 }
3845                         }
3846
3847                         /* if the monitoring section had a pointer to this route, remove it */
3848                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3849                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3850                                 ProcessorChangeBlocker pcb (this, false);
3851                                 (*iter)->remove_aux_or_listen (_monitor_out);
3852                         }
3853
3854                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3855                         if (mt && mt->step_editing()) {
3856                                 if (_step_editors > 0) {
3857                                         _step_editors--;
3858                                 }
3859                         }
3860                 }
3861
3862                 /* writer goes out of scope, forces route list update */
3863
3864         } // end of RCU Writer scope
3865
3866         if (mute_changed) {
3867                 MuteChanged (); /* EMIT SIGNAL */
3868         }
3869
3870         update_route_solo_state ();
3871         update_latency_compensation ();
3872         set_dirty();
3873
3874         /* Re-sort routes to remove the graph's current references to the one that is
3875          * going away, then flush old references out of the graph.
3876          * Wave Tracks: reconnect routes
3877          */
3878
3879 #ifdef USE_TRACKS_CODE_FEATURES
3880                 reconnect_existing_routes(true, false);
3881 #else
3882                 routes.flush (); // maybe unsafe, see below.
3883                 resort_routes ();
3884 #endif
3885
3886         if (_process_graph && !deletion_in_progress() && _engine.running()) {
3887                 _process_graph->clear_other_chain ();
3888         }
3889
3890         /* get rid of it from the dead wood collection in the route list manager */
3891         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3892
3893         routes.flush ();
3894
3895         /* remove these routes from the selection if appropriate, and signal
3896          * the change *before* we call DropReferences for them.
3897          */
3898
3899         if (send_selected && !deletion_in_progress()) {
3900                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3901                         _selection->remove_stripable_by_id ((*iter)->id());
3902                 }
3903                 PropertyChange pc;
3904                 pc.add (Properties::selected);
3905                 PresentationInfo::Change (pc);
3906         }
3907
3908         /* try to cause everyone to drop their references
3909          * and unregister ports from the backend
3910          */
3911
3912         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3913                 (*iter)->drop_references ();
3914         }
3915
3916         if (deletion_in_progress()) {
3917                 return;
3918         }
3919
3920         PropertyChange pc;
3921         pc.add (Properties::order);
3922         PresentationInfo::Change (pc);
3923
3924         /* save the new state of the world */
3925
3926         if (save_state (_current_snapshot_name)) {
3927                 save_history (_current_snapshot_name);
3928         }
3929
3930         update_route_record_state ();
3931 }
3932
3933 void
3934 Session::remove_route (boost::shared_ptr<Route> route)
3935 {
3936         boost::shared_ptr<RouteList> rl (new RouteList);
3937         rl->push_back (route);
3938         remove_routes (rl);
3939 }
3940
3941 void
3942 Session::route_mute_changed ()
3943 {
3944         MuteChanged (); /* EMIT SIGNAL */
3945         set_dirty ();
3946 }
3947
3948 void
3949 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3950 {
3951         boost::shared_ptr<Route> route (wpr.lock());
3952
3953         if (!route) {
3954                 return;
3955         }
3956
3957         assert (Config->get_solo_control_is_listen_control());
3958
3959         if (route->solo_control()->soloed_by_self_or_masters()) {
3960
3961                 if (Config->get_exclusive_solo()) {
3962
3963                         RouteGroup* rg = route->route_group ();
3964                         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3965
3966                         boost::shared_ptr<RouteList> r = routes.reader ();
3967
3968                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3969                                 if ((*i) == route) {
3970                                         /* already changed */
3971                                         continue;
3972                                 }
3973
3974                                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3975                                         /* route does not get solo propagated to it */
3976                                         continue;
3977                                 }
3978
3979                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3980                                         /* this route is a part of the same solo group as the route
3981                                          * that was changed. Changing that route did change or will
3982                                          * change all group members appropriately, so we can ignore it
3983                                          * here
3984                                          */
3985                                         continue;
3986                                 }
3987                                 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3988                         }
3989                 }
3990
3991                 _listen_cnt++;
3992
3993         } else if (_listen_cnt > 0) {
3994
3995                 _listen_cnt--;
3996         }
3997 }
3998
3999 void
4000 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
4001 {
4002         boost::shared_ptr<Route> route (wpr.lock());
4003
4004         if (!route) {
4005                 return;
4006         }
4007
4008         bool send_changed = false;
4009
4010         if (route->solo_isolate_control()->solo_isolated()) {
4011                 if (_solo_isolated_cnt == 0) {
4012                         send_changed = true;
4013                 }
4014                 _solo_isolated_cnt++;
4015         } else if (_solo_isolated_cnt > 0) {
4016                 _solo_isolated_cnt--;
4017                 if (_solo_isolated_cnt == 0) {
4018                         send_changed = true;
4019                 }
4020         }
4021
4022         if (send_changed) {
4023                 IsolatedChanged (); /* EMIT SIGNAL */
4024         }
4025 }
4026
4027 void
4028 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
4029 {
4030         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
4031
4032         boost::shared_ptr<Route> route (wpr.lock());
4033
4034         if (!route) {
4035                 return;
4036         }
4037
4038         if (Config->get_solo_control_is_listen_control()) {
4039                 route_listen_changed (group_override, wpr);
4040                 return;
4041         }
4042
4043         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()));
4044
4045         if (route->solo_control()->transitioned_into_solo() == 0) {
4046                 /* route solo changed by upstream/downstream or clear all solo state; not interesting
4047                    to Session.
4048                 */
4049                 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()));
4050                 return;
4051         }
4052
4053         boost::shared_ptr<RouteList> r = routes.reader ();
4054         int32_t delta = route->solo_control()->transitioned_into_solo ();
4055
4056         /* the route may be a member of a group that has shared-solo
4057          * semantics. If so, then all members of that group should follow the
4058          * solo of the changed route. But ... this is optional, controlled by a
4059          * Controllable::GroupControlDisposition.
4060          *
4061          * The first argument to the signal that this method is connected to is the
4062          * GroupControlDisposition value that was used to change solo.
4063          *
4064          * If the solo change was done with group semantics (either InverseGroup
4065          * (force the entire group to change even if the group shared solo is
4066          * disabled) or UseGroup (use the group, which may or may not have the
4067          * shared solo property enabled)) then as we propagate the change to
4068          * the entire session we should IGNORE THE GROUP that the changed route
4069          * belongs to.
4070          */
4071
4072         RouteGroup* rg = route->route_group ();
4073         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
4074
4075         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
4076
4077         if (delta == 1 && Config->get_exclusive_solo()) {
4078
4079                 /* new solo: disable all other solos, but not the group if its solo-enabled */
4080
4081                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4082
4083                         if ((*i) == route) {
4084                                 /* already changed */
4085                                 continue;
4086                         }
4087
4088                         if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4089                                 /* route does not get solo propagated to it */
4090                                 continue;
4091                         }
4092
4093                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4094                                 /* this route is a part of the same solo group as the route
4095                                  * that was changed. Changing that route did change or will
4096                                  * change all group members appropriately, so we can ignore it
4097                                  * here
4098                                  */
4099                                 continue;
4100                         }
4101
4102                         (*i)->solo_control()->set_value (0.0, group_override);
4103                 }
4104         }
4105
4106         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4107
4108         RouteList uninvolved;
4109
4110         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4111
4112         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4113                 bool via_sends_only;
4114                 bool in_signal_flow;
4115
4116                 if ((*i) == route) {
4117                         /* already changed */
4118                         continue;
4119                 }
4120
4121                 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4122                         /* route does not get solo propagated to it */
4123                         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(),
4124                                                                   (*i)->can_solo()));
4125                         continue;
4126                 }
4127
4128                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4129                         /* this route is a part of the same solo group as the route
4130                          * that was changed. Changing that route did change or will
4131                          * change all group members appropriately, so we can ignore it
4132                          * here
4133                          */
4134                         continue;
4135                 }
4136
4137                 in_signal_flow = false;
4138
4139                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4140
4141                 if ((*i)->feeds (route, &via_sends_only)) {
4142                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4143                         if (!via_sends_only) {
4144                                 if (!route->soloed_by_others_upstream()) {
4145                                         (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4146                                 } else {
4147                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4148                                 }
4149                         } else {
4150                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4151                         }
4152                         in_signal_flow = true;
4153                 } else {
4154                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4155                 }
4156
4157                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4158
4159                 if (route->feeds (*i, &via_sends_only)) {
4160                         /* propagate solo upstream only if routing other than
4161                            sends is involved, but do consider the other route
4162                            (*i) to be part of the signal flow even if only
4163                            sends are involved.
4164                         */
4165                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4166                                                                   route->name(),
4167                                                                   (*i)->name(),
4168                                                                   via_sends_only,
4169                                                                   route->soloed_by_others_downstream(),
4170                                                                   route->soloed_by_others_upstream()));
4171                         if (!via_sends_only) {
4172                                 //NB. Triggers Invert Push, which handles soloed by downstream
4173                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4174                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4175                         } else {
4176                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4177                         }
4178                         in_signal_flow = true;
4179                 } else {
4180                         DEBUG_TRACE (DEBUG::Solo, string_compose("\tno feed to %1\n", (*i)->name()) );
4181                 }
4182
4183                 if (!in_signal_flow) {
4184                         uninvolved.push_back (*i);
4185                 }
4186         }
4187
4188         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4189
4190         /* now notify that the mute state of the routes not involved in the signal
4191            pathway of the just-solo-changed route may have altered.
4192         */
4193
4194         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4195                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4196                 (*i)->act_on_mute ();
4197                 /* Session will emit SoloChanged() after all solo changes are
4198                  * complete, which should be used by UIs to update mute status
4199                  */
4200         }
4201 }
4202
4203 void
4204 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4205 {
4206         /* now figure out if anything that matters is soloed (or is "listening")*/
4207
4208         bool something_soloed = false;
4209         bool something_listening = false;
4210         uint32_t listeners = 0;
4211         uint32_t isolated = 0;
4212
4213         if (!r) {
4214                 r = routes.reader();
4215         }
4216
4217         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4218                 if ((*i)->can_solo()) {
4219                         if (Config->get_solo_control_is_listen_control()) {
4220                                 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4221                                         listeners++;
4222                                         something_listening = true;
4223                                 }
4224                         } else {
4225                                 (*i)->set_listen (false);
4226                                 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4227                                         something_soloed = true;
4228                                 }
4229                         }
4230                 }
4231
4232                 if ((*i)->solo_isolate_control()->solo_isolated()) {
4233                         isolated++;
4234                 }
4235         }
4236
4237         if (something_soloed != _non_soloed_outs_muted) {
4238                 _non_soloed_outs_muted = something_soloed;
4239                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4240         }
4241
4242         if (something_listening != _listening) {
4243                 _listening = something_listening;
4244                 SoloActive (_listening);
4245         }
4246
4247         _listen_cnt = listeners;
4248
4249         if (isolated != _solo_isolated_cnt) {
4250                 _solo_isolated_cnt = isolated;
4251                 IsolatedChanged (); /* EMIT SIGNAL */
4252         }
4253
4254         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4255                                                   something_soloed, listeners, isolated));
4256
4257
4258         SoloChanged (); /* EMIT SIGNAL */
4259         set_dirty();
4260 }
4261
4262 bool
4263 Session::muted () const
4264 {
4265         // TODO consider caching the value on every MuteChanged signal,
4266         // Note that API users may also subscribe to MuteChanged and hence
4267         // this method needs to be called first.
4268         bool muted = false;
4269         StripableList all;
4270         get_stripables (all);
4271         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4272                 assert (!(*i)->is_auditioner()); // XXX remove me
4273                 if ((*i)->is_monitor()) {
4274                         continue;
4275                 }
4276                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route>(*i);
4277                 if (r && !r->active()) {
4278                         continue;
4279                 }
4280                 boost::shared_ptr<MuteControl> mc = (*i)->mute_control();
4281                 if (mc && mc->muted ()) {
4282                         muted = true;
4283                         break;
4284                 }
4285         }
4286         return muted;
4287 }
4288
4289 std::vector<boost::weak_ptr<AutomationControl> >
4290 Session::cancel_all_mute ()
4291 {
4292         StripableList all;
4293         get_stripables (all);
4294         std::vector<boost::weak_ptr<AutomationControl> > muted;
4295         boost::shared_ptr<ControlList> cl (new ControlList);
4296         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4297                 assert (!(*i)->is_auditioner());
4298                 if ((*i)->is_monitor()) {
4299                         continue;
4300                 }
4301                 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (*i);
4302                 if (r && !r->active()) {
4303                         continue;
4304                 }
4305                 boost::shared_ptr<AutomationControl> ac = (*i)->mute_control();
4306                 if (ac && ac->get_value () > 0) {
4307                         cl->push_back (ac);
4308                         muted.push_back (boost::weak_ptr<AutomationControl>(ac));
4309                 }
4310         }
4311         if (!cl->empty ()) {
4312                 set_controls (cl, 0.0, PBD::Controllable::UseGroup);
4313         }
4314         return muted;
4315 }
4316
4317 void
4318 Session::get_stripables (StripableList& sl, PresentationInfo::Flag fl) const
4319 {
4320         boost::shared_ptr<RouteList> r = routes.reader ();
4321         for (RouteList::iterator it = r->begin(); it != r->end(); ++it) {
4322                 if ((*it)->presentation_info ().flags () & fl) {
4323                         sl.push_back (*it);
4324                 }
4325         }
4326
4327         if (fl & PresentationInfo::VCA) {
4328                 VCAList v = _vca_manager->vcas ();
4329                 sl.insert (sl.end(), v.begin(), v.end());
4330         }
4331 }
4332
4333 StripableList
4334 Session::get_stripables () const
4335 {
4336         PresentationInfo::Flag fl = PresentationInfo::AllStripables;
4337         StripableList rv;
4338         Session::get_stripables (rv, fl);
4339         rv.sort (Stripable::Sorter ());
4340         return rv;
4341 }
4342
4343 RouteList
4344 Session::get_routelist (bool mixer_order, PresentationInfo::Flag fl) const
4345 {
4346         boost::shared_ptr<RouteList> r = routes.reader ();
4347         RouteList rv;
4348         for (RouteList::iterator it = r->begin(); it != r->end(); ++it) {
4349                 if ((*it)->presentation_info ().flags () & fl) {
4350                         rv.push_back (*it);
4351                 }
4352         }
4353         rv.sort (Stripable::Sorter (mixer_order));
4354         return rv;
4355 }
4356
4357 boost::shared_ptr<RouteList>
4358 Session::get_routes_with_internal_returns() const
4359 {
4360         boost::shared_ptr<RouteList> r = routes.reader ();
4361         boost::shared_ptr<RouteList> rl (new RouteList);
4362
4363         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4364                 if ((*i)->internal_return ()) {
4365                         rl->push_back (*i);
4366                 }
4367         }
4368         return rl;
4369 }
4370
4371 bool
4372 Session::io_name_is_legal (const std::string& name) const
4373 {
4374         boost::shared_ptr<RouteList> r = routes.reader ();
4375
4376         for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4377                 if (name == reserved->first) {
4378                         if (!route_by_name (reserved->first)) {
4379                                 /* first instance of a reserved name is allowed for some */
4380                                 return reserved->second;
4381                         }
4382                         /* all other instances of a reserved name are not allowed */
4383                         return false;
4384                 }
4385         }
4386
4387         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4388                 if ((*i)->name() == name) {
4389                         return false;
4390                 }
4391
4392                 if ((*i)->has_io_processor_named (name)) {
4393                         return false;
4394                 }
4395         }
4396
4397         return true;
4398 }
4399
4400 void
4401 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4402 {
4403         RouteList rl2;
4404         vector<string> connections;
4405
4406         /* if we are passed only a single route and we're not told to turn
4407          * others off, then just do the simple thing.
4408          */
4409
4410         if (flip_others == false && rl->size() == 1) {
4411                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4412                 if (mt) {
4413                         mt->set_input_active (onoff);
4414                         return;
4415                 }
4416         }
4417
4418         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4419
4420                 PortSet& ps ((*rt)->input()->ports());
4421
4422                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4423                         p->get_connections (connections);
4424                 }
4425
4426                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4427                         routes_using_input_from (*s, rl2);
4428                 }
4429
4430                 /* scan all relevant routes to see if others are on or off */
4431
4432                 bool others_are_already_on = false;
4433
4434                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4435
4436                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4437
4438                         if (!mt) {
4439                                 continue;
4440                         }
4441
4442                         if ((*r) != (*rt)) {
4443                                 if (mt->input_active()) {
4444                                         others_are_already_on = true;
4445                                 }
4446                         } else {
4447                                 /* this one needs changing */
4448                                 mt->set_input_active (onoff);
4449                         }
4450                 }
4451
4452                 if (flip_others) {
4453
4454                         /* globally reverse other routes */
4455
4456                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4457                                 if ((*r) != (*rt)) {
4458                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4459                                         if (mt) {
4460                                                 mt->set_input_active (!others_are_already_on);
4461                                         }
4462                                 }
4463                         }
4464                 }
4465         }
4466 }
4467
4468 void
4469 Session::routes_using_input_from (const string& str, RouteList& rl)
4470 {
4471         boost::shared_ptr<RouteList> r = routes.reader();
4472
4473         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4474                 if ((*i)->input()->connected_to (str)) {
4475                         rl.push_back (*i);
4476                 }
4477         }
4478 }
4479
4480 boost::shared_ptr<Route>
4481 Session::route_by_name (string name) const
4482 {
4483         boost::shared_ptr<RouteList> r = routes.reader ();
4484
4485         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4486                 if ((*i)->name() == name) {
4487                         return *i;
4488                 }
4489         }
4490
4491         return boost::shared_ptr<Route> ((Route*) 0);
4492 }
4493
4494 boost::shared_ptr<Route>
4495 Session::route_by_id (PBD::ID id) const
4496 {
4497         boost::shared_ptr<RouteList> r = routes.reader ();
4498
4499         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4500                 if ((*i)->id() == id) {
4501                         return *i;
4502                 }
4503         }
4504
4505         return boost::shared_ptr<Route> ((Route*) 0);
4506 }
4507
4508
4509 boost::shared_ptr<Stripable>
4510 Session::stripable_by_id (PBD::ID id) const
4511 {
4512         StripableList sl;
4513         get_stripables (sl);
4514
4515         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4516                 if ((*s)->id() == id) {
4517                         return *s;
4518                 }
4519         }
4520
4521         return boost::shared_ptr<Stripable>();
4522 }
4523
4524 boost::shared_ptr<Processor>
4525 Session::processor_by_id (PBD::ID id) const
4526 {
4527         boost::shared_ptr<RouteList> r = routes.reader ();
4528
4529         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4530                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4531                 if (p) {
4532                         return p;
4533                 }
4534         }
4535
4536         return boost::shared_ptr<Processor> ();
4537 }
4538
4539 boost::shared_ptr<Route>
4540 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4541 {
4542         return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4543 }
4544
4545 boost::shared_ptr<Stripable>
4546 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4547 {
4548         StripableList sl;
4549         PresentationInfo::order_t match_cnt = 0;
4550
4551         get_stripables (sl);
4552         sl.sort (Stripable::Sorter());
4553
4554         for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4555
4556                 if ((*s)->presentation_info().hidden()) {
4557                         /* if the caller didn't explicitly ask for hidden
4558                            stripables, ignore hidden ones. This matches
4559                            the semantics of the pre-PresentationOrder
4560                            "get by RID" logic of Ardour 4.x and earlier.
4561
4562                            XXX at some point we should likely reverse
4563                            the logic of the flags, because asking for "the
4564                            hidden stripables" is not going to be common,
4565                            whereas asking for visible ones is normal.
4566                         */
4567
4568                         if (! (flags & PresentationInfo::Hidden)) {
4569                                 continue;
4570                         }
4571                 }
4572
4573                 if ((*s)->presentation_info().flag_match (flags)) {
4574                         if (match_cnt++ == n) {
4575                                 return *s;
4576                         }
4577                 }
4578         }
4579
4580         /* there is no nth stripable that matches the given flags */
4581         return boost::shared_ptr<Stripable>();
4582 }
4583
4584 boost::shared_ptr<Route>
4585 Session::route_by_selected_count (uint32_t id) const
4586 {
4587         RouteList r (*(routes.reader ()));
4588         r.sort (Stripable::Sorter());
4589
4590         RouteList::iterator i;
4591
4592         for (i = r.begin(); i != r.end(); ++i) {
4593                 if ((*i)->is_selected()) {
4594                         if (id == 0) {
4595                                 return *i;
4596                         }
4597                         --id;
4598                 }
4599         }
4600
4601         return boost::shared_ptr<Route> ();
4602 }
4603
4604 void
4605 Session::reassign_track_numbers ()
4606 {
4607         int64_t tn = 0;
4608         int64_t bn = 0;
4609         RouteList r (*(routes.reader ()));
4610         r.sort (Stripable::Sorter());
4611
4612         StateProtector sp (this);
4613
4614         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4615                 assert (!(*i)->is_auditioner());
4616                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4617                         (*i)->set_track_number(++tn);
4618                 }
4619                 else if (!(*i)->is_master() && !(*i)->is_monitor()) {
4620                         (*i)->set_track_number(--bn);
4621                 }
4622         }
4623         const uint32_t decimals = ceilf (log10f (tn + 1));
4624         const bool decimals_changed = _track_number_decimals != decimals;
4625         _track_number_decimals = decimals;
4626
4627         if (decimals_changed && config.get_track_name_number ()) {
4628                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4629                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4630                         if (t) {
4631                                 t->resync_track_name();
4632                         }
4633                 }
4634                 // trigger GUI re-layout
4635                 config.ParameterChanged("track-name-number");
4636         }
4637
4638 #ifndef NDEBUG
4639         if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4640                 boost::shared_ptr<RouteList> rl = routes.reader ();
4641                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4642                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4643                 }
4644         }
4645 #endif /* NDEBUG */
4646
4647 }
4648
4649 void
4650 Session::playlist_region_added (boost::weak_ptr<Region> w)
4651 {
4652         boost::shared_ptr<Region> r = w.lock ();
4653         if (!r) {
4654                 return;
4655         }
4656
4657         /* These are the operations that are currently in progress... */
4658         list<GQuark> curr = _current_trans_quarks;
4659         curr.sort ();
4660
4661         /* ...and these are the operations during which we want to update
4662            the session range location markers.
4663         */
4664         list<GQuark> ops;
4665         ops.push_back (Operations::capture);
4666         ops.push_back (Operations::paste);
4667         ops.push_back (Operations::duplicate_region);
4668         ops.push_back (Operations::insert_file);
4669         ops.push_back (Operations::insert_region);
4670         ops.push_back (Operations::drag_region_brush);
4671         ops.push_back (Operations::region_drag);
4672         ops.push_back (Operations::selection_grab);
4673         ops.push_back (Operations::region_fill);
4674         ops.push_back (Operations::fill_selection);
4675         ops.push_back (Operations::create_region);
4676         ops.push_back (Operations::region_copy);
4677         ops.push_back (Operations::fixed_time_region_copy);
4678         ops.sort ();
4679
4680         /* See if any of the current operations match the ones that we want */
4681         list<GQuark> in;
4682         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4683
4684         /* If so, update the session range markers */
4685         if (!in.empty ()) {
4686                 maybe_update_session_range (r->position (), r->last_sample ());
4687         }
4688 }
4689
4690 /** Update the session range markers if a is before the current start or
4691  *  b is after the current end.
4692  */
4693 void
4694 Session::maybe_update_session_range (samplepos_t a, samplepos_t b)
4695 {
4696         if (loading ()) {
4697                 return;
4698         }
4699
4700         samplepos_t session_end_marker_shift_samples = session_end_shift * _nominal_sample_rate;
4701
4702         if (_session_range_location == 0) {
4703
4704                 set_session_range_location (a, b + session_end_marker_shift_samples);
4705
4706         } else {
4707
4708                 if (_session_range_is_free && (a < _session_range_location->start())) {
4709                         _session_range_location->set_start (a);
4710                 }
4711
4712                 if (_session_range_is_free && (b > _session_range_location->end())) {
4713                         _session_range_location->set_end (b);
4714                 }
4715         }
4716 }
4717
4718 void
4719 Session::set_session_range_is_free (bool yn)
4720 {
4721         _session_range_is_free = yn;
4722 }
4723
4724 void
4725 Session::playlist_ranges_moved (list<Evoral::RangeMove<samplepos_t> > const & ranges)
4726 {
4727         for (list<Evoral::RangeMove<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4728                 maybe_update_session_range (i->to, i->to + i->length);
4729         }
4730 }
4731
4732 void
4733 Session::playlist_regions_extended (list<Evoral::Range<samplepos_t> > const & ranges)
4734 {
4735         for (list<Evoral::Range<samplepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4736                 maybe_update_session_range (i->from, i->to);
4737         }
4738 }
4739
4740 /* Region management */
4741
4742 boost::shared_ptr<Region>
4743 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4744 {
4745         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4746         RegionFactory::RegionMap::const_iterator i;
4747         boost::shared_ptr<Region> region;
4748
4749         Glib::Threads::Mutex::Lock lm (region_lock);
4750
4751         for (i = regions.begin(); i != regions.end(); ++i) {
4752
4753                 region = i->second;
4754
4755                 if (region->whole_file()) {
4756
4757                         if (child->source_equivalent (region)) {
4758                                 return region;
4759                         }
4760                 }
4761         }
4762
4763         return boost::shared_ptr<Region> ();
4764 }
4765
4766 int
4767 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4768 {
4769         set<boost::shared_ptr<Region> > relevant_regions;
4770
4771         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4772                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4773         }
4774
4775         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4776                 set<boost::shared_ptr<Region> >::iterator tmp;
4777
4778                 tmp = r;
4779                 ++tmp;
4780
4781                 _playlists->destroy_region (*r);
4782                 RegionFactory::map_remove (*r);
4783
4784                 (*r)->drop_sources ();
4785                 (*r)->drop_references ();
4786
4787                 relevant_regions.erase (r);
4788
4789                 r = tmp;
4790         }
4791
4792         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4793
4794                 {
4795                         Glib::Threads::Mutex::Lock ls (source_lock);
4796                         /* remove from the main source list */
4797                         sources.erase ((*s)->id());
4798                 }
4799
4800                 (*s)->mark_for_remove ();
4801                 (*s)->drop_references ();
4802                 SourceRemoved(*s);
4803
4804                 s = srcs.erase (s);
4805         }
4806
4807         return 0;
4808 }
4809
4810 int
4811 Session::remove_last_capture ()
4812 {
4813         list<boost::shared_ptr<Source> > srcs;
4814
4815         boost::shared_ptr<RouteList> rl = routes.reader ();
4816         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4817                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4818                 if (!tr) {
4819                         continue;
4820                 }
4821
4822                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4823
4824                 if (!l.empty()) {
4825                         srcs.insert (srcs.end(), l.begin(), l.end());
4826                         l.clear ();
4827                 }
4828         }
4829
4830         destroy_sources (srcs);
4831
4832         save_state (_current_snapshot_name);
4833
4834         return 0;
4835 }
4836
4837 void
4838 Session::get_last_capture_sources (std::list<boost::shared_ptr<Source> >& srcs)
4839 {
4840         boost::shared_ptr<RouteList> rl = routes.reader ();
4841         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4842                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4843                 if (!tr) {
4844                         continue;
4845                 }
4846
4847                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4848
4849                 if (!l.empty()) {
4850                         srcs.insert (srcs.end(), l.begin(), l.end());
4851                         l.clear ();
4852                 }
4853         }
4854 }
4855
4856 /* Source Management */
4857
4858 void
4859 Session::add_source (boost::shared_ptr<Source> source)
4860 {
4861         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4862         pair<SourceMap::iterator,bool> result;
4863
4864         entry.first = source->id();
4865         entry.second = source;
4866
4867         {
4868                 Glib::Threads::Mutex::Lock lm (source_lock);
4869                 result = sources.insert (entry);
4870         }
4871
4872         if (result.second) {
4873
4874                 /* yay, new source */
4875
4876                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4877
4878                 if (fs) {
4879                         if (!fs->within_session()) {
4880                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4881                         }
4882                 }
4883
4884                 set_dirty();
4885
4886                 boost::shared_ptr<AudioFileSource> afs;
4887
4888                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4889                         if (Config->get_auto_analyse_audio()) {
4890                                 Analyser::queue_source_for_analysis (source, false);
4891                         }
4892                 }
4893
4894                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4895
4896                 SourceAdded(source);
4897         }
4898 }
4899
4900 void
4901 Session::remove_source (boost::weak_ptr<Source> src)
4902 {
4903         if (deletion_in_progress ()) {
4904                 return;
4905         }
4906
4907         SourceMap::iterator i;
4908         boost::shared_ptr<Source> source = src.lock();
4909
4910         if (!source) {
4911                 return;
4912         }
4913
4914         {
4915                 Glib::Threads::Mutex::Lock lm (source_lock);
4916
4917                 if ((i = sources.find (source->id())) != sources.end()) {
4918                         sources.erase (i);
4919                         SourceRemoved(source);
4920                 }
4921         }
4922
4923         if (!in_cleanup () && !loading ()) {
4924
4925                 /* save state so we don't end up with a session file
4926                  * referring to non-existent sources.
4927                  */
4928
4929                 save_state (_current_snapshot_name);
4930         }
4931 }
4932
4933 boost::shared_ptr<Source>
4934 Session::source_by_id (const PBD::ID& id)
4935 {
4936         Glib::Threads::Mutex::Lock lm (source_lock);
4937         SourceMap::iterator i;
4938         boost::shared_ptr<Source> source;
4939
4940         if ((i = sources.find (id)) != sources.end()) {
4941                 source = i->second;
4942         }
4943
4944         return source;
4945 }
4946
4947 boost::shared_ptr<AudioFileSource>
4948 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4949 {
4950         /* Restricted to audio files because only audio sources have channel
4951            as a property.
4952         */
4953
4954         Glib::Threads::Mutex::Lock lm (source_lock);
4955
4956         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4957                 boost::shared_ptr<AudioFileSource> afs
4958                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4959
4960                 if (afs && afs->path() == path && chn == afs->channel()) {
4961                         return afs;
4962                 }
4963         }
4964
4965         return boost::shared_ptr<AudioFileSource>();
4966 }
4967
4968 boost::shared_ptr<MidiSource>
4969 Session::midi_source_by_path (const std::string& path, bool need_source_lock) const
4970 {
4971         /* Restricted to MIDI files because audio sources require a channel
4972            for unique identification, in addition to a path.
4973         */
4974
4975         Glib::Threads::Mutex::Lock lm (source_lock, Glib::Threads::NOT_LOCK);
4976         if (need_source_lock) {
4977                 lm.acquire ();
4978         }
4979
4980         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4981                 boost::shared_ptr<MidiSource> ms
4982                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4983                 boost::shared_ptr<FileSource> fs
4984                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4985
4986                 if (ms && fs && fs->path() == path) {
4987                         return ms;
4988                 }
4989         }
4990
4991         return boost::shared_ptr<MidiSource>();
4992 }
4993
4994 uint32_t
4995 Session::count_sources_by_origin (const string& path)
4996 {
4997         uint32_t cnt = 0;
4998         Glib::Threads::Mutex::Lock lm (source_lock);
4999
5000         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
5001                 boost::shared_ptr<FileSource> fs
5002                         = boost::dynamic_pointer_cast<FileSource>(i->second);
5003
5004                 if (fs && fs->origin() == path) {
5005                         ++cnt;
5006                 }
5007         }
5008
5009         return cnt;
5010 }
5011
5012 static string
5013 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
5014         if (hash) {
5015                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
5016                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
5017         } else {
5018                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
5019         }
5020 }
5021
5022 string
5023 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
5024 {
5025         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
5026
5027         if (Glib::path_is_absolute (filepath)) {
5028
5029                 /* rip the session dir from the audiofile source */
5030
5031                 string session_path;
5032                 bool in_another_session = true;
5033
5034                 if (filepath.find (interchange_dir_string) != string::npos) {
5035
5036                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
5037                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
5038                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
5039                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
5040
5041                         /* see if it is within our session */
5042
5043                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5044                                 if (i->path == session_path) {
5045                                         in_another_session = false;
5046                                         break;
5047                                 }
5048                         }
5049                 } else {
5050                         in_another_session = false;
5051                 }
5052
5053
5054                 if (in_another_session) {
5055                         SessionDirectory sd (session_path);
5056                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
5057                 }
5058         }
5059
5060         /* 1) if file belongs to this session
5061          * it may be a relative path (interchange/...)
5062          * or just basename (session_state, remove source)
5063          * -> just use the basename
5064          */
5065         std::string filename = Glib::path_get_basename (filepath);
5066         std::string path;
5067
5068         /* 2) if the file is outside our session dir:
5069          * (imported but not copied) add the path for check-summming */
5070         if (!in_session) {
5071                 path = Glib::path_get_dirname (filepath);
5072         }
5073
5074         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
5075 }
5076
5077 string
5078 Session::new_audio_source_path_for_embedded (const std::string& path)
5079 {
5080         /* embedded source:
5081          *
5082          * we know that the filename is already unique because it exists
5083          * out in the filesystem.
5084          *
5085          * However, when we bring it into the session, we could get a
5086          * collision.
5087          *
5088          * Eg. two embedded files:
5089          *
5090          *          /foo/bar/baz.wav
5091          *          /frob/nic/baz.wav
5092          *
5093          * When merged into session, these collide.
5094          *
5095          * There will not be a conflict with in-memory sources
5096          * because when the source was created we already picked
5097          * a unique name for it.
5098          *
5099          * This collision is not likely to be common, but we have to guard
5100          * against it.  So, if there is a collision, take the md5 hash of the
5101          * the path, and use that as the filename instead.
5102          */
5103
5104         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5105         string base = Glib::path_get_basename (path);
5106         string newpath = Glib::build_filename (sdir.sound_path(), base);
5107
5108         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5109
5110                 MD5 md5;
5111
5112                 md5.digestString (path.c_str());
5113                 md5.writeToString ();
5114                 base = md5.digestChars;
5115
5116                 string ext = get_suffix (path);
5117
5118                 if (!ext.empty()) {
5119                         base += '.';
5120                         base += ext;
5121                 }
5122
5123                 newpath = Glib::build_filename (sdir.sound_path(), base);
5124
5125                 /* if this collides, we're screwed */
5126
5127                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5128                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5129                         return string();
5130                 }
5131
5132         }
5133
5134         return newpath;
5135 }
5136
5137 /** Return true if there are no audio file sources that use @param name as
5138  * the filename component of their path.
5139  *
5140  * Return false otherwise.
5141  *
5142  * This method MUST ONLY be used to check in-session, mono files since it
5143  * hard-codes the channel of the audio file source we are looking for as zero.
5144  *
5145  * If/when Ardour supports native files in non-mono formats, the logic here
5146  * will need to be revisited.
5147  */
5148 bool
5149 Session::audio_source_name_is_unique (const string& name)
5150 {
5151         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5152         vector<space_and_path>::iterator i;
5153         uint32_t existing = 0;
5154
5155         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5156
5157                 /* note that we search *without* the extension so that
5158                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5159                    in the event that this new name is required for
5160                    a file format change.
5161                 */
5162
5163                 const string spath = *i;
5164
5165                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5166                         existing++;
5167                         break;
5168                 }
5169
5170                 /* it is possible that we have the path already
5171                  * assigned to a source that has not yet been written
5172                  * (ie. the write source for a diskstream). we have to
5173                  * check this in order to make sure that our candidate
5174                  * path isn't used again, because that can lead to
5175                  * two Sources point to the same file with different
5176                  * notions of their removability.
5177                  */
5178
5179
5180                 string possible_path = Glib::build_filename (spath, name);
5181
5182                 if (audio_source_by_path_and_channel (possible_path, 0)) {
5183                         existing++;
5184                         break;
5185                 }
5186         }
5187
5188         return (existing == 0);
5189 }
5190
5191 string
5192 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)
5193 {
5194         ostringstream sstr;
5195         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5196
5197         if (Profile->get_trx() && destructive) {
5198                 sstr << 'T';
5199                 sstr << setfill ('0') << setw (4) << cnt;
5200                 sstr << legalized_base;
5201         } else {
5202                 sstr << legalized_base;
5203
5204                 if (take_required || related_exists) {
5205                         sstr << '-';
5206                         sstr << cnt;
5207                 }
5208         }
5209
5210         if (nchan == 2) {
5211                 if (chan == 0) {
5212                         sstr << "%L";
5213                 } else {
5214                         sstr << "%R";
5215                 }
5216         } else if (nchan > 2) {
5217                 if (nchan < 26) {
5218                         sstr << '%';
5219                         sstr << 'a' + chan;
5220                 } else {
5221                         /* XXX what? more than 26 channels! */
5222                         sstr << '%';
5223                         sstr << chan+1;
5224                 }
5225         }
5226
5227         sstr << ext;
5228
5229         return sstr.str();
5230 }
5231
5232 /** Return a unique name based on \a base for a new internal audio source */
5233 string
5234 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5235 {
5236         uint32_t cnt;
5237         string possible_name;
5238         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5239         string legalized;
5240         bool some_related_source_name_exists = false;
5241
5242         legalized = legalize_for_path (base);
5243
5244         // Find a "version" of the base name that doesn't exist in any of the possible directories.
5245
5246         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5247
5248                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5249
5250                 if (audio_source_name_is_unique (possible_name)) {
5251                         break;
5252                 }
5253
5254                 some_related_source_name_exists = true;
5255
5256                 if (cnt > limit) {
5257                         error << string_compose(
5258                                         _("There are already %1 recordings for %2, which I consider too many."),
5259                                         limit, base) << endmsg;
5260                         destroy ();
5261                         throw failed_constructor();
5262                 }
5263         }
5264
5265         /* We've established that the new name does not exist in any session
5266          * directory, so now find out which one we should use for this new
5267          * audio source.
5268          */
5269
5270         SessionDirectory sdir (get_best_session_directory_for_new_audio());
5271
5272         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5273
5274         return s;
5275 }
5276
5277 /** Return a unique name based on `base` for a new internal MIDI source */
5278 string
5279 Session::new_midi_source_path (const string& base, bool need_lock)
5280 {
5281         string possible_path;
5282         string possible_name;
5283
5284         possible_name = legalize_for_path (base);
5285
5286         // Find a "version" of the file name that doesn't exist in any of the possible directories.
5287         std::vector<string> sdirs = source_search_path(DataType::MIDI);
5288
5289         /* - the main session folder is the first in the vector.
5290          * - after checking all locations for file-name uniqueness,
5291          *   we keep the one from the last iteration as new file name
5292          * - midi files are small and should just be kept in the main session-folder
5293          *
5294          * -> reverse the array, check main session folder last and use that as location
5295          *    for MIDI files.
5296          */
5297         std::reverse(sdirs.begin(), sdirs.end());
5298
5299         while (true) {
5300                 possible_name = bump_name_once (possible_name, '-');
5301
5302                 vector<space_and_path>::iterator i;
5303                 uint32_t existing = 0;
5304
5305                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5306
5307                         possible_path = Glib::build_filename (*i, possible_name + ".mid");
5308
5309                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5310                                 existing++;
5311                         }
5312
5313                         if (midi_source_by_path (possible_path, need_lock)) {
5314                                 existing++;
5315                         }
5316                 }
5317
5318                 if (possible_path.size () >= PATH_MAX) {
5319                         error << string_compose(
5320                                         _("There are already many recordings for %1, resulting in a too long file-path %2."),
5321                                         base, possible_path) << endmsg;
5322                         destroy ();
5323                         return 0;
5324                 }
5325
5326                 if (existing == 0) {
5327                         break;
5328                 }
5329         }
5330
5331         /* No need to "find best location" for software/app-based RAID, because
5332            MIDI is so small that we always put it in the same place.
5333         */
5334
5335         return possible_path;
5336 }
5337
5338
5339 /** Create a new within-session audio source */
5340 boost::shared_ptr<AudioFileSource>
5341 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5342 {
5343         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5344
5345         if (!path.empty()) {
5346                 return boost::dynamic_pointer_cast<AudioFileSource> (
5347                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, sample_rate(), true, true));
5348         } else {
5349                 throw failed_constructor ();
5350         }
5351 }
5352
5353 /** Create a new within-session MIDI source */
5354 boost::shared_ptr<MidiSource>
5355 Session::create_midi_source_for_session (string const & basic_name)
5356 {
5357         const string path = new_midi_source_path (basic_name);
5358
5359         if (!path.empty()) {
5360                 return boost::dynamic_pointer_cast<SMFSource> (
5361                         SourceFactory::createWritable (
5362                                 DataType::MIDI, *this, path, false, sample_rate()));
5363         } else {
5364                 throw failed_constructor ();
5365         }
5366 }
5367
5368 /** Create a new within-session MIDI source */
5369 boost::shared_ptr<MidiSource>
5370 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5371 {
5372         /* the caller passes in the track the source will be used in,
5373            so that we can keep the numbering sane.
5374
5375            Rationale: a track with the name "Foo" that has had N
5376            captures carried out so far will ALREADY have a write source
5377            named "Foo-N+1.mid" waiting to be used for the next capture.
5378
5379            If we call new_midi_source_name() we will get "Foo-N+2". But
5380            there is no region corresponding to "Foo-N+1", so when
5381            "Foo-N+2" appears in the track, the gap presents the user
5382            with odd behaviour - why did it skip past Foo-N+1?
5383
5384            We could explain this to the user in some odd way, but
5385            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5386            use "Foo-N+1" here.
5387
5388            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5389         */
5390
5391         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5392         assert (mt);
5393         std::string name = track->steal_write_source_name ();
5394
5395         if (name.empty()) {
5396                 return boost::shared_ptr<MidiSource>();
5397         }
5398
5399         /* MIDI files are small, just put them in the first location of the
5400            session source search path.
5401         */
5402
5403         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5404
5405         return boost::dynamic_pointer_cast<SMFSource> (
5406                 SourceFactory::createWritable (
5407                         DataType::MIDI, *this, path, false, sample_rate()));
5408 }
5409
5410 bool
5411 Session::playlist_is_active (boost::shared_ptr<Playlist> playlist)
5412 {
5413         Glib::Threads::Mutex::Lock lm (_playlists->lock);
5414         for (SessionPlaylists::List::iterator i = _playlists->playlists.begin(); i != _playlists->playlists.end(); i++) {
5415                 if ( (*i) == playlist ) {
5416                         return true;
5417                 }
5418         }
5419         return false;
5420 }
5421
5422 void
5423 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5424 {
5425         if (playlist->hidden()) {
5426                 return;
5427         }
5428
5429         _playlists->add (playlist);
5430
5431         if (unused) {
5432                 playlist->release();
5433         }
5434
5435         set_dirty();
5436 }
5437
5438 void
5439 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5440 {
5441         if (deletion_in_progress ()) {
5442                 return;
5443         }
5444
5445         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5446
5447         if (!playlist) {
5448                 return;
5449         }
5450
5451         _playlists->remove (playlist);
5452
5453         set_dirty();
5454 }
5455
5456 void
5457 Session::set_audition (boost::shared_ptr<Region> r)
5458 {
5459         pending_audition_region = r;
5460         add_post_transport_work (PostTransportAudition);
5461         _butler->schedule_transport_work ();
5462 }
5463
5464 void
5465 Session::audition_playlist ()
5466 {
5467         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5468         ev->region.reset ();
5469         queue_event (ev);
5470 }
5471
5472
5473 void
5474 Session::register_lua_function (
5475                 const std::string& name,
5476                 const std::string& script,
5477                 const LuaScriptParamList& args
5478                 )
5479 {
5480         Glib::Threads::Mutex::Lock lm (lua_lock);
5481
5482         lua_State* L = lua.getState();
5483
5484         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5485         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5486         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5487                 if ((*i)->optional && !(*i)->is_set) { continue; }
5488                 tbl_arg[(*i)->name] = (*i)->value;
5489         }
5490         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5491         lm.release();
5492
5493         LuaScriptsChanged (); /* EMIT SIGNAL */
5494         set_dirty();
5495 }
5496
5497 void
5498 Session::unregister_lua_function (const std::string& name)
5499 {
5500         Glib::Threads::Mutex::Lock lm (lua_lock);
5501         (*_lua_del)(name); // throws luabridge::LuaException
5502         lua.collect_garbage ();
5503         lm.release();
5504
5505         LuaScriptsChanged (); /* EMIT SIGNAL */
5506         set_dirty();
5507 }
5508
5509 std::vector<std::string>
5510 Session::registered_lua_functions ()
5511 {
5512         Glib::Threads::Mutex::Lock lm (lua_lock);
5513         std::vector<std::string> rv;
5514
5515         try {
5516                 luabridge::LuaRef list ((*_lua_list)());
5517                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5518                         if (!i.key ().isString ()) { assert(0); continue; }
5519                         rv.push_back (i.key ().cast<std::string> ());
5520                 }
5521         } catch (...) { }
5522         return rv;
5523 }
5524
5525 #ifndef NDEBUG
5526 static void _lua_print (std::string s) {
5527         std::cout << "SessionLua: " << s << "\n";
5528 }
5529 #endif
5530
5531 void
5532 Session::try_run_lua (pframes_t nframes)
5533 {
5534         if (_n_lua_scripts == 0) return;
5535         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5536         if (tm.locked ()) {
5537                 try { (*_lua_run)(nframes); } catch (...) { }
5538                 lua.collect_garbage_step ();
5539         }
5540 }
5541
5542 void
5543 Session::setup_lua ()
5544 {
5545 #ifndef NDEBUG
5546         lua.Print.connect (&_lua_print);
5547 #endif
5548         lua.sandbox (true);
5549         lua.do_command (
5550                         "function ArdourSession ()"
5551                         "  local self = { scripts = {}, instances = {} }"
5552                         ""
5553                         "  local remove = function (n)"
5554                         "   self.scripts[n] = nil"
5555                         "   self.instances[n] = nil"
5556                         "   Session:scripts_changed()" // call back
5557                         "  end"
5558                         ""
5559                         "  local addinternal = function (n, f, a)"
5560                         "   assert(type(n) == 'string', 'function-name must be string')"
5561                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5562                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5563                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5564                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5565                         "   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 }"
5566                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5567                         "   Session:scripts_changed()" // call back
5568                         "  end"
5569                         ""
5570                         "  local add = function (n, b, a)"
5571                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5572                         "   load (b)()" // assigns f
5573                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5574                         "   addinternal (n, load(f), a)"
5575                         "  end"
5576                         ""
5577                         "  local run = function (...)"
5578                         "   for n, s in pairs (self.instances) do"
5579                         "     local status, err = pcall (s, ...)"
5580                         "     if not status then"
5581                         "       print ('fn \"'.. n .. '\": ', err)"
5582                         "       remove (n)"
5583                         "      end"
5584                         "   end"
5585                         "   collectgarbage()"
5586                         "  end"
5587                         ""
5588                         "  local cleanup = function ()"
5589                         "   self.scripts = nil"
5590                         "   self.instances = nil"
5591                         "  end"
5592                         ""
5593                         "  local list = function ()"
5594                         "   local rv = {}"
5595                         "   for n, _ in pairs (self.scripts) do"
5596                         "     rv[n] = true"
5597                         "   end"
5598                         "   return rv"
5599                         "  end"
5600                         ""
5601                         "  local function basic_serialize (o)"
5602                         "    if type(o) == \"number\" then"
5603                         "     return tostring(o)"
5604                         "    else"
5605                         "     return string.format(\"%q\", o)"
5606                         "    end"
5607                         "  end"
5608                         ""
5609                         "  local function serialize (name, value)"
5610                         "   local rv = name .. ' = '"
5611                         "   collectgarbage()"
5612                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5613                         "    return rv .. basic_serialize(value) .. ' '"
5614                         "   elseif type(value) == \"table\" then"
5615                         "    rv = rv .. '{} '"
5616                         "    for k,v in pairs(value) do"
5617                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5618                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5619                         "     collectgarbage()" // string concatenation allocates a new string :(
5620                         "    end"
5621                         "    return rv;"
5622                         "   elseif type(value) == \"function\" then"
5623                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5624                         "   else"
5625                         "    error('cannot save a ' .. type(value))"
5626                         "   end"
5627                         "  end"
5628                         ""
5629                         ""
5630                         "  local save = function ()"
5631                         "   return (serialize('scripts', self.scripts))"
5632                         "  end"
5633                         ""
5634                         "  local restore = function (state)"
5635                         "   self.scripts = {}"
5636                         "   load (state)()"
5637                         "   for n, s in pairs (scripts) do"
5638                         "    addinternal (n, load(s['f']), s['a'])"
5639                         "   end"
5640                         "  end"
5641                         ""
5642                         " return { run = run, add = add, remove = remove,"
5643                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5644                         " end"
5645                         " "
5646                         " sess = ArdourSession ()"
5647                         " ArdourSession = nil"
5648                         " "
5649                         "function ardour () end"
5650                         );
5651
5652         lua_State* L = lua.getState();
5653
5654         try {
5655                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5656                 lua.do_command ("sess = nil"); // hide it.
5657                 lua.do_command ("collectgarbage()");
5658
5659                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5660                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5661                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5662                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5663                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5664                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5665                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5666         } catch (luabridge::LuaException const& e) {
5667                 fatal << string_compose (_("programming error: %1"),
5668                                 std::string ("Failed to setup session Lua interpreter") + e.what ())
5669                         << endmsg;
5670                 abort(); /*NOTREACHED*/
5671         } catch (...) {
5672                 fatal << string_compose (_("programming error: %1"),
5673                                 X_("Failed to setup session Lua interpreter"))
5674                         << endmsg;
5675                 abort(); /*NOTREACHED*/
5676         }
5677
5678         lua_mlock (L, 1);
5679         LuaBindings::stddef (L);
5680         LuaBindings::common (L);
5681         LuaBindings::dsp (L);
5682         lua_mlock (L, 0);
5683         luabridge::push <Session *> (L, this);
5684         lua_setglobal (L, "Session");
5685 }
5686
5687 void
5688 Session::scripts_changed ()
5689 {
5690         assert (!lua_lock.trylock()); // must hold lua_lock
5691
5692         try {
5693                 luabridge::LuaRef list ((*_lua_list)());
5694                 int cnt = 0;
5695                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5696                         if (!i.key ().isString ()) { assert(0); continue; }
5697                         ++cnt;
5698                 }
5699                 _n_lua_scripts = cnt;
5700         } catch (luabridge::LuaException const& e) {
5701                 fatal << string_compose (_("programming error: %1"),
5702                                 std::string ("Indexing Lua Session Scripts failed.") + e.what ())
5703                         << endmsg;
5704                 abort(); /*NOTREACHED*/
5705         } catch (...) {
5706                 fatal << string_compose (_("programming error: %1"),
5707                                 X_("Indexing Lua Session Scripts failed."))
5708                         << endmsg;
5709                 abort(); /*NOTREACHED*/
5710         }
5711 }
5712
5713 void
5714 Session::non_realtime_set_audition ()
5715 {
5716         assert (pending_audition_region);
5717         auditioner->audition_region (pending_audition_region);
5718         pending_audition_region.reset ();
5719         AuditionActive (true); /* EMIT SIGNAL */
5720 }
5721
5722 void
5723 Session::audition_region (boost::shared_ptr<Region> r)
5724 {
5725         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5726         ev->region = r;
5727         queue_event (ev);
5728 }
5729
5730 void
5731 Session::cancel_audition ()
5732 {
5733         if (!auditioner) {
5734                 return;
5735         }
5736         if (auditioner->auditioning()) {
5737                 auditioner->cancel_audition ();
5738                 AuditionActive (false); /* EMIT SIGNAL */
5739         }
5740 }
5741
5742 bool
5743 Session::is_auditioning () const
5744 {
5745         /* can be called before we have an auditioner object */
5746         if (auditioner) {
5747                 return auditioner->auditioning();
5748         } else {
5749                 return false;
5750         }
5751 }
5752
5753 void
5754 Session::graph_reordered ()
5755 {
5756         /* don't do this stuff if we are setting up connections
5757            from a set_state() call or creating new tracks. Ditto for deletion.
5758         */
5759
5760         if (inital_connect_or_deletion_in_progress () || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5761                 return;
5762         }
5763
5764         resort_routes ();
5765
5766         /* force all diskstreams to update their capture offset values to
5767          * reflect any changes in latencies within the graph.
5768          */
5769         update_route_latency (false, true);
5770 }
5771
5772 /** @return Number of samples that there is disk space available to write,
5773  *  if known.
5774  */
5775 boost::optional<samplecnt_t>
5776 Session::available_capture_duration ()
5777 {
5778         Glib::Threads::Mutex::Lock lm (space_lock);
5779
5780         if (_total_free_4k_blocks_uncertain) {
5781                 return boost::optional<samplecnt_t> ();
5782         }
5783
5784         float sample_bytes_on_disk = 4.0; // keep gcc happy
5785
5786         switch (config.get_native_file_data_format()) {
5787         case FormatFloat:
5788                 sample_bytes_on_disk = 4.0;
5789                 break;
5790
5791         case FormatInt24:
5792                 sample_bytes_on_disk = 3.0;
5793                 break;
5794
5795         case FormatInt16:
5796                 sample_bytes_on_disk = 2.0;
5797                 break;
5798
5799         default:
5800                 /* impossible, but keep some gcc versions happy */
5801                 fatal << string_compose (_("programming error: %1"),
5802                                          X_("illegal native file data format"))
5803                       << endmsg;
5804                 abort(); /*NOTREACHED*/
5805         }
5806
5807         double scale = 4096.0 / sample_bytes_on_disk;
5808
5809         if (_total_free_4k_blocks * scale > (double) max_samplecnt) {
5810                 return max_samplecnt;
5811         }
5812
5813         return (samplecnt_t) floor (_total_free_4k_blocks * scale);
5814 }
5815
5816 void
5817 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5818 {
5819         {
5820                 RCUWriter<BundleList> writer (_bundles);
5821                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5822                 b->push_back (bundle);
5823         }
5824
5825         if (emit_signal) {
5826                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5827         }
5828
5829         set_dirty();
5830 }
5831
5832 void
5833 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5834 {
5835         bool removed = false;
5836
5837         {
5838                 RCUWriter<BundleList> writer (_bundles);
5839                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5840                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5841
5842                 if (i != b->end()) {
5843                         b->erase (i);
5844                         removed = true;
5845                 }
5846         }
5847
5848         if (removed) {
5849                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5850         }
5851
5852         set_dirty();
5853 }
5854
5855 boost::shared_ptr<Bundle>
5856 Session::bundle_by_name (string name) const
5857 {
5858         boost::shared_ptr<BundleList> b = _bundles.reader ();
5859
5860         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5861                 if ((*i)->name() == name) {
5862                         return* i;
5863                 }
5864         }
5865
5866         return boost::shared_ptr<Bundle> ();
5867 }
5868
5869 void
5870 Session::tempo_map_changed (const PropertyChange&)
5871 {
5872         clear_clicks ();
5873
5874         _playlists->update_after_tempo_map_change ();
5875
5876         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5877
5878         set_dirty ();
5879 }
5880
5881 void
5882 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5883 {
5884         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5885                 (*i)->recompute_samples_from_beat ();
5886         }
5887 }
5888
5889 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5890  * the given count with the current block size.
5891  */
5892 void
5893 Session::ensure_buffers (ChanCount howmany)
5894 {
5895         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5896 }
5897
5898 void
5899 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5900 {
5901         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5902                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5903         }
5904 }
5905
5906 uint32_t
5907 Session::next_insert_id ()
5908 {
5909         /* this doesn't really loop forever. just think about it */
5910
5911         while (true) {
5912                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5913                         if (!insert_bitset[n]) {
5914                                 insert_bitset[n] = true;
5915                                 return n;
5916
5917                         }
5918                 }
5919
5920                 /* none available, so resize and try again */
5921
5922                 insert_bitset.resize (insert_bitset.size() + 16, false);
5923         }
5924 }
5925
5926 uint32_t
5927 Session::next_send_id ()
5928 {
5929         /* this doesn't really loop forever. just think about it */
5930
5931         while (true) {
5932                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5933                         if (!send_bitset[n]) {
5934                                 send_bitset[n] = true;
5935                                 return n;
5936
5937                         }
5938                 }
5939
5940                 /* none available, so resize and try again */
5941
5942                 send_bitset.resize (send_bitset.size() + 16, false);
5943         }
5944 }
5945
5946 uint32_t
5947 Session::next_aux_send_id ()
5948 {
5949         /* this doesn't really loop forever. just think about it */
5950
5951         while (true) {
5952                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5953                         if (!aux_send_bitset[n]) {
5954                                 aux_send_bitset[n] = true;
5955                                 return n;
5956
5957                         }
5958                 }
5959
5960                 /* none available, so resize and try again */
5961
5962                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5963         }
5964 }
5965
5966 uint32_t
5967 Session::next_return_id ()
5968 {
5969         /* this doesn't really loop forever. just think about it */
5970
5971         while (true) {
5972                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5973                         if (!return_bitset[n]) {
5974                                 return_bitset[n] = true;
5975                                 return n;
5976
5977                         }
5978                 }
5979
5980                 /* none available, so resize and try again */
5981
5982                 return_bitset.resize (return_bitset.size() + 16, false);
5983         }
5984 }
5985
5986 void
5987 Session::mark_send_id (uint32_t id)
5988 {
5989         if (id >= send_bitset.size()) {
5990                 send_bitset.resize (id+16, false);
5991         }
5992         if (send_bitset[id]) {
5993                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5994         }
5995         send_bitset[id] = true;
5996 }
5997
5998 void
5999 Session::mark_aux_send_id (uint32_t id)
6000 {
6001         if (id >= aux_send_bitset.size()) {
6002                 aux_send_bitset.resize (id+16, false);
6003         }
6004         if (aux_send_bitset[id]) {
6005                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
6006         }
6007         aux_send_bitset[id] = true;
6008 }
6009
6010 void
6011 Session::mark_return_id (uint32_t id)
6012 {
6013         if (id >= return_bitset.size()) {
6014                 return_bitset.resize (id+16, false);
6015         }
6016         if (return_bitset[id]) {
6017                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
6018         }
6019         return_bitset[id] = true;
6020 }
6021
6022 void
6023 Session::mark_insert_id (uint32_t id)
6024 {
6025         if (id >= insert_bitset.size()) {
6026                 insert_bitset.resize (id+16, false);
6027         }
6028         if (insert_bitset[id]) {
6029                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
6030         }
6031         insert_bitset[id] = true;
6032 }
6033
6034 void
6035 Session::unmark_send_id (uint32_t id)
6036 {
6037         if (id < send_bitset.size()) {
6038                 send_bitset[id] = false;
6039         }
6040 }
6041
6042 void
6043 Session::unmark_aux_send_id (uint32_t id)
6044 {
6045         if (id < aux_send_bitset.size()) {
6046                 aux_send_bitset[id] = false;
6047         }
6048 }
6049
6050 void
6051 Session::unmark_return_id (uint32_t id)
6052 {
6053         if (deletion_in_progress ()) {
6054                 return;
6055         }
6056         if (id < return_bitset.size()) {
6057                 return_bitset[id] = false;
6058         }
6059 }
6060
6061 void
6062 Session::unmark_insert_id (uint32_t id)
6063 {
6064         if (id < insert_bitset.size()) {
6065                 insert_bitset[id] = false;
6066         }
6067 }
6068
6069 void
6070 Session::reset_native_file_format ()
6071 {
6072         boost::shared_ptr<RouteList> rl = routes.reader ();
6073
6074         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6075                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6076                 if (tr) {
6077                         /* don't save state as we do this, there's no point */
6078                         _state_of_the_state = StateOfTheState (_state_of_the_state | InCleanup);
6079                         tr->reset_write_sources (false);
6080                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
6081                 }
6082         }
6083 }
6084
6085 bool
6086 Session::route_name_unique (string n) const
6087 {
6088         boost::shared_ptr<RouteList> r = routes.reader ();
6089
6090         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6091                 if ((*i)->name() == n) {
6092                         return false;
6093                 }
6094         }
6095
6096         return true;
6097 }
6098
6099 bool
6100 Session::route_name_internal (string n) const
6101 {
6102         if (auditioner && auditioner->name() == n) {
6103                 return true;
6104         }
6105
6106         if (_click_io && _click_io->name() == n) {
6107                 return true;
6108         }
6109
6110         return false;
6111 }
6112
6113 int
6114 Session::freeze_all (InterThreadInfo& itt)
6115 {
6116         boost::shared_ptr<RouteList> r = routes.reader ();
6117
6118         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6119
6120                 boost::shared_ptr<Track> t;
6121
6122                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
6123                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
6124                            of every track.
6125                         */
6126                         t->freeze_me (itt);
6127                 }
6128         }
6129
6130         return 0;
6131 }
6132
6133 boost::shared_ptr<Region>
6134 Session::write_one_track (Track& track, samplepos_t start, samplepos_t end,
6135                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
6136                           InterThreadInfo& itt,
6137                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
6138                           bool for_export, bool for_freeze)
6139 {
6140         boost::shared_ptr<Region> result;
6141         boost::shared_ptr<Playlist> playlist;
6142         boost::shared_ptr<Source> source;
6143         ChanCount diskstream_channels (track.n_channels());
6144         samplepos_t position;
6145         samplecnt_t this_chunk;
6146         samplepos_t to_do;
6147         samplepos_t latency_skip;
6148         BufferSet buffers;
6149         samplepos_t len = end - start;
6150         bool need_block_size_reset = false;
6151         ChanCount const max_proc = track.max_processor_streams ();
6152         string legal_playlist_name;
6153         string possible_path;
6154
6155         DataType data_type = track.data_type();
6156
6157         if (end <= start) {
6158                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
6159                                          end, start) << endmsg;
6160                 return result;
6161         }
6162
6163         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
6164                         include_endpoint, for_export, for_freeze);
6165
6166         if (data_type == DataType::MIDI && endpoint && !for_export && !for_freeze && diskstream_channels.n(DataType::AUDIO) > 0) {
6167                 data_type = DataType::AUDIO;
6168         }
6169
6170         if (diskstream_channels.n(data_type) < 1) {
6171                 error << _("Cannot write a range with no data.") << endmsg;
6172                 return result;
6173         }
6174
6175         // block all process callback handling
6176
6177         block_processing ();
6178
6179         {
6180                 // synchronize with AudioEngine::process_callback()
6181                 // make sure processing is not currently running
6182                 // and processing_blocked() is honored before
6183                 // acquiring thread buffers
6184                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6185         }
6186
6187         _bounce_processing_active = true;
6188
6189         /* call tree *MUST* hold route_lock */
6190
6191         if ((playlist = track.playlist()) == 0) {
6192                 goto out;
6193         }
6194
6195         legal_playlist_name = "(bounce)" + legalize_for_path (playlist->name());
6196
6197         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(data_type); ++chan_n) {
6198
6199                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6200                 string path = ((data_type == DataType::AUDIO)
6201                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6202                                : new_midi_source_path (legal_playlist_name));
6203
6204                 if (path.empty()) {
6205                         goto out;
6206                 }
6207
6208                 try {
6209                         source = SourceFactory::createWritable (data_type, *this, path, false, sample_rate());
6210                 }
6211
6212                 catch (failed_constructor& err) {
6213                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6214                         goto out;
6215                 }
6216
6217                 srcs.push_back (source);
6218         }
6219
6220         /* tell redirects that care that we are about to use a much larger
6221          * blocksize. this will flush all plugins too, so that they are ready
6222          * to be used for this process.
6223          */
6224
6225         need_block_size_reset = true;
6226         track.set_block_size (bounce_chunk_size);
6227         _engine.main_thread()->get_buffers ();
6228
6229         position = start;
6230         to_do = len;
6231         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6232
6233         /* create a set of reasonably-sized buffers */
6234         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6235                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6236         }
6237         buffers.set_count (max_proc);
6238
6239         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6240                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6241                 boost::shared_ptr<MidiSource> ms;
6242                 if (afs) {
6243                         afs->prepare_for_peakfile_writes ();
6244                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6245                         Source::Lock lock(ms->mutex());
6246                         ms->mark_streaming_write_started(lock);
6247                 }
6248         }
6249
6250         while (to_do && !itt.cancel) {
6251
6252                 this_chunk = min (to_do, bounce_chunk_size);
6253
6254                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6255                         goto out;
6256                 }
6257
6258                 start += this_chunk;
6259                 to_do -= this_chunk;
6260                 itt.progress = (float) (1.0 - ((double) to_do / len));
6261
6262                 if (latency_skip >= bounce_chunk_size) {
6263                         latency_skip -= bounce_chunk_size;
6264                         continue;
6265                 }
6266
6267                 const samplecnt_t current_chunk = this_chunk - latency_skip;
6268
6269                 uint32_t n = 0;
6270                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6271                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6272                         boost::shared_ptr<MidiSource> ms;
6273
6274                         if (afs) {
6275                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6276                                         goto out;
6277                                 }
6278                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6279                                 Source::Lock lock(ms->mutex());
6280
6281                                 const MidiBuffer& buf = buffers.get_midi(0);
6282                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6283                                         Evoral::Event<samplepos_t> ev = *i;
6284                                         if (!endpoint || for_export) {
6285                                                 ev.set_time(ev.time() - position);
6286                                         }
6287                                         ms->append_event_samples(lock, ev, ms->natural_position());
6288                                 }
6289                         }
6290                 }
6291                 latency_skip = 0;
6292         }
6293
6294         /* post-roll, pick up delayed processor output */
6295         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6296
6297         while (latency_skip && !itt.cancel) {
6298                 this_chunk = min (latency_skip, bounce_chunk_size);
6299                 latency_skip -= this_chunk;
6300
6301                 buffers.silence (this_chunk, 0);
6302                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6303
6304                 uint32_t n = 0;
6305                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6306                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6307
6308                         if (afs) {
6309                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6310                                         goto out;
6311                                 }
6312                         }
6313                 }
6314         }
6315
6316         if (!itt.cancel) {
6317
6318                 time_t now;
6319                 struct tm* xnow;
6320                 time (&now);
6321                 xnow = localtime (&now);
6322
6323                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6324                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6325                         boost::shared_ptr<MidiSource> ms;
6326
6327                         if (afs) {
6328                                 afs->update_header (position, *xnow, now);
6329                                 afs->flush_header ();
6330                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6331                                 Source::Lock lock(ms->mutex());
6332                                 ms->mark_streaming_write_completed(lock);
6333                         }
6334                 }
6335
6336                 /* construct a region to represent the bounced material */
6337
6338                 PropertyList plist;
6339
6340                 plist.add (Properties::start, 0);
6341                 plist.add (Properties::whole_file, true);
6342                 plist.add (Properties::length, srcs.front()->length(srcs.front()->natural_position()));
6343                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6344
6345                 result = RegionFactory::create (srcs, plist, true);
6346
6347         }
6348
6349         out:
6350         if (!result) {
6351                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6352                         (*src)->mark_for_remove ();
6353                         (*src)->drop_references ();
6354                 }
6355
6356         } else {
6357                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6358                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6359
6360                         if (afs)
6361                                 afs->done_with_peakfile_writes ();
6362                 }
6363         }
6364
6365         _bounce_processing_active = false;
6366
6367         if (need_block_size_reset) {
6368                 _engine.main_thread()->drop_buffers ();
6369                 track.set_block_size (get_block_size());
6370         }
6371
6372         unblock_processing ();
6373
6374         return result;
6375 }
6376
6377 gain_t*
6378 Session::gain_automation_buffer() const
6379 {
6380         return ProcessThread::gain_automation_buffer ();
6381 }
6382
6383 gain_t*
6384 Session::trim_automation_buffer() const
6385 {
6386         return ProcessThread::trim_automation_buffer ();
6387 }
6388
6389 gain_t*
6390 Session::send_gain_automation_buffer() const
6391 {
6392         return ProcessThread::send_gain_automation_buffer ();
6393 }
6394
6395 gain_t*
6396 Session::scratch_automation_buffer() const
6397 {
6398         return ProcessThread::scratch_automation_buffer ();
6399 }
6400
6401 pan_t**
6402 Session::pan_automation_buffer() const
6403 {
6404         return ProcessThread::pan_automation_buffer ();
6405 }
6406
6407 BufferSet&
6408 Session::get_silent_buffers (ChanCount count)
6409 {
6410         return ProcessThread::get_silent_buffers (count);
6411 }
6412
6413 BufferSet&
6414 Session::get_scratch_buffers (ChanCount count, bool silence)
6415 {
6416         return ProcessThread::get_scratch_buffers (count, silence);
6417 }
6418
6419 BufferSet&
6420 Session::get_noinplace_buffers (ChanCount count)
6421 {
6422         return ProcessThread::get_noinplace_buffers (count);
6423 }
6424
6425 BufferSet&
6426 Session::get_route_buffers (ChanCount count, bool silence)
6427 {
6428         return ProcessThread::get_route_buffers (count, silence);
6429 }
6430
6431
6432 BufferSet&
6433 Session::get_mix_buffers (ChanCount count)
6434 {
6435         return ProcessThread::get_mix_buffers (count);
6436 }
6437
6438 uint32_t
6439 Session::ntracks () const
6440 {
6441         uint32_t n = 0;
6442         boost::shared_ptr<RouteList> r = routes.reader ();
6443
6444         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6445                 if (boost::dynamic_pointer_cast<Track> (*i)) {
6446                         ++n;
6447                 }
6448         }
6449
6450         return n;
6451 }
6452
6453 uint32_t
6454 Session::nbusses () const
6455 {
6456         uint32_t n = 0;
6457         boost::shared_ptr<RouteList> r = routes.reader ();
6458
6459         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6460                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6461                         ++n;
6462                 }
6463         }
6464
6465         return n;
6466 }
6467
6468 uint32_t
6469 Session::nstripables (bool with_monitor) const
6470 {
6471         uint32_t rv = routes.reader()->size ();
6472         rv += _vca_manager->vcas ().size ();
6473
6474         if (with_monitor) {
6475                 return rv;
6476         }
6477
6478         if (_monitor_out) {
6479                 assert (rv > 0);
6480                 --rv;
6481         }
6482         return rv;
6483 }
6484
6485 bool
6486 Session::plot_process_graph (std::string const& file_name) const {
6487         return _process_graph ? _process_graph->plot (file_name) : false;
6488 }
6489
6490 void
6491 Session::add_automation_list(AutomationList *al)
6492 {
6493         automation_lists[al->id()] = al;
6494 }
6495
6496 /** @return true if there is at least one record-enabled track, otherwise false */
6497 bool
6498 Session::have_rec_enabled_track () const
6499 {
6500         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6501 }
6502
6503 bool
6504 Session::have_rec_disabled_track () const
6505 {
6506         return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6507 }
6508
6509 /** Update the state of our rec-enabled tracks flag */
6510 void
6511 Session::update_route_record_state ()
6512 {
6513         boost::shared_ptr<RouteList> rl = routes.reader ();
6514         RouteList::iterator i = rl->begin();
6515         while (i != rl->end ()) {
6516
6517                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6518                                     if (tr && tr->rec_enable_control()->get_value()) {
6519                         break;
6520                 }
6521
6522                 ++i;
6523         }
6524
6525         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6526
6527         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6528
6529         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6530                 RecordStateChanged (); /* EMIT SIGNAL */
6531         }
6532
6533         for (i = rl->begin(); i != rl->end (); ++i) {
6534                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6535                 if (tr && !tr->rec_enable_control()->get_value()) {
6536                         break;
6537                 }
6538         }
6539
6540         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6541
6542         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6543
6544         if (record_status() == Recording && record_arm_state_changed ) {
6545                 RecordArmStateChanged ();
6546         }
6547
6548 }
6549
6550 void
6551 Session::listen_position_changed ()
6552 {
6553         if (loading ()) {
6554                 /* skip duing session restore (already taken care of) */
6555                 return;
6556         }
6557         ProcessorChangeBlocker pcb (this);
6558         boost::shared_ptr<RouteList> r = routes.reader ();
6559         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6560                 (*i)->listen_position_changed ();
6561         }
6562 }
6563
6564 void
6565 Session::solo_control_mode_changed ()
6566 {
6567         if (soloing() || listening()) {
6568                 if (loading()) {
6569                         /* We can't use ::clear_all_solo_state() here because during
6570                            session loading at program startup, that will queue a call
6571                            to rt_clear_all_solo_state() that will not execute until
6572                            AFTER solo states have been established (thus throwing away
6573                            the session's saved solo state). So just explicitly turn
6574                            them all off.
6575                         */
6576                         set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6577                 } else {
6578                         clear_all_solo_state (get_routes());
6579                 }
6580         }
6581 }
6582
6583 /** Called when a property of one of our route groups changes */
6584 void
6585 Session::route_group_property_changed (RouteGroup* rg)
6586 {
6587         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6588 }
6589
6590 /** Called when a route is added to one of our route groups */
6591 void
6592 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6593 {
6594         RouteAddedToRouteGroup (rg, r);
6595 }
6596
6597 /** Called when a route is removed from one of our route groups */
6598 void
6599 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6600 {
6601         update_route_record_state ();
6602         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6603
6604         if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6605                 remove_route_group (*rg);
6606         }
6607 }
6608
6609 boost::shared_ptr<AudioTrack>
6610 Session::get_nth_audio_track (int nth) const
6611 {
6612         boost::shared_ptr<RouteList> rl = routes.reader ();
6613         rl->sort (Stripable::Sorter ());
6614
6615         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6616                 if (!boost::dynamic_pointer_cast<AudioTrack> (*r)) {
6617                         continue;
6618                 }
6619
6620                 if (--nth > 0) {
6621                         continue;
6622                 }
6623                 return boost::dynamic_pointer_cast<AudioTrack> (*r);
6624         }
6625         return boost::shared_ptr<AudioTrack> ();
6626 }
6627
6628 boost::shared_ptr<RouteList>
6629 Session::get_tracks () const
6630 {
6631         boost::shared_ptr<RouteList> rl = routes.reader ();
6632         boost::shared_ptr<RouteList> tl (new RouteList);
6633
6634         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6635                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6636                         assert (!(*r)->is_auditioner()); // XXX remove me
6637                         tl->push_back (*r);
6638                 }
6639         }
6640         return tl;
6641 }
6642
6643 boost::shared_ptr<RouteList>
6644 Session::get_routes_with_regions_at (samplepos_t const p) const
6645 {
6646         boost::shared_ptr<RouteList> r = routes.reader ();
6647         boost::shared_ptr<RouteList> rl (new RouteList);
6648
6649         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6650                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6651                 if (!tr) {
6652                         continue;
6653                 }
6654
6655                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6656                 if (!pl) {
6657                         continue;
6658                 }
6659
6660                 if (pl->has_region_at (p)) {
6661                         rl->push_back (*i);
6662                 }
6663         }
6664
6665         return rl;
6666 }
6667
6668 void
6669 Session::goto_end ()
6670 {
6671         if (_session_range_location) {
6672                 request_locate (_session_range_location->end(), false);
6673         } else {
6674                 request_locate (0, false);
6675         }
6676 }
6677
6678 void
6679 Session::goto_start (bool and_roll)
6680 {
6681         if (_session_range_location) {
6682                 request_locate (_session_range_location->start(), and_roll);
6683         } else {
6684                 request_locate (0, and_roll);
6685         }
6686 }
6687
6688 samplepos_t
6689 Session::current_start_sample () const
6690 {
6691         return _session_range_location ? _session_range_location->start() : 0;
6692 }
6693
6694 samplepos_t
6695 Session::current_end_sample () const
6696 {
6697         return _session_range_location ? _session_range_location->end() : 0;
6698 }
6699
6700 void
6701 Session::set_session_range_location (samplepos_t start, samplepos_t end)
6702 {
6703         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6704         _locations->add (_session_range_location);
6705 }
6706
6707 void
6708 Session::step_edit_status_change (bool yn)
6709 {
6710         bool send = false;
6711
6712         bool val = false;
6713         if (yn) {
6714                 send = (_step_editors == 0);
6715                 val = true;
6716
6717                 _step_editors++;
6718         } else {
6719                 send = (_step_editors == 1);
6720                 val = false;
6721
6722                 if (_step_editors > 0) {
6723                         _step_editors--;
6724                 }
6725         }
6726
6727         if (send) {
6728                 StepEditStatusChange (val);
6729         }
6730 }
6731
6732
6733 void
6734 Session::start_time_changed (samplepos_t old)
6735 {
6736         /* Update the auto loop range to match the session range
6737            (unless the auto loop range has been changed by the user)
6738         */
6739
6740         Location* s = _locations->session_range_location ();
6741         if (s == 0) {
6742                 return;
6743         }
6744
6745         Location* l = _locations->auto_loop_location ();
6746
6747         if (l && l->start() == old) {
6748                 l->set_start (s->start(), true);
6749         }
6750         set_dirty ();
6751 }
6752
6753 void
6754 Session::end_time_changed (samplepos_t old)
6755 {
6756         /* Update the auto loop range to match the session range
6757            (unless the auto loop range has been changed by the user)
6758         */
6759
6760         Location* s = _locations->session_range_location ();
6761         if (s == 0) {
6762                 return;
6763         }
6764
6765         Location* l = _locations->auto_loop_location ();
6766
6767         if (l && l->end() == old) {
6768                 l->set_end (s->end(), true);
6769         }
6770         set_dirty ();
6771 }
6772
6773 std::vector<std::string>
6774 Session::source_search_path (DataType type) const
6775 {
6776         Searchpath sp;
6777
6778         if (session_dirs.size() == 1) {
6779                 switch (type) {
6780                 case DataType::AUDIO:
6781                         sp.push_back (_session_dir->sound_path());
6782                         break;
6783                 case DataType::MIDI:
6784                         sp.push_back (_session_dir->midi_path());
6785                         break;
6786                 }
6787         } else {
6788                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6789                         SessionDirectory sdir (i->path);
6790                         switch (type) {
6791                         case DataType::AUDIO:
6792                                 sp.push_back (sdir.sound_path());
6793                                 break;
6794                         case DataType::MIDI:
6795                                 sp.push_back (sdir.midi_path());
6796                                 break;
6797                         }
6798                 }
6799         }
6800
6801         if (type == DataType::AUDIO) {
6802                 const string sound_path_2X = _session_dir->sound_path_2X();
6803                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6804                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6805                                 sp.push_back (sound_path_2X);
6806                         }
6807                 }
6808         }
6809
6810         // now check the explicit (possibly user-specified) search path
6811
6812         switch (type) {
6813         case DataType::AUDIO:
6814                 sp += Searchpath(config.get_audio_search_path ());
6815                 break;
6816         case DataType::MIDI:
6817                 sp += Searchpath(config.get_midi_search_path ());
6818                 break;
6819         }
6820
6821         return sp;
6822 }
6823
6824 void
6825 Session::ensure_search_path_includes (const string& path, DataType type)
6826 {
6827         Searchpath sp;
6828
6829         if (path == ".") {
6830                 return;
6831         }
6832
6833         switch (type) {
6834         case DataType::AUDIO:
6835                 sp += Searchpath(config.get_audio_search_path ());
6836                 break;
6837         case DataType::MIDI:
6838                 sp += Searchpath (config.get_midi_search_path ());
6839                 break;
6840         }
6841
6842         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6843                 /* No need to add this new directory if it has the same inode as
6844                    an existing one; checking inode rather than name prevents duplicated
6845                    directories when we are using symlinks.
6846
6847                    On Windows, I think we could just do if (*i == path) here.
6848                 */
6849                 if (PBD::equivalent_paths (*i, path)) {
6850                         return;
6851                 }
6852         }
6853
6854         sp += path;
6855
6856         switch (type) {
6857         case DataType::AUDIO:
6858                 config.set_audio_search_path (sp.to_string());
6859                 break;
6860         case DataType::MIDI:
6861                 config.set_midi_search_path (sp.to_string());
6862                 break;
6863         }
6864 }
6865
6866 void
6867 Session::remove_dir_from_search_path (const string& dir, DataType type)
6868 {
6869         Searchpath sp;
6870
6871         switch (type) {
6872         case DataType::AUDIO:
6873                 sp = Searchpath(config.get_audio_search_path ());
6874                 break;
6875         case DataType::MIDI:
6876                 sp = Searchpath (config.get_midi_search_path ());
6877                 break;
6878         }
6879
6880         sp -= dir;
6881
6882         switch (type) {
6883         case DataType::AUDIO:
6884                 config.set_audio_search_path (sp.to_string());
6885                 break;
6886         case DataType::MIDI:
6887                 config.set_midi_search_path (sp.to_string());
6888                 break;
6889         }
6890
6891 }
6892
6893 boost::shared_ptr<Speakers>
6894 Session::get_speakers()
6895 {
6896         return _speakers;
6897 }
6898
6899 list<string>
6900 Session::unknown_processors () const
6901 {
6902         list<string> p;
6903
6904         boost::shared_ptr<RouteList> r = routes.reader ();
6905         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6906                 list<string> t = (*i)->unknown_processors ();
6907                 copy (t.begin(), t.end(), back_inserter (p));
6908         }
6909
6910         p.sort ();
6911         p.unique ();
6912
6913         return p;
6914 }
6915
6916 void
6917 Session::set_worst_io_latencies_x (IOChange, void *)
6918 {
6919                 set_worst_io_latencies ();
6920 }
6921
6922 void
6923 Session::send_latency_compensation_change ()
6924 {
6925         /* As a result of Send::set_output_latency()
6926          * or InternalReturn::set_playback_offset ()
6927          * the send's own latency can change (source track
6928          * is aligned with target bus).
6929          *
6930          * This can only happen be triggered by
6931          * Route::update_signal_latency ()
6932          * when updating the processor latency.
6933          *
6934          * We need to walk the graph again to take those changes into account
6935          * (we should probably recurse or process the graph in a 2 step process).
6936          */
6937         ++_send_latency_changes;
6938 }
6939
6940 bool
6941 Session::update_route_latency (bool playback, bool apply_to_delayline)
6942 {
6943         /* Note: RouteList is process-graph sorted */
6944         boost::shared_ptr<RouteList> r = routes.reader ();
6945
6946         if (playback) {
6947                 /* reverse the list so that we work backwards from the last route to run to the first,
6948                  * this is not needed, but can help to reduce the iterations for aux-sends.
6949                  */
6950                 RouteList* rl = routes.reader().get();
6951                 r.reset (new RouteList (*rl));
6952                 reverse (r->begin(), r->end());
6953         }
6954
6955         bool changed = false;
6956         int bailout = 0;
6957 restart:
6958         _send_latency_changes = 0;
6959         _worst_route_latency = 0;
6960
6961         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6962                 // if (!(*i)->active()) { continue ; } // TODO
6963                 samplecnt_t l;
6964                 if ((*i)->signal_latency () != (l = (*i)->update_signal_latency (apply_to_delayline))) {
6965                         changed = true;
6966                 }
6967                 _worst_route_latency = std::max (l, _worst_route_latency);
6968         }
6969
6970         if (_send_latency_changes > 0) {
6971                 // only 1 extra iteration is needed (we allow only 1 level of aux-sends)
6972                 // BUT..  jack'n'sends'n'bugs
6973                 if (++bailout < 5) {
6974                         cerr << "restarting Session::update_latency. # of send changes: " << _send_latency_changes << " iteration: " << bailout << endl;
6975                         goto restart;
6976                 }
6977         }
6978
6979         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_route_latency, (changed ? "yes" : "no")));
6980
6981         return changed;
6982 }
6983
6984 void
6985 Session::update_latency (bool playback)
6986 {
6987         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6988
6989         if (inital_connect_or_deletion_in_progress () || _adding_routes_in_progress || _route_deletion_in_progress) {
6990                 return;
6991         }
6992         if (!_engine.running()) {
6993                 return;
6994         }
6995
6996         /* Note; RouteList is sorted as process-graph */
6997         boost::shared_ptr<RouteList> r = routes.reader ();
6998
6999         if (playback) {
7000                 /* reverse the list so that we work backwards from the last route to run to the first */
7001                 RouteList* rl = routes.reader().get();
7002                 r.reset (new RouteList (*rl));
7003                 reverse (r->begin(), r->end());
7004         }
7005
7006         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7007                 samplecnt_t latency = (*i)->set_private_port_latencies (playback);
7008                 (*i)->set_public_port_latencies (latency, playback);
7009         }
7010
7011         if (playback) {
7012                 set_worst_output_latency ();
7013                 update_route_latency (true, true);
7014         } else {
7015                 set_worst_input_latency ();
7016                 update_route_latency (false, false);
7017         }
7018
7019         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
7020 }
7021
7022 void
7023 Session::initialize_latencies ()
7024 {
7025         {
7026                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
7027                 update_latency (false);
7028                 update_latency (true);
7029         }
7030
7031         set_worst_io_latencies ();
7032 }
7033
7034 void
7035 Session::set_worst_io_latencies ()
7036 {
7037         set_worst_output_latency ();
7038         set_worst_input_latency ();
7039 }
7040
7041 void
7042 Session::set_worst_output_latency ()
7043 {
7044         if (inital_connect_or_deletion_in_progress ()) {
7045                 return;
7046         }
7047
7048         _worst_output_latency = 0;
7049
7050         if (!_engine.running()) {
7051                 return;
7052         }
7053
7054         boost::shared_ptr<RouteList> r = routes.reader ();
7055
7056         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7057                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
7058         }
7059
7060         _worst_output_latency = max (_worst_output_latency, _click_io->latency());
7061
7062         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
7063 }
7064
7065 void
7066 Session::set_worst_input_latency ()
7067 {
7068         if (inital_connect_or_deletion_in_progress ()) {
7069                 return;
7070         }
7071
7072         _worst_input_latency = 0;
7073
7074         if (!_engine.running()) {
7075                 return;
7076         }
7077
7078         boost::shared_ptr<RouteList> r = routes.reader ();
7079
7080         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7081                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
7082         }
7083
7084         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
7085 }
7086
7087 void
7088 Session::update_latency_compensation (bool force_whole_graph)
7089 {
7090         if (inital_connect_or_deletion_in_progress ()) {
7091                 return;
7092         }
7093         /* this lock is not usually contended, but under certain conditions,
7094          * update_latency_compensation may be called concurrently.
7095          * e.g. drag/drop copy a latent plugin while rolling.
7096          * GUI thread (via route_processors_changed) and
7097          * auto_connect_thread_run may race.
7098          */
7099         Glib::Threads::Mutex::Lock lx (_update_latency_lock, Glib::Threads::TRY_LOCK);
7100         if (!lx.locked()) {
7101                 /* no need to do this twice */
7102                 return;
7103         }
7104
7105         bool some_track_latency_changed = update_route_latency (false, false);
7106
7107         if (some_track_latency_changed || force_whole_graph)  {
7108                 _engine.update_latencies ();
7109                 /* above call will ask the backend up update its latencies, which
7110                  * eventually will trigger  AudioEngine::latency_callback () and
7111                  * call Session::update_latency ()
7112                  */
7113         } else {
7114                 boost::shared_ptr<RouteList> r = routes.reader ();
7115                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7116                         (*i)->apply_latency_compensation ();
7117                 }
7118         }
7119 }
7120
7121 char
7122 Session::session_name_is_legal (const string& path)
7123 {
7124         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
7125
7126         for (int i = 0; illegal_chars[i]; ++i) {
7127                 if (path.find (illegal_chars[i]) != string::npos) {
7128                         return illegal_chars[i];
7129                 }
7130         }
7131
7132         return 0;
7133 }
7134
7135 void
7136 Session::notify_presentation_info_change ()
7137 {
7138         if (deletion_in_progress()) {
7139                 return;
7140         }
7141
7142         reassign_track_numbers();
7143
7144 #ifdef USE_TRACKS_CODE_FEATURES
7145         /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
7146          * if track order has been changed by user
7147          */
7148         reconnect_existing_routes(true, true);
7149 #endif
7150
7151 }
7152
7153 bool
7154 Session::operation_in_progress (GQuark op) const
7155 {
7156         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
7157 }
7158
7159 boost::shared_ptr<Port>
7160 Session::ltc_output_port () const
7161 {
7162         return _ltc_output ? _ltc_output->nth (0) : boost::shared_ptr<Port> ();
7163 }
7164
7165 void
7166 Session::reconnect_ltc_output ()
7167 {
7168         if (_ltc_output) {
7169
7170                 string src = Config->get_ltc_output_port();
7171
7172                 _ltc_output->disconnect (this);
7173
7174                 if (src != _("None") && !src.empty())  {
7175                         _ltc_output->nth (0)->connect (src);
7176                 }
7177         }
7178 }
7179
7180 void
7181 Session::set_range_selection (samplepos_t start, samplepos_t end)
7182 {
7183         _range_selection = Evoral::Range<samplepos_t> (start, end);
7184 #ifdef USE_TRACKS_CODE_FEATURES
7185         follow_playhead_priority ();
7186 #endif
7187 }
7188
7189 void
7190 Session::set_object_selection (samplepos_t start, samplepos_t end)
7191 {
7192         _object_selection = Evoral::Range<samplepos_t> (start, end);
7193 #ifdef USE_TRACKS_CODE_FEATURES
7194         follow_playhead_priority ();
7195 #endif
7196 }
7197
7198 void
7199 Session::clear_range_selection ()
7200 {
7201         _range_selection = Evoral::Range<samplepos_t> (-1,-1);
7202 #ifdef USE_TRACKS_CODE_FEATURES
7203         follow_playhead_priority ();
7204 #endif
7205 }
7206
7207 void
7208 Session::clear_object_selection ()
7209 {
7210         _object_selection = Evoral::Range<samplepos_t> (-1,-1);
7211 #ifdef USE_TRACKS_CODE_FEATURES
7212         follow_playhead_priority ();
7213 #endif
7214 }
7215
7216 void
7217 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
7218                 const ChanCount& input_start,
7219                 const ChanCount& output_start,
7220                 const ChanCount& input_offset,
7221                 const ChanCount& output_offset)
7222 {
7223         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7224         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7225                                 input_start, output_start,
7226                                 input_offset, output_offset));
7227
7228         auto_connect_thread_wakeup ();
7229 }
7230
7231 void
7232 Session::auto_connect_thread_wakeup ()
7233 {
7234         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7235                 pthread_cond_signal (&_auto_connect_cond);
7236                 pthread_mutex_unlock (&_auto_connect_mutex);
7237         }
7238 }
7239
7240 void
7241 Session::queue_latency_recompute ()
7242 {
7243         g_atomic_int_inc (&_latency_recompute_pending);
7244         auto_connect_thread_wakeup ();
7245 }
7246
7247 void
7248 Session::auto_connect (const AutoConnectRequest& ar)
7249 {
7250         boost::shared_ptr<Route> route = ar.route.lock();
7251
7252         if (!route) { return; }
7253
7254         if (!IO::connecting_legal) {
7255                 return;
7256         }
7257
7258         /* If both inputs and outputs are auto-connected to physical ports,
7259          * use the max of input and output offsets to ensure auto-connected
7260          * port numbers always match up (e.g. the first audio input and the
7261          * first audio output of the route will have the same physical
7262          * port number).  Otherwise just use the lowest input or output
7263          * offset possible.
7264          */
7265
7266         const bool in_out_physical =
7267                 (Config->get_input_auto_connect() & AutoConnectPhysical)
7268                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7269                 && ar.connect_inputs;
7270
7271         const ChanCount in_offset = in_out_physical
7272                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7273                 : ar.input_offset;
7274
7275         const ChanCount out_offset = in_out_physical
7276                 ? ChanCount::max(ar.input_offset, ar.output_offset)
7277                 : ar.output_offset;
7278
7279         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7280                 vector<string> physinputs;
7281                 vector<string> physoutputs;
7282
7283
7284                 /* for connecting track inputs we only want MIDI ports marked
7285                  * for "music".
7286                  */
7287
7288                 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7289
7290                 if (!physinputs.empty() && ar.connect_inputs) {
7291                         uint32_t nphysical_in = physinputs.size();
7292
7293                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7294                                 string port;
7295
7296                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7297                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7298                                 }
7299
7300                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7301                                         break;
7302                                 }
7303                         }
7304                 }
7305
7306                 if (!physoutputs.empty()) {
7307                         uint32_t nphysical_out = physoutputs.size();
7308                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7309                                 string port;
7310
7311                                 /* Waves Tracks:
7312                                  * do not create new connections if we reached the limit of physical outputs
7313                                  * in Multi Out mode
7314                                  */
7315                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7316                                                 ARDOUR::Profile->get_trx () &&
7317                                                 ar.output_offset.get(*t) == nphysical_out ) {
7318                                         break;
7319                                 }
7320
7321                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7322                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7323                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7324                                         /* master bus is audio only */
7325                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7326                                                 port = _master_out->input()->ports().port(*t,
7327                                                                 i % _master_out->input()->n_ports().get(*t))->name();
7328                                         }
7329                                 }
7330
7331                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7332                                         break;
7333                                 }
7334                         }
7335                 }
7336         }
7337 }
7338
7339 void
7340 Session::auto_connect_thread_start ()
7341 {
7342         if (g_atomic_int_get (&_ac_thread_active)) {
7343                 return;
7344         }
7345
7346         while (!_auto_connect_queue.empty ()) {
7347                 _auto_connect_queue.pop ();
7348         }
7349
7350         g_atomic_int_set (&_ac_thread_active, 1);
7351         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7352                 g_atomic_int_set (&_ac_thread_active, 0);
7353         }
7354 }
7355
7356 void
7357 Session::auto_connect_thread_terminate ()
7358 {
7359         if (!g_atomic_int_get (&_ac_thread_active)) {
7360                 return;
7361         }
7362
7363         {
7364                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7365                 while (!_auto_connect_queue.empty ()) {
7366                         _auto_connect_queue.pop ();
7367                 }
7368         }
7369
7370         /* cannot use auto_connect_thread_wakeup() because that is allowed to
7371          * fail to wakeup the thread.
7372          */
7373
7374         pthread_mutex_lock (&_auto_connect_mutex);
7375         g_atomic_int_set (&_ac_thread_active, 0);
7376         pthread_cond_signal (&_auto_connect_cond);
7377         pthread_mutex_unlock (&_auto_connect_mutex);
7378
7379         void *status;
7380         pthread_join (_auto_connect_thread, &status);
7381 }
7382
7383 void *
7384 Session::auto_connect_thread (void *arg)
7385 {
7386         Session *s = static_cast<Session *>(arg);
7387         s->auto_connect_thread_run ();
7388         pthread_exit (0);
7389         return 0;
7390 }
7391
7392 void
7393 Session::auto_connect_thread_run ()
7394 {
7395         pthread_set_name (X_("autoconnect"));
7396         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7397         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7398         pthread_mutex_lock (&_auto_connect_mutex);
7399         while (g_atomic_int_get (&_ac_thread_active)) {
7400
7401                 if (!_auto_connect_queue.empty ()) {
7402                         // Why would we need the process lock ??
7403                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7404                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7405                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
7406                         //   We have control over those, but what does jack do?
7407                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7408
7409                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7410                         while (!_auto_connect_queue.empty ()) {
7411                                 const AutoConnectRequest ar (_auto_connect_queue.front());
7412                                 _auto_connect_queue.pop ();
7413                                 lx.release ();
7414                                 auto_connect (ar);
7415                                 lx.acquire ();
7416                         }
7417                 }
7418
7419                 if (!actively_recording ()) { // might not be needed,
7420                         /* this is only used for updating plugin latencies, the
7421                          * graph does not change. so it's safe in general.
7422                          * BUT..
7423                          * update_latency_compensation ()
7424                          * calls DiskWriter::set_capture_offset () which
7425                          * modifies the capture-offset, which can be a problem.
7426                          */
7427                         while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7428                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7429                                 update_latency_compensation ();
7430                         }
7431                 }
7432
7433                 {
7434                         // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7435                         // jack1 cannot cope with removing ports while processing
7436                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7437                         AudioEngine::instance()->clear_pending_port_deletions ();
7438                 }
7439
7440                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7441         }
7442         pthread_mutex_unlock (&_auto_connect_mutex);
7443 }
7444
7445 void
7446 Session::cancel_all_solo ()
7447 {
7448         StripableList sl;
7449
7450         get_stripables (sl);
7451
7452         set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7453         clear_all_solo_state (routes.reader());
7454 }
7455
7456 void
7457 Session::maybe_update_tempo_from_midiclock_tempo (float bpm)
7458 {
7459         if (_tempo_map->n_tempos() == 1) {
7460                 TempoSection& ts (_tempo_map->tempo_section_at_sample (0));
7461                 if (fabs (ts.note_types_per_minute() - bpm) > (0.01 * ts.note_types_per_minute())) {
7462                         const Tempo tempo (bpm, 4.0, bpm);
7463                         std::cerr << "new tempo " << bpm << " old " << ts.note_types_per_minute() << std::endl;
7464                         _tempo_map->replace_tempo (ts, tempo, 0.0, 0.0, AudioTime);
7465                 }
7466         }
7467 }