libs/ardour/session.cc

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