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