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