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