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