libs/ardour/session.cc

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