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