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