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