libs/ardour/session.cc

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