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