libs/ardour/session.cc

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