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