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