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