libs/ardour/session.cc

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