libs/ardour/session.cc

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