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