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