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