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