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