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