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