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