libs/ardour/session.cc

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