libs/ardour/session.cc

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