libs/ardour/session.cc

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