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, _1, wpr));
3210                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, 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 (void* /*src*/, 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_solo_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                         boost::shared_ptr<RouteList> r = routes.reader ();
3508                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3509                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() || (leave_group_alone && ((*i)->route_group() == rg))) {
3510                                         continue;
3511                                 }
3512                                 (*i)->set_listen (false, this);
3513                         }
3514                 }
3515
3516                 _listen_cnt++;
3517
3518         } else if (_listen_cnt > 0) {
3519
3520                 _listen_cnt--;
3521         }
3522
3523         update_route_solo_state ();
3524 }
3525 void
3526 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3527 {
3528         boost::shared_ptr<Route> route = wpr.lock ();
3529
3530         if (!route) {
3531                 /* should not happen */
3532                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_isolated_changed")) << endmsg;
3533                 return;
3534         }
3535
3536         bool send_changed = false;
3537
3538         if (route->solo_isolated()) {
3539                 if (_solo_isolated_cnt == 0) {
3540                         send_changed = true;
3541                 }
3542                 _solo_isolated_cnt++;
3543         } else if (_solo_isolated_cnt > 0) {
3544                 _solo_isolated_cnt--;
3545                 if (_solo_isolated_cnt == 0) {
3546                         send_changed = true;
3547                 }
3548         }
3549
3550         if (send_changed) {
3551                 IsolatedChanged (); /* EMIT SIGNAL */
3552         }
3553 }
3554
3555 void
3556 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
3557 {
3558         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3559
3560         if (!self_solo_change) {
3561                 // session doesn't care about changes to soloed-by-others
3562                 return;
3563         }
3564
3565         boost::shared_ptr<Route> route = wpr.lock ();
3566         assert (route);
3567
3568         boost::shared_ptr<RouteList> r = routes.reader ();
3569         int32_t delta;
3570
3571         if (route->self_soloed()) {
3572                 delta = 1;
3573         } else {
3574                 delta = -1;
3575         }
3576
3577         RouteGroup* rg = route->route_group ();
3578         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
3579
3580         if (delta == 1 && Config->get_exclusive_solo()) {
3581
3582                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3583
3584                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3585                         if ((*i) == route || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3586                             (leave_group_alone && ((*i)->route_group() == rg))) {
3587                                 continue;
3588                         }
3589                         (*i)->set_solo (false, this);
3590                 }
3591         }
3592
3593         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3594
3595         RouteList uninvolved;
3596
3597         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3598
3599         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3600                 bool via_sends_only;
3601                 bool in_signal_flow;
3602
3603                 if ((*i) == route || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3604                     (leave_group_alone && ((*i)->route_group() == rg))) {
3605                         continue;
3606                 }
3607
3608                 in_signal_flow = false;
3609
3610                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3611
3612                 if ((*i)->feeds (route, &via_sends_only)) {
3613                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3614                         if (!via_sends_only) {
3615                                 if (!route->soloed_by_others_upstream()) {
3616                                         (*i)->mod_solo_by_others_downstream (delta);
3617                                 }
3618                         } else {
3619                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3620                         }
3621                         in_signal_flow = true;
3622                 } else {
3623                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3624                 }
3625
3626                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3627
3628                 if (route->feeds (*i, &via_sends_only)) {
3629                         /* propagate solo upstream only if routing other than
3630                            sends is involved, but do consider the other route
3631                            (*i) to be part of the signal flow even if only
3632                            sends are involved.
3633                         */
3634                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3635                                                                   route->name(),
3636                                                                   (*i)->name(),
3637                                                                   via_sends_only,
3638                                                                   route->soloed_by_others_downstream(),
3639                                                                   route->soloed_by_others_upstream()));
3640                         if (!via_sends_only) {
3641                                 if (!route->soloed_by_others_downstream()) {
3642                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3643                                         (*i)->mod_solo_by_others_upstream (delta);
3644                                 } else {
3645                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3646                                 }
3647                         } else {
3648                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3649                         }
3650                         in_signal_flow = true;
3651                 } else {
3652                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3653                 }
3654
3655                 if (!in_signal_flow) {
3656                         uninvolved.push_back (*i);
3657                 }
3658         }
3659
3660         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3661
3662         update_route_solo_state (r);
3663
3664         /* now notify that the mute state of the routes not involved in the signal
3665            pathway of the just-solo-changed route may have altered.
3666         */
3667
3668         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3669                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3670                 (*i)->act_on_mute ();
3671                 (*i)->mute_changed (this);
3672         }
3673
3674         SoloChanged (); /* EMIT SIGNAL */
3675         set_dirty();
3676 }
3677
3678 void
3679 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3680 {
3681         /* now figure out if anything that matters is soloed (or is "listening")*/
3682
3683         bool something_soloed = false;
3684         uint32_t listeners = 0;
3685         uint32_t isolated = 0;
3686
3687         if (!r) {
3688                 r = routes.reader();
3689         }
3690
3691         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3692                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3693                         something_soloed = true;
3694                 }
3695
3696                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3697                         if (Config->get_solo_control_is_listen_control()) {
3698                                 listeners++;
3699                         } else {
3700                                 (*i)->set_listen (false, this);
3701                         }
3702                 }
3703
3704                 if ((*i)->solo_isolated()) {
3705                         isolated++;
3706                 }
3707         }
3708
3709         if (something_soloed != _non_soloed_outs_muted) {
3710                 _non_soloed_outs_muted = something_soloed;
3711                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3712         }
3713
3714         _listen_cnt = listeners;
3715
3716         if (isolated != _solo_isolated_cnt) {
3717                 _solo_isolated_cnt = isolated;
3718                 IsolatedChanged (); /* EMIT SIGNAL */
3719         }
3720
3721         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3722                                                   something_soloed, listeners, isolated));
3723 }
3724
3725 boost::shared_ptr<RouteList>
3726 Session::get_routes_with_internal_returns() const
3727 {
3728         boost::shared_ptr<RouteList> r = routes.reader ();
3729         boost::shared_ptr<RouteList> rl (new RouteList);
3730
3731         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3732                 if ((*i)->internal_return ()) {
3733                         rl->push_back (*i);
3734                 }
3735         }
3736         return rl;
3737 }
3738
3739 bool
3740 Session::io_name_is_legal (const std::string& name)
3741 {
3742         boost::shared_ptr<RouteList> r = routes.reader ();
3743
3744         for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
3745                 if (name == *reserved) {
3746                         return false;
3747                 }
3748         }
3749
3750         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3751                 if ((*i)->name() == name) {
3752                         return false;
3753                 }
3754
3755                 if ((*i)->has_io_processor_named (name)) {
3756                         return false;
3757                 }
3758         }
3759
3760         return true;
3761 }
3762
3763 void
3764 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3765 {
3766         RouteList rl2;
3767         vector<string> connections;
3768
3769         /* if we are passed only a single route and we're not told to turn
3770          * others off, then just do the simple thing.
3771          */
3772
3773         if (flip_others == false && rl->size() == 1) {
3774                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3775                 if (mt) {
3776                         mt->set_input_active (onoff);
3777                         return;
3778                 }
3779         }
3780
3781         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3782
3783                 PortSet& ps ((*rt)->input()->ports());
3784
3785                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3786                         p->get_connections (connections);
3787                 }
3788
3789                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3790                         routes_using_input_from (*s, rl2);
3791                 }
3792
3793                 /* scan all relevant routes to see if others are on or off */
3794
3795                 bool others_are_already_on = false;
3796
3797                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3798
3799                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3800
3801                         if (!mt) {
3802                                 continue;
3803                         }
3804
3805                         if ((*r) != (*rt)) {
3806                                 if (mt->input_active()) {
3807                                         others_are_already_on = true;
3808                                 }
3809                         } else {
3810                                 /* this one needs changing */
3811                                 mt->set_input_active (onoff);
3812                         }
3813                 }
3814
3815                 if (flip_others) {
3816
3817                         /* globally reverse other routes */
3818
3819                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3820                                 if ((*r) != (*rt)) {
3821                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3822                                         if (mt) {
3823                                                 mt->set_input_active (!others_are_already_on);
3824                                         }
3825                                 }
3826                         }
3827                 }
3828         }
3829 }
3830
3831 void
3832 Session::routes_using_input_from (const string& str, RouteList& rl)
3833 {
3834         boost::shared_ptr<RouteList> r = routes.reader();
3835
3836         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3837                 if ((*i)->input()->connected_to (str)) {
3838                         rl.push_back (*i);
3839                 }
3840         }
3841 }
3842
3843 boost::shared_ptr<Route>
3844 Session::route_by_name (string name)
3845 {
3846         boost::shared_ptr<RouteList> r = routes.reader ();
3847
3848         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3849                 if ((*i)->name() == name) {
3850                         return *i;
3851                 }
3852         }
3853
3854         return boost::shared_ptr<Route> ((Route*) 0);
3855 }
3856
3857 boost::shared_ptr<Route>
3858 Session::route_by_id (PBD::ID id)
3859 {
3860         boost::shared_ptr<RouteList> r = routes.reader ();
3861
3862         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3863                 if ((*i)->id() == id) {
3864                         return *i;
3865                 }
3866         }
3867
3868         return boost::shared_ptr<Route> ((Route*) 0);
3869 }
3870
3871 boost::shared_ptr<Track>
3872 Session::track_by_diskstream_id (PBD::ID id)
3873 {
3874         boost::shared_ptr<RouteList> r = routes.reader ();
3875
3876         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3877                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3878                 if (t && t->using_diskstream_id (id)) {
3879                         return t;
3880                 }
3881         }
3882
3883         return boost::shared_ptr<Track> ();
3884 }
3885
3886 boost::shared_ptr<Route>
3887 Session::route_by_remote_id (uint32_t id)
3888 {
3889         boost::shared_ptr<RouteList> r = routes.reader ();
3890
3891         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3892                 if ((*i)->remote_control_id() == id) {
3893                         return *i;
3894                 }
3895         }
3896
3897         return boost::shared_ptr<Route> ((Route*) 0);
3898 }
3899
3900
3901 void
3902 Session::reassign_track_numbers ()
3903 {
3904         int64_t tn = 0;
3905         int64_t bn = 0;
3906         RouteList r (*(routes.reader ()));
3907         SignalOrderRouteSorter sorter;
3908         r.sort (sorter);
3909
3910         StateProtector sp (this);
3911
3912         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3913                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3914                         (*i)->set_track_number(++tn);
3915                 }
3916                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3917                         (*i)->set_track_number(--bn);
3918                 }
3919         }
3920         const uint32_t decimals = ceilf (log10f (tn + 1));
3921         const bool decimals_changed = _track_number_decimals != decimals;
3922         _track_number_decimals = decimals;
3923
3924         if (decimals_changed && config.get_track_name_number ()) {
3925                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3926                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3927                         if (t) {
3928                                 t->resync_track_name();
3929                         }
3930                 }
3931                 // trigger GUI re-layout
3932                 config.ParameterChanged("track-name-number");
3933         }
3934 }
3935
3936 void
3937 Session::playlist_region_added (boost::weak_ptr<Region> w)
3938 {
3939         boost::shared_ptr<Region> r = w.lock ();
3940         if (!r) {
3941                 return;
3942         }
3943
3944         /* These are the operations that are currently in progress... */
3945         list<GQuark> curr = _current_trans_quarks;
3946         curr.sort ();
3947
3948         /* ...and these are the operations during which we want to update
3949            the session range location markers.
3950         */
3951         list<GQuark> ops;
3952         ops.push_back (Operations::capture);
3953         ops.push_back (Operations::paste);
3954         ops.push_back (Operations::duplicate_region);
3955         ops.push_back (Operations::insert_file);
3956         ops.push_back (Operations::insert_region);
3957         ops.push_back (Operations::drag_region_brush);
3958         ops.push_back (Operations::region_drag);
3959         ops.push_back (Operations::selection_grab);
3960         ops.push_back (Operations::region_fill);
3961         ops.push_back (Operations::fill_selection);
3962         ops.push_back (Operations::create_region);
3963         ops.push_back (Operations::region_copy);
3964         ops.push_back (Operations::fixed_time_region_copy);
3965         ops.sort ();
3966
3967         /* See if any of the current operations match the ones that we want */
3968         list<GQuark> in;
3969         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3970
3971         /* If so, update the session range markers */
3972         if (!in.empty ()) {
3973                 maybe_update_session_range (r->position (), r->last_frame ());
3974         }
3975 }
3976
3977 /** Update the session range markers if a is before the current start or
3978  *  b is after the current end.
3979  */
3980 void
3981 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3982 {
3983         if (_state_of_the_state & Loading) {
3984                 return;
3985         }
3986
3987         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
3988
3989         if (_session_range_location == 0) {
3990
3991                 set_session_range_location (a, b + session_end_marker_shift_samples);
3992
3993         } else {
3994
3995                 if (a < _session_range_location->start()) {
3996                         _session_range_location->set_start (a);
3997                 }
3998
3999                 if (b > _session_range_location->end()) {
4000                         _session_range_location->set_end (b);
4001                 }
4002         }
4003 }
4004
4005 void
4006 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4007 {
4008         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4009                 maybe_update_session_range (i->to, i->to + i->length);
4010         }
4011 }
4012
4013 void
4014 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4015 {
4016         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4017                 maybe_update_session_range (i->from, i->to);
4018         }
4019 }
4020
4021 /* Region management */
4022
4023 boost::shared_ptr<Region>
4024 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4025 {
4026         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4027         RegionFactory::RegionMap::const_iterator i;
4028         boost::shared_ptr<Region> region;
4029
4030         Glib::Threads::Mutex::Lock lm (region_lock);
4031
4032         for (i = regions.begin(); i != regions.end(); ++i) {
4033
4034                 region = i->second;
4035
4036                 if (region->whole_file()) {
4037
4038                         if (child->source_equivalent (region)) {
4039                                 return region;
4040                         }
4041                 }
4042         }
4043
4044         return boost::shared_ptr<Region> ();
4045 }
4046
4047 int
4048 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4049 {
4050         set<boost::shared_ptr<Region> > relevant_regions;
4051
4052         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4053                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4054         }
4055
4056         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4057                 set<boost::shared_ptr<Region> >::iterator tmp;
4058
4059                 tmp = r;
4060                 ++tmp;
4061
4062                 playlists->destroy_region (*r);
4063                 RegionFactory::map_remove (*r);
4064
4065                 (*r)->drop_sources ();
4066                 (*r)->drop_references ();
4067
4068                 relevant_regions.erase (r);
4069
4070                 r = tmp;
4071         }
4072
4073         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4074
4075                 {
4076                         Glib::Threads::Mutex::Lock ls (source_lock);
4077                         /* remove from the main source list */
4078                         sources.erase ((*s)->id());
4079                 }
4080
4081                 (*s)->mark_for_remove ();
4082                 (*s)->drop_references ();
4083
4084                 s = srcs.erase (s);
4085         }
4086
4087         return 0;
4088 }
4089
4090 int
4091 Session::remove_last_capture ()
4092 {
4093         list<boost::shared_ptr<Source> > srcs;
4094
4095         boost::shared_ptr<RouteList> rl = routes.reader ();
4096         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4097                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4098                 if (!tr) {
4099                         continue;
4100                 }
4101
4102                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4103
4104                 if (!l.empty()) {
4105                         srcs.insert (srcs.end(), l.begin(), l.end());
4106                         l.clear ();
4107                 }
4108         }
4109
4110         destroy_sources (srcs);
4111
4112         save_state (_current_snapshot_name);
4113
4114         return 0;
4115 }
4116
4117 /* Source Management */
4118
4119 void
4120 Session::add_source (boost::shared_ptr<Source> source)
4121 {
4122         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4123         pair<SourceMap::iterator,bool> result;
4124
4125         entry.first = source->id();
4126         entry.second = source;
4127
4128         {
4129                 Glib::Threads::Mutex::Lock lm (source_lock);
4130                 result = sources.insert (entry);
4131         }
4132
4133         if (result.second) {
4134
4135                 /* yay, new source */
4136
4137                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4138
4139                 if (fs) {
4140                         if (!fs->within_session()) {
4141                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4142                         }
4143                 }
4144
4145                 set_dirty();
4146
4147                 boost::shared_ptr<AudioFileSource> afs;
4148
4149                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4150                         if (Config->get_auto_analyse_audio()) {
4151                                 Analyser::queue_source_for_analysis (source, false);
4152                         }
4153                 }
4154
4155                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4156         }
4157 }
4158
4159 void
4160 Session::remove_source (boost::weak_ptr<Source> src)
4161 {
4162         if (_state_of_the_state & Deletion) {
4163                 return;
4164         }
4165
4166         SourceMap::iterator i;
4167         boost::shared_ptr<Source> source = src.lock();
4168
4169         if (!source) {
4170                 return;
4171         }
4172
4173         {
4174                 Glib::Threads::Mutex::Lock lm (source_lock);
4175
4176                 if ((i = sources.find (source->id())) != sources.end()) {
4177                         sources.erase (i);
4178                 }
4179         }
4180
4181         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4182
4183                 /* save state so we don't end up with a session file
4184                    referring to non-existent sources.
4185                 */
4186
4187                 save_state (_current_snapshot_name);
4188         }
4189 }
4190
4191 boost::shared_ptr<Source>
4192 Session::source_by_id (const PBD::ID& id)
4193 {
4194         Glib::Threads::Mutex::Lock lm (source_lock);
4195         SourceMap::iterator i;
4196         boost::shared_ptr<Source> source;
4197
4198         if ((i = sources.find (id)) != sources.end()) {
4199                 source = i->second;
4200         }
4201
4202         return source;
4203 }
4204
4205 boost::shared_ptr<AudioFileSource>
4206 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4207 {
4208         /* Restricted to audio files because only audio sources have channel
4209            as a property.
4210         */
4211
4212         Glib::Threads::Mutex::Lock lm (source_lock);
4213
4214         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4215                 boost::shared_ptr<AudioFileSource> afs
4216                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4217
4218                 if (afs && afs->path() == path && chn == afs->channel()) {
4219                         return afs;
4220                 }
4221         }
4222
4223         return boost::shared_ptr<AudioFileSource>();
4224 }
4225
4226 boost::shared_ptr<MidiSource>
4227 Session::midi_source_by_path (const std::string& path) const
4228 {
4229         /* Restricted to MIDI files because audio sources require a channel
4230            for unique identification, in addition to a path.
4231         */
4232
4233         Glib::Threads::Mutex::Lock lm (source_lock);
4234
4235         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4236                 boost::shared_ptr<MidiSource> ms
4237                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4238                 boost::shared_ptr<FileSource> fs
4239                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4240
4241                 if (ms && fs && fs->path() == path) {
4242                         return ms;
4243                 }
4244         }
4245
4246         return boost::shared_ptr<MidiSource>();
4247 }
4248
4249 uint32_t
4250 Session::count_sources_by_origin (const string& path)
4251 {
4252         uint32_t cnt = 0;
4253         Glib::Threads::Mutex::Lock lm (source_lock);
4254
4255         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4256                 boost::shared_ptr<FileSource> fs
4257                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4258
4259                 if (fs && fs->origin() == path) {
4260                         ++cnt;
4261                 }
4262         }
4263
4264         return cnt;
4265 }
4266
4267 static string
4268 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4269         if (hash) {
4270                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4271                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4272         } else {
4273                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4274         }
4275 }
4276
4277 string
4278 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4279 {
4280         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4281
4282         if (Glib::path_is_absolute (filepath)) {
4283
4284                 /* rip the session dir from the audiofile source */
4285
4286                 string session_path;
4287                 bool in_another_session = true;
4288
4289                 if (filepath.find (interchange_dir_string) != string::npos) {
4290
4291                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4292                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4293                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4294                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4295
4296                         /* see if it is within our session */
4297
4298                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4299                                 if (i->path == session_path) {
4300                                         in_another_session = false;
4301                                         break;
4302                                 }
4303                         }
4304                 } else {
4305                         in_another_session = false;
4306                 }
4307
4308
4309                 if (in_another_session) {
4310                         SessionDirectory sd (session_path);
4311                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4312                 }
4313         }
4314
4315         /* 1) if file belongs to this session
4316          * it may be a relative path (interchange/...)
4317          * or just basename (session_state, remove source)
4318          * -> just use the basename
4319          */
4320         std::string filename = Glib::path_get_basename (filepath);
4321         std::string path;
4322
4323         /* 2) if the file is outside our session dir:
4324          * (imported but not copied) add the path for check-summming */
4325         if (!in_session) {
4326                 path = Glib::path_get_dirname (filepath);
4327         }
4328
4329         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4330 }
4331
4332 string
4333 Session::new_audio_source_path_for_embedded (const std::string& path)
4334 {
4335         /* embedded source:
4336          *
4337          * we know that the filename is already unique because it exists
4338          * out in the filesystem.
4339          *
4340          * However, when we bring it into the session, we could get a
4341          * collision.
4342          *
4343          * Eg. two embedded files:
4344          *
4345          *          /foo/bar/baz.wav
4346          *          /frob/nic/baz.wav
4347          *
4348          * When merged into session, these collide.
4349          *
4350          * There will not be a conflict with in-memory sources
4351          * because when the source was created we already picked
4352          * a unique name for it.
4353          *
4354          * This collision is not likely to be common, but we have to guard
4355          * against it.  So, if there is a collision, take the md5 hash of the
4356          * the path, and use that as the filename instead.
4357          */
4358
4359         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4360         string base = Glib::path_get_basename (path);
4361         string newpath = Glib::build_filename (sdir.sound_path(), base);
4362
4363         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4364
4365                 MD5 md5;
4366
4367                 md5.digestString (path.c_str());
4368                 md5.writeToString ();
4369                 base = md5.digestChars;
4370
4371                 string ext = get_suffix (path);
4372
4373                 if (!ext.empty()) {
4374                         base += '.';
4375                         base += ext;
4376                 }
4377
4378                 newpath = Glib::build_filename (sdir.sound_path(), base);
4379
4380                 /* if this collides, we're screwed */
4381
4382                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4383                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4384                         return string();
4385                 }
4386
4387         }
4388
4389         return newpath;
4390 }
4391
4392 /** Return true if there are no audio file sources that use @param name as
4393  * the filename component of their path.
4394  *
4395  * Return false otherwise.
4396  *
4397  * This method MUST ONLY be used to check in-session, mono files since it
4398  * hard-codes the channel of the audio file source we are looking for as zero.
4399  *
4400  * If/when Ardour supports native files in non-mono formats, the logic here
4401  * will need to be revisited.
4402  */
4403 bool
4404 Session::audio_source_name_is_unique (const string& name)
4405 {
4406         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4407         vector<space_and_path>::iterator i;
4408         uint32_t existing = 0;
4409
4410         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4411
4412                 /* note that we search *without* the extension so that
4413                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4414                    in the event that this new name is required for
4415                    a file format change.
4416                 */
4417
4418                 const string spath = *i;
4419
4420                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4421                         existing++;
4422                         break;
4423                 }
4424
4425                 /* it is possible that we have the path already
4426                  * assigned to a source that has not yet been written
4427                  * (ie. the write source for a diskstream). we have to
4428                  * check this in order to make sure that our candidate
4429                  * path isn't used again, because that can lead to
4430                  * two Sources point to the same file with different
4431                  * notions of their removability.
4432                  */
4433
4434
4435                 string possible_path = Glib::build_filename (spath, name);
4436
4437                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4438                         existing++;
4439                         break;
4440                 }
4441         }
4442
4443         return (existing == 0);
4444 }
4445
4446 string
4447 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)
4448 {
4449         ostringstream sstr;
4450         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4451
4452         if (Profile->get_trx() && destructive) {
4453                 sstr << 'T';
4454                 sstr << setfill ('0') << setw (4) << cnt;
4455                 sstr << legalized_base;
4456         } else {
4457                 sstr << legalized_base;
4458
4459                 if (take_required || related_exists) {
4460                         sstr << '-';
4461                         sstr << cnt;
4462                 }
4463         }
4464
4465         if (nchan == 2) {
4466                 if (chan == 0) {
4467                         sstr << "%L";
4468                 } else {
4469                         sstr << "%R";
4470                 }
4471         } else if (nchan > 2) {
4472                 if (nchan < 26) {
4473                         sstr << '%';
4474                         sstr << 'a' + chan;
4475                 } else {
4476                         /* XXX what? more than 26 channels! */
4477                         sstr << '%';
4478                         sstr << chan+1;
4479                 }
4480         }
4481
4482         sstr << ext;
4483
4484         return sstr.str();
4485 }
4486
4487 /** Return a unique name based on \a base for a new internal audio source */
4488 string
4489 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4490 {
4491         uint32_t cnt;
4492         string possible_name;
4493         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4494         string legalized;
4495         bool some_related_source_name_exists = false;
4496
4497         legalized = legalize_for_path (base);
4498
4499         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4500
4501         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4502
4503                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4504
4505                 if (audio_source_name_is_unique (possible_name)) {
4506                         break;
4507                 }
4508
4509                 some_related_source_name_exists = true;
4510
4511                 if (cnt > limit) {
4512                         error << string_compose(
4513                                         _("There are already %1 recordings for %2, which I consider too many."),
4514                                         limit, base) << endmsg;
4515                         destroy ();
4516                         throw failed_constructor();
4517                 }
4518         }
4519
4520         /* We've established that the new name does not exist in any session
4521          * directory, so now find out which one we should use for this new
4522          * audio source.
4523          */
4524
4525         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4526
4527         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4528
4529         return s;
4530 }
4531
4532 /** Return a unique name based on `base` for a new internal MIDI source */
4533 string
4534 Session::new_midi_source_path (const string& base)
4535 {
4536         uint32_t cnt;
4537         char buf[PATH_MAX+1];
4538         const uint32_t limit = 10000;
4539         string legalized;
4540         string possible_path;
4541         string possible_name;
4542
4543         buf[0] = '\0';
4544         legalized = legalize_for_path (base);
4545
4546         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4547         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4548
4549         /* - the main session folder is the first in the vector.
4550          * - after checking all locations for file-name uniqueness,
4551          *   we keep the one from the last iteration as new file name
4552          * - midi files are small and should just be kept in the main session-folder
4553          *
4554          * -> reverse the array, check main session folder last and use that as location
4555          *    for MIDI files.
4556          */
4557         std::reverse(sdirs.begin(), sdirs.end());
4558
4559         for (cnt = 1; cnt <= limit; ++cnt) {
4560
4561                 vector<space_and_path>::iterator i;
4562                 uint32_t existing = 0;
4563
4564                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4565
4566                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4567                         possible_name = buf;
4568
4569                         possible_path = Glib::build_filename (*i, possible_name);
4570
4571                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4572                                 existing++;
4573                         }
4574
4575                         if (midi_source_by_path (possible_path)) {
4576                                 existing++;
4577                         }
4578                 }
4579
4580                 if (existing == 0) {
4581                         break;
4582                 }
4583
4584                 if (cnt > limit) {
4585                         error << string_compose(
4586                                         _("There are already %1 recordings for %2, which I consider too many."),
4587                                         limit, base) << endmsg;
4588                         destroy ();
4589                         return 0;
4590                 }
4591         }
4592
4593         /* No need to "find best location" for software/app-based RAID, because
4594            MIDI is so small that we always put it in the same place.
4595         */
4596
4597         return possible_path;
4598 }
4599
4600
4601 /** Create a new within-session audio source */
4602 boost::shared_ptr<AudioFileSource>
4603 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4604 {
4605         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4606
4607         if (!path.empty()) {
4608                 return boost::dynamic_pointer_cast<AudioFileSource> (
4609                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
4610         } else {
4611                 throw failed_constructor ();
4612         }
4613 }
4614
4615 /** Create a new within-session MIDI source */
4616 boost::shared_ptr<MidiSource>
4617 Session::create_midi_source_for_session (string const & basic_name)
4618 {
4619         const string path = new_midi_source_path (basic_name);
4620
4621         if (!path.empty()) {
4622                 return boost::dynamic_pointer_cast<SMFSource> (
4623                         SourceFactory::createWritable (
4624                                 DataType::MIDI, *this, path, false, frame_rate()));
4625         } else {
4626                 throw failed_constructor ();
4627         }
4628 }
4629
4630 /** Create a new within-session MIDI source */
4631 boost::shared_ptr<MidiSource>
4632 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4633 {
4634         /* the caller passes in the track the source will be used in,
4635            so that we can keep the numbering sane.
4636
4637            Rationale: a track with the name "Foo" that has had N
4638            captures carried out so far will ALREADY have a write source
4639            named "Foo-N+1.mid" waiting to be used for the next capture.
4640
4641            If we call new_midi_source_name() we will get "Foo-N+2". But
4642            there is no region corresponding to "Foo-N+1", so when
4643            "Foo-N+2" appears in the track, the gap presents the user
4644            with odd behaviour - why did it skip past Foo-N+1?
4645
4646            We could explain this to the user in some odd way, but
4647            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4648            use "Foo-N+1" here.
4649
4650            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4651         */
4652
4653         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4654         assert (mt);
4655         std::string name = track->steal_write_source_name ();
4656
4657         if (name.empty()) {
4658                 return boost::shared_ptr<MidiSource>();
4659         }
4660
4661         /* MIDI files are small, just put them in the first location of the
4662            session source search path.
4663         */
4664
4665         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4666
4667         return boost::dynamic_pointer_cast<SMFSource> (
4668                 SourceFactory::createWritable (
4669                         DataType::MIDI, *this, path, false, frame_rate()));
4670 }
4671
4672
4673 void
4674 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4675 {
4676         if (playlist->hidden()) {
4677                 return;
4678         }
4679
4680         playlists->add (playlist);
4681
4682         if (unused) {
4683                 playlist->release();
4684         }
4685
4686         set_dirty();
4687 }
4688
4689 void
4690 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4691 {
4692         if (_state_of_the_state & Deletion) {
4693                 return;
4694         }
4695
4696         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4697
4698         if (!playlist) {
4699                 return;
4700         }
4701
4702         playlists->remove (playlist);
4703
4704         set_dirty();
4705 }
4706
4707 void
4708 Session::set_audition (boost::shared_ptr<Region> r)
4709 {
4710         pending_audition_region = r;
4711         add_post_transport_work (PostTransportAudition);
4712         _butler->schedule_transport_work ();
4713 }
4714
4715 void
4716 Session::audition_playlist ()
4717 {
4718         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4719         ev->region.reset ();
4720         queue_event (ev);
4721 }
4722
4723 void
4724 Session::non_realtime_set_audition ()
4725 {
4726         assert (pending_audition_region);
4727         auditioner->audition_region (pending_audition_region);
4728         pending_audition_region.reset ();
4729         AuditionActive (true); /* EMIT SIGNAL */
4730 }
4731
4732 void
4733 Session::audition_region (boost::shared_ptr<Region> r)
4734 {
4735         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4736         ev->region = r;
4737         queue_event (ev);
4738 }
4739
4740 void
4741 Session::cancel_audition ()
4742 {
4743         if (!auditioner) {
4744                 return;
4745         }
4746         if (auditioner->auditioning()) {
4747                 auditioner->cancel_audition ();
4748                 AuditionActive (false); /* EMIT SIGNAL */
4749         }
4750 }
4751
4752 bool
4753 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4754 {
4755         if (a->is_monitor()) {
4756                 return true;
4757         }
4758         if (b->is_monitor()) {
4759                 return false;
4760         }
4761         return a->order_key () < b->order_key ();
4762 }
4763
4764 bool
4765 Session::is_auditioning () const
4766 {
4767         /* can be called before we have an auditioner object */
4768         if (auditioner) {
4769                 return auditioner->auditioning();
4770         } else {
4771                 return false;
4772         }
4773 }
4774
4775 void
4776 Session::graph_reordered ()
4777 {
4778         /* don't do this stuff if we are setting up connections
4779            from a set_state() call or creating new tracks. Ditto for deletion.
4780         */
4781
4782         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
4783                 return;
4784         }
4785
4786         /* every track/bus asked for this to be handled but it was deferred because
4787            we were connecting. do it now.
4788         */
4789
4790         request_input_change_handling ();
4791
4792         resort_routes ();
4793
4794         /* force all diskstreams to update their capture offset values to
4795            reflect any changes in latencies within the graph.
4796         */
4797
4798         boost::shared_ptr<RouteList> rl = routes.reader ();
4799         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4800                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4801                 if (tr) {
4802                         tr->set_capture_offset ();
4803                 }
4804         }
4805 }
4806
4807 /** @return Number of frames that there is disk space available to write,
4808  *  if known.
4809  */
4810 boost::optional<framecnt_t>
4811 Session::available_capture_duration ()
4812 {
4813         Glib::Threads::Mutex::Lock lm (space_lock);
4814
4815         if (_total_free_4k_blocks_uncertain) {
4816                 return boost::optional<framecnt_t> ();
4817         }
4818
4819         float sample_bytes_on_disk = 4.0; // keep gcc happy
4820
4821         switch (config.get_native_file_data_format()) {
4822         case FormatFloat:
4823                 sample_bytes_on_disk = 4.0;
4824                 break;
4825
4826         case FormatInt24:
4827                 sample_bytes_on_disk = 3.0;
4828                 break;
4829
4830         case FormatInt16:
4831                 sample_bytes_on_disk = 2.0;
4832                 break;
4833
4834         default:
4835                 /* impossible, but keep some gcc versions happy */
4836                 fatal << string_compose (_("programming error: %1"),
4837                                          X_("illegal native file data format"))
4838                       << endmsg;
4839                 abort(); /*NOTREACHED*/
4840         }
4841
4842         double scale = 4096.0 / sample_bytes_on_disk;
4843
4844         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4845                 return max_framecnt;
4846         }
4847
4848         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4849 }
4850
4851 void
4852 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
4853 {
4854         {
4855                 RCUWriter<BundleList> writer (_bundles);
4856                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4857                 b->push_back (bundle);
4858         }
4859
4860         if (emit_signal) {
4861                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4862         }
4863
4864         set_dirty();
4865 }
4866
4867 void
4868 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4869 {
4870         bool removed = false;
4871
4872         {
4873                 RCUWriter<BundleList> writer (_bundles);
4874                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4875                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
4876
4877                 if (i != b->end()) {
4878                         b->erase (i);
4879                         removed = true;
4880                 }
4881         }
4882
4883         if (removed) {
4884                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
4885         }
4886
4887         set_dirty();
4888 }
4889
4890 boost::shared_ptr<Bundle>
4891 Session::bundle_by_name (string name) const
4892 {
4893         boost::shared_ptr<BundleList> b = _bundles.reader ();
4894
4895         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4896                 if ((*i)->name() == name) {
4897                         return* i;
4898                 }
4899         }
4900
4901         return boost::shared_ptr<Bundle> ();
4902 }
4903
4904 void
4905 Session::tempo_map_changed (const PropertyChange&)
4906 {
4907         clear_clicks ();
4908
4909         playlists->update_after_tempo_map_change ();
4910
4911         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4912
4913         set_dirty ();
4914 }
4915
4916 void
4917 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
4918 {
4919         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
4920                 (*i)->recompute_frames_from_bbt ();
4921         }
4922 }
4923
4924 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4925  * the given count with the current block size.
4926  */
4927 void
4928 Session::ensure_buffers (ChanCount howmany)
4929 {
4930         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4931 }
4932
4933 void
4934 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4935 {
4936         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4937                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4938         }
4939 }
4940
4941 uint32_t
4942 Session::next_insert_id ()
4943 {
4944         /* this doesn't really loop forever. just think about it */
4945
4946         while (true) {
4947                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4948                         if (!insert_bitset[n]) {
4949                                 insert_bitset[n] = true;
4950                                 return n;
4951
4952                         }
4953                 }
4954
4955                 /* none available, so resize and try again */
4956
4957                 insert_bitset.resize (insert_bitset.size() + 16, false);
4958         }
4959 }
4960
4961 uint32_t
4962 Session::next_send_id ()
4963 {
4964         /* this doesn't really loop forever. just think about it */
4965
4966         while (true) {
4967                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4968                         if (!send_bitset[n]) {
4969                                 send_bitset[n] = true;
4970                                 return n;
4971
4972                         }
4973                 }
4974
4975                 /* none available, so resize and try again */
4976
4977                 send_bitset.resize (send_bitset.size() + 16, false);
4978         }
4979 }
4980
4981 uint32_t
4982 Session::next_aux_send_id ()
4983 {
4984         /* this doesn't really loop forever. just think about it */
4985
4986         while (true) {
4987                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4988                         if (!aux_send_bitset[n]) {
4989                                 aux_send_bitset[n] = true;
4990                                 return n;
4991
4992                         }
4993                 }
4994
4995                 /* none available, so resize and try again */
4996
4997                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4998         }
4999 }
5000
5001 uint32_t
5002 Session::next_return_id ()
5003 {
5004         /* this doesn't really loop forever. just think about it */
5005
5006         while (true) {
5007                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
5008                         if (!return_bitset[n]) {
5009                                 return_bitset[n] = true;
5010                                 return n;
5011
5012                         }
5013                 }
5014
5015                 /* none available, so resize and try again */
5016
5017                 return_bitset.resize (return_bitset.size() + 16, false);
5018         }
5019 }
5020
5021 void
5022 Session::mark_send_id (uint32_t id)
5023 {
5024         if (id >= send_bitset.size()) {
5025                 send_bitset.resize (id+16, false);
5026         }
5027         if (send_bitset[id]) {
5028                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5029         }
5030         send_bitset[id] = true;
5031 }
5032
5033 void
5034 Session::mark_aux_send_id (uint32_t id)
5035 {
5036         if (id >= aux_send_bitset.size()) {
5037                 aux_send_bitset.resize (id+16, false);
5038         }
5039         if (aux_send_bitset[id]) {
5040                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5041         }
5042         aux_send_bitset[id] = true;
5043 }
5044
5045 void
5046 Session::mark_return_id (uint32_t id)
5047 {
5048         if (id >= return_bitset.size()) {
5049                 return_bitset.resize (id+16, false);
5050         }
5051         if (return_bitset[id]) {
5052                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5053         }
5054         return_bitset[id] = true;
5055 }
5056
5057 void
5058 Session::mark_insert_id (uint32_t id)
5059 {
5060         if (id >= insert_bitset.size()) {
5061                 insert_bitset.resize (id+16, false);
5062         }
5063         if (insert_bitset[id]) {
5064                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5065         }
5066         insert_bitset[id] = true;
5067 }
5068
5069 void
5070 Session::unmark_send_id (uint32_t id)
5071 {
5072         if (id < send_bitset.size()) {
5073                 send_bitset[id] = false;
5074         }
5075 }
5076
5077 void
5078 Session::unmark_aux_send_id (uint32_t id)
5079 {
5080         if (id < aux_send_bitset.size()) {
5081                 aux_send_bitset[id] = false;
5082         }
5083 }
5084
5085 void
5086 Session::unmark_return_id (uint32_t id)
5087 {
5088         if (id < return_bitset.size()) {
5089                 return_bitset[id] = false;
5090         }
5091 }
5092
5093 void
5094 Session::unmark_insert_id (uint32_t id)
5095 {
5096         if (id < insert_bitset.size()) {
5097                 insert_bitset[id] = false;
5098         }
5099 }
5100
5101 void
5102 Session::reset_native_file_format ()
5103 {
5104         boost::shared_ptr<RouteList> rl = routes.reader ();
5105
5106         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5107                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5108                 if (tr) {
5109                         /* don't save state as we do this, there's no point
5110                          */
5111                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5112                         tr->reset_write_sources (false);
5113                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5114                 }
5115         }
5116 }
5117
5118 bool
5119 Session::route_name_unique (string n) const
5120 {
5121         boost::shared_ptr<RouteList> r = routes.reader ();
5122
5123         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5124                 if ((*i)->name() == n) {
5125                         return false;
5126                 }
5127         }
5128
5129         return true;
5130 }
5131
5132 bool
5133 Session::route_name_internal (string n) const
5134 {
5135         if (auditioner && auditioner->name() == n) {
5136                 return true;
5137         }
5138
5139         if (_click_io && _click_io->name() == n) {
5140                 return true;
5141         }
5142
5143         return false;
5144 }
5145
5146 int
5147 Session::freeze_all (InterThreadInfo& itt)
5148 {
5149         boost::shared_ptr<RouteList> r = routes.reader ();
5150
5151         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5152
5153                 boost::shared_ptr<Track> t;
5154
5155                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5156                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5157                            of every track.
5158                         */
5159                         t->freeze_me (itt);
5160                 }
5161         }
5162
5163         return 0;
5164 }
5165
5166 boost::shared_ptr<Region>
5167 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5168                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5169                           InterThreadInfo& itt,
5170                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5171                           bool for_export, bool for_freeze)
5172 {
5173         boost::shared_ptr<Region> result;
5174         boost::shared_ptr<Playlist> playlist;
5175         boost::shared_ptr<Source> source;
5176         ChanCount diskstream_channels (track.n_channels());
5177         framepos_t position;
5178         framecnt_t this_chunk;
5179         framepos_t to_do;
5180         framepos_t latency_skip;
5181         BufferSet buffers;
5182         framepos_t len = end - start;
5183         bool need_block_size_reset = false;
5184         ChanCount const max_proc = track.max_processor_streams ();
5185         string legal_playlist_name;
5186         string possible_path;
5187
5188         if (end <= start) {
5189                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5190                                          end, start) << endmsg;
5191                 return result;
5192         }
5193
5194         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5195                         include_endpoint, for_export, for_freeze);
5196
5197         if (diskstream_channels.n(track.data_type()) < 1) {
5198                 error << _("Cannot write a range with no data.") << endmsg;
5199                 return result;
5200         }
5201
5202         // block all process callback handling
5203
5204         block_processing ();
5205
5206         {
5207                 // synchronize with AudioEngine::process_callback()
5208                 // make sure processing is not currently running
5209                 // and processing_blocked() is honored before
5210                 // acquiring thread buffers
5211                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5212         }
5213
5214         _bounce_processing_active = true;
5215
5216         /* call tree *MUST* hold route_lock */
5217
5218         if ((playlist = track.playlist()) == 0) {
5219                 goto out;
5220         }
5221
5222         legal_playlist_name = legalize_for_path (playlist->name());
5223
5224         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5225
5226                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5227                 string path = ((track.data_type() == DataType::AUDIO)
5228                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5229                                : new_midi_source_path (legal_playlist_name));
5230
5231                 if (path.empty()) {
5232                         goto out;
5233                 }
5234
5235                 try {
5236                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5237                 }
5238
5239                 catch (failed_constructor& err) {
5240                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5241                         goto out;
5242                 }
5243
5244                 srcs.push_back (source);
5245         }
5246
5247         /* tell redirects that care that we are about to use a much larger
5248          * blocksize. this will flush all plugins too, so that they are ready
5249          * to be used for this process.
5250          */
5251
5252         need_block_size_reset = true;
5253         track.set_block_size (bounce_chunk_size);
5254         _engine.main_thread()->get_buffers ();
5255
5256         position = start;
5257         to_do = len;
5258         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5259
5260         /* create a set of reasonably-sized buffers */
5261         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5262                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5263         }
5264         buffers.set_count (max_proc);
5265
5266         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5267                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5268                 boost::shared_ptr<MidiSource> ms;
5269                 if (afs) {
5270                         afs->prepare_for_peakfile_writes ();
5271                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5272                         Source::Lock lock(ms->mutex());
5273                         ms->mark_streaming_write_started(lock);
5274                 }
5275         }
5276
5277         while (to_do && !itt.cancel) {
5278
5279                 this_chunk = min (to_do, bounce_chunk_size);
5280
5281                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5282                         goto out;
5283                 }
5284
5285                 start += this_chunk;
5286                 to_do -= this_chunk;
5287                 itt.progress = (float) (1.0 - ((double) to_do / len));
5288
5289                 if (latency_skip >= bounce_chunk_size) {
5290                         latency_skip -= bounce_chunk_size;
5291                         continue;
5292                 }
5293
5294                 const framecnt_t current_chunk = this_chunk - latency_skip;
5295
5296                 uint32_t n = 0;
5297                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5298                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5299                         boost::shared_ptr<MidiSource> ms;
5300
5301                         if (afs) {
5302                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5303                                         goto out;
5304                                 }
5305                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5306                                 Source::Lock lock(ms->mutex());
5307
5308                                 const MidiBuffer& buf = buffers.get_midi(0);
5309                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5310                                         Evoral::Event<framepos_t> ev = *i;
5311                                         ev.set_time(ev.time() - position);
5312                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5313                                 }
5314                         }
5315                 }
5316                 latency_skip = 0;
5317         }
5318
5319         /* post-roll, pick up delayed processor output */
5320         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5321
5322         while (latency_skip && !itt.cancel) {
5323                 this_chunk = min (latency_skip, bounce_chunk_size);
5324                 latency_skip -= this_chunk;
5325
5326                 buffers.silence (this_chunk, 0);
5327                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5328
5329                 uint32_t n = 0;
5330                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5331                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5332
5333                         if (afs) {
5334                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5335                                         goto out;
5336                                 }
5337                         }
5338                 }
5339         }
5340
5341         if (!itt.cancel) {
5342
5343                 time_t now;
5344                 struct tm* xnow;
5345                 time (&now);
5346                 xnow = localtime (&now);
5347
5348                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5349                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5350                         boost::shared_ptr<MidiSource> ms;
5351
5352                         if (afs) {
5353                                 afs->update_header (position, *xnow, now);
5354                                 afs->flush_header ();
5355                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5356                                 Source::Lock lock(ms->mutex());
5357                                 ms->mark_streaming_write_completed(lock);
5358                         }
5359                 }
5360
5361                 /* construct a region to represent the bounced material */
5362
5363                 PropertyList plist;
5364
5365                 plist.add (Properties::start, 0);
5366                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5367                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5368
5369                 result = RegionFactory::create (srcs, plist);
5370
5371         }
5372
5373   out:
5374         if (!result) {
5375                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5376                         (*src)->mark_for_remove ();
5377                         (*src)->drop_references ();
5378                 }
5379
5380         } else {
5381                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5382                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5383
5384                         if (afs)
5385                                 afs->done_with_peakfile_writes ();
5386                 }
5387         }
5388
5389         _bounce_processing_active = false;
5390
5391         if (need_block_size_reset) {
5392                 _engine.main_thread()->drop_buffers ();
5393                 track.set_block_size (get_block_size());
5394         }
5395
5396         unblock_processing ();
5397
5398         return result;
5399 }
5400
5401 gain_t*
5402 Session::gain_automation_buffer() const
5403 {
5404         return ProcessThread::gain_automation_buffer ();
5405 }
5406
5407 gain_t*
5408 Session::trim_automation_buffer() const
5409 {
5410         return ProcessThread::trim_automation_buffer ();
5411 }
5412
5413 gain_t*
5414 Session::send_gain_automation_buffer() const
5415 {
5416         return ProcessThread::send_gain_automation_buffer ();
5417 }
5418
5419 pan_t**
5420 Session::pan_automation_buffer() const
5421 {
5422         return ProcessThread::pan_automation_buffer ();
5423 }
5424
5425 BufferSet&
5426 Session::get_silent_buffers (ChanCount count)
5427 {
5428         return ProcessThread::get_silent_buffers (count);
5429 }
5430
5431 BufferSet&
5432 Session::get_scratch_buffers (ChanCount count, bool silence)
5433 {
5434         return ProcessThread::get_scratch_buffers (count, silence);
5435 }
5436
5437 BufferSet&
5438 Session::get_route_buffers (ChanCount count, bool silence)
5439 {
5440         return ProcessThread::get_route_buffers (count, silence);
5441 }
5442
5443
5444 BufferSet&
5445 Session::get_mix_buffers (ChanCount count)
5446 {
5447         return ProcessThread::get_mix_buffers (count);
5448 }
5449
5450 uint32_t
5451 Session::ntracks () const
5452 {
5453         uint32_t n = 0;
5454         boost::shared_ptr<RouteList> r = routes.reader ();
5455
5456         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5457                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5458                         ++n;
5459                 }
5460         }
5461
5462         return n;
5463 }
5464
5465 uint32_t
5466 Session::nbusses () const
5467 {
5468         uint32_t n = 0;
5469         boost::shared_ptr<RouteList> r = routes.reader ();
5470
5471         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5472                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5473                         ++n;
5474                 }
5475         }
5476
5477         return n;
5478 }
5479
5480 void
5481 Session::add_automation_list(AutomationList *al)
5482 {
5483         automation_lists[al->id()] = al;
5484 }
5485
5486 /** @return true if there is at least one record-enabled track, otherwise false */
5487 bool
5488 Session::have_rec_enabled_track () const
5489 {
5490         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5491 }
5492
5493 bool
5494 Session::have_rec_disabled_track () const
5495 {
5496     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5497 }
5498
5499 /** Update the state of our rec-enabled tracks flag */
5500 void
5501 Session::update_route_record_state ()
5502 {
5503         boost::shared_ptr<RouteList> rl = routes.reader ();
5504         RouteList::iterator i = rl->begin();
5505         while (i != rl->end ()) {
5506
5507                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5508                 if (tr && tr->record_enabled ()) {
5509                         break;
5510                 }
5511
5512                 ++i;
5513         }
5514
5515         int const old = g_atomic_int_get (&_have_rec_enabled_track);
5516
5517         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5518
5519         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5520                 RecordStateChanged (); /* EMIT SIGNAL */
5521         }
5522
5523         for (i = rl->begin(); i != rl->end (); ++i) {
5524                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5525                 if (tr && !tr->record_enabled ()) {
5526                         break;
5527                 }
5528         }
5529
5530         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5531
5532         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
5533
5534         if (record_status() == Recording && record_arm_state_changed ) {
5535                 RecordArmStateChanged ();
5536         }
5537
5538 }
5539
5540 void
5541 Session::listen_position_changed ()
5542 {
5543         boost::shared_ptr<RouteList> r = routes.reader ();
5544
5545         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5546                 (*i)->listen_position_changed ();
5547         }
5548 }
5549
5550 void
5551 Session::solo_control_mode_changed ()
5552 {
5553         /* cancel all solo or all listen when solo control mode changes */
5554
5555         if (soloing()) {
5556                 set_solo (get_routes(), false);
5557         } else if (listening()) {
5558                 set_listen (get_routes(), false);
5559         }
5560 }
5561
5562 /** Called when a property of one of our route groups changes */
5563 void
5564 Session::route_group_property_changed (RouteGroup* rg)
5565 {
5566         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5567 }
5568
5569 /** Called when a route is added to one of our route groups */
5570 void
5571 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5572 {
5573         RouteAddedToRouteGroup (rg, r);
5574 }
5575
5576 /** Called when a route is removed from one of our route groups */
5577 void
5578 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5579 {
5580         update_route_record_state ();
5581         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5582 }
5583
5584 boost::shared_ptr<RouteList>
5585 Session::get_tracks () const
5586 {
5587         boost::shared_ptr<RouteList> rl = routes.reader ();
5588         boost::shared_ptr<RouteList> tl (new RouteList);
5589
5590         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5591                 if (boost::dynamic_pointer_cast<Track> (*r)) {
5592                         if (!(*r)->is_auditioner()) {
5593                                 tl->push_back (*r);
5594                         }
5595                 }
5596         }
5597         return tl;
5598 }
5599
5600 boost::shared_ptr<RouteList>
5601 Session::get_routes_with_regions_at (framepos_t const p) const
5602 {
5603         boost::shared_ptr<RouteList> r = routes.reader ();
5604         boost::shared_ptr<RouteList> rl (new RouteList);
5605
5606         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5607                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5608                 if (!tr) {
5609                         continue;
5610                 }
5611
5612                 boost::shared_ptr<Playlist> pl = tr->playlist ();
5613                 if (!pl) {
5614                         continue;
5615                 }
5616
5617                 if (pl->has_region_at (p)) {
5618                         rl->push_back (*i);
5619                 }
5620         }
5621
5622         return rl;
5623 }
5624
5625 void
5626 Session::goto_end ()
5627 {
5628         if (_session_range_location) {
5629                 request_locate (_session_range_location->end(), false);
5630         } else {
5631                 request_locate (0, false);
5632         }
5633 }
5634
5635 void
5636 Session::goto_start ()
5637 {
5638         if (_session_range_location) {
5639                 request_locate (_session_range_location->start(), false);
5640         } else {
5641                 request_locate (0, false);
5642         }
5643 }
5644
5645 framepos_t
5646 Session::current_start_frame () const
5647 {
5648         return _session_range_location ? _session_range_location->start() : 0;
5649 }
5650
5651 framepos_t
5652 Session::current_end_frame () const
5653 {
5654         return _session_range_location ? _session_range_location->end() : 0;
5655 }
5656
5657 void
5658 Session::set_session_range_location (framepos_t start, framepos_t end)
5659 {
5660         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5661         _locations->add (_session_range_location);
5662 }
5663
5664 void
5665 Session::step_edit_status_change (bool yn)
5666 {
5667         bool send = false;
5668
5669         bool val = false;
5670         if (yn) {
5671                 send = (_step_editors == 0);
5672                 val = true;
5673
5674                 _step_editors++;
5675         } else {
5676                 send = (_step_editors == 1);
5677                 val = false;
5678
5679                 if (_step_editors > 0) {
5680                         _step_editors--;
5681                 }
5682         }
5683
5684         if (send) {
5685                 StepEditStatusChange (val);
5686         }
5687 }
5688
5689
5690 void
5691 Session::start_time_changed (framepos_t old)
5692 {
5693         /* Update the auto loop range to match the session range
5694            (unless the auto loop range has been changed by the user)
5695         */
5696
5697         Location* s = _locations->session_range_location ();
5698         if (s == 0) {
5699                 return;
5700         }
5701
5702         Location* l = _locations->auto_loop_location ();
5703
5704         if (l && l->start() == old) {
5705                 l->set_start (s->start(), true);
5706         }
5707 }
5708
5709 void
5710 Session::end_time_changed (framepos_t old)
5711 {
5712         /* Update the auto loop range to match the session range
5713            (unless the auto loop range has been changed by the user)
5714         */
5715
5716         Location* s = _locations->session_range_location ();
5717         if (s == 0) {
5718                 return;
5719         }
5720
5721         Location* l = _locations->auto_loop_location ();
5722
5723         if (l && l->end() == old) {
5724                 l->set_end (s->end(), true);
5725         }
5726 }
5727
5728 std::vector<std::string>
5729 Session::source_search_path (DataType type) const
5730 {
5731         Searchpath sp;
5732
5733         if (session_dirs.size() == 1) {
5734                 switch (type) {
5735                 case DataType::AUDIO:
5736                         sp.push_back (_session_dir->sound_path());
5737                         break;
5738                 case DataType::MIDI:
5739                         sp.push_back (_session_dir->midi_path());
5740                         break;
5741                 }
5742         } else {
5743                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5744                         SessionDirectory sdir (i->path);
5745                         switch (type) {
5746                         case DataType::AUDIO:
5747                                 sp.push_back (sdir.sound_path());
5748                                 break;
5749                         case DataType::MIDI:
5750                                 sp.push_back (sdir.midi_path());
5751                                 break;
5752                         }
5753                 }
5754         }
5755
5756         if (type == DataType::AUDIO) {
5757                 const string sound_path_2X = _session_dir->sound_path_2X();
5758                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5759                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5760                                 sp.push_back (sound_path_2X);
5761                         }
5762                 }
5763         }
5764
5765         // now check the explicit (possibly user-specified) search path
5766
5767         switch (type) {
5768         case DataType::AUDIO:
5769                 sp += Searchpath(config.get_audio_search_path ());
5770                 break;
5771         case DataType::MIDI:
5772                 sp += Searchpath(config.get_midi_search_path ());
5773                 break;
5774         }
5775
5776         return sp;
5777 }
5778
5779 void
5780 Session::ensure_search_path_includes (const string& path, DataType type)
5781 {
5782         Searchpath sp;
5783
5784         if (path == ".") {
5785                 return;
5786         }
5787
5788         switch (type) {
5789         case DataType::AUDIO:
5790                 sp += Searchpath(config.get_audio_search_path ());
5791                 break;
5792         case DataType::MIDI:
5793                 sp += Searchpath (config.get_midi_search_path ());
5794                 break;
5795         }
5796
5797         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5798                 /* No need to add this new directory if it has the same inode as
5799                    an existing one; checking inode rather than name prevents duplicated
5800                    directories when we are using symlinks.
5801
5802                    On Windows, I think we could just do if (*i == path) here.
5803                 */
5804                 if (PBD::equivalent_paths (*i, path)) {
5805                         return;
5806                 }
5807         }
5808
5809         sp += path;
5810
5811         switch (type) {
5812         case DataType::AUDIO:
5813                 config.set_audio_search_path (sp.to_string());
5814                 break;
5815         case DataType::MIDI:
5816                 config.set_midi_search_path (sp.to_string());
5817                 break;
5818         }
5819 }
5820
5821 void
5822 Session::remove_dir_from_search_path (const string& dir, DataType type)
5823 {
5824         Searchpath sp;
5825
5826         switch (type) {
5827         case DataType::AUDIO:
5828                 sp = Searchpath(config.get_audio_search_path ());
5829                 break;
5830         case DataType::MIDI:
5831                 sp = Searchpath (config.get_midi_search_path ());
5832                 break;
5833         }
5834
5835         sp -= dir;
5836
5837         switch (type) {
5838         case DataType::AUDIO:
5839                 config.set_audio_search_path (sp.to_string());
5840                 break;
5841         case DataType::MIDI:
5842                 config.set_midi_search_path (sp.to_string());
5843                 break;
5844         }
5845
5846 }
5847
5848 boost::shared_ptr<Speakers>
5849 Session::get_speakers()
5850 {
5851         return _speakers;
5852 }
5853
5854 list<string>
5855 Session::unknown_processors () const
5856 {
5857         list<string> p;
5858
5859         boost::shared_ptr<RouteList> r = routes.reader ();
5860         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5861                 list<string> t = (*i)->unknown_processors ();
5862                 copy (t.begin(), t.end(), back_inserter (p));
5863         }
5864
5865         p.sort ();
5866         p.unique ();
5867
5868         return p;
5869 }
5870
5871 void
5872 Session::update_latency (bool playback)
5873 {
5874         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
5875
5876         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
5877                 return;
5878         }
5879
5880         boost::shared_ptr<RouteList> r = routes.reader ();
5881         framecnt_t max_latency = 0;
5882
5883         if (playback) {
5884                 /* reverse the list so that we work backwards from the last route to run to the first */
5885                 RouteList* rl = routes.reader().get();
5886                 r.reset (new RouteList (*rl));
5887                 reverse (r->begin(), r->end());
5888         }
5889
5890         /* compute actual latency values for the given direction and store them all in per-port
5891            structures. this will also publish the same values (to JACK) so that computation of latency
5892            for routes can consistently use public latency values.
5893         */
5894
5895         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5896                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
5897         }
5898
5899         /* because we latency compensate playback, our published playback latencies should
5900            be the same for all output ports - all material played back by ardour has
5901            the same latency, whether its caused by plugins or by latency compensation. since
5902            these may differ from the values computed above, reset all playback port latencies
5903            to the same value.
5904         */
5905
5906         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
5907
5908         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5909                 (*i)->set_public_port_latencies (max_latency, playback);
5910         }
5911
5912         if (playback) {
5913
5914                 post_playback_latency ();
5915
5916         } else {
5917
5918                 post_capture_latency ();
5919         }
5920
5921         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
5922 }
5923
5924 void
5925 Session::post_playback_latency ()
5926 {
5927         set_worst_playback_latency ();
5928
5929         boost::shared_ptr<RouteList> r = routes.reader ();
5930
5931         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5932                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5933                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5934                 }
5935         }
5936
5937         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5938                 (*i)->set_latency_compensation (_worst_track_latency);
5939         }
5940 }
5941
5942 void
5943 Session::post_capture_latency ()
5944 {
5945         set_worst_capture_latency ();
5946
5947         /* reflect any changes in capture latencies into capture offsets
5948          */
5949
5950         boost::shared_ptr<RouteList> rl = routes.reader();
5951         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5952                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5953                 if (tr) {
5954                         tr->set_capture_offset ();
5955                 }
5956         }
5957 }
5958
5959 void
5960 Session::initialize_latencies ()
5961 {
5962         {
5963                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5964                 update_latency (false);
5965                 update_latency (true);
5966         }
5967
5968         set_worst_io_latencies ();
5969 }
5970
5971 void
5972 Session::set_worst_io_latencies ()
5973 {
5974         set_worst_playback_latency ();
5975         set_worst_capture_latency ();
5976 }
5977
5978 void
5979 Session::set_worst_playback_latency ()
5980 {
5981         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5982                 return;
5983         }
5984
5985         _worst_output_latency = 0;
5986
5987         if (!_engine.connected()) {
5988                 return;
5989         }
5990
5991         boost::shared_ptr<RouteList> r = routes.reader ();
5992
5993         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5994                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5995         }
5996
5997         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5998 }
5999
6000 void
6001 Session::set_worst_capture_latency ()
6002 {
6003         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6004                 return;
6005         }
6006
6007         _worst_input_latency = 0;
6008
6009         if (!_engine.connected()) {
6010                 return;
6011         }
6012
6013         boost::shared_ptr<RouteList> r = routes.reader ();
6014
6015         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6016                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6017         }
6018
6019         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6020 }
6021
6022 void
6023 Session::update_latency_compensation (bool force_whole_graph)
6024 {
6025         bool some_track_latency_changed = false;
6026
6027         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6028                 return;
6029         }
6030
6031         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6032
6033         _worst_track_latency = 0;
6034
6035         boost::shared_ptr<RouteList> r = routes.reader ();
6036
6037         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6038                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6039                         framecnt_t tl;
6040                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6041                                 some_track_latency_changed = true;
6042                         }
6043                         _worst_track_latency = max (tl, _worst_track_latency);
6044                 }
6045         }
6046
6047         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6048                                                      (some_track_latency_changed ? "yes" : "no")));
6049
6050         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6051
6052         if (some_track_latency_changed || force_whole_graph)  {
6053                 _engine.update_latencies ();
6054         }
6055
6056
6057         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6058                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6059                 if (!tr) {
6060                         continue;
6061                 }
6062                 tr->set_capture_offset ();
6063         }
6064 }
6065
6066 char
6067 Session::session_name_is_legal (const string& path)
6068 {
6069         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6070
6071         for (int i = 0; illegal_chars[i]; ++i) {
6072                 if (path.find (illegal_chars[i]) != string::npos) {
6073                         return illegal_chars[i];
6074                 }
6075         }
6076
6077         return 0;
6078 }
6079
6080 uint32_t
6081 Session::next_control_id () const
6082 {
6083         int subtract = 0;
6084
6085         /* the monitor bus remote ID is in a different
6086          * "namespace" than regular routes. its existence doesn't
6087          * affect normal (low) numbered routes.
6088          */
6089
6090         if (_monitor_out) {
6091                 subtract++;
6092         }
6093
6094         /* the same about masterbus in Waves Tracks */
6095
6096         if (Profile->get_trx() && _master_out) {
6097                 subtract++;
6098         }
6099
6100         return nroutes() - subtract;
6101 }
6102
6103 void
6104 Session::notify_remote_id_change ()
6105 {
6106         if (deletion_in_progress()) {
6107                 return;
6108         }
6109
6110         switch (Config->get_remote_model()) {
6111         case MixerOrdered:
6112                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6113                 break;
6114         default:
6115                 break;
6116         }
6117
6118 #ifdef USE_TRACKS_CODE_FEATURES
6119                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6120                  * if track order has been changed by user
6121                  */
6122                 reconnect_existing_routes(true, true);
6123 #endif
6124
6125 }
6126
6127 void
6128 Session::sync_order_keys ()
6129 {
6130         if (deletion_in_progress()) {
6131                 return;
6132         }
6133
6134         /* tell everyone that something has happened to the sort keys
6135            and let them sync up with the change(s)
6136            this will give objects that manage the sort order keys the
6137            opportunity to keep them in sync if they wish to.
6138         */
6139
6140         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6141
6142         reassign_track_numbers();
6143
6144         Route::SyncOrderKeys (); /* EMIT SIGNAL */
6145
6146         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6147 }
6148
6149 bool
6150 Session::operation_in_progress (GQuark op) const
6151 {
6152         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6153 }
6154
6155 boost::shared_ptr<Port>
6156 Session::ltc_input_port () const
6157 {
6158         return _ltc_input->nth (0);
6159 }
6160
6161 boost::shared_ptr<Port>
6162 Session::ltc_output_port () const
6163 {
6164         return _ltc_output->nth (0);
6165 }
6166
6167 void
6168 Session::reconnect_ltc_input ()
6169 {
6170         if (_ltc_input) {
6171
6172                 string src = Config->get_ltc_source_port();
6173
6174                 _ltc_input->disconnect (this);
6175
6176                 if (src != _("None") && !src.empty())  {
6177                         _ltc_input->nth (0)->connect (src);
6178                 }
6179
6180                 if ( ARDOUR::Profile->get_trx () ) {
6181                         // Tracks need this signal to update timecode_source_dropdown
6182                         MtcOrLtcInputPortChanged (); //emit signal
6183                 }
6184         }
6185 }
6186
6187 void
6188 Session::reconnect_ltc_output ()
6189 {
6190         if (_ltc_output) {
6191
6192                 string src = Config->get_ltc_output_port();
6193
6194                 _ltc_output->disconnect (this);
6195
6196                 if (src != _("None") && !src.empty())  {
6197                         _ltc_output->nth (0)->connect (src);
6198                 }
6199         }
6200 }
6201
6202 void
6203 Session::set_range_selection (framepos_t start, framepos_t end)
6204 {
6205         _range_selection = Evoral::Range<framepos_t> (start, end);
6206 #ifdef USE_TRACKS_CODE_FEATURES
6207         follow_playhead_priority ();
6208 #endif
6209 }
6210
6211 void
6212 Session::set_object_selection (framepos_t start, framepos_t end)
6213 {
6214         _object_selection = Evoral::Range<framepos_t> (start, end);
6215 #ifdef USE_TRACKS_CODE_FEATURES
6216         follow_playhead_priority ();
6217 #endif
6218 }
6219
6220 void
6221 Session::clear_range_selection ()
6222 {
6223         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6224 #ifdef USE_TRACKS_CODE_FEATURES
6225         follow_playhead_priority ();
6226 #endif
6227 }
6228
6229 void
6230 Session::clear_object_selection ()
6231 {
6232         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6233 #ifdef USE_TRACKS_CODE_FEATURES
6234         follow_playhead_priority ();
6235 #endif
6236 }