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)
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                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2521                                 (*r)->add_processor (p, PreFader);
2522
2523                         }
2524                 }
2525         }
2526
2527         return ret;
2528 }
2529
2530 RouteList
2531 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, boost::shared_ptr<PluginInfo> instrument)
2532 {
2533         string bus_name;
2534         uint32_t bus_id = 0;
2535         string port;
2536         RouteList ret;
2537
2538         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2539
2540         while (how_many) {
2541                 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2542                         error << "cannot find name for new midi bus" << endmsg;
2543                         goto failure;
2544                 }
2545
2546                 try {
2547                         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
2548
2549                         if (bus->init ()) {
2550                                 goto failure;
2551                         }
2552
2553                         if (Profile->get_mixbus ()) {
2554                                 bus->set_strict_io (true);
2555                         }
2556
2557 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2558                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2559 #endif
2560                         {
2561                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2562
2563                                 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2564                                         error << _("cannot configure new midi bus input") << endmsg;
2565                                         goto failure;
2566                                 }
2567
2568
2569                                 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2570                                         error << _("cannot configure new midi bus output") << endmsg;
2571                                         goto failure;
2572                                 }
2573                         }
2574
2575                         if (route_group) {
2576                                 route_group->add (bus);
2577                         }
2578                         if (Config->get_remote_model() == UserOrdered) {
2579                                 bus->set_remote_control_id (next_control_id());
2580                         }
2581
2582                         ret.push_back (bus);
2583                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2584                         ARDOUR::GUIIdle ();
2585                 }
2586
2587                 catch (failed_constructor &err) {
2588                         error << _("Session: could not create new audio route.") << endmsg;
2589                         goto failure;
2590                 }
2591
2592                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2593                         error << pfe.what() << endmsg;
2594                         goto failure;
2595                 }
2596
2597
2598                 --how_many;
2599         }
2600
2601   failure:
2602         if (!ret.empty()) {
2603                 StateProtector sp (this);
2604                 add_routes (ret, false, false, false);
2605
2606                 if (instrument) {
2607                         for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2608                                 PluginPtr plugin = instrument->load (*this);
2609                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2610                                 (*r)->add_processor (p, PreFader);
2611                         }
2612                 }
2613         }
2614
2615         return ret;
2616
2617 }
2618
2619
2620 void
2621 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2622 {
2623         boost::shared_ptr<Route> midi_track (wmt.lock());
2624
2625         if (!midi_track) {
2626                 return;
2627         }
2628
2629         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2630
2631                 if (change.after.n_audio() <= change.before.n_audio()) {
2632                         return;
2633                 }
2634
2635                 /* new audio ports: make sure the audio goes somewhere useful,
2636                  * unless the user has no-auto-connect selected.
2637                  *
2638                  * The existing ChanCounts don't matter for this call as they are only
2639                  * to do with matching input and output indices, and we are only changing
2640                  * outputs here.
2641                  */
2642                 auto_connect_route (midi_track, false, ChanCount(), change.before);
2643         }
2644 }
2645
2646 #ifdef USE_TRACKS_CODE_FEATURES
2647
2648 static bool
2649 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2650 {
2651         return route1->remote_control_id() < route2->remote_control_id();
2652 }
2653
2654 void
2655 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2656 {
2657         // it is not allowed to perform connection
2658         if (!IO::connecting_legal) {
2659                 return;
2660         }
2661
2662         // if we are deleting routes we will call this once at the end
2663         if (_route_deletion_in_progress) {
2664                 return;
2665         }
2666
2667         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2668
2669         if (withLock) {
2670                 lm.acquire ();
2671         }
2672
2673         // We need to disconnect the route's inputs and outputs first
2674         // basing on autoconnect configuration
2675         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2676         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2677
2678         ChanCount existing_inputs;
2679         ChanCount existing_outputs;
2680         count_existing_track_channels (existing_inputs, existing_outputs);
2681
2682         //ChanCount inputs = ChanCount::ZERO;
2683         //ChanCount outputs = ChanCount::ZERO;
2684
2685         RouteList existing_routes = *routes.reader ();
2686         existing_routes.sort (compare_routes_by_remote_id);
2687
2688         {
2689                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2690
2691                 vector<string> physinputs;
2692                 vector<string> physoutputs;
2693
2694                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2695                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2696
2697                 uint32_t input_n = 0;
2698                 uint32_t output_n = 0;
2699                 RouteList::iterator rIter = existing_routes.begin();
2700                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2701                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2702                 for (; rIter != existing_routes.end(); ++rIter) {
2703                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2704                                 continue;
2705                         }
2706
2707                         if (current_output_auto_connection == AutoConnectPhysical) {
2708                                 (*rIter)->amp()->deactivate();
2709                         } else if (current_output_auto_connection == AutoConnectMaster) {
2710                                 (*rIter)->amp()->activate();
2711                         }
2712
2713                         if (reconnectIputs) {
2714                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2715
2716                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2717
2718                                         if (current_input_auto_connection & AutoConnectPhysical) {
2719
2720                                                 if ( input_n == physinputs.size() ) {
2721                                                         break;
2722                                                 }
2723
2724                                                 string port = physinputs[input_n];
2725
2726                                                 if (port.empty() ) {
2727                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2728                                                 }
2729
2730                                                 //GZ: check this; could be heavy
2731                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2732                                                 ++input_n;
2733                                         }
2734                                 }
2735                         }
2736
2737                         if (reconnectOutputs) {
2738
2739                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2740                                 if (current_output_auto_connection & AutoConnectPhysical) {
2741
2742                                         //GZ: check this; could be heavy
2743                                         (*rIter)->output()->disconnect (this);
2744                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2745
2746                                         //GZ: check this; could be heavy
2747                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2748
2749                                 } else if (current_output_auto_connection & AutoConnectMaster){
2750
2751                                         if (!reconnect_master) {
2752                                                 continue;
2753                                         }
2754
2755                                         //GZ: check this; could be heavy
2756                                         (*rIter)->output()->disconnect (this);
2757
2758                                         if (_master_out) {
2759                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2760                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2761                                         } else {
2762                                                 error << error << "Master bus is not available" << endmsg;
2763                                                 break;
2764                                         }
2765                                 }
2766
2767                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2768                                         if (current_output_auto_connection & AutoConnectPhysical) {
2769
2770                                                 if ( output_n == physoutputs.size() ) {
2771                                                         break;
2772                                                 }
2773
2774                                                 string port = physoutputs[output_n];
2775
2776                                                 if (port.empty() ) {
2777                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2778                                                 }
2779
2780                                                 //GZ: check this; could be heavy
2781                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2782                                                 ++output_n;
2783
2784                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2785
2786                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2787                                                         break;
2788                                                 }
2789
2790                                                 // connect to master bus
2791                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2792
2793                                                 if (port.empty() ) {
2794                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2795                                                 }
2796
2797
2798                                                 //GZ: check this; could be heavy
2799                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2800
2801                                         }
2802                                 }
2803                         }
2804                 }
2805
2806                 _master_out->output()->disconnect (this);
2807                 auto_connect_master_bus ();
2808         }
2809
2810         graph_reordered ();
2811
2812         session_routes_reconnected (); /* EMIT SIGNAL */
2813 }
2814
2815 void
2816 Session::reconnect_midi_scene_ports(bool inputs)
2817 {
2818     if (inputs ) {
2819
2820         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2821         if (scene_in_ptr) {
2822             scene_in_ptr->disconnect_all ();
2823
2824             std::vector<EngineStateController::MidiPortState> midi_port_states;
2825             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2826
2827             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2828
2829             for (; state_iter != midi_port_states.end(); ++state_iter) {
2830                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2831                     scene_in_ptr->connect (state_iter->name);
2832                 }
2833             }
2834         }
2835
2836     } else {
2837
2838         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2839
2840         if (scene_out_ptr ) {
2841             scene_out_ptr->disconnect_all ();
2842
2843             std::vector<EngineStateController::MidiPortState> midi_port_states;
2844             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2845
2846             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2847
2848             for (; state_iter != midi_port_states.end(); ++state_iter) {
2849                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2850                     scene_out_ptr->connect (state_iter->name);
2851                 }
2852             }
2853         }
2854     }
2855 }
2856
2857 void
2858 Session::reconnect_mtc_ports ()
2859 {
2860         boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2861
2862         if (!mtc_in_ptr) {
2863                 return;
2864         }
2865
2866         mtc_in_ptr->disconnect_all ();
2867
2868         std::vector<EngineStateController::MidiPortState> midi_port_states;
2869         EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2870
2871         std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2872
2873         for (; state_iter != midi_port_states.end(); ++state_iter) {
2874                 if (state_iter->available && state_iter->mtc_in) {
2875                         mtc_in_ptr->connect (state_iter->name);
2876                 }
2877         }
2878
2879         if (!_midi_ports->mtc_input_port ()->connected () &&
2880             config.get_external_sync () &&
2881             (Config->get_sync_source () == MTC) ) {
2882                 config.set_external_sync (false);
2883         }
2884
2885         if ( ARDOUR::Profile->get_trx () ) {
2886                 // Tracks need this signal to update timecode_source_dropdown
2887                 MtcOrLtcInputPortChanged (); //emit signal
2888         }
2889 }
2890
2891 void
2892 Session::reconnect_mmc_ports(bool inputs)
2893 {
2894         if (inputs ) { // get all enabled midi input ports
2895
2896                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
2897                 if (mmc_in_ptr) {
2898                         mmc_in_ptr->disconnect_all ();
2899                         std::vector<std::string> enabled_midi_inputs;
2900                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
2901
2902                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
2903
2904                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
2905                                 mmc_in_ptr->connect (*port_iter);
2906                         }
2907
2908                 }
2909         } else { // get all enabled midi output ports
2910
2911                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
2912                 if (mmc_out_ptr ) {
2913                         mmc_out_ptr->disconnect_all ();
2914                         std::vector<std::string> enabled_midi_outputs;
2915                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
2916
2917                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
2918
2919                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
2920                                 mmc_out_ptr->connect (*port_iter);
2921                         }
2922                 }
2923         }
2924 }
2925
2926 #endif
2927
2928 /** Caller must not hold process lock
2929  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2930  */
2931 list< boost::shared_ptr<AudioTrack> >
2932 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2933                           uint32_t how_many, string name_template)
2934 {
2935         string track_name;
2936         uint32_t track_id = 0;
2937         string port;
2938         RouteList new_routes;
2939         list<boost::shared_ptr<AudioTrack> > ret;
2940
2941         const string name_pattern = default_track_name_pattern (DataType::AUDIO);
2942         bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2943
2944         while (how_many) {
2945
2946                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
2947                         error << "cannot find name for new audio track" << endmsg;
2948                         goto failed;
2949                 }
2950
2951                 boost::shared_ptr<AudioTrack> track;
2952
2953                 try {
2954                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2955
2956                         if (track->init ()) {
2957                                 goto failed;
2958                         }
2959
2960                         if (Profile->get_mixbus ()) {
2961                                 track->set_strict_io (true);
2962                         }
2963
2964
2965                         if (ARDOUR::Profile->get_trx ()) {
2966                                 // TRACKS considers it's not a USE CASE, it's
2967                                 // a piece of behavior of the session model:
2968                                 //
2969                                 // Gain for a newly created route depends on
2970                                 // the current output_auto_connect mode:
2971                                 //
2972                                 //  0 for Stereo Out mode
2973                                 //  0 Multi Out mode
2974                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
2975                                         track->set_gain (dB_to_coefficient (0), Controllable::NoGroup);
2976                                 }
2977                         }
2978
2979                         track->use_new_diskstream();
2980
2981 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2982                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2983 #endif
2984                         {
2985                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2986
2987                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2988                                         error << string_compose (
2989                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2990                                                 input_channels, output_channels)
2991                                               << endmsg;
2992                                         goto failed;
2993                                 }
2994
2995                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2996                                         error << string_compose (
2997                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2998                                                 input_channels, output_channels)
2999                                               << endmsg;
3000                                         goto failed;
3001                                 }
3002                         }
3003
3004                         if (route_group) {
3005                                 route_group->add (track);
3006                         }
3007
3008                         track->non_realtime_input_change();
3009
3010                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
3011                         if (Config->get_remote_model() == UserOrdered) {
3012                                 track->set_remote_control_id (next_control_id());
3013                         }
3014
3015                         new_routes.push_back (track);
3016                         ret.push_back (track);
3017
3018                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3019                 }
3020
3021                 catch (failed_constructor &err) {
3022                         error << _("Session: could not create new audio track.") << endmsg;
3023                         goto failed;
3024                 }
3025
3026                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3027
3028                         error << pfe.what() << endmsg;
3029                         goto failed;
3030                 }
3031
3032                 --how_many;
3033         }
3034
3035   failed:
3036         if (!new_routes.empty()) {
3037                 StateProtector sp (this);
3038                 if (Profile->get_trx()) {
3039                         add_routes (new_routes, false, false, false);
3040                 } else {
3041                         add_routes (new_routes, true, true, false);
3042                 }
3043         }
3044
3045         return ret;
3046 }
3047
3048 /** Caller must not hold process lock.
3049  *  @param name_template string to use for the start of the name, or "" to use "Bus".
3050  */
3051 RouteList
3052 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
3053 {
3054         string bus_name;
3055         uint32_t bus_id = 0;
3056         string port;
3057         RouteList ret;
3058
3059         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3060
3061         while (how_many) {
3062                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3063                         error << "cannot find name for new audio bus" << endmsg;
3064                         goto failure;
3065                 }
3066
3067                 try {
3068                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
3069
3070                         if (bus->init ()) {
3071                                 goto failure;
3072                         }
3073
3074                         if (Profile->get_mixbus ()) {
3075                                 bus->set_strict_io (true);
3076                         }
3077
3078 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
3079                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
3080 #endif
3081                         {
3082                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3083
3084                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3085                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3086                                                                  input_channels, output_channels)
3087                                               << endmsg;
3088                                         goto failure;
3089                                 }
3090
3091
3092                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3093                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3094                                                                  input_channels, output_channels)
3095                                               << endmsg;
3096                                         goto failure;
3097                                 }
3098                         }
3099
3100                         if (route_group) {
3101                                 route_group->add (bus);
3102                         }
3103                         if (Config->get_remote_model() == UserOrdered) {
3104                                 bus->set_remote_control_id (next_control_id());
3105                         }
3106
3107                         bus->add_internal_return ();
3108
3109                         ret.push_back (bus);
3110
3111                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3112
3113                         ARDOUR::GUIIdle ();
3114                 }
3115
3116
3117                 catch (failed_constructor &err) {
3118                         error << _("Session: could not create new audio route.") << endmsg;
3119                         goto failure;
3120                 }
3121
3122                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3123                         error << pfe.what() << endmsg;
3124                         goto failure;
3125                 }
3126
3127
3128                 --how_many;
3129         }
3130
3131   failure:
3132         if (!ret.empty()) {
3133                 StateProtector sp (this);
3134                 if (Profile->get_trx()) {
3135                         add_routes (ret, false, false, false);
3136                 } else {
3137                         add_routes (ret, false, true, true); // autoconnect // outputs only
3138                 }
3139         }
3140
3141         return ret;
3142
3143 }
3144
3145 RouteList
3146 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base, PlaylistDisposition pd)
3147 {
3148         XMLTree tree;
3149
3150         if (!tree.read (template_path.c_str())) {
3151                 return RouteList();
3152         }
3153
3154         return new_route_from_template (how_many, *tree.root(), name_base, pd);
3155 }
3156
3157 RouteList
3158 Session::new_route_from_template (uint32_t how_many, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3159 {
3160         RouteList ret;
3161         uint32_t control_id;
3162         uint32_t number = 0;
3163         const uint32_t being_added = how_many;
3164         /* This will prevent the use of any existing XML-provided PBD::ID
3165            values by Stateful.
3166         */
3167         Stateful::ForceIDRegeneration force_ids;
3168         IO::disable_connecting ();
3169
3170         control_id = next_control_id ();
3171
3172         while (how_many) {
3173
3174                 /* We're going to modify the node contents a bit so take a
3175                  * copy. The node may be re-used when duplicating more than once.
3176                  */
3177
3178                 XMLNode node_copy (node);
3179
3180                 try {
3181                         string name;
3182
3183                         if (!name_base.empty()) {
3184
3185                                 /* if we're adding more than one routes, force
3186                                  * all the names of the new routes to be
3187                                  * numbered, via the final parameter.
3188                                  */
3189
3190                                 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3191                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3192                                         /*NOTREACHDE*/
3193                                 }
3194
3195                         } else {
3196
3197                                 string const route_name  = node_copy.property(X_("name"))->value ();
3198
3199                                 /* generate a new name by adding a number to the end of the template name */
3200                                 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3201                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3202                                         abort(); /*NOTREACHED*/
3203                                 }
3204                         }
3205
3206                         /* set this name in the XML description that we are about to use */
3207
3208                         bool rename_playlist;
3209                         switch (pd) {
3210                         case NewPlaylist:
3211                                 rename_playlist = true;
3212                                 break;
3213                         case CopyPlaylist:
3214                         case SharePlaylist:
3215                                 rename_playlist = false;
3216                         }
3217
3218                         Route::set_name_in_state (node_copy, name, rename_playlist);
3219
3220                         /* trim bitslots from listen sends so that new ones are used */
3221                         XMLNodeList children = node_copy.children ();
3222                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3223                                 if ((*i)->name() == X_("Processor")) {
3224                                         /* ForceIDRegeneration does not catch the following */
3225                                         XMLProperty const * role = (*i)->property (X_("role"));
3226                                         XMLProperty const * type = (*i)->property (X_("type"));
3227                                         if (role && role->value() == X_("Aux")) {
3228                                                 /* check if the target bus exists.
3229                                                  * we should not save aux-sends in templates.
3230                                                  */
3231                                                 XMLProperty const * target = (*i)->property (X_("target"));
3232                                                 if (!target) {
3233                                                         (*i)->add_property ("type", "dangling-aux-send");
3234                                                         continue;
3235                                                 }
3236                                                 boost::shared_ptr<Route> r = route_by_id (target->value());
3237                                                 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3238                                                         (*i)->add_property ("type", "dangling-aux-send");
3239                                                         continue;
3240                                                 }
3241                                         }
3242                                         if (role && role->value() == X_("Listen")) {
3243                                                 (*i)->remove_property (X_("bitslot"));
3244                                         }
3245                                         else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3246                                                 char buf[32];
3247                                                 Delivery::Role xrole;
3248                                                 uint32_t bitslot = 0;
3249                                                 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3250                                                 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3251                                                 snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
3252                                                 (*i)->remove_property (X_("bitslot"));
3253                                                 (*i)->remove_property (X_("name"));
3254                                                 (*i)->add_property ("bitslot", buf);
3255                                                 (*i)->add_property ("name", name);
3256                                         }
3257                                         else if (type && type->value() == X_("return")) {
3258                                                 // Return::set_state() generates a new one
3259                                                 (*i)->remove_property (X_("bitslot"));
3260                                         }
3261                                         else if (type && type->value() == X_("port")) {
3262                                                 // PortInsert::set_state() handles the bitslot
3263                                                 (*i)->remove_property (X_("bitslot"));
3264                                                 (*i)->add_property ("ignore-name", "1");
3265                                         }
3266                                 }
3267                         }
3268
3269                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3270
3271                         if (route == 0) {
3272                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3273                                 goto out;
3274                         }
3275
3276                         if (boost::dynamic_pointer_cast<Track>(route)) {
3277                                 /* force input/output change signals so that the new diskstream
3278                                    picks up the configuration of the route. During session
3279                                    loading this normally happens in a different way.
3280                                 */
3281
3282                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3283
3284                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3285                                 change.after = route->input()->n_ports();
3286                                 route->input()->changed (change, this);
3287                                 change.after = route->output()->n_ports();
3288                                 route->output()->changed (change, this);
3289                         }
3290
3291                         route->set_remote_control_id (control_id);
3292                         ++control_id;
3293
3294                         boost::shared_ptr<Track> track;
3295
3296                         if ((track = boost::dynamic_pointer_cast<Track> (route))) {
3297                                 switch (pd) {
3298                                 case NewPlaylist:
3299                                         track->use_new_playlist ();
3300                                         break;
3301                                 case CopyPlaylist:
3302                                         track->use_copy_playlist ();
3303                                         break;
3304                                 case SharePlaylist:
3305                                         break;
3306                                 }
3307                         };
3308
3309                         ret.push_back (route);
3310
3311                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3312                 }
3313
3314                 catch (failed_constructor &err) {
3315                         error << _("Session: could not create new route from template") << endmsg;
3316                         goto out;
3317                 }
3318
3319                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3320                         error << pfe.what() << endmsg;
3321                         goto out;
3322                 }
3323
3324                 --how_many;
3325         }
3326
3327   out:
3328         if (!ret.empty()) {
3329                 StateProtector sp (this);
3330                 if (Profile->get_trx()) {
3331                         add_routes (ret, false, false, false);
3332                 } else {
3333                         add_routes (ret, true, true, false);
3334                 }
3335                 IO::enable_connecting ();
3336         }
3337
3338         return ret;
3339 }
3340
3341 void
3342 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
3343 {
3344         try {
3345                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3346                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
3347
3348         } catch (...) {
3349                 error << _("Adding new tracks/busses failed") << endmsg;
3350         }
3351
3352         graph_reordered ();
3353
3354         update_latency (true);
3355         update_latency (false);
3356
3357         set_dirty();
3358
3359         if (save) {
3360                 save_state (_current_snapshot_name);
3361         }
3362
3363         reassign_track_numbers();
3364
3365         update_route_record_state ();
3366
3367         RouteAdded (new_routes); /* EMIT SIGNAL */
3368 }
3369
3370 void
3371 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3372 {
3373         ChanCount existing_inputs;
3374         ChanCount existing_outputs;
3375         uint32_t order = next_control_id();
3376
3377
3378         if (_order_hint > -1) {
3379                 order = _order_hint;
3380                 _order_hint = -1;
3381         }
3382
3383         count_existing_track_channels (existing_inputs, existing_outputs);
3384
3385         {
3386                 RCUWriter<RouteList> writer (routes);
3387                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3388                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3389
3390                 /* if there is no control out and we're not in the middle of loading,
3391                  * resort the graph here. if there is a control out, we will resort
3392                  * toward the end of this method. if we are in the middle of loading,
3393                  * we will resort when done.
3394                  */
3395
3396                 if (!_monitor_out && IO::connecting_legal) {
3397                         resort_routes_using (r);
3398                 }
3399         }
3400
3401         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3402
3403                 boost::weak_ptr<Route> wpr (*x);
3404                 boost::shared_ptr<Route> r (*x);
3405
3406                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3407                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3408                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3409                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3410                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3411                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3412
3413                 if (r->is_master()) {
3414                         _master_out = r;
3415                 }
3416
3417                 if (r->is_monitor()) {
3418                         _monitor_out = r;
3419                 }
3420
3421                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3422                 if (tr) {
3423                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3424                         track_playlist_changed (boost::weak_ptr<Track> (tr));
3425                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3426
3427                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3428                         if (mt) {
3429                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3430                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3431                         }
3432                 }
3433
3434                 if (input_auto_connect || output_auto_connect) {
3435                         auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3436                         existing_inputs += r->n_inputs();
3437                         existing_outputs += r->n_outputs();
3438                 }
3439
3440                 /* order keys are a GUI responsibility but we need to set up
3441                          reasonable defaults because they also affect the remote control
3442                          ID in most situations.
3443                          */
3444
3445                 if (!r->has_order_key ()) {
3446                         if (r->is_auditioner()) {
3447                                 /* use an arbitrarily high value */
3448                                 r->set_order_key (UINT_MAX);
3449                         } else {
3450                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3451                                 r->set_order_key (order);
3452                                 order++;
3453                         }
3454                 }
3455
3456                 ARDOUR::GUIIdle ();
3457         }
3458
3459         if (_monitor_out && IO::connecting_legal) {
3460                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3461
3462                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3463                         if ((*x)->is_monitor()) {
3464                                 /* relax */
3465                         } else if ((*x)->is_master()) {
3466                                 /* relax */
3467                         } else {
3468                                 (*x)->enable_monitor_send ();
3469                         }
3470                 }
3471         }
3472 }
3473
3474 void
3475 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3476 {
3477         boost::shared_ptr<RouteList> r = routes.reader ();
3478         boost::shared_ptr<Send> s;
3479
3480         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3481                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3482                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3483                 }
3484         }
3485 }
3486
3487 void
3488 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3489 {
3490         boost::shared_ptr<RouteList> r = routes.reader ();
3491         boost::shared_ptr<Send> s;
3492
3493         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3494                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3495                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3496                 }
3497         }
3498 }
3499
3500 void
3501 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3502 {
3503         boost::shared_ptr<RouteList> r = routes.reader ();
3504         boost::shared_ptr<Send> s;
3505
3506         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3507                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3508                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3509                 }
3510         }
3511 }
3512
3513 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3514 void
3515 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3516 {
3517         boost::shared_ptr<RouteList> r = routes.reader ();
3518         boost::shared_ptr<RouteList> t (new RouteList);
3519
3520         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3521                 /* no MIDI sends because there are no MIDI busses yet */
3522                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3523                         t->push_back (*i);
3524                 }
3525         }
3526
3527         add_internal_sends (dest, p, t);
3528 }
3529
3530 void
3531 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3532 {
3533         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3534                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3535         }
3536 }
3537
3538 void
3539 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3540 {
3541         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3542 }
3543
3544 void
3545 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3546 {
3547         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3548                 return;
3549         }
3550
3551         if (!dest->internal_return()) {
3552                 dest->add_internal_return ();
3553         }
3554
3555         sender->add_aux_send (dest, before);
3556
3557         graph_reordered ();
3558 }
3559
3560
3561 void
3562 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3563 {
3564         { // RCU Writer scope
3565                 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3566                 RCUWriter<RouteList> writer (routes);
3567                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3568
3569
3570                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3571
3572                         if (*iter == _master_out) {
3573                                 continue;
3574                         }
3575
3576                         (*iter)->set_solo (false, Controllable::NoGroup);
3577
3578                         rs->remove (*iter);
3579
3580                         /* deleting the master out seems like a dumb
3581                            idea, but its more of a UI policy issue
3582                            than our concern.
3583                         */
3584
3585                         if (*iter == _master_out) {
3586                                 _master_out = boost::shared_ptr<Route> ();
3587                         }
3588
3589                         if (*iter == _monitor_out) {
3590                                 _monitor_out.reset ();
3591                         }
3592
3593                         // We need to disconnect the route's inputs and outputs
3594
3595                         (*iter)->input()->disconnect (0);
3596                         (*iter)->output()->disconnect (0);
3597
3598                         /* if the route had internal sends sending to it, remove them */
3599                         if ((*iter)->internal_return()) {
3600
3601                                 boost::shared_ptr<RouteList> r = routes.reader ();
3602                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3603                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3604                                         if (s) {
3605                                                 (*i)->remove_processor (s);
3606                                         }
3607                                 }
3608                         }
3609
3610                         /* if the monitoring section had a pointer to this route, remove it */
3611                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3612                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3613                                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3614                                 (*iter)->remove_aux_or_listen (_monitor_out);
3615                         }
3616
3617                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3618                         if (mt && mt->step_editing()) {
3619                                 if (_step_editors > 0) {
3620                                         _step_editors--;
3621                                 }
3622                         }
3623                 }
3624
3625                 /* writer goes out of scope, forces route list update */
3626
3627         } // end of RCU Writer scope
3628
3629         update_route_solo_state ();
3630         RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3631         update_latency_compensation ();
3632         set_dirty();
3633
3634         /* Re-sort routes to remove the graph's current references to the one that is
3635          * going away, then flush old references out of the graph.
3636          * Wave Tracks: reconnect routes
3637          */
3638
3639 #ifdef USE_TRACKS_CODE_FEATURES
3640                 reconnect_existing_routes(true, false);
3641 #else
3642                 routes.flush (); // maybe unsafe, see below.
3643                 resort_routes ();
3644 #endif
3645
3646         if (_process_graph && !(_state_of_the_state & Deletion)) {
3647                 _process_graph->clear_other_chain ();
3648         }
3649
3650         /* get rid of it from the dead wood collection in the route list manager */
3651         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3652
3653         routes.flush ();
3654
3655         /* try to cause everyone to drop their references
3656          * and unregister ports from the backend
3657          */
3658
3659         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3660                 (*iter)->drop_references ();
3661         }
3662
3663         if (_state_of_the_state & Deletion) {
3664                 return;
3665         }
3666
3667         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3668
3669         /* save the new state of the world */
3670
3671         if (save_state (_current_snapshot_name)) {
3672                 save_history (_current_snapshot_name);
3673         }
3674
3675         reassign_track_numbers();
3676         update_route_record_state ();
3677 }
3678
3679 void
3680 Session::remove_route (boost::shared_ptr<Route> route)
3681 {
3682         boost::shared_ptr<RouteList> rl (new RouteList);
3683         rl->push_back (route);
3684         remove_routes (rl);
3685 }
3686
3687 void
3688 Session::route_mute_changed ()
3689 {
3690         set_dirty ();
3691 }
3692
3693 void
3694 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3695 {
3696         boost::shared_ptr<Route> route = wpr.lock();
3697         if (!route) {
3698                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_listen_changed")) << endmsg;
3699                 return;
3700         }
3701
3702         if (route->listening_via_monitor ()) {
3703
3704                 if (Config->get_exclusive_solo()) {
3705
3706                         RouteGroup* rg = route->route_group ();
3707                         const bool group_already_accounted_for = route->use_group (group_override, &RouteGroup::is_solo);
3708
3709                         boost::shared_ptr<RouteList> r = routes.reader ();
3710
3711                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3712                                 if ((*i) == route) {
3713                                         /* already changed */
3714                                         continue;
3715                                 }
3716
3717                                 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3718                                         /* route does not get solo propagated to it */
3719                                         continue;
3720                                 }
3721
3722                                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3723                                         /* this route is a part of the same solo group as the route
3724                                          * that was changed. Changing that route did change or will
3725                                          * change all group members appropriately, so we can ignore it
3726                                          * here
3727                                          */
3728                                         continue;
3729                                 }
3730                                 (*i)->set_listen (false, Controllable::NoGroup);
3731                         }
3732                 }
3733
3734                 _listen_cnt++;
3735
3736         } else if (_listen_cnt > 0) {
3737
3738                 _listen_cnt--;
3739         }
3740
3741         update_route_solo_state ();
3742 }
3743 void
3744 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3745 {
3746         boost::shared_ptr<Route> route = wpr.lock ();
3747
3748         if (!route) {
3749                 /* should not happen */
3750                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_isolated_changed")) << endmsg;
3751                 return;
3752         }
3753
3754         bool send_changed = false;
3755
3756         if (route->solo_isolated()) {
3757                 if (_solo_isolated_cnt == 0) {
3758                         send_changed = true;
3759                 }
3760                 _solo_isolated_cnt++;
3761         } else if (_solo_isolated_cnt > 0) {
3762                 _solo_isolated_cnt--;
3763                 if (_solo_isolated_cnt == 0) {
3764                         send_changed = true;
3765                 }
3766         }
3767
3768         if (send_changed) {
3769                 IsolatedChanged (); /* EMIT SIGNAL */
3770         }
3771 }
3772
3773 void
3774 Session::route_solo_changed (bool self_solo_change, Controllable::GroupControlDisposition group_override,  boost::weak_ptr<Route> wpr)
3775 {
3776         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3777
3778         if (!self_solo_change) {
3779                 // session doesn't care about changes to soloed-by-others
3780                 return;
3781         }
3782
3783         boost::shared_ptr<Route> route = wpr.lock ();
3784         assert (route);
3785
3786         boost::shared_ptr<RouteList> r = routes.reader ();
3787         int32_t delta;
3788
3789         if (route->self_soloed()) {
3790                 delta = 1;
3791         } else {
3792                 delta = -1;
3793         }
3794
3795         /* the route may be a member of a group that has shared-solo
3796          * semantics. If so, then all members of that group should follow the
3797          * solo of the changed route. But ... this is optional, controlled by a
3798          * Controllable::GroupControlDisposition.
3799          *
3800          * The first argument to the signal that this method is connected to is the
3801          * GroupControlDisposition value that was used to change solo.
3802          *
3803          * If the solo change was done with group semantics (either InverseGroup
3804          * (force the entire group to change even if the group shared solo is
3805          * disabled) or UseGroup (use the group, which may or may not have the
3806          * shared solo property enabled)) then as we propagate the change to
3807          * the entire session we should IGNORE THE GROUP that the changed route
3808          * belongs to.
3809          */
3810
3811         RouteGroup* rg = route->route_group ();
3812         const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3813
3814         if (delta == 1 && Config->get_exclusive_solo()) {
3815
3816                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3817
3818                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3819
3820                         if ((*i) == route) {
3821                                 /* already changed */
3822                                 continue;
3823                         }
3824
3825                         if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3826                                 /* route does not get solo propagated to it */
3827                                 continue;
3828                         }
3829
3830                         if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3831                                 /* this route is a part of the same solo group as the route
3832                                  * that was changed. Changing that route did change or will
3833                                  * change all group members appropriately, so we can ignore it
3834                                  * here
3835                                  */
3836                                 continue;
3837                         }
3838
3839                         (*i)->set_solo (false, group_override);
3840                 }
3841         }
3842
3843         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3844
3845         RouteList uninvolved;
3846
3847         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3848
3849         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3850                 bool via_sends_only;
3851                 bool in_signal_flow;
3852
3853                 if ((*i) == route) {
3854                         /* already changed */
3855                         continue;
3856                 }
3857
3858                 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3859                         /* route does not get solo propagated to it */
3860                         continue;
3861                 }
3862
3863                 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3864                         /* this route is a part of the same solo group as the route
3865                          * that was changed. Changing that route did change or will
3866                          * change all group members appropriately, so we can ignore it
3867                          * here
3868                          */
3869                         continue;
3870                 }
3871
3872                 in_signal_flow = false;
3873
3874                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3875
3876                 if ((*i)->feeds (route, &via_sends_only)) {
3877                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3878                         if (!via_sends_only) {
3879                                 if (!route->soloed_by_others_upstream()) {
3880                                         (*i)->mod_solo_by_others_downstream (delta);
3881                                 } else {
3882                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
3883                                 }
3884                         } else {
3885                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3886                         }
3887                         in_signal_flow = true;
3888                 } else {
3889                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3890                 }
3891
3892                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3893
3894                 if (route->feeds (*i, &via_sends_only)) {
3895                         /* propagate solo upstream only if routing other than
3896                            sends is involved, but do consider the other route
3897                            (*i) to be part of the signal flow even if only
3898                            sends are involved.
3899                         */
3900                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3901                                                                   route->name(),
3902                                                                   (*i)->name(),
3903                                                                   via_sends_only,
3904                                                                   route->soloed_by_others_downstream(),
3905                                                                   route->soloed_by_others_upstream()));
3906                         if (!via_sends_only) {
3907                                 //NB. Triggers Invert Push, which handles soloed by downstream
3908                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3909                                 (*i)->mod_solo_by_others_upstream (delta);
3910                         } else {
3911                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3912                         }
3913                         in_signal_flow = true;
3914                 } else {
3915                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3916                 }
3917
3918                 if (!in_signal_flow) {
3919                         uninvolved.push_back (*i);
3920                 }
3921         }
3922
3923         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3924
3925         update_route_solo_state (r);
3926
3927         /* now notify that the mute state of the routes not involved in the signal
3928            pathway of the just-solo-changed route may have altered.
3929         */
3930
3931         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3932                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3933                 (*i)->act_on_mute ();
3934                 (*i)->mute_changed ();
3935         }
3936
3937         SoloChanged (); /* EMIT SIGNAL */
3938         set_dirty();
3939 }
3940
3941 void
3942 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3943 {
3944         /* now figure out if anything that matters is soloed (or is "listening")*/
3945
3946         bool something_soloed = false;
3947         bool something_listening = false;
3948         uint32_t listeners = 0;
3949         uint32_t isolated = 0;
3950
3951         if (!r) {
3952                 r = routes.reader();
3953         }
3954
3955         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3956                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3957                         something_soloed = true;
3958                 }
3959
3960                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3961                         if (Config->get_solo_control_is_listen_control()) {
3962                                 listeners++;
3963                                 something_listening = true;
3964                         } else {
3965                                 (*i)->set_listen (false, Controllable::NoGroup);
3966                         }
3967                 }
3968
3969                 if ((*i)->solo_isolated()) {
3970                         isolated++;
3971                 }
3972         }
3973
3974         if (something_soloed != _non_soloed_outs_muted) {
3975                 _non_soloed_outs_muted = something_soloed;
3976                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3977         }
3978
3979         if (something_listening != _listening) {
3980                 _listening = something_listening;
3981                 SoloActive (_listening);
3982         }
3983
3984         _listen_cnt = listeners;
3985
3986         if (isolated != _solo_isolated_cnt) {
3987                 _solo_isolated_cnt = isolated;
3988                 IsolatedChanged (); /* EMIT SIGNAL */
3989         }
3990
3991         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3992                                                   something_soloed, listeners, isolated));
3993 }
3994
3995 boost::shared_ptr<RouteList>
3996 Session::get_routes_with_internal_returns() const
3997 {
3998         boost::shared_ptr<RouteList> r = routes.reader ();
3999         boost::shared_ptr<RouteList> rl (new RouteList);
4000
4001         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4002                 if ((*i)->internal_return ()) {
4003                         rl->push_back (*i);
4004                 }
4005         }
4006         return rl;
4007 }
4008
4009 bool
4010 Session::io_name_is_legal (const std::string& name)
4011 {
4012         boost::shared_ptr<RouteList> r = routes.reader ();
4013
4014         for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4015                 if (name == *reserved) {
4016                         if (!route_by_name (*reserved)) {
4017                                 /* first instance of a reserved name is allowed */
4018                                 return true;
4019                         }
4020                         /* all other instances of a reserved name are not allowed */
4021                         return false;
4022                 }
4023         }
4024
4025         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4026                 if ((*i)->name() == name) {
4027                         return false;
4028                 }
4029
4030                 if ((*i)->has_io_processor_named (name)) {
4031                         return false;
4032                 }
4033         }
4034
4035         return true;
4036 }
4037
4038 void
4039 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4040 {
4041         RouteList rl2;
4042         vector<string> connections;
4043
4044         /* if we are passed only a single route and we're not told to turn
4045          * others off, then just do the simple thing.
4046          */
4047
4048         if (flip_others == false && rl->size() == 1) {
4049                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4050                 if (mt) {
4051                         mt->set_input_active (onoff);
4052                         return;
4053                 }
4054         }
4055
4056         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4057
4058                 PortSet& ps ((*rt)->input()->ports());
4059
4060                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4061                         p->get_connections (connections);
4062                 }
4063
4064                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4065                         routes_using_input_from (*s, rl2);
4066                 }
4067
4068                 /* scan all relevant routes to see if others are on or off */
4069
4070                 bool others_are_already_on = false;
4071
4072                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4073
4074                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4075
4076                         if (!mt) {
4077                                 continue;
4078                         }
4079
4080                         if ((*r) != (*rt)) {
4081                                 if (mt->input_active()) {
4082                                         others_are_already_on = true;
4083                                 }
4084                         } else {
4085                                 /* this one needs changing */
4086                                 mt->set_input_active (onoff);
4087                         }
4088                 }
4089
4090                 if (flip_others) {
4091
4092                         /* globally reverse other routes */
4093
4094                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4095                                 if ((*r) != (*rt)) {
4096                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4097                                         if (mt) {
4098                                                 mt->set_input_active (!others_are_already_on);
4099                                         }
4100                                 }
4101                         }
4102                 }
4103         }
4104 }
4105
4106 void
4107 Session::routes_using_input_from (const string& str, RouteList& rl)
4108 {
4109         boost::shared_ptr<RouteList> r = routes.reader();
4110
4111         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4112                 if ((*i)->input()->connected_to (str)) {
4113                         rl.push_back (*i);
4114                 }
4115         }
4116 }
4117
4118 boost::shared_ptr<Route>
4119 Session::route_by_name (string name)
4120 {
4121         boost::shared_ptr<RouteList> r = routes.reader ();
4122
4123         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4124                 if ((*i)->name() == name) {
4125                         return *i;
4126                 }
4127         }
4128
4129         return boost::shared_ptr<Route> ((Route*) 0);
4130 }
4131
4132 boost::shared_ptr<Route>
4133 Session::route_by_id (PBD::ID id)
4134 {
4135         boost::shared_ptr<RouteList> r = routes.reader ();
4136
4137         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4138                 if ((*i)->id() == id) {
4139                         return *i;
4140                 }
4141         }
4142
4143         return boost::shared_ptr<Route> ((Route*) 0);
4144 }
4145
4146 boost::shared_ptr<Processor>
4147 Session::processor_by_id (PBD::ID id) const
4148 {
4149         boost::shared_ptr<RouteList> r = routes.reader ();
4150
4151         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4152                 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4153                 if (p) {
4154                         return p;
4155                 }
4156         }
4157
4158         return boost::shared_ptr<Processor> ();
4159 }
4160
4161 boost::shared_ptr<Track>
4162 Session::track_by_diskstream_id (PBD::ID id)
4163 {
4164         boost::shared_ptr<RouteList> r = routes.reader ();
4165
4166         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4167                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4168                 if (t && t->using_diskstream_id (id)) {
4169                         return t;
4170                 }
4171         }
4172
4173         return boost::shared_ptr<Track> ();
4174 }
4175
4176 boost::shared_ptr<Route>
4177 Session::route_by_remote_id (uint32_t id)
4178 {
4179         boost::shared_ptr<RouteList> r = routes.reader ();
4180
4181         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4182                 if ((*i)->remote_control_id() == id) {
4183                         return *i;
4184                 }
4185         }
4186
4187         return boost::shared_ptr<Route> ((Route*) 0);
4188 }
4189
4190
4191 boost::shared_ptr<Route>
4192 Session::route_by_selected_count (uint32_t id)
4193 {
4194         boost::shared_ptr<RouteList> r = routes.reader ();
4195
4196         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4197                 /* NOT IMPLEMENTED */
4198         }
4199
4200         return boost::shared_ptr<Route> ((Route*) 0);
4201 }
4202
4203
4204 void
4205 Session::reassign_track_numbers ()
4206 {
4207         int64_t tn = 0;
4208         int64_t bn = 0;
4209         RouteList r (*(routes.reader ()));
4210         SignalOrderRouteSorter sorter;
4211         r.sort (sorter);
4212
4213         StateProtector sp (this);
4214
4215         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4216                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4217                         (*i)->set_track_number(++tn);
4218                 }
4219                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4220                         (*i)->set_track_number(--bn);
4221                 }
4222         }
4223         const uint32_t decimals = ceilf (log10f (tn + 1));
4224         const bool decimals_changed = _track_number_decimals != decimals;
4225         _track_number_decimals = decimals;
4226
4227         if (decimals_changed && config.get_track_name_number ()) {
4228                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4229                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4230                         if (t) {
4231                                 t->resync_track_name();
4232                         }
4233                 }
4234                 // trigger GUI re-layout
4235                 config.ParameterChanged("track-name-number");
4236         }
4237 }
4238
4239 void
4240 Session::playlist_region_added (boost::weak_ptr<Region> w)
4241 {
4242         boost::shared_ptr<Region> r = w.lock ();
4243         if (!r) {
4244                 return;
4245         }
4246
4247         /* These are the operations that are currently in progress... */
4248         list<GQuark> curr = _current_trans_quarks;
4249         curr.sort ();
4250
4251         /* ...and these are the operations during which we want to update
4252            the session range location markers.
4253         */
4254         list<GQuark> ops;
4255         ops.push_back (Operations::capture);
4256         ops.push_back (Operations::paste);
4257         ops.push_back (Operations::duplicate_region);
4258         ops.push_back (Operations::insert_file);
4259         ops.push_back (Operations::insert_region);
4260         ops.push_back (Operations::drag_region_brush);
4261         ops.push_back (Operations::region_drag);
4262         ops.push_back (Operations::selection_grab);
4263         ops.push_back (Operations::region_fill);
4264         ops.push_back (Operations::fill_selection);
4265         ops.push_back (Operations::create_region);
4266         ops.push_back (Operations::region_copy);
4267         ops.push_back (Operations::fixed_time_region_copy);
4268         ops.sort ();
4269
4270         /* See if any of the current operations match the ones that we want */
4271         list<GQuark> in;
4272         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4273
4274         /* If so, update the session range markers */
4275         if (!in.empty ()) {
4276                 maybe_update_session_range (r->position (), r->last_frame ());
4277         }
4278 }
4279
4280 /** Update the session range markers if a is before the current start or
4281  *  b is after the current end.
4282  */
4283 void
4284 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4285 {
4286         if (_state_of_the_state & Loading) {
4287                 return;
4288         }
4289
4290         framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4291
4292         if (_session_range_location == 0) {
4293
4294                 set_session_range_location (a, b + session_end_marker_shift_samples);
4295
4296         } else {
4297
4298                 if (a < _session_range_location->start()) {
4299                         _session_range_location->set_start (a);
4300                 }
4301
4302                 if (b > _session_range_location->end()) {
4303                         _session_range_location->set_end (b);
4304                 }
4305         }
4306 }
4307
4308 void
4309 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4310 {
4311         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4312                 maybe_update_session_range (i->to, i->to + i->length);
4313         }
4314 }
4315
4316 void
4317 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4318 {
4319         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4320                 maybe_update_session_range (i->from, i->to);
4321         }
4322 }
4323
4324 /* Region management */
4325
4326 boost::shared_ptr<Region>
4327 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4328 {
4329         const RegionFactory::RegionMap& regions (RegionFactory::regions());
4330         RegionFactory::RegionMap::const_iterator i;
4331         boost::shared_ptr<Region> region;
4332
4333         Glib::Threads::Mutex::Lock lm (region_lock);
4334
4335         for (i = regions.begin(); i != regions.end(); ++i) {
4336
4337                 region = i->second;
4338
4339                 if (region->whole_file()) {
4340
4341                         if (child->source_equivalent (region)) {
4342                                 return region;
4343                         }
4344                 }
4345         }
4346
4347         return boost::shared_ptr<Region> ();
4348 }
4349
4350 int
4351 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4352 {
4353         set<boost::shared_ptr<Region> > relevant_regions;
4354
4355         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4356                 RegionFactory::get_regions_using_source (*s, relevant_regions);
4357         }
4358
4359         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4360                 set<boost::shared_ptr<Region> >::iterator tmp;
4361
4362                 tmp = r;
4363                 ++tmp;
4364
4365                 playlists->destroy_region (*r);
4366                 RegionFactory::map_remove (*r);
4367
4368                 (*r)->drop_sources ();
4369                 (*r)->drop_references ();
4370
4371                 relevant_regions.erase (r);
4372
4373                 r = tmp;
4374         }
4375
4376         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4377
4378                 {
4379                         Glib::Threads::Mutex::Lock ls (source_lock);
4380                         /* remove from the main source list */
4381                         sources.erase ((*s)->id());
4382                 }
4383
4384                 (*s)->mark_for_remove ();
4385                 (*s)->drop_references ();
4386
4387                 s = srcs.erase (s);
4388         }
4389
4390         return 0;
4391 }
4392
4393 int
4394 Session::remove_last_capture ()
4395 {
4396         list<boost::shared_ptr<Source> > srcs;
4397
4398         boost::shared_ptr<RouteList> rl = routes.reader ();
4399         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4400                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4401                 if (!tr) {
4402                         continue;
4403                 }
4404
4405                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4406
4407                 if (!l.empty()) {
4408                         srcs.insert (srcs.end(), l.begin(), l.end());
4409                         l.clear ();
4410                 }
4411         }
4412
4413         destroy_sources (srcs);
4414
4415         save_state (_current_snapshot_name);
4416
4417         return 0;
4418 }
4419
4420 /* Source Management */
4421
4422 void
4423 Session::add_source (boost::shared_ptr<Source> source)
4424 {
4425         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4426         pair<SourceMap::iterator,bool> result;
4427
4428         entry.first = source->id();
4429         entry.second = source;
4430
4431         {
4432                 Glib::Threads::Mutex::Lock lm (source_lock);
4433                 result = sources.insert (entry);
4434         }
4435
4436         if (result.second) {
4437
4438                 /* yay, new source */
4439
4440                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4441
4442                 if (fs) {
4443                         if (!fs->within_session()) {
4444                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4445                         }
4446                 }
4447
4448                 set_dirty();
4449
4450                 boost::shared_ptr<AudioFileSource> afs;
4451
4452                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4453                         if (Config->get_auto_analyse_audio()) {
4454                                 Analyser::queue_source_for_analysis (source, false);
4455                         }
4456                 }
4457
4458                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4459         }
4460 }
4461
4462 void
4463 Session::remove_source (boost::weak_ptr<Source> src)
4464 {
4465         if (_state_of_the_state & Deletion) {
4466                 return;
4467         }
4468
4469         SourceMap::iterator i;
4470         boost::shared_ptr<Source> source = src.lock();
4471
4472         if (!source) {
4473                 return;
4474         }
4475
4476         {
4477                 Glib::Threads::Mutex::Lock lm (source_lock);
4478
4479                 if ((i = sources.find (source->id())) != sources.end()) {
4480                         sources.erase (i);
4481                 }
4482         }
4483
4484         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4485
4486                 /* save state so we don't end up with a session file
4487                    referring to non-existent sources.
4488                 */
4489
4490                 save_state (_current_snapshot_name);
4491         }
4492 }
4493
4494 boost::shared_ptr<Source>
4495 Session::source_by_id (const PBD::ID& id)
4496 {
4497         Glib::Threads::Mutex::Lock lm (source_lock);
4498         SourceMap::iterator i;
4499         boost::shared_ptr<Source> source;
4500
4501         if ((i = sources.find (id)) != sources.end()) {
4502                 source = i->second;
4503         }
4504
4505         return source;
4506 }
4507
4508 boost::shared_ptr<AudioFileSource>
4509 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4510 {
4511         /* Restricted to audio files because only audio sources have channel
4512            as a property.
4513         */
4514
4515         Glib::Threads::Mutex::Lock lm (source_lock);
4516
4517         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4518                 boost::shared_ptr<AudioFileSource> afs
4519                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4520
4521                 if (afs && afs->path() == path && chn == afs->channel()) {
4522                         return afs;
4523                 }
4524         }
4525
4526         return boost::shared_ptr<AudioFileSource>();
4527 }
4528
4529 boost::shared_ptr<MidiSource>
4530 Session::midi_source_by_path (const std::string& path) const
4531 {
4532         /* Restricted to MIDI files because audio sources require a channel
4533            for unique identification, in addition to a path.
4534         */
4535
4536         Glib::Threads::Mutex::Lock lm (source_lock);
4537
4538         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4539                 boost::shared_ptr<MidiSource> ms
4540                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4541                 boost::shared_ptr<FileSource> fs
4542                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4543
4544                 if (ms && fs && fs->path() == path) {
4545                         return ms;
4546                 }
4547         }
4548
4549         return boost::shared_ptr<MidiSource>();
4550 }
4551
4552 uint32_t
4553 Session::count_sources_by_origin (const string& path)
4554 {
4555         uint32_t cnt = 0;
4556         Glib::Threads::Mutex::Lock lm (source_lock);
4557
4558         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4559                 boost::shared_ptr<FileSource> fs
4560                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4561
4562                 if (fs && fs->origin() == path) {
4563                         ++cnt;
4564                 }
4565         }
4566
4567         return cnt;
4568 }
4569
4570 static string
4571 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4572         if (hash) {
4573                 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4574                 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4575         } else {
4576                 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4577         }
4578 }
4579
4580 string
4581 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4582 {
4583         string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4584
4585         if (Glib::path_is_absolute (filepath)) {
4586
4587                 /* rip the session dir from the audiofile source */
4588
4589                 string session_path;
4590                 bool in_another_session = true;
4591
4592                 if (filepath.find (interchange_dir_string) != string::npos) {
4593
4594                         session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4595                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4596                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4597                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4598
4599                         /* see if it is within our session */
4600
4601                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4602                                 if (i->path == session_path) {
4603                                         in_another_session = false;
4604                                         break;
4605                                 }
4606                         }
4607                 } else {
4608                         in_another_session = false;
4609                 }
4610
4611
4612                 if (in_another_session) {
4613                         SessionDirectory sd (session_path);
4614                         return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4615                 }
4616         }
4617
4618         /* 1) if file belongs to this session
4619          * it may be a relative path (interchange/...)
4620          * or just basename (session_state, remove source)
4621          * -> just use the basename
4622          */
4623         std::string filename = Glib::path_get_basename (filepath);
4624         std::string path;
4625
4626         /* 2) if the file is outside our session dir:
4627          * (imported but not copied) add the path for check-summming */
4628         if (!in_session) {
4629                 path = Glib::path_get_dirname (filepath);
4630         }
4631
4632         return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4633 }
4634
4635 string
4636 Session::new_audio_source_path_for_embedded (const std::string& path)
4637 {
4638         /* embedded source:
4639          *
4640          * we know that the filename is already unique because it exists
4641          * out in the filesystem.
4642          *
4643          * However, when we bring it into the session, we could get a
4644          * collision.
4645          *
4646          * Eg. two embedded files:
4647          *
4648          *          /foo/bar/baz.wav
4649          *          /frob/nic/baz.wav
4650          *
4651          * When merged into session, these collide.
4652          *
4653          * There will not be a conflict with in-memory sources
4654          * because when the source was created we already picked
4655          * a unique name for it.
4656          *
4657          * This collision is not likely to be common, but we have to guard
4658          * against it.  So, if there is a collision, take the md5 hash of the
4659          * the path, and use that as the filename instead.
4660          */
4661
4662         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4663         string base = Glib::path_get_basename (path);
4664         string newpath = Glib::build_filename (sdir.sound_path(), base);
4665
4666         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4667
4668                 MD5 md5;
4669
4670                 md5.digestString (path.c_str());
4671                 md5.writeToString ();
4672                 base = md5.digestChars;
4673
4674                 string ext = get_suffix (path);
4675
4676                 if (!ext.empty()) {
4677                         base += '.';
4678                         base += ext;
4679                 }
4680
4681                 newpath = Glib::build_filename (sdir.sound_path(), base);
4682
4683                 /* if this collides, we're screwed */
4684
4685                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4686                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4687                         return string();
4688                 }
4689
4690         }
4691
4692         return newpath;
4693 }
4694
4695 /** Return true if there are no audio file sources that use @param name as
4696  * the filename component of their path.
4697  *
4698  * Return false otherwise.
4699  *
4700  * This method MUST ONLY be used to check in-session, mono files since it
4701  * hard-codes the channel of the audio file source we are looking for as zero.
4702  *
4703  * If/when Ardour supports native files in non-mono formats, the logic here
4704  * will need to be revisited.
4705  */
4706 bool
4707 Session::audio_source_name_is_unique (const string& name)
4708 {
4709         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4710         vector<space_and_path>::iterator i;
4711         uint32_t existing = 0;
4712
4713         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4714
4715                 /* note that we search *without* the extension so that
4716                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4717                    in the event that this new name is required for
4718                    a file format change.
4719                 */
4720
4721                 const string spath = *i;
4722
4723                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4724                         existing++;
4725                         break;
4726                 }
4727
4728                 /* it is possible that we have the path already
4729                  * assigned to a source that has not yet been written
4730                  * (ie. the write source for a diskstream). we have to
4731                  * check this in order to make sure that our candidate
4732                  * path isn't used again, because that can lead to
4733                  * two Sources point to the same file with different
4734                  * notions of their removability.
4735                  */
4736
4737
4738                 string possible_path = Glib::build_filename (spath, name);
4739
4740                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4741                         existing++;
4742                         break;
4743                 }
4744         }
4745
4746         return (existing == 0);
4747 }
4748
4749 string
4750 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)
4751 {
4752         ostringstream sstr;
4753         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4754
4755         if (Profile->get_trx() && destructive) {
4756                 sstr << 'T';
4757                 sstr << setfill ('0') << setw (4) << cnt;
4758                 sstr << legalized_base;
4759         } else {
4760                 sstr << legalized_base;
4761
4762                 if (take_required || related_exists) {
4763                         sstr << '-';
4764                         sstr << cnt;
4765                 }
4766         }
4767
4768         if (nchan == 2) {
4769                 if (chan == 0) {
4770                         sstr << "%L";
4771                 } else {
4772                         sstr << "%R";
4773                 }
4774         } else if (nchan > 2) {
4775                 if (nchan < 26) {
4776                         sstr << '%';
4777                         sstr << 'a' + chan;
4778                 } else {
4779                         /* XXX what? more than 26 channels! */
4780                         sstr << '%';
4781                         sstr << chan+1;
4782                 }
4783         }
4784
4785         sstr << ext;
4786
4787         return sstr.str();
4788 }
4789
4790 /** Return a unique name based on \a base for a new internal audio source */
4791 string
4792 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4793 {
4794         uint32_t cnt;
4795         string possible_name;
4796         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4797         string legalized;
4798         bool some_related_source_name_exists = false;
4799
4800         legalized = legalize_for_path (base);
4801
4802         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4803
4804         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4805
4806                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4807
4808                 if (audio_source_name_is_unique (possible_name)) {
4809                         break;
4810                 }
4811
4812                 some_related_source_name_exists = true;
4813
4814                 if (cnt > limit) {
4815                         error << string_compose(
4816                                         _("There are already %1 recordings for %2, which I consider too many."),
4817                                         limit, base) << endmsg;
4818                         destroy ();
4819                         throw failed_constructor();
4820                 }
4821         }
4822
4823         /* We've established that the new name does not exist in any session
4824          * directory, so now find out which one we should use for this new
4825          * audio source.
4826          */
4827
4828         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4829
4830         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4831
4832         return s;
4833 }
4834
4835 /** Return a unique name based on `base` for a new internal MIDI source */
4836 string
4837 Session::new_midi_source_path (const string& base)
4838 {
4839         uint32_t cnt;
4840         char buf[PATH_MAX+1];
4841         const uint32_t limit = 10000;
4842         string legalized;
4843         string possible_path;
4844         string possible_name;
4845
4846         buf[0] = '\0';
4847         legalized = legalize_for_path (base);
4848
4849         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4850         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4851
4852         /* - the main session folder is the first in the vector.
4853          * - after checking all locations for file-name uniqueness,
4854          *   we keep the one from the last iteration as new file name
4855          * - midi files are small and should just be kept in the main session-folder
4856          *
4857          * -> reverse the array, check main session folder last and use that as location
4858          *    for MIDI files.
4859          */
4860         std::reverse(sdirs.begin(), sdirs.end());
4861
4862         for (cnt = 1; cnt <= limit; ++cnt) {
4863
4864                 vector<space_and_path>::iterator i;
4865                 uint32_t existing = 0;
4866
4867                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4868
4869                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4870                         possible_name = buf;
4871
4872                         possible_path = Glib::build_filename (*i, possible_name);
4873
4874                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4875                                 existing++;
4876                         }
4877
4878                         if (midi_source_by_path (possible_path)) {
4879                                 existing++;
4880                         }
4881                 }
4882
4883                 if (existing == 0) {
4884                         break;
4885                 }
4886
4887                 if (cnt > limit) {
4888                         error << string_compose(
4889                                         _("There are already %1 recordings for %2, which I consider too many."),
4890                                         limit, base) << endmsg;
4891                         destroy ();
4892                         return 0;
4893                 }
4894         }
4895
4896         /* No need to "find best location" for software/app-based RAID, because
4897            MIDI is so small that we always put it in the same place.
4898         */
4899
4900         return possible_path;
4901 }
4902
4903
4904 /** Create a new within-session audio source */
4905 boost::shared_ptr<AudioFileSource>
4906 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4907 {
4908         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4909
4910         if (!path.empty()) {
4911                 return boost::dynamic_pointer_cast<AudioFileSource> (
4912                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
4913         } else {
4914                 throw failed_constructor ();
4915         }
4916 }
4917
4918 /** Create a new within-session MIDI source */
4919 boost::shared_ptr<MidiSource>
4920 Session::create_midi_source_for_session (string const & basic_name)
4921 {
4922         const string path = new_midi_source_path (basic_name);
4923
4924         if (!path.empty()) {
4925                 return boost::dynamic_pointer_cast<SMFSource> (
4926                         SourceFactory::createWritable (
4927                                 DataType::MIDI, *this, path, false, frame_rate()));
4928         } else {
4929                 throw failed_constructor ();
4930         }
4931 }
4932
4933 /** Create a new within-session MIDI source */
4934 boost::shared_ptr<MidiSource>
4935 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4936 {
4937         /* the caller passes in the track the source will be used in,
4938            so that we can keep the numbering sane.
4939
4940            Rationale: a track with the name "Foo" that has had N
4941            captures carried out so far will ALREADY have a write source
4942            named "Foo-N+1.mid" waiting to be used for the next capture.
4943
4944            If we call new_midi_source_name() we will get "Foo-N+2". But
4945            there is no region corresponding to "Foo-N+1", so when
4946            "Foo-N+2" appears in the track, the gap presents the user
4947            with odd behaviour - why did it skip past Foo-N+1?
4948
4949            We could explain this to the user in some odd way, but
4950            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4951            use "Foo-N+1" here.
4952
4953            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4954         */
4955
4956         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4957         assert (mt);
4958         std::string name = track->steal_write_source_name ();
4959
4960         if (name.empty()) {
4961                 return boost::shared_ptr<MidiSource>();
4962         }
4963
4964         /* MIDI files are small, just put them in the first location of the
4965            session source search path.
4966         */
4967
4968         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4969
4970         return boost::dynamic_pointer_cast<SMFSource> (
4971                 SourceFactory::createWritable (
4972                         DataType::MIDI, *this, path, false, frame_rate()));
4973 }
4974
4975
4976 void
4977 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4978 {
4979         if (playlist->hidden()) {
4980                 return;
4981         }
4982
4983         playlists->add (playlist);
4984
4985         if (unused) {
4986                 playlist->release();
4987         }
4988
4989         set_dirty();
4990 }
4991
4992 void
4993 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4994 {
4995         if (_state_of_the_state & Deletion) {
4996                 return;
4997         }
4998
4999         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5000
5001         if (!playlist) {
5002                 return;
5003         }
5004
5005         playlists->remove (playlist);
5006
5007         set_dirty();
5008 }
5009
5010 void
5011 Session::set_audition (boost::shared_ptr<Region> r)
5012 {
5013         pending_audition_region = r;
5014         add_post_transport_work (PostTransportAudition);
5015         _butler->schedule_transport_work ();
5016 }
5017
5018 void
5019 Session::audition_playlist ()
5020 {
5021         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5022         ev->region.reset ();
5023         queue_event (ev);
5024 }
5025
5026
5027 void
5028 Session::register_lua_function (
5029                 const std::string& name,
5030                 const std::string& script,
5031                 const LuaScriptParamList& args
5032                 )
5033 {
5034         Glib::Threads::Mutex::Lock lm (lua_lock);
5035
5036         lua_State* L = lua.getState();
5037
5038         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5039         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5040         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5041                 if ((*i)->optional && !(*i)->is_set) { continue; }
5042                 tbl_arg[(*i)->name] = (*i)->value;
5043         }
5044         (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5045         set_dirty();
5046 }
5047
5048 void
5049 Session::unregister_lua_function (const std::string& name)
5050 {
5051         Glib::Threads::Mutex::Lock lm (lua_lock);
5052         (*_lua_del)(name); // throws luabridge::LuaException
5053         lua.collect_garbage ();
5054         set_dirty();
5055 }
5056
5057 std::vector<std::string>
5058 Session::registered_lua_functions ()
5059 {
5060         Glib::Threads::Mutex::Lock lm (lua_lock);
5061         std::vector<std::string> rv;
5062
5063         try {
5064                 luabridge::LuaRef list ((*_lua_list)());
5065                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5066                         if (!i.key ().isString ()) { assert(0); continue; }
5067                         rv.push_back (i.key ().cast<std::string> ());
5068                 }
5069         } catch (luabridge::LuaException const& e) { }
5070         return rv;
5071 }
5072
5073 #ifndef NDEBUG
5074 static void _lua_print (std::string s) {
5075         std::cout << "SessionLua: " << s << "\n";
5076 }
5077 #endif
5078
5079 void
5080 Session::try_run_lua (pframes_t nframes)
5081 {
5082         if (_n_lua_scripts == 0) return;
5083         Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5084         if (tm.locked ()) {
5085                 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5086         }
5087 }
5088
5089 void
5090 Session::setup_lua ()
5091 {
5092 #ifndef NDEBUG
5093         lua.Print.connect (&_lua_print);
5094 #endif
5095         lua.do_command (
5096                         "function ArdourSession ()"
5097                         "  local self = { scripts = {}, instances = {} }"
5098                         ""
5099                         "  local remove = function (n)"
5100                         "   self.scripts[n] = nil"
5101                         "   self.instances[n] = nil"
5102                         "   Session:scripts_changed()" // call back
5103                         "  end"
5104                         ""
5105                         "  local addinternal = function (n, f, a)"
5106                         "   assert(type(n) == 'string', 'function-name must be string')"
5107                         "   assert(type(f) == 'function', 'Given script is a not a function')"
5108                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5109                         "   assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5110                         "   self.scripts[n] = { ['f'] = f, ['a'] = a }"
5111                         "   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"
5112                         "   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 }"
5113                         "   self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5114                         "   Session:scripts_changed()" // call back
5115                         "  end"
5116                         ""
5117                         "  local add = function (n, b, a)"
5118                         "   assert(type(b) == 'string', 'ByteCode must be string')"
5119                         "   load (b)()" // assigns f
5120                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5121                         "   addinternal (n, load(f), a)"
5122                         "  end"
5123                         ""
5124                         "  local run = function (...)"
5125                         "   for n, s in pairs (self.instances) do"
5126                         "     local status, err = pcall (s, ...)"
5127                         "     if not status then"
5128                         "       print ('fn \"'.. n .. '\": ', err)"
5129                         "       remove (n)"
5130                         "      end"
5131                         "   end"
5132                         "   collectgarbage()"
5133                         "  end"
5134                         ""
5135                         "  local cleanup = function ()"
5136                         "   self.scripts = nil"
5137                         "   self.instances = nil"
5138                         "  end"
5139                         ""
5140                         "  local list = function ()"
5141                         "   local rv = {}"
5142                         "   for n, _ in pairs (self.scripts) do"
5143                         "     rv[n] = true"
5144                         "   end"
5145                         "   return rv"
5146                         "  end"
5147                         ""
5148                         "  local function basic_serialize (o)"
5149                         "    if type(o) == \"number\" then"
5150                         "     return tostring(o)"
5151                         "    else"
5152                         "     return string.format(\"%q\", o)"
5153                         "    end"
5154                         "  end"
5155                         ""
5156                         "  local function serialize (name, value)"
5157                         "   local rv = name .. ' = '"
5158                         "   collectgarbage()"
5159                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5160                         "    return rv .. basic_serialize(value) .. ' '"
5161                         "   elseif type(value) == \"table\" then"
5162                         "    rv = rv .. '{} '"
5163                         "    for k,v in pairs(value) do"
5164                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5165                         "     rv = rv .. serialize(fieldname, v) .. ' '"
5166                         "     collectgarbage()" // string concatenation allocates a new string :(
5167                         "    end"
5168                         "    return rv;"
5169                         "   elseif type(value) == \"function\" then"
5170                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
5171                         "   else"
5172                         "    error('cannot save a ' .. type(value))"
5173                         "   end"
5174                         "  end"
5175                         ""
5176                         ""
5177                         "  local save = function ()"
5178                         "   return (serialize('scripts', self.scripts))"
5179                         "  end"
5180                         ""
5181                         "  local restore = function (state)"
5182                         "   self.scripts = {}"
5183                         "   load (state)()"
5184                         "   for n, s in pairs (scripts) do"
5185                         "    addinternal (n, load(s['f']), s['a'])"
5186                         "   end"
5187                         "  end"
5188                         ""
5189                         " return { run = run, add = add, remove = remove,"
5190                   "          list = list, restore = restore, save = save, cleanup = cleanup}"
5191                         " end"
5192                         " "
5193                         " sess = ArdourSession ()"
5194                         " ArdourSession = nil"
5195                         " "
5196                         "function ardour () end"
5197                         );
5198
5199         lua_State* L = lua.getState();
5200
5201         try {
5202                 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5203                 lua.do_command ("sess = nil"); // hide it.
5204                 lua.do_command ("collectgarbage()");
5205
5206                 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5207                 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5208                 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5209                 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5210                 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5211                 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5212                 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5213         } catch (luabridge::LuaException const& e) {
5214                 fatal << string_compose (_("programming error: %1"),
5215                                 X_("Failed to setup Lua interpreter"))
5216                         << endmsg;
5217                 abort(); /*NOTREACHED*/
5218         }
5219
5220         LuaBindings::stddef (L);
5221         LuaBindings::common (L);
5222         LuaBindings::dsp (L);
5223         luabridge::push <Session *> (L, this);
5224         lua_setglobal (L, "Session");
5225 }
5226
5227 void
5228 Session::scripts_changed ()
5229 {
5230         assert (!lua_lock.trylock()); // must hold lua_lock
5231
5232         try {
5233                 luabridge::LuaRef list ((*_lua_list)());
5234                 int cnt = 0;
5235                 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5236                         if (!i.key ().isString ()) { assert(0); continue; }
5237                         ++cnt;
5238                 }
5239                 _n_lua_scripts = cnt;
5240         } catch (luabridge::LuaException const& e) {
5241                 fatal << string_compose (_("programming error: %1"),
5242                                 X_("Indexing Lua Session Scripts failed."))
5243                         << endmsg;
5244                 abort(); /*NOTREACHED*/
5245         }
5246 }
5247
5248 void
5249 Session::non_realtime_set_audition ()
5250 {
5251         assert (pending_audition_region);
5252         auditioner->audition_region (pending_audition_region);
5253         pending_audition_region.reset ();
5254         AuditionActive (true); /* EMIT SIGNAL */
5255 }
5256
5257 void
5258 Session::audition_region (boost::shared_ptr<Region> r)
5259 {
5260         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5261         ev->region = r;
5262         queue_event (ev);
5263 }
5264
5265 void
5266 Session::cancel_audition ()
5267 {
5268         if (!auditioner) {
5269                 return;
5270         }
5271         if (auditioner->auditioning()) {
5272                 auditioner->cancel_audition ();
5273                 AuditionActive (false); /* EMIT SIGNAL */
5274         }
5275 }
5276
5277 bool
5278 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
5279 {
5280         if (a->is_monitor()) {
5281                 return true;
5282         }
5283         if (b->is_monitor()) {
5284                 return false;
5285         }
5286         return a->order_key () < b->order_key ();
5287 }
5288
5289 bool
5290 Session::is_auditioning () const
5291 {
5292         /* can be called before we have an auditioner object */
5293         if (auditioner) {
5294                 return auditioner->auditioning();
5295         } else {
5296                 return false;
5297         }
5298 }
5299
5300 void
5301 Session::graph_reordered ()
5302 {
5303         /* don't do this stuff if we are setting up connections
5304            from a set_state() call or creating new tracks. Ditto for deletion.
5305         */
5306
5307         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5308                 return;
5309         }
5310
5311         /* every track/bus asked for this to be handled but it was deferred because
5312            we were connecting. do it now.
5313         */
5314
5315         request_input_change_handling ();
5316
5317         resort_routes ();
5318
5319         /* force all diskstreams to update their capture offset values to
5320            reflect any changes in latencies within the graph.
5321         */
5322
5323         boost::shared_ptr<RouteList> rl = routes.reader ();
5324         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5325                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5326                 if (tr) {
5327                         tr->set_capture_offset ();
5328                 }
5329         }
5330 }
5331
5332 /** @return Number of frames that there is disk space available to write,
5333  *  if known.
5334  */
5335 boost::optional<framecnt_t>
5336 Session::available_capture_duration ()
5337 {
5338         Glib::Threads::Mutex::Lock lm (space_lock);
5339
5340         if (_total_free_4k_blocks_uncertain) {
5341                 return boost::optional<framecnt_t> ();
5342         }
5343
5344         float sample_bytes_on_disk = 4.0; // keep gcc happy
5345
5346         switch (config.get_native_file_data_format()) {
5347         case FormatFloat:
5348                 sample_bytes_on_disk = 4.0;
5349                 break;
5350
5351         case FormatInt24:
5352                 sample_bytes_on_disk = 3.0;
5353                 break;
5354
5355         case FormatInt16:
5356                 sample_bytes_on_disk = 2.0;
5357                 break;
5358
5359         default:
5360                 /* impossible, but keep some gcc versions happy */
5361                 fatal << string_compose (_("programming error: %1"),
5362                                          X_("illegal native file data format"))
5363                       << endmsg;
5364                 abort(); /*NOTREACHED*/
5365         }
5366
5367         double scale = 4096.0 / sample_bytes_on_disk;
5368
5369         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5370                 return max_framecnt;
5371         }
5372
5373         return (framecnt_t) floor (_total_free_4k_blocks * scale);
5374 }
5375
5376 void
5377 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5378 {
5379         {
5380                 RCUWriter<BundleList> writer (_bundles);
5381                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5382                 b->push_back (bundle);
5383         }
5384
5385         if (emit_signal) {
5386                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5387         }
5388
5389         set_dirty();
5390 }
5391
5392 void
5393 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5394 {
5395         bool removed = false;
5396
5397         {
5398                 RCUWriter<BundleList> writer (_bundles);
5399                 boost::shared_ptr<BundleList> b = writer.get_copy ();
5400                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5401
5402                 if (i != b->end()) {
5403                         b->erase (i);
5404                         removed = true;
5405                 }
5406         }
5407
5408         if (removed) {
5409                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
5410         }
5411
5412         set_dirty();
5413 }
5414
5415 boost::shared_ptr<Bundle>
5416 Session::bundle_by_name (string name) const
5417 {
5418         boost::shared_ptr<BundleList> b = _bundles.reader ();
5419
5420         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5421                 if ((*i)->name() == name) {
5422                         return* i;
5423                 }
5424         }
5425
5426         return boost::shared_ptr<Bundle> ();
5427 }
5428
5429 void
5430 Session::tempo_map_changed (const PropertyChange&)
5431 {
5432         clear_clicks ();
5433
5434         playlists->update_after_tempo_map_change ();
5435
5436         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5437
5438         set_dirty ();
5439 }
5440
5441 void
5442 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5443 {
5444         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5445                 (*i)->recompute_frames_from_bbt ();
5446         }
5447 }
5448
5449 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5450  * the given count with the current block size.
5451  */
5452 void
5453 Session::ensure_buffers (ChanCount howmany)
5454 {
5455         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5456 }
5457
5458 void
5459 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5460 {
5461         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5462                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5463         }
5464 }
5465
5466 uint32_t
5467 Session::next_insert_id ()
5468 {
5469         /* this doesn't really loop forever. just think about it */
5470
5471         while (true) {
5472                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5473                         if (!insert_bitset[n]) {
5474                                 insert_bitset[n] = true;
5475                                 return n;
5476
5477                         }
5478                 }
5479
5480                 /* none available, so resize and try again */
5481
5482                 insert_bitset.resize (insert_bitset.size() + 16, false);
5483         }
5484 }
5485
5486 uint32_t
5487 Session::next_send_id ()
5488 {
5489         /* this doesn't really loop forever. just think about it */
5490
5491         while (true) {
5492                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5493                         if (!send_bitset[n]) {
5494                                 send_bitset[n] = true;
5495                                 return n;
5496
5497                         }
5498                 }
5499
5500                 /* none available, so resize and try again */
5501
5502                 send_bitset.resize (send_bitset.size() + 16, false);
5503         }
5504 }
5505
5506 uint32_t
5507 Session::next_aux_send_id ()
5508 {
5509         /* this doesn't really loop forever. just think about it */
5510
5511         while (true) {
5512                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5513                         if (!aux_send_bitset[n]) {
5514                                 aux_send_bitset[n] = true;
5515                                 return n;
5516
5517                         }
5518                 }
5519
5520                 /* none available, so resize and try again */
5521
5522                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5523         }
5524 }
5525
5526 uint32_t
5527 Session::next_return_id ()
5528 {
5529         /* this doesn't really loop forever. just think about it */
5530
5531         while (true) {
5532                 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5533                         if (!return_bitset[n]) {
5534                                 return_bitset[n] = true;
5535                                 return n;
5536
5537                         }
5538                 }
5539
5540                 /* none available, so resize and try again */
5541
5542                 return_bitset.resize (return_bitset.size() + 16, false);
5543         }
5544 }
5545
5546 void
5547 Session::mark_send_id (uint32_t id)
5548 {
5549         if (id >= send_bitset.size()) {
5550                 send_bitset.resize (id+16, false);
5551         }
5552         if (send_bitset[id]) {
5553                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5554         }
5555         send_bitset[id] = true;
5556 }
5557
5558 void
5559 Session::mark_aux_send_id (uint32_t id)
5560 {
5561         if (id >= aux_send_bitset.size()) {
5562                 aux_send_bitset.resize (id+16, false);
5563         }
5564         if (aux_send_bitset[id]) {
5565                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5566         }
5567         aux_send_bitset[id] = true;
5568 }
5569
5570 void
5571 Session::mark_return_id (uint32_t id)
5572 {
5573         if (id >= return_bitset.size()) {
5574                 return_bitset.resize (id+16, false);
5575         }
5576         if (return_bitset[id]) {
5577                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5578         }
5579         return_bitset[id] = true;
5580 }
5581
5582 void
5583 Session::mark_insert_id (uint32_t id)
5584 {
5585         if (id >= insert_bitset.size()) {
5586                 insert_bitset.resize (id+16, false);
5587         }
5588         if (insert_bitset[id]) {
5589                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5590         }
5591         insert_bitset[id] = true;
5592 }
5593
5594 void
5595 Session::unmark_send_id (uint32_t id)
5596 {
5597         if (id < send_bitset.size()) {
5598                 send_bitset[id] = false;
5599         }
5600 }
5601
5602 void
5603 Session::unmark_aux_send_id (uint32_t id)
5604 {
5605         if (id < aux_send_bitset.size()) {
5606                 aux_send_bitset[id] = false;
5607         }
5608 }
5609
5610 void
5611 Session::unmark_return_id (uint32_t id)
5612 {
5613         if (_state_of_the_state & Deletion) { return; }
5614         if (id < return_bitset.size()) {
5615                 return_bitset[id] = false;
5616         }
5617 }
5618
5619 void
5620 Session::unmark_insert_id (uint32_t id)
5621 {
5622         if (id < insert_bitset.size()) {
5623                 insert_bitset[id] = false;
5624         }
5625 }
5626
5627 void
5628 Session::reset_native_file_format ()
5629 {
5630         boost::shared_ptr<RouteList> rl = routes.reader ();
5631
5632         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5633                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5634                 if (tr) {
5635                         /* don't save state as we do this, there's no point
5636                          */
5637                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5638                         tr->reset_write_sources (false);
5639                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5640                 }
5641         }
5642 }
5643
5644 bool
5645 Session::route_name_unique (string n) const
5646 {
5647         boost::shared_ptr<RouteList> r = routes.reader ();
5648
5649         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5650                 if ((*i)->name() == n) {
5651                         return false;
5652                 }
5653         }
5654
5655         return true;
5656 }
5657
5658 bool
5659 Session::route_name_internal (string n) const
5660 {
5661         if (auditioner && auditioner->name() == n) {
5662                 return true;
5663         }
5664
5665         if (_click_io && _click_io->name() == n) {
5666                 return true;
5667         }
5668
5669         return false;
5670 }
5671
5672 int
5673 Session::freeze_all (InterThreadInfo& itt)
5674 {
5675         boost::shared_ptr<RouteList> r = routes.reader ();
5676
5677         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5678
5679                 boost::shared_ptr<Track> t;
5680
5681                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5682                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5683                            of every track.
5684                         */
5685                         t->freeze_me (itt);
5686                 }
5687         }
5688
5689         return 0;
5690 }
5691
5692 boost::shared_ptr<Region>
5693 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5694                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5695                           InterThreadInfo& itt,
5696                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5697                           bool for_export, bool for_freeze)
5698 {
5699         boost::shared_ptr<Region> result;
5700         boost::shared_ptr<Playlist> playlist;
5701         boost::shared_ptr<Source> source;
5702         ChanCount diskstream_channels (track.n_channels());
5703         framepos_t position;
5704         framecnt_t this_chunk;
5705         framepos_t to_do;
5706         framepos_t latency_skip;
5707         BufferSet buffers;
5708         framepos_t len = end - start;
5709         bool need_block_size_reset = false;
5710         ChanCount const max_proc = track.max_processor_streams ();
5711         string legal_playlist_name;
5712         string possible_path;
5713
5714         if (end <= start) {
5715                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5716                                          end, start) << endmsg;
5717                 return result;
5718         }
5719
5720         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5721                         include_endpoint, for_export, for_freeze);
5722
5723         if (diskstream_channels.n(track.data_type()) < 1) {
5724                 error << _("Cannot write a range with no data.") << endmsg;
5725                 return result;
5726         }
5727
5728         // block all process callback handling
5729
5730         block_processing ();
5731
5732         {
5733                 // synchronize with AudioEngine::process_callback()
5734                 // make sure processing is not currently running
5735                 // and processing_blocked() is honored before
5736                 // acquiring thread buffers
5737                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5738         }
5739
5740         _bounce_processing_active = true;
5741
5742         /* call tree *MUST* hold route_lock */
5743
5744         if ((playlist = track.playlist()) == 0) {
5745                 goto out;
5746         }
5747
5748         legal_playlist_name = legalize_for_path (playlist->name());
5749
5750         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5751
5752                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5753                 string path = ((track.data_type() == DataType::AUDIO)
5754                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5755                                : new_midi_source_path (legal_playlist_name));
5756
5757                 if (path.empty()) {
5758                         goto out;
5759                 }
5760
5761                 try {
5762                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5763                 }
5764
5765                 catch (failed_constructor& err) {
5766                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5767                         goto out;
5768                 }
5769
5770                 srcs.push_back (source);
5771         }
5772
5773         /* tell redirects that care that we are about to use a much larger
5774          * blocksize. this will flush all plugins too, so that they are ready
5775          * to be used for this process.
5776          */
5777
5778         need_block_size_reset = true;
5779         track.set_block_size (bounce_chunk_size);
5780         _engine.main_thread()->get_buffers ();
5781
5782         position = start;
5783         to_do = len;
5784         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5785
5786         /* create a set of reasonably-sized buffers */
5787         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5788                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5789         }
5790         buffers.set_count (max_proc);
5791
5792         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5793                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5794                 boost::shared_ptr<MidiSource> ms;
5795                 if (afs) {
5796                         afs->prepare_for_peakfile_writes ();
5797                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5798                         Source::Lock lock(ms->mutex());
5799                         ms->mark_streaming_write_started(lock);
5800                 }
5801         }
5802
5803         while (to_do && !itt.cancel) {
5804
5805                 this_chunk = min (to_do, bounce_chunk_size);
5806
5807                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5808                         goto out;
5809                 }
5810
5811                 start += this_chunk;
5812                 to_do -= this_chunk;
5813                 itt.progress = (float) (1.0 - ((double) to_do / len));
5814
5815                 if (latency_skip >= bounce_chunk_size) {
5816                         latency_skip -= bounce_chunk_size;
5817                         continue;
5818                 }
5819
5820                 const framecnt_t current_chunk = this_chunk - latency_skip;
5821
5822                 uint32_t n = 0;
5823                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5824                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5825                         boost::shared_ptr<MidiSource> ms;
5826
5827                         if (afs) {
5828                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5829                                         goto out;
5830                                 }
5831                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5832                                 Source::Lock lock(ms->mutex());
5833
5834                                 const MidiBuffer& buf = buffers.get_midi(0);
5835                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5836                                         Evoral::Event<framepos_t> ev = *i;
5837                                         ev.set_time(ev.time() - position);
5838                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5839                                 }
5840                         }
5841                 }
5842                 latency_skip = 0;
5843         }
5844
5845         /* post-roll, pick up delayed processor output */
5846         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5847
5848         while (latency_skip && !itt.cancel) {
5849                 this_chunk = min (latency_skip, bounce_chunk_size);
5850                 latency_skip -= this_chunk;
5851
5852                 buffers.silence (this_chunk, 0);
5853                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5854
5855                 uint32_t n = 0;
5856                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5857                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5858
5859                         if (afs) {
5860                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5861                                         goto out;
5862                                 }
5863                         }
5864                 }
5865         }
5866
5867         if (!itt.cancel) {
5868
5869                 time_t now;
5870                 struct tm* xnow;
5871                 time (&now);
5872                 xnow = localtime (&now);
5873
5874                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5875                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5876                         boost::shared_ptr<MidiSource> ms;
5877
5878                         if (afs) {
5879                                 afs->update_header (position, *xnow, now);
5880                                 afs->flush_header ();
5881                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5882                                 Source::Lock lock(ms->mutex());
5883                                 ms->mark_streaming_write_completed(lock);
5884                         }
5885                 }
5886
5887                 /* construct a region to represent the bounced material */
5888
5889                 PropertyList plist;
5890
5891                 plist.add (Properties::start, 0);
5892                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5893                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5894
5895                 result = RegionFactory::create (srcs, plist);
5896
5897         }
5898
5899   out:
5900         if (!result) {
5901                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5902                         (*src)->mark_for_remove ();
5903                         (*src)->drop_references ();
5904                 }
5905
5906         } else {
5907                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5908                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5909
5910                         if (afs)
5911                                 afs->done_with_peakfile_writes ();
5912                 }
5913         }
5914
5915         _bounce_processing_active = false;
5916
5917         if (need_block_size_reset) {
5918                 _engine.main_thread()->drop_buffers ();
5919                 track.set_block_size (get_block_size());
5920         }
5921
5922         unblock_processing ();
5923         itt.done = true;
5924
5925         return result;
5926 }
5927
5928 gain_t*
5929 Session::gain_automation_buffer() const
5930 {
5931         return ProcessThread::gain_automation_buffer ();
5932 }
5933
5934 gain_t*
5935 Session::trim_automation_buffer() const
5936 {
5937         return ProcessThread::trim_automation_buffer ();
5938 }
5939
5940 gain_t*
5941 Session::send_gain_automation_buffer() const
5942 {
5943         return ProcessThread::send_gain_automation_buffer ();
5944 }
5945
5946 pan_t**
5947 Session::pan_automation_buffer() const
5948 {
5949         return ProcessThread::pan_automation_buffer ();
5950 }
5951
5952 BufferSet&
5953 Session::get_silent_buffers (ChanCount count)
5954 {
5955         return ProcessThread::get_silent_buffers (count);
5956 }
5957
5958 BufferSet&
5959 Session::get_scratch_buffers (ChanCount count, bool silence)
5960 {
5961         return ProcessThread::get_scratch_buffers (count, silence);
5962 }
5963
5964 BufferSet&
5965 Session::get_noinplace_buffers (ChanCount count)
5966 {
5967         return ProcessThread::get_noinplace_buffers (count);
5968 }
5969
5970 BufferSet&
5971 Session::get_route_buffers (ChanCount count, bool silence)
5972 {
5973         return ProcessThread::get_route_buffers (count, silence);
5974 }
5975
5976
5977 BufferSet&
5978 Session::get_mix_buffers (ChanCount count)
5979 {
5980         return ProcessThread::get_mix_buffers (count);
5981 }
5982
5983 uint32_t
5984 Session::ntracks () const
5985 {
5986         uint32_t n = 0;
5987         boost::shared_ptr<RouteList> r = routes.reader ();
5988
5989         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5990                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5991                         ++n;
5992                 }
5993         }
5994
5995         return n;
5996 }
5997
5998 uint32_t
5999 Session::nbusses () const
6000 {
6001         uint32_t n = 0;
6002         boost::shared_ptr<RouteList> r = routes.reader ();
6003
6004         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6005                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6006                         ++n;
6007                 }
6008         }
6009
6010         return n;
6011 }
6012
6013 void
6014 Session::add_automation_list(AutomationList *al)
6015 {
6016         automation_lists[al->id()] = al;
6017 }
6018
6019 /** @return true if there is at least one record-enabled track, otherwise false */
6020 bool
6021 Session::have_rec_enabled_track () const
6022 {
6023         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6024 }
6025
6026 bool
6027 Session::have_rec_disabled_track () const
6028 {
6029     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6030 }
6031
6032 /** Update the state of our rec-enabled tracks flag */
6033 void
6034 Session::update_route_record_state ()
6035 {
6036         boost::shared_ptr<RouteList> rl = routes.reader ();
6037         RouteList::iterator i = rl->begin();
6038         while (i != rl->end ()) {
6039
6040                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6041                 if (tr && tr->record_enabled ()) {
6042                         break;
6043                 }
6044
6045                 ++i;
6046         }
6047
6048         int const old = g_atomic_int_get (&_have_rec_enabled_track);
6049
6050         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6051
6052         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6053                 RecordStateChanged (); /* EMIT SIGNAL */
6054         }
6055
6056         for (i = rl->begin(); i != rl->end (); ++i) {
6057                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6058                 if (tr && !tr->record_enabled ()) {
6059                         break;
6060                 }
6061         }
6062
6063         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6064
6065         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6066
6067         if (record_status() == Recording && record_arm_state_changed ) {
6068                 RecordArmStateChanged ();
6069         }
6070
6071 }
6072
6073 void
6074 Session::listen_position_changed ()
6075 {
6076         boost::shared_ptr<RouteList> r = routes.reader ();
6077
6078         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6079                 (*i)->listen_position_changed ();
6080         }
6081 }
6082
6083 void
6084 Session::solo_control_mode_changed ()
6085 {
6086         /* cancel all solo or all listen when solo control mode changes */
6087
6088         if (soloing()) {
6089                 set_solo (get_routes(), false);
6090         } else if (listening()) {
6091                 set_listen (get_routes(), false);
6092         }
6093 }
6094
6095 /** Called when a property of one of our route groups changes */
6096 void
6097 Session::route_group_property_changed (RouteGroup* rg)
6098 {
6099         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6100 }
6101
6102 /** Called when a route is added to one of our route groups */
6103 void
6104 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6105 {
6106         RouteAddedToRouteGroup (rg, r);
6107 }
6108
6109 /** Called when a route is removed from one of our route groups */
6110 void
6111 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6112 {
6113         update_route_record_state ();
6114         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6115 }
6116
6117 boost::shared_ptr<RouteList>
6118 Session::get_tracks () const
6119 {
6120         boost::shared_ptr<RouteList> rl = routes.reader ();
6121         boost::shared_ptr<RouteList> tl (new RouteList);
6122
6123         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6124                 if (boost::dynamic_pointer_cast<Track> (*r)) {
6125                         if (!(*r)->is_auditioner()) {
6126                                 tl->push_back (*r);
6127                         }
6128                 }
6129         }
6130         return tl;
6131 }
6132
6133 boost::shared_ptr<RouteList>
6134 Session::get_routes_with_regions_at (framepos_t const p) const
6135 {
6136         boost::shared_ptr<RouteList> r = routes.reader ();
6137         boost::shared_ptr<RouteList> rl (new RouteList);
6138
6139         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6140                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6141                 if (!tr) {
6142                         continue;
6143                 }
6144
6145                 boost::shared_ptr<Playlist> pl = tr->playlist ();
6146                 if (!pl) {
6147                         continue;
6148                 }
6149
6150                 if (pl->has_region_at (p)) {
6151                         rl->push_back (*i);
6152                 }
6153         }
6154
6155         return rl;
6156 }
6157
6158 void
6159 Session::goto_end ()
6160 {
6161         if (_session_range_location) {
6162                 request_locate (_session_range_location->end(), false);
6163         } else {
6164                 request_locate (0, false);
6165         }
6166 }
6167
6168 void
6169 Session::goto_start ()
6170 {
6171         if (_session_range_location) {
6172                 request_locate (_session_range_location->start(), false);
6173         } else {
6174                 request_locate (0, false);
6175         }
6176 }
6177
6178 framepos_t
6179 Session::current_start_frame () const
6180 {
6181         return _session_range_location ? _session_range_location->start() : 0;
6182 }
6183
6184 framepos_t
6185 Session::current_end_frame () const
6186 {
6187         return _session_range_location ? _session_range_location->end() : 0;
6188 }
6189
6190 void
6191 Session::set_session_range_location (framepos_t start, framepos_t end)
6192 {
6193         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
6194         _locations->add (_session_range_location);
6195 }
6196
6197 void
6198 Session::step_edit_status_change (bool yn)
6199 {
6200         bool send = false;
6201
6202         bool val = false;
6203         if (yn) {
6204                 send = (_step_editors == 0);
6205                 val = true;
6206
6207                 _step_editors++;
6208         } else {
6209                 send = (_step_editors == 1);
6210                 val = false;
6211
6212                 if (_step_editors > 0) {
6213                         _step_editors--;
6214                 }
6215         }
6216
6217         if (send) {
6218                 StepEditStatusChange (val);
6219         }
6220 }
6221
6222
6223 void
6224 Session::start_time_changed (framepos_t old)
6225 {
6226         /* Update the auto loop range to match the session range
6227            (unless the auto loop range has been changed by the user)
6228         */
6229
6230         Location* s = _locations->session_range_location ();
6231         if (s == 0) {
6232                 return;
6233         }
6234
6235         Location* l = _locations->auto_loop_location ();
6236
6237         if (l && l->start() == old) {
6238                 l->set_start (s->start(), true);
6239         }
6240 }
6241
6242 void
6243 Session::end_time_changed (framepos_t old)
6244 {
6245         /* Update the auto loop range to match the session range
6246            (unless the auto loop range has been changed by the user)
6247         */
6248
6249         Location* s = _locations->session_range_location ();
6250         if (s == 0) {
6251                 return;
6252         }
6253
6254         Location* l = _locations->auto_loop_location ();
6255
6256         if (l && l->end() == old) {
6257                 l->set_end (s->end(), true);
6258         }
6259 }
6260
6261 std::vector<std::string>
6262 Session::source_search_path (DataType type) const
6263 {
6264         Searchpath sp;
6265
6266         if (session_dirs.size() == 1) {
6267                 switch (type) {
6268                 case DataType::AUDIO:
6269                         sp.push_back (_session_dir->sound_path());
6270                         break;
6271                 case DataType::MIDI:
6272                         sp.push_back (_session_dir->midi_path());
6273                         break;
6274                 }
6275         } else {
6276                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6277                         SessionDirectory sdir (i->path);
6278                         switch (type) {
6279                         case DataType::AUDIO:
6280                                 sp.push_back (sdir.sound_path());
6281                                 break;
6282                         case DataType::MIDI:
6283                                 sp.push_back (sdir.midi_path());
6284                                 break;
6285                         }
6286                 }
6287         }
6288
6289         if (type == DataType::AUDIO) {
6290                 const string sound_path_2X = _session_dir->sound_path_2X();
6291                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6292                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6293                                 sp.push_back (sound_path_2X);
6294                         }
6295                 }
6296         }
6297
6298         // now check the explicit (possibly user-specified) search path
6299
6300         switch (type) {
6301         case DataType::AUDIO:
6302                 sp += Searchpath(config.get_audio_search_path ());
6303                 break;
6304         case DataType::MIDI:
6305                 sp += Searchpath(config.get_midi_search_path ());
6306                 break;
6307         }
6308
6309         return sp;
6310 }
6311
6312 void
6313 Session::ensure_search_path_includes (const string& path, DataType type)
6314 {
6315         Searchpath sp;
6316
6317         if (path == ".") {
6318                 return;
6319         }
6320
6321         switch (type) {
6322         case DataType::AUDIO:
6323                 sp += Searchpath(config.get_audio_search_path ());
6324                 break;
6325         case DataType::MIDI:
6326                 sp += Searchpath (config.get_midi_search_path ());
6327                 break;
6328         }
6329
6330         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6331                 /* No need to add this new directory if it has the same inode as
6332                    an existing one; checking inode rather than name prevents duplicated
6333                    directories when we are using symlinks.
6334
6335                    On Windows, I think we could just do if (*i == path) here.
6336                 */
6337                 if (PBD::equivalent_paths (*i, path)) {
6338                         return;
6339                 }
6340         }
6341
6342         sp += path;
6343
6344         switch (type) {
6345         case DataType::AUDIO:
6346                 config.set_audio_search_path (sp.to_string());
6347                 break;
6348         case DataType::MIDI:
6349                 config.set_midi_search_path (sp.to_string());
6350                 break;
6351         }
6352 }
6353
6354 void
6355 Session::remove_dir_from_search_path (const string& dir, DataType type)
6356 {
6357         Searchpath sp;
6358
6359         switch (type) {
6360         case DataType::AUDIO:
6361                 sp = Searchpath(config.get_audio_search_path ());
6362                 break;
6363         case DataType::MIDI:
6364                 sp = Searchpath (config.get_midi_search_path ());
6365                 break;
6366         }
6367
6368         sp -= dir;
6369
6370         switch (type) {
6371         case DataType::AUDIO:
6372                 config.set_audio_search_path (sp.to_string());
6373                 break;
6374         case DataType::MIDI:
6375                 config.set_midi_search_path (sp.to_string());
6376                 break;
6377         }
6378
6379 }
6380
6381 boost::shared_ptr<Speakers>
6382 Session::get_speakers()
6383 {
6384         return _speakers;
6385 }
6386
6387 list<string>
6388 Session::unknown_processors () const
6389 {
6390         list<string> p;
6391
6392         boost::shared_ptr<RouteList> r = routes.reader ();
6393         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6394                 list<string> t = (*i)->unknown_processors ();
6395                 copy (t.begin(), t.end(), back_inserter (p));
6396         }
6397
6398         p.sort ();
6399         p.unique ();
6400
6401         return p;
6402 }
6403
6404 void
6405 Session::update_latency (bool playback)
6406 {
6407
6408         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6409
6410         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6411                 return;
6412         }
6413
6414         boost::shared_ptr<RouteList> r = routes.reader ();
6415         framecnt_t max_latency = 0;
6416
6417         if (playback) {
6418                 /* reverse the list so that we work backwards from the last route to run to the first */
6419                 RouteList* rl = routes.reader().get();
6420                 r.reset (new RouteList (*rl));
6421                 reverse (r->begin(), r->end());
6422         }
6423
6424         /* compute actual latency values for the given direction and store them all in per-port
6425            structures. this will also publish the same values (to JACK) so that computation of latency
6426            for routes can consistently use public latency values.
6427         */
6428
6429         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6430                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6431         }
6432
6433         /* because we latency compensate playback, our published playback latencies should
6434            be the same for all output ports - all material played back by ardour has
6435            the same latency, whether its caused by plugins or by latency compensation. since
6436            these may differ from the values computed above, reset all playback port latencies
6437            to the same value.
6438         */
6439
6440         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6441
6442         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6443                 (*i)->set_public_port_latencies (max_latency, playback);
6444         }
6445
6446         if (playback) {
6447
6448                 post_playback_latency ();
6449
6450         } else {
6451
6452                 post_capture_latency ();
6453         }
6454
6455         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6456 }
6457
6458 void
6459 Session::post_playback_latency ()
6460 {
6461         set_worst_playback_latency ();
6462
6463         boost::shared_ptr<RouteList> r = routes.reader ();
6464
6465         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6466                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6467                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6468                 }
6469         }
6470
6471         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6472                 (*i)->set_latency_compensation (_worst_track_latency);
6473         }
6474 }
6475
6476 void
6477 Session::post_capture_latency ()
6478 {
6479         set_worst_capture_latency ();
6480
6481         /* reflect any changes in capture latencies into capture offsets
6482          */
6483
6484         boost::shared_ptr<RouteList> rl = routes.reader();
6485         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6486                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6487                 if (tr) {
6488                         tr->set_capture_offset ();
6489                 }
6490         }
6491 }
6492
6493 void
6494 Session::initialize_latencies ()
6495 {
6496         {
6497                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6498                 update_latency (false);
6499                 update_latency (true);
6500         }
6501
6502         set_worst_io_latencies ();
6503 }
6504
6505 void
6506 Session::set_worst_io_latencies ()
6507 {
6508         set_worst_playback_latency ();
6509         set_worst_capture_latency ();
6510 }
6511
6512 void
6513 Session::set_worst_playback_latency ()
6514 {
6515         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6516                 return;
6517         }
6518
6519         _worst_output_latency = 0;
6520
6521         if (!_engine.connected()) {
6522                 return;
6523         }
6524
6525         boost::shared_ptr<RouteList> r = routes.reader ();
6526
6527         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6528                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6529         }
6530
6531         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6532 }
6533
6534 void
6535 Session::set_worst_capture_latency ()
6536 {
6537         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6538                 return;
6539         }
6540
6541         _worst_input_latency = 0;
6542
6543         if (!_engine.connected()) {
6544                 return;
6545         }
6546
6547         boost::shared_ptr<RouteList> r = routes.reader ();
6548
6549         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6550                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6551         }
6552
6553         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6554 }
6555
6556 void
6557 Session::update_latency_compensation (bool force_whole_graph)
6558 {
6559         bool some_track_latency_changed = false;
6560
6561         if (_state_of_the_state & (InitialConnecting|Deletion)) {
6562                 return;
6563         }
6564
6565         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6566
6567         _worst_track_latency = 0;
6568
6569         boost::shared_ptr<RouteList> r = routes.reader ();
6570
6571         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6572                 if (!(*i)->is_auditioner() && ((*i)->active())) {
6573                         framecnt_t tl;
6574                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6575                                 some_track_latency_changed = true;
6576                         }
6577                         _worst_track_latency = max (tl, _worst_track_latency);
6578                 }
6579         }
6580
6581         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6582                                                      (some_track_latency_changed ? "yes" : "no")));
6583
6584         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6585
6586         if (some_track_latency_changed || force_whole_graph)  {
6587                 _engine.update_latencies ();
6588         }
6589
6590
6591         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6592                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6593                 if (!tr) {
6594                         continue;
6595                 }
6596                 tr->set_capture_offset ();
6597         }
6598 }
6599
6600 char
6601 Session::session_name_is_legal (const string& path)
6602 {
6603         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6604
6605         for (int i = 0; illegal_chars[i]; ++i) {
6606                 if (path.find (illegal_chars[i]) != string::npos) {
6607                         return illegal_chars[i];
6608                 }
6609         }
6610
6611         return 0;
6612 }
6613
6614 uint32_t
6615 Session::next_control_id () const
6616 {
6617         int subtract = 0;
6618
6619         /* the monitor bus remote ID is in a different
6620          * "namespace" than regular routes. its existence doesn't
6621          * affect normal (low) numbered routes.
6622          */
6623
6624         if (_monitor_out) {
6625                 subtract++;
6626         }
6627
6628         /* the same about masterbus in Waves Tracks */
6629
6630         if (Profile->get_trx() && _master_out) {
6631                 subtract++;
6632         }
6633
6634         return nroutes() - subtract;
6635 }
6636
6637 void
6638 Session::notify_remote_id_change ()
6639 {
6640         if (deletion_in_progress()) {
6641                 return;
6642         }
6643
6644         switch (Config->get_remote_model()) {
6645         case MixerOrdered:
6646                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6647                 break;
6648         default:
6649                 break;
6650         }
6651
6652 #ifdef USE_TRACKS_CODE_FEATURES
6653                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6654                  * if track order has been changed by user
6655                  */
6656                 reconnect_existing_routes(true, true);
6657 #endif
6658
6659 }
6660
6661 void
6662 Session::sync_order_keys ()
6663 {
6664         if (deletion_in_progress()) {
6665                 return;
6666         }
6667
6668         /* tell everyone that something has happened to the sort keys
6669            and let them sync up with the change(s)
6670            this will give objects that manage the sort order keys the
6671            opportunity to keep them in sync if they wish to.
6672         */
6673
6674         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6675
6676         reassign_track_numbers();
6677
6678         Route::SyncOrderKeys (); /* EMIT SIGNAL */
6679
6680         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6681 }
6682
6683 bool
6684 Session::operation_in_progress (GQuark op) const
6685 {
6686         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6687 }
6688
6689 boost::shared_ptr<Port>
6690 Session::ltc_input_port () const
6691 {
6692         return _ltc_input->nth (0);
6693 }
6694
6695 boost::shared_ptr<Port>
6696 Session::ltc_output_port () const
6697 {
6698         return _ltc_output->nth (0);
6699 }
6700
6701 void
6702 Session::reconnect_ltc_input ()
6703 {
6704         if (_ltc_input) {
6705
6706                 string src = Config->get_ltc_source_port();
6707
6708                 _ltc_input->disconnect (this);
6709
6710                 if (src != _("None") && !src.empty())  {
6711                         _ltc_input->nth (0)->connect (src);
6712                 }
6713
6714                 if ( ARDOUR::Profile->get_trx () ) {
6715                         // Tracks need this signal to update timecode_source_dropdown
6716                         MtcOrLtcInputPortChanged (); //emit signal
6717                 }
6718         }
6719 }
6720
6721 void
6722 Session::reconnect_ltc_output ()
6723 {
6724         if (_ltc_output) {
6725
6726                 string src = Config->get_ltc_output_port();
6727
6728                 _ltc_output->disconnect (this);
6729
6730                 if (src != _("None") && !src.empty())  {
6731                         _ltc_output->nth (0)->connect (src);
6732                 }
6733         }
6734 }
6735
6736 void
6737 Session::set_range_selection (framepos_t start, framepos_t end)
6738 {
6739         _range_selection = Evoral::Range<framepos_t> (start, end);
6740 #ifdef USE_TRACKS_CODE_FEATURES
6741         follow_playhead_priority ();
6742 #endif
6743 }
6744
6745 void
6746 Session::set_object_selection (framepos_t start, framepos_t end)
6747 {
6748         _object_selection = Evoral::Range<framepos_t> (start, end);
6749 #ifdef USE_TRACKS_CODE_FEATURES
6750         follow_playhead_priority ();
6751 #endif
6752 }
6753
6754 void
6755 Session::clear_range_selection ()
6756 {
6757         _range_selection = Evoral::Range<framepos_t> (-1,-1);
6758 #ifdef USE_TRACKS_CODE_FEATURES
6759         follow_playhead_priority ();
6760 #endif
6761 }
6762
6763 void
6764 Session::clear_object_selection ()
6765 {
6766         _object_selection = Evoral::Range<framepos_t> (-1,-1);
6767 #ifdef USE_TRACKS_CODE_FEATURES
6768         follow_playhead_priority ();
6769 #endif
6770 }
6771
6772 void
6773 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
6774                 const ChanCount& input_start,
6775                 const ChanCount& output_start,
6776                 const ChanCount& input_offset,
6777                 const ChanCount& output_offset)
6778 {
6779         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6780         _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
6781                                 input_start, output_start,
6782                                 input_offset, output_offset));
6783
6784         if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
6785                 pthread_cond_signal (&_auto_connect_cond);
6786                 pthread_mutex_unlock (&_auto_connect_mutex);
6787         }
6788 }
6789
6790 void
6791 Session::auto_connect (const AutoConnectRequest& ar)
6792 {
6793         boost::shared_ptr<Route> route = ar.route.lock();
6794
6795         if (!route) { return; }
6796
6797         if (!IO::connecting_legal) {
6798                 return;
6799         }
6800
6801         /* If both inputs and outputs are auto-connected to physical ports,
6802          * use the max of input and output offsets to ensure auto-connected
6803          * port numbers always match up (e.g. the first audio input and the
6804          * first audio output of the route will have the same physical
6805          * port number).  Otherwise just use the lowest input or output
6806          * offset possible.
6807          */
6808
6809         const bool in_out_physical =
6810                 (Config->get_input_auto_connect() & AutoConnectPhysical)
6811                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
6812                 && ar.connect_inputs;
6813
6814         const ChanCount in_offset = in_out_physical
6815                 ? ChanCount::max(ar.input_offset, ar.output_offset)
6816                 : ar.input_offset;
6817
6818         const ChanCount out_offset = in_out_physical
6819                 ? ChanCount::max(ar.input_offset, ar.output_offset)
6820                 : ar.output_offset;
6821
6822         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6823                 vector<string> physinputs;
6824                 vector<string> physoutputs;
6825
6826                 _engine.get_physical_outputs (*t, physoutputs);
6827                 _engine.get_physical_inputs (*t, physinputs);
6828
6829                 if (!physinputs.empty() && ar.connect_inputs) {
6830                         uint32_t nphysical_in = physinputs.size();
6831
6832                         for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
6833                                 string port;
6834
6835                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
6836                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
6837                                 }
6838
6839                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
6840                                         break;
6841                                 }
6842                         }
6843                 }
6844
6845                 if (!physoutputs.empty()) {
6846                         uint32_t nphysical_out = physoutputs.size();
6847                         for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
6848                                 string port;
6849
6850                                 /* Waves Tracks:
6851                                  * do not create new connections if we reached the limit of physical outputs
6852                                  * in Multi Out mode
6853                                  */
6854                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
6855                                                 ARDOUR::Profile->get_trx () &&
6856                                                 ar.output_offset.get(*t) == nphysical_out ) {
6857                                         break;
6858                                 }
6859
6860                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
6861                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
6862                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
6863                                         /* master bus is audio only */
6864                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
6865                                                 port = _master_out->input()->ports().port(*t,
6866                                                                 i % _master_out->input()->n_ports().get(*t))->name();
6867                                         }
6868                                 }
6869
6870                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
6871                                         break;
6872                                 }
6873                         }
6874                 }
6875         }
6876 }
6877
6878 void
6879 Session::auto_connect_thread_start ()
6880 {
6881         if (_ac_thread_active) {
6882                 return;
6883         }
6884
6885         while (!_auto_connect_queue.empty ()) {
6886                 _auto_connect_queue.pop ();
6887         }
6888
6889         _ac_thread_active = true;
6890         if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
6891                 _ac_thread_active = false;
6892         }
6893 }
6894
6895 void
6896 Session::auto_connect_thread_terminate ()
6897 {
6898         if (!_ac_thread_active) {
6899                 return;
6900         }
6901         _ac_thread_active = false;
6902
6903         {
6904                 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6905                 while (!_auto_connect_queue.empty ()) {
6906                         _auto_connect_queue.pop ();
6907                 }
6908         }
6909
6910         if (pthread_mutex_lock (&_auto_connect_mutex) == 0) {
6911                 pthread_cond_signal (&_auto_connect_cond);
6912                 pthread_mutex_unlock (&_auto_connect_mutex);
6913         }
6914
6915         void *status;
6916         pthread_join (_auto_connect_thread, &status);
6917 }
6918
6919 void *
6920 Session::auto_connect_thread (void *arg)
6921 {
6922         Session *s = static_cast<Session *>(arg);
6923         s->auto_connect_thread_run ();
6924         pthread_exit (0);
6925         return 0;
6926 }
6927
6928 void
6929 Session::auto_connect_thread_run ()
6930 {
6931         pthread_set_name (X_("autoconnect"));
6932         SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
6933         PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
6934         pthread_mutex_lock (&_auto_connect_mutex);
6935         while (_ac_thread_active) {
6936
6937                 if (!_auto_connect_queue.empty ()) {
6938                         // Why would we need the process lock ??
6939                         // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
6940                         //   graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
6941                         //   All ardour-internal backends use a std::vector   xxxAudioBackend::find_port()
6942                         //   We have control over those, but what does jack do?
6943                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
6944
6945                         Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6946                         while (!_auto_connect_queue.empty ()) {
6947                                 const AutoConnectRequest ar (_auto_connect_queue.front());
6948                                 _auto_connect_queue.pop ();
6949                                 lx.release ();
6950                                 auto_connect (ar);
6951                                 lx.acquire ();
6952                         }
6953                 }
6954
6955                 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
6956         }
6957         pthread_mutex_unlock (&_auto_connect_mutex);
6958 }