libs/ardour/session.cc

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