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