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                                         /* ForceIDRegeneration does not catch the following */
3188                                         XMLProperty* role = (*i)->property (X_("role"));
3189                                         XMLProperty* type = (*i)->property (X_("type"));
3190                                         if (role && role->value() == X_("Aux")) {
3191                                                 /* check if the target bus exists.
3192                                                  * we should not save aux-sends in templates.
3193                                                  */
3194                                                 XMLProperty* target = (*i)->property (X_("target"));
3195                                                 if (!target) {
3196                                                         (*i)->add_property ("type", "dangling-aux-send");
3197                                                         continue;
3198                                                 }
3199                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3200                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3201                                                         (*i)->add_property ("type", "dangling-aux-send");
3202                                                         continue;
3203                                                 }
3204                                         }
3205                                         if (role && role->value() == X_("Listen")) {
3206                                                 (*i)->remove_property (X_("bitslot"));
3207                                         }
3208                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3209                                                 char buf[32];
3210                                                 Delivery::Role xrole;
3211                                                 uint32_t bitslot = 0;
3212                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3213                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3214                                                 snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
3215                                                 (*i)->remove_property (X_("bitslot"));
3216                                                 (*i)->remove_property (X_("name"));
3217                                                 (*i)->add_property ("bitslot", buf);
3218                                                 (*i)->add_property ("name", name);
3219                                         }
3220                                         else if (type && type->value() == X_("return")) {
3221                                                 // Return::set_state() generates a new one
3222                                                 (*i)->remove_property (X_("bitslot"));
3223                                         }
3224                                         else if (type && type->value() == X_("port")) {
3225                                                 // PortInsert::set_state() handles the bitslot
3226                                                 (*i)->remove_property (X_("bitslot"));
3227                                                 (*i)->add_property ("ignore-name", "1");
3228                                         }
3229                                 }
3230                         }
3231
3232                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3233
3234                         if (route == 0) {
3235                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3236                                 goto out;
3237                         }
3238
3239                         if (boost::dynamic_pointer_cast<Track>(route)) {
3240                                 /* force input/output change signals so that the new diskstream
3241                                    picks up the configuration of the route. During session
3242                                    loading this normally happens in a different way.
3243                                 */
3244
3245                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3246
3247                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3248                                 change.after = route->input()->n_ports();
3249                                 route->input()->changed (change, this);
3250                                 change.after = route->output()->n_ports();
3251                                 route->output()->changed (change, this);
3252                         }
3253
3254                         route->set_remote_control_id (control_id);
3255                         ++control_id;
3256
3257                         boost::shared_ptr<Track> track;
3258
3259                         if ((track = boost::dynamic_pointer_cast<Track> (route))) {
3260                                 switch (pd) {
3261                                 case NewPlaylist:
3262                                         track->use_new_playlist ();
3263                                         break;
3264                                 case CopyPlaylist:
3265                                         track->use_copy_playlist ();
3266                                         break;
3267                                 case SharePlaylist:
3268                                         break;
3269                                 }
3270                         };
3271
3272                         ret.push_back (route);
3273
3274                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3275                 }
3276
3277                 catch (failed_constructor &err) {
3278                         error << _("Session: could not create new route from template") << endmsg;
3279                         goto out;
3280                 }
3281
3282                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3283                         error << pfe.what() << endmsg;
3284                         goto out;
3285                 }
3286
3287                 --how_many;
3288         }
3289
3290   out:
3291         if (!ret.empty()) {
3292                 StateProtector sp (this);
3293                 if (Profile->get_trx()) {
3294                         add_routes (ret, false, false, false);
3295                 } else {
3296                         add_routes (ret, true, true, false);
3297                 }
3298                 IO::enable_connecting ();
3299         }
3300
3301         return ret;
3302 }
3303
3304 void
3305 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
3306 {
3307         try {
3308                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3309                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
3310
3311         } catch (...) {
3312                 error << _("Adding new tracks/busses failed") << endmsg;
3313         }
3314
3315         graph_reordered ();
3316
3317         update_latency (true);
3318         update_latency (false);
3319
3320         set_dirty();
3321
3322         if (save) {
3323                 save_state (_current_snapshot_name);
3324         }
3325
3326         reassign_track_numbers();
3327
3328         update_route_record_state ();
3329
3330         RouteAdded (new_routes); /* EMIT SIGNAL */
3331 }
3332
3333 void
3334 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3335 {
3336         ChanCount existing_inputs;
3337         ChanCount existing_outputs;
3338         uint32_t order = next_control_id();
3339
3340
3341         if (_order_hint > -1) {
3342                 order = _order_hint;
3343                 _order_hint = -1;
3344         }
3345
3346         count_existing_track_channels (existing_inputs, existing_outputs);
3347
3348         {
3349                 RCUWriter<RouteList> writer (routes);
3350                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3351                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3352
3353                 /* if there is no control out and we're not in the middle of loading,
3354                  * resort the graph here. if there is a control out, we will resort
3355                  * toward the end of this method. if we are in the middle of loading,
3356                  * we will resort when done.
3357                  */
3358
3359                 if (!_monitor_out && IO::connecting_legal) {
3360                         resort_routes_using (r);
3361                 }
3362         }
3363
3364         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3365
3366                 boost::weak_ptr<Route> wpr (*x);
3367                 boost::shared_ptr<Route> r (*x);
3368
3369                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3370                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3371                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3372                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3373                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3374                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3375
3376                 if (r->is_master()) {
3377                         _master_out = r;
3378                 }
3379
3380                 if (r->is_monitor()) {
3381                         _monitor_out = r;
3382                 }
3383
3384                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3385                 if (tr) {
3386                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3387                         track_playlist_changed (boost::weak_ptr<Track> (tr));
3388                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3389
3390                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3391                         if (mt) {
3392                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3393                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3394                         }
3395                 }
3396
3397                 if (input_auto_connect || output_auto_connect) {
3398                         auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3399                         existing_inputs += r->n_inputs();
3400                         existing_outputs += r->n_outputs();
3401                 }
3402
3403                 /* order keys are a GUI responsibility but we need to set up
3404                          reasonable defaults because they also affect the remote control
3405                          ID in most situations.
3406                          */
3407
3408                 if (!r->has_order_key ()) {
3409                         if (r->is_auditioner()) {
3410                                 /* use an arbitrarily high value */
3411                                 r->set_order_key (UINT_MAX);
3412                         } else {
3413                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3414                                 r->set_order_key (order);
3415                                 order++;
3416                         }
3417                 }
3418
3419                 ARDOUR::GUIIdle ();
3420         }
3421
3422         if (_monitor_out && IO::connecting_legal) {
3423                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3424
3425                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3426                         if ((*x)->is_monitor()) {
3427                                 /* relax */
3428                         } else if ((*x)->is_master()) {
3429                                 /* relax */
3430                         } else {
3431                                 (*x)->enable_monitor_send ();
3432                         }
3433                 }
3434         }
3435 }
3436
3437 void
3438 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3439 {
3440         boost::shared_ptr<RouteList> r = routes.reader ();
3441         boost::shared_ptr<Send> s;
3442
3443         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3444                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3445                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3446                 }
3447         }
3448 }
3449
3450 void
3451 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3452 {
3453         boost::shared_ptr<RouteList> r = routes.reader ();
3454         boost::shared_ptr<Send> s;
3455
3456         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3457                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3458                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3459                 }
3460         }
3461 }
3462
3463 void
3464 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3465 {
3466         boost::shared_ptr<RouteList> r = routes.reader ();
3467         boost::shared_ptr<Send> s;
3468
3469         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3470                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3471                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3472                 }
3473         }
3474 }
3475
3476 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3477 void
3478 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3479 {
3480         boost::shared_ptr<RouteList> r = routes.reader ();
3481         boost::shared_ptr<RouteList> t (new RouteList);
3482
3483         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3484                 /* no MIDI sends because there are no MIDI busses yet */
3485                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3486                         t->push_back (*i);
3487                 }
3488         }
3489
3490         add_internal_sends (dest, p, t);
3491 }
3492
3493 void
3494 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3495 {
3496         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3497                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3498         }
3499 }
3500
3501 void
3502 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3503 {
3504         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3505 }
3506
3507 void
3508 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3509 {
3510         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3511                 return;
3512         }
3513
3514         if (!dest->internal_return()) {
3515                 dest->add_internal_return ();
3516         }
3517
3518         sender->add_aux_send (dest, before);
3519
3520         graph_reordered ();
3521 }
3522
3523
3524 void
3525 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3526 {
3527         { // RCU Writer scope
3528                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3529                 RCUWriter<RouteList> writer (routes);
3530                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3531
3532
3533                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3534
3535                         if (*iter == _master_out) {
3536                                 continue;
3537                         }
3538
3539                         (*iter)->set_solo (false, Controllable::NoGroup);
3540
3541                         rs->remove (*iter);
3542
3543                         /* deleting the master out seems like a dumb
3544                            idea, but its more of a UI policy issue
3545                            than our concern.
3546                         */
3547
3548                         if (*iter == _master_out) {
3549                                 _master_out = boost::shared_ptr<Route> ();
3550                         }
3551
3552                         if (*iter == _monitor_out) {
3553                                 _monitor_out.reset ();
3554                         }
3555
3556                         // We need to disconnect the route's inputs and outputs
3557
3558                         (*iter)->input()->disconnect (0);
3559                         (*iter)->output()->disconnect (0);
3560
3561                         /* if the route had internal sends sending to it, remove them */
3562                         if ((*iter)->internal_return()) {
3563
3564                                 boost::shared_ptr<RouteList> r = routes.reader ();
3565                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3566                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3567                                         if (s) {
3568                                                 (*i)->remove_processor (s);
3569                                         }
3570                                 }
3571                         }
3572
3573                         /* if the monitoring section had a pointer to this route, remove it */
3574                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3575                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3576                                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3577                                 (*iter)->remove_aux_or_listen (_monitor_out);
3578                         }
3579
3580                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3581                         if (mt && mt->step_editing()) {
3582                                 if (_step_editors > 0) {
3583                                         _step_editors--;
3584                                 }
3585                         }
3586                 }
3587
3588                 /* writer goes out of scope, forces route list update */
3589
3590         } // end of RCU Writer scope
3591
3592         update_route_solo_state ();
3593         RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3594         update_latency_compensation ();
3595         set_dirty();
3596
3597         /* Re-sort routes to remove the graph's current references to the one that is
3598          * going away, then flush old references out of the graph.
3599          * Wave Tracks: reconnect routes
3600          */
3601
3602 #ifdef USE_TRACKS_CODE_FEATURES
3603                 reconnect_existing_routes(true, false);
3604 #else
3605                 routes.flush (); // maybe unsafe, see below.
3606                 resort_routes ();
3607 #endif
3608
3609         if (_process_graph && !(_state_of_the_state & Deletion)) {
3610                 _process_graph->clear_other_chain ();
3611         }
3612
3613         /* get rid of it from the dead wood collection in the route list manager */
3614         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3615
3616         routes.flush ();
3617
3618         /* try to cause everyone to drop their references
3619          * and unregister ports from the backend
3620          */
3621
3622         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3623                 (*iter)->drop_references ();
3624         }
3625
3626         if (_state_of_the_state & Deletion) {
3627                 return;
3628         }
3629
3630         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3631
3632         /* save the new state of the world */
3633
3634         if (save_state (_current_snapshot_name)) {
3635                 save_history (_current_snapshot_name);
3636         }
3637
3638         reassign_track_numbers();
3639         update_route_record_state ();
3640 }
3641
3642 void
3643 Session::remove_route (boost::shared_ptr<Route> route)
3644 {
3645         boost::shared_ptr<RouteList> rl (new RouteList);
3646         rl->push_back (route);
3647         remove_routes (rl);
3648 }
3649
3650 void
3651 Session::route_mute_changed ()
3652 {
3653         set_dirty ();
3654 }
3655
3656 void
3657 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3658 {
3659         boost::shared_ptr<Route> route = wpr.lock();
3660         if (!route) {
3661                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_listen_changed")) << endmsg;
3662                 return;
3663         }
3664
3665         if (route->listening_via_monitor ()) {
3666
3667                 if (Config->get_exclusive_solo()) {
3668
3669                         RouteGroup* rg = route->route_group ();
3670                         const bool group_already_accounted_for = route->use_group (group_override, &RouteGroup::is_solo);
3671
3672                         boost::shared_ptr<RouteList> r = routes.reader ();
3673
3674                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3675                                 if ((*i) == route) {
3676                                         /* already changed */
3677                                         continue;
3678                                 }
3679
3680                                 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3681                                         /* route does not get solo propagated to it */
3682                                         continue;
3683                                 }
3684
3685                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3686                                         /* this route is a part of the same solo group as the route
3687                                          * that was changed. Changing that route did change or will
3688                                          * change all group members appropriately, so we can ignore it
3689                                          * here
3690                                          */
3691                                         continue;
3692                                 }
3693                                 (*i)->set_listen (false, Controllable::NoGroup);
3694                         }
3695                 }
3696
3697                 _listen_cnt++;
3698
3699         } else if (_listen_cnt > 0) {
3700
3701                 _listen_cnt--;
3702         }
3703
3704         update_route_solo_state ();
3705 }
3706 void
3707 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3708 {
3709         boost::shared_ptr<Route> route = wpr.lock ();
3710
3711         if (!route) {
3712                 /* should not happen */
3713                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_isolated_changed")) << endmsg;
3714                 return;
3715         }
3716
3717         bool send_changed = false;
3718
3719         if (route->solo_isolated()) {
3720                 if (_solo_isolated_cnt == 0) {
3721                         send_changed = true;
3722                 }
3723                 _solo_isolated_cnt++;
3724         } else if (_solo_isolated_cnt > 0) {
3725                 _solo_isolated_cnt--;
3726                 if (_solo_isolated_cnt == 0) {
3727                         send_changed = true;
3728                 }
3729         }
3730
3731         if (send_changed) {
3732                 IsolatedChanged (); /* EMIT SIGNAL */
3733         }
3734 }
3735
3736 void
3737 Session::route_solo_changed (bool self_solo_change, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
3738 {
3739         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3740
3741         if (!self_solo_change) {
3742                 // session doesn't care about changes to soloed-by-others
3743                 return;
3744         }
3745
3746         boost::shared_ptr<Route> route = wpr.lock ();
3747         assert (route);
3748
3749         boost::shared_ptr<RouteList> r = routes.reader ();
3750         int32_t delta;
3751
3752         if (route->self_soloed()) {
3753                 delta = 1;
3754         } else {
3755                 delta = -1;
3756         }
3757
3758         /* the route may be a member of a group that has shared-solo
3759          * semantics. If so, then all members of that group should follow the
3760          * solo of the changed route. But ... this is optional, controlled by a
3761          * Controllable::GroupControlDisposition.
3762          *
3763          * The first argument to the signal that this method is connected to is the
3764          * GroupControlDisposition value that was used to change solo.
3765          *
3766          * If the solo change was done with group semantics (either InverseGroup
3767          * (force the entire group to change even if the group shared solo is
3768          * disabled) or UseGroup (use the group, which may or may not have the
3769          * shared solo property enabled)) then as we propagate the change to
3770          * the entire session we should IGNORE THE GROUP that the changed route
3771          * belongs to.
3772          */
3773
3774         RouteGroup* rg = route->route_group ();
3775         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3776
3777         if (delta == 1 && Config->get_exclusive_solo()) {
3778
3779                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3780
3781                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3782
3783                         if ((*i) == route) {
3784                                 /* already changed */
3785                                 continue;
3786                         }
3787
3788                         if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3789                                 /* route does not get solo propagated to it */
3790                                 continue;
3791                         }
3792
3793                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3794                                 /* this route is a part of the same solo group as the route
3795                                  * that was changed. Changing that route did change or will
3796                                  * change all group members appropriately, so we can ignore it
3797                                  * here
3798                                  */
3799                                 continue;
3800                         }
3801
3802                         (*i)->set_solo (false, group_override);
3803                 }
3804         }
3805
3806         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3807
3808         RouteList uninvolved;
3809
3810         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3811
3812         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3813                 bool via_sends_only;
3814                 bool in_signal_flow;
3815
3816                 if ((*i) == route) {
3817                         /* already changed */
3818                         continue;
3819                 }
3820
3821                 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3822                         /* route does not get solo propagated to it */
3823                         continue;
3824                 }
3825
3826                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3827                         /* this route is a part of the same solo group as the route
3828                          * that was changed. Changing that route did change or will
3829                          * change all group members appropriately, so we can ignore it
3830                          * here
3831                          */
3832                         continue;
3833                 }
3834
3835                 in_signal_flow = false;
3836
3837                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3838
3839                 if ((*i)->feeds (route, &via_sends_only)) {
3840                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3841                         if (!via_sends_only) {
3842                                 if (!route->soloed_by_others_upstream()) {
3843                                         (*i)->mod_solo_by_others_downstream (delta);
3844                                 } else {
3845                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
3846                                 }
3847                         } else {
3848                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3849                         }
3850                         in_signal_flow = true;
3851                 } else {
3852                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3853                 }
3854
3855                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3856
3857                 if (route->feeds (*i, &via_sends_only)) {
3858                         /* propagate solo upstream only if routing other than
3859                            sends is involved, but do consider the other route
3860                            (*i) to be part of the signal flow even if only
3861                            sends are involved.
3862                         */
3863                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3864                                                                   route->name(),
3865                                                                   (*i)->name(),
3866                                                                   via_sends_only,
3867                                                                   route->soloed_by_others_downstream(),
3868                                                                   route->soloed_by_others_upstream()));
3869                         if (!via_sends_only) {
3870                                 //NB. Triggers Invert Push, which handles soloed by downstream
3871                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3872                                 (*i)->mod_solo_by_others_upstream (delta);
3873                         } else {
3874                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3875                         }
3876                         in_signal_flow = true;
3877                 } else {
3878                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3879                 }
3880
3881                 if (!in_signal_flow) {
3882                         uninvolved.push_back (*i);
3883                 }
3884         }
3885
3886         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3887
3888         update_route_solo_state (r);
3889
3890         /* now notify that the mute state of the routes not involved in the signal
3891            pathway of the just-solo-changed route may have altered.
3892         */
3893
3894         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3895                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3896                 (*i)->act_on_mute ();
3897                 (*i)->mute_changed ();
3898         }
3899
3900         SoloChanged (); /* EMIT SIGNAL */
3901         set_dirty();
3902 }
3903
3904 void
3905 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3906 {
3907         /* now figure out if anything that matters is soloed (or is "listening")*/
3908
3909         bool something_soloed = false;
3910         bool something_listening = false;
3911         uint32_t listeners = 0;
3912         uint32_t isolated = 0;
3913
3914         if (!r) {
3915                 r = routes.reader();
3916         }
3917
3918         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3919                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3920                         something_soloed = true;
3921                 }
3922
3923                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3924                         if (Config->get_solo_control_is_listen_control()) {
3925                                 listeners++;
3926                                 something_listening = true;
3927                         } else {
3928                                 (*i)->set_listen (false, Controllable::NoGroup);
3929                         }
3930                 }
3931
3932                 if ((*i)->solo_isolated()) {
3933                         isolated++;
3934                 }
3935         }
3936
3937         if (something_soloed != _non_soloed_outs_muted) {
3938                 _non_soloed_outs_muted = something_soloed;
3939                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3940         }
3941
3942         if (something_listening != _listening) {
3943                 _listening = something_listening;
3944                 SoloActive (_listening);
3945         }
3946
3947         _listen_cnt = listeners;
3948
3949         if (isolated != _solo_isolated_cnt) {
3950                 _solo_isolated_cnt = isolated;
3951                 IsolatedChanged (); /* EMIT SIGNAL */
3952         }
3953
3954         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3955                                                   something_soloed, listeners, isolated));
3956 }
3957
3958 boost::shared_ptr<RouteList>
3959 Session::get_routes_with_internal_returns() const
3960 {
3961         boost::shared_ptr<RouteList> r = routes.reader ();
3962         boost::shared_ptr<RouteList> rl (new RouteList);
3963
3964         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3965                 if ((*i)->internal_return ()) {
3966                         rl->push_back (*i);
3967                 }
3968         }
3969         return rl;
3970 }
3971
3972 bool
3973 Session::io_name_is_legal (const std::string& name)
3974 {
3975         boost::shared_ptr<RouteList> r = routes.reader ();
3976
3977         for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
3978                 if (name == *reserved) {
3979                         if (!route_by_name (*reserved)) {
3980                                 /* first instance of a reserved name is allowed */
3981                                 return true;
3982                         }
3983                         /* all other instances of a reserved name are not allowed */
3984                         return false;
3985                 }
3986         }
3987
3988         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3989                 if ((*i)->name() == name) {
3990                         return false;
3991                 }
3992
3993                 if ((*i)->has_io_processor_named (name)) {
3994                         return false;
3995                 }
3996         }
3997
3998         return true;
3999 }
4000
4001 void
4002 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4003 {
4004         RouteList rl2;
4005         vector<string> connections;
4006
4007         /* if we are passed only a single route and we're not told to turn
4008          * others off, then just do the simple thing.
4009          */
4010
4011         if (flip_others == false && rl->size() == 1) {
4012                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4013                 if (mt) {
4014                         mt->set_input_active (onoff);
4015                         return;
4016                 }
4017         }
4018
4019         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4020
4021                 PortSet& ps ((*rt)->input()->ports());
4022
4023                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4024                         p->get_connections (connections);
4025                 }
4026
4027                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4028                         routes_using_input_from (*s, rl2);
4029                 }
4030
4031                 /* scan all relevant routes to see if others are on or off */
4032
4033                 bool others_are_already_on = false;
4034
4035                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4036
4037                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4038
4039                         if (!mt) {
4040                                 continue;
4041                         }
4042
4043                         if ((*r) != (*rt)) {
4044                                 if (mt->input_active()) {
4045                                         others_are_already_on = true;
4046                                 }
4047                         } else {
4048                                 /* this one needs changing */
4049                                 mt->set_input_active (onoff);
4050                         }
4051                 }
4052
4053                 if (flip_others) {
4054
4055                         /* globally reverse other routes */
4056
4057                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4058                                 if ((*r) != (*rt)) {
4059                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4060                                         if (mt) {
4061                                                 mt->set_input_active (!others_are_already_on);
4062                                         }
4063                                 }
4064                         }
4065                 }
4066         }
4067 }
4068
4069 void
4070 Session::routes_using_input_from (const string& str, RouteList& rl)
4071 {
4072         boost::shared_ptr<RouteList> r = routes.reader();
4073
4074         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4075                 if ((*i)->input()->connected_to (str)) {
4076                         rl.push_back (*i);
4077                 }
4078         }
4079 }
4080
4081 boost::shared_ptr<Route>
4082 Session::route_by_name (string name)
4083 {
4084         boost::shared_ptr<RouteList> r = routes.reader ();
4085
4086         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4087                 if ((*i)->name() == name) {
4088                         return *i;
4089                 }
4090         }
4091
4092         return boost::shared_ptr<Route> ((Route*) 0);
4093 }
4094
4095 boost::shared_ptr<Route>
4096 Session::route_by_id (PBD::ID id)
4097 {
4098         boost::shared_ptr<RouteList> r = routes.reader ();
4099
4100         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4101                 if ((*i)->id() == id) {
4102                         return *i;
4103                 }
4104         }
4105
4106         return boost::shared_ptr<Route> ((Route*) 0);
4107 }
4108
4109 boost::shared_ptr<Processor>
4110 Session::processor_by_id (PBD::ID id) const
4111 {
4112         boost::shared_ptr<RouteList> r = routes.reader ();
4113
4114         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4115                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4116                 if (p) {
4117                         return p;
4118                 }
4119         }
4120
4121         return boost::shared_ptr<Processor> ();
4122 }
4123
4124 boost::shared_ptr<Track>
4125 Session::track_by_diskstream_id (PBD::ID id)
4126 {
4127         boost::shared_ptr<RouteList> r = routes.reader ();
4128
4129         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4130                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4131                 if (t && t->using_diskstream_id (id)) {
4132                         return t;
4133                 }
4134         }
4135
4136         return boost::shared_ptr<Track> ();
4137 }
4138
4139 boost::shared_ptr<Route>
4140 Session::route_by_remote_id (uint32_t id)
4141 {
4142         boost::shared_ptr<RouteList> r = routes.reader ();
4143
4144         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4145                 if ((*i)->remote_control_id() == id) {
4146                         return *i;
4147                 }
4148         }
4149
4150         return boost::shared_ptr<Route> ((Route*) 0);
4151 }
4152
4153
4154 boost::shared_ptr<Route>
4155 Session::route_by_selected_count (uint32_t id)
4156 {
4157         boost::shared_ptr<RouteList> r = routes.reader ();
4158
4159         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4160                 /* NOT IMPLEMENTED */
4161         }
4162
4163         return boost::shared_ptr<Route> ((Route*) 0);
4164 }
4165
4166
4167 void
4168 Session::reassign_track_numbers ()
4169 {
4170         int64_t tn = 0;
4171         int64_t bn = 0;
4172         RouteList r (*(routes.reader ()));
4173         SignalOrderRouteSorter sorter;
4174         r.sort (sorter);
4175
4176         StateProtector sp (this);
4177
4178         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4179                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4180                         (*i)->set_track_number(++tn);
4181                 }
4182                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4183                         (*i)->set_track_number(--bn);
4184                 }
4185         }
4186         const uint32_t decimals = ceilf (log10f (tn + 1));
4187         const bool decimals_changed = _track_number_decimals != decimals;
4188         _track_number_decimals = decimals;
4189
4190         if (decimals_changed && config.get_track_name_number ()) {
4191                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4192                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4193                         if (t) {
4194                                 t->resync_track_name();
4195                         }
4196                 }
4197                 // trigger GUI re-layout
4198                 config.ParameterChanged("track-name-number");
4199         }
4200 }
4201
4202 void
4203 Session::playlist_region_added (boost::weak_ptr<Region> w)
4204 {
4205         boost::shared_ptr<Region> r = w.lock ();
4206         if (!r) {
4207                 return;
4208         }
4209
4210         /* These are the operations that are currently in progress... */
4211         list<GQuark> curr = _current_trans_quarks;
4212         curr.sort ();
4213
4214         /* ...and these are the operations during which we want to update
4215            the session range location markers.
4216         */
4217         list<GQuark> ops;
4218         ops.push_back (Operations::capture);
4219         ops.push_back (Operations::paste);
4220         ops.push_back (Operations::duplicate_region);
4221         ops.push_back (Operations::insert_file);
4222         ops.push_back (Operations::insert_region);
4223         ops.push_back (Operations::drag_region_brush);
4224         ops.push_back (Operations::region_drag);
4225         ops.push_back (Operations::selection_grab);
4226         ops.push_back (Operations::region_fill);
4227         ops.push_back (Operations::fill_selection);
4228         ops.push_back (Operations::create_region);
4229         ops.push_back (Operations::region_copy);
4230         ops.push_back (Operations::fixed_time_region_copy);
4231         ops.sort ();
4232
4233         /* See if any of the current operations match the ones that we want */
4234         list<GQuark> in;
4235         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4236
4237         /* If so, update the session range markers */
4238         if (!in.empty ()) {
4239                 maybe_update_session_range (r->position (), r->last_frame ());
4240         }
4241 }
4242
4243 /** Update the session range markers if a is before the current start or
4244  *  b is after the current end.
4245  */
4246 void
4247 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4248 {
4249         if (_state_of_the_state & Loading) {
4250                 return;
4251         }
4252
4253         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4254
4255         if (_session_range_location == 0) {
4256
4257                 set_session_range_location (a, b + session_end_marker_shift_samples);
4258
4259         } else {
4260
4261                 if (a < _session_range_location->start()) {
4262                         _session_range_location->set_start (a);
4263                 }
4264
4265                 if (b > _session_range_location->end()) {
4266                         _session_range_location->set_end (b);
4267                 }
4268         }
4269 }
4270
4271 void
4272 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4273 {
4274         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4275                 maybe_update_session_range (i->to, i->to + i->length);
4276         }
4277 }
4278
4279 void
4280 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4281 {
4282         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4283                 maybe_update_session_range (i->from, i->to);
4284         }
4285 }
4286
4287 /* Region management */
4288
4289 boost::shared_ptr<Region>
4290 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4291 {
4292         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4293         RegionFactory::RegionMap::const_iterator i;
4294         boost::shared_ptr<Region> region;
4295
4296         Glib::Threads::Mutex::Lock lm (region_lock);
4297
4298         for (i = regions.begin(); i != regions.end(); ++i) {
4299
4300                 region = i->second;
4301
4302                 if (region->whole_file()) {
4303
4304                         if (child->source_equivalent (region)) {
4305                                 return region;
4306                         }
4307                 }
4308         }
4309
4310         return boost::shared_ptr<Region> ();
4311 }
4312
4313 int
4314 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4315 {
4316         set<boost::shared_ptr<Region> > relevant_regions;
4317
4318         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4319                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4320         }
4321
4322         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4323                 set<boost::shared_ptr<Region> >::iterator tmp;
4324
4325                 tmp = r;
4326                 ++tmp;
4327
4328                 playlists->destroy_region (*r);
4329                 RegionFactory::map_remove (*r);
4330
4331                 (*r)->drop_sources ();
4332                 (*r)->drop_references ();
4333
4334                 relevant_regions.erase (r);
4335
4336                 r = tmp;
4337         }
4338
4339         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4340
4341                 {
4342                         Glib::Threads::Mutex::Lock ls (source_lock);
4343                         /* remove from the main source list */
4344                         sources.erase ((*s)->id());
4345                 }
4346
4347                 (*s)->mark_for_remove ();
4348                 (*s)->drop_references ();
4349
4350                 s = srcs.erase (s);
4351         }
4352
4353         return 0;
4354 }
4355
4356 int
4357 Session::remove_last_capture ()
4358 {
4359         list<boost::shared_ptr<Source> > srcs;
4360
4361         boost::shared_ptr<RouteList> rl = routes.reader ();
4362         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4363                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4364                 if (!tr) {
4365                         continue;
4366                 }
4367
4368                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4369
4370                 if (!l.empty()) {
4371                         srcs.insert (srcs.end(), l.begin(), l.end());
4372                         l.clear ();
4373                 }
4374         }
4375
4376         destroy_sources (srcs);
4377
4378         save_state (_current_snapshot_name);
4379
4380         return 0;
4381 }
4382
4383 /* Source Management */
4384
4385 void
4386 Session::add_source (boost::shared_ptr<Source> source)
4387 {
4388         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4389         pair<SourceMap::iterator,bool> result;
4390
4391         entry.first = source->id();
4392         entry.second = source;
4393
4394         {
4395                 Glib::Threads::Mutex::Lock lm (source_lock);
4396                 result = sources.insert (entry);
4397         }
4398
4399         if (result.second) {
4400
4401                 /* yay, new source */
4402
4403                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4404
4405                 if (fs) {
4406                         if (!fs->within_session()) {
4407                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4408                         }
4409                 }
4410
4411                 set_dirty();
4412
4413                 boost::shared_ptr<AudioFileSource> afs;
4414
4415                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4416                         if (Config->get_auto_analyse_audio()) {
4417                                 Analyser::queue_source_for_analysis (source, false);
4418                         }
4419                 }
4420
4421                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4422         }
4423 }
4424
4425 void
4426 Session::remove_source (boost::weak_ptr<Source> src)
4427 {
4428         if (_state_of_the_state & Deletion) {
4429                 return;
4430         }
4431
4432         SourceMap::iterator i;
4433         boost::shared_ptr<Source> source = src.lock();
4434
4435         if (!source) {
4436                 return;
4437         }
4438
4439         {
4440                 Glib::Threads::Mutex::Lock lm (source_lock);
4441
4442                 if ((i = sources.find (source->id())) != sources.end()) {
4443                         sources.erase (i);
4444                 }
4445         }
4446
4447         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4448
4449                 /* save state so we don't end up with a session file
4450                    referring to non-existent sources.
4451                 */
4452
4453                 save_state (_current_snapshot_name);
4454         }
4455 }
4456
4457 boost::shared_ptr<Source>
4458 Session::source_by_id (const PBD::ID& id)
4459 {
4460         Glib::Threads::Mutex::Lock lm (source_lock);
4461         SourceMap::iterator i;
4462         boost::shared_ptr<Source> source;
4463
4464         if ((i = sources.find (id)) != sources.end()) {
4465                 source = i->second;
4466         }
4467
4468         return source;
4469 }
4470
4471 boost::shared_ptr<AudioFileSource>
4472 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4473 {
4474         /* Restricted to audio files because only audio sources have channel
4475            as a property.
4476         */
4477
4478         Glib::Threads::Mutex::Lock lm (source_lock);
4479
4480         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4481                 boost::shared_ptr<AudioFileSource> afs
4482                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4483
4484                 if (afs && afs->path() == path && chn == afs->channel()) {
4485                         return afs;
4486                 }
4487         }
4488
4489         return boost::shared_ptr<AudioFileSource>();
4490 }
4491
4492 boost::shared_ptr<MidiSource>
4493 Session::midi_source_by_path (const std::string& path) const
4494 {
4495         /* Restricted to MIDI files because audio sources require a channel
4496            for unique identification, in addition to a path.
4497         */
4498
4499         Glib::Threads::Mutex::Lock lm (source_lock);
4500
4501         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4502                 boost::shared_ptr<MidiSource> ms
4503                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4504                 boost::shared_ptr<FileSource> fs
4505                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4506
4507                 if (ms && fs && fs->path() == path) {
4508                         return ms;
4509                 }
4510         }
4511
4512         return boost::shared_ptr<MidiSource>();
4513 }
4514
4515 uint32_t
4516 Session::count_sources_by_origin (const string& path)
4517 {
4518         uint32_t cnt = 0;
4519         Glib::Threads::Mutex::Lock lm (source_lock);
4520
4521         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4522                 boost::shared_ptr<FileSource> fs
4523                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4524
4525                 if (fs && fs->origin() == path) {
4526                         ++cnt;
4527                 }
4528         }
4529
4530         return cnt;
4531 }
4532
4533 static string
4534 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4535         if (hash) {
4536                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4537                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4538         } else {
4539                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4540         }
4541 }
4542
4543 string
4544 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4545 {
4546         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4547
4548         if (Glib::path_is_absolute (filepath)) {
4549
4550                 /* rip the session dir from the audiofile source */
4551
4552                 string session_path;
4553                 bool in_another_session = true;
4554
4555                 if (filepath.find (interchange_dir_string) != string::npos) {
4556
4557                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4558                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4559                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4560                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4561
4562                         /* see if it is within our session */
4563
4564                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4565                                 if (i->path == session_path) {
4566                                         in_another_session = false;
4567                                         break;
4568                                 }
4569                         }
4570                 } else {
4571                         in_another_session = false;
4572                 }
4573
4574
4575                 if (in_another_session) {
4576                         SessionDirectory sd (session_path);
4577                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4578                 }
4579         }
4580
4581         /* 1) if file belongs to this session
4582          * it may be a relative path (interchange/...)
4583          * or just basename (session_state, remove source)
4584          * -> just use the basename
4585          */
4586         std::string filename = Glib::path_get_basename (filepath);
4587         std::string path;
4588
4589         /* 2) if the file is outside our session dir:
4590          * (imported but not copied) add the path for check-summming */
4591         if (!in_session) {
4592                 path = Glib::path_get_dirname (filepath);
4593         }
4594
4595         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4596 }
4597
4598 string
4599 Session::new_audio_source_path_for_embedded (const std::string& path)
4600 {
4601         /* embedded source:
4602          *
4603          * we know that the filename is already unique because it exists
4604          * out in the filesystem.
4605          *
4606          * However, when we bring it into the session, we could get a
4607          * collision.
4608          *
4609          * Eg. two embedded files:
4610          *
4611          *          /foo/bar/baz.wav
4612          *          /frob/nic/baz.wav
4613          *
4614          * When merged into session, these collide.
4615          *
4616          * There will not be a conflict with in-memory sources
4617          * because when the source was created we already picked
4618          * a unique name for it.
4619          *
4620          * This collision is not likely to be common, but we have to guard
4621          * against it.  So, if there is a collision, take the md5 hash of the
4622          * the path, and use that as the filename instead.
4623          */
4624
4625         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4626         string base = Glib::path_get_basename (path);
4627         string newpath = Glib::build_filename (sdir.sound_path(), base);
4628
4629         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4630
4631                 MD5 md5;
4632
4633                 md5.digestString (path.c_str());
4634                 md5.writeToString ();
4635                 base = md5.digestChars;
4636
4637                 string ext = get_suffix (path);
4638
4639                 if (!ext.empty()) {
4640                         base += '.';
4641                         base += ext;
4642                 }
4643
4644                 newpath = Glib::build_filename (sdir.sound_path(), base);
4645
4646                 /* if this collides, we're screwed */
4647
4648                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4649                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4650                         return string();
4651                 }
4652
4653         }
4654
4655         return newpath;
4656 }
4657
4658 /** Return true if there are no audio file sources that use @param name as
4659  * the filename component of their path.
4660  *
4661  * Return false otherwise.
4662  *
4663  * This method MUST ONLY be used to check in-session, mono files since it
4664  * hard-codes the channel of the audio file source we are looking for as zero.
4665  *
4666  * If/when Ardour supports native files in non-mono formats, the logic here
4667  * will need to be revisited.
4668  */
4669 bool
4670 Session::audio_source_name_is_unique (const string& name)
4671 {
4672         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4673         vector<space_and_path>::iterator i;
4674         uint32_t existing = 0;
4675
4676         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4677
4678                 /* note that we search *without* the extension so that
4679                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4680                    in the event that this new name is required for
4681                    a file format change.
4682                 */
4683
4684                 const string spath = *i;
4685
4686                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4687                         existing++;
4688                         break;
4689                 }
4690
4691                 /* it is possible that we have the path already
4692                  * assigned to a source that has not yet been written
4693                  * (ie. the write source for a diskstream). we have to
4694                  * check this in order to make sure that our candidate
4695                  * path isn't used again, because that can lead to
4696                  * two Sources point to the same file with different
4697                  * notions of their removability.
4698                  */
4699
4700
4701                 string possible_path = Glib::build_filename (spath, name);
4702
4703                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4704                         existing++;
4705                         break;
4706                 }
4707         }
4708
4709         return (existing == 0);
4710 }
4711
4712 string
4713 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)
4714 {
4715         ostringstream sstr;
4716         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4717
4718         if (Profile->get_trx() && destructive) {
4719                 sstr << 'T';
4720                 sstr << setfill ('0') << setw (4) << cnt;
4721                 sstr << legalized_base;
4722         } else {
4723                 sstr << legalized_base;
4724
4725                 if (take_required || related_exists) {
4726                         sstr << '-';
4727                         sstr << cnt;
4728                 }
4729         }
4730
4731         if (nchan == 2) {
4732                 if (chan == 0) {
4733                         sstr << "%L";
4734                 } else {
4735                         sstr << "%R";
4736                 }
4737         } else if (nchan > 2) {
4738                 if (nchan < 26) {
4739                         sstr << '%';
4740                         sstr << 'a' + chan;
4741                 } else {
4742                         /* XXX what? more than 26 channels! */
4743                         sstr << '%';
4744                         sstr << chan+1;
4745                 }
4746         }
4747
4748         sstr << ext;
4749
4750         return sstr.str();
4751 }
4752
4753 /** Return a unique name based on \a base for a new internal audio source */
4754 string
4755 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4756 {
4757         uint32_t cnt;
4758         string possible_name;
4759         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4760         string legalized;
4761         bool some_related_source_name_exists = false;
4762
4763         legalized = legalize_for_path (base);
4764
4765         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4766
4767         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4768
4769                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4770
4771                 if (audio_source_name_is_unique (possible_name)) {
4772                         break;
4773                 }
4774
4775                 some_related_source_name_exists = true;
4776
4777                 if (cnt > limit) {
4778                         error << string_compose(
4779                                         _("There are already %1 recordings for %2, which I consider too many."),
4780                                         limit, base) << endmsg;
4781                         destroy ();
4782                         throw failed_constructor();
4783                 }
4784         }
4785
4786         /* We've established that the new name does not exist in any session
4787          * directory, so now find out which one we should use for this new
4788          * audio source.
4789          */
4790
4791         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4792
4793         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4794
4795         return s;
4796 }
4797
4798 /** Return a unique name based on `base` for a new internal MIDI source */
4799 string
4800 Session::new_midi_source_path (const string& base)
4801 {
4802         uint32_t cnt;
4803         char buf[PATH_MAX+1];
4804         const uint32_t limit = 10000;
4805         string legalized;
4806         string possible_path;
4807         string possible_name;
4808
4809         buf[0] = '\0';
4810         legalized = legalize_for_path (base);
4811
4812         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4813         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4814
4815         /* - the main session folder is the first in the vector.
4816          * - after checking all locations for file-name uniqueness,
4817          *   we keep the one from the last iteration as new file name
4818          * - midi files are small and should just be kept in the main session-folder
4819          *
4820          * -> reverse the array, check main session folder last and use that as location
4821          *    for MIDI files.
4822          */
4823         std::reverse(sdirs.begin(), sdirs.end());
4824
4825         for (cnt = 1; cnt <= limit; ++cnt) {
4826
4827                 vector<space_and_path>::iterator i;
4828                 uint32_t existing = 0;
4829
4830                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4831
4832                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4833                         possible_name = buf;
4834
4835                         possible_path = Glib::build_filename (*i, possible_name);
4836
4837                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4838                                 existing++;
4839                         }
4840
4841                         if (midi_source_by_path (possible_path)) {
4842                                 existing++;
4843                         }
4844                 }
4845
4846                 if (existing == 0) {
4847                         break;
4848                 }
4849
4850                 if (cnt > limit) {
4851                         error << string_compose(
4852                                         _("There are already %1 recordings for %2, which I consider too many."),
4853                                         limit, base) << endmsg;
4854                         destroy ();
4855                         return 0;
4856                 }
4857         }
4858
4859         /* No need to "find best location" for software/app-based RAID, because
4860            MIDI is so small that we always put it in the same place.
4861         */
4862
4863         return possible_path;
4864 }
4865
4866
4867 /** Create a new within-session audio source */
4868 boost::shared_ptr<AudioFileSource>
4869 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4870 {
4871         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4872
4873         if (!path.empty()) {
4874                 return boost::dynamic_pointer_cast<AudioFileSource> (
4875                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
4876         } else {
4877                 throw failed_constructor ();
4878         }
4879 }
4880
4881 /** Create a new within-session MIDI source */
4882 boost::shared_ptr<MidiSource>
4883 Session::create_midi_source_for_session (string const & basic_name)
4884 {
4885         const string path = new_midi_source_path (basic_name);
4886
4887         if (!path.empty()) {
4888                 return boost::dynamic_pointer_cast<SMFSource> (
4889                         SourceFactory::createWritable (
4890                                 DataType::MIDI, *this, path, false, frame_rate()));
4891         } else {
4892                 throw failed_constructor ();
4893         }
4894 }
4895
4896 /** Create a new within-session MIDI source */
4897 boost::shared_ptr<MidiSource>
4898 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4899 {
4900         /* the caller passes in the track the source will be used in,
4901            so that we can keep the numbering sane.
4902
4903            Rationale: a track with the name "Foo" that has had N
4904            captures carried out so far will ALREADY have a write source
4905            named "Foo-N+1.mid" waiting to be used for the next capture.
4906
4907            If we call new_midi_source_name() we will get "Foo-N+2". But
4908            there is no region corresponding to "Foo-N+1", so when
4909            "Foo-N+2" appears in the track, the gap presents the user
4910            with odd behaviour - why did it skip past Foo-N+1?
4911
4912            We could explain this to the user in some odd way, but
4913            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4914            use "Foo-N+1" here.
4915
4916            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4917         */
4918
4919         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4920         assert (mt);
4921         std::string name = track->steal_write_source_name ();
4922
4923         if (name.empty()) {
4924                 return boost::shared_ptr<MidiSource>();
4925         }
4926
4927         /* MIDI files are small, just put them in the first location of the
4928            session source search path.
4929         */
4930
4931         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4932
4933         return boost::dynamic_pointer_cast<SMFSource> (
4934                 SourceFactory::createWritable (
4935                         DataType::MIDI, *this, path, false, frame_rate()));
4936 }
4937
4938
4939 void
4940 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4941 {
4942         if (playlist->hidden()) {
4943                 return;
4944         }
4945
4946         playlists->add (playlist);
4947
4948         if (unused) {
4949                 playlist->release();
4950         }
4951
4952         set_dirty();
4953 }
4954
4955 void
4956 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4957 {
4958         if (_state_of_the_state & Deletion) {
4959                 return;
4960         }
4961
4962         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4963
4964         if (!playlist) {
4965                 return;
4966         }
4967
4968         playlists->remove (playlist);
4969
4970         set_dirty();
4971 }
4972
4973 void
4974 Session::set_audition (boost::shared_ptr<Region> r)
4975 {
4976         pending_audition_region = r;
4977         add_post_transport_work (PostTransportAudition);
4978         _butler->schedule_transport_work ();
4979 }
4980
4981 void
4982 Session::audition_playlist ()
4983 {
4984         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4985         ev->region.reset ();
4986         queue_event (ev);
4987 }
4988
4989
4990 void
4991 Session::register_lua_function (
4992                 const std::string& name,
4993                 const std::string& script,
4994                 const LuaScriptParamList& args
4995                 )
4996 {
4997         Glib::Threads::Mutex::Lock lm (lua_lock);
4998
4999         lua_State* L = lua.getState();
5000
5001         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5002         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5003         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5004                 if ((*i)->optional && !(*i)->is_set) { continue; }
5005                 tbl_arg[(*i)->name] = (*i)->value;
5006         }
5007         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5008         set_dirty();
5009 }
5010
5011 void
5012 Session::unregister_lua_function (const std::string& name)
5013 {
5014         Glib::Threads::Mutex::Lock lm (lua_lock);
5015         (*_lua_del)(name); // throws luabridge::LuaException
5016         lua.collect_garbage ();
5017         set_dirty();
5018 }
5019
5020 std::vector<std::string>
5021 Session::registered_lua_functions ()
5022 {
5023         Glib::Threads::Mutex::Lock lm (lua_lock);
5024         std::vector<std::string> rv;
5025
5026         try {
5027                 luabridge::LuaRef list ((*_lua_list)());
5028                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5029                         if (!i.key ().isString ()) { assert(0); continue; }
5030                         rv.push_back (i.key ().cast<std::string> ());
5031                 }
5032         } catch (luabridge::LuaException const& e) { }
5033         return rv;
5034 }
5035
5036 #ifndef NDEBUG
5037 static void _lua_print (std::string s) {
5038         std::cout << "SessionLua: " << s << "\n";
5039 }
5040 #endif
5041
5042 void
5043 Session::try_run_lua (pframes_t nframes)
5044 {
5045         if (_n_lua_scripts == 0) return;
5046         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5047         if (tm.locked ()) {
5048                 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5049         }
5050 }
5051
5052 void
5053 Session::setup_lua ()
5054 {
5055 #ifndef NDEBUG
5056         lua.Print.connect (&_lua_print);
5057 #endif
5058         lua.do_command (
5059                         "function ArdourSession ()"
5060                         "  local self = { scripts = {}, instances = {} }"
5061                         ""
5062                         "  local remove = function (n)"
5063                         "   self.scripts[n] = nil"
5064                         "   self.instances[n] = nil"
5065                         "   Session:scripts_changed()" // call back
5066                         "  end"
5067                         ""
5068                         "  local addinternal = function (n, f, a)"
5069                         "   assert(type(n) == 'string', 'function-name must be string')"
5070                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5071                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5072                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5073                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5074                         "   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"
5075                         "   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 }"
5076                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5077                         "   Session:scripts_changed()" // call back
5078                         "  end"
5079                         ""
5080                         "  local add = function (n, b, a)"
5081                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5082                         "   load (b)()" // assigns f
5083                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5084                         "   addinternal (n, load(f), a)"
5085                         "  end"
5086                         ""
5087                         "  local run = function (...)"
5088                         "   for n, s in pairs (self.instances) do"
5089                         "     local status, err = pcall (s, ...)"
5090                         "     if not status then"
5091                         "       print ('fn \"'.. n .. '\": ', err)"
5092                         "       remove (n)"
5093                         "      end"
5094                         "   end"
5095                         "   collectgarbage()"
5096                         "  end"
5097                         ""
5098                         "  local cleanup = function ()"
5099                         "   self.scripts = nil"
5100                         "   self.instances = nil"
5101                         "  end"
5102                         ""
5103                         "  local list = function ()"
5104                         "   local rv = {}"
5105                         "   for n, _ in pairs (self.scripts) do"
5106                         "     rv[n] = true"
5107                         "   end"
5108                         "   return rv"
5109                         "  end"
5110                         ""
5111                         "  local function basic_serialize (o)"
5112                         "    if type(o) == \"number\" then"
5113                         "     return tostring(o)"
5114                         "    else"
5115                         "     return string.format(\"%q\", o)"
5116                         "    end"
5117                         "  end"
5118                         ""
5119                         "  local function serialize (name, value)"
5120                         "   local rv = name .. ' = '"
5121                         "   collectgarbage()"
5122                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5123                         "    return rv .. basic_serialize(value) .. ' '"
5124                         "   elseif type(value) == \"table\" then"
5125                         "    rv = rv .. '{} '"
5126                         "    for k,v in pairs(value) do"
5127                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5128                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5129                         "     collectgarbage()" // string concatenation allocates a new string :(
5130                         "    end"
5131                         "    return rv;"
5132                         "   elseif type(value) == \"function\" then"
5133                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5134                         "   else"
5135                         "    error('cannot save a ' .. type(value))"
5136                         "   end"
5137                         "  end"
5138                         ""
5139                         ""
5140                         "  local save = function ()"
5141                         "   return (serialize('scripts', self.scripts))"
5142                         "  end"
5143                         ""
5144                         "  local restore = function (state)"
5145                         "   self.scripts = {}"
5146                         "   load (state)()"
5147                         "   for n, s in pairs (scripts) do"
5148                         "    addinternal (n, load(s['f']), s['a'])"
5149                         "   end"
5150                         "  end"
5151                         ""
5152                         " return { run = run, add = add, remove = remove,"
5153                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5154                         " end"
5155                         " "
5156                         " sess = ArdourSession ()"
5157                         " ArdourSession = nil"
5158                         " "
5159                         "function ardour () end"
5160                         );
5161
5162         lua_State* L = lua.getState();
5163
5164         try {
5165                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5166                 lua.do_command ("sess = nil"); // hide it.
5167                 lua.do_command ("collectgarbage()");
5168
5169                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5170                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5171                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5172                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5173                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5174                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5175                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5176         } catch (luabridge::LuaException const& e) {
5177                 fatal << string_compose (_("programming error: %1"),
5178                                 X_("Failed to setup Lua interpreter"))
5179                         << endmsg;
5180                 abort(); /*NOTREACHED*/
5181         }
5182
5183         LuaBindings::stddef (L);
5184         LuaBindings::common (L);
5185         LuaBindings::dsp (L);
5186         luabridge::push <Session *> (L, this);
5187         lua_setglobal (L, "Session");
5188 }
5189
5190 void
5191 Session::scripts_changed ()
5192 {
5193         assert (!lua_lock.trylock()); // must hold lua_lock
5194
5195         try {
5196                 luabridge::LuaRef list ((*_lua_list)());
5197                 int cnt = 0;
5198                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5199                         if (!i.key ().isString ()) { assert(0); continue; }
5200                         ++cnt;
5201                 }
5202                 _n_lua_scripts = cnt;
5203         } catch (luabridge::LuaException const& e) {
5204                 fatal << string_compose (_("programming error: %1"),
5205                                 X_("Indexing Lua Session Scripts failed."))
5206                         << endmsg;
5207                 abort(); /*NOTREACHED*/
5208         }
5209 }
5210
5211 void
5212 Session::non_realtime_set_audition ()
5213 {
5214         assert (pending_audition_region);
5215         auditioner->audition_region (pending_audition_region);
5216         pending_audition_region.reset ();
5217         AuditionActive (true); /* EMIT SIGNAL */
5218 }
5219
5220 void
5221 Session::audition_region (boost::shared_ptr<Region> r)
5222 {
5223         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5224         ev->region = r;
5225         queue_event (ev);
5226 }
5227
5228 void
5229 Session::cancel_audition ()
5230 {
5231         if (!auditioner) {
5232                 return;
5233         }
5234         if (auditioner->auditioning()) {
5235                 auditioner->cancel_audition ();
5236                 AuditionActive (false); /* EMIT SIGNAL */
5237         }
5238 }
5239
5240 bool
5241 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
5242 {
5243         if (a->is_monitor()) {
5244                 return true;
5245         }
5246         if (b->is_monitor()) {
5247                 return false;
5248         }
5249         return a->order_key () < b->order_key ();
5250 }
5251
5252 bool
5253 Session::is_auditioning () const
5254 {
5255         /* can be called before we have an auditioner object */
5256         if (auditioner) {
5257                 return auditioner->auditioning();
5258         } else {
5259                 return false;
5260         }
5261 }
5262
5263 void
5264 Session::graph_reordered ()
5265 {
5266         /* don't do this stuff if we are setting up connections
5267            from a set_state() call or creating new tracks. Ditto for deletion.
5268         */
5269
5270         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5271                 return;
5272         }
5273
5274         /* every track/bus asked for this to be handled but it was deferred because
5275            we were connecting. do it now.
5276         */
5277
5278         request_input_change_handling ();
5279
5280         resort_routes ();
5281
5282         /* force all diskstreams to update their capture offset values to
5283            reflect any changes in latencies within the graph.
5284         */
5285
5286         boost::shared_ptr<RouteList> rl = routes.reader ();
5287         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5288                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5289                 if (tr) {
5290                         tr->set_capture_offset ();
5291                 }
5292         }
5293 }
5294
5295 /** @return Number of frames that there is disk space available to write,
5296  *  if known.
5297  */
5298 boost::optional<framecnt_t>
5299 Session::available_capture_duration ()
5300 {
5301         Glib::Threads::Mutex::Lock lm (space_lock);
5302
5303         if (_total_free_4k_blocks_uncertain) {
5304                 return boost::optional<framecnt_t> ();
5305         }
5306
5307         float sample_bytes_on_disk = 4.0; // keep gcc happy
5308
5309         switch (config.get_native_file_data_format()) {
5310         case FormatFloat:
5311                 sample_bytes_on_disk = 4.0;
5312                 break;
5313
5314         case FormatInt24:
5315                 sample_bytes_on_disk = 3.0;
5316                 break;
5317
5318         case FormatInt16:
5319                 sample_bytes_on_disk = 2.0;
5320                 break;
5321
5322         default:
5323                 /* impossible, but keep some gcc versions happy */
5324                 fatal << string_compose (_("programming error: %1"),
5325                                          X_("illegal native file data format"))
5326                       << endmsg;
5327                 abort(); /*NOTREACHED*/
5328         }
5329
5330         double scale = 4096.0 / sample_bytes_on_disk;
5331
5332         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5333                 return max_framecnt;
5334         }
5335
5336         return (framecnt_t) floor (_total_free_4k_blocks * scale);
5337 }
5338
5339 void
5340 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5341 {
5342         {
5343                 RCUWriter<BundleList> writer (_bundles);
5344                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5345                 b->push_back (bundle);
5346         }
5347
5348         if (emit_signal) {
5349                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5350         }
5351
5352         set_dirty();
5353 }
5354
5355 void
5356 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5357 {
5358         bool removed = false;
5359
5360         {
5361                 RCUWriter<BundleList> writer (_bundles);
5362                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5363                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5364
5365                 if (i != b->end()) {
5366                         b->erase (i);
5367                         removed = true;
5368                 }
5369         }
5370
5371         if (removed) {
5372                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5373         }
5374
5375         set_dirty();
5376 }
5377
5378 boost::shared_ptr<Bundle>
5379 Session::bundle_by_name (string name) const
5380 {
5381         boost::shared_ptr<BundleList> b = _bundles.reader ();
5382
5383         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5384                 if ((*i)->name() == name) {
5385                         return* i;
5386                 }
5387         }
5388
5389         return boost::shared_ptr<Bundle> ();
5390 }
5391
5392 void
5393 Session::tempo_map_changed (const PropertyChange&)
5394 {
5395         clear_clicks ();
5396
5397         playlists->update_after_tempo_map_change ();
5398
5399         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5400
5401         set_dirty ();
5402 }
5403
5404 void
5405 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5406 {
5407         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5408                 (*i)->recompute_frames_from_bbt ();
5409         }
5410 }
5411
5412 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5413  * the given count with the current block size.
5414  */
5415 void
5416 Session::ensure_buffers (ChanCount howmany)
5417 {
5418         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5419 }
5420
5421 void
5422 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5423 {
5424         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5425                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5426         }
5427 }
5428
5429 uint32_t
5430 Session::next_insert_id ()
5431 {
5432         /* this doesn't really loop forever. just think about it */
5433
5434         while (true) {
5435                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5436                         if (!insert_bitset[n]) {
5437                                 insert_bitset[n] = true;
5438                                 return n;
5439
5440                         }
5441                 }
5442
5443                 /* none available, so resize and try again */
5444
5445                 insert_bitset.resize (insert_bitset.size() + 16, false);
5446         }
5447 }
5448
5449 uint32_t
5450 Session::next_send_id ()
5451 {
5452         /* this doesn't really loop forever. just think about it */
5453
5454         while (true) {
5455                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5456                         if (!send_bitset[n]) {
5457                                 send_bitset[n] = true;
5458                                 return n;
5459
5460                         }
5461                 }
5462
5463                 /* none available, so resize and try again */
5464
5465                 send_bitset.resize (send_bitset.size() + 16, false);
5466         }
5467 }
5468
5469 uint32_t
5470 Session::next_aux_send_id ()
5471 {
5472         /* this doesn't really loop forever. just think about it */
5473
5474         while (true) {
5475                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5476                         if (!aux_send_bitset[n]) {
5477                                 aux_send_bitset[n] = true;
5478                                 return n;
5479
5480                         }
5481                 }
5482
5483                 /* none available, so resize and try again */
5484
5485                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5486         }
5487 }
5488
5489 uint32_t
5490 Session::next_return_id ()
5491 {
5492         /* this doesn't really loop forever. just think about it */
5493
5494         while (true) {
5495                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5496                         if (!return_bitset[n]) {
5497                                 return_bitset[n] = true;
5498                                 return n;
5499
5500                         }
5501                 }
5502
5503                 /* none available, so resize and try again */
5504
5505                 return_bitset.resize (return_bitset.size() + 16, false);
5506         }
5507 }
5508
5509 void
5510 Session::mark_send_id (uint32_t id)
5511 {
5512         if (id >= send_bitset.size()) {
5513                 send_bitset.resize (id+16, false);
5514         }
5515         if (send_bitset[id]) {
5516                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5517         }
5518         send_bitset[id] = true;
5519 }
5520
5521 void
5522 Session::mark_aux_send_id (uint32_t id)
5523 {
5524         if (id >= aux_send_bitset.size()) {
5525                 aux_send_bitset.resize (id+16, false);
5526         }
5527         if (aux_send_bitset[id]) {
5528                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5529         }
5530         aux_send_bitset[id] = true;
5531 }
5532
5533 void
5534 Session::mark_return_id (uint32_t id)
5535 {
5536         if (id >= return_bitset.size()) {
5537                 return_bitset.resize (id+16, false);
5538         }
5539         if (return_bitset[id]) {
5540                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5541         }
5542         return_bitset[id] = true;
5543 }
5544
5545 void
5546 Session::mark_insert_id (uint32_t id)
5547 {
5548         if (id >= insert_bitset.size()) {
5549                 insert_bitset.resize (id+16, false);
5550         }
5551         if (insert_bitset[id]) {
5552                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5553         }
5554         insert_bitset[id] = true;
5555 }
5556
5557 void
5558 Session::unmark_send_id (uint32_t id)
5559 {
5560         if (id < send_bitset.size()) {
5561                 send_bitset[id] = false;
5562         }
5563 }
5564
5565 void
5566 Session::unmark_aux_send_id (uint32_t id)
5567 {
5568         if (id < aux_send_bitset.size()) {
5569                 aux_send_bitset[id] = false;
5570         }
5571 }
5572
5573 void
5574 Session::unmark_return_id (uint32_t id)
5575 {
5576         if (_state_of_the_state & Deletion) { return; }
5577         if (id < return_bitset.size()) {
5578                 return_bitset[id] = false;
5579         }
5580 }
5581
5582 void
5583 Session::unmark_insert_id (uint32_t id)
5584 {
5585         if (id < insert_bitset.size()) {
5586                 insert_bitset[id] = false;
5587         }
5588 }
5589
5590 void
5591 Session::reset_native_file_format ()
5592 {
5593         boost::shared_ptr<RouteList> rl = routes.reader ();
5594
5595         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5596                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5597                 if (tr) {
5598                         /* don't save state as we do this, there's no point
5599                          */
5600                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5601                         tr->reset_write_sources (false);
5602                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5603                 }
5604         }
5605 }
5606
5607 bool
5608 Session::route_name_unique (string n) const
5609 {
5610         boost::shared_ptr<RouteList> r = routes.reader ();
5611
5612         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5613                 if ((*i)->name() == n) {
5614                         return false;
5615                 }
5616         }
5617
5618         return true;
5619 }
5620
5621 bool
5622 Session::route_name_internal (string n) const
5623 {
5624         if (auditioner && auditioner->name() == n) {
5625                 return true;
5626         }
5627
5628         if (_click_io && _click_io->name() == n) {
5629                 return true;
5630         }
5631
5632         return false;
5633 }
5634
5635 int
5636 Session::freeze_all (InterThreadInfo& itt)
5637 {
5638         boost::shared_ptr<RouteList> r = routes.reader ();
5639
5640         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5641
5642                 boost::shared_ptr<Track> t;
5643
5644                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5645                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5646                            of every track.
5647                         */
5648                         t->freeze_me (itt);
5649                 }
5650         }
5651
5652         return 0;
5653 }
5654
5655 boost::shared_ptr<Region>
5656 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5657                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5658                           InterThreadInfo& itt,
5659                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5660                           bool for_export, bool for_freeze)
5661 {
5662         boost::shared_ptr<Region> result;
5663         boost::shared_ptr<Playlist> playlist;
5664         boost::shared_ptr<Source> source;
5665         ChanCount diskstream_channels (track.n_channels());
5666         framepos_t position;
5667         framecnt_t this_chunk;
5668         framepos_t to_do;
5669         framepos_t latency_skip;
5670         BufferSet buffers;
5671         framepos_t len = end - start;
5672         bool need_block_size_reset = false;
5673         ChanCount const max_proc = track.max_processor_streams ();
5674         string legal_playlist_name;
5675         string possible_path;
5676
5677         if (end <= start) {
5678                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5679                                          end, start) << endmsg;
5680                 return result;
5681         }
5682
5683         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5684                         include_endpoint, for_export, for_freeze);
5685
5686         if (diskstream_channels.n(track.data_type()) < 1) {
5687                 error << _("Cannot write a range with no data.") << endmsg;
5688                 return result;
5689         }
5690
5691         // block all process callback handling
5692
5693         block_processing ();
5694
5695         {
5696                 // synchronize with AudioEngine::process_callback()
5697                 // make sure processing is not currently running
5698                 // and processing_blocked() is honored before
5699                 // acquiring thread buffers
5700                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5701         }
5702
5703         _bounce_processing_active = true;
5704
5705         /* call tree *MUST* hold route_lock */
5706
5707         if ((playlist = track.playlist()) == 0) {
5708                 goto out;
5709         }
5710
5711         legal_playlist_name = legalize_for_path (playlist->name());
5712
5713         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5714
5715                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5716                 string path = ((track.data_type() == DataType::AUDIO)
5717                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5718                                : new_midi_source_path (legal_playlist_name));
5719
5720                 if (path.empty()) {
5721                         goto out;
5722                 }
5723
5724                 try {
5725                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5726                 }
5727
5728                 catch (failed_constructor& err) {
5729                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5730                         goto out;
5731                 }
5732
5733                 srcs.push_back (source);
5734         }
5735
5736         /* tell redirects that care that we are about to use a much larger
5737          * blocksize. this will flush all plugins too, so that they are ready
5738          * to be used for this process.
5739          */
5740
5741         need_block_size_reset = true;
5742         track.set_block_size (bounce_chunk_size);
5743         _engine.main_thread()->get_buffers ();
5744
5745         position = start;
5746         to_do = len;
5747         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5748
5749         /* create a set of reasonably-sized buffers */
5750         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5751                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5752         }
5753         buffers.set_count (max_proc);
5754
5755         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5756                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5757                 boost::shared_ptr<MidiSource> ms;
5758                 if (afs) {
5759                         afs->prepare_for_peakfile_writes ();
5760                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5761                         Source::Lock lock(ms->mutex());
5762                         ms->mark_streaming_write_started(lock);
5763                 }
5764         }
5765
5766         while (to_do && !itt.cancel) {
5767
5768                 this_chunk = min (to_do, bounce_chunk_size);
5769
5770                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5771                         goto out;
5772                 }
5773
5774                 start += this_chunk;
5775                 to_do -= this_chunk;
5776                 itt.progress = (float) (1.0 - ((double) to_do / len));
5777
5778                 if (latency_skip >= bounce_chunk_size) {
5779                         latency_skip -= bounce_chunk_size;
5780                         continue;
5781                 }
5782
5783                 const framecnt_t current_chunk = this_chunk - latency_skip;
5784
5785                 uint32_t n = 0;
5786                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5787                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5788                         boost::shared_ptr<MidiSource> ms;
5789
5790                         if (afs) {
5791                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5792                                         goto out;
5793                                 }
5794                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5795                                 Source::Lock lock(ms->mutex());
5796
5797                                 const MidiBuffer& buf = buffers.get_midi(0);
5798                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5799                                         Evoral::Event<framepos_t> ev = *i;
5800                                         ev.set_time(ev.time() - position);
5801                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5802                                 }
5803                         }
5804                 }
5805                 latency_skip = 0;
5806         }
5807
5808         /* post-roll, pick up delayed processor output */
5809         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5810
5811         while (latency_skip && !itt.cancel) {
5812                 this_chunk = min (latency_skip, bounce_chunk_size);
5813                 latency_skip -= this_chunk;
5814
5815                 buffers.silence (this_chunk, 0);
5816                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5817
5818                 uint32_t n = 0;
5819                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5820                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5821
5822                         if (afs) {
5823                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5824                                         goto out;
5825                                 }
5826                         }
5827                 }
5828         }
5829
5830         if (!itt.cancel) {
5831
5832                 time_t now;
5833                 struct tm* xnow;
5834                 time (&now);
5835                 xnow = localtime (&now);
5836
5837                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5838                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5839                         boost::shared_ptr<MidiSource> ms;
5840
5841                         if (afs) {
5842                                 afs->update_header (position, *xnow, now);
5843                                 afs->flush_header ();
5844                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5845                                 Source::Lock lock(ms->mutex());
5846                                 ms->mark_streaming_write_completed(lock);
5847                         }
5848                 }
5849
5850                 /* construct a region to represent the bounced material */
5851
5852                 PropertyList plist;
5853
5854                 plist.add (Properties::start, 0);
5855                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5856                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5857
5858                 result = RegionFactory::create (srcs, plist);
5859
5860         }
5861
5862   out:
5863         if (!result) {
5864                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5865                         (*src)->mark_for_remove ();
5866                         (*src)->drop_references ();
5867                 }
5868
5869         } else {
5870                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5871                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5872
5873                         if (afs)
5874                                 afs->done_with_peakfile_writes ();
5875                 }
5876         }
5877
5878         _bounce_processing_active = false;
5879
5880         if (need_block_size_reset) {
5881                 _engine.main_thread()->drop_buffers ();
5882                 track.set_block_size (get_block_size());
5883         }
5884
5885         unblock_processing ();
5886         itt.done = true;
5887
5888         return result;
5889 }
5890
5891 gain_t*
5892 Session::gain_automation_buffer() const
5893 {
5894         return ProcessThread::gain_automation_buffer ();
5895 }
5896
5897 gain_t*
5898 Session::trim_automation_buffer() const
5899 {
5900         return ProcessThread::trim_automation_buffer ();
5901 }
5902
5903 gain_t*
5904 Session::send_gain_automation_buffer() const
5905 {
5906         return ProcessThread::send_gain_automation_buffer ();
5907 }
5908
5909 pan_t**
5910 Session::pan_automation_buffer() const
5911 {
5912         return ProcessThread::pan_automation_buffer ();
5913 }
5914
5915 BufferSet&
5916 Session::get_silent_buffers (ChanCount count)
5917 {
5918         return ProcessThread::get_silent_buffers (count);
5919 }
5920
5921 BufferSet&
5922 Session::get_scratch_buffers (ChanCount count, bool silence)
5923 {
5924         return ProcessThread::get_scratch_buffers (count, silence);
5925 }
5926
5927 BufferSet&
5928 Session::get_noinplace_buffers (ChanCount count)
5929 {
5930         return ProcessThread::get_noinplace_buffers (count);
5931 }
5932
5933 BufferSet&
5934 Session::get_route_buffers (ChanCount count, bool silence)
5935 {
5936         return ProcessThread::get_route_buffers (count, silence);
5937 }
5938
5939
5940 BufferSet&
5941 Session::get_mix_buffers (ChanCount count)
5942 {
5943         return ProcessThread::get_mix_buffers (count);
5944 }
5945
5946 uint32_t
5947 Session::ntracks () const
5948 {
5949         uint32_t n = 0;
5950         boost::shared_ptr<RouteList> r = routes.reader ();
5951
5952         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5953                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5954                         ++n;
5955                 }
5956         }
5957
5958         return n;
5959 }
5960
5961 uint32_t
5962 Session::nbusses () const
5963 {
5964         uint32_t n = 0;
5965         boost::shared_ptr<RouteList> r = routes.reader ();
5966
5967         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5968                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5969                         ++n;
5970                 }
5971         }
5972
5973         return n;
5974 }
5975
5976 void
5977 Session::add_automation_list(AutomationList *al)
5978 {
5979         automation_lists[al->id()] = al;
5980 }
5981
5982 /** @return true if there is at least one record-enabled track, otherwise false */
5983 bool
5984 Session::have_rec_enabled_track () const
5985 {
5986         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5987 }
5988
5989 bool
5990 Session::have_rec_disabled_track () const
5991 {
5992     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5993 }
5994
5995 /** Update the state of our rec-enabled tracks flag */
5996 void
5997 Session::update_route_record_state ()
5998 {
5999         boost::shared_ptr<RouteList> rl = routes.reader ();
6000         RouteList::iterator i = rl->begin();
6001         while (i != rl->end ()) {
6002
6003                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6004                 if (tr && tr->record_enabled ()) {
6005                         break;
6006                 }
6007
6008                 ++i;
6009         }
6010
6011         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6012
6013         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6014
6015         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6016                 RecordStateChanged (); /* EMIT SIGNAL */
6017         }
6018
6019         for (i = rl->begin(); i != rl->end (); ++i) {
6020                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6021                 if (tr && !tr->record_enabled ()) {
6022                         break;
6023                 }
6024         }
6025
6026         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6027
6028         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6029
6030         if (record_status() == Recording && record_arm_state_changed ) {
6031                 RecordArmStateChanged ();
6032         }
6033
6034 }
6035
6036 void
6037 Session::listen_position_changed ()
6038 {
6039         boost::shared_ptr<RouteList> r = routes.reader ();
6040
6041         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6042                 (*i)->listen_position_changed ();
6043         }
6044 }
6045
6046 void
6047 Session::solo_control_mode_changed ()
6048 {
6049         /* cancel all solo or all listen when solo control mode changes */
6050
6051         if (soloing()) {
6052                 set_solo (get_routes(), false);
6053         } else if (listening()) {
6054                 set_listen (get_routes(), false);
6055         }
6056 }
6057
6058 /** Called when a property of one of our route groups changes */
6059 void
6060 Session::route_group_property_changed (RouteGroup* rg)
6061 {
6062         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6063 }
6064
6065 /** Called when a route is added to one of our route groups */
6066 void
6067 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6068 {
6069         RouteAddedToRouteGroup (rg, r);
6070 }
6071
6072 /** Called when a route is removed from one of our route groups */
6073 void
6074 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6075 {
6076         update_route_record_state ();
6077         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6078 }
6079
6080 boost::shared_ptr<RouteList>
6081 Session::get_tracks () const
6082 {
6083         boost::shared_ptr<RouteList> rl = routes.reader ();
6084         boost::shared_ptr<RouteList> tl (new RouteList);
6085
6086         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6087                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6088                         if (!(*r)->is_auditioner()) {
6089                                 tl->push_back (*r);
6090                         }
6091                 }
6092         }
6093         return tl;
6094 }
6095
6096 boost::shared_ptr<RouteList>
6097 Session::get_routes_with_regions_at (framepos_t const p) const
6098 {
6099         boost::shared_ptr<RouteList> r = routes.reader ();
6100         boost::shared_ptr<RouteList> rl (new RouteList);
6101
6102         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6103                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6104                 if (!tr) {
6105                         continue;
6106                 }
6107
6108                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6109                 if (!pl) {
6110                         continue;
6111                 }
6112
6113                 if (pl->has_region_at (p)) {
6114                         rl->push_back (*i);
6115                 }
6116         }
6117
6118         return rl;
6119 }
6120
6121 void
6122 Session::goto_end ()
6123 {
6124         if (_session_range_location) {
6125                 request_locate (_session_range_location->end(), false);
6126         } else {
6127                 request_locate (0, false);
6128         }
6129 }
6130
6131 void
6132 Session::goto_start ()
6133 {
6134         if (_session_range_location) {
6135                 request_locate (_session_range_location->start(), false);
6136         } else {
6137                 request_locate (0, false);
6138         }
6139 }
6140
6141 framepos_t
6142 Session::current_start_frame () const
6143 {
6144         return _session_range_location ? _session_range_location->start() : 0;
6145 }
6146
6147 framepos_t
6148 Session::current_end_frame () const
6149 {
6150         return _session_range_location ? _session_range_location->end() : 0;
6151 }
6152
6153 void
6154 Session::set_session_range_location (framepos_t start, framepos_t end)
6155 {
6156         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
6157         _locations->add (_session_range_location);
6158 }
6159
6160 void
6161 Session::step_edit_status_change (bool yn)
6162 {
6163         bool send = false;
6164
6165         bool val = false;
6166         if (yn) {
6167                 send = (_step_editors == 0);
6168                 val = true;
6169
6170                 _step_editors++;
6171         } else {
6172                 send = (_step_editors == 1);
6173                 val = false;
6174
6175                 if (_step_editors > 0) {
6176                         _step_editors--;
6177                 }
6178         }
6179
6180         if (send) {
6181                 StepEditStatusChange (val);
6182         }
6183 }
6184
6185
6186 void
6187 Session::start_time_changed (framepos_t old)
6188 {
6189         /* Update the auto loop range to match the session range
6190            (unless the auto loop range has been changed by the user)
6191         */
6192
6193         Location* s = _locations->session_range_location ();
6194         if (s == 0) {
6195                 return;
6196         }
6197
6198         Location* l = _locations->auto_loop_location ();
6199
6200         if (l && l->start() == old) {
6201                 l->set_start (s->start(), true);
6202         }
6203 }
6204
6205 void
6206 Session::end_time_changed (framepos_t old)
6207 {
6208         /* Update the auto loop range to match the session range
6209            (unless the auto loop range has been changed by the user)
6210         */
6211
6212         Location* s = _locations->session_range_location ();
6213         if (s == 0) {
6214                 return;
6215         }
6216
6217         Location* l = _locations->auto_loop_location ();
6218
6219         if (l && l->end() == old) {
6220                 l->set_end (s->end(), true);
6221         }
6222 }
6223
6224 std::vector<std::string>
6225 Session::source_search_path (DataType type) const
6226 {
6227         Searchpath sp;
6228
6229         if (session_dirs.size() == 1) {
6230                 switch (type) {
6231                 case DataType::AUDIO:
6232                         sp.push_back (_session_dir->sound_path());
6233                         break;
6234                 case DataType::MIDI:
6235                         sp.push_back (_session_dir->midi_path());
6236                         break;
6237                 }
6238         } else {
6239                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6240                         SessionDirectory sdir (i->path);
6241                         switch (type) {
6242                         case DataType::AUDIO:
6243                                 sp.push_back (sdir.sound_path());
6244                                 break;
6245                         case DataType::MIDI:
6246                                 sp.push_back (sdir.midi_path());
6247                                 break;
6248                         }
6249                 }
6250         }
6251
6252         if (type == DataType::AUDIO) {
6253                 const string sound_path_2X = _session_dir->sound_path_2X();
6254                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6255                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6256                                 sp.push_back (sound_path_2X);
6257                         }
6258                 }
6259         }
6260
6261         // now check the explicit (possibly user-specified) search path
6262
6263         switch (type) {
6264         case DataType::AUDIO:
6265                 sp += Searchpath(config.get_audio_search_path ());
6266                 break;
6267         case DataType::MIDI:
6268                 sp += Searchpath(config.get_midi_search_path ());
6269                 break;
6270         }
6271
6272         return sp;
6273 }
6274
6275 void
6276 Session::ensure_search_path_includes (const string& path, DataType type)
6277 {
6278         Searchpath sp;
6279
6280         if (path == ".") {
6281                 return;
6282         }
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         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6294                 /* No need to add this new directory if it has the same inode as
6295                    an existing one; checking inode rather than name prevents duplicated
6296                    directories when we are using symlinks.
6297
6298                    On Windows, I think we could just do if (*i == path) here.
6299                 */
6300                 if (PBD::equivalent_paths (*i, path)) {
6301                         return;
6302                 }
6303         }
6304
6305         sp += path;
6306
6307         switch (type) {
6308         case DataType::AUDIO:
6309                 config.set_audio_search_path (sp.to_string());
6310                 break;
6311         case DataType::MIDI:
6312                 config.set_midi_search_path (sp.to_string());
6313                 break;
6314         }
6315 }
6316
6317 void
6318 Session::remove_dir_from_search_path (const string& dir, DataType type)
6319 {
6320         Searchpath sp;
6321
6322         switch (type) {
6323         case DataType::AUDIO:
6324                 sp = Searchpath(config.get_audio_search_path ());
6325                 break;
6326         case DataType::MIDI:
6327                 sp = Searchpath (config.get_midi_search_path ());
6328                 break;
6329         }
6330
6331         sp -= dir;
6332
6333         switch (type) {
6334         case DataType::AUDIO:
6335                 config.set_audio_search_path (sp.to_string());
6336                 break;
6337         case DataType::MIDI:
6338                 config.set_midi_search_path (sp.to_string());
6339                 break;
6340         }
6341
6342 }
6343
6344 boost::shared_ptr<Speakers>
6345 Session::get_speakers()
6346 {
6347         return _speakers;
6348 }
6349
6350 list<string>
6351 Session::unknown_processors () const
6352 {
6353         list<string> p;
6354
6355         boost::shared_ptr<RouteList> r = routes.reader ();
6356         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6357                 list<string> t = (*i)->unknown_processors ();
6358                 copy (t.begin(), t.end(), back_inserter (p));
6359         }
6360
6361         p.sort ();
6362         p.unique ();
6363
6364         return p;
6365 }
6366
6367 void
6368 Session::update_latency (bool playback)
6369 {
6370         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6371
6372         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
6373                 return;
6374         }
6375
6376         boost::shared_ptr<RouteList> r = routes.reader ();
6377         framecnt_t max_latency = 0;
6378
6379         if (playback) {
6380                 /* reverse the list so that we work backwards from the last route to run to the first */
6381                 RouteList* rl = routes.reader().get();
6382                 r.reset (new RouteList (*rl));
6383                 reverse (r->begin(), r->end());
6384         }
6385
6386         /* compute actual latency values for the given direction and store them all in per-port
6387            structures. this will also publish the same values (to JACK) so that computation of latency
6388            for routes can consistently use public latency values.
6389         */
6390
6391         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6392                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6393         }
6394
6395         /* because we latency compensate playback, our published playback latencies should
6396            be the same for all output ports - all material played back by ardour has
6397            the same latency, whether its caused by plugins or by latency compensation. since
6398            these may differ from the values computed above, reset all playback port latencies
6399            to the same value.
6400         */
6401
6402         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6403
6404         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6405                 (*i)->set_public_port_latencies (max_latency, playback);
6406         }
6407
6408         if (playback) {
6409
6410                 post_playback_latency ();
6411
6412         } else {
6413
6414                 post_capture_latency ();
6415         }
6416
6417         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6418 }
6419
6420 void
6421 Session::post_playback_latency ()
6422 {
6423         set_worst_playback_latency ();
6424
6425         boost::shared_ptr<RouteList> r = routes.reader ();
6426
6427         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6428                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6429                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6430                 }
6431         }
6432
6433         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6434                 (*i)->set_latency_compensation (_worst_track_latency);
6435         }
6436 }
6437
6438 void
6439 Session::post_capture_latency ()
6440 {
6441         set_worst_capture_latency ();
6442
6443         /* reflect any changes in capture latencies into capture offsets
6444          */
6445
6446         boost::shared_ptr<RouteList> rl = routes.reader();
6447         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6448                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6449                 if (tr) {
6450                         tr->set_capture_offset ();
6451                 }
6452         }
6453 }
6454
6455 void
6456 Session::initialize_latencies ()
6457 {
6458         {
6459                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6460                 update_latency (false);
6461                 update_latency (true);
6462         }
6463
6464         set_worst_io_latencies ();
6465 }
6466
6467 void
6468 Session::set_worst_io_latencies ()
6469 {
6470         set_worst_playback_latency ();
6471         set_worst_capture_latency ();
6472 }
6473
6474 void
6475 Session::set_worst_playback_latency ()
6476 {
6477         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6478                 return;
6479         }
6480
6481         _worst_output_latency = 0;
6482
6483         if (!_engine.connected()) {
6484                 return;
6485         }
6486
6487         boost::shared_ptr<RouteList> r = routes.reader ();
6488
6489         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6490                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6491         }
6492
6493         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6494 }
6495
6496 void
6497 Session::set_worst_capture_latency ()
6498 {
6499         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6500                 return;
6501         }
6502
6503         _worst_input_latency = 0;
6504
6505         if (!_engine.connected()) {
6506                 return;
6507         }
6508
6509         boost::shared_ptr<RouteList> r = routes.reader ();
6510
6511         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6512                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6513         }
6514
6515         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6516 }
6517
6518 void
6519 Session::update_latency_compensation (bool force_whole_graph)
6520 {
6521         bool some_track_latency_changed = false;
6522
6523         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6524                 return;
6525         }
6526
6527         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6528
6529         _worst_track_latency = 0;
6530
6531         boost::shared_ptr<RouteList> r = routes.reader ();
6532
6533         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6534                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6535                         framecnt_t tl;
6536                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6537                                 some_track_latency_changed = true;
6538                         }
6539                         _worst_track_latency = max (tl, _worst_track_latency);
6540                 }
6541         }
6542
6543         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6544                                                      (some_track_latency_changed ? "yes" : "no")));
6545
6546         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6547
6548         if (some_track_latency_changed || force_whole_graph)  {
6549                 _engine.update_latencies ();
6550         }
6551
6552
6553         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6554                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6555                 if (!tr) {
6556                         continue;
6557                 }
6558                 tr->set_capture_offset ();
6559         }
6560 }
6561
6562 char
6563 Session::session_name_is_legal (const string& path)
6564 {
6565         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6566
6567         for (int i = 0; illegal_chars[i]; ++i) {
6568                 if (path.find (illegal_chars[i]) != string::npos) {
6569                         return illegal_chars[i];
6570                 }
6571         }
6572
6573         return 0;
6574 }
6575
6576 uint32_t
6577 Session::next_control_id () const
6578 {
6579         int subtract = 0;
6580
6581         /* the monitor bus remote ID is in a different
6582          * "namespace" than regular routes. its existence doesn't
6583          * affect normal (low) numbered routes.
6584          */
6585
6586         if (_monitor_out) {
6587                 subtract++;
6588         }
6589
6590         /* the same about masterbus in Waves Tracks */
6591
6592         if (Profile->get_trx() && _master_out) {
6593                 subtract++;
6594         }
6595
6596         return nroutes() - subtract;
6597 }
6598
6599 void
6600 Session::notify_remote_id_change ()
6601 {
6602         if (deletion_in_progress()) {
6603                 return;
6604         }
6605
6606         switch (Config->get_remote_model()) {
6607         case MixerOrdered:
6608                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6609                 break;
6610         default:
6611                 break;
6612         }
6613
6614 #ifdef USE_TRACKS_CODE_FEATURES
6615                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6616                  * if track order has been changed by user
6617                  */
6618                 reconnect_existing_routes(true, true);
6619 #endif
6620
6621 }
6622
6623 void
6624 Session::sync_order_keys ()
6625 {
6626         if (deletion_in_progress()) {
6627                 return;
6628         }
6629
6630         /* tell everyone that something has happened to the sort keys
6631            and let them sync up with the change(s)
6632            this will give objects that manage the sort order keys the
6633            opportunity to keep them in sync if they wish to.
6634         */
6635
6636         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6637
6638         reassign_track_numbers();
6639
6640         Route::SyncOrderKeys (); /* EMIT SIGNAL */
6641
6642         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6643 }
6644
6645 bool
6646 Session::operation_in_progress (GQuark op) const
6647 {
6648         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6649 }
6650
6651 boost::shared_ptr<Port>
6652 Session::ltc_input_port () const
6653 {
6654         return _ltc_input->nth (0);
6655 }
6656
6657 boost::shared_ptr<Port>
6658 Session::ltc_output_port () const
6659 {
6660         return _ltc_output->nth (0);
6661 }
6662
6663 void
6664 Session::reconnect_ltc_input ()
6665 {
6666         if (_ltc_input) {
6667
6668                 string src = Config->get_ltc_source_port();
6669
6670                 _ltc_input->disconnect (this);
6671
6672                 if (src != _("None") && !src.empty())  {
6673                         _ltc_input->nth (0)->connect (src);
6674                 }
6675
6676                 if ( ARDOUR::Profile->get_trx () ) {
6677                         // Tracks need this signal to update timecode_source_dropdown
6678                         MtcOrLtcInputPortChanged (); //emit signal
6679                 }
6680         }
6681 }
6682
6683 void
6684 Session::reconnect_ltc_output ()
6685 {
6686         if (_ltc_output) {
6687
6688                 string src = Config->get_ltc_output_port();
6689
6690                 _ltc_output->disconnect (this);
6691
6692                 if (src != _("None") && !src.empty())  {
6693                         _ltc_output->nth (0)->connect (src);
6694                 }
6695         }
6696 }
6697
6698 void
6699 Session::set_range_selection (framepos_t start, framepos_t end)
6700 {
6701         _range_selection = Evoral::Range<framepos_t> (start, end);
6702 #ifdef USE_TRACKS_CODE_FEATURES
6703         follow_playhead_priority ();
6704 #endif
6705 }
6706
6707 void
6708 Session::set_object_selection (framepos_t start, framepos_t end)
6709 {
6710         _object_selection = Evoral::Range<framepos_t> (start, end);
6711 #ifdef USE_TRACKS_CODE_FEATURES
6712         follow_playhead_priority ();
6713 #endif
6714 }
6715
6716 void
6717 Session::clear_range_selection ()
6718 {
6719         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6720 #ifdef USE_TRACKS_CODE_FEATURES
6721         follow_playhead_priority ();
6722 #endif
6723 }
6724
6725 void
6726 Session::clear_object_selection ()
6727 {
6728         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6729 #ifdef USE_TRACKS_CODE_FEATURES
6730         follow_playhead_priority ();
6731 #endif
6732 }
6733
6734 void
6735 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
6736                 const ChanCount& input_start,
6737                 const ChanCount& output_start,
6738                 const ChanCount& input_offset,
6739                 const ChanCount& output_offset)
6740 {
6741         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6742         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
6743                                 input_start, output_start,
6744                                 input_offset, output_offset));
6745
6746         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
6747                 pthread_cond_signal (&_auto_connect_cond);
6748                 pthread_mutex_unlock (&_auto_connect_mutex);
6749         }
6750 }
6751
6752 void
6753 Session::auto_connect (const AutoConnectRequest& ar)
6754 {
6755         boost::shared_ptr<Route> route = ar.route.lock();
6756
6757         if (!route) { return; }
6758
6759         if (!IO::connecting_legal) {
6760                 return;
6761         }
6762
6763         /* If both inputs and outputs are auto-connected to physical ports,
6764          * use the max of input and output offsets to ensure auto-connected
6765          * port numbers always match up (e.g. the first audio input and the
6766          * first audio output of the route will have the same physical
6767          * port number).  Otherwise just use the lowest input or output
6768          * offset possible.
6769          */
6770
6771         const bool in_out_physical =
6772                 (Config->get_input_auto_connect() & AutoConnectPhysical)
6773                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
6774                 && ar.connect_inputs;
6775
6776         const ChanCount in_offset = in_out_physical
6777                 ? ChanCount::max(ar.input_offset, ar.output_offset)
6778                 : ar.input_offset;
6779
6780         const ChanCount out_offset = in_out_physical
6781                 ? ChanCount::max(ar.input_offset, ar.output_offset)
6782                 : ar.output_offset;
6783
6784         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6785                 vector<string> physinputs;
6786                 vector<string> physoutputs;
6787
6788                 _engine.get_physical_outputs (*t, physoutputs);
6789                 _engine.get_physical_inputs (*t, physinputs);
6790
6791                 if (!physinputs.empty() && ar.connect_inputs) {
6792                         uint32_t nphysical_in = physinputs.size();
6793
6794                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
6795                                 string port;
6796
6797                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
6798                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
6799                                 }
6800
6801                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
6802                                         break;
6803                                 }
6804                         }
6805                 }
6806
6807                 if (!physoutputs.empty()) {
6808                         uint32_t nphysical_out = physoutputs.size();
6809                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
6810                                 string port;
6811
6812                                 /* Waves Tracks:
6813                                  * do not create new connections if we reached the limit of physical outputs
6814                                  * in Multi Out mode
6815                                  */
6816                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
6817                                                 ARDOUR::Profile->get_trx () &&
6818                                                 ar.output_offset.get(*t) == nphysical_out ) {
6819                                         break;
6820                                 }
6821
6822                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
6823                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
6824                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
6825                                         /* master bus is audio only */
6826                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
6827                                                 port = _master_out->input()->ports().port(*t,
6828                                                                 i % _master_out->input()->n_ports().get(*t))->name();
6829                                         }
6830                                 }
6831
6832                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
6833                                         break;
6834                                 }
6835                         }
6836                 }
6837         }
6838 }
6839
6840 void
6841 Session::auto_connect_thread_start ()
6842 {
6843         if (_ac_thread_active) {
6844                 return;
6845         }
6846
6847         while (!_auto_connect_queue.empty ()) {
6848                 _auto_connect_queue.pop ();
6849         }
6850
6851         _ac_thread_active = true;
6852         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
6853                 _ac_thread_active = false;
6854         }
6855 }
6856
6857 void
6858 Session::auto_connect_thread_terminate ()
6859 {
6860         if (!_ac_thread_active) {
6861                 return;
6862         }
6863         _ac_thread_active = false;
6864
6865         {
6866                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6867                 while (!_auto_connect_queue.empty ()) {
6868                         _auto_connect_queue.pop ();
6869                 }
6870         }
6871
6872         if (pthread_mutex_lock (&_auto_connect_mutex) == 0) {
6873                 pthread_cond_signal (&_auto_connect_cond);
6874                 pthread_mutex_unlock (&_auto_connect_mutex);
6875         }
6876
6877         void *status;
6878         pthread_join (_auto_connect_thread, &status);
6879 }
6880
6881 void *
6882 Session::auto_connect_thread (void *arg)
6883 {
6884         Session *s = static_cast<Session *>(arg);
6885         s->auto_connect_thread_run ();
6886         pthread_exit (0);
6887         return 0;
6888 }
6889
6890 void
6891 Session::auto_connect_thread_run ()
6892 {
6893         pthread_set_name (X_("autoconnect"));
6894         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
6895         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
6896         pthread_mutex_lock (&_auto_connect_mutex);
6897         while (_ac_thread_active) {
6898
6899                 if (!_auto_connect_queue.empty ()) {
6900                         // Why would we need the process lock ??
6901                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
6902                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
6903                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
6904                         //   We have control over those, but what does jack do?
6905                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
6906
6907                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6908                         while (!_auto_connect_queue.empty ()) {
6909                                 const AutoConnectRequest ar (_auto_connect_queue.front());
6910                                 _auto_connect_queue.pop ();
6911                                 lx.release ();
6912                                 auto_connect (ar);
6913                                 lx.acquire ();
6914                         }
6915                 }
6916
6917                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
6918         }
6919         pthread_mutex_unlock (&_auto_connect_mutex);
6920 }