libs/ardour/session.cc

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