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