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