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